Fertiges Labyrinthprogramm!!!!

[G3tzR@zor]

Hi@all,
ich habe zufällig im Forum dieses Programm gefunden, um meinen Asuro durch ein Rechtwinkliges Labyrinth fahren zu lassen.



#include "asuro.h"

#define FULL_L 200
#define FULL_R 205


volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
StatusLED(GREEN);
BackLED(OFF,OFF);
MotorDir(FWD,FWD);
MotorSpeed(FULL_L,FULL_R);
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
StatusLED(YELLOW);
BackLED(ON,ON);
MotorDir(RWD,RWD);
MotorSpeed(FULL_L,FULL_R);
}


void KurveLR(void) /* Kurve rückwärts Links */
{
StatusLED(YELLOW);
BackLED(ON,OFF);
MotorDir(RWD,RWD);
MotorSpeed(FULL_L,0);
}


void KurveRR(void) /* Kurve rückwärts Rechts */
{
StatusLED(YELLOW);
BackLED(OFF,ON);
MotorDir(RWD,RWD);
MotorSpeed(0, FULL_R);
}

void KurveRF(void) /* Kurve vorwärts Rechts */
{
StatusLED(YELLOW);
BackLED(OFF,OFF);
MotorDir(BREAK,FWD);
MotorSpeed(0,FULL_R);
}

void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveRR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

KurveLR();
Msleep(355);

Anhalten();
Msleep(250);

KurveRF();
Msleep(355);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveLR();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+10 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}

Dieses habe ich mit Hilfe der neuen Lib abgeändert!

#include "asuro.h"
#include "myasuro.h"

#define FULL_L 200
#define FULL_R 215


volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
StatusLED(GREEN);
BackLED(OFF,OFF);
MotorDir(FWD,FWD);
MotorSpeed(FULL_L,FULL_R);
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-50,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(90,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-90,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(180,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}

So weit funktioniert auch noch alles bis auf das gerade aus fahren"void fahren (void)", da dies doch sehr Batterieabhängig ist.

Da die Go Funktion nicht unterbrochen werden kann, wollte ich dies durch eine Regelng mit Hilfe der Odometrie realisieren.

Nachdem ich diese Regelung wie folgt in das Labyrinth Programm eingebunden habe bekomme ich beim Compilieren die Fehlermeldung
"List Index Out of Bounds(249)"




#include "asuro.h"
#include "myasuro.h"

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

volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);
while(Pollswitch()<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(160-difference,160);
else MotorSpeed(160,160+difference);
}


void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}

Beide Programme einzeln compiliert funzen ohne probleme!

Gibt es vll noch eine einfachere Möglichkeit den Asuro eine unbestimmte Strecke gerade aus fahren zu lassen bis eine Kollision erfolgt?

Ich steh jetzt nach 3 Tagen ständigem rumprobiern irgendwie mit dem Kopf an der Mauer. BITTE HELFT MIR!!!

MfG
GetzRazor

Hier noch der Text aus der Memo von Asuro Flash!

>Session Environment Variables:
AF_AVRDIR=C:\WinAVR-20090313
AF_PROJECT=LMAA
AF_SOURCE_FILES=asuro.c LMAA.c new.c
AF_ASM_SRC_FILES=
AF_PRGDIR=C:\Programme\AsuroFlash
AF_PRJDIR=C:\Dokumente und Einstellungen\All Users\Anwendungsdaten\AsuroFlash\Projects\LMAA
AF_LIB_PATH=C:\WinAVR-20090313\lib
File asuro.c saved.
File asuro.h saved.
File LMAA.c saved.
File myasuro.h saved.
>Default make_all.cmd file created.
>Default makefile created.
Make
set -e; avr-gcc -MM -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=new.lst -IC:\Programme\AsuroFlash\include -IC:\WinAVR-20090313\lib\inc new.c \
| sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > new.d; \
[ -s new.d ] || rm -f new.d
set -e; avr-gcc -MM -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=LMAA.lst -IC:\Programme\AsuroFlash\include -IC:\WinAVR-20090313\lib\inc LMAA.c \
| sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > LMAA.d; \
[ -s LMAA.d ] || rm -f LMAA.d
set -e; avr-gcc -MM -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=asuro.lst -IC:\Programme\AsuroFlash\include -IC:\WinAVR-20090313\lib\inc asuro.c \
| sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > asuro.d; \
[ -s asuro.d ] || rm -f asuro.d
-------- begin --------
avr-gcc --version
avr-gcc (GCC) 3.3.1
Copyright (C) 2003 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

Size before:
LMAA.elf :
section size addr
.text 2956 0
.data 16 8388704
.bss 32 8388720
.noinit 0 8388752
.eeprom 0 8454144
.stab 6012 0
.stabstr 2992 0
Total 12008


avr-gcc -c -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=asuro.lst -IC:\Programme\AsuroFlash\include -IC:\WinAVR-20090313\lib\inc asuro.c -o asuro.o
avr-gcc -c -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms=LMAA.lst -IC:\Programme\AsuroFlash\include -IC:\WinAVR-20090313\lib\inc LMAA.c -o LMAA.o
LMAA.c: In function `Fahren':
LMAA.c:176: warning: `main' is normally a non-static function
LMAA.c:248: error: parse error at end of input
make: *** [LMAA.o] Error 1

C:\Dokumente und Einstellungen\All Users\Anwendungsdaten\AsuroFlash\Projects\LMAA>C:\WinAVR\utils\bin\make all

ExitCode 2
>Ready.

[Osser]

Hi G3tzR@zor,

mein WinAVR hat folgende Versionssignatur:

avr-gcc --version
avr-gcc (GCC) 4.2.2 (WinAVR 20071221)
Copyright (C) 2007 Free Software Foundation, Inc.


Vielleicht liegts daran dass deine WinAVR Version von 2003 ist, bin mir nämlich nicht sicher ob die neue LIB damit noch geht.

Welche Version von AsuroFlash benutzt Du?


Gruss,

O.

[G3tzR@zor]

Hi Osser,
ich benutze die Asuro Flash Version 1.7.10.99
Hatte bis dato auch keine probleme mehr, seid meinem letzten post.

Ich wundere mich nur dass ich die Progs einzeln comilieren kann aber eben nicht zusammen in einem Prog?!

Ich hab nur Bedenken alles neu zu installieren weil ich nicht genau weis wie ich alles einbinden muss, damit es funktioniert.

Mein Kollege wollte sich alles auf sein Lappy machen und hat die neuesten Versionen runtergeladen.
Also -Asuro Flash 1.7.11.102
-WinAVR 20090313
-Asuro Lib 2.8.0

Binde ich nun in den C++ Optionen die Aktuelle WinAVR ein hängt sich asuro flash beim Compilieren auf. Benutze ich die alte Version bekomm ich nur einen Fehler in der asuro.c angezeigt(f_cpu......)habs lappy grad net da von ihm.

Hab zu dem Fehler (f_cpu.....) nur einen Beitrag gefunden wo geschrieben wurde, dass es sich um eine falsche Verlinkung im make File handelt.

Anscheinend kommen hier mehrere probs zusammen.

Ich werd mal versuchen die neuen Versionen auf einem anderen PC zum laufen zu bekommen.

Aber kann das wirklich sein, dass die progs getrennt funzen und zusammengeführt die Fehlermeldung kommt?

Vielen dank schonmal für deine schnelle Antwort!

MfG
G3tzR@zor

[hai1991]

hallo zusammen

nur mal eine vermutung, da du schreibst, dass beide progs einzelln funktioniern, zusammen aber nicht.
kann es sein, dass es zu lange wird?
ich habe jetzt nicht genau geschaut bzgl der länge der programme, aber das fällt mir dazu ein.
wie gesagt es ist nur eine vermutung!

[G3tzR@zor]

Hallo,
danke zunächst nochmal für eure Antworten.

Ich habe mittlerweile die neuesten Versionen installiert und zum laufen gebracht!

@Osser
Die Fehlermeldung "List index out of bounds" hat sich dadurch wirklich erledigt. Danke für den Hinweis!

@hai1991
Die Länge der Progs beträgt einzeln compiliert nur jeweils um die 45 Seiten.

Nun muss aber doch im Bereich der fahren Funktion noch ein Fehler sein!

Hier nochmal das Prog


#include "asuro.h"
#include "myasuro.h"

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

volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);
while(PollSwitch()<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(160-difference,160);
else MotorSpeed(160,160+difference);
}


void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}


und das entsprechende Memo




>Session Environment Variables:
AF_AVRDIR=C:\WinAVR-20090306rc1
AF_PROJECT=Labyrinth
AF_SOURCE_FILES=asuro.c Labyrinth.c
AF_ASM_SRC_FILES=
AF_PRGDIR=C:\Program Files (x86)\AsuroFlash
AF_PRJDIR=C:\Documents and Settings\Administrator\Desktop\Asuro\Projekte\LMAA
AF_LIB_PATH=C:\AsuroLib
File asuro.c saved.
File asuro.h saved.
File myasuro.h saved.
File Labyrinth.c saved.
>Default make_all.cmd file created.
>Default makefile created.
Make
C:\Documents and Settings\Administrator\Desktop\Asuro\Projekte\LMAA>C:\WinAVR-20090306rc1\utils\bin\make all
set -e; avr-gcc -MM -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -I"C:\AsuroLib/inc" -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms="Labyrinth.lst" "Labyrinth.c" \
| sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > "Labyrinth.d"; \
[ -s Labyrinth.d ] || rm -f "Labyrinth.d"
set -e; avr-gcc -MM -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -I"C:\AsuroLib/inc" -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms="asuro.lst" "asuro.c" \
| sed 's,\(.*\)\.o[ :]*,\1.o \1.d : ,g' > "asuro.d"; \
[ -s asuro.d ] || rm -f "asuro.d"
-------- begin --------
avr-gcc --version
avr-gcc (WinAVR 20090306rc1) 4.3.2
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions. There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

avr-gcc -c -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -I"C:\AsuroLib/inc" -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms="asuro.lst" "asuro.c" -o asuro.o
In file included from asuro.h:147,
from asuro.c:137:
c:/winavr-20090306rc1/lib/gcc/../../avr/include/avr/signal.h:36:2: warning: #warning "This header file is obsolete. Use <avr/interrupt.h>."
asuro.c: In function 'PrintInt':
asuro.c:482: warning: pointer targets in passing argument 1 of 'SerWrite' differ in signedness
avr-gcc -c -mmcu=atmega8 -DF_CPU=8000000UL -I. -g -Os -I"C:\AsuroLib/inc" -funsigned-char -funsigned-bitfields -fpack-struct -fshort-enums -Wall -Wstrict-prototypes -Wa,-ahlms="Labyrinth.lst" "Labyrinth.c" -o Labyrinth.o
In file included from asuro.h:147,
from Labyrinth.c:1:
c:/winavr-20090306rc1/lib/gcc/../../avr/include/avr/signal.h:36:2: warning: #warning "This header file is obsolete. Use <avr/interrupt.h>."
Labyrinth.c: In function 'Fahren':
Labyrinth.c:175: warning: 'main' is normally a non-static function
Labyrinth.c:247: error: expected declaration or statement at end of input
make: *** [Labyrinth.o] Error 1


ExitCode 2
>Ready.


MfG
G3tzR@zor


Edit

Habe nun auch den Fehler im Programm gefunden!

In der fahren Funktion hat am Ende noch eine geschlossene, geschweifte Klammer gefehlt, wodurch natürlich der ganze rest des Programms mit eingebunden war.

So weit so gut, hab mich schon gefreut, dass es endlich geht und hab das Prog gleich mal auf meinen Asuro geflasht.

Nun fährt er, warum auch immer, nur noch rückwärts, die StatusLED leuchtet Rot und er reagiert auf keinen Taster.

Habt ihr habt eine Idee was nun an meinem Prog noch falsch ist.

Hier mal der fast funktionierende Code



#include "asuro.h"
#include "myasuro.h"

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

volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);
while(PollSwitch()<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(180-difference,180);
else MotorSpeed(180,180+difference);
}
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}




Danke schonmal im Vorraus für eure Hilfe!

MfG
G3tzR@zor[/code]

[radbruch]

Hallo

Schön dass die meisten deiner Probleme schon gelöst sind.


while(PollSwitch()<1) { ...Das funktioniert praktisch nie! PollSwitch() liefert nicht immer 0 zurück wenn keine Taste gedrückt wurde:

https://www.roboternetz.de/phpBB2/viewtopic.php?t=48053
(Eines der unzähligen Beispiele)

Gruß

mic

[G3tzR@zor]

Ich bin so langsam wirklich am Verzweifeln. Ich habe nun Versucht die Pollswitch abfrage so einzubauen.



#include "asuro.h"
#include "myasuro.h"

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


volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned char taste1, taste2;
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);


while((taste1<1) && (taste1==taste2)) {
taste1 = PollSwitch();
taste2 = PollSwitch();
// 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(180-difference,180);
else MotorSpeed(180,180+difference);

}
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}


Nun leuchtet die StatusLED Grün und die LED für die Linensensoren.

Setze ich das eine taster1=PollSwitch() vor die while schleife fährt der Ausuro nur noch Rückwärts bei roter StatusLED und leuchtender LiniensensorLED. Er nimmt auch keine Pollswitch anweisung mehr an.


#include "asuro.h"
#include "myasuro.h"

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


volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned char taste1, taste2;
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);
taste1 = PollSwitch();

while((taste1<1) && (taste1==taste2)) {

taste2 = PollSwitch();
// 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(180-difference,180);
else MotorSpeed(180,180+difference);

}
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}


Warum fährt er Rückwärts? Dies ist doch im ganzen Programm nicht vorgesehen, bis auf dieses kurz zurück bei einer Kollision.

Hier mal die beiden Hex files zu den Codes. Vll könnt ihr sie bei eurem Asuro mal testen.

[Valen]

Die taste1 und taste2 wert sind nicht initialisiert. Im ersten 'fahren'-code gar nicht. Im zweiten code has du nur taste1 einer wert gegeben mit Pollswitch vor du ihn UND taste2 im while-Schleife header uberpruft. Man kan nicht darauf verlassen das einer Variabele einer sinnvoller wert hat am anfang von das program. Immer einer sichere wert eingeben beim deklarieren, oder gleich mit einer function einer wert zuweisen vordem eine logische entscheidung daruber gemacht wird..

unsigned char taste1=0;
unsigned char taste2=0;

Ich bin mich nicht sicher das folgende auch compiliert wird:

unsigned char taste1=0, taste2=0;

[G3tzR@zor]

Nochmal kurz ein Aktueller Stand meines Progs,

- Asuro fährt los und die Odometrieregelung funktioniert
- Sobald ein Taster gedrückt wird wird die Schleife verlassen

so weit so gut....

aber
-das prog springt weder in firstcol() noch in fahren(), sondern lässt den Asuro nur noch rückwärts fahren bei roter StatusLED.


Aktueller Code:


#include "asuro.h"
#include "myasuro.h"

#define TRIGGERLEVEL 830
#define HYSTERESIS 10
#define LOW 0
#define HIGH 1
#define keine_taste (PINC & (1<<PC4))

volatile unsigned int i;

void Fahren(void) /* Vorwärts fahren */
{
unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);

while(keine_taste){
// 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(180-difference,180);
else MotorSpeed(180,180+difference);

}
}

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* Zurück fahren */
{
Encoder_Init();
Go(-10,200);
}


void KurveR(void) /* Kurve Rechts 90° */
{
Encoder_Init();
Turn(60,200);
}


void KurveL(void) /* Kurve rückwärts Rechts */
{
Encoder_Init();
Turn(-50,200);
}

void Drehung(void) /*180° Kurve*/
{
Encoder_Init();
Turn(120,200);
}


void Firstcol(void) /* Programm Rechtskurve im Parcour 1. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(15);

Anhalten();
Msleep(10);

KurveR();
Msleep(400);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch ();
}

void Secondcol(void) /* Programm Linkskurve im Parcour, 2. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

Anhalten();
Msleep(250);

Drehung();
Msleep(355);

Anhalten();
Msleep(250);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();
}

void Thirdcol(void) /* Programm Sackgasse im Parcour, 3. Kollision */
{
Anhalten();
Msleep(250);

Zurueck();
Msleep(10);

KurveL();
Msleep(310);

Anhalten();
Msleep(250);

switched = 0;
StartSwitch();

}

void Disco(void) /* PARTYTIME! -15mal blinken/piepsen-*/
{

for(i = 0; i < 16; i++)
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}


}


int main (void) /* Hauptprogrammbeginn */
{
unsigned int data[2]; /* Speicherplpatz für Helligkeitswert */
unsigned int Summe;
Init ();
switched = 0; /* Kollisionserkennung auf 0 setzen */
StartSwitch (); /* Taster-Interrupt aktivieren */
FrontLED(ON);
LineData(data); /* Speichern von Helligkeitswert in data[0,1] */
Summe = data[0]+data[1]; /* Summe der Werte beider Fototransistoren */


while (1)
{
if (switched == 1) /* Wenn 1. Kollision, dann Rechtskurve 90° aus */
{

Firstcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für 2. Kollision */
{
if (switched == 1) /* Wenn 2. Kollision, dann Drehung 180° */
{
Secondcol();

for(i = 0; i < 25000; i++) /* Setze Zeitschlaufe für dritte Kollision */
{
if (switched == 1) /* Wenn 3. Kollision, dann Linksdrehung 90° */
{
Thirdcol();
}

else /* Keine 3. Kollision, Fahre normal */
{
Fahren();
}


}

}

else /* Keine 2. Kollision, Fahre normal */
{
Fahren();
}


}



}



else /* gar keine Kollision, Fahre normal, Stopp bei Linie */
{
LineData(data);
if(data[0]+data[1]+200 > Summe) /* Untergrundhelligkeitsdifferenz feststellen */
{
Fahren();
}
else
{
Disco(); /* Party gut - Alles gut */
while(1)
{} /* Endlosschleife - Ende des Programmes */
}
}
}
return 0;
}


Hat wirklich niemand eine Ahnung wie dieses Verhalten zu stande kommt?

MfG
G3tzR@zor

[Valen]

Ich denke es ist nun wichtig du last ihn irgendwie sein Programme ablauf zum Rechner senden. Sondern wirst du das Programfehler nie finden. Fug mahl an das begin jeder Subfunction ein SerWrite ein die den Nahme des Functions (oder ein ähnliche kurze ID-code) ubermittelt uber IR. Vieleicht mit einer kurzen msleep weil das program möglich schneller geht dan 2400 baud ubermitteln kan. (deswegen auch kurze ID-codes) Und dann Asuro auf deinen tisch testen mit seiner Rädern hoch. Nur fur das debug prozzes. Gedanke-experimenten machen uber den ablauf ist zu Komplex, und gibt absolut keiner sicherheit. Weil man den Ododata oder Linedata werten nicht kennst.

[G3tzR@zor]

Hallo Valen,
vielen dank für deinen Tip, leider habe noch nichts mit der SerWrite Funktion gemacht und weis daher nicht wie und wo ich da was einbinden muss.

Hättest du vielleicht Zeit mir das zu machen? Wäre echt nett!

Ich bin jetzt beim weiteren herumtesten mit dem Prog so weit gekommen, dass nach einem Tasterdruck die Funktion Firstcol() aktiviert wird.

Er bleibt also kurz stehen und bleibt dann bei Zurueck() hängen. Es sieht für mich im Moment so aus als würde irgendwas verhindern, dass der Encoder initialisiert wird und dadurch die Go Funktion unendlich ausgeführt wird, weil keine daten von der Odometrie gemessen werden.

MfG
G3tzR@zor

[Valen]

void Fahren(void) /* Vorwärts fahren */
{
SerWrite ("FhS", 3); /* "Fahren start" senden uber IR*/

unsigned int data[2];
signed int status[2]={0,0};
signed int difference=0;
MotorDir(FWD, FWD);
...
...
// Z?ldifferenz passend auf die Motoren verteilen
if (difference>0) MotorSpeed(180-difference,180);
else MotorSpeed(180,180+difference);
}

SerWrite("FhE",3); /* "Fahren Ende" senden uber IR*/
}Und ähnliche codes. Zum beispiel:

MS,ME: Main start und ende.
FcS, FcE: Firstcol start und ende,
ScS, ScE: Secondcol start und ende,
usw. fur die andere functionen in dein program.

Und vieleicht die ADC werten auch ubermitteln. Aber das konnte zuviel daten werden zum ubertragen. [Edit] Dafur ist aber PrintInt besser ge-eignet. Lies mahl print.c im lib verzeichnis durch.

Am ende hast du auch eine while(1) schleife (nach dem Disco anruf). Besser dort auch etwas senden damit du weist er wird da immer stecken bleiben.

[G3tzR@zor]

Hallo Valen,
vielen dank für deine schnelle Hilfe!
Ich habs mal getestet und funktioniert wunderbar. Es hat sich nun herausgestellt, dass er wirlich in dem Programmteil "Zurueck()" hängen bleibt.
Hiermit bin ich eigendlich davon überzeugt, dass der befehl "Encoder_Init()" nicht ausgeführt wird.

Hab natürlich gleich mal getestet, was passiert wenn ich in "Zurück()" das "Encoder_Init()" raus nehme. Danach ergab sich das selbe Verhalten, was mir sagt, dass das initialisieren der Odometrie an der Stelle einfach übersprungen wird.

Kann es sein, dass durch die Regelung in "Fahren()" die odometrie noch aktiv ist und durch das "Encoder_Init()" ausgeschaltet wird?

Ich hoffe, dass wir mit dem Wissen nun etwas weiter kommen.

MfG,
G3tzR@zor

[Valen]

Ich hab auch keine "Encoder_Init" in meiner lib 2.80rc1. Nur "EncoderInit". Bist du sicher den compiler hat daruber nicht geklagt. Such mahl deine lib quell code dateien durch ob da irgendwo diesen "Encoder_Init" steckt.

[G3tzR@zor]

Ohh mann, vielen dank, das war der rettende Gedanke! Ich hatte vergessen nach der neuen Installation der Lib 2.80rc1 auch die Dateien "asuro.c, asuro.h und myasuro.h" in meinem Projektverzeichnis auszutauschen. 8-[

In der alten Lib 2.7x(weis nicht mehr genau) war das noch Encoder_Init, dies hat sich mit der neuen geändert.

Nachdem ich die Dateien ausgetauscht und neu compiliert hatte funktionierte das Programm ohne gößere probleme!

Ich hätte überall den Fehler gesucht nur nicht in der Lib!

Muss nun nur noch ein paar kleinere fehler behben. Da der Asuro im moment noch zu schnell durch das Labyrint fährt, erfolgt die nächste Kollision noch bevor die erste Zeitschleife abgelaufen ist.

Ich werde dies noch Verbessern und dann den entgültigen Programmcode hier posten.

@ valen...Nochmal vielen vielen Dank du warst meine Rettung! =D>

Wünsch dir noch nen schönen Feiertag!
G3tzR@zor

[Valen]

Keinen dank, den unterstrich war mir auch komplet nicht aufgefallen. :oops:

[G3tzR@zor]

**********kleine INFO***********
Ich habe das Programm nun fertig und auch komplett dokumentiert! Da es sich bei dem Programm um ein Abschlussprojekt für meinen Techniker handelt, das ich bis nächste Woche Donnerstag abegeben muss, kann ich im Moment den finalen Code noch nicht posten.

Also ich habe euch nicht Vergessen und sobald ich meine Note bekommen habe werde ich den Code veröffentlichen, damit auch alle etwas davon haben!

Gruß
G3tzR@zor

[G3tzR@zor]

Hi...hier bin ich mal wieder. Da die Noten für das Projekt nun fest stehen kann ich nun den Code posten.



/***************************Bibliotheken einbinden*****************************/
#include "asuro.h"
#include "myasuro.h"

/*******************Defines und Variablen für Fahren Regelung******************/

unsigned int data[2]; //Speicherplatz für Odometriedaten bereitstellen
signed int status[2]={0,0}; // Variable zur Bestimmung der Hell/Dunkel wechsel
signed int difference=0; // Variable zur regelung der Motorgeschwindigkeit

#define TRIGGERLEVEL 650 //Schwellwert für Hell/Dunkel übergänge
#define HYSTERESIS 10 // Ausgleich von Messfehlern
#define LOW 0 // Definition für Dunkel
#define HIGH 1 // Definition für Hell
#define keine_taste (PINC & (1<<PC4)) //Taster direkt abfragen


/************Variablen für Zeitvorgaben zwischen den Kollisionen***************/

unsigned long meineZeit;
unsigned long meineZeit2;

/**************Speicherplatz für Liniendaten bereitstellen*********************/

unsigned int umgebung[1];

/***Variable für Dunkelerkennung, damit der Asruro im Dunkeln stehen bleibt****/
int dunkel;

/**************************Vorwärts fahren*************************************/

void Fahren(void)
{
// Prozessor neu initialieren um EncoderInit() zurückzusetzen
// da sonst die Regelung nicht mehr funktioniert
Init();
FrontLED(ON);
;
//Motor Drehrichtung bestimmen
MotorDir(FWD, FWD);

// so lange gerade aus fahren bis ein Taster gedrückt wird
// und es hell genug ist
while((keine_taste) && (umgebung[0]>1))
{
LineData(umgebung);
// 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ässt
if (difference<-255) difference=-255;
if (difference>255) difference=255;

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

// Zäldifferenz passend auf die Motoren verteilen
if (difference>0) MotorSpeed(190-difference,190);
else MotorSpeed(190,190+difference);
}
Dunkel ();
}

/********Einzelfunktionen für Verarbeitung in First-,Second und Thirdcol********/

void Anhalten(void) /* Anhalten */
{
StatusLED(RED);
BackLED(OFF,OFF);
MotorDir(BREAK,BREAK);
}

void Zurueck(void) /* 20mm Zurück fahren */
{
EncoderInit();
GoTurn(-40,0,200);
}


void KurveR(void) /* 90° Kurve Rechts */
{
EncoderInit();
GoTurn(0,90,200);
}

void KurveL(void) /* 90° Kurve Links */
{
EncoderInit();
GoTurn(0,-90,200);
}

void Drehung(void) /*180° Drehung*/
{
EncoderInit();
GoTurn(0,180,200);
}
/****************Programm Rechtskurve im Parcour 1. Kollision******************/

void Firstcol(void)
{
Anhalten();
Msleep(250);

Zurueck();

Anhalten();
Msleep(10);

KurveR();

Anhalten();
Msleep(250);

meineZeit=Gettime(); //Aktuelle Prozessorzeit für Kollisionserkennung
//in meineZeit speichern
switched = 0;
StartSwitch ();
}

/*****************Programm Linkskurve im Parcour, 2. Kollision*****************/

void Secondcol(void)
{
Anhalten();
Msleep(250);

Zurueck();

Anhalten();
Msleep(250);

Drehung();

Anhalten();
Msleep(250);

meineZeit2=Gettime(); //Aktuelle Prozessorzeit für Kollisionserkennung
// in meineZeit2 speichern

switched = 0; // Kollisionserkennung auf 0 setzen
StartSwitch(); // Taster-Interrupt aktivieren
}

/*****************Programm Sackgasse im Parcour, 3. Kollision******************/

void Thirdcol(void)
{
Anhalten();
Msleep(250);

Zurueck();

KurveL();

Anhalten();
Msleep(250);

switched = 0; // Kollisionserkennung auf 0 setzen
StartSwitch(); // Taster-Interrupt aktivieren

}

/******Abfrage der Liniensensoren um Helligkeit der Umgebung festzustellen*****/
void Dunkel (void)
{
LineData(umgebung);
if (umgebung[0]<1)
{
dunkel = 1;
}

else if(umgebung[0]>1)
{
dunkel = 0;
}
}

/*****Wird ausgeführt, wenn der Asuro das ende des Labyrinths erreicht hat!****/
/*******Ende des Labyrints muss durch eine Einhausung abgedunkelt werden!******/
void Ziel(void)
{
int i;
for(i = 0; i < 16; i++) /* Asuro steht im Dunkeln, Ziel erreicht*/
{
MotorDir(FWD,FWD);
MotorSpeed(50,50);
BackLED(OFF,OFF);
StatusLED(OFF);
FrontLED(OFF);
Msleep(200);

MotorDir(BREAK,BREAK);
BackLED(ON,ON);
StatusLED(RED);
FrontLED(ON);
Msleep(200);
}
dunkel=0;
}

/*****************************Hauptprogrammbeginn** ****************************/

int main (void)
{
Init (); // Prozessor initialisieren

StatusLED(RED); // 3 Sekunden Countdown zum Start,
Msleep(1000);
StatusLED(YELLOW); // Status Led wird im Sekundentakt
Msleep(1000);
StatusLED(GREEN); // von Rot über Gelb zu Grün geschaltet
Msleep(1000);
FrontLED(ON);
switched = 0; // Kollisionserkennung auf 0 setzen
StartSwitch (); // Taster-Interrupt aktivieren


/********************Endlosschleife für Zustandsabfrage************************/

while(1)
{

/******************Wenn 1. Kollision, dann Rechtskurve 90°*********************/

if ((switched == 1)&&(Gettime()>meineZeit+1000)&&(Gettime()>meineZeit2+600))
{
Firstcol();
}
/*********Wenn 2. Kollision innerhalb 1s nach abarbeitung von Firstcol*******/

else if ((switched == 1)&&(Gettime()<meineZeit+1000))
{
Secondcol();
}

/********Wenn 3. Kollision innerhalb 0,6s nach abarbeitung von Secondcol*******/

else if ((switched == 1)&&(Gettime()<meineZeit2+600))
{
Thirdcol();
}

/**************************Wenn umgebung zu dunkel*****************************/

else if(dunkel==1)
{
Ziel();
}

/*********************Wenn keine Kollision, Fahre normal***********************/

else
{
Fahren();
}


}

/*********************Endlosschleife - Ende des Programmes*********************/
/*****Um zu verhindern, dass eventuell alte Programmteile aufgerufen werden****/
/*********************die sich noch im Speicher befinden***********************/

while(1);
return 0;
}


Folgende Dinge müsst ihr beim Bau des Labyriths beachten!!!
1. Es muss rechtwinklig aufgebaut sein
2. Bei Sackgassen muss der Lösungsweg gegenüber der Sackgasse liegen

Bei Meinem Asuro hab ich folgendes verbessert:
1. Odometriesensoren abgedunkelt mit schwarzem Papier
2. Die Odometriescheiben(12er) habe ich mit hilfe von Kabelisolierung, die ich über die Welle geschoben habe befestigt um den Abstand zu den Sensoren gleich zu halten.

Hab euch noch 2 Bilder von den Verbesserungen und das .hex file gepostet und ein kleines Video bei Youtube hoch geladen.

Videolink: http://www.youtube.com/watch?v=JB6F8HWTHLE

So nun wünsch ich euch viel Spass und Erfolg mit dem Code.

P.S. Das Programm funktioniert nur mit der aktuellen, erweiterten Lib aus dem Roboternetz Forum.

Ein großes danke Schön an die, die die Lib entwickeln, einfach spitze was ihr da mittlerweile auf die Beine gestellt habt.

Gruß
G3tzR@zor

[Valen]

Super!!!

[Sternthaler]

Auch ein SUPER von mir.

Gruß Sternthaler

[Valen]

Ein bisschen spät, vindest du nicht Sternthaler? ;)