Programm-Test

[qwertix]

Hallo,
Ich hab mal ne Frage:
Könnte jemend von euch vllt dieses Programm für den Asuro testen?

#include "asuro.h"
int main(void) {
unsigned int data[2];
unsigned int ododata[2];
unsigned int odo;
int Strecke;
int Streckerueck;
int diff;
char Nummer;
int Zahl;
Init();
Strecke=0;
Streckerueck=0;
FrontLED(ON);

MotorDir(FWD,FWD);
StatusLED(GREEN);
while(PollSwitch() < 2){
LineData(data);

if (data [0] > data [1] )
{MotorSpeed(200,150);}
else
{MotorSpeed(150,200);}
Strecke++;}
while(1){
StatusLED(RED);
MotorSpeed(0,0);
Nummer=0;
while (Nummer<5)
{Zahl=0;
while (Zahl<100)
{
Sleep(216);
Zahl++;
}
Zahl=0;
BackLED(ON,OFF);
while (Zahl<100)
{
Sleep(216);
Zahl++;
}
BackLED(OFF,ON);
Nummer++;}
Zahl=0;
MotorDir(RWD,RWD);
MotorSpeed(180,180);
BackLED(ON,ON);
while (Zahl<350)
{
Sleep(216);
Zahl++;
}
MotorDir(FWD,RWD);
MotorSpeed(120,120);
Zahl=0;
while (Zahl<35)
{
OdometrieData(ododata);
odo=ododata [0];
Sleep(255);
OdometrieData(ododata);
diff=odo-ododata [0];
if (diff>750)
{Zahl++;}
else{}
}
MotorDir(FWD,FWD);
while(Strecke-Streckerueck>100){
LineData(data);

if (data [0] > data [1] )
{MotorSpeed(200,150);}
else
{MotorSpeed(150,200);}
Streckerueck++;}
}

return 0;
}
Meiner ist nämlich kaputt und ich will nicht auf den neuen warten!
Außerdem brauch ich es für einen Vortrag.
Wenn ihr Fehler oder Umständlichkeiten im Code findet könnt ihr mir ja antworten.
Das Programm soll folgendermaßen laufen:
Asuro fährt einer Linie entlang, fährt dann gegen die Wand, dreht um und fährt wieder zurück der Linie entlang. Jetzt soll er aber lernen und nicht mehr gegen die Wand auf der anderen Seite fahren, sondern kurz vorher stoppen und umdrehen (habe ich mit 'nem Zähler beim Liniensensor gemacht und nich mit Odometrie)
Ich hoffe es funktioniert, bin aber echt nich sicher weil ich schon länger nicht mehr programmiert habe.
Vielen Dank,
Qwertix

[qwertix]

schade dass mir keiner geschrieben hat...
habs jetzt selbst ausprobiertfunktioniert aber nich vor allem das mit der odometrie klappt gar nicht
wär nett wenn mir jemand sagen könnte wie ich den asuro dazu bring ne halbe drehung zu machen...
danke qwertix

[vklaffehn]

Moin!
Beim Asuro kann ich die leider nicht wirklich weiterhelfen, aber evtl. solltest du den Titel Deines Beitrages etwas aussagekräftiger formulieren, dann findet sich evtl. eher wer, der Dir helfen kann.
MfG
Volker

[radbruch]

Hallo


schade dass mir keiner geschrieben hat...Bitte entschuldige.

Du solltest besser warten bis dein neuer asuro eingetroffen ist und noch etwas üben:


#include "asuro.h"

int main(void)
{
unsigned int data[2];
unsigned int ododata[2];
unsigned int odo;
int Strecke;
int Streckerueck;
int diff;
char Nummer;
int Zahl;

Init();
Strecke=0;
Streckerueck=0;
FrontLED(ON);

MotorDir(FWD,FWD); // Nach Init() ist MotorDir immer FWD,FWD
StatusLED(GREEN); // und StatusLED immer grün!

// Ab hier wird der Linie gefolgt bis eine Taste gedrückt wird.
// Bei jedem Durchgang wird Strecke erhöht. Bei 8MHz geht das trotz
// kurzer Verzögeung durch LineData() rasend schnell, Strecke wird
// vermutlich mehrmals überlaufen!

while(PollSwitch() < 2)
{
LineData(data);

if (data [0] > data [1] )
MotorSpeed(200,150);
else
MotorSpeed(150,200);

Strecke++;
}

// Beginn der eigentlichen Hauptschleife, asuro steht vor einer Wand
// Es wird deshalb mit roter StatusLED und stehenden Motoren gestartet...

while(1)
{
StatusLED(RED);
MotorSpeed(0,0);
Nummer=0;

// ... und 5 mal im Wechsel mit den BackLEDs geblinkt...
while (Nummer<5)
{
Zahl=0;
while (Zahl<100)
{
Sleep(216);
Zahl++;
}
Zahl=0;
BackLED(ON,OFF);

while (Zahl<100)
{
Sleep(216);
Zahl++;
}
BackLED(OFF,ON);

Nummer++;
}

// ... dann etwas zurückstoßen um Abstand von der Wand zu gewinnen ...

Zahl=0;
MotorDir(RWD,RWD);
MotorSpeed(180,180);
BackLED(ON,ON);
while (Zahl<350)
{
Sleep(216);
Zahl++;
}

// Was jetzt kommt blicke ich noch nicht ganz. Aber Odometrie mit
// eingeschalteten BackLeds geht schon mal gar nicht!

MotorDir(FWD,RWD); // langsam vorwärts fahren
MotorSpeed(120,120);
Zahl=0;
while (Zahl<35) // Folgendes mehrfach ausführen (endlos wenn diff<=750!!!)
{
OdometrieData(ododata); // Odo-Helligkeitswerte einlesen
odo=ododata [0]; // Linker Wert in odo speichern
Sleep(255); // sehr kurz warten
OdometrieData(ododata); // Werte nochmals einlesen
diff=odo-ododata [0]; // Werte vergleichen: Wenn der erste Wert mehr
if (diff>750) Zahl++; // als 750 größer als der Zweite ist... Wasdas?
}

// So, das haben wir nun 35 mal gemacht und fahren weiterhin vorwärts mit 120.
// Jetzt dreht asuro nach links oder rechts bis er eine Linie erkennt. Dabei wird
// bei jedem Schleifendurchgang (auch während er die Linie noch sucht oder wenn er
// pendelt) der Schleifendurchgangszähler (Streckerueck) mit irgendwas
// (übergelaufene Strecke) verglichen. So geht das nicht! Ganz blöd wäre
// wenn Strecke zu Beginn kleiner als 100 wäre. Aber dank überlaufenden
// Variablen wird auch dann irgendwann mal abgebrochen.

MotorDir(FWD,FWD);
while(Strecke-Streckerueck>100)
{
LineData(data);

if (data [0] > data [1] )
MotorSpeed(200,150);
else
MotorSpeed(150,200);

Streckerueck++;
}
// Jetzt sollte der asuro vor der gegenüberliegenden Wand stehen ....
}

return 0;
}(Nicht gestestet weil mein asuro eingemottet ist)

Gruß

mic

[Valen]

Oops, habe schon was geschrieben, aber in deiner doppelt-thread. Und der ist schon geschlossen. Ich hoffe einer moderator kann meiner post hier hinnein fugen, und denn anderen schliessen.

EDIT: Verlass mahl auf Radbruch. Seiner Documentierung ist viel genauer wie meiner schreckliche Deutsch.

[qwertix]

ok danke euch allen,
mein asuro is mittlerweile da und zusammengebaut.
hab da programm noch mal überarbeitet!
hab das mit den strecken und der odometrie weggelassen dafür findet er die linie jetzt mit den photosensoren vorne.
außerdem kann er der linie entlagfahren auch wenn er nicht auf ihr gestartet wird.
hier der code:

#include "asuro.h"
int main(void) {
unsigned int data[2];
int diff;
char Nummer;
int Zahl; // Variablen deklarieren
Init();
FrontLED(ON); // LiniensuchLED einschalten
MotorDir(FWD,FWD); // Motor vorwärt Laufen lassen
MotorSpeed(150,150); // mit mitlerer Geschwindigkeit
diff=0; // Variable Null setzen
while (diff<50) // Solage fortfahren bis ein Unterschied von mindestens 50
{ // zwischen den Liniensensoren vorliegt
LineData(data);
diff = data [0]- data [1];
Sleep(255); // Zwischendurch Pausen machen um den Prozessor
} // Nicht unnötig zu belasten
Zahl=0; // Variable Null setzen
while (Zahl<100) // Noch etwa eine 1/3 Sekunde weiterfahren,
{ // Sodass die Drehachse über der Linie liegt
Sleep(216);
Zahl++;
}
MotorDir(FWD,RWD); // Im Uhrzeigersinn drehen
MotorSpeed(100,100); // Mit eher schwacher Motorleistung

BackLED(ON,ON); // Rücklichter anschalten
diff=0; // Variable Null setzen
while (diff<50) // Drehen bis die Linie gefunden ist
{
LineData(data);
diff = data [0]- data [1];
Sleep(255);
}
while(1){ // Endlosschleife
StatusLED(GREEN); // StatusLED auf grün Schalten
MotorDir(FWD,FWD); // Geradeaus fahren

while(PollSwitch() < 4){ // Schleife: Bis ein Taster anstößt wird folgendes gemacht:
LineData(data); // Liniensensoren auslesen

if (data [0] > data [1] ) // Wenn der rechte Sensor dunkler ist
{MotorSpeed(190,140);} // => linker Motor schneller fahren
else // Sonst
{MotorSpeed(140,190);} // => rechter Motor schneller fahren
}

StatusLED(RED); // StatusLED auf rot Schalten
MotorSpeed(0,0); // Motoren stoppen
Nummer=0; // Variable Null stzen
while (Nummer<5) // schleife: Fünf mal folgendes machen:
{Zahl=0; // Variable null setzen
while (Zahl<100) // 0,3 Sekunden warten
{
Sleep(216);
Zahl++;
}
Zahl=0; // Variable wieder Nul setzen
BackLED(ON,OFF); // Linke BackLED anschalten, die rechte aus
while (Zahl<100) // 0,3 Sekunden warten
{
Sleep(216);
Zahl++;
}
BackLED(OFF,ON); // Jetzt rechte BackLED anschalten und die linke aus
Nummer++;} // =>Die hinteren LEDs blinken abwechselnd
Zahl=0; // fünf mal im 0,3 Sekundentakt
MotorDir(RWD,RWD); // Rückwärts fahren
MotorSpeed(100,100); // Langsam
BackLED(ON,ON); // BackLEDs beide an
while (Zahl<200) // 0,6 sek lang so weitermachen
{
Sleep(216);
Zahl++;
}
MotorDir(FWD,RWD); // Im Uhrzeigersinn drehen
MotorSpeed(100,100); // Nicht zu schnell!
Zahl=0; // Variable null setzen
while (Zahl<100) // Kurz warten um nicht die selbe Linie auf welcher
{ // Man steht zu registrieren
Sleep(216);
Zahl++;
}
diff=0; // Variable null stzen
while (diff<50) // Schleife: Solange weiterdrehen bis ein Unterschied von
{ // mehr als 50 zwischen den beiden Liniensensoren ist
LineData(data);
diff = data [0]- data [1];
Sleep(255);
} // Linie gefunden? Dann wieder hoch zur Endlosschleife
}
return 0;
}
es funktioniert!

[Valen]

Gut gemacht! Deine Code ist auch besser zu lesen.

Aber nur diesen:


while(PollSwitch() < 4){ // Schleife: Bis ein Taster anstößt wird folgendes gemacht:
LineData(data); // Liniensensoren auslesenEr macht diesen Schleife nun wenn gar keine taster eingedruckt ist, aber auch wenn die 2 ganz rechter Taster (nr 5 und 6) angestossen sind. Mochtest du nicht lieber bei jeder taster eindruck die Schleife verlassen? Dann muss es eigentlich <1 sein. Aber die Taster abfrage ist schon ganz storungs empfindlich mit laufenden motoren. Lies diesen Thread mal durch. Aber da sind ist ganze menge Threads mehr uber geschrieben. Such mahl ein bisschen weiter.

Oops, etwas vergessen:

https://www.roboternetz.de/phpBB2/viewtopic.php?t=43367

[radbruch]

Aber hallo. Das sieht ja wirklich sehr viel besser aus. Ein großes Lob deshalb auch von mir.

Wichtig bei der ganzen Kommentiererei ist das als Kommentar zu beschreiben was man im Code nicht sehen kann. Das ist überflüssig:

Zahl=0; // Variable null setzen

und das ist schon ziemlich optimal :)

while (Zahl<100) // Kurz warten um nicht die selbe Linie auf welcher
{ // Man steht zu registrieren

Einrückungen würden noch helfen die Gliederungen besser darzustellen.

@Valen:
Leider hat das Forum gestern deinen Beitrag "gefressen" als ich versuchte beide Threads zusammenzuführen.

Gruß

mic

[Valen]

@Valen:
Leider hat das Forum gestern deinen Beitrag "gefressen" als ich versuchte beide Threads zusammenzuführen.

Gruß

micKein problem. Deine erklärungen waren schon besser wie meine.