ATNEL tech-forum 2014-06-09T13:40:37+01:00 https://forum.atnel.pl/feed.php?f=4&t=7340&mode 2014-06-09T13:40:37+01:00 2014-06-09T13:40:37+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83826#p83826 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]> eMCe2 napisał(a):

Mozna sie do jakiejs przedsprzedazy na YellowBooka zapisac? Bo chetnie bym juz cos przygarnal Jakas data wydania juz znana? Ten rok? Nie ten?


Nie nie, proszę - jeszcze dużo za wcześnie aby cokolwiek o tym mówić :( przykro mi .... ale za to obiecuję, że dla forumowicza będzie tłusty, wręcz ociekający tłuszczem rabat ;)

Statystyki: Napisane przez mirekk36 — 9 cze 2014, o 13:40

]]> 2014-06-09T13:27:01+01:00 2014-06-09T13:27:01+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83823#p83823 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]>
Mozna sie do jakiejs przedsprzedazy na YellowBooka zapisac? Bo chetnie bym juz cos przygarnal :D Jakas data wydania juz znana? Ten rok? Nie ten?

Statystyki: Napisane przez eMCe2 — 9 cze 2014, o 13:27

]]> 2014-06-08T22:24:13+01:00 2014-06-08T22:24:13+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83773#p83773 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]> mokrowski napisał(a):

Wiesz Mirku, taka mnie ,,myśl puknęła w głowę".


Tak tak - mam to od dawna na myśli ... i powoli mam nadzieję, że i mi uda się to jakoś dobrze przedstawić - a będę to poruszał i w poradnikach wideo ... ale też (jeśli uda mi się napisać) kolejne książki to już od YellowBooka - zacznie się czas - korzystania teraz z tego co dowiedzieliśmy się w dwóch pierwszych książkach ... i jak tworzyć projekty od początku do końca - dobierając odpowiednio poznane wcześniej narzędzia z obydwu książek i jak stosować je w praktyce - bo zdaję sobie sprawę, że z tym jest duży problem... Tyle tylko że w poradnikach nie uda mi się wszystkiego przedstawić tak jak bym chciał - dlatego sporą część widzę w książkach i już dawno mam to jakby zaplanowane .... a poradniki będą nadal mam nadzieję uzupełnieniem ...

wbrew pozorom to nie jest (przynajmniej dla mnie łatwe zadanie) ... skutecznie przekazać taką wiedzę ... bo wielu czytelników z jednej strony jej oczekuje ale z drugiej strony jak tylko zobaczy coś ciut bardziej skomplikowanego to zaraz się boi w ogóle albo tego oglądać albo czytać .... obawiając się, że i tak niby nie da sobie rady ... albo że nagle czasu nie ma itp ...

dlatego mam tu pewne pomysły na przekaz książkowy - ale zobaczymy czy się sprawdzi ;)

kolega rezasurmar miał też rację że po części w tych poradnikach o callbackach ale i w wielu innych również o tym eepromie, że z nich jak ktoś chce - ale jak chce ... to również zobaczy jaką drogą iść w sensie dzielenia programu na funkcje bo robię tam to na żywo że tak powiem, pomimo że główny cel poradnika jest niby inny .... No ale .... znowu - wielu początkujących boi się nawet tego obejrzeć .... podpatrzeć, chociaż się oswoić ... a przecież w międzyczasie cały czas nawijam w poradniku teksty typu

"no to teraz powołamy sobie do życia funkcję x" ... itd itp itd

Statystyki: Napisane przez mirekk36 — 8 cze 2014, o 22:24

]]> 2014-06-08T12:34:10+01:00 2014-06-08T12:34:10+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83706#p83706 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]>
Dlatego zawsze warto opisać co ma robić program na kartce i podzielić go na poszczególne sekcje, algorytmy.

Statystyki: Napisane przez Gość — 8 cze 2014, o 12:34

]]> 2014-06-08T10:49:14+01:00 2014-06-08T10:49:14+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83696#p83696 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]>

Program byłoby pewnie znacznie łatwiej zrobić, gdyby nie to, że sobie utrudniłem życie tymi czujnikami.

Ten "tworek" miał być poprawiony, ale spełniał swoją funkcję, więc pozostał na miejscu.

Statystyki: Napisane przez piotreks-89 — 8 cze 2014, o 10:49

]]> 2014-06-08T09:41:17+01:00 2014-06-08T09:41:17+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83693#p83693 <![CDATA[Re: ATmega16A - Zastąpienie delay'ów timer'ami.]]>
Pomyśl - zasada jest jedna - PĘTLA GŁÓWNA programu powinna być jak najkrótsza a z niej powinny być wywoływane funkcje ... głównie .. bo wiadomo że czasem parę IF'ów się trafi

to właśnie przez to - przestajesz sam panować nad kodem ... analiza takiego kodu jest mega ciężka ...


poza tym tworzenie TAKICH - (nie obraź się za określenie) POTWORKÓW:

[syntax=c]led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);[/syntax]

to już gwóźdź do przysłowiowej trumny .... odnośnie tego "potworka" obejrzyj sobie to:

http://mirekk36.blogspot.com/2014/05/mi ... rawki.html

ok ?

Statystyki: Napisane przez mirekk36 — 8 cze 2014, o 09:41

]]> 2014-06-08T09:17:33+01:00 2014-06-08T09:17:33+01:00 https://forum.atnel.pl/viewtopic.php?t=7340&p=83691#p83691 <![CDATA[ATmega16A - Zastąpienie delay'ów timer'ami.]]>
Wielu konstruktorów robotów w ogóle nie pokazuje swojego kodu. Po wielu nieudanych godzinach zastępowania delay'ów timer'ami odpadam. Sam nie dam rady :(

Aktualnie mam taki program:
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

// ***** preprocesor
#define S1 (1<<PA0)
#define S2 (1<<PC1)

#define KTIR1 (1<<PA6)
#define KTIR2 (1<<PA5)

#define AKU (1<<PA7)

#define RXD (1<<PD0)
#define TXD (1<<PD1)

#define KS_KEY (1<<PD3)
#define START_KEY (1<<PD2)

#define TSOP1 (1<<PA1)
#define TSOP2 (1<<PA4)
#define TSOP3 (1<<PA3)
#define TSOP4 (1<<PA2)

#define LED1 (1<<PC7)
#define LED2 (1<<PC6)
#define LED3 (1<<PC0)
#define LED4 (1<<PD6)

#define IR1 (1<<PB4)
#define IR2 (1<<PB3)
#define IR3 (1<<PB2)
#define IR4 (1<<PB1)
#define IR5 (1<<PB0)

#define IR_KEY (1<<PD7)

#define L1 (1<<PC5)
#define L2 (1<<PC4)
#define PWM_L (1<<PD5)

#define P1 (1<<PC3)
#define P2 (1<<PC2)
#define PWM_P (1<<PD4)

// *** mekrodefinicje
#define LEWA_PRZOD ( PORTC |= L1, PORTC &= ~L2 )
#define LEWA_TYL ( PORTC &= ~L1, PORTC |= L2 )
#define LEWA_HAM ( PORTC &= ~( L1 | L2 ) )

#define PRAWA_PRZOD ( PORTC |= P1, PORTC &= ~P2 )
#define PRAWA_TYL ( PORTC &= ~P1, PORTC |= P2 )
#define PRAWA_HAM ( PORTC &= ~( P1 | P2 ) )

//OCR1A - lewa strona
//OCR1B - prawa strona
#define HAM ( LEWA_HAM, PRAWA_HAM )

#define OBROT_PRAWO ( odwrot(odwrot_pwm), _delay_ms(250), skr_p(mid_pwm), _delay_ms(200), _delay_ms(100) )
#define OBROT_LEWO ( odwrot(odwrot_pwm), _delay_ms(250), skr_l(mid_pwm), _delay_ms(200), _delay_ms(100) )

// *** deklaracje funkcji
uint16_t pomiar(uint8_t kanal);
void prog_stop(void);
void odlicz_5s(void);
void led_on(uint8_t numer_on);
void led_off(uint8_t numer_off);
void led_xor(uint8_t numer_xor);
void program(uint8_t prog);

//*** definicje najważniejszych funkcji
void przod(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_PRZOD;
PRAWA_PRZOD;
}

void odwrot(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_TYL;
PRAWA_TYL;
}

void skr_l(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
PRAWA_HAM;
LEWA_PRZOD;
}

void skr_p(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_HAM;
PRAWA_PRZOD;
}

// *** definicje stałych
const uint16_t a=700;//zmienna, do której porównywane są wartości czujników
const uint16_t aku_adc=525;//ADC=(Vin*1024)/Vref | ADC=(3,25*1024)/4,94
/*
Wartości aku_adc:
1) 600 - 7,8V
2) 550 - 7,73V
3) 525 - ?
4) 500 - ?
*/
const uint16_t max_pwm=1000;
const uint16_t mid_pwm=500;
const uint16_t min_pwm=200;
const uint16_t odwrot_pwm=700;

// *** definicje zmiennych
uint8_t b=19;//zmienna przechowująca ilość zliczeń 250ms
uint8_t ss1=0;//zmienna pomocnicza stanu S1
uint8_t ss2=1;//zmienna pomocnicza stanu S2
volatile uint8_t start=0;//zmienna pomocnicza - startowanie robota (z możliwością edycji w przerwaniach)
uint8_t PROGRAM=1;//zmienna przechowująca wartość programu startowego
volatile uint8_t wykonaj=1;//zmienna pomocnicza pozwalająca na jednokrotne wykonanie programu startowego (z możliwością edycji w przerwaniach)

// *** obsługa modułu startowego - przerwanie od INT0
ISR( INT0_vect )
{
//blok warunkowy - odczyt, jaka zmiana nastąpiła
if( ( PIND & START_KEY ) )
{
start=1;
wykonaj=1;
}
else
{
start=0;
wykonaj=0;
}
}

// ********** funkcja główna programu
int main(void)
{
// ***** inicjalizacja
// *** ADC
ADMUX |= (1<<REFS0);
ADCSRA |= (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1);

// *** Timer/Counter1
TCCR1A |= (1<<COM1A1) | (1<<COM1B1) | (1<<WGM11);//Timer1 tryb Fast-PWM (WGM11 + WGM12 + WGM13), tryb nieodwrócony
TCCR1B |= (1<<CS11) | (1<<WGM12) | (1<<WGM13); //Prescaler: 8 (CS11)
ICR1=500;//Częstotliwość 4kHz - F=Fq/p/ICR1
OCR1A=0;//PWM - wypełnienie 0
OCR1B=0;//PWM - wypełnienie 0

// *** Timer/Counter2
TCCR2 |= (1<<WGM21) | (1<<COM20) | (1<<CS20); //Timer2 tryb CTC (WGM21), przełącza OC2 przy zrównaniu(COM20), prescaler=1 (CS20)
OCR2=222; //OCR2 = Fq/2F | 36kHz

// *** Przerwania zewnętrzne
MCUCR |= (1<<ISC00);//Dowolna zmiana stanu logicznego na INT0 wywoła żądanie przerwania (ISC00=1)
GICR |= (1<<INT0);//Włączenie przerwań od pinu INT0
sei(); //Globalne włączenie przerwań

// *** wejścia
DDRA &= ~( S1 | KTIR1 | KTIR2 | AKU | TSOP1| TSOP2 | TSOP3 | TSOP4 );//S1, KTIR1, KTIR2 - wejście
PORTA |= S1;//S1 - podciągnięty do Vcc

DDRC &= ~S2;//S2 - wejście
PORTC |= S2;//S2 - podciągnięty do Vcc

DDRD &= ~( START_KEY | KS_KEY );//START_KEY i KS_KEY - wejścia

// *** wyjścia
DDRC |= LED1 | LED2 | LED3;//LED1, LED2, LED3 - wyjścia
PORTC |= LED1 | LED2 | LED3;//LED1, LED2, LED3 - wyłączone (podciągnięte do Vcc)

DDRD |= LED4 | IR_KEY;//LED4, IR_KEY - wyjście
PORTD |= LED4;//LED4 - wyłączone (podciągnięte do Vcc)

DDRB |= IR1 | IR2 | IR3 | IR4 | IR5;//IR1, IR2, IR3, IR4, IR5 - wyjścia
PORTB |= IR1 | IR2 | IR3 | IR4 | IR5;//IR1, IR2, IR3, IR4, IR5 - włączone (1 - ON, 0 - OFF)

DDRC |= L1 | L2 | P1 | P2;//L1, L2, P1, P2 - wyjścia
HAM;

DDRD |= PWM_L | PWM_P;//PWM_L, PWM_P - wyjścia

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

// *** pętla nieskończona
while(1)
{
// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

//zerowanie LED'ów
led_off(1);
led_off(2);
led_off(3);
led_off(4);

HAM;

//blok warunkowy - sprawdzanie stanu S2
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
ss2=0;
}
else
{
ss2=1;
}
}

//blok warunkowy - sprawdzanie stanu S2
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) ) ss1=1;
else ss1=0;
}

// ***** PROGRAM TESTOWY ROBOTA *****
while( ss1>0 )
{
// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

// *** TEST CZUJNIKÓW PRZECIWNIKA ***
while( ss1==1 )
{
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=2;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=1;
}

if( !( PINA & TSOP1 ) ) led_on(1);
else led_off(1);

if( !( PINA & TSOP2 ) ) led_on(2);
else led_off(2);

if( !( PINA & TSOP3 ) ) led_on(3);
else led_off(3);

if( !( PINA & TSOP4 ) ) led_on(4);
else led_off(4);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}

// *** TEST CZUJNIKÓW LINII ***
while( ss1==2 )
{

led_off(3);
led_off(4);

if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=3;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=2;
}

if( pomiar(5)<=a ) led_on(1);
else led_off(1);

if( pomiar(6)<=a ) led_on(2);
else led_off(2);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}

// *** TEST SILNIKÓW ***
while( ss1==3 )
{

led_off(1);
led_off(2);
led_off(3);
led_off(4);

if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=0;
HAM;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=3;
}

przod(max_pwm);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}
}

// ***** PROGRAM GŁÓWNY ROBOTA *****
// *** MENU WYBORU PROGRAMU STARTOWEGO ***
while( ss2==0 )
{

HAM;

//blok warunkowy - sprawdzanie stanu S1 (jeśli wciśnięty PROGRAM++)
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
PROGRAM++;
}
}

if( PROGRAM==1 ) led_on(1);
else led_off(1);

if( PROGRAM==2 ) led_on(2);
else led_off(2);

if( PROGRAM==3 ) led_on(3);
else led_off(3);

if( PROGRAM==4 ) led_on(4);
else led_off(4);

if( PROGRAM==5 )
{
led_on(2);
led_on(3);
led_on(4);
}
else
{
led_off(2);
led_off(3);
led_off(4);
}

if( PROGRAM==6 )
{
led_on(1);
led_on(3);
led_on(4);
}
else
{
led_off(1);
led_off(3);
led_off(4);
}

if( PROGRAM==7 )
{
led_on(1);
led_on(2);
led_on(4);
}
else
{
led_off(1);
led_off(2);
led_off(4);
}

if( PROGRAM==8 )
{
led_on(1);
led_on(2);
led_on(3);
}
else
{
led_off(1);
led_off(2);
led_off(3);
}

if( PROGRAM==9 ) PROGRAM=0;

//blok warunkowy - sprawdzanie stanu S2 (jeśli wciśnięty uruchom robota)
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
// ZGAŚ DIODY LED
led_off(1);
led_off(2);
led_off(3);
led_off(4);

//WYSTARTUJ ROBOTA
start=1;
wykonaj=1;

//ODCZEKAJ 5s
odlicz_5s();
}
}

// *** ALGORYTM WALKI ***
while( start==1 )
{
// *** jednokrotne wykonanie programu startowego
if( wykonaj==1 )
{
program( PROGRAM );//uruchom program startowy uprzednio wybrany w menu
wykonaj=0;//i wykonaj go wyłącznie raz!
}

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

//blok warunkowy - odczyt stanu KTIR1
if( pomiar(5)<=a )
{
OBROT_PRAWO;
}

//blok warunkowy - odczyt stanu KTIR2
if( pomiar(6)<=a )
{
OBROT_PRAWO;
}

//blok warunkowy - odczyt stanu KTIR1 && KRIR2
if( pomiar(5)<=a && pomiar(6)<=a )
{
OBROT_PRAWO;
}

//blok warunkowy - odczyt stanu KTIR1 && TSOP3
if( pomiar(5)<=a && !( PINA & TSOP3 ) )
{
OBROT_PRAWO;
}

//blok warunkowy - odczyt stanu KTIR2 && TSOP3
if( pomiar(6)<=a && !( PINA & TSOP3 ) )
{
OBROT_LEWO;
}

//blok warunkowy - odczyt stanu KTIR1 && TSOP4
if( pomiar(5)<=a && !( PINA & TSOP4 ) )
{
OBROT_PRAWO;
}

//blok warunkowy - odczyt stanu KTIR2 && TSOP4
if( pomiar(6)<=a && !( PINA & TSOP3 ) )
{
OBROT_PRAWO;
}

// blok warunkowy - odczyt stanu TSOP1
if( !( PINA & TSOP1 ) )
{
led_on(1);
skr_l(max_pwm);
}
else
{
led_off(1);
przod(min_pwm);
}

// blok warunkowy - odczyt stanu TSOP2
if( !( PINA & TSOP2 ) )
{
led_on(2);
skr_p(max_pwm);
}
else
{
led_off(2);
}

// blok warunkowy - odczyt stanu TSOP3
if( !( PINA & TSOP3 ) )
{
if( !( PINA & TSOP4 ) && pomiar(5)>a && pomiar(6)>a )
{
led_on(3);
led_on(4);
przod(max_pwm);
}
else
{
led_on(3);
skr_p(mid_pwm);
}
}
else
{
led_off(3);
}

// blok warunkowy - odczyt stanu TSOP4
if( !( PINA & TSOP4 ) )
{
if( !( PINA & TSOP3 ) && pomiar(5)>a && pomiar(6)>a )
{
led_on(3);
led_on(4);
przod(max_pwm);
}
else
{
led_on(4);
skr_l(mid_pwm);
}
}
else
{
led_off(4);
}

//blok warunkowy - odczyt stanu S2
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
start=0;//jeśli wciśnięty - zatrzymaj robota
ss2=1;//i wyjdź do menu wyboru PROGRAM TESTOWY/PROGRAM GŁÓWNY
}
else
{
start=1;//jeśli nie - walcz dalej
ss2=0;//i nie wychodź do menu wyboru PROGRAM TESTOWY/PROGRAM GŁÓWNY
}
}
}
}
}
}
// ********** koniec funkcji głównej programu

// *** definicje funkcji
uint16_t pomiar(uint8_t kanal)
{
ADMUX=(ADMUX & 0xf8)|kanal;
ADCSRA|=(1<<ADSC);
while(ADCSRA & (1<<ADSC));
return ADCW;
}

void prog_stop(void)
{
//zahamuj wszystkie silniki, wyłącz wszystkie diody IR, wyświetl sekwencję zapalania/gaszenia wszystkoch diod
HAM;
PORTB &= ~( IR1 | IR2 | IR3 | IR4 | IR5 );
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
//wykonaj pętlę zabierającą 100% czasu procesora
while(1);
}

void odlicz_5s(void)
{
b=0;
while( b<19 )
{
_delay_ms(250);
led_xor(1);
led_xor(2);
led_xor(3);
led_xor(4);
b++;
}
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(100);
}

void led_on(uint8_t numer_on)
{
switch ( numer_on )
{
case 1: ( PORTC &= ~LED1 ); break;
case 2: ( PORTC &= ~LED2 ); break;
case 3: ( PORTC &= ~LED3 ); break;
case 4: ( PORTD &= ~LED4 ); break;
default: {}; break;
}
}

void led_off(uint8_t numer_off)
{
switch ( numer_off )
{
case 1: ( PORTC |= LED1 ); break;
case 2: ( PORTC |= LED2 ); break;
case 3: ( PORTC |= LED3 ); break;
case 4: ( PORTD |= LED4 ); break;
default: {}; break;
}
}

void led_xor(uint8_t numer_xor)
{
switch ( numer_xor )
{
case 1: ( PORTC ^= LED1 ); break;
case 2: ( PORTC ^= LED2 ); break;
case 3: ( PORTC ^= LED3 ); break;
case 4: ( PORTD ^= LED4 ); break;
default: {}; break;
}
}

void program(uint8_t prog)
{
switch ( prog )
{
//*** PROGRAM STARTOWY 0
case 0:
{
PROGRAM=0;
};
break;

//*** PROGRAM STARTOWY 1
case 1:
{
skr_p(max_pwm);
_delay_ms(250);
_delay_ms(100);
};
break;

//*** PROGRAM STARTOWY 2
case 2:
{
skr_l(max_pwm);
_delay_ms(250);
_delay_ms(100);
};
break;

//*** PROGRAM STARTOWY 3
case 3:
{
skr_p(max_pwm);
_delay_ms(250);
_delay_ms(50);
};
break;

//*** PROGRAM STARTOWY 4
case 4:
{
skr_l(max_pwm);
_delay_ms(250);
_delay_ms(50);
};
break;

//*** PROGRAM STARTOWY 5
case 5:
{
skr_p(max_pwm);
_delay_ms(250);
_delay_ms(150);
};
break;

//*** PROGRAM STARTOWY 6
case 6:
{
skr_l(max_pwm);
_delay_ms(250);
_delay_ms(150);
};
break;

//*** PROGRAM STARTOWY 7
case 7:
{
skr_p(350);
_delay_ms(250);
_delay_ms(250);
_delay_ms(250);
_delay_ms(150);
skr_p(max_pwm);
_delay_ms(250);
};
break;

//*** PROGRAM STARTOWY 8
case 8:
{
skr_l(350);
_delay_ms(250);
_delay_ms(250);
_delay_ms(250);
_delay_ms(150);
skr_l(max_pwm);
_delay_ms(250);
};
break;

default: {}; break;
}
}[/syntax]
Wszystko działa, ale... Te delay'e... Gdy robot wykonuje któryś z manewrów - OBROT_PRAWA, OBROT_LEWA lub któryś z programów startowych (które są zapisane w instrukcji switch) nie znajdzie przeciwnika. Jest po prostu ślepy przez te delay'e i wiadomo, jak to się kończy... Przeciwnik podjeżdża i bez problemu może zepchnąć mojego robota, bo ten nie ma się jak bronić.

Pierwsza zmiana - delay'e na timer:
No to pomyślałem, że można by zamienić delay'e na odliczanie czasu timer'ami i w trakcie wykonywania funkcji obrot_p, obrot_l, program_lewa, program_prawa sprawdzać czujniki. Z racji tego, że został mi ostatni wolny timer - timer0, to on zajmuje się odliczaniem czasu. Jest ustawiony w tryb CTC i daje przerwanie, co 1ms (bez przełączania wyjścia). Uznałem, że dla mnie dobrą podstawą czasu będzie 20ms (czas, w którym nie zapcham buforów TSOP'ów). Dlatego po zliczeniu zmiennej ilosc_1ms=20, inkrementuję zmienną ilosc_20ms, daję sygnał o wykonaniu pomiaru i zeruję ilosc_1ms. Wszystkie funkcje są oparte o właśnie podstawę czasu 20ms. Gdy któryś z czujników zauważy przeciwnika, to ilosc_20ms jest zwiększana do do takiej ilości, aby wyjść z wszystkich pętli. Oczywiście to nie działa i nie mam pojęcia czemu...

Druga zmiana - "paczkowanie" impulsów dla większego zasięgu czujników:
Dotychczas włączałem wszystkie diody IR i modulowałem sygnał na 36kHz. To działa, ale zapycha bufory odbiorników TSOP i zmniejsza się zasięg. Postanowiłem to zmienić i dodałem tzw. "paczkowanie". Teraz wysyłam sygnał testowy (według DS), czyli 30 impulsów (bo tyle wykona się w ciągu 85us). Problem w tym, że tutaj też mam delay'e. Drugi problem, że funkcja czujnik() nie działa jeśli jest ta zmienna stan. Bez zmiennej, czyli z return'em już po samym odczycie stanu pinu działa, ale nie mam pewności czy funkcja wykonuje się do końca - czy dioda zostanie zgaszona.

Powstało coś takiego:
[syntax=c]#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

// ***** preprocesor
#define S1 (1<<PA0)
#define S2 (1<<PC1)

#define KTIR1 (1<<PA6)
#define KTIR2 (1<<PA5)

#define AKU (1<<PA7)

#define RXD (1<<PD0)
#define TXD (1<<PD1)

#define KS_KEY (1<<PD3)
#define START_KEY (1<<PD2)

#define TSOP1 (1<<PA1)
#define TSOP2 (1<<PA4)
#define TSOP3 (1<<PA3)
#define TSOP4 (1<<PA2)

#define LED1 (1<<PC7)
#define LED2 (1<<PC6)
#define LED3 (1<<PC0)
#define LED4 (1<<PD6)

#define IR1 (1<<PB4)
#define IR2 (1<<PB3)
#define IR3 (1<<PB2)
#define IR4 (1<<PB1)
#define IR5 (1<<PB0)

#define IR_KEY (1<<PD7)

#define L1 (1<<PC5)
#define L2 (1<<PC4)
#define PWM_L (1<<PD5)

#define P1 (1<<PC3)
#define P2 (1<<PC2)
#define PWM_P (1<<PD4)

// *** mekrodefinicje
#define LEWA_PRZOD ( PORTC |= L1, PORTC &= ~L2 )
#define LEWA_TYL ( PORTC &= ~L1, PORTC |= L2 )
#define LEWA_HAM ( PORTC &= ~( L1 | L2 ) )

#define PRAWA_PRZOD ( PORTC |= P1, PORTC &= ~P2 )
#define PRAWA_TYL ( PORTC &= ~P1, PORTC |= P2 )
#define PRAWA_HAM ( PORTC &= ~( P1 | P2 ) )

//OCR1A - lewa strona
//OCR1B - prawa strona
#define HAM ( LEWA_HAM, PRAWA_HAM )

#define OBROT_PRAWO ( odwrot(odwrot_pwm), _delay_ms(250), skr_p(mid_pwm), _delay_ms(200), _delay_ms(100) )
#define OBROT_LEWO ( odwrot(odwrot_pwm), _delay_ms(250), skr_l(mid_pwm), _delay_ms(200), _delay_ms(100) )

// *** deklaracje funkcji
uint16_t pomiar(uint8_t kanal);
void prog_stop(void);
void odlicz_5s(void);
void led_on(uint8_t numer_on);
void led_off(uint8_t numer_off);
void led_xor(uint8_t numer_xor);
void program(uint8_t prog);

// *** definicje stałych
const uint16_t a=650;//zmienna, do której porównywane są wartości czujników
const uint16_t aku_adc=525;//ADC=(Vin*1024)/Vref | ADC=(3,25*1024)/4,94
/*
Wartości aku_adc:
1) 600 - 7,8V
2) 550 - 7,73V
3) 525 - ?
4) 500 - ?
*/
const uint16_t max_pwm=1000;
const uint16_t mid_pwm=500;
const uint16_t min_pwm=200;
const uint16_t odwrot_pwm=700;

// *** definicje zmiennych
uint8_t b=19;//zmienna przechowująca ilość zliczeń 250ms
uint8_t ss1=0;//zmienna pomocnicza stanu S1
uint8_t ss2=1;//zmienna pomocnicza stanu S2
volatile uint8_t start=0;//zmienna pomocnicza - startowanie robota (z możliwością edycji w przerwaniach)
uint8_t PROGRAM=1;//zmienna przechowująca wartość programu startowego
volatile uint8_t wykonaj=1;//zmienna pomocnicza pozwalająca na jednokrotne wykonanie programu startowego (z możliwością edycji w przerwaniach)
volatile uint16_t ilosc_1ms=0;//zmienna pomocnicza przechowująca ilość zliczeń 1ms
volatile uint16_t ilosc_20ms=0;//zmienna pomocnciza przechowująca ilość zliczeń 20ms
volatile uint8_t wykonaj_pomiar=0;//zmienna decydująca o wykonaniu pomiarów z czujników

//*** definicje najważniejszych funkcji
uint8_t czujnik(uint8_t tsop, uint8_t ir)
{
uint8_t stan=0;//zmienna lokalna przechowująca wartość zwracaną na końcu funkcji
PORTB |= (ir);//włączenie diody IRx
_delay_us(85);//30 impulsów 36kHz
if( !(PINA & tsop) ) stan=1;//jeśli TSOPx coś wykrył wpisz 1 do zmiennej
else stan=0;//jeśli nie, to wpisz 0
PORTB &= ~(ir);//wyłącz diodę IRx
_delay_ms(1);//odczekaj 1ms w celu zlikwidowania błędów
if(stan==1) return 1;//jeśli coś wykryto to zwróć 1
else return 0;//jeśli nie, to zwróć 0
}

uint8_t czujnik_przod(void)
{
uint8_t stan=0;//zmienna lokalna przechowująca wartość zwracaną na końcu funkcji
PORTB |= IR4;//włączenie diody IR4
_delay_us(85);//30 impulsów 36kHz
if( !(PINA & TSOP3) && !(PINA & TSOP4) ) stan=1;//jeśli TSOP3 i TSOP4 coś wykrył wpisz 1 do zmiennej
else stan=0;//jeśli nie, to wpisz 0
PORTB &= ~IR4;//wyłącz diodę IR4
_delay_ms(1);//odczekaj 1ms w celu zlikwidowania błędów
if(stan==1) return 1;//jeśli coś wykryto to zwróć 1
else return 0;//jeśli nie, to zwróć 0
}

void przod(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_PRZOD;
PRAWA_PRZOD;
}

void odwrot(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_TYL;
PRAWA_TYL;
}

void skr_l(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
PRAWA_HAM;
LEWA_PRZOD;
}

void skr_p(uint16_t pwm)
{
OCR1A=(pwm);
OCR1B=(pwm);
LEWA_HAM;
PRAWA_PRZOD;
}

void obrot_p(void)
{
ilosc_20ms=0;

while(ilosc_20ms<11)
{
odwrot(odwrot_pwm);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=23;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=23;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=23;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}

while(ilosc_20ms>10 && ilosc_20ms<23)
{
skr_p(mid_pwm);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=23;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=23;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=23;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}
}

void obrot_l(void)
{

ilosc_20ms=0;

while(ilosc_20ms<11)
{
odwrot(odwrot_pwm);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=23;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=23;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=23;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}

while(ilosc_20ms>10 && ilosc_20ms<23)
{
skr_l(mid_pwm);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=23;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=23;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=23;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=23;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}
}

void program_lewa(uint8_t czas1, uint8_t czas2, uint16_t pwm_czas1, uint16_t pwm_czas2)
{
ilosc_20ms=0;

while(ilosc_20ms<czas1)
{
skr_l(pwm_czas1);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=czas2;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=czas2;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=czas2;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}

while(ilosc_20ms>czas1 && ilosc_20ms<czas2)
{
skr_l(pwm_czas2);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=czas2;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=czas2;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=czas2;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}
}

void program_prawa(uint8_t czas1, uint8_t czas2, uint16_t pwm_czas1, uint16_t pwm_czas2)
{
ilosc_20ms=0;

while(ilosc_20ms<czas1)
{
skr_p(pwm_czas1);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=czas2;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=czas2;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=czas2;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}

while(ilosc_20ms>czas1 && ilosc_20ms<czas2)
{
skr_p(pwm_czas2);
if(wykonaj_pomiar==1)
{
//Blok odczytu czujnika z przodu
if( czujnik_przod() )
{
led_on(3);
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(3);
led_off(4);
}

//Blok odczytu czujnika lewy-przod
if( czujnik(TSOP3,IR3) )
{
led_on(3);
ilosc_20ms=czas2;
}
else
{
led_off(3);
}

//Blok odczytu czujnika prawy-przod
if( czujnik(TSOP4,IR5) )
{
led_on(4);
ilosc_20ms=czas2;
}
else
{
led_off(4);
}

//Blok odczytu czujnika lewy
if( czujnik(TSOP2,IR1) )
{
led_on(1);
ilosc_20ms=czas2;
}
else
{
led_off(1);
}

//Blok odczytu czujnika prawy
if( czujnik(TSOP1,IR2) )
{
led_on(2);
ilosc_20ms=czas2;
}
else
{
led_off(2);
}

wykonaj_pomiar=0;

}
}
}

// *** obsługa modułu startowego - przerwanie od INT0
ISR( INT0_vect )
{
//blok warunkowy - odczyt, jaka zmiana nastąpiła
if( ( PIND & START_KEY ) )
{
start=1;
wykonaj=1;
}
else
{
start=0;
wykonaj=0;
}
}

// *** timer odliczający dokładnie 1ms
ISR( TIMER0_COMP_vect )
{
ilosc_1ms++;
if(ilosc_1ms>=20)
{
ilosc_1ms=0;
ilosc_20ms++;
wykonaj_pomiar=1;
}
}

// ********** funkcja główna programu
int main(void)
{
// ***** inicjalizacja
// *** ADC
ADMUX |= (1<<REFS0);
ADCSRA |= (1<<ADEN) | (1<<ADPS0) | (1<<ADPS1);

// *** Timer/Counter0
TCCR0 |= (1<<WGM01) | (1<<CS00) | (1<<CS01);//Timer0 tryb CTC; Prescaler: 64
OCR0 = 249;//OCR=(16000000/(64*1000))-1 - 1ms
TIMSK |= (1<<OCIE0);//Włącznie przerwań od Timer0

// *** Timer/Counter1
TCCR1A |= (1<<COM1A1) | (1<<COM1B1) | (1<<WGM11);//Timer1 tryb Fast-PWM (WGM11 + WGM12 + WGM13), tryb nieodwrócony
TCCR1B |= (1<<CS11) | (1<<WGM12) | (1<<WGM13); //Prescaler: 8 (CS11)
ICR1=500;//Częstotliwość 4kHz - F=Fq/p/ICR1
OCR1A=0;//PWM - wypełnienie 0
OCR1B=0;//PWM - wypełnienie 0

// *** Timer/Counter2
TCCR2 |= (1<<WGM21) | (1<<COM20) | (1<<CS20); //Timer2 tryb CTC (WGM21), przełącza OC2 przy zrównaniu(COM20), prescaler=1 (CS20)
OCR2=222; //OCR2 = Fq/2F | 36kHz

// *** Przerwania zewnętrzne
MCUCR |= (1<<ISC00);//Dowolna zmiana stanu logicznego na INT0 wywoła żądanie przerwania (ISC00=1)
GICR |= (1<<INT0);//Włączenie przerwań od pinu INT0
sei(); //Globalne włączenie przerwań

// *** wejścia
DDRA &= ~( S1 | KTIR1 | KTIR2 | AKU | TSOP1| TSOP2 | TSOP3 | TSOP4 );//S1, KTIR1, KTIR2 - wejście
PORTA |= S1;//S1 - podciągnięty do Vcc

DDRC &= ~S2;//S2 - wejście
PORTC |= S2;//S2 - podciągnięty do Vcc

DDRD &= ~( START_KEY | KS_KEY );//START_KEY i KS_KEY - wejścia

// *** wyjścia
DDRC |= LED1 | LED2 | LED3;//LED1, LED2, LED3 - wyjścia
PORTC |= LED1 | LED2 | LED3;//LED1, LED2, LED3 - wyłączone (podciągnięte do Vcc)

DDRD |= LED4 | IR_KEY;//LED4, IR_KEY - wyjście
PORTD |= LED4;//LED4 - wyłączone (podciągnięte do Vcc)

DDRB |= IR1 | IR2 | IR3 | IR4 | IR5;//IR1, IR2, IR3, IR4, IR5 - wyjścia
PORTB &= ~(IR1 | IR2 | IR3 | IR4 | IR5);//IR1, IR2, IR3, IR4, IR5 - wyłączone (1 - ON, 0 - OFF)

DDRC |= L1 | L2 | P1 | P2;//L1, L2, P1, P2 - wyjścia
HAM;

DDRD |= PWM_L | PWM_P;//PWM_L, PWM_P - wyjścia

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

// *** pętla nieskończona
while(1)
{
// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

//zerowanie LED'ów
led_off(1);
led_off(2);
led_off(3);
led_off(4);

HAM;

//blok warunkowy - sprawdzanie stanu S2
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
ss2=0;
}
else
{
ss2=1;
}
}

//blok warunkowy - sprawdzanie stanu S2
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) ) ss1=1;
else ss1=0;
}

// ***** PROGRAM TESTOWY ROBOTA *****
while( ss1>0 )
{
// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

// *** TEST CZUJNIKÓW PRZECIWNIKA ***
while( ss1==1 )
{
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=2;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=1;
}

if( czujnik(TSOP3,IR3) ) led_on(1);
else led_off(1);

if( czujnik_przod() ) led_on(2);
else led_off(2);

if( czujnik(TSOP4,IR5) ) led_on(3);
else led_off(3);

led_off(4);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}

// *** TEST CZUJNIKÓW LINII ***
while( ss1==2 )
{

if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=3;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=2;
}

if( pomiar(5)<=a ) led_on(1);
else led_off(1);

if( pomiar(6)<=a ) led_on(2);
else led_off(2);

if( czujnik(TSOP2,IR1) ) led_on(3);
else led_off(3);

if( czujnik(TSOP1,IR2) ) led_on(4);
else led_off(4);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}

// *** TEST SILNIKÓW ***
while( ss1==3 )
{

led_off(1);
led_off(2);
led_off(3);
led_off(4);

if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
ss1=0;
HAM;
led_off(1);
led_off(2);
led_off(3);
led_off(4);
}
else ss1=3;
}

przod(max_pwm);

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();
}
}

// ***** PROGRAM GŁÓWNY ROBOTA *****
// *** MENU WYBORU PROGRAMU STARTOWEGO ***
while( ss2==0 )
{

HAM;

//blok warunkowy - sprawdzanie stanu S1 (jeśli wciśnięty PROGRAM++)
if( !( PINA & S1 ) )
{
_delay_ms(100);
if( !( PINA & S1 ) )
{
PROGRAM++;
}
}

if( PROGRAM==1 ) led_on(1);
else led_off(1);

if( PROGRAM==2 ) led_on(2);
else led_off(2);

if( PROGRAM==3 ) led_on(3);
else led_off(3);

if( PROGRAM==4 ) led_on(4);
else led_off(4);

if( PROGRAM==5 )
{
led_on(2);
led_on(3);
led_on(4);
}
else
{
led_off(2);
led_off(3);
led_off(4);
}

if( PROGRAM==6 )
{
led_on(1);
led_on(3);
led_on(4);
}
else
{
led_off(1);
led_off(3);
led_off(4);
}

if( PROGRAM==7 )
{
led_on(1);
led_on(2);
led_on(4);
}
else
{
led_off(1);
led_off(2);
led_off(4);
}

if( PROGRAM==8 )
{
led_on(1);
led_on(2);
led_on(3);
}
else
{
led_off(1);
led_off(2);
led_off(3);
}

if( PROGRAM==9 ) PROGRAM=0;

//blok warunkowy - sprawdzanie stanu S2 (jeśli wciśnięty uruchom robota)
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
// ZGAŚ DIODY LED
led_off(1);
led_off(2);
led_off(3);
led_off(4);

//WYSTARTUJ ROBOTA
start=1;
wykonaj=1;

//ODCZEKAJ 5s
odlicz_5s();
}
}

// *** ALGORYTM WALKI ***
while( start==1 )
{
// *** jednokrotne wykonanie programu startowego
if( wykonaj==1 )
{
program( PROGRAM );//uruchom program startowy uprzednio wybrany w menu
wykonaj=0;//i wykonaj go wyłącznie raz!
}

// *** sprawdzanie napięcia akumulatora
if( pomiar(7)<=aku_adc ) prog_stop();

//blok warunkowy - odczyt stanu KTIR1
if( pomiar(5)<=a )
{
obrot_p();
}

//blok warunkowy - odczyt stanu KTIR2
if( pomiar(6)<=a )
{
obrot_l();
}

//blok warunkowy - odczyt stanu KTIR1 && KRIR2
if( pomiar(5)<=a && pomiar(6)<=a )
{
obrot_p();
}

//blok warunkowy - odczyt stanu KTIR1 && czujnika przedniego-lewego
if( pomiar(5)<=a && czujnik(TSOP3,IR3) )
{
obrot_p();
}

//blok warunkowy - odczyt stanu KTIR2 && czujnika przedniego-lewego
if( pomiar(6)<=a && czujnik(TSOP3,IR3) )
{
obrot_l();
}

//blok warunkowy - odczyt stanu KTIR1 && czujnika przedniego-prawego
if( pomiar(5)<=a && czujnik(TSOP4,IR5) )
{
obrot_p();
}

//blok warunkowy - odczyt stanu KTIR2 && czujnika przedniego-prawego
if( pomiar(6)<=a && czujnik(TSOP4,IR5) )
{
obrot_l();
}

// blok warunkowy - odczyt czujnika prawego
if( czujnik(TSOP1,IR2) )
{
led_on(1);
skr_l(max_pwm);
}
else
{
led_off(1);
przod(min_pwm);
}

// blok warunkowy - odczyt czujnika lewego
if( czujnik(TSOP2,IR1) )
{
led_on(2);
skr_p(max_pwm);
}
else
{
led_off(2);
}

// blok warunkowy - odczyt czujnika przedniego-lewego
if( czujnik(TSOP3,IR3) )
{
led_on(3);
skr_p(mid_pwm);
}
else
{
led_off(3);
}

// blok warunkowy - odczyt czujnika przedniego-prawego
if( czujnik(TSOP4,IR5) )
{
led_on(4);
skr_l(mid_pwm);
}
else
{
led_off(4);
}

// blok warunkowy - odczyt czujnika przedniego
if( czujnik_przod() )
{
if( pomiar(5)<=a || pomiar(6)<=a )
{
obrot_p();
}
else
{
led_on(3);
led_on(4);
przod(max_pwm);
}
}
else
{
led_off(3);
led_off(4);
}

//blok warunkowy - odczyt stanu S2
if( !( PINC & S2 ) )
{
_delay_ms(100);
if( !( PINC & S2 ) )
{
start=0;//jeśli wciśnięty - zatrzymaj robota
ss2=1;//i wyjdź do menu wyboru PROGRAM TESTOWY/PROGRAM GŁÓWNY
}
else
{
start=1;//jeśli nie - walcz dalej
ss2=0;//i nie wychodź do menu wyboru PROGRAM TESTOWY/PROGRAM GŁÓWNY
}
}
}
}
}
}
// ********** koniec funkcji głównej programu

// *** definicje funkcji
uint16_t pomiar(uint8_t kanal)
{
ADMUX=(ADMUX & 0xf8)|kanal;
ADCSRA|=(1<<ADSC);
while(ADCSRA & (1<<ADSC));
return ADCW;
}

void prog_stop(void)
{
//zahamuj wszystkie silniki, wyłącz wszystkie diody IR, wyświetl sekwencję zapalania/gaszenia wszystkoch diod
HAM;
PORTB &= ~( IR1 | IR2 | IR3 | IR4 | IR5 );
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(250);
_delay_ms(250);
led_on(1);
led_on(2);
led_on(3);
led_on(4);
_delay_ms(250);
_delay_ms(250);
led_off(1);
led_off(2);
led_off(3);
led_off(4);
//wykonaj pętlę zabierającą 100% czasu procesora
while(1);
}

void odlicz_5s(void)
{
b=0;
while( b<19 )
{
_delay_ms(250);
led_xor(1);
led_xor(2);
led_xor(3);
led_xor(4);
b++;
}
led_off(1);
led_off(2);
led_off(3);
led_off(4);
_delay_ms(100);
}

void led_on(uint8_t numer_on)
{
switch ( numer_on )
{
case 1: ( PORTC &= ~LED1 ); break;
case 2: ( PORTC &= ~LED2 ); break;
case 3: ( PORTC &= ~LED3 ); break;
case 4: ( PORTD &= ~LED4 ); break;
default: {}; break;
}
}

void led_off(uint8_t numer_off)
{
switch ( numer_off )
{
case 1: ( PORTC |= LED1 ); break;
case 2: ( PORTC |= LED2 ); break;
case 3: ( PORTC |= LED3 ); break;
case 4: ( PORTD |= LED4 ); break;
default: {}; break;
}
}

void led_xor(uint8_t numer_xor)
{
switch ( numer_xor )
{
case 1: ( PORTC ^= LED1 ); break;
case 2: ( PORTC ^= LED2 ); break;
case 3: ( PORTC ^= LED3 ); break;
case 4: ( PORTD ^= LED4 ); break;
default: {}; break;
}
}

void program(uint8_t prog)
{
switch ( prog )
{
//*** PROGRAM STARTOWY 0
case 0:
{
PROGRAM=0;
};
break;

//*** PROGRAM STARTOWY 1
case 1:
{
//skr_p(max_pwm);
//_delay_ms(250);
//_delay_ms(100);

program_prawa(0,14,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 2
case 2:
{
//skr_l(max_pwm);
//_delay_ms(250);
//_delay_ms(100);

program_lewa(0,14,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 3
case 3:
{
//skr_p(max_pwm);
//_delay_ms(250);
//_delay_ms(50);

program_prawa(0,12,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 4
case 4:
{
//skr_l(max_pwm);
//_delay_ms(250);
//_delay_ms(50);

program_lewa(0,12,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 5
case 5:
{
//skr_p(max_pwm);
//_delay_ms(250);
//_delay_ms(150);

program_prawa(0,16,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 6
case 6:
{
//skr_l(max_pwm);
//_delay_ms(250);
//_delay_ms(150);

program_lewa(0,16,0,max_pwm);
};
break;

//*** PROGRAM STARTOWY 7
case 7:
{
//skr_p(350);
//_delay_ms(250);
//_delay_ms(250);
//_delay_ms(250);
//_delay_ms(150);
//skr_p(max_pwm);
//_delay_ms(250);

program_prawa(36,10,350,max_pwm);
};
break;

//*** PROGRAM STARTOWY 8
case 8:
{
//skr_l(350);
//_delay_ms(250);
//_delay_ms(250);
//_delay_ms(250);
//_delay_ms(150);
//skr_l(max_pwm);
//_delay_ms(250);

program_lewa(36,10,350,max_pwm);
};
break;

default: {}; break;
}
}[/syntax]

Będę ogromnie wdzięczny za każdą pomoc :D Robot wprawdzie przechodzi na emeryturę, ale chciałbym go odstawić na półkę, jako w pełni ukończonego :)

Statystyki: Napisane przez piotreks-89 — 8 cze 2014, o 09:17

]]>