Jak poprawnie rozbić bajt na bity w komunikacji szeregowej z użyciem Keil?

witam ponownie...
Znowu zatrzymalem sie na jakiejs drobnostce. Chcialem zrobic komunikacje
szeregowa miedzy procesorami. W zmiennej typu char znak
mam przechowany bajt danych, ktory chce wyslac szeregowo. Wszystko jest

tylko nie potrafie "rozebrac" bajtu na bity...
Chce to zrobic iloczynem logicznym, mam ksiazke do ansi c i tam jest
napisane ze wynikiem operacji bajt & bajt = true/false, tak tez napisalem
kawalek kodu (do zobaczenia nizej), podczas uruchomienia debuger'a wyszlo

to ze jezeli w znak mam np. 64 (dziesietnie) i wykonam operacje znak & 64

w wyniku otrzymam 64 (0x0040). I jak to interpretowac? dlazcego wynikiem

jest 1?
Jak poprawnie to napisac?

PS. Zmodyfikowalem program jeszcze tak: if (znak & 64 == 64){ ... ale
rowniez nie dziala to prawidlowo. i w wyniku dzialania programu sa same

nn1=0, nn2=0, nn3=0.

pozdrawiam,
Bartek.

//przyklad programu fragment
unsigned char znak;
znak = 0x0040;

if( znak & 128 == 1 ){
data_out = 1;
puts("nn1 = 1");
}
else
{
data_out = 0;
puts("nn1 = 0");
}

data_clk = 0;
while(data_in == 1)
{}
data_clk = 1;
//2

if( znak & 64 == 1){
data_out = 1;
puts("nn2 = 1");
}
else
{
data_out = 0;
puts("nn2 = 0");
}

data_clk = 0;
while(data_in == 1)
{}
data_clk = 1;

//3
if(znak & 32 == 1){
data_out = 1;
puts("nn3 = 1");
}
else
{
data_out = 0;
puts("nn3 = 0");
}

przesunięcie bitowe i sprawdzaj tylko jaka wartosc jest na pierwszej

czyli znak & 1

Znowu zatrzymalem sie na jakiejs drobnostce. Chcialem zrobic komunikacje
szeregowa miedzy procesorami. W zmiennej typu char znak
mam przechowany bajt danych, ktory chce wyslac szeregowo. Wszystko jest ok,
tylko nie potrafie "rozebrac" bajtu na bity...
Chce to zrobic iloczynem logicznym, mam ksiazke do ansi c i tam jest
napisane ze wynikiem operacji bajt & bajt = true/false, tak tez napisalem
kawalek kodu (do zobaczenia nizej), podczas uruchomienia debuger'a wyszlo na
to ze jezeli w znak mam np. 64 (dziesietnie) i wykonam operacje znak & 64 to
w wyniku otrzymam 64 (0x0040). I jak to interpretowac?

Jezeli chcesz sprawdzic, czy bit n jest zapalony, wygodniej napisac:
if (znak & (1<<n))
a jezeli sprawdzasz, czy jest zgaszony:
if (!(znak & (1<<n)))
i juz.

Podobnie gdy w zmiennej znak chcesz zapalic bit n:
znak |= (1<<n);
lub go zgasic:
znak &= ~(1<<n);

W praktyce programujac w C znacznie lepiej jest pozamykac
te operacje w makrach, bo w dluzszym kodzie latwo o pomylke,
np. zapomni sie napisania tyldy. A w przypadku np. BSET(x,n),
BCLR(x,n) i BTST(x,n) taka mozliwosc nie zachodzi.

BTW: Ostatnio spotkałem się z ciekawym błędem (którego kompilator C,
mając pełną rację, nie zauważył), powodującym niezłe zamieszanie. Kumpel
napisał:
a=+5;
zamiast
a+=5;

Piotr Wyderski wrote:

a=+5;

zamiast

a+=5;

Patrząc na kod, ciężko to zauważyć, a wynik jest do przewidzenia. Z
drugiej strony to ciekawe, że można sobie napisać tak po prostu stałą +5
i już.
Im mniejszy błąd tym dłużej się go tropi. :-)

Chce to zrobic iloczynem logicznym, mam ksiazke do ansi
c i tam jest napisane ze wynikiem operacji bajt & bajt = true/false

podczas uruchomienia debuger'a wyszlo na to ze jezeli w znak mam
np. 64 (dziesietnie) i wykonam operacje znak & 64 to w wyniku
otrzymam 64 (0x0040). I jak to interpretowac?

Jak poprawnie to napisac?

PS. Zmodyfikowalem program jeszcze tak: if (znak & 64 == 64){ ... ale
rowniez nie dziala to prawidlowo.

Albo ksiazka klamie, albo Ty zaniedbales kontekst. :-) x & y to jest
operacja na wektorze bitowym (w szczegolnosci na znaku) i jej
wynikiem jest rowniez wektor bitowy, stad trudno przypuszczac, by
mogl sie on rownac true albo false.

W czym problem ?

Niezerowy wektor bitowy jest traktowany jako logiczne 1,
zerowy jako 0.

Jakos nie narzekam na te "nieproszona" konwersje typow,
szczegolnie ze jest ona chyba najnaturalniejsza z naturalnych.

Spotkalem sie w jednym kompilatorze z bledem, polegajacym na rzutowaniu
wektora bitowego na wartosc logiczna przez wziecie najmlodszego bitu
(zrzutowanie bajtu na bit a potem na wartosc logiczna).

W tym, ze wektor bitowy to zupelnie inny typ niz jego skladowa
i nie mozna wprost dokonac unifikacji obu typow. Tak samo jest
np. w przypadku zbioru jednoelementowego. Jest jasne, ze nie
jest on rownowazny swojemu elementowi, {a} != a. Jest to po
prostu niedopuszczalne na poziomie formalnym.

Niezerowy wektor bitowy jest traktowany jako logiczne 1,
zerowy jako 0.

Ale to wymaga niejawnej konwersji typu {0,1}^n -> bool.

Porzadne jezyki programowania nie zezwalaja na automatyczna
zmiene typu argumentu i zglaszaja to uzytkownikowi jako blad
systemu typow, wymuszajac jawne rzutowanie, a w C nawet
nie dostaniesz informacji, ze cos jest nie tak. Zreszta takich
kwiatkow jest wiecej.

Jakos nie narzekam na te "nieproszona" konwersje typow,
szczegolnie ze jest ona chyba najnaturalniejsza z naturalnych.

Sa ludzie, ktorzy narzekaja, a ja sie do nich zaliczam, bo na
pierwszym miejscu stawiam sobie elegancje i spojnosc formalna
jezyka. Przyznaje, ze C jest wygodnym narzedziem, uzywam
go i bede uzywal oraz uczyl tego jezyka studentow informatyki (...)

Znowu zatrzymalem sie na jakiejs drobnostce. Chcialem zrobic komunikacje
szeregowa miedzy procesorami. W zmiennej typu char znak
mam przechowany bajt danych, ktory chce wyslac szeregowo. Wszystko jest ok,
tylko nie potrafie "rozebrac" bajtu na bity...

PS. Zmodyfikowalem program jeszcze tak: if (znak & 64 == 64){ ... ale
rowniez nie dziala to prawidlowo. i w wyniku dzialania programu sa same zera
nn1=0, nn2=0, nn3=0.

unsigned char znak;
znak = 0x0040;

if( znak & 128 == 1 ){

if( znak & 64 == 1){ [...]
//3
if(znak & 32 == 1){ [..]

tylko nie potrafie "rozebrac" bajtu na bity...