Asuro soll ein Quadrat fahren... und nicht mehrere!

Hallo!
So brauch mal wieder eure Hilfe.
Hab ein Programm geschrieben, bei dem mein ASURO ein Quadrat fahren soll. Macht er auch... er führt es nur ständig aus. Ich möchte aber, dass er nur ein Quadrat fährt.
Hab schon alle möglichen Schleifen ausprobiert... er ignoriert die Anweisungen aber und fährt mehrere Quadrate..
Kann mir jemand helfen und sagen, wie ich mein Programm abändern muss, damit er nur ein Quadrat fährt?

Mein Programm:

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; Init(); MotorDir(FWD,FWD); while (1) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } }

Im Switch sage ich ihm was er fahren soll und unten werte ich die Odometrie aus. Da er die Odometrie ja auch ständig ausführen soll, dachte ich, dass ich eine Schleife direkt nach dem while einfügen muss, da ich nicht weiß wie ich die while abändere, dass sie das ganze nur 4mal ausführt.
Habe es z.B. mit einer if else versucht.

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int x; signed int x=0; Init(); MotorDir(FWD,FWD); while (1) { if (x==4) { x++; switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } else MotorDir(BREAK,BREAK); } }

Hi,
zähl doch einfach immer wenn du an den ecken drehst eine zählvariable um eines hoch.
und mach die bedingung in der while(ecke < 4)
also ungefähr so:
ecke=0
while (ecke<4)
{
if (distanz=0)
{
drehung;
ecke ++
}
}

mfg jeffrey

hi,
ich denke du musst den wert von distance so am ende des ersten quadrates angeben, dass er nicht wieder in die schleife reinkommt...
Er fängt ja mit distance=0 wieder von anfang an...

Hi Jeffrey,
wenn ich das mit dem while (ecke<4) ausprobiere, dann springt er mir nicht mehr in den switch und fährt nur noch gerade aus:

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int ecke=0; Init(); MotorDir(FWD,FWD); while (ecke<4) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; /*case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break;*/ } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); ecke++; } return 0; }

Hi inka,
versteh ich das richtig, dass du die strecke meinst bis ich ein Quadrat abgefahren hab??? das läge dann über 1000 und es macht auch nicht was es soll....

du hast recht. im code:

Code:

case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird

geht er mit distance=0 wieder an den anfang der switch distance schleife,fährt also unendlich lange im quadrat...
ich habe es dann mit einer for schleife gemacht, die "um die switch schleife" und innerhalb der while schleife liegt...
habe den code aber nicht mehr...

Hm ok... du meinst das also so:

Code:

while (1) { for (x=0; x<4; x++) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data);

wenn ja: asuro macht nun garnichts mehr :D

hi,
also ich bin mit dem asuro zeug nicht so genau vertraut. deswegen weiß ich nicht genau, wqs dein programm macht, aber ich glaube, das sah vorher noch twas anders aus. hier mal kurz wie ich es machen würde:
ecke=0;
distance=200;
while(ecke<4)
{
if(distance=0)
{
drehung 90°;
distance=200;
ecke ++;
}
distnace=distance mit odd überprüfen;
}

so also distance ist jetzt deine seitenlänge vom quadrat. das ganze abbremszeug kannst du natürlich noch zusätzlich einbauen.

wenn du es mit for machen willst, sollte es auch so gehen:

for i=1 to 4
{
distance=200;
while (distance>0)
{
distnace=distance mit odd überprüfen;
}
drehung um 90°;
}

denke, dass sollte funktionieren.
mfg jeffrey

Irgendwie bekomm ich das nicht hin...
Hier mal alle Möglichkeiten die ich ausprobiert habe...

1) while-Schleife

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (zaehler<4) { zaehler++; switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } return 0; }

Hier fährt ASURO nur geradeaus...

2) for-Schleife

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (1) { for(zaehler=0; zaehler<4; zaehler++) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } } return 0; }

Hier fährt ASURO immer wieder das Quadrat und hört nicht mehr auf.

3) if-Anweisung

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (1) { if (zaehler<4) { zaehler++; switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } } return 0; }

Nun fährt ASURO im Kreis.

4) if-else-Anweisung

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (1) { if (zaehler<4) { zaehler++; switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } else MotorDir(BREAK,BREAK); } return 0; }

Hier springt er sofort in else, da er stehen bleibt.

5) do-while-Schleife

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (1) { do { zaehler++; switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } while (zaehler<4); } return 0; }

Auch hier fährt ASURO unendlich Quadrate.

Ich bin der Meinung, dass ich die Schleifen irgendwie falsch setze, sonst müsste ja eine funktionieren.
Oder mein Zähler funktioniert nicht....
Er muss ja aber sowohl die Differenz und die Odometrie 4mal ausführen, also muss ich die Schleifen in die while setzen. Ich kann ja die Schleifen nicht vor der Odometrie enden lassen, oder?

Hi,
markier mal in deinem ersten programm, wo genau du dem asuro sagst, dass er in der ecke drehen soll. ich find des irgendwie net. in dieser if anweisung musst du zähler++ schreiben.
mfg jeffrey

Ich sage dem ASURO jeweils, dass er den Switch 4 mal ausführen soll. Ein sSwitch ist eine Seite + Ecke.

hi, wo genau in der switch anweisung ist denn die ecke?also welche anweisung führt die 90° drehung aus?

edit: hab´s gefunden, wer lesen kann ist klar im vorteil ;-)

probier mal den code:

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (zaehler<4) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; zaehler++; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } return 0; }

mfg jeffrey

Jipppiiii es geht!!! :cheesy: :cheesy: :cheesy: :cheesy: :cheesy: :cheesy: :cheesy:
Allerdings muss man den Zähler bisschen weiter hinter setzen, das konntest du aber nicht wissen, da die Drehung bis zum distance=0 geht...
Desweiteren muss man return 0 weglassen, da ja sonst die while-Schleife wieder von vorne beginnt. Also fügt man ein MotorDir(BREAK,BREAK) ein und ASURO bleibt genau nach einem Quadrat stehen.

Hier nochmal mein fertiger Code...

Code:

#include "asuro.h" //Schwellwert für die Hell/Dunkel-Unterscheidung //Eventuell muss damit etwas variiert werden #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 int main(void) { unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); while (zaehler<4) { switch(distance) { //Am Anfang der Strecke Vollgas case 0:MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; //Am Ende langsamer werden... case 215:speed=200; break; case 230:speed=150; break; //...und stehen bleiben case 251:MotorDir(BREAK,BREAK); //etwas warten, bis der Roboter wirklich steht for (i=0; i<100; i++) { Sleep(255); } //auf der Stelle nach links drehen MotorDir(RWD,FWD); speed=255; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird distance=252; break; case 282: speed=200; break; case 288: speed=150; break; case 292: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=0; //und noch vermeiden, dass die Verzögerung //mehrmals aufgerufen wird zaehler++; break; } //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } MotorDir(BREAK,BREAK); }

hi,
O:) gut, dass es jetzt geht.
aber

Zitat:

wer lesen kann ist klar im vorteil Zwinkern

gilt auch für dich ;-) weil ich hatte ja geschrieben

Zitat:

if(distance=0)
{
drehung 90°;
distance=200;
ecke ++;
}

da wurde der zähler auch erst in der if/case anweisung für die drehung hoch gezählt, und nicht bei jedem schleifen durchlauf.

aber jetzt funktioniert ja alles.
mfg jeffrey

So da nun endlich mein Quadrat funktioniert, versuche auch ich das Haus vom Nikolaus zu zeichnen.
Leider funktioniert es nicht wie erhofft.
Habe 4 Unterprogramme geschrieben, welche nacheinander ausgeführt werden sollen. Funktioniert auch ein Teil davon.
Das Programm läuft allerdings nur bis zum Quadrat und danach hört er auf zu fahren, springt also nicht in die Unterprogramme Dach1 und Dach2.

Könnte mal jemand drüberschauen und sagen, was ich falsch mache???
Danke

Code:

//---------------------------------------------------------------------------------- //Projekt: HAUS VOM NIKOLAUS //---------------------------------------------------------------------------------- #include "asuro.h" #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 //---------------------------------------------------------------------------------- //Variablen deklarieren //---------------------------------------------------------------------------------- unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; //---------------------------------------------------------------------------------- //Unterprogramm Odometrie //---------------------------------------------------------------------------------- void Odometrie (void) { //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } //---------------------------------------------------------------------------------- //Unterprogramm Haus (Quadrat, Kantenlänge 29cm) //---------------------------------------------------------------------------------- void Haus(void) { //Schleife (wird 4mal ausgeführt), da 4 Seiten while (zaehler<4) { switch(distance) { //Hausseite case 0: MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach links, 90° case 145: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(RWD,FWD); speed=255; distance=146; break; case 176: speed=200; break; case 182: speed=150; break; //stehen bleiben und kurz warten case 186: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; //zurück zum Anfang distance=0; //Schleifenzähler zaehler++; break; } Odometrie(); } //stehen bleiben, nachdem ASURO ein Quadrat gefahren ist MotorDir(BREAK,BREAK); } //-------------------------------------------------------------------------------- //Unterprogramm Dach1 (Diagonale 1, 41cm; Dach Seite 1, 19cm) //-------------------------------------------------------------------------------- void Dach1(void) { switch(distance) { //Drehung nach links, 45° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 10: speed=200; break; case 15: speed=150; break; //Diagonale 1 case 21: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 190: speed=200; break; case 200: speed=150; break; //Drehung nach rechts, 95° case 227: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=228; break; case 248: speed=200; break; case 258: speed=150; break; //Dach Seite 1, linke Seite case 268: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=269; break; case 340: speed=200; break; case 350: speed=150; break; case 363: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; } Odometrie(); } //--------------------------------------------------------------------------------- //Unterprogramm Dach2 (Diagonale 2, 41cm; Dach Seite 2, 19cm) //--------------------------------------------------------------------------------- void Dach2(void) { switch(distance) { //Drehung nach rechts, 80° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 25: speed=200; break; case 30: speed=150; break; //Dach Seite 2, rechte Seite case 37: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach rechts, 95° case 131: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=132; break; case 150: speed=200; break; case 160: speed=150; break; //Diagonale 2 case 171: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=172; break; case 340: speed=200; break; case 350: speed=150; break; case 377: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; } Odometrie(); } //----------------------------------------------------------------------------------- //Hauptprogramm //----------------------------------------------------------------------------------- int main (void) { Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); StatusLED(OFF); Haus(); StatusLED(RED); Dach1(); StatusLED(GREEN); Dach2(); StatusLED(YELLOW); }

spontan fällt auf, dass am ende der main() schleife sowohl die endlosschleife
while(1);
sowie auch
return 0;
fehlen.
ausserdem glaube ich dass die klammern {} in der funktion haus() nicht zueinander passen.

Hi,

Code:

//---------------------------------------------------------------------------------- //Projekt: HAUS VOM NIKOLAUS //---------------------------------------------------------------------------------- #include "asuro.h" #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 //---------------------------------------------------------------------------------- //Variablen deklarieren //---------------------------------------------------------------------------------- unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; //---------------------------------------------------------------------------------- //Unterprogramm Odometrie //---------------------------------------------------------------------------------- void Odometrie (void) { //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } //---------------------------------------------------------------------------------- //Unterprogramm Haus (Quadrat, Kantenlänge 29cm) //---------------------------------------------------------------------------------- void Haus(void) { //Schleife (wird 4mal ausgeführt), da 4 Seiten while (zaehler<4) { switch(distance) { //Hausseite case 0: MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach links, 90° case 145: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(RWD,FWD); speed=255; distance=146; break; case 176: speed=200; break; case 182: speed=150; break; //stehen bleiben und kurz warten case 186: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; //zurück zum Anfang distance=0; //Schleifenzähler zaehler++; break; } Odometrie(); } //stehen bleiben, nachdem ASURO ein Quadrat gefahren ist MotorDir(BREAK,BREAK); } //-------------------------------------------------------------------------------- //Unterprogramm Dach1 (Diagonale 1, 41cm; Dach Seite 1, 19cm) //-------------------------------------------------------------------------------- void Dach1(void) { while(distance<364){ switch(distance) { //Drehung nach links, 45° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 10: speed=200; break; case 15: speed=150; break; //Diagonale 1 case 21: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 190: speed=200; break; case 200: speed=150; break; //Drehung nach rechts, 95° case 227: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=228; break; case 248: speed=200; break; case 258: speed=150; break; //Dach Seite 1, linke Seite case 268: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=269; break; case 340: speed=200; break; case 350: speed=150; break; case 363: MotorDir(BREAK,BREAK); distance++;for (i=0; i<100; i++) { Sleep(255); } break; } Odometrie(); } } //--------------------------------------------------------------------------------- //Unterprogramm Dach2 (Diagonale 2, 41cm; Dach Seite 2, 19cm) //--------------------------------------------------------------------------------- void Dach2(void) {while(distance<378){ switch(distance) { //Drehung nach rechts, 80° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 25: speed=200; break; case 30: speed=150; break; //Dach Seite 2, rechte Seite case 37: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach rechts, 95° case 131: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=132; break; case 150: speed=200; break; case 160: speed=150; break; //Diagonale 2 case 171: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=172; break; case 340: speed=200; break; case 350: speed=150; break; case 377: MotorDir(BREAK,BREAK); distance++;for (i=0; i<100; i++) { Sleep(255); } break; } Odometrie(); }} //----------------------------------------------------------------------------------- //Hauptprogramm //----------------------------------------------------------------------------------- int main (void) { Init(); MotorDir(FWD,FWD); BackLED(OFF,OFF); StatusLED(OFF); Haus(); distance=0; StatusLED(RED); Dach1(); distance=0; StatusLED(GREEN); Dach2(); StatusLED(YELLOW); }

könnte klappen, klammern, return0 etc habe ich nicht überprüft. weiß auch nicht mehr genau wie das aussehen muss
mfg jeffrey

ps: hab mal ne frage, du sagst du benötigst den asuro bei der arbeit, welche firma braucht nen suro, der das haus vom nikolaus malt? und was mich noch mehr interessiert, für was brauchen die den?

Danke werde das am Montag mal ausprobieren, hab den ASURO leider nicht zu Hause.

Naja das ist eher eine Arbeitsbeschaffungsmaßnahme für die Studenten. Bin zur Zeit dort in der Lehrwerkstatt und lerne Mikrocontroller zu programmieren und da dachte mein Ausbilder es wär ganz lustig doch nen Roboter zu programmieren und da ich den Wettbewerb hier im Forum gesehn habe, dachte ich ich versuch das mit dem Haus vom Nikolaus auch mal.

@damaltor...
an den Klammern in der Funktion Haus kann es nicht liegen, da mir der ASURO diesen Teil ja malt...

trotzdem, ich habe nicht genau geschaut aber es könnte sein dass er aus der funktion nicht mehr rauskomt...

Es funktioniert immer noch nicht...
Habe mal LED zwischendurch ein- bzw. ausschalten lassen um zu sehn wo mein Programm hängt... joa es hängt nicht, sondern überspringt einfach einen Teil. Haus macht er einwandfrei und springt auch aus dem Unterprogramm raus, soll dann in Dach1 springen, macht es aber nicht. Es überspringt mir einfach Dach1 und Dach2 und schaltet sofort die BackLEDs an.
Habe ich die Unterprogramme in der main falsch eingefügt??
Mögliche Fehler in den Unterprogrammen habe ich ausgeschlossen, da ich sie unabhängig voneinander getestet habe...

Code:

//---------------------------------------------------------------------------------- //Projekt: HAUS VOM NIKOLAUS //---------------------------------------------------------------------------------- #include "asuro.h" #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 //---------------------------------------------------------------------------------- //Variablen deklarieren //---------------------------------------------------------------------------------- unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; //---------------------------------------------------------------------------------- //Unterprogramm Odometrie //---------------------------------------------------------------------------------- void Odometrie (void) { //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } //---------------------------------------------------------------------------------- //Unterprogramm Haus (Quadrat, Kantenlänge 29cm) //---------------------------------------------------------------------------------- void Haus (void) { //Schleife (wird 4mal ausgeführt), da 4 Seiten while (zaehler<4) { switch(distance) { //Hausseite case 0: MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach links, 90° case 145: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(RWD,FWD); speed=255; distance=146; break; case 176: speed=200; break; case 182: speed=150; break; //stehen bleiben und kurz warten case 186: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; //zurück zum Anfang distance=0; //Schleifenzähler zaehler++; break; } Odometrie(); } //stehen bleiben, nachdem ASURO ein Quadrat gefahren ist MotorDir(BREAK,BREAK); } //-------------------------------------------------------------------------------- //Unterprogramm Dach1 (Diagonale 1, 41cm; Dach Seite 1, 19cm) //-------------------------------------------------------------------------------- void Dach1 (void) { while(zaehler<1) { switch(distance) { //Drehung nach links, 45° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 10: speed=200; break; case 15: speed=150; break; //Diagonale 1 case 21: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 190: speed=200; break; case 200: speed=150; break; //Drehung nach rechts, 95° case 227: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=228; break; case 248: speed=200; break; case 258: speed=150; break; //Dach Seite 1, linke Seite case 268: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=269; break; case 340: speed=200; break; case 350: speed=150; break; case 363: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; zaehler++; } Odometrie(); } MotorDir(BREAK,BREAK); } //--------------------------------------------------------------------------------- //Unterprogramm Dach2 (Diagonale 2, 41cm; Dach Seite 2, 19cm) //--------------------------------------------------------------------------------- void Dach2 (void) { while(zaehler<1) { switch(distance) { //Drehung nach rechts, 80° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 25: speed=200; break; case 30: speed=150; break; //Dach Seite 2, rechte Seite case 37: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach rechts, 95° case 131: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=132; break; case 150: speed=200; break; case 160: speed=150; break; //Diagonale 2 case 171: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=172; break; case 340: speed=200; break; case 350: speed=150; break; case 377: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; zaehler++; } Odometrie(); } MotorDir(BREAK,BREAK); } //----------------------------------------------------------------------------------- //Hauptprogramm //----------------------------------------------------------------------------------- int main (void) { Init(); while(zaehler<1) { BackLED(OFF,OFF); StatusLED(OFF); FrontLED(ON); Haus(); FrontLED(OFF); StatusLED(RED); //MotorDir(FWD,FWD); Dach1(); StatusLED(GREEN); //MotorDir(FWD,FWD); Dach2(); BackLED(ON,ON); zaehler++; } return 0; }

hallo,
hast du den code, den ich oben gepostet habe mal getestet? funktioniert der auch nicht?
du musst den zähler auch wieder auf 0 setzen, bevor du immer weiter hoch zählst.
also so irgendwie:

mfg jeffrey

Code:

//---------------------------------------------------------------------------------- //Projekt: HAUS VOM NIKOLAUS //---------------------------------------------------------------------------------- #include "asuro.h" #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 //---------------------------------------------------------------------------------- //Variablen deklarieren //---------------------------------------------------------------------------------- unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; //---------------------------------------------------------------------------------- //Unterprogramm Odometrie //---------------------------------------------------------------------------------- void Odometrie (void) { //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } //---------------------------------------------------------------------------------- //Unterprogramm Haus (Quadrat, Kantenlänge 29cm) //---------------------------------------------------------------------------------- void Haus (void) { //Schleife (wird 4mal ausgeführt), da 4 Seiten while (zaehler<4) { switch(distance) { //Hausseite case 0: MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach links, 90° case 145: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(RWD,FWD); speed=255; distance=146; break; case 176: speed=200; break; case 182: speed=150; break; //stehen bleiben und kurz warten case 186: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; //zurück zum Anfang distance=0; //Schleifenzähler zaehler++; break; } Odometrie(); } //stehen bleiben, nachdem ASURO ein Quadrat gefahren ist MotorDir(BREAK,BREAK); } //-------------------------------------------------------------------------------- //Unterprogramm Dach1 (Diagonale 1, 41cm; Dach Seite 1, 19cm) //-------------------------------------------------------------------------------- void Dach1 (void) { zaehler=0; while(zaehler<1) { switch(distance) { //Drehung nach links, 45° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 10: speed=200; break; case 15: speed=150; break; //Diagonale 1 case 21: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 190: speed=200; break; case 200: speed=150; break; //Drehung nach rechts, 95° case 227: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=228; break; case 248: speed=200; break; case 258: speed=150; break; //Dach Seite 1, linke Seite case 268: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=269; break; case 340: speed=200; break; case 350: speed=150; break; case 363: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } zaehler++; break; } Odometrie(); } MotorDir(BREAK,BREAK); } //--------------------------------------------------------------------------------- //Unterprogramm Dach2 (Diagonale 2, 41cm; Dach Seite 2, 19cm) //--------------------------------------------------------------------------------- void Dach2 (void) { zaehler=0; while(zaehler<1) { switch(distance) { //Drehung nach rechts, 80° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 25: speed=200; break; case 30: speed=150; break; //Dach Seite 2, rechte Seite case 37: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach rechts, 95° case 131: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=132; break; case 150: speed=200; break; case 160: speed=150; break; //Diagonale 2 case 171: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=172; break; case 340: speed=200; break; case 350: speed=150; break; case 377: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } zaehler++; break; } Odometrie(); } MotorDir(BREAK,BREAK); } //----------------------------------------------------------------------------------- //Hauptprogramm //----------------------------------------------------------------------------------- int main (void) { Init(); while(zaehler<1) { BackLED(OFF,OFF); StatusLED(OFF); FrontLED(ON); Haus(); FrontLED(OFF); StatusLED(RED); //MotorDir(FWD,FWD); Dach1(); StatusLED(GREEN); //MotorDir(FWD,FWD); Dach2(); BackLED(ON,ON); zaehler++; } return 0; }

denke allerdings, dass dieses programm genau das gleiche macht wie meines von oben, vielleicht habe ih ja au nen denkfehler drin.
mfg jeffey

Hm ich dachte eigentlich, dass jedes Unterprogramm auf meine oben deklarierten Variablen zugreift. Sonst müsste ich sie ja immer wieder deklarieren und oben hab ich ja bereits den zaehler sowie distance auf 0 gesetzte.
Was ist eigentlich der Unterschied zwischen void Haus (void) und void Haus ()??

hi,
natürlich greifft jedes unterprogramm auf diese variable zu, allerdings hat die variable weiterhin den wert, den sie nach dem letzten unterprogramm hatte.
bei den fragen zum unterschied kann ich dir nix sagen, bin nicht mehr so drin in c, habe es schon lange nicht mehr verwendet.
mfg jeffrey

edit: ich weiß auch nicht, ob meine codevorschläge so funktionieren, habe selbst eider keinen asuro, und selbst wenn, hätte ich nicht das privileg während der "arbeit", obwohl dipl arbeit machen auch nicht richtig arbeiten ist, damit spielen und das testen zu können.

ok, Danke.
Er kommt inzwischen in das 2te Unterprogramm, bleibt aber manchmal drin hängen...
Vlt kann mir das mit dem void Haus(void) und void Haus() jemand anderes erklären!

Hi,
das hängen bleiben kommt denke ich vom case, also wenn dein distance > als 363 ist, dann wird dein stopp übersrungen. kann man auch den case distance>= 363 verwenden? dann nimm den, oder falls das nicht geht, lass den letzten case weg, und mache dafür eine if abfragen, also

Code:

if(distance>=363) { MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } zaehler++; }

vielleicht hilft das, oder wo im unterprogramm bleibt es hängen?
gruß jeffrey

Er fährt mir nun mein Haus vom Nikolaus.. manchmal bleibt er stehn, dann muss man ihn einfach nochmal starten...

Hab das nun garnicht mit dem distance >363 gemacht... geht auch so, wenn man distance wieder auf null setzt.

Mein code sieht also so aus:

Code:

//---------------------------------------------------------------------------------- //Projekt: HAUS VOM NIKOLAUS //---------------------------------------------------------------------------------- #include "asuro.h" #define TRIGGERLEVEL 680 #define HYSTERESIS 30 #define LOW 0 #define HIGH 1 //---------------------------------------------------------------------------------- //Variablen deklarieren //---------------------------------------------------------------------------------- unsigned int data [2]; signed int status [2]={0,0}; unsigned int speed=255; //Startwert für halbe Motorgeschwindigkeit signed int difference=0; unsigned int distance=0; int i; int zaehler=0; //---------------------------------------------------------------------------------- //Unterprogramm Odometrie //---------------------------------------------------------------------------------- void Odometrie (void) { //Helligkeitswerte der Lichtschranken auslesen OdometrieData(data); //Wechsel linker Sensor von niedrig auf hoch? if((status[0]==LOW)&&(data[0]>TRIGGERLEVEL+HYSTERESIS)) { status[0]=HIGH; difference++; distance++; } //Wechsel linker Sensor von hoch auf niedrig? if((status[0]==HIGH)&&(data[0]<TRIGGERLEVEL-HYSTERESIS)) { status[0]=LOW; difference++; distance++; } //Wechsel rechter Sensor von niedrig auf hoch? if((status[1]==LOW)&&(data[1]>TRIGGERLEVEL+HYSTERESIS)) { status[1]=HIGH; difference--; } //Wechsel rechter Sensor von hoch auf niedrig? if((status[1]==HIGH)&&(data[1]<TRIGGERLEVEL-HYSTERESIS)) { status[1]=LOW; difference--; } //zur Sicherheit: verhindern, dass der Differenzzähler den erlaubten //Wertebereich verlässt if(difference<-155) difference=-155; if(difference>155) difference=155; //StatusLED noch entsprechend der erkannten Segmente aufleuchten //lassen, grün für links, rot für rechts StatusLED(status[0]+status[1]*2); //Zähldifferenz passemd auf die Motoren verteilen if(difference>0) MotorSpeed(155-difference,155); else MotorSpeed(155,155+difference); } //---------------------------------------------------------------------------------- //Unterprogramm Haus (Quadrat, Kantenlänge 29cm) //---------------------------------------------------------------------------------- void Haus (void) { distance=0; zaehler=0; //Schleife (wird 4mal ausgeführt), da 4 Seiten while (zaehler<4) { switch(distance) { //Hausseite case 0: MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach links, 90° case 145: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(RWD,FWD); speed=255; distance=146; break; case 176: speed=200; break; case 182: speed=150; break; //stehen bleiben und kurz warten case 186: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; //zurück zum Anfang distance=0; //Schleifenzähler zaehler++; break; } Odometrie(); } //stehen bleiben, nachdem ASURO ein Quadrat gefahren ist MotorDir(BREAK,BREAK); } //-------------------------------------------------------------------------------- //Unterprogramm Dach1 (Diagonale 1, 41cm; Dach Seite 1, 19cm) //-------------------------------------------------------------------------------- void Dach1 (void) { distance=0; zaehler=0; while(zaehler<1) { switch(distance) { //Drehung nach links, 45° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 10: speed=200; break; case 15: speed=150; break; //Diagonale 1 case 21: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 190: speed=200; break; case 200: speed=150; break; //Drehung nach rechts, 95° case 227: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=228; break; case 248: speed=200; break; case 258: speed=150; break; //Dach Seite 1, linke Seite case 268: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=269; break; case 340: speed=200; break; case 350: speed=150; break; case 363: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; zaehler++; } Odometrie(); } MotorDir(BREAK,BREAK); } //--------------------------------------------------------------------------------- //Unterprogramm Dach2 (Diagonale 2, 41cm; Dach Seite 2, 19cm) //--------------------------------------------------------------------------------- void Dach2 (void) { while(zaehler<1) { switch(distance) { //Drehung nach rechts, 80° case 0: MotorDir(RWD,FWD); MotorSpeed(speed,speed); distance=1; break; case 25: speed=200; break; case 30: speed=150; break; //Dach Seite 2, rechte Seite case 37: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); MotorSpeed(speed,speed); break; case 110: speed=200; break; case 120: speed=150; break; //Drehung nach rechts, 95° case 131: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,RWD); speed=255; distance=132; break; case 150: speed=200; break; case 160: speed=150; break; //Diagonale 2 case 171: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } MotorDir(FWD,FWD); speed=255; distance=172; break; case 340: speed=200; break; case 350: speed=150; break; case 377: MotorDir(BREAK,BREAK); for (i=0; i<100; i++) { Sleep(255); } break; zaehler++; } Odometrie(); } MotorDir(BREAK,BREAK); } //----------------------------------------------------------------------------------- //Hauptprogramm //----------------------------------------------------------------------------------- int main (void) { Init(); while(zaehler<1) { BackLED(OFF,OFF); StatusLED(OFF); FrontLED(ON); Haus(); FrontLED(OFF); StatusLED(RED); Dach1(); StatusLED(OFF); StatusLED(GREEN); Dach2(); BackLED(ON,ON); zaehler++; } return 0; }

Werde nun meine Winkel noch ein wenig verfeinern und dann mal mein Ergebnis dem Wettbewerb präsentieren.

variablen, die ausserhalb der main-funktion deklariert wurden, sind global und können überall im programm verwendet werden. nachteil: sie ligen dauerhaft im speicher, auch wenn sie gerade nicht verwendet werden, und der ist natürlich stark begrenzt.

void steht am anfang: die funktion hat keinen rückgabewert (zB Odometriedata)
bei pollswitch zB steht hier char (oder unsigned char?), welcher zurückgegeben wird.

void steht in den klammern: die funktion benötigt keine argumente bzw übergabewerte, zB PollSwitch. Motordir hingegen bekommt die richtungen übergeben.

Hi,
und hast du den Wettbewerb gewonnen?
MfG Jeffrey