int test03(void)
{
int n;
Init();
StatusLED(XGN);
FrontLED(ON);
BackLED(ON, ON);
MotorDir(BREAK, FREE);
MotorSpeed(150,80);
while(1)
{
BackLED(OFF, OFF);
StatusLED(XGN);
for (n=1; n<100; n++) Sleep(255);
StatusLED(XRD);
for (n=1; n<100; n++) Sleep(255);
}
return 0;
}
void readData(){
if (usart_byte_avail_intr() == 1)
{
ReadData[0] = (unsigned char)usart_getc_intr();
//usart_putc(ReadData[0]);
if ((ReadData[0] == 'G') /*&& (usart_string_avail_intr() == 1)*/)
{
StatusLED(OFF);
//usart_puts(" IF_G \r\n");
//usart_putc(ReadData[0]);
int i=1;
while (ReadData[i] != 'E' && usart_byte_avail_intr() == 1)
{
ReadData[i]=usart_getc_intr();
//usart_putc(ReadData[i]);
i++;
StatusLED(GREEN);
//usart_putc('M');
}
//usart_putc('N');
}
//usart_puts("Asuro: " + ReadData[0]);
}
}
/**
* @brief Funktion Ausweichen
*
* Der Asuro benutzt den Ultraschall um die Umgebung zu scannen und weicht
* jedem Hinderniss mit einer Rechtsdrehung aus und fährt weiter geradeaus.
*
* @param Speed Die Fahrgeschwindigkeit
* @return Kein Rückgabewert(void)
*
*/
void Ausweichen(uint16_t Speed)
{
sei();
/*~~~~~~~~~~*/
int pos, i;
int posmarker;
/*~~~~~~~~~~*/
TextAusgabe("Vor Ping");
TextAusgabe(CR);
posmarker = 0;
Ping(20);
TextAusgabe("Nach PING");
TextAusgabe(CR);
for (pos = 0; pos < 1000; pos++)
{
TextAusgabe("In der ersten For-schleife");
TextAusgabe(CR);
/* 1000 = die maximale Entfernung */
_delay_us(10);
if ((ACSR & (1 << ACI)) != 0)
{
TextAusgabe("Im ersten if");
TextAusgabe(CR);
/* Wenn Register ACI von ACSR nicht gesetzt ist dann.. */
if (posmarker == 0)
{
TextAusgabe("Im zweiten if");
TextAusgabe(CR);
posmarker = pos;
} /* Wenn posmarker = 0 ist dann pos und posmarker gleichsetzen */
}
TextAusgabe("Vor ACSR");
ACSR |= (1 << ACI); /* Das Bit ACI setzen. Damit es durch einen Interrupt gel�scht werden kann */
}
if (posmarker < 200)
{
TextAusgabe("Im dritten if");
TextAusgabe(CR);
/* Wenn ein Hinderniss im Bereich von 200 ist */
StatusLED(Rot); /* StatusLed leuchtet Rot */
Motor(BREAK, BREAK, 0, 0); /* Motor kurz anhalten */
Motor(FWD, BWD, 0, 255); /* Linkes Rad vorw�rts und Rechtes R�ckw�rts(Ausweichen) */
}
else
{
TextAusgabe("Im else");
TextAusgabe(CR);
StatusLED(Gruen); /* LED Gr�n */
Motor(FWD, FWD, Speed, Speed); /* Motoren f�hrt geradeaus */
for (i = 0; i < 100; i++)
{
TextAusgabe("Im zweiten for");
TextAusgabe(CR);
_delay_ms(1);
} /* kurze Pause */
}
}
int main()
{
uint16_t n;
unsigned char direction=FWD,inv_direction=RWD;
// ASURO initialisieren
Init();
//Text aus FLASH ausgeben
SerPrint_p(PSTR("Hello World!\n"));
//Puffer im SRAM für Kommandos
uint8_t buff;
StatusLED(OFF);//GREEN,RED,YELLOW,OFF
while(1)
{
SerRead(&buff,1,0);
if(buff=='1')
{
StatusLED(RED);
}
else if(buff=='2')
{
StatusLED(GREEN);
}
else if(buff=='3')
{
StatusLED(YELLOW);
}
// Fügen Sie hier die noch fehlenden Kommandos ein
// Für das Martinshorn Kommando verwenden Sie bitte die Funktion Sound() der AsuroLib. Schauen Sie sich die Dokumentation dieser Funktion an.
// Eine Iterations des Martinshorns soll so programmiert werden, dass für 500ms ein Ton mit einer Frequenz von 410Hz und dann für 500ms ein Ton mit einer Frequenz von 547Hz abgespielt wird.
// Beide Töne sollen mit maximaler Amplitude abgespielt werden. Wiederholen Sie die Tonfolge 5x.
else
{
StatusLED(OFF);
}
}
while(1);
return 0;
}
int test05(void)
{
int n, s, light;
char key;
Init();
StatusLED(XGN);
FrontLED(ON);
BackLED(ON, ON);
//SerWrite("Begin...", 8);
//SerWrite("Waiting for command... ", 23);
SerRead(key, 1, 0);
if (key == 'g')
{
SerWrite("Good Morning... Starting...", 27);
}
else
{
SerWrite("So... just start... ", 20);
}
while(1)
{
for (s=80; s<300; s+=10)
{
SerWrite("Looping... ", 11);
MotorDir(FWD, RWD);
MotorSpeed(150,s);
SerWrite("Sleep Now! ", 11);
for (n=1; n< 100; n++) Sleep(255);
if (s > 200)
{
SerWrite("S>200 ", 6);
s=80;
}
}
}
return 0;
}
/* LED Test */
void ledtest(void)
{
StatusLED(RED);
delayms(300);
StatusLED(GREEN);
delayms(100);
StatusLED(YELLOW);
delayms(50);
StatusLED(OFF);
delayms(1000);
FrontLED(ON);
delayms(200);
BackLED(ON, ON);
delayms(500);
FrontLED(OFF);
BackLED(OFF, OFF);
delayms(500);
}
int test01(void)
{
Init();
StatusLED(XGN);
FrontLED(ON);
BackLED(ON, ON);
MotorDir(BREAK, FREE);
MotorSpeed(150,80);
while(1);
return 0;
}
int test02(void)
{
Init();
StatusLED(XGN);
FrontLED(ON);
BackLED(ON, ON);
MotorDir(FWD, RWD);
MotorSpeed(150,80);
while(1);
return 0;
}
int test04(void)
{
int n;
Init();
StatusLED(XRD);
FrontLED(ON);
BackLED(ON, ON);
MotorDir(FREE, FREE);
MotorSpeed(150, 150);
for (n=1; n<200; n++) Sleep(255);
StatusLED(XGN);
FrontLED(OFF);
BackLED(OFF, OFF);
for (n=1; n<50; n++) Sleep(255);
while(1)
{
StatusLED(XGN);
BackLED(OFF, OFF);
FrontLED(ON);
MotorDir(FWD, FWD);
for (n=1; n<500; n++) Sleep(255);
StatusLED(XRD);
BackLED(OFF, OFF);
FrontLED(OFF);
MotorDir(BREAK, BREAK);
for (n=1; n<100; n++) Sleep(255);
StatusLED(XGN);
BackLED(ON, ON);
FrontLED(OFF);
MotorDir(RWD, RWD);
for (n=1; n<500; n++) Sleep(255);
StatusLED(XRD);
BackLED(OFF, OFF);
FrontLED(OFF);
MotorDir(BREAK, BREAK);
for (n=1; n<100; n++) Sleep(255);
}
return 0;
}
/* Init function Processor will be initalized to work correctly */
void Init (void)
{
//-------- seriell interface programmed in boot routine and already running -------
// prepare 36kHz for IR - Communication
TCCR2 = (1 << WGM21) | (1 << COM20) | (1 << CS20);
OCR2 = 0x6E; // 36kHz @8MHz
TIMSK |= (1 << OCIE2); // 36kHz counter for sleep
// prepare RS232
UCSRA = 0x00;
UCSRB = 0x00;
UCSRC = 0x86; // No Parity | 1 Stop Bit | 8 Data Bit
UBRRL = 0xCF; // 2400bps @ 8.00MHz
// I/O Ports
DDRB = IRTX | LEFT_DIR | PWM | GREEN_LED;
DDRD = RIGHT_DIR | FRONT_LED | ODOMETRIE_LED | RED_LED;
// for PWM (8-Bit PWM) on OC1A & OC1B
TCCR1A = (1 << WGM10) | (1 << COM1A1) | (1 << COM1B1);
// tmr1 running on MCU clock/8
TCCR1B = (1 << CS11);
// A/D Conversion
ADCSRA = (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1); // clk/64
ODOMETRIE_LED_OFF;
FrontLED(OFF);
BackLED(ON,ON);
BackLED(OFF,OFF);
StatusLED(GREEN);
MotorDir(FWD,FWD);
MotorSpeed(0,0);
sei();
}
void Lichtorgel(void){
MotorDir(FWD,BWD);
MotorSpeed(255,255);
for(int q = 0; q < 15; q++){
StatusLED(GREEN);
msleep(50);
BackLED(ON,OFF);
msleep(50);
StatusLED(RED);
msleep(50);
BackLED(OFF,ON);
msleep(50);
StatusLED(YELLOW);
msleep(50);
FrontLED(ON);
msleep(50);
FrontLED(OFF);
}
MotorDir(BREAK,BREAK);
MotorSpeed(0,0);
while(1){
StatusLED(GREEN);
msleep(50);
BackLED(ON,OFF);
msleep(50);
StatusLED(RED);
msleep(50);
BackLED(OFF,ON);
msleep(50);
StatusLED(YELLOW);
msleep(50);
FrontLED(ON);
msleep(50);
FrontLED(OFF);
}
}
void StereoSound(uint16_t *noten1, uint16_t *noten2)
{
uint16_t index1=0,index2=0;
uint16_t timer1,timer2;
uint16_t phase1,phase2,angle1,angle2;
uint8_t dir1=FWD,dir2=FWD;
uint8_t speed1,speed2;
FrontLED(OFF);
BackLED(OFF,OFF);
StatusLED(OFF);
angle1=(uint32_t)noten1[index1++]*65536/FS;
timer1=noten1[index1++]*(FS/1000);
if(angle1==0)speed1=0;
else speed1=255;
angle2=(uint32_t)noten2[index2++]*65536/FS;
timer2=noten2[index2++]*(FS/1000);
if(angle2==0)speed2=0;
else speed2=255;
MotorSpeed(speed1,speed2);
cli(); // stop all interrupts
while(timer1!=0)
{
timer1--;
timer2--;
if(timer1==0)
{
angle1=(uint32_t)noten1[index1++]*65536/FS;
timer1=noten1[index1++]*(FS/1000);
if(angle1==0)speed1=0;
else speed1=255;
MotorSpeed(speed1,speed2);
}
if(timer2==0)
{
angle2=(uint32_t)noten2[index2++]*65536/FS;
timer2=noten2[index2++]*(FS/1000);
if(angle2==0)speed2=0;
else speed2=255;
MotorSpeed(speed1,speed2);
}
phase1+=angle1;
if(phase1&0x8000) dir1=FWD;
else dir1=RWD;
phase2+=angle2;
if(phase2&0x8000) dir2=FWD;
else dir2=RWD;
MotorDir(dir1,dir2);
// sync with Timer2 ( 31250Hz )
while(!(TIFR&(1<<TOV2)));
TIFR|=TIFR&(1<<TOV2);
}
MotorSpeed(0,0);
sei(); // enable all interrupts
}
void main(void) {
Init();
FrontLED(ON);
int i=0;
int linienEnde = 0;
int fast = 200;
unsigned int stData = 0, schwarz = 0;
//Weißwert festlegen
unsigned int data[2];
LineData(data);
stData = data[LEFT] + data[RIGHT] + 50;
StatusLED(GREEN);
msleep(3000);
StatusLED(YELLOW);
//Schwarzwert setzen
LineData(data);
schwarz = data[LEFT] + data[RIGHT];
msleep(1000);
StatusLED(GREEN);
MotorSpeed(fast,fast);
StatusLED(YELLOW);
while(1){
LineData(data);
if(data[LEFT] > data[RIGHT]){
MotorDir(FWD,FREE);
BackLED(ON,OFF);
}else if(data[RIGHT] > data[LEFT]){
MotorDir(FREE,FWD);
BackLED(OFF,ON); ;
}
if(data[LEFT]+data[RIGHT]>stData){
StatusLED(RED);
i++;
}else{
i=0;
StatusLED(YELLOW);
}
if(i>100){
linienEnde = 1;
}
while(linienEnde){
MotorDir(FWD,RWD);
LineData(data);
if(data[LEFT]+data[RIGHT] < schwarz+100){
MotorDir(BREAK,BREAK);
msleep(50);
while(linienEnde){
MotorSpeed(80,80);
MotorDir(RWD,FWD);
LineData(data);
if(data[LEFT] + data[RIGHT] < schwarz+100){
linienEnde = 0;
}
}
MotorSpeed(fast,fast);
}
}
Kollision();
}
}
/*!
\brief
Initialisiert die Hardware: Ports, A/D Wandler, Serielle Schnittstelle, PWM\n
Die Init Funktion muss von jeden Programm beim Start aufgerufen werden
\see
Die Funktionen Sleep() und Msleep() in time.c werden mit dem hier\n
eingestellten 36 kHz-Takt betrieben.\n
\par Funktionsweise der Zeitfunktionen:
Msleep() ruft Sleep() auf. In Sleep() wird die globale Variable count36kHz\n
zur Zeitverzoegerung benutzt. Diese Variable wird jedesmal im Interrupt\n
SIG_OVERFLOW2 um 1 hochgezaehlt.\n
Der Interrupt selber wird durch den hier eingestellten Timer ausgeloesst.\n
Somit ist dieser Timer fuer die Zeitverzoegerung zustaendig.
\see
Die globale Variable autoencode fuer die automatische Bearbeitung der\n
Odometrie-ADC-Wandler wird hier auf FALSE gesetzt.
\par Hinweis zur 36 kHz-Frequenz vom Timer 2
Genau diese Frequenz wird von dem Empfaengerbaustein benoetigt und kann\n
deshalb nicht geaendert werden.\n
In der urspruenglichen, vom Hersteller ausgelieferten LIB, war diese\n
Frequenz allerdings auf 72 kHz eingestellt. Durch eine geschickte\n
Umkonfigurierung durch waste konnte diese aber halbiert werden.\n
Sinnvoll ist dies, da der durch diesen Timer2 auch ausgeloesste Timer-\n
Interrupt dann nur noch die Haelfte an Rechenzeit in Anspruch nimmt.
\par Beispiel:
(Nur zur Demonstration der Parameter/Returnwerte)
\code
// Die Init()-Funktion MUSS IMMER zu Anfang aufgerufen werden.
int main (void)
{
int wert;
Init ();
while (1)
(
// Dein Programm
}
return 0;
}
\endcode
*****************************************************************************/
void Init (
void)
{
/*
Timer2, zum Betrieb mit der seriellen Schnittstelle, fuer die
IR-Kommunikation auf 36 kHz eingestellt.
*/
#if defined(__AVR_ATmega168__)
// fast PWM, set OC2A on compare match, clear OC2A at bottom, clk/1
TCCR2A = _BV(WGM20) | _BV(WGM21) | _BV(COM2A0) | _BV(COM2A1);
TCCR2B = _BV(CS20);
// interrupt on timer overflow
TIMSK2 |= _BV(TOIE2);
#else
// fast PWM, set OC2A on compare match, clear OC2A at bottom, clk/1
TCCR2 = _BV(WGM20) | _BV(WGM21) | _BV(COM20) | _BV(COM21) | _BV(CS20);
// interrupt on timer overflow
TIMSK |= _BV(TOIE2);
#endif
// 36kHz carrier/timer
OCR2 = 0x91;
/*
Die serielle Schnittstelle wurde waerend der Boot-Phase schon
programmiert und gestartet. Hier werden die Parameter auf 2400 1N8 gesetzt.
*/
#if defined(__AVR_ATmega168__)
UBRR0L = (uint8_t)(F_CPU/(BAUD_RATE*16L)-1);
UBRR0H = (F_CPU/(BAUD_RATE*16L)-1) >> 8;
UCSR0B = (1<<RXEN0) | (1<<TXEN0);
UCSR0C = (1<<UCSZ00) | (1<<UCSZ01);
#else
UBRRH = (((F_CPU/BAUD_RATE)/16)-1)>>8; // set baud rate
UBRRL = (((F_CPU/BAUD_RATE)/16)-1);
UCSRB = (1<<RXEN)|(1<<TXEN); // enable Rx & Tx
UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // config USART; 8N1
#endif
/*
Datenrichtung der I/O-Ports festlegen. Dies ist durch die Beschaltung der
Asuro-Hardware nicht aenderbar.
Port B: Seriell Senden; Richtungsvorgabe Motor links; Takt fuer die
Geschwindigkeit beider Motoren; Grueneanteil-Status-LED
Port D: Richtungsvorgabe Motor rechts; Vordere LED;
Odometrie-LED (Radsensor); Rotanteil-Status-LED
*/
DDRB = IRTX | RIGHT_DIR | PWM | GREEN_LED;
DDRD = LEFT_DIR | FRONT_LED | ODOMETRIE_LED | RED_LED;
/*
PWM-Kanaele OC1A und OC1B auf 8-Bit einstellen.
Sie werden fuer die Geschwindigkeitsvorgaben der Motoren benutzt.
*/
TCCR1A = _BV(WGM10) | _BV(COM1A1) | _BV(COM1B1);
TCCR1B = _BV(CS11); // tmr1-Timer mit MCU-Takt/8 betreiben.
/*
Einstellungen des A/D-Wandlers auf MCU-Takt/64
*/
ADCSRA = _BV(ADEN) | _BV(ADPS2) | _BV(ADPS1);
/*
Sonstige Vorbereitungen.
- Alle LED's ausschalten
- Motoren stoppen und schon mal auf Vorwaerts einstellen.
- Globale Variable autoencoder ausschalten.
*/
ODOMETRIE_LED_OFF;
FrontLED (OFF);
BackLED (ON, ON);
BackLED (OFF, OFF);
StatusLED (GREEN);
MotorDir (FWD, FWD);
MotorSpeed (0, 0);
autoencode = FALSE;
Ovr2IntFunc = 0;
AdcIntFunc = 0;
/*
Funktion zum ALLGEMEINEN ZULASSEN von Interrupts.
*/
sei ();
}
