Putin ajutor cu Texas Instruments Lounchpad

[Liviu M]

m-a întrecut.

Asa, asa, fa misto de mine. Am inteles, iti las "programa" in pace. PS Glumesc, da? Ca serios vorbind, e o placere sa-ti citesc posturile. :bere:

[Vizitator]

Nu e la mişto, chiar te rog să intervii de căte ori crezi că e nevoie, NU vreau să stai deoparte!Intervenţiile tale sunt foarte utile, şi eu îţi citesc mesajele cu aceeaşi plăcere.Mă opresc aici cu aprecierile, altfel toate complimentele astea ar putea deveni prea "gay". Mai vorbim, până atunci, spor la programat, şi te rog, de câte ori discuţia o ia razna, adu-ne cu picioarele pe pământ!

[adyyo]

Salutare. Imi pare rau ca nu am mai participat la discutie saptamana asta, dar am fost ocupat cu licenta si pe langa asta...am murit de cald Revenind la LED-ulete. Am inteles cum fac derularea la stanga, totul se bazeaza pe bitul de semn. Bon...acuma pentru derularea la dreapta, teoretic ar trebui sa fac invers, sa salvez valoarea lui LSB, sa derulez la dreapta apoi sa trec valoarea salvata inapoi in LSB. Ce nu stiu e cum pot afla ce am in ultimul bit. La deplasarea spre stanga am vazut ca prin comparare cu 0 pot afla daca am 1 sau 0 in primul bit dar pentru deplasarea spre dreapta cum pot afla ce e in LSB?

[Liviu M]

totul se bazeaza pe bitul de semn.

Sau pe masti.

 

derularea la dreapta...apoi sa trec valoarea salvata inapoi in LSB.

Eu as zice in MSB.

 

Ce nu stiu e cum pot afla ce am in ultimul bit... dar pentru deplasarea spre dreapta cum pot afla ce e in LSB?

Ai voie sa citesti si ce scriu eu, nu doar ce scrie George.

Mastile sunt bune si la asta.

Ca sa afli valoarea oricarui bit, n-ai decat sa aplici masca corespunzatoare. Si pentru ca mi-ai ignorat macar un post anterior, nu-ti zic direct ce masca/cum folosesti masca.

[adyyo]

Ai dreptate, e MSB ca e primul din dreapta. Tineam eu matricea invers si am incurcat ordinea bitilor. Ti-am citit toate posturile cu acelasi interes cu care citesc si posturile lui Geore, dar cred ca am uitat detaliile. Se simte ca am avut cateva zile de pauza de la jucatul cu MCU. Ma apuc sa mai citesc primele posturi sa imi reimprospatez memoria. Si oricum, nu am destula experienta cu programatul incat sa imi dau seama care este cea mai simpla metoda pentru a rezolva o anumita problema. Am asa un talent de a alege cea mai grea rezolvare...

[Liviu M]

Glumeam :)Oricum, nu trebuie sa cauti prea mult. Imediat dupa postul lui George, ala cu testul in functie de semn, am scris si eu o varianta folosind masca 0x80. MSB e, in mod normal, cel mai din stanga. Numai ca acum voiai sa rotesti la dreapta. Asta inseamna ca daca nu-l salvezi, cel mai din dreapta bit (LSB-Least Significant Bit) se pierde. Daca vrei rotatie si-l salvezi, ca sa fie rotatia rotatie, trebuie sa mearga in capatul celalalt al octetului, in stanga, adica pe post de MSB.

[picolo]

Eu as fi facut testul direct dupa MSB (buffer & 0x80), astfel incat sa fiu independent de tipul de date (pot fi foarte bine si unsigned char). Daca vrea sa afiseze caractere chinezesti (ASCII extins), cu codul tau nu sunt sigur ca poate.

 

void rotire_stânga(int nr_pixeli_rotiţi) { // rotirea afişajului la stânga cu un nr de n pixeli (n=nr_pixeli_rotiţi)   char i, n, bit_salvat;   for (n = 1; n <= nr_pixeli_rotiţi; n++) {      for i = 0; i < MAX_COL; i++) {         if (buffer[i] & 0x80) // dacă MSB == 1            bit_salvat = 1; // salvez MSB         else            bit_salvat = 0; // salvez MSB         buffer[i] <<= 1; deplasere spre stînga         if (bit_salvat == 1) // în mod normal, LSB este 0 în urma deplasării, dacă MSB era 1 inainte,            ++buffer[i];  // atunci copiez MSB în LSB, adică pun 1 în LSB (fac asta prin incrementare)      }   }}

sau asa:

 

Buffer=(Buffer << j) | (Buffer >> (j-1)); // pentru rotire stanga

Buffer=(Buffer >> j) | (Buffer << (j-1)); // pentru rotire dreapta

 

for (n = 1; n <= nr_pixeli_rotiţi; n++)

{

for i = 0; i < MAX_COL; i++)

{

Buffer=(Buffer << 1) | (Buffer >>7);

}

}

[Liviu M]

Interesanta solutia. Singura intrebare ar fi care varianta e mai eficienta ca timp de executie (8 shifturi sau o gramada de if/else-uri).

[adyyo]

Multumesc Liviu pentru ajutor. Incerc sa vad ce imi iese. Ce-i drept, pare mai simpla si mai rapida varianta lui picolo.

[picolo]

Multumesc Liviu pentru ajutor. Incerc sa vad ce imi iese. Ce-i drept, pare mai simpla si mai rapida varianta lui picolo.

Ce este pus intre for{} este ok.In primele doua linii am scris o tampenie:Buffer=(Buffer << j) | (Buffer >> (j-1)); // pentru rotire stangaBuffer=(Buffer >> j) | (Buffer << (j-1)); // pentru rotire dreaptapentru cazul general, corect este:Buffer=(Buffer << j) | (Buffer >> (n-j)); // pentru rotire stangaBuffer=(Buffer >> j) | (Buffer << (n-j)); // pentru rotire dreaptaunde n este lungime in biti pentru Buffer iar j este numar de biti care trebuie rotiti.(prin Buffer , in cazul tau, intelegand un char, int, long etc)Sau ,mai simplu si mai rapid, in asm unde poti apela instructiunile 'rotate left/right'.Dar nu cred ca este nevoie in cazul tau.Felicitari. Pare ca ai reusit sa intelegi ce s-a scris pe aici.

[Liviu M]

Iar o varianta situata (dpdv al eficientei) intre variantele anterioare (de C) si asm e probabil folosirea bitului carry (cel putin la rotirea la stanga, la rotirea la dreapta nu stiu daca se genereaza vreun flag).

 

void rotire_stânga(int nr_pixeli_rotiţi) { // rotirea afişajului la stânga cu un nr de n pixeli (n=nr_pixeli_rotiţi)   char i, n, bit_salvat;   for (n = 1; n <= nr_pixeli_rotiţi; n++) {      for i = 0; i < MAX_COL; i++) {         buffer[i] <<= 1; deplasere spre stînga         buffer[i] += C; //C vrea sa fie bitul carry. E definit in fisierul .h, da' nu sunt sigur ca si functioneaza.                                 //George, help! Habar n-am daca si cum se poate citi bitul carry.      }   }}

[Vizitator]

Ultima oară intrasem după ceva icon_jook , acum, după zile de absenţă, la fel.

De data asta icon_jook cu "motiv", tocmai mi s-a furat bicicleta. :cry:

În ritmul ăsta, am toate şansele să ajung beţivanul ElForum-ului.

:partyman:

picolo varianta ta e, de departe, soluţia cea mai elegantă pentru rotire. N-o ştiam şi nici nu mi-a dat prin cap, îmi place.

Mai mult, poate fi aplicată direct pentru rotirea cu x pixeli deodată, iar rotirea la stânga cu x pixel este acelaşi lucru cu rotirea la dreapta cu sizeof(buffer)-x, de unde rezultă că direcţia de rotire poate fi schimbată umblând doar la x, fără să mai schimbăm linia care face rotirea propriu-zisă.

 

Un alt avantaj este că secvenţa se execută mereu în acelaşi timp (acelaşi număr de instrucţiuni), indiferent de valoarea biţilor sau de căt de mult îi rotim. Nu am încercat practic să văd ce cod rezultă în asamblare, dar pare evident că va rezulta ceva mult mai eficient decât versiunile cu if-uri.

 

adyyo, dacă ai timp, vezi şi funcţia sizeof, dar pune accent pe licenţă, te rog.

Licenţa e prioritară, restul poate rămâne pentru mai târziu.

 

Liviu M, n-am verificat, dar îmi amintesc ca prin ceaţă că MSP430 are ceea ce am întâlnit sub denumirea de "barrel shift" (sau "barrel roll", după caz - nu ştiu dacă termenul este consacrat), înseamnă că MCU-ul poate face o shift-are (sau rotire) cu n biţi deodată, într-o singură operaţie, fără să fie nevoit să execute o buclă de n deplasări sau rotiri pe un singur bit. Asta înseamnă că metoda dată de picolo va genera în assembler un cod foarte eficient.

 

Încă o precizare, extended ASCII se referă la codurile ASCII cuprinse între 128 şi 255, nu are legătură cu reprezentarea caracterelor chinezeşti. Pentru reprezentarea altor seturi de caractere mai ciudate, precum cele arabe, chinezeşti, etc., se folosesc alte reprezentări, pe 2 sau 4 octeţi, spre deosebire de bătrânul ASCII care este pe un singur octet.

 

Mai multe detalii despre reprezentare caracterelor pot fi aflate căutând despre Unicode, dar nu prea are legătură cu ce facem noi acum, propun să rămânem deocamdată la ASCII.

 

N-am înţeles de ce, pentru caracterele chinezeşti, nu ar mai merge exemplul cu testarea semnului. Tipul şi reprezentarea caracterului nu au legătură cu imaginea caracterului, imagine desenată în buffer. Noi rotim desenul.

 

Nu ştiu dacă la MSP shift-area actualizează sau nu bitul de carry. Trebuie văzut în setul de instrucţiuni din assembler. E cam târziu şi sunt după o zi de pomină, caut altă dată. S-ar putea să meargă, dar nu cred că are şanse să bată metoda dată de picolo. Trebuie încercate toate variantele şi văzut ce scoate compilatorul pentru fiecare variantă în parte.

 

Spor la butonat!

[Liviu M]

Aia cu caracterele chinezesti era pe post de gluma, habar n-am cum sunt reprezentate. Se voia o completare la metoda ta (buna pentru signed), nu o "combatere" a ei.

La partea de rapiditate, comparam o varianta (in C) in care se foloseste bitul carry *) cu variantele celelalte de C si-mi dadea probabil mai rapida.

 

Da' cred ca am impins discutia prea departe de scopul initial. Sorry! Sa revenim.

 

*) In cazul in care se poate folosi, normal si eventual numai la deplasarea la stanga, ca la dreapta nu sunt sigur ca muta LSB in carry.

[adyyo]

Imi pare rau pentru pierderea ta George. Sper ca ai fost la politie si ai sesizat furtul, impreuna cu poze ale bicicletei si cu factura sau macar codul de pe cadru de sub monoblocul pedalier. Dupa asta, urmareste duminica bazarul sau talciocul, sigur o gasesti acolo la vanzare. Asa a facut un prieten de al meu caruia i s-a furat bicicleta saptamana trecuta (joi parca) iar duminica a gasit-o in talcioc. Hotul sustinea in fata politiei ca a cumparat-o la randul sau duminica anterioara din talcioc, dar noi in acea duminica am fost la concurs deci s-a dat singur de gol

Sper sa o recuperezi.

 

Revenind la beculete. Ati ajuns prea departe cu deplasarea bitilor si mi-e greu sa tin pasul. Deocamdata vreau sa fac varianta lui Liviu pentru ca am inteles in mare parte cum functioneaza, singura problema este ca nu reusesc sa copii bitul salvat in MSB.

void rotire_dreapta(int nr_pixeli_rotiti)				// rotirea afisajului la dreapta cu un nr de n pixeli (n=nr_pixeli_rotiti){	char x, m, bit_salvat_d;	for (m = 1 ; m <= nr_pixeli_rotiti ; m++)	{		for (x = 0 ; x < COL_MAX ; x++)		{			if (display_buffer[x] & 0x01)				// Daca MSB = 1			bit_salvat_d = 1;							// salvez LSB			else			bit_salvat_d = 0;							// salvez LSB			display_buffer[x] >>= 1;					// deplasare spre dreapta			if (bit_salvat_d == 1)						// daca bit salvat = 1			display_buffer[x] |= 0x01;					// aici nu sunt sigur cum trec 1 in MSB		}	}}

Dupa ce ma lamuresc cu asta, vreau sa inteleg si varianta lui picolo deoarece mi-ar simplifica mult programul si ar arata mai profi.

[Liviu M]

MSB e bitul cel mai din stanga => 1000 0000 => 0x80.

Adica ai nevoie de un SAU cu 0x80.

Varianta lui picolo (daca mi-e permis sa incerc traducerea) (pentru rotire stanga, sa zicem) face intai shiftul stanga cu o pozitie (cum am facut si noi pana acum) si in loc sa testeze ce valoare a avut MSB ca sa-l salveze in LSB, muta direct MSB pe pozitia dorita (>>7 ) si face un SAU intre cele 2 valori obtinute prin cele 2 operatii de shiftare.

 

LE Ca n-am fost atent

Atentie!!!! MSB e bitul cel mai din stanga. Comentariile din ultimul tau cod sunt neactualizate!

Ca sa concluzionam: la rotire dreapta se salveaza LSB (masca 0x01) si se scrie in MSB (masca 0x80).