Progettazione software per cubo led 4x4x4

[Galaxi93]

Codice: Seleziona tutto

bit <<= (n%8);

Questo comando sposta di n%8 posti a sinistra tutti i bit, ed è come se avessi fatto un elevazione, solo che invece che averla in decimale, ce l'ho in binario. Il +1 di prima non serve, perché quando usce 0 da quel calcolo non deve spostare nulla. Se esce per esempio 3, mi sposta di tre posti verso sinistra il bit più a destra (dato che sopra ho specificato che bit=1), quindi ottengo "0b00001000" che equivale a 8 decimale(2 elevato alla 3). Poi quel valore lo sommo o sottraggo (dipende da stato) all'array e il gioco è fatto. Non ho tralasciato niente, vero?

[c1b8]

Hai tralasciato un particolare: così facendo non ottimizzi.
Mi spiego meglio.
Per ottimizzare del codice è mia abitudine seguire nell'ordine i tre passi seguenti:
1) rimozione istruzioni inutili
2) parlare la stessa lingua
3) rivisitazione algoritmo.

Tu stai tentando di realizzare la fase 3 senza aver eseguito le prime 2 fasi e questo non ti aiuta.

Vediamo di capire le diverse fasi.
1) rimozione istruzioni inutili
Durante lo sviluppo si aggiungono istruzioni che nel corso del progetto possono diventare del tutto inutili nel codice. Un esempio è la funzione acc_led che era previsto venisse chiamata per spegnere tutti i led. Questo non è più vero e quindi la if iniziale (if (x+y+z==0)) è inutile e spreca tempo per niente (oltre alla valutazione true/false esegue tre somme). ELIMINARE.
In questa situazione potrebbero trovarsi altre funzioni o parti del codice.

2) parlare la stessa lingua
Quando programmi devi ricordarti che sistema hai sotto per parlare con lui nel migliore dei modi. E' come se tu facessi un viaggio all'estero senza prima aver imparato la lingua, ti troverai a dover ricorrere spesso a "intermediari" o a scendere a compromessi. Nel tuo caso hai intrapreso un viaggio nel mondo dei microcontrollori ad 8 bit, privi di coprocessore matematico e la cui lingua preferita è il "digitale".
Non utilizzare, dove possibile, un interprete per dialogare, ma impara il linguaggio del posto ed utilizzalo.
Un esempio: se impieghi funzioni matematiche quali moltiplicazione e/o divisioni (anche la % è una divisione) il sistema non ti capisce ed avrà bisogno di un traduttore (nel tuo caso il mikroC che inventa una funzione apposita). Sapendo che il sistema parla il 'binario' usa funzioni binarie quindi: << o AND o OR
Ti assicuro che puoi ottenere gli stessi risultati ma in tempi molto minori.
In questa ottica si possono modificare diversi punti del codice: richiamare la acc_led senza sommare 1 a x, y, z. Di conseguenza nella acc_led eliminare il -5. Ancora la acc_led esegue un y*4 che può trasformarsi in y<<2.
E avanti così in altri punti del codice.

3) rivisitazione algoritmo.
Questo è il punto più complesso e quindi l'ultimo. Si tratta di mettere in dubbio il lavoro svolto fino a questo punto e cambiarlo. Prima di arrivare a questo però dovresti essere sicuro di aver provato tutte le altre possibilità.

Ciao.

[Galaxi93]

Hai tralasciato un particolare: così facendo non ottimizzi.

Ci avrei scommesso...

Ora mi metto all'opera! Grazie per le dritte!

Per quanto riguarda i #define che diceva posta10100, come possono ottimizzare il programma?

[c1b8]

I #define ti evitano di eseguire la chiamata a funzione includendo nel punto in cui ti serve tutto il codice della funzione stessa.
A mio avviso sono performanti nel momento in cui le funzioni prevedono controlli sui dati di input, cosa che non hai nel codice. Con i #define tutti questi controlli possono essere eliminati.
Altra ottimizzazione che consentono di ottenere è l'eliminazione di tutti quel overload dovuto al passaggio dei parametri, in questo senso possono servirti.
In ogni caso però con questa tecnica ottieni un incremento, a volte considerevole, della memoria utilizzata.
Potrebbero quindi essere visti come passa 2,5 della ottimizzazione.

[Galaxi93]

Ho provato a migliorare il programma, anche se penso che ci sia dell'altro da fare.

http://galaxy93.pastebin.com/m334689d4

Ho aggiunto la funzione reset che secondo me, è utile per tutti i futuri giochi (e anche per evitare ripetizioni). Ho anche ordinato bene tutte le funzioni, commentandole e dividendole in gruppi.

Una cosa che non sono riuscito a semplificare è %. Non so come fare.

Grazie a tutti,

Davide.

[phylum]

beh visto che hai seguito il mio consiglio di sfruttare pb

posso dirti:
hai imparato che << e' il tuo "amico" per le moltiplicazioni
>> per le divisioni
& per calcolare i resti

[posta10100]

Rieccomi!
Sono sparito per un per un po ma vi assicuro ho un ottimo motivo
Ora rileggo il codice... poi vi dico se lo riconosco ancora

[posta10100]

Inizierei a dare un occhio a come sono implementate le funzioni più utilizzate.
Partirei dalla

Codice: Seleziona tutto

unsigned char getIndex(unsigned char y, unsigned char z)

Come viene implementata (in assembler) dal compilatore?
In particolare: come traduce

Codice: Seleziona tutto

z<<1 + 1

Luca.

[Galaxi93]

Ora rileggo il codice... poi vi dico se lo riconosco ancora

Esagerato!


Vuoi sapere questo?

Codice: Seleziona tutto

;Cubo_led_v06.c,52 ::       }
$022D   $   L_getIndex_6:
;Cubo_led_v06.c,53 ::       return z<<1 + 1;            //restituisce z*2+1.
$022D   $082D         MOVF   FARG_getIndex+1, 0
$022E   $00C0         MOVWF   STACK_0
$022F   $0DC0         RLF   STACK_0, 1
$0230   $1040         BCF   STACK_0, 0
$0231   $0DC0         RLF   STACK_0, 1
$0232   $1040         BCF   STACK_0, 0
;Cubo_led_v06.c,54 ::       }
$0233   $0008         RETURN

Premetto che in asm non so proprio nulla.

[posta10100]

Sinceramente non capisco cosa fa...
Qui carica il valore di z in una variabile locale, e ok...

Codice: Seleziona tutto

$022D   $082D         MOVF   FARG_getIndex+1, 0
$022E   $00C0         MOVWF   STACK_0

Qui sposta a sx di un bit e cancella il lsb per evitare che possa esserci un 1 nel carry che rientra da dx, e va bene...

Codice: Seleziona tutto

$022F   $0DC0         RLF   STACK_0, 1
$0230   $1040         BCF   STACK_0, 0

Ma poi fa di nuovo la stessa operazione...

Codice: Seleziona tutto

$0231   $0DC0         RLF   STACK_0, 1
$0232   $1040         BCF   STACK_0, 0

Cosa mi sfugge???