Pułapki AVR: Zerowanie bitu przez wpisanie jedynki

Autor: Dondu

Artykuł jest fragmentem cyklu: Pułapki mikrokontrolerów AVR

Co to jest zerowanie bitu? To wpisanie zera na wybranym bicie jakiegoś rejestru. Zapewne wiesz już, że należy użyć takiego kodu:

nazwa_rejestru &= ~(1<<nazwa_bitu);

//na przykład zerowanie bitu TWEN w rejestrze TWCR
TWCR &= ~(1<<TWEN);

Więcej na temat operacji na bitach: Ustawianie i zerowanie bitów

Niestety w niektórych rejestrach mikrokontrolerów AVR są wyjątki od tej reguły, a wyzerowanie bitu za pomocą programu, następuje poprzez wpisanie jedynki, a nie zera. 

y0yster
... czyli musi być wyczyszczona przez zapisanie tam 1. Nie czaję tego.
Normalnie już sobie włosy wyrywam.

Na potrzeby tego artykułu, nazwę te bity, "bitami szalonymi", podobnie jak manewr Szalonego Iwana.

Przykład:

Rys. Rejestr TWCR mikrokontrolera ATmega8

Czyli, aby wyzerować bit TWINT musimy zapisać do niego jedynkę:

TWCR |= (1<<TWINT);  //zerowanie przez wpisanie jedynki

Jak widzisz, zarówno TWEN jak i TWINT znajdują się w tym samym rejestrze, ale ich zerowanie jest realizowane różnie:

• TWEN - przez wpisanie zera,
• TWINT - przez wpisanie jedynki (bit "szalony")

Ale to nie jedyny problem!

Prześledźmy przykład, w którym bit TWINT jest ustawiony (czyli występuje żądanie obsługi przerwania), ale przerwanie jeszcze nie zostało obsłużone, a właśnie dokonujemy zmiany bitów w rejestrze TWCR:

Stan początkowy rejestru TWCR był na przykład taki (binarnie): 10000100 co oznacza, że ustawione były bity  TWINT oraz TWEN.

Załóżmy, że teraz programista chce ustawić tylko i wyłącznie bit TWEA. Robi to w najprostszy sposób

TWCR |= (1<<TWEA); //chcemy ustawić tylko i wyłącznie bit TWEA

Poniżej kod wygenerowany przez kompilator:

IN  R24,  0x36 //wczytaj do rej R24 zawartość rejestru TWCR (adres 0x36)
ORI R24,  0x40 //suma logiczna R24 oraz liczby reprezentującej (1<<TWEA)
OUT 0x36, R24  //zapisz nową wartość do rejestru TWCR

Czy widzisz coś groźnego w tym kodzie, co dotyczy bitu TWINT?

No to zobaczmy, co będzie w rejestrze R24 po wykonaniu dwóch pierwszych rozkazów assemblera pokazanych powyżej:

Trzeci rozkaz assemblera z kodu powyżej załaduje więc do rejestru TWCR nową wartość (binarnie) 11000100.

W przypadku bitu TWEA jedynka zostanie poprawnie ustawiona.

W przypadku bitu TWINT zgodnie z zasadą zerowania przez wipsanie do niego jedynki (bit "szalony"), bit ten zostanie wyzerowany (!) pomimo, że w kodzie C w ogóle go nie wskazywaliśmy.

Podobnie będzie, gdy będziemy chcieli wyzerować jakiś bit za pomocą &= na przykład tak:

TWCR &= ~(1<<TWEN); //chcemy wyzerować wyłącznie bit TWEN

Niestety także wtedy nastąpi podobny ciąg instrukcji assemblera, które także wyślą do rejestru TWCR bajt zawierający jedynkę na bicie TWINT, co spowoduje jego wyzerowanie.

Jak sobie poradzić?
Niestety operując na rejestrach zawierających bity kasowane przez wpisanie jedynki, należy samemu zadbać o to, by wpisując nową wartość nie mieć jedynki na takim bicie. Są dwie metody, które pokażę ponownie na przykładzie bitu TWINT:

1. zapis konkretnej wartości wszystkich bitów,
2. wykorzystanie rejestru pośredniczącego.

Pierwszy sposób, zmusza Ciebie do perfekcyjnego pilnowania co w rejestrze ma być w danej chwili, co nie jest takie proste przy bardziej skomplikowanych programach. Wykorzystujesz wtedy po prostu wpisanie nowej wartości całego rejestru, z wyzerowanym bitem TWINT:

TWCR = (1<<TWEA) | (1<<TWEN); 

Drugi sposób to wykorzystanie rejestru pośredniego:

//możemy zrobić tak:
register unsigned char rej_posr; //definiuj rejestr pomocniczy
rej_posr = TWCR & ~(1<<TWINT);   //odczytujemy TWCR do zmiennej pomocniczej 
                                 //i zerujemy w niej bit TWINT
rej_posr |= (1<<TWEA);           //dodajemy bity które chcemy ustawić 
                                 //lub zerujemy za pomocą &=
TWCR = rej_posr;                 //zapisujemy całość do rejestru TWCR


//lub w uproszczeniu tak:
TWCR =  (TWCR  | (1<<TWEA)) & ~(1<<TWINT);

Wygenerowany przez kompilator kod będzie wyglądał tak:

IN  R24,0x36  //wczytaj do rej R24 zawartość rejestru TWCR (adres 0x36)
ANDI R24,0x3F //wyzeruj bit TWINT
ORI  R24,0x40 //suma logiczna R24 oraz liczby reprezentującej (1<<TWEA)
OUT  0x36,R24 //zapisz nową wartość do rejestru TWCR

Zobaczmy więc jak zachowa się taki kod:

Zauważ, że w wyniku w rejestrze R24 dostajemy prawidłowo ustawione bity TWEA i TWEN oraz wyzerowany bit TWINT. Zapisanie takiej wartości z rejestru R24 do rejestru TWCR (zgodnie z zasadą omawianą w tym punkcie) nie wyzeruje "szalonego" bitu TWINT, który jest w tym rejestrze ustawiony, a którego nie chcieliśmy zmieniać.

Czyli taki kod pozwala nam na spokojne operowanie na bitach rejestrów zawierających "szalone" bity, a różni się defacto tylko jednym rozkazem assemblera: ANDI.


Czy to dotyczy tylko bitu TWINT? 
Nie! Bitów "szalonych" jest więcej, dlatego trzeba uważnie sprawdzać datasheet.
Na przykład dla ATmega8:

• ACI
• ICF1
• INTF0, INTF1
• OCF1A, OCF1B
• OCF2
• TOV0, TOV1, TOV2
• TWINT

W innych mikrokontrolerach mogą być także inne bity - zawsze sprawdzaj w datasheet!

Ta pułapka jest jednym z najczęściej występujących problemów stających na drodze początkujących.

Zobacz pozostałe pułapki AVR

• Pułapki AVR: Spis treści