ATNEL tech-forum

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-29T20:22:50+01:00

Koledzy, walczę dalej z tym odbiornikiem Manchester. Sprawdziłem na oscyloskopie - nadajnik nadaje poprawnie. Na symulatorze proteusa działa dobrze nadawanie i odbieranie. Dioda w while() przełącza się. Natomiast na rzeczywistym układzie nie działa. Gdzieś jest jakiś babol. Tylko gdzie. Mam wrażenie, że procesor sie zawiesza, bo wstawiając przełączanie diody w kod przerwania od INT0 albo w kod przerwania od porownania z OCR0A dioda zaswieca sie, przy nastepnych ramkach danych już świeci i ani mrugnie.

[syntax=c]#include
#include
#include
#include

volatile short int okres, cykl, testczas, bity_startowe, bit, byte, przeczytano, dana;
int tt;
void przelacz(void)
{
PORTB^=0b00000100;
}

int init(void)
{

MCUCR|=(1<GIMSK|=(1<// zegar
TCCR0B|=(1<
}

//---------------------------TU przerwanie od INT0
ISR(INT0_vect)
{

if (bity_startowe==0)
{
if (cykl==0)
{
TCNT0=0;
cykl=1;
}
else
{
okres=TCNT0;
cykl=0;
if (okres>72 && okres<80) // odebrano bity startowe z poprawnym okresem
{
bity_startowe=1;
testczas=okres*3/4;
OCR0A=testczas; //testczas do sprawdzania bitow
//odczytano bity startowe poprawnie, obliczono czas probkowania kolejnych danych,
//ustawienie przerwania od kazdego zbocza
GIFR|=(1<MCUCR&=~(1<GIMSK&=~(1<TCNT0=0; // zeruj licznik, za chwile bedzie probkowanie
TIFR0 = (1<TIMSK0|=(1<
}
else
{
bity_startowe=0; // nie odczytano wlasciwych bitow startowych, za duzy lub za maly okres
}
}
}
else // tu kazde zbocze bitow danych
{
GIFR|=(1<MCUCR&=~(1<GIMSK&=~(1<TCNT0=0;
}
{
}
}

ISR(TIM0_COMPA_vect) //
{

if ((PINB&0b00000010)!=0 ) // jezeli PINB=1 to byte = 0
byte=0;
else
byte=1;

dana=(dana<<1); //przesun w lewo o 1
dana=dana|byte;

bit++;

GIMSK|=(1<MCUCR|=0b00000001; //kazda zmiana na INT0 wyzwala przerwanie

if (bit==12)
{

przeczytano=1;
bity_startowe=0;
TIFR0 = (1<TIMSK0&=0b11111011; // wylacz przerwania z COMPA
bit=0;
byte=0;
GIFR|=(1<GIMSK&=~(1<}
}
// -------------------------------------

//-----------------------------------------------------------------------------
int main(void)
{
DDRB|=0b00000100;

init();
sei();

while(1)
{

if (przeczytano==1 && dana==0b000000000001)
{

przelacz();
dana=0;
przeczytano=0;
_delay_ms(10);
init();
sei();
}
}

}[/syntax]

Statystyki: Napisane przez krzysiekk — 29 lis 2016, o 20:22

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-27T20:31:03+01:00

No i zrobiłem, na symulatorze proteusa dziala dobrze. Tzn nadajnik i odbiornik komunikują się
ze sobą. Po nadaniu paczki danych przez nadajnik, odbiornik odczytuje je, porównuje z wartością wpisaną w odbiornik i przełącza diodę na stan przeciwny. Po załadowaniu natomiast wsadów do
realnych układów, tzn nadajnika i odbiornika i po połączeniu ich - na razie - przewodem sygnałowym i masą układ odbiornika nie przełącza diody. Niestety nie jestem w stanie w warunkach domowych sprawdzić poprawności wysyłanej ramki danych, bo nie mam oscyloskopu...więc puki co nic nie ruszę dalej :/

Statystyki: Napisane przez krzysiekk — 27 lis 2016, o 20:31

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T20:05:54+01:00

Rewelacja!!!! Serdecznie Ci dziękuję.

Statystyki: Napisane przez krzysiekk — 26 lis 2016, o 20:05

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T19:33:32+01:00

Nie analizowałem dokładnie kodu, jednak na początek miałbym taką uwagę.

Zauważyłem, że wyłączasz przerwania, po czym ponownie je włączasz.

Po pierwsze we funkcji przerwania_wylacz() robisz to niepoprawnie (powinno być & zamiast |). Poza tym dla uzyskania większej czytelności lepiej zrobić to tak:[syntax=c]TIMSK0 |= (1<TIMSK0 &= ~(1<Wtedy nie ma wątpliwości jaki bit ustawiasz czy też zerujesz.

Po drugie, wyłączenie przerwań jest często błędnie interpretowane. Ustawienie czy też zerowanie (akurat w tym przypadku) bitu OCIE0B w rejestrze TIMSK0 oznacza tylko wyłączenie zezwolenia na przerwanie. Timer cały czas zlicza impulsy (TCNT0) i kiedy jego wartość zrówna się z wartością rejestru OCR0B zostanie ustawiona flaga OCF0B w rejestrze TIFR0. W tej sytuacji procedura obsługi przerwania nie zostanie uruchomiona, ponieważ zezwolenie jest wyłączone, jednak flaga jest ustawiona i zostaje zapamiętana. Kiedy ponownie włączysz zezwolenie na to przerwanie (OCIE0B w TIMSK0), procedura jego obsługi zostaje natychmiast uruchomiona niezależnie od aktualnego stanu licznika TCNT0, bo przecież flaga została już ustawiona wcześniej.

Flaga zostaje wyzerowana dopiero wtedy, gdy przerwanie zostanie obsłużone (przez procedurę obsługi) lub gdy wyzerujemy ją programowo. Ewentualnym rozwiązaniem wydawałoby się może wyłączenie zliczania przez licznik (by uniknąć ustawienia flagi), ale to i tak nie zawsze zagwarantuje, że flaga nie zostanie ustawiona. Dlatego moim zdaniem lepszym rozwiązaniem (przynajmniej w tym przypadku) jest programowe zerowanie flagi tuż przed zezwoleniem na przerwanie:[syntax=c]...
TIFR0 = (1< TIMSK0 |= (1<...[/syntax]

Statystyki: Napisane przez andrews — 26 lis 2016, o 19:33

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T19:32:59+01:00

Znalazlem przyczyną, dlaczego wychodzil mi do main(). Pracowałem nad inną wersją kodu i miałem
ustawione to tak, że włączone było przerwanie od rejestru A, a wektor procedury przerwania
byl ISR(TIM0_COMPB_vect) ... wersja kodu powyżej nie ma tego błędu.

Wychodzenie do main już jest naprawione, natomiast wciaż nie moge odnaleźć przyczyny,
dlaczego wywołuje mi się przerwanie ISR(TIM0_COMPA_vect) mimo że nie TCNT0 osiąga
wartości wpisanej do rejestru OCR0A...

Statystyki: Napisane przez krzysiekk — 26 lis 2016, o 19:32

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T17:09:36+01:00

Robie teraz podejscie z symulatorem Atmel Studio i jego stimulifile do debuggera. A kod...

Program jest odbiornikiem kodu manchester. Kod napisałem sam, bez posiłkowania się
książkami, stad pewnie niestandardowo to robię i pewnie niejednokrotnie wyważam otwarte już przez innych drzwi, popełniając przy tym liczne błędy. Odbiornik ten ma docelowo służyć do komunikacji radiowej, na razie jednak w proteusie symulacje robie tak, że jeden uC podłączony jest wyjściem do wejścia INT0 (PB1) drugiego uC, którego kod jest poniżej. Jak odbierze poprawną daną, ma zaświecić diodę.

[syntax=c]#include
#include
#include
#include

volatile int okres, cykl, testczas, bity_startowe, bit, byte, przeczytano, dana;

void przelacz(void)
{

PORTB^=0b00000100;
}

int init(void)
{
MCUCR|=0b00000011; //narastajacy stanu wyzwala przerwanie
GIMSK|=0b01000000; //przerwanie z INT0

// zegar
TCCR0B|=0b00000100; //preskaler na 256

return 0;
}

void counter_zero(void)
{
TCCR0B=0;//wylacz zegar
TCNT0=0 ;//wyzeruj zegar
TCCR0B|=0b00000100; // wlacz zegar na preskaler 256
}
void init2()
{
GIMSK|=0b01000000; //przerwanie z INT0
counter_zero();
TIMSK0|=0b00001000; // wlacza przerwanie COMPB
MCUCR&=0b11111101; // wylacz reakcje na zbocze narastajace na rzecz....
MCUCR|=0b00000001; // kazda zmiana INT0 wywoluje przerwanie

}
void przerwania_wylacz()
{
TIMSK0|=0b1110111;
}
//---------------------------TU
ISR(TIM0_COMPB_vect) //
{
if ((TCNT0==0) || (przeczytano!=0))return;
bit++; //licz bity
if ((PINB&0b00000010)!=0 ) // jezeli PINB=1 to byte = 0
byte=0;
else
byte=1;

dana=(dana<<1); //przesun w lewo o 1
dana=dana|byte;
if (bit==12)
{
przeczytano=1;
bity_startowe=0;
init();
TIMSK0&=0b11110111; // wylacz przerwania z COMPB
bit=0;
}
else
{
przeczytano=0;
}
counter_zero();
GIMSK|=0b01000000; //przerwanie z INT0
}
// -------------------------------------
ISR(INT0_vect)
{
if (bity_startowe==0)
{
if (cykl==0)
{
counter_zero();
cykl=1;
}
else
{
okres=TCNT0;
cykl=0;
if (okres>72 && okres<80) // odebrano bity startowe
{
bity_startowe=1;
testczas=okres*3/4;

OCR0B=testczas; //testczas do sprawdzania bitow

init2();
}
else
{
bity_startowe=0;
}
}
}
else // tu kazde zbocze bitow danych
{
GIMSK&=0b10111111; // wylacz reakcje na zbocze
counter_zero(); // zeruj licznik
}
}

//-----------------------------------------------------------------------------
int main(void)
{
DDRB|=0b00000100;

init();
sei();

while(1)
{
if (dana==0b000000001111)
{
przelacz();
dana=0;
}
}

}[/syntax]

Statystyki: Napisane przez krzysiekk — 26 lis 2016, o 17:09

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T14:51:10+01:00

krzysiekk napisał(a):

Pytam tak lakonicznie, ponieważ być może nie wiem o czymś, co jest w jakiś tam sposób naturalne.

To co opisujesz nie jest oczywiście naturalne. Nie musi jednak wynikać z błędnej symulacji, lecz np. ze źle napisanego kodu. Przykładowo ten mikrokontroler ma stosunkowo mało pamięci RAM, więc łatwo doprowadzić do sytuacji, kiedy dane programu nadpisują stos. A na stosie są przecież między innymi adresy powrotu z funkcji czy też z procedury obsługi przerwania i wtedy mogą się dziać różne dziwne rzeczy.

Możemy sobie tutaj tak gdybać nie wiadomo jak długo bez skutku, jednak myślę, że raczej nikt Ci nie pomoże znaleźć przyczyny problemów, dopóki nie przedstawisz kodu.

Statystyki: Napisane przez andrews — 26 lis 2016, o 14:51

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-26T12:55:57+01:00

Pytam tak lakonicznie, ponieważ być może nie wiem o czymś, co jest w jakiś tam sposób naturalne.
Co do Proteusa...to ogolnie jakis dziwny jest ten symulator. Teraz na przykład ni stad ni zowąd wraca mi z procedury przerwania do main() i wykonuje
tam instrukcje inicjalizacyjne, jakby został reset wywołany. A w progranie nigdzie nie dałem żadnego resetu. Gdy natomiast wchodze do sumulatora w trybie
dissassembly,to symulacja nie wychodzi mi do main(). Nic już nie rozumiem, a poziom frustracji rośnie.

Statystyki: Napisane przez krzysiekk — 26 lis 2016, o 12:55

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-25T22:23:01+01:00

Mogą się zdarzyć sytuacje, gdy tak nie będzie, ale za dużo pisania, żeby to wytłumaczyć, a bez kodu trudno zgadywać przyczynę zachowania symulatora, które opisałeś (w dodatku niezbyt dokładnie).

Nie mam tutaj zamiaru bronić Proteusa. Nie znam tego programu i nie wiem, na ile poprawnie symuluje mikrokontrolery AVR. Ja tylko próbuję skorygować Twój tok rozumowania

Statystyki: Napisane przez andrews — 25 lis 2016, o 22:23

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-25T21:44:08+01:00

Ok, ale gdy nie ustawie trybu CTC, to nie powinno mi zerowac timera i po wejsciu w procedure obslugi tego przerwania TCNT0 powinno miec wartość o 1 większa niż OCR0A. Czy to sie zgadza?

Statystyki: Napisane przez krzysiekk — 25 lis 2016, o 21:44

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-25T20:17:55+01:00

krzysiekk napisał(a):

...a procek wchodzi mi do ISR(TIM0_COMPA_vect) przy TCNT0 = 0

A jakiej wartości TCNT0 się spodziewasz? Przecież w trybie CTC w momencie ustawienia flagi przerwania od porównania OCF0A jednocześnie jest zerowany rejestr TCNT0.

Spójrz do noty katalogowej na rysunek 11-11 na stronie 69 to zrozumiesz, dlaczego w momencie wejścia w procedurę obsługi przerwania rejestr TCNT0 musi być równy 0.

Możesz spróbować ustawić przerwanie od porównania z OCR0B (oczywiście ustawiając wcześniej wartość tego rejestru na wartość mniejszą od OCR0A). Wtedy po wejściu do procedury obsługi przerwania wartość TCNT0 będzie o 1 wyższa od wartości OCR0B.

Statystyki: Napisane przez andrews — 25 lis 2016, o 20:17

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-25T17:11:19+01:00

Robie tak samo, potem debugguje dalej...a procek wchodzi mi do ISR(TIM0_COMPA_vect) przy TCNT0 = 0 :O

Statystyki: Napisane przez krzysiekk — 25 lis 2016, o 17:11

Re: pytanie o przerwanie z porownania licznika z rejestrem

2016-11-25T13:40:38+01:00

Może nie włączyłeś trybu CTC i przerwanie dostajesz z przepełnienia.

[syntax=c]/*
TCCR0A |= (1<TIMSK0 |= (1<OCR0A = 150; //Wpisanie wartosci 150 do rejesru porownania aby uzyskac przerwanie co 1KHz (przy taktowaniu 9,6MHz)
TCCR0B |= ( (1<*/

/*
ISR(TIM0_COMPA_vect) //Obsluga przerwania zglaszanego przez osmiobitowy TIMER0 pracujacy w trybie CTC
{

}
*/[/syntax]

U mnie po takim ustawieniu timera przerwanie działa prawidłowo.

Statystyki: Napisane przez P3ndz3l3k — 25 lis 2016, o 13:40

pytanie o przerwanie z porownania licznika z rejestrem

2016-11-24T20:26:18+01:00

Panowie (a może też panie),

czy jest taka szansa, aby uC wchodził mi do procedury przerwania ISR(TIM0_COMPA_vect)
mimo że TCNT0 nie osiągnął wartości wpisanej do OCR0A?

Czy ja o czymś nie wiem?

Tak mi się dzieje w Proteusie, przy Attiny 13, w debugerze.

Pozdrawiam
KK

Statystyki: Napisane przez krzysiekk — 24 lis 2016, o 20:26