Elvis

Raczej nie spaliłeś, tylko źle ci doradzili. Optotriak będzie działał tylko z prądem przemiennym. Triak uruchamiany jest prądem bramki, niestety do wyłączenia konieczne jest wyłączenie zasilania. W przypadku prądu przemiennego triak wyłączany jest przy przejściu przez zero. Jeśli podłączyłeś do prądu stałego, to raz włączony będzie przewodzić, aż do wyłączenia zasilania.

Uruchomiłem program na płytce olimex-a z atmega128 (http://olimex.com/dev/pdf/AVR/AVR-MT-128-SCH-REV-A.pdf). Konieczne były drobne zmiany, ale działa: // PROGRAM OBSLUGUJACY WYSWIETLACZ LCD (2X16 ZNAKOW) // // Atmega16, 4Mhz, // ///////////////////////////////////////////////////// //-------------------------------------------------- // Biblioteki: #include <avr/io.h> #include <inttypes.h> #define F_CPU 4000000 #include <util/delay.h> //-------------------------------------------------- // Makra upraszczajace dostep do portow: #define PORT(X) XPORT(X) //podanie w programie: PORT(D) zinterpretuje jako "PORTD" #define XPORT(X) (PORT##X) #define PIN(X) XPIN(X) #define XPIN(X) (PIN##X) #define DDR(X) XDDR(X) #define XDDR(X) (DDR##X) //-------------------------------------------------- // Definicje wyprowadzen: #define LCD_RS 0 #define LCD_RSPORT C #define LCD_RW 1 #define LCD_RWPORT C #define LCD_E 2 #define LCD_EPORT C #define LCD_DPORT C #define LCD_D4 4 //-------------------------------------------------- // Komendy sterujace wyswietlaczem: #define LCDC_CLS 0x01 #define LCDC_HOME 0x02 #define LCDC_MODE 0x04 #define LCDC_MODER 0x02 #define LCDC_MODEL 0 #define LCDC_MODEMOVE 0x01 #define LCDC_ON 0x08 #define LCDC_ONDISPLAY 0x04 #define LCDC_ONCURSOR 0x02 #define LCDC_ONBLINK 0x01 #define LCDC_SHIFT 0x10 #define LCDC_SHIFTDISPLAY 0x08 #define LCDC_SHIFTR 0x04 #define LCDC_SHIFTL 0 #define LCDC_FUNC 0x20 #define LCDC_FUNC8b 0x10 #define LCDC_FUNC4b 0 #define LCDC_FUNC2L 0x08 #define LCDC_FUNC1L 0 #define LCDC_FUNC5x10 0x4 #define LCDC_FUNC5x7 0 #define LCDC_CGRAM 0x40 #define LCDC_DDRAM 0x80 //--------------------------------------------------- // Definicje opoznien: void delay250ns() { volatile int i; for (i=0;i<2;i++) i=i; } #define delayus8(t)\ {asm volatile( \ "delayus8_loop%=: \n\t"\ "nop \n\t"\ "dec %[ticks] \n\t"\ "brne delayus8_loop%= \n\t"\ : :[ticks]"r"(t) );} //DEC - 1 cykl; BRNE - 2 cykle; +1 x nop; Zegar 4Mhz void delay100us8(uint8_t t) { while(t>0) { delayus8(100) --t; } } //------------------------------------------------- // Funkcje niskiego poziomu: #define LCD_EPULSE() \ {PORT(LCD_EPORT) |= 1<<LCD_E; \ delay250ns(); \ PORT(LCD_EPORT) &= ~(1<<LCD_E);} // LCD_EPULSE - strobuje dostep do wyswietlacza (zalaczamy czas na pobranie danych lub rozkazow) void LCD_sendHalf(uint8_t data) { data = (data & 0x0F) << LCD_D4; PORT(LCD_DPORT) = (PORT(LCD_DPORT) & ~(0x0F<<LCD_D4)) | data; LCD_EPULSE(); } void LCD_send(uint8_t data) { LCD_sendHalf(data>>4); //starsza czesc LCD_sendHalf(data); //mlodsza czesc delayus8(120);//120 us } //------------------------------------------------- // Funkcje wysylajace komendy i dane: void LCD_command(uint8_t command) { PORT(LCD_RSPORT) &= ~(1<<LCD_RS); //przeslanie instrykcji; RS = 0 LCD_send(command); } void LCD_data(uint8_t data) //przeslanie danych do DD RAM; RS = 1 { PORT(LCD_RSPORT) |= 1<<LCD_RS; LCD_send(data); } void LCD_cls(void) //czyszczenie wyswietlacza { LCD_command(LCDC_CLS); delay100us8(48); } void LCD_home(void) //ustawianie wyswietlacza w pozycji home { LCD_command(LCDC_HOME); delay100us8(50); } //------------------------------------------------- // Inicjacja Wyswietlacza: void LCD_init(void) { delay100us8(150); PORT(LCD_RSPORT) &= ~(1<<LCD_RS); LCD_sendHalf((LCDC_FUNC | LCDC_FUNC8b)); delay100us8(41); LCD_sendHalf((LCDC_FUNC | LCDC_FUNC8b)); delay100us8(2); LCD_sendHalf((LCDC_FUNC | LCDC_FUNC4b)); //teraz jest juz 4b, koniec korzystania z sendHalf LCD_command(LCDC_FUNC | LCDC_FUNC4b | LCDC_FUNC2L | LCDC_FUNC5x7); LCD_command(LCDC_ON); LCD_cls(); LCD_command(LCDC_MODE | LCDC_MODEL); LCD_command(LCDC_ON | LCDC_ONDISPLAY); } //------------------------------------------------- //PETLA GLOWNA: int main(void) { //inicjalizacja portow DDR(LCD_DPORT) |= 1<<LCD_E | 1<<LCD_RW | 1<<LCD_RS | 0x0F<<LCD_D4; PORT(LCD_RWPORT) &= ~(1<<LCD_RW); DDRA |= 1<<0;//podciagniecie diodki sprawdzajacej czy program przejdzie _delay_ms(100); //przygotowanie wyswietlacza LCD_init(); //podanie danych na wyswietlacz LCD_cls(); LCD_data('H'); LCD_data('E'); LCD_data('L'); LCD_data('L'); LCD_data('O'); PORTA |= 1<<0;//wl. diodki sprawdzajacej while (1) ; return 0; } [ Dodano: 31 Mar 10 10:20 ] Definicję F_CPU należy oczywiście przenieść do pliku make, ale na szybko jest w kodzie. Musiałem dodać opóźnienie przed inicjalizacją lcd - 100ms, inaczej czasem pojawiały się krzaki. Zmieniłem procedurę opóźniającą. Lepiej użyć _delay_us zamiast niej. To co było nie chciało mi się kompilować. Dodałem jeszcze obsługę pinu RW - płytka olimex ma wyprowadzony, więc musiałem go wyzerować. Jeszcze jedna zmiana to dodanie LCD_cls() przed wyświetlaniem napisu. Inaczej wyświetlał tylko 'H'. Kod powinien działać, jeśli nie, to sprawdź czy hardware jest na pewno sprawny.

No właśnie - brakuje jeszcze pętli na końcu. dodaj while (1); przed ostatnim return

LCD_sendHalf((LCDC_FUNC | LCDC_FUNC8b)<<LCD_D4); LCD_sendHalf((LCDC_FUNC | LCDC_FUNC8b)<<LCD_D4); LCD_sendHalf((LCDC_FUNC | LCDC_FUNC4b)<<LCD_D4); Niepotrzebne są < #define LCDC_FUNC 0x20 #define LCDC_FUNC8b 0x10 #define LCDC_FUNC4b 0

Takie aktywne czekanie ma kilka poważnych wad. Po pierwsze jest mało dokładne. Jeśli w trakcie wystąpi przerwanie, to czas będzie inny. Dla 1-wire może to mieć znaczenie, więc trzeba wyłączać przerwania czekając, co z kolei może powodować problemy procedur działających na przerwaniach. Dodatkowy problem to pobór prądu. Procesory ARM potrafią sporo pobrać. W końcu 60MHz to sporo. Więc czekanie w pętli to marnowanie czasu i prądu. Najlepiej jest uruchomić timer i uśpić procesor. Wtedy mamy dokładność działania, brak opóźnień przerwań i oszczędność prądu.

Jak chodzi o biblioteki to niestety na arm jest trudniej. Nigdy nie używałem, ale znalazłem bibliotekę ArmLib - http://hubbard.engr.scu.edu/embedded/arm/armlib/index.html , w niej jest trochę funkcji, które wydają się ciekawe. Najprościej opóźnienie zrobić na pętli - oscyloskopem wyregulować i chodzi. Niestety dokładność jest wtedy bardzo słaba. Jeśli opóźnienia maja być dokładnie mierzone pozostaje użyć timer. LPC21xx ma 2 timery. Można wykorzystać jeden do tworzenia opóźnień, albo wprowadzić globalny licznik czasu i za jego pomocą tworzyć opóźnienia. Jest jeszcze jedna możliwość, uruchomić RTOS, np. FreeRTOS - http://www.freertos.org/ . Dopiero wtedy procesor nie będzie marnował czasu czekając aktywnie w pętlach.

Sorki, jeśli źle zrozumiałem. Nie chodziło mi o piekarnik, tylko o piec do montażu elementów smd.

SeerKaza, to ty gadasz głupoty. Obudowy TQFP64 (SMD, raster 0.5mm) da się lutować zwykłą lutownicą. Ja nie próbowałem, ale widziałem jak inni lutują - więc da się. Natomiast BGA raczej nie da się zlutować w domowych warunkach. Gorące powietrze nie podgrzeje wszystkich padów równomiernie. Poza tym konieczna byłaby kontrola temperatury. O ile wiem konieczny jest piec. [ Dodano: 29 Mar 10 09:25 ] Jednak ludzie wszystko domowymi metodami zrobią: http://www.elektroda.pl/rtvforum/topic73518.html Ale i tak łatwiej poradzić sobie z LQFP. Tak, czy inaczej jest to dużo wyższa szkoła jazdy niż AVR, nawet w smd. Samo wykonanie płytki pod taki procesor to trudna sprawa. Więc trzeba zamawiać pcb - a to kosztuje i trwa. Dla BGA konieczne są płytki wielowarstwowe, więc kosztuje jeszcze więcej.

Właśnie błędy konkretnych procesorów mi chodziło, nie o cały rdzeń. Ale to w każdym procesorze się zdarza. Jak chodzi o stm32lib to jest rzeczywiście super łatwo programować, niestety kosztem wydajności. Chciałem sprawdzić, czy na prawdę I/O mają prędkość 50MHz. Przy stm32lib prędkość max to ok. 2-3MHz. Dopiero bezpośredni zapis do rejestrów + maksymalna optymalizacja dało 50MHz. Ale i tak biblioteka bardzo przyjemna.

Bardzo polecam cortex-m3. Co prawda nie są pozbawione błędów, ale wiele rozwiązań jest udoskonalonych w porównaniu z ARM7. Testowałem STM32 oraz NXP (LPC176x) i osobiście wolę NXP - głównie ze względu na doświadczenie w programowaniu LPC2148. Natomiast dużym plusem STM32 jest standardowa biblioteka oferowana przez producenta. Jak chodzi o kompilatory, to coraz lepiej radzi sobie z nowymi procesorami gcc. Polecam środowisko Rowley (CorssStudio) - bardzo łatwo rozpocząć przygodę z nowymi procesorami. Natomiast jak chodzi o darmowe narzędzia, to CortexM3 mają standardową bibliotekę obsługi dostarczaną przez ARM oraz STM32 mają dedykowaną bibliotekę producenta. Główny problem moim zdaniem to obudowy - raster 0.5mm nie jest łatwy w domowych warunkach. Oczywiście tylko SMD, przewlekanych procesorów brak Najtańsze moduły z zalutowanymi procesorami ma w ofercie (chyba) propox. jednak taki moduł to już wydatek rzędu 90-100zł.

To ja głosuję, że winny jest brak diód w mostku. Kiedyś testowałem silnik krokowy w podobnym układzie - indukowało się ponad 100V... Ale najlepiej sprawdzić podłączając diody, jak zacznie działać, to będzie odpowiedź.

Ja bym proponował jeszcze raz sprawdzić, czy to nie problem z zasilaniem. Spróbuj odłączyć silniki i ręcznie "pochodzić" chwilę robotem. Jeśli nie będzie się resetował, to może jednak skoki zasilania - kondensatory powinny pomóc. Jak nadal będzie problem, to proponuję bardzo skrócić program - najpierw zrobić jazdę bez czujników - np. 2sek prosto, 2 sek w prawo 2 sek w lewo. Póżniej dodać obsługę 1 czujnika i zobaczyć czy działa. Dalej kolejno dodawać następne czujniki - jak się popsuje to będzie wiadomo gdzie szukać błędu.

Strasznie kombinujesz. Na pewno nie byłoby łatwo. Gdybyś po prostu podłączył tranzystor pnp do wyjścia procesora, to niezależnie od stanu linii procesora tranzystor by przewodził. Musiałbyś mieć wyjście open-colector oraz rezystor podciągający. Z open-colector można sobie jeszcze poradzić (sztuczka jak przy i2c, zamiast wystawiania 1, zmiana kierunku działania portu), ale pull-up nie wiem, czy nie byłby szkodliwy dla procesora. Ja polecam wersję: bipolarny npn, polowy z kanałem P.

co do bipolarnych to tak, ale BUZ11 jest ma kanał N więc nie polecam.

Na mój gust to przepełniasz stos. Funkcja Jedz wywołuje np. Prosto, następnie prosto wywołuje Jedz. Zamiast Call używaj Goto (tak przynajmniej jest w Basic-u, bo Bascom-a nigdy nie używałem). Jeśli używasz Call, to na końcu procedury musi być z niej powrót (pewnie przez Return).

Moim zdaniem polecony IRLZ44 nie najlepiej się nadaje. Nie wiem jaki schemat chcesz zastosować, ale najlepszym rozwiązaniem jest zaproponowane przez madman07-a. Czyli tranzystor npn, którym wysterujesz MOSFET. Wtedy nie jest potrzebny model "L". IRLZ44 się nie nadaje, bo potrzebny będzie MOSFET z kanałem P, a nie N. Takie rozwiązanie sprawdzałem na 12V, działa bardzo dobrze. Jeśli zastosujesz MOSFET z kanałem N, to obie części układu nie będą miały wspólnej masy. Może to być akceptowalne, i wtedy IRLZ44 nie stanowi problemu.

A jaki prąd płynie przez to 24V? Bo jeśli przewidujesz większy pobór prądu oraz rzadkie przełączanie, to może zwykły przekaźnik?

Ponieważ sporo osób pyta o kody źródłowe, załączam kody dla RFM12 oraz HM-T868S. RFM12B_T.zip RFM12B_R.zip HM_FSK.zip

Nie chciało mi się wierzyć, że enum nie działa. I słusznie, pobrałem kompilator arduino i sprawdziłem. Działa dokładnie jak w C. Nie lubię wklejać kodów na forum, ale tym razem zrobię wyjątek: #include <LiquidCrystal.h> //biblioteka do obslugi LCD enum { KIERUNEK_STOP, KIERUNEK_PROSTO, KIERUNEK_W_LEWO, KIERUNEK_OW_LEWO, KIERUNEK_W_PRAWO, KIERUNEK_OW_PRAWO }; LiquidCrystal lcd(12, 11, 5, 4, 3, 2); //LCD podpięty pod te piny int irLPin = 0; // Analog PIN 0; Left IR int irCPin = 1; // Analog PIN 1; Center IR int irRPin = 2; // Analog PIN 2; Right IR int irLval; // Left IR int irCval; // Center IR int irRval; // Right IR const int lewy1Pin = 32; // lewy silnik 32 const int lewy2Pin = 34; // lewy silnik 34 const int prawy1Pin = 36;// prawy 36 const int prawy2Pin = 38;//prawy 36 const int lewyonPin = 8; // wlacz lewy H-bridge const int prawyonPin = 9; // wlacz prawy H-bridge const int ledPin = 13; // LED int j; int czulosc = 500; //czulosc czujnikow IR const int czujnik = 5; int dystans = 0; int i; int PWM1 = 127; //wypelnienie PMW max 255 tu 1/2 max int PWM2 = 64; //wypelnienie PMW tu 1/4 max int kierunek = KIERUNEK_PROSTO; // kierunek jazdy robota void setup() { lcd.begin(16, 2); // inicjuj lcd 16x2 pinMode(irLPin, INPUT); // ustawienie pinu czujnikow jako wejscia pinMode(irCPin, INPUT); pinMode(irRPin, INPUT); pinMode(ledPin, OUTPUT); // ustawienie pinu LED jako wyjscia // ustawienia wyjsc silnika pinMode(lewy1Pin, OUTPUT); pinMode(lewy2Pin, OUTPUT); pinMode(prawy1Pin, OUTPUT); pinMode(prawy2Pin, OUTPUT); pinMode(lewyonPin, OUTPUT); pinMode(prawyonPin, OUTPUT); pinMode(czujnik, INPUT); // ustawienie wyjscia SHARP // wlaczenie silnikow lewy,prawy analogWrite(lewyonPin, 255); //wlacz prawy z pelnym wypelnieniem PWM analogWrite(prawyonPin, 255);//wlacz lewy z pelnym wypelnieniem PWM } void loop() { Look(); decyzja(); sterowanie(); LCD(); //sprawdzanie(); } void Look() //sprawdz czujniki { for (j =0; j <3; j++) { irLval = analogRead(irLPin); irCval = analogRead(irCPin); irRval = analogRead(irRPin); dystans = analogRead(czujnik); //oczytaj warotsc z SHARP } //delay(50); } void jedz() // jedz do przodu { analogWrite(lewyonPin, PWM1); //wlacz prawy analogWrite(prawyonPin, PWM1);//wlacz lewy digitalWrite(lewy1Pin, LOW); // do przodu sil1 digitalWrite(lewy2Pin, HIGH); // do przodu sil1 digitalWrite(prawy1Pin, LOW); // do przodu sil2 digitalWrite(prawy2Pin, HIGH);// do produ sil2 } void wstecz()//jedz w tyl { analogWrite(lewyonPin, PWM1); //wlacz prawy analogWrite(prawyonPin, PWM1);//wlacz lewy digitalWrite(lewy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(lewy2Pin, LOW); // set leg 2 of the H-bridge low digitalWrite(prawy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(prawy2Pin, LOW); } void tyllewo() { analogWrite(lewyonPin, PWM1); //wlacz prawy analogWrite(prawyonPin, PWM2);//wlacz lewy digitalWrite(lewy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(lewy2Pin, LOW); // set leg 2 of the H-bridge low digitalWrite(prawy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(prawy2Pin, LOW); } void tylprawo() { analogWrite(lewyonPin, PWM2); //wlacz prawy analogWrite(prawyonPin, PWM1);//wlacz lewy digitalWrite(lewy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(lewy2Pin, LOW); // set leg 2 of the H-bridge low digitalWrite(prawy1Pin, HIGH); // set leg 1 of the H-bridge high digitalWrite(prawy2Pin, LOW); } void owlewo() //skrec ostro w prawo { analogWrite(lewyonPin, PWM1); //wlacz prawy analogWrite(prawyonPin, 0);//wlacz lewy digitalWrite(lewy1Pin, LOW); // przod digitalWrite(lewy2Pin, HIGH); // przod digitalWrite(prawy1Pin, LOW); // tyl digitalWrite(prawy2Pin, HIGH); // tyl } void wlewo() //skrec w prawo { analogWrite(lewyonPin, PWM1); //wlacz prawy analogWrite(prawyonPin, PWM2);//wlacz lewy digitalWrite(lewy1Pin, LOW); // przod digitalWrite(lewy2Pin, HIGH); // przod digitalWrite(prawy1Pin, LOW); // tyl digitalWrite(prawy2Pin, HIGH); // tyl } void wprawo() // skrec w lewo { analogWrite(lewyonPin, PWM2); //wlacz prawy analogWrite(prawyonPin, PWM1);//wlacz lewy digitalWrite(lewy1Pin, LOW); // tyl digitalWrite(lewy2Pin, HIGH); // tyl digitalWrite(prawy1Pin, LOW); // przod digitalWrite(prawy2Pin, HIGH); // przod } void owprawo() // skrec ostro w lewo { analogWrite(lewyonPin, 0); //wlacz prawy analogWrite(prawyonPin, PWM1);//wlacz lewy digitalWrite(lewy1Pin, LOW); // tyl digitalWrite(lewy2Pin, HIGH); // tyl digitalWrite(prawy1Pin, LOW); // przod digitalWrite(prawy2Pin, HIGH); // przod } void stoj() { analogWrite(lewyonPin, 0); //wlacz prawy analogWrite(prawyonPin, 0);//wlacz lewy digitalWrite(lewy1Pin, LOW); // tyl stop digitalWrite(lewy2Pin, LOW); // tyl stop digitalWrite(prawy1Pin, LOW); // przod stop digitalWrite(prawy2Pin, LOW); // przod stop } void LCD() { lcd.setCursor(0,0); lcd.print("L"); lcd.print(irLval); //lcd.setCursor(0,5); lcd.print("C"); lcd.print(irCval); //lcd.setCursor(0,13); lcd.print("R"); lcd.print(irRval); //delay(100); //lcd.setCursor(0,0); //lcd.print("L "); //lcd.setCursor(0,5); //lcd.print("C "); //lcd.setCursor(0,13); //lcd.print("R "); //delay(100); lcd.setCursor(1,1); lcd.print("Dystans:"); // wyświetl wartość dla dystansu lcd.print(dystans); delay(100); } void decyzja () { if ((irLval >czulosc) && (irCval <czulosc) && (irRval >czulosc)) { kierunek = KIERUNEK_PROSTO; } else if((irLval <czulosc) && (irCval >czulosc) && (irRval >czulosc)) { kierunek = KIERUNEK_W_PRAWO; } else if((irLval >czulosc) && (irCval >czulosc) && (irRval <czulosc)) { kierunek = KIERUNEK_W_LEWO; } else if((irLval <czulosc) && (irCval <czulosc) && (irRval >czulosc)) { kierunek = KIERUNEK_OW_PRAWO; } else if((irLval >czulosc) && (irCval <czulosc) && (irRval <czulosc)) { kierunek = KIERUNEK_OW_LEWO; } if((irLval >czulosc) && (irCval >czulosc) && (irRval >czulosc)) { kierunek = KIERUNEK_STOP; } } void sterowanie() { static int kierunek_poprzedni = KIERUNEK_STOP; // poprzedni kierunek jazdy if (kierunek_poprzedni==kierunek) return; switch (kierunek) { case KIERUNEK_PROSTO: jedz(); break; case KIERUNEK_W_LEWO: wlewo(); break; case KIERUNEK_OW_LEWO: owlewo(); break; case KIERUNEK_W_PRAWO: wprawo(); break; case KIERUNEK_OW_PRAWO: owprawo(); break; case KIERUNEK_STOP: default: stoj(); break; } kierunek_poprzedni=kierunek; } [ Dodano: 22 Mar 10 10:02 ] Nigdy wcześniej arduino nie używałem, ale jak już pobrałem postanowiłem sprawdzić, co to takiego. Więc jest to najzwyklejsze C, kompilator to najzwyklejszy WinAVR, czyli gcc. W katalogu arduino-0018\hardware\tools\avr jest cały pakiet. Czyli jak ktoś poznał arduino to przy okazji nauczył się C. Poza WinAVR arduino daje jakieś IDE napisane w Javie (ja wolę AVRStudio, ale co kto lubi). Najciekawsze są biblioteki. W katalogu arduino-0018\libraries są gotowe biblioteki do obsługi LCD, eeprom, servo, silnika krokowego i wielu innych. Napisane są w standardowym C++, więc nawet jeśli ktoś nie planuje używać arduino może te biblioteki wykorzystać.

To nieprawda. ASCII jest 7-bitowe, jeśli nie wierzysz sprawdź na wikipedii. Co prawda używa się 8 bitowego kodowania, ale to już nie jest ascii. Kody >127 nie należą do standardu.

W C++ można pominąć enum przed deklaracją zmiennej, więc kod był w C++ poprawny. Niestety w C trzeba powtarzać enum przed typem zmiennej.

Nie podłączaj nigdy bezpośrednio - zawsze przez rezystor 100-470ohm.

Jeśli już to: enum NKierunkek kierunek = KIEUNEK_PROSTO; Ale sprawdzałem pod gcc i keil enum {X1, X2 }; i kompilowało bez problemu.

Jest jak najbardziej poprawna. Ma tylko taką wadę, że za rok ciężko sobie przypomnieć co znaczy "kierunek = 2". Jeśli enum nie działa można wykorzystać instrukcję #define, czyli #define KIERUNEK_PROSTO 1 #define KIERUNEK_STOP 2 #define KIERUNEK_PRAWO 3 #define KIERUNEK_LEWO 4

Ja bym proponował małą zmianę - chyba nieco lepiej byłoby mieć rezystory R1-R5 (podciągające) na płytce z czujnikami (o ile tylko jest miejsce). Po pierwsze można wtedy przetestować płytkę czujników zwykłym multimetrem (będzie sygnał napięciowy). Po drugie płytkę można będzie łatwo wykorzystać np. w kolejnym robocie.