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 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);
}
}
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 main(void) {
Init();
syd_message("Line Counter");
FrontLED(ON);
while (1) {
check_buttons();
calibrate();
count();
}
return 0;
}
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;
}
void bcr_initBarcodeReader(void) {
EncoderInit();
MotorDir(FWD,FWD);
FrontLED(ON);
lineCounter = 0;
rawCounter = 0;
latestLineData = 0;
unsigned int tmp[2];
util_getStableLineData(tmp);
tolFactor = getToleranceValue(tmp[LEFT] + tmp[RIGHT]);
int i;
util_pauseInterrupts();
for(i = 0; i < (M_RAW_DATAPOINTS * M_WINDOW_SIZE); i++) {
measureDataPoint();
Msleep(5);
}
ts_init();
ts_addFunction(&measureDataPoint, M_SAMPLING_FREQ);
sei();
}
/* 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 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 ();
}
void checkData() {
//-----------------------------------------------vorwärts
if(ReadData[0] == 'W')
{
DirLeft = FWD;
DirRight = FWD;
//BackLED(ON,ON);
//FrontLED(OFF);
//usart_putc(ReadData[0]);
}
//----------------------------------------------rückwärts
else if (ReadData[0] == 'S')
{
DirLeft = RWD;
DirRight = RWD;
//BackLED(ON, ON);
//FrontLED(ON);
//usart_putc(ReadData[0]);
}
//-----------------------------------------------links
else if (ReadData[0] == 'A')
{
DirLeft = RWD;
DirRight = FWD;
//BackLED(ON,OFF);
//FrontLED(OFF);
/*usart_putc('L');
usart_puti((int) SollSpeedLeft, 3);*/
//usart_putc(ReadData[0]);
}
//-----------------------------------------------rechts
else if (ReadData[0] == 'D')
{
DirLeft = FWD;
DirRight = RWD;
//BackLED(OFF, ON);
//FrontLED(OFF);
/*usart_putc('R');
usart_puti((int) SollSpeedRight, 3);*/
//usart_putc(ReadData[0]);
}
//-----------------------------------------------Speed
else if (ReadData[0] == 'G')
{
SollSpeedLeft = (char) atol(ReadData +1);
int i=1;
while (ReadData[i] != 'Z')
{
i++;
}
SollSpeedRight = (char) atol(ReadData +i+1);
IstSpeedLeft = SollSpeedLeft;
IstSpeedRight = SollSpeedRight;
/*usart_putc(ReadData[0]);
usart_putc('L');
usart_puti((int) SollSpeedLeft, 3);
usart_putc('R');
usart_puti((int) SollSpeedRight, 3);
usart_puts("\r\n");*/
}
//-------------------------------------------------Regler
else if (ReadData[0] == 'R')
{
KP = (char) atol(ReadData +1);
int i=1;
while (ReadData[i] != 'Z')
{
i++;
}
KI = (char) atol(ReadData +i+1);
while (ReadData[i] != 'Y')
{
i++;
}
KD = (char) atol(ReadData +i+1);
/*usart_putc(ReadData[0]);
usart_putc('P');
usart_puti((int) rpm_p, 3);
usart_putc('I');
usart_puti((int) rpm_i, 3);
usart_putc('D');
usart_puti((int) rpm_d, 3);
usart_puts("\r\n");*/
}
//------------------------------------------------keine Zeichen empfangen
else if (ReadData[0] == 'X')
{
DirLeft = FREE;
DirRight = FREE;
FrontLED(OFF);
BackLED(OFF, OFF);
//StatusLED(YELLOW);
}
//-----------------------------------------------Handshake
else if (ReadData[0] == 'h')
{
usart_puts("Handshake \r\n");
usart_puts("\r\n");
}
}
