ASURO als GFS

[InFaIN]

Hallo,

Ich habe vor den Asuro als GFS Thema zu nehmen. Wer es nicht weiß eine GFS ist eine Gleichwertige Feststellung von Schülerleistungen, eine art Referat nur mit mehr Wertung in der Shuhlnote.

Ich willte jezt mal Fragen ob dies schon mal jemand gemacht hat oder ob ihr mir Tipps geben könnt was ich alles reinbringen könnte. Ich bräuchte vieleicht auch noch Bilder vom Zusammenbau.

Vielen Dank im voraus

InFaIN

[Hornet]

Hi,

ich würde dir empfehlen mehr auf die Elektronik und die Mechanik des Asuros einzugehen, als auf die Software, da das meist für deine Zuhöhrer langweilig wird. Da sie sich unter den einzelnen Funktionen nicht sofort, wenn überhaupt etwas vorstellen können.
Ich würde den Schaltplan an die Wand werfen eventl in einer Powerpoint Präsentation und dann die Elektronik etwas erklären und zeigen wo jetzt spezielle Dinge (bsp die Odometrie) im Schaltplan verschaltet ist und wie es zum Schluss auf der Platine aussieht. Dann ein bisschen was über die Mechanik. Software nur kurz anschneiden. und zum schluss den asuro laufen lassen, da kannst du es dir dann ausuchen on du ein Beispielprogramm nimmst oder ein selbst geschriebenes.

Gruß
Simon

[Lunarman]

Ich würde beispielsweise ein Programm nehmen, dass alle Funktionen zeigt... Und dann natürlich wieder auf den Schaltplan verweisen ;) machs am Besten so dass der ASURO nicht so weit fährt in den einzelnen Sequenzen, sodass du ihn auf dem Pult fahren lassen kannst. Dann sehen die Leute auch was davon ohne dass alle aufstehen. Führt nur zu Chaos :D

[Sternthaler]

Hallo InFaIN,
ich stimme Hornet da zu, dass es schierig sein könnte 'ein bisschen Software' an Mann/Frau zu verkaufen.
Unter Wichtig- ASURO und Abitur ! (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=29559) hatte ich mal etwas zu den Tasten und deren Bearbeitung am Asuro geschrieben. Dort ist einiges über den Dreisatz zur Spannungsberechnung in Kombination mit den vielen bunten Widerständen der Taster. Auch die schnuckelige Verdrahtung derselben am Asuro ist (glaube ich) recht umfangreich erklärt.

Gruß Sternthaler
Und viel Erfolg

[robo.fr]

Hallo InFAin,

vielleicht kann Dir das hier weiterhelfen:

http://www.informatik.fh-wiesbaden.de/~linn/vpdv05/asuro/projektdokumentation/projektdokumentation/

http://www.informatik.fh-wiesbaden.de/~linn/vpdv05/asuro/vortrag/asuro-vortrag.pdf

Gruß,
robo

[InFaIN]

Erstmal Danke für die vielen Tipps. Ich werde jezt mal weitermachen und eure tipps beachten. Ich meld mich dann vermutlich später nochmal und präsentiere euch das ergebniss. Vieleicht will ja nochmal jemand eine GFS über den Asuro machen.

InFaIN

[InFaIN]

Ich bin jezt gerade bei dem Thema Spannungsteiler bei den Tastern nun ist mein proplem ich habe keien ahnung wie ich weitermachen muss.

+5V
|
1 MOhm
|
+-----------------------Messgerät(AD-Wandler)
|
+--Taster1--Widerstand1--Masse
|
+--Taster2--Widerstand2--Masse
|
+--Taster3—-Widerstand3--Masse
|
+--Taster4—-Widerstand4--Masse
|
+--Taster5—-Widerstand5—-Masse
|
+--Taster6--Widerstand6--Masse
|
Fester Widerstand
|
+5V

Beispiel 1: Taster1 Ist gedrückt. Dann muss man rechnen
Beispiel 2: Taster 4 und Taster 5 sind gedrückt. Dann muss man rechnen

So nur wie muss ich es rechnen und vieleicht weiß ja auch einer die Werte für die Wiederrstände. Und nehmt noch zur kenntniss, dass ich das ganze 8. Klässlern erklären muss die in Physik nur Reden und nich Aufpassen. Zur beruhigung Wiederstände ham mer in Physik schon gemacht.

[Sternthaler]

Hallo InFaIN,
das steht doch tatsächlich alles unter dem oben (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?t=29559) von mir angegebenen Thread.
Immerhin warst du ja ja schon drin um den 'Schaltplan' abzumalen.

Das Grundgerüst der Rechnung (Reihen- / Parallelberechnung) ist hier (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=273356#273356) zu finden.

Die Werte der Widerstände (schreibt man nur mit i und nicht mit ie) stehen direkt darunter an dieser (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=273400#273400) Stelle.

Und noch einen Beitrag weiter, steht hier (https://www.roboternetz.de/phpBB2/zeigebeitrag.php?p=273461#273461) wie man dann rechnet.

Gruß Sternthaler

[InFaIN]

Dein lezter link hat mir sehr geholfen nun wollt ich einfach nur zur kontrolle fragen ob ich nach diesem Beispiel richtig gerechnet habe:




+5V (egal woher)
|
Widerstand 999 Ohm (die beiden parallel gerechnet)
|
+-----------------+
|
+----------AD-Wandler vom Prozessor (Pin 27)
|
+--------+--------+---+----+--------+--------+
|
|
|
| 5 NICHT gedrückte Taster
|
| | | | | |
Widerstände 2000 4000 8200 16000 33000 60000
| | | | | |
+--------+--------+---+----+--------+--------+
|
|
Masse


Dann müsste doch rauskommen 666 Ohm wenn ich richtig gerechnet hab.

Doch dann hab ich des proplem(ich hab den beitrag von dir im andern Theard gelesen) dass ich des mit dem AD wandler nich so ganz verstehe. Du hast es ja für den hellichkeitssensor erklärt nur ist mir da nicht so ganz klar wei ich es bei den Tastern machen muss.

Vielen Dank im voraus

InFaIN

[damaltor]

der AD wandler (ADC) wandelt einen spannungswert am eingang in einen zahenwert um.

nehmen wir das so, wie es in deiner zeichnung oben drin ist. reduziert auf das minimum kann man es doch so betrachten:

VCC (5V) -- 999Ω -- ADC-pin -- 2000Ω -- Masse

den 999er runden wir mal auf 1000Ω.

das was du hier siehst ist ein sogenannter spannungsteiler. die spannung in der mitte am adc pin zwischen den beiden widerständen ist:

VCC * R2 / (R1 + R2)
also:
5V * 2000Ω / (2000Ω + 1000Ω)
also etwa 3,3333V

der ADC misst nun diese 3,333V. dabei berücksichtigt er folgendes:
0V -> 0
VCC -> 1023

du kannst also den wert des adc auch berechnen nach folgender formel:
ADCWERT = MESSSPANNUNG * 1023 / VCC
also
ADCWERT = 3,333V * 1023 / 5V
also
ADCWERT = 682
(in diesem fall sogar ohne kommastellen. wenn kommastellen auftreten, werden diese IMMER abgerundet. 100,99999 wäre also 100 und nicht 101!)

diese zahl, 682 ist der vom prozessor berechnete wert für die spannung an seinem ADC-eingang.

dann schauen wir mal in die asuro.c, in diesem fall in die originale von der cd (habe gerade keine andere zur hand). suche nach der funktion pollswitch. der obere teil ist "nur" dazu da, den ADC zu initialisieren und die messung zu starten. wichtig für uns ist die unterste zeile, bei dem return:

((unsigned char) ((( 1024.0/(float)i - 1.0)) * 61.0 + 0.5))

mithilfe dieser formel wird der eben herausgefundene ADC-wert in einen pollswitch-wert umgerechnet. dabei ist "i" in der formel der ADC-wert.
wir rechnen also: (1024 / 682 - 1) * 61,0 + 0,5
und kommen auf den (eher schlechten) wert von etwa 31 (32 sollten es sein).

aber das grundprinzip ist soweit in ordnung (jetzt siehst du wenigstens mal warum man die 61.0 verändern kann / sollte um die werte zu verbessern).

rechne noch ein paar beispiele, zB den taster auf der gegenüberliegenden seite, oder (LEVEL2 =) rechne was passiert wenn mehrere taster gleichzeitig gedrückt werden (diese sind dann parallel geschaltet!).

wenn du noch fragen hast dann melde dich einfach.

[InFaIN]

Erstmal vileen Dank für deine Antwort damaltor.

Ich denke ich habe es jezt verstanden.

jezt habe ich es mal auf Level 2 probiert mit zwei Taster, doch ich bin mir nicht wirklich sicher ob es richtig ist.





+5V
|
Widerstand 1000Ω Ohm
|
+-----------------+
|
+----------AD-Wandler
|
+--------+--------+---+----+--------+--------+
| |
| |
| |
| 4 NICHT gedrückte Taster |
| |
| | | | | |
Widerstände 2000Ω 4000Ω 8200Ω 16000Ω 33000Ω 60000Ω
| | | | | |
+--------+--------+---+----+--------+--------+
|
|
Masse



1 1
---------------------------------- ______ ------------------------
1 1 ______ 1 1
-------------- + ---------------- --------- + ----------
Widerstant1 Widerstand 2 2000Ω 60000Ω


Das Ergebnis wäre dann gerundet: 1935Ω


Spannung * Widerstand1 / (Widerstand1 + Widerstand2)
5V * 1935Ω / ( 1935Ω + 1000Ω)
= 3,2964V

Gemessene Spannung * 1023 / Spannung
3,2964V * 1023 / 5V
= 469 (richtig gerundet)

(1023 / gemessener Wert - 1) * 61 + 0.5
(1023 / 469 - 1) * 61 + 0.5
= 72


Ich hoffe man kann es erkennen ist alles nen bissle verutscht.

InFaIN

[damaltor]

na gut probeiren wir das mal.
60000Ω || 2000Ω = 1935 Ω
U_ADC = 5V * 1935Ω / (1935Ω + 1000Ω) = 3,2964V
(kleiner fehler in deiner beschreibung, aber richtig gerechnet. U_ADC = VCC * R2 / (R1 + R2), nicht R1 vorne!)
ADC = 3,2964V * 1023 / 5V = 674 (!! Fehler, du hast 2,2964 eingetippt!)
POLLSWITCH = (1023 / 674 - 1) * 61 + 0,5 = 32,0

sollte 33 (=32 + 1) sein.

also an sich hast du es wohl verstanden, aber dich leider vertippt :D

diese fehler am ende könnten evtl darauf zurückzuführen sein, dass VCC nicht genau 5V ist sondern etwas darüber. habe ich aber noch nicht nachgerechnet.

EDIT:
Level3: alle atsten gedrückt.
2000Ω||4000Ω||8200Ω||16000Ω||33000Ω||60000Ω = 1018.9308Ω

[Sternthaler]

Schön, dass ihr weiterkommt.
Ich sehe direkt den glühenden Taschenrechner vor meinen Augen ;-)

Tut mir leid, dass ich im Moment nicht so intensiv dabei bin, aber damaltor richtet es ja bestens.



.. Doch dann hab ich des proplem(ich hab den beitrag von dir im andern Theard gelesen) dass ich des mit dem AD wandler nich so ganz verstehe. Du hast es ja für den hellichkeitssensor erklärt nur ist mir da nicht so ganz klar wei ich es bei den Tastern machen muss. ..
Die Sache mit den Helligkeitssensoren und/oder den Tasten ist etwas ganz anderes als der AD-Wandler.
Du musst hier ganz stark unterscheiden worum es bei den beiden Dingen (AD-Wandler / Sensoren) geht.

Der AD-Wandler ist 'nur' dafür zuständig, die Analogen Spannungswerte der Sensoren/Taster in eine für den Computer lesbare Digitale Zahl zu 'verwandeln'. (Das hat damaltor gerade erklärt.)

In dem Thread, in dem ich das mit den Helligkeitssensoren erklärte, habe ich sie so dargestellt, dass man sie einfach als veränderbare Widerstände betrachten kann.
Nun hast du ja schon selber die Aufgabe von damaltor mit den 2 gedrückten Tastern berechnet. Und??? Was hast du da gemacht??? Du hast die Widerstände an den Tastern nur neu zusammengeschaltet, so dass sich der Gesamtwert da geändert hat. (Parallelschalten von Widerständen mit Tastern)
Siehst du den Zusammenhang? Licht ändert am Helligkeitsensor den Widerstand. Finger an den Tastern ändert den Widerstand in der Schaltung.
Und der AD-Wandler muss nur nachsehen, wie groß dann die Spannung ist, um die Zahl zu bestimmen.


Also schön unterscheiden:
Sensoren (Licht/Finger/Luftfeuchtigkeit/...) ändern eine Spannung.
AD-Wandler machen dir 'nur' eine Zahl daraus, damit der Computer damit arbeiten kann.

Weiterhin viel Erfolg bei der Elektrotechnik
wünscht dir Sternthaler

P.S.: Immer schön weiter fragen, wenn noch was unklar ist.

[InFaIN]

Nun ist es mal wieder so weit, ich brauche euro hilfe. Vornweg die Hilfe sollte schnell sein da ich an diesem Donnerstag meine GFS halten muss.

Ich habe jezt alle meine Codes verucht in eine Datei zu bekommen da man ja schlecht beim vortrag immer flashen kann. Nun habe ich aber das proplem damit dies nicht funktioniert. Ich hoffe ihr könnt mir helfen. Ich habe den code von der Kolision genommen um das "Menü" zu machen. Hier der Code:



#include "asuro.h"


#define TRIGGERLEVEL 655
#define HYSTERESIS 10
#define LOW 0
#define HIGH 1


#define GESCHW 65


int main(void)
{
unsigned int z ,ll ,rr;
unsigned char taste1, taste2 ,taste3, taste4;

unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;

MotorDir(FWD, FWD);


int lData[2];
int i, donl, doffl, donr, doffr, l, r;

Init();


while(1)
{
taste4=PollSwitch();
taste2=PollSwitch();
taste1=PollSwitch();
taste3=PollSwitch();
if (taste1 && (taste1==taste2) && (taste3==taste4) && (taste1==taste3) && (taste1==taste4))
{
ll=0;
rr=0;
if (taste1==1) {
//////////////////////////////////////////////
///// Kolision
//////////////////////////////////////////////

while(1)
{
taste4=PollSwitch();
taste2=PollSwitch();
taste1=PollSwitch();
taste3=PollSwitch();
if (taste1 && (taste1==taste2) && (taste3==taste4) && (taste1==taste3) && (taste1==taste4))
{
l=0;
r=0;
if (taste1==1) {l=120;r=0;}
if (taste1==2) {l=0;r=160;}
if (taste1==4) {l=0;r=120;}
if (taste1==8) {l=120;r=0;}
if (taste1==16) {l=160;r=0;}
if (taste1==32) {l=0;r=120;}
StatusLED(RED);
MotorDir(RWD,RWD);
MotorSpeed(l,r);

for(z=0;z<250;z++)
{
Sleep(255);
}
}
else
{
StatusLED(GREEN);
MotorDir(FWD,FWD);
MotorSpeed(120,120);
}
taste2=0;
taste1=0;
}
return 0;


//////////////////////////////////////////////
///// Kolision
//////////////////////////////////////////////
}
if (taste1==2)
{
//////////////////////////////////////////////
///// Odometer
//////////////////////////////////////////////

while(1) {
// 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++;
}
// Wechsel linker Sensor von hoch auf niedrig?
if ((status[0]==HIGH) && (data[0]<TRIGGERLEVEL-HYSTERESIS)) {
status[0]=LOW;
difference++;
}
// 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?ler
// den erlaubten Wertebereich verl?st
if (difference<-255) difference=-255;
if (difference>255) difference=255;

// Status-LED noch entsprechend der erkannten Segmente
// aufleuchten lassen, grn fr links, rot fr rechts
StatusLED(status[0]+status[1]*2);

// Z?ldifferenz passend auf die Motoren verteilen
if (difference>0) MotorSpeed(255-difference-50,255-50);
else MotorSpeed(255-50,255+difference-50);

}
return 0;

//////////////////////////////////////////////
///// Odometer
//////////////////////////////////////////////
}
if (taste1==4)
{
//////////////////////////////////////////////
///// Linien
//////////////////////////////////////////////

while(1)
{
FrontLED(OFF); // Umgebungslicht filtern
Sleep(10); // kurz warten bis LED aus
LineData(lData); //
LineData(lData); //
doffl = (lData[0]); //
doffr = (lData[1]); //
FrontLED(ON); //
Sleep(10); // kurz warten bis LED an
LineData(lData); //
LineData(lData); //
donl = (lData[0]); //
donr = (lData[1]); //
l = donl - doffl; //
r = donr - doffr; // r und l sind nun die werte von T9 und T10 mit gefiltertem Umgebungslicht
i = (l+r)/2;

if (l<r) // gegenlenken
{
MotorSpeed(GESCHW -i+68, GESCHW +i);
}
else
{
MotorSpeed(GESCHW +i+68, GESCHW -i);
}

}
return 0;

//////////////////////////////////////////////
///// linien
//////////////////////////////////////////////
}
if (taste1==8) {l=120;r=0;}
if (taste1==16) {l=160;r=0;}
if (taste1==32) {l=0;r=120;}
StatusLED(RED);

taste2=0;
taste1=0;

}
return 0;
}
}


Naja wenn ihr mir nicht helfen könnt auch nicht so schlimm dan muss ich eben doch nebenher flashen.

Vielen Dank im Voraus!

[hai1991]

hallo

was genau funktionier bei deinem programm nicht?

[InFaIN]

Naja wenn ich einen Taster drücke passiert garnix

[hai1991]

allso erst mal vorweg: 4 tasterabfragen sind doch etwas viel, aber sicher nicht das problem. im normalfall genügen immer 2, zb auf diese art:


do{
taster=PollSwitch();
}while(taster!=PollSwitch());


so, und nun zu deinem problem:
versuch einmal nach dem ersten return 0; noch eine abschließende "}" zu setzen. ich glaube, dass es daran liegen kann.

ein anderer ansatz wäre es, dein ganzes programm noch einmal zu schreiben, und dann im main() nur die programmanwahl per tasterabfrage zu machen, und die ganzen programme (kollision, odometrie,...) in eigenen funktionen außerhalb von main() auszuführen. dadurch wird der code automatisch übersichtliche, und man kann somit auch leicher fehler suchen/finden.

[Sternthaler]

Hallo InFaIN,

den vorgeschlagenen Ansatz von hai1991 kann ich nur unterstützen.
Hier ist mal eine formatierte Version. Es ist nichts geändert, sondern nur mal ordentlich eingerückt. Dann wird der Fehler auch sichtbar.

#include "asuro.h"

#define TRIGGERLEVEL 655
#define HYSTERESIS 10
#define LOW 0
#define HIGH 1
#define GESCHW 65

int main (void)
{
unsigned int z, ll, rr;
unsigned char taste1, taste2 ,taste3, taste4;
unsigned int data [2];
signed int status [2] = {0, 0};
signed int difference = 0;
int lData [2];
int i, donl, doffl, donr, doffr, l, r;

MotorDir (FWD, FWD);

Init ();

while (1)
{
taste4 = PollSwitch ();
taste2 = PollSwitch ();
taste1 = PollSwitch ();
taste3 = PollSwitch ();

if (taste1 &&
taste1 == taste2 &&
taste3 == taste4 &&
taste1 == taste3 &&
taste1 == taste4)
{
ll = 0;
rr = 0;
if (taste1 == 1)
{
//////////////////////////////////////////////
///// Kolision
//////////////////////////////////////////////

while (1)
{
taste4 = PollSwitch ();
taste2 = PollSwitch ();
taste1 = PollSwitch ();
taste3 = PollSwitch ();

if (taste1 &&
taste1 == taste2 &&
taste3 == taste4 &&
taste1 == taste3 &&
taste1 == taste4)
{
l = 0;
r = 0;

if (taste1 == 1) { l = 120; r = 0; }
if (taste1 == 2) { l = 0; r = 160; }
if (taste1 == 4) { l = 0; r = 120; }
if (taste1 == 8) { l = 120; r = 0; }
if (taste1 == 16) { l = 160; r = 0; }
if (taste1 == 32) { l = 0; r = 120; }

StatusLED (RED);
MotorDir (RWD, RWD);
MotorSpeed (l, r);

for (z = 0; z < 250; z++)
{
Sleep (255);
}
}
else
{
StatusLED (GREEN);
MotorDir (FWD, FWD);
MotorSpeed (120, 120);
}
taste2 = 0;
taste1 = 0;
}
return 0;

//////////////////////////////////////////////
///// Kolision
//////////////////////////////////////////////
}

if (taste1 == 2)
{
//////////////////////////////////////////////
///// Odometer
//////////////////////////////////////////////

while (1)
{
// 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++;
}
// Wechsel linker Sensor von hoch auf niedrig?
if (status [0] == HIGH &&
data [0] < TRIGGERLEVEL - HYSTERESIS)
{
status [0] = LOW;
difference++;
}

// 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?ler
// den erlaubten Wertebereich verl?st
if (difference <- 255)
difference = -255;
if (difference > 255)
difference = 255;

// Status-LED noch entsprechend der erkannten Segmente
// aufleuchten lassen, grn fr links, rot fr rechts
StatusLED (status [0] + status [1] * 2);

// Zaeldifferenz passend auf die Motoren verteilen
if (difference > 0)
MotorSpeed (255 - difference - 50, 255 - 50);
else
MotorSpeed (255 - 50, 255 + difference - 50);
}
return 0;

//////////////////////////////////////////////
///// Odometer
//////////////////////////////////////////////
}

if (taste1 == 4)
{
//////////////////////////////////////////////
///// Linien
//////////////////////////////////////////////

while (1)
{
FrontLED (OFF); // Umgebungslicht filtern
Sleep (10); // kurz warten bis LED aus
LineData (lData); //
LineData (lData); //
doffl = lData [0]; //
doffr = lData [1]; //
FrontLED (ON); //
Sleep (10); // kurz warten bis LED an
LineData (lData); //
LineData (lData); //
donl = lData [0]; //
donr = lData [1]; //
l = donl - doffl; //
r = donr - doffr; // r und l sind nun die werte von T9 und
// T10 mit gefiltertem Umgebungslicht
i = (l + r) / 2;

if (l < r) // gegenlenken
{
MotorSpeed (GESCHW - i + 68, GESCHW + i);
}
else
{
MotorSpeed (GESCHW + i + 68, GESCHW - i);
}
}
return 0;

//////////////////////////////////////////////
///// linien
//////////////////////////////////////////////
}

if (taste1 == 8) { l = 120; r = 0; }
if (taste1 == 16) { l = 160; r = 0; }
if (taste1 == 32) { l = 0; r = 120; }
StatusLED (RED);

taste2 = 0;
taste1 = 0;
}
return 0;
}
}

Wird jetzt mal alles aus dem ersten if() in der while()-Schleife hinter dem Init() entfernt, bleibt nur noch folgendes übrig:
#include "asuro.h"

#define TRIGGERLEVEL 655
#define HYSTERESIS 10
#define LOW 0
#define HIGH 1
#define GESCHW 65

int main (void)
{
unsigned int z, ll, rr;
unsigned char taste1, taste2 ,taste3, taste4;
unsigned int data [2];
signed int status [2] = {0, 0};
signed int difference = 0;
int lData [2];
int i, donl, doffl, donr, doffr, l, r;

MotorDir (FWD, FWD);

Init ();

while (1)
{
taste4 = PollSwitch ();
taste2 = PollSwitch ();
taste1 = PollSwitch ();
taste3 = PollSwitch ();

if (taste1 &&
taste1 == taste2 &&
taste3 == taste4 &&
taste1 == taste3 &&
taste1 == taste4)
{
}
return 0;
}
}

Das geht zwar durch den Compiler, aber dieses Programm verläßt die main()-Funktion mehr oder weniger sofort nach dem einschalten wieder. Und das ist leider falsch.

Wenn alle 'return 0'-Zeilen entfernt werden sollte es auf alle Fälle schon mal besser gehen.

Wird der Asuro eingeschalte, sollte das 'Menü' aktiv sein:
- Taste1 = 1: Kollision
- Taste1 = 2: Odometer
- Taste1 = 4: Linien

- Taste1 = 8: Variablen l und r setzen, aber nichts weiteres.
- Taste1 = 16: Sollten hier Motorbewegungen angestoßen werden?
- Taste1 = 32: Es scheint dann ein MotorSpeed() zu fehlen

Ob die Funktionen bei Taste1 = 1, 2, 4 gehen weiss ich nicht.
Das formatieren kostet viel überflüßige Zeit, wenn man es nicht sofort macht.

Gruß Sternthaler

P.S.: Versuch einmal, ob der Asuro anders reagiert, wenn du sofort nach dem Einschalten einen der ersten 3 Taster drückst.
Dann sollte das 'Menü' ja schon ausgewählt werden. Aber ob dann nicht die 4-fach-Tastenabfrage blockiert?