Jestem na początku BB (190st) i próbuje przerabiać poznane programy po swojemu ,teraz siedze nad programem w którym
diody powinny zapalać się jedna po drugiej przy tym nie gasnąć a na końcu pentli wszystkie osiem gaśnie.
Myślałem że poradze sobie sam ale dałem za wygraną i prosze o pomoc.
Oto jedna z wersji:


Pozd.

witam,
Tak dla zastanowienia się,
jeżeli program wejdzie w "for",
to tak długo tam wykonuje operacje i nie wyjdzie z pętli aż " i" nie będzie <8,

w tablicy masz zdefiniowane wartości każdego bitu.
ale wysyłając na port powinieneś tę nową wartość z tablicy dopisać do istniejącej wartości portu, a nie przyrównać.
Jeżeli chcesz przyrównać to musisz tak zmienić wartości w tablicy, żeby wypełniały bity w bajcie(porcie).
dla rozjaśnienia
0000 0001 - 1
0000 0010 - 2
0000 0100 - 4
to jest to co masz w tablicy.
a może jeśli już to umieść w tablicy
0000 0001 - 1
0000 0011 - 3
0000 0111 - 7
0000 1111 - 15
zauważ że każda następna wartość to (poprzednia*2) +1 ,
pomyśl może nad zastosowaniem takiego algorytmu.

Diody zapalają się poprawnie jedna po drugiej ale gasną ,ja chcę otrzymać efekt że zapali się pierwsza ,zapali się druga i nie
zgaśnie i tak dalej....... i nie rozumiem:
1-zapala się dioda pierwsza
3-zapala się dioda druga
7-zapala się dioda ......

no nie sprawdzę teraz, ale może tak

chodzi o to żeby do pierwszej świecącej dołączyć drugą i trzecią, a nie ją wyświetlić.
pisząc PORTx = coś;
port będzie miał wartość podaną. czyli jedną z tablicy, a nie ich jakby nałożenie. na siebie

Przeanalizuj sobie poniższy kod:


Powołałem tablicę 9-elementową:
tab[0] - zapala się dioda nr1
tab[1] - zapala się dioda nr1 i dioda nr2
tab[2] - zapala się dioda nr1, nr2 i nr3
.
.
.
tab[7] - zapalają się wszystkie diody
tab[8] - gasną wszystkie diody

Mam nadzieję, że jest to jasne. W razie czego pytaj czego nie rozumiesz.

To samo "zadanie" można zrealizować wbrew pozorom na wiele sposobów, niekoniecznie wykorzystując tablicę, a wykorzystując na przykład przesunięcia bitowe. Na podstawie "wersji wojskowej" z bloga: http://mirekk36.blogspot.co.uk/2012/10/ror-rolowanie-bitow-wersja-wojskowa.html można to napisać tak:



Myślę, że warto takie podejście również przeanalizować.

Dziękuje za podpowiedzi -metoda tablicowa teraz wydaje się banalnie prosta ale nie wiedziałem że w nawiasach tablicy
moge dodawać ,co do pezesunięć bitowych wracam do BB i bloga.
Następnym krokiem będzie podłączenie klawiszy.

PS.-Jeszcz jakiś przykład będzie mile widziany .

Pozd.

Witam jeśli chodzi o zapalenie ledow ja polecam koledze analizę kodów do realizacji robaka to jest dopiero kopalnią wiedzy. Dodam, że robak to konkurs który pojawił się tu na forum.
Pozdrawiam

Wysłane z mojego HTC One_M8 przy użyciu Tapatalka

Mam jeszcze ptyanie dotyczące Wersji Wojskowej dlaczego podczas przewijania w prawo
bajt = ( (bajt>>1) | ( bajt<<7 ) );
diody świecą:
1-pierwsza po prawej
2-pierwsza po lewej
3-druga po lewej itd. do szóstej i pentla zaczyna się od nowa.

Pozd.

Cieszę się, że "metoda tablicowa" okazała się banalnie prosta.
Tak samo będzie z wersją wojskową.
Myślę, że powinieneś to sobie rozpisać na kartce papieru, krok po kroku.
Poniżej wersja wojskowa w prawo:


Dlaczego teraz działa?

O ile dobrze rozumiem to ( bajt>>1) zapala się pierwsza dioda najstarszy bit (128) przesunięcie o "1" i zapala się następna bit(64) i tak do "7" a (bajt<<7) oznacz powrót do "1" , a co z PORTA=~bajt; to ostatnia dioda,
a może (bajt<<7) przy zapaleniu się ostatniej powrót do pierwszej.

Pozd.

Witam,
Tu musisz wziąć pod uwagę kilka rzeczy na raz.
Aktualny stan Port.
Nowy stan port- po kazdej operacji.
Oraz przesuniecie aktualnego stanu portu w lewo oraz w prawo i nałożenie wyników na siebie.
Wynik jest w następnym obiegu stanem wyjściowym port.
1000 0000 = ( 1000 0000 >> 1) | ( 1000 0000<<7).
Czyli ........= (0100 0000) | (0000 0000)
Czyli........= (0100 0000). Po operacji |.
I wszystko sie powtarza ale z port już równym 0100 0000.

------------------------ [ Dodano po: 53 minutyach ]

Natomiast kiedy wynik portu dojdzie do wartości 0000 0001
Port 0000 0001 zaraz będzie miał wartość:
= (0000 0001>>1) | (0000 0001<<7) // wartość portu przed operacja gotowa do przesunięcia.
Czyli po przesunieciach
=(0000 0000) | (1000 0000)
Po operacji |
Nowa wartość portu 1000 0000

Kolego Daro69 ma rację, że trzeba wziąść pod uwagę kilka rzeczy na raz, przede wszystkim to, że zmienna bajt jest zadeklarowana i jednocześnie zdefiniowana jako zmienna globalna, która domyślnie przyjmuje wartość 0. Dlatego w poniższej tabelce rozpisałem co po kolei następuje, jaką wartość otrzymuje zmienna bajt w kolejnych obiegach pętli nieskończonej dla kodu z zapalaniem diod Led od lewej do prawej. Sądzę, że na podstawie tego kodu powstał całkiem fajny przykład na zabawę z przesunięciami bitowymi.



I tak w pierwszym obiegu pętli while (patrz pierwsza kolumna) zmienna bajt=0 czyli binarnie 0000 0000 (patrz druga kolumna).
Następnie dokonujemy przesunięcia bitowego o 1 pozycję w prawo (trzecia kolumna) oraz przesunięcia bitowego o 7 pozycji w lewo (czwarta kolumna).
W piątej kolumnie oblicamy sume logiczną (alternatywę) z obliczonych wartości z trzeciej i czwartej kolumny.
W szóstej kolumnie przypisujemy do rejestru wyjściowego PORTA wartość obliczonej zmiennej bajt (wartość z kolumny piątej). Ponieważ diody są podłączone katodami do mikrokontrolera, dlatego dokonujemy po drodze negacji, prawda?
Jeśli to nie jest jasne to polecam: http://mirekk36.blogspot.co.uk/2012/01/avr-porty-wewy-dir-podstawy.html
Za to w ostatniej kolumnie otrzymujemy wynik inkrementacji zmiennej bajt ( bajt++, czyli bajt = bajt +1; ).
W kazdym obiegu pętli wykonujemy dokładnie to samo, czyli przesunięcie bitowe o 1 w prawo, o 7 w lewo, sumę logiczną i wynik przypisujemy do zmiennej bajt:

Następnie podajemy to na port do którego są podłączone diody Led:

Na samym końcu dokonujemy inkrementacji zmiennej bajt.
Porównaj 10 obieg pętli z 1 obiegiem. Wynika z tego, że w 11 obiegu bedzie dokładnie to samo co w 2, w 12 to samo co w 3 itd.
Zauważ w którym momencie dokonujemy przypisania zmiennej bajt do PORTA.
Porównaj sobie kody z przesuwaniem diod Led od prawej do lewej i od lewej do prawej. Zrób sobie taką tabelkę na kartce papieru (tym razem dla kodu z przesuwaniem diod Led od prawej do lewej).
Mam nadzieję, że przesunięcia bitowe i tym razem okażą się dla ciebie banalnie proste.
Jeśli coś jest nie jasne daj znać. Chętnie pomogę.
Pozdrawiam.

Na podstawie tabeli którą przedstawił kolega rozpisałem kod tak jak jest napisany z przesunięciem w lewo i myśle
że coś jest zle, przypuszczam że bajt++.
Przy okazji tego przykładu przećwiczyłem sobie przesunięcia i lepiej je zrozumiałem.




PS.Bardzo fajna tabelka dzięki

Pozd.

no przyjrzałem się tabelce kolegi "anshar" i tam jest wszystko OK.
Natomiast w tabelce powyżej już nie.
w pierwszym słupku jest bajt, w drugim odwrócony bajt , a w trzecim powinien być przesunięty bajt - a nie przesunięty "odwrócony bajt".

------------------------ [ Dodano po: 1 minucie ]

czyli powinny być przesunięte zera a nie jedynki w pierwszej linijce.

Zrobiłem tak jak jest zapisany program bajt , ~bajt i ten odwrócony bajt przesunołem myślałem że jak on jest zapisany
nad przesunięciem to właśnie tan dwrócony bajt zostanie przesunięty .
Kolega "anshar" przedstawił przykład przesunięcia w prawo i tam bajt odwracany jest pod koniec tabeli
ja zrobiłem przesunięcie w lewo .

no tak,
ale to jest tak że nowy bajt = przesunięty stary bajt,
i PORT= odwrócony nowy bajt. (ale ten bajt się nie odwraca tylko odwrócony wynik jest podany do PORT)
a nie że bajt to odwrócony bajt.
.....................................................
mam nadzieję że teraz to nie zakręciłem kolegi za bardzo.

------------------------ [ Dodano po: 7 minutach ]

stary bajt 0000 0001
przesunięty stary bajt np o 3 w lewo da nowy 0000 1000

PORT teraz będzie miał 1111 0111 (bo podajemy mu odwrócony bajt) a bajt nadal jest 0000 1000.
i przesuwamy go znowu np. o 2 w lewo teraz bajt będzie miał 0010 0000 a na port pójdzie
odwrócenie czyli port będzie 1101 1111.

Kolega Daro69 ma rację.
Aż zrobiłem nową tabelkę, tym razem dla przesunięcia w lewo:

hie..
pomęczymy kolegę aż w końcu załapie i będzie zaskoczony że to takie proste.

------------------------ [ Dodano po: 6 minutach ]

może tak :
nie ma tu zapisu bajt = ~bajt;
(bo wtedy rzeczywiście odwrócił by się nam bajt i to on odwrócony by się przesuwał )

W skrucie można by powiedzieć przesuwamy bajt odczytujemy ~bajt , to dlaczego zapisujemy PORTA = ~bajt;
raz na górze (przesunięcie w lewo) a ma dole w prawo.
Same przesunięcia są dla mnie tyiko z zapisem troche ciemniej.
----------------------------------------------------------------------------------
Z tym męczeniem ~bajt

Pozd.

to może jeszcze raz.
bajt to 8 bitów. np "0000 0001"
teraz zrobimy operację przesunięcia na poprzednim kodzie

krok_1 - " PORT = ~bajt;" ----> PORT otrzymuje wartość(1111 1110)= ~odwrócony bajt (0000 0001)
PORT to teraz 1111 1110 , a bajt to 0000 0001 <----------------------****

krok_2 - "bajt = ( (bajt<<1)|(bajt>>7) ) ;
rozbijmy to na drobne.
(stary bajt<<1) --> (0000 0001 << 1) da wynik 0000 0010
(stary bajt>>7) --> (0000 0001 >> 7) da wynik 0000 0000 jedynka i kilka zer wypada z prawej a z lewej wchodzą zera.
te dwa wyniki łączy operator bitowy OR.
(teraz uwaga, to są te nasze dwa wyniki).zamiast zapisać obok siebie utworzę kolumnę.

0000 0010 pierwszy wynik przesunięty
" | " operator
0000 0000 drugi wynik przesunięty
...............
0000 0010 suma przesunięć (nakładanie jedynek na siebie w pionie)

gdyby była jedynka np. na trzecim bicie w którymkolwiek z przesunięć to była by i w wyniku też na trzecim bicie.
teraz nowy bajt ma postać 0000 0010.

teraz jest bajt++; dodanie jeden do nowy bajt.

0000 0010 to wartość 2.
dodamy jeden.
0000 0011 to jest wartość 3
czyli teraz bajt to 0000 0011

i znowu jest polecenie PORT=~bajt; czyli odwrócony ( nowszy bajt 0000 0011 )
od teraz PORT to 1111 1100 a bajt to 0000 0011. <----------------------****

krok_ - "bajt = ( (bajt<<1)|(bajt>>7) ) ;
rozbijmy to znowu na drobne.
( bajt<<1) --> (0000 0011 << 1) da wynik 0000 0110
( bajt>>7) --> (0000 0011 >> 7) da wynik 0000 0000 obie jedynki i kilka zer wypada z prawej a z lewej wchodzą zera.
te dwa wyniki łączy operator bitowy OR.

0000 0110 pierwszy wynik przesunięty
" | " operator
0000 0000 drugi wynik przesunięty
...............
0000 0110 suma przesunięć (nakładanie jedynek na siebie w pionie)

teraz nowy bajt ma postać 0000 0110.

teraz jest bajt++; dodanie jeden do bajt.

0000 0110 to wartość 6.
dodamy jeden.
0000 0111 to jest wartość 7
czyli teraz bajt to 0000 0111 (7)

i znowu jest polecenie PORT=~bajt; czyli odwrócony ( nowszy bajt 0000 0111 )
od teraz PORT to 1111 1000 a bajt to 0000 0111. <----------------------****

itd.....

Dlaczego zapisujemy: PORTA = ~bajt; ?

Ano dlatego, że jeśli zapisalibyśmy PORTA = bajt; to na port A (PORTA) wystawimy (przypiszemy) wartość zmiennej bajt, prawda?
Czyli jeśli bajt = 0b00001111; to na porcie A cztery najstarsze bity przyjmą wartość 0, a cztery najmłodsze wartość 1.
Teraz jeśli diody LED podłączone są anodami do mikrokontrolera, a katodami (oczywiście poprzez rezystory ograniczające prąd) do masy to cztery diody podłączone do PA7, PA6, PA5 i PA4 nie będą się świeciły, za to diody podłączone do PA3, PA2, PA1 i PA0 zaświecą się.
Inaczej jest gdy diody podłączone są odwrotnie, czyli katodami do mikrokontrolera, a anodami (również poprzez rezystory ograniczające prąd) tym razem do Vcc. Teraz diody od PA7 do PA4 będą się świeciły, a cztery pozostałe nie będą.
Dlatego używamy operatora negacji "~" i zapisujemy PORTA = ~bajt;, by diody świeciły się zgodnie z założeniem, że "1" oznacza świecenie, a "0" oznacza nieświecenie.

Dla potwierdzenia zamiast PORTA = ~bajt; napisz PORTA = bajt;, skompiluj i wgraj program do procka. Zobacz co się będzie działo.
Mam nadzieję, że jest to dla ciebie jasne.

Dlaczego zapisujemy PORTA = ~bajt; raz na górze (przesunięcie w lewo) a raz na dole (przesunięcie w prawo)?

A jakie jest założenie programu (programisty)? No przecież to ty sam wymyśliłeś, by diody przesuwały się (zaświecały się po kolei) od prawej strony do lewej przy czym gdy wszystkie osiem diod będą się już świeciły, to w kolejnym kroku mają wszystkie zgasnąć. Z kolei w następnym kroku znowu zaświeci się pierwsza dioda LED itd., prawda?
Przygotowałem dwie tabelki (pierwsza dla przesunięcia w prawo, druga dla przesunięcie w lewo). Zapomnij na razie w jednym i drugim przypadku o kolumnie zawierającej właśnie PORT = ~bajt; i sprawdź czy wszystko się zgadza. Teraz przypomnij sobie jaki chcesz osiągnąć rezultat (jak te biedne diody LED mają się zachowywać).
W którym miejscu umieściłbyś teraz tą linijkę kodu, tak aby diody świeciły i gasły prawidłowo?

Za pomocą "metody wojskowej" chciałem ci pokazać, że wykorzystując mechanizm przesunięć bitowych można osiągnąć w tym przypadku to samo co za pomocą metody tablicowej.
Różnica jest taka, że zamiast tablicy zawierającej 9 zmiennych uint8_t, definiujemy tylko jedną zmienną np. uint8_t bajt i właśnie na niej dokonujemy wszystkie "operacje", czyli przesunięcie bitowe w lewo lub w prawo, bądź inkrementację tej zmiennej.

Proponuję dla odmiany teraz taki kodzik (od prawej do lewej):


Też działa prawidłowo, chociaż wygląda prościej, prawda?
Przeanalizuj go sobie. Zauważ, że zasada działania tego programu, jego algorytm jest bardzo podobny do tego z wykorzystaniem "metody wojskowej" od prawej do lewej. Tylko tutaj trzeba było zadbać o gaszenie diod LED za pomocą dodatkowego warunku if.

A co zrobić, by na podstawie tego kodu powyżej, teraz diody przesuwały się od lewej do prawej?

@Daro69
Damy radę.

Bardzo fajny przykład wiec postanowiłem go rozpisać:
PORTA 1111 1111
1<< 1111 1110
end-------------------
wynik 1111 1110
potem kolejne przesunięcie i pentla ,czy tak to powinno być.

Pozd.

Tu przesuwasz jedynkę o 254 w lewo.
czyli z 0000 0001(jedynka) przesunięta o 254 w lewo będzie (?)
raczej nie 1111 1110 przyjrzyj się.
z lewej strony jest wartość przesuwana a z prawej ilość przesunięć o 1.

------------------------ [ Dodano po: 8 minutach ]

tylko dobrze zrozum, 1111 1110 to wartość 254. a nie siedem jedynek.

Własnie mam problem jak kompilator odczytuje program, Mirek nakrecił film poruszający to zagadnienie ,niekiedy mam z tym problem z zkolejnością odczytu lub zapisu.
Same przesunięcia nie stanowiom problemu, ale zastosowanie ich w kodzie to niekiedy zgadywanka np.:

PORTA-1111 1111-(255)
(1<<1) = (1<<1111 1111)=1111 1110 ( 254 ) =~=0000 0001( 1 )

Pozd.

P
no nie tak.

PORTA = 1111 1111;

PORTA = PORTA << 1 ; /*chcemy przesunąć całą zawartość portu o jedno miejsce w lewo.*/
czyli:
PORTA = 1111 1111 << 1 ;
wynik to PORTA ---> 1111 1110
(wartość przesuwana<<wartość przesunięcia)/* to co z lewej 1111 1111 << w lewo o 1miejsce*/

albo takie coś:
PORTA = 1100 0011;

PORTA = (PORTA<<3); da w wyniku 0001 1000 /*przesunięcie o 3 tego co w PORTA*/

PORTA = (0001 0001<<3); da w wyniku 1000 1000 /*do PORTA wpisaliśmy przesunięte o 3 w lewo to 0001 0001*/

uwaga! odwrotny zapis z innym przesunięciem
PORTA = ( 3 << 0000 0010 ); /*tu przesuwamy trojkę"3"czyli(0000 0011), <<w lewo, (0000 0010)←o dwa miejsca, */ wynik na PORTA
PORTA to 0000 1100

------------------------ [ Dodano po: 6 minutach ]

porównaj zapisy:
(3<<2) czyli (0000 0011 <<0000 0010) // trójka przesuwana o dwa w lewo. -->wynik 0000 1100
(2<<3) czyli (0000 0010 <<0000 0011) //dwójka przesuwana o trzy w lewo. -->wynik 0001 0000

A czy taki zapis jest poprawny:

wynik=1111 1110

1001 0110<<2 ----->0101 1000
0010 0011<<3------>0001 1000
4>>0101 1100------>0000 0101
1>>1101 1010------>0110 1101
Pozd.

Tak to mi wygląda.

Kod z wyrażeniem if (8<1) pezesłał kolega "anshar" (kod powyżej).
No i wreście przechodzimy do sedna sprawy .
Problemem nie są przesunięcia bitowe tylko sam zapis i w jakiej kolejności kompilator odczytuje kod to znaczy :
PORTA=1111 1111 ( PORTA= 0xFF)
a wyrażenie ~ (1<<i) daje wynik 1111 1110 więc poco znak "~"które powinno dać wynik 0000 0001

Pozd.

a...
ten zapis:
~ (1<<i)
jest wyjęty z kontekstu.
w oryginale kolegi "anshar" było : "PORTA &=~ (1<<i);"
To oznacza zerowanie w PORTA bitu na "i" pozycji od prawej.

------------------------ [ Dodano po: 8 minutach ]

w całości zapis PORTA &=~ (1<<i); jeżeli np. i=3;
to to samo co PORTA = PORTA & ~(1<<i);
co można rozpisać:
PORTA 1111 1111 ma się równać (PORTA_1111 1111) & ~(0000 0001 << 3);
co daje 1111 1111 ma się równać (PORTA_1111 1111) & ~(0000 1000);
co daje 1111 1111 ma się równać (PORTA_1111 1111) & (1111 0111);
co daje 1111 1111 ma się równać (PORTA_1111 0111); (czyli wygaszony trzeci bit w bajcie licząc od zerowego.) .

O ile dobrze zrozumiałem to podam inny przykład :
PORTA & =~(2<<i); a np. i=2
to wynik będzie 1110 1111
Jak jeszcze pozwolisz pomarudzć to chciałbym wyjaśnić jedną kwestię z twojego przykładu

jaką wartość ma "i" przesunięta o "0"
Ja to rozumiem w ten sposób " uint8_t i " jest to miejsce na wartości od 0 do 255 czyli jak w kodzie kolegi anshar
"

"i" to znaczy pusty bajt 0000 0000 a dopiero przy kolejnym obiegiem pentli " i++ " dodawany jest kolejny bit to jest:

i++
| 128 | 64 | 32 | 16 | 8 | 4 | 2 | 1 |
<---------------------

0000 0001 = 1
0000 0011 = 3 (1+2)
0000 0111 = 7 (1+2+4)
0000 1111 = 15 (itd.)
0001 1111 = 31
0011 1111 = 63
0111 1111 = 127
1111 1111 = 255
koniec pentli i następna .
A w przeciwną strone cyli w prawo wyglada tak samo tylko w odwrotnij kolejności zaczynamy od najstarszego bitu
PORTA & =~(128>>1);
1000 0000 = 128
1100 0000 = 64 (128-64)
1110 0000 = 32 (128-64-32)
itd.


PS.dziekuje za cierpliwość, zaczołem inaczej patrzeć na inne kody chociaż dużo jeszcze przedemną.

Pozd.