Progettazione software per cubo led 4x4x4

[posta10100]

Come spesso accade nell'informatica, quando le cose cominciano ad accartocciarsi è meglio buttar via tutto e rifare da capo!
Ecco il nuovo codice:

Codice: Seleziona tutto

unsigned char map[8];   // array dichiarato come variabile globale che contiene lo stato dei led

E questi sono i nuovi metodi commentati!

Codice: Seleziona tutto

    /*
     * Divido il cubo in 4 piani orizzontali per z che va da 0 a 3
     * Ogni piano contiene 16 led, rappresentabili con 16 bit, 2 char
     * z quindi seleziona la coppia di char dell'array per ogni piano
     * z = 0, char di indice 0 e char di indice 1
     * z = 1, char di indice 2 e char di indice 3
     * in definitiva gli indici sono (z * 2) e (z * 2 + 1)
     * Ogni piano lo divido in 2 semipiani, uno associato al char
     * di indice più basso, uno a quello di indice più alto.
     * Su questo piano considero le coordinate x e y cha vanno da 0 a 3
     * Decido che se y < 2 (quindi per y == 0 e y == 1) memorizzo nel
     * char di indice minore, se y >= 2 nel char di indice maggiore
     * Ogni semipiano quindi ha 2 file di 4 led. Se y è dispari
     * memorizzo nei 4 bit più significativi del char, se pari in quelli
     * meno significativi.
    */

    /* Questa funzione, in funzione delle coordinate x, y, z, restituisce
     * l'indice del char da utilizzare
    */

    unsigned char getIndex(unsigned char y, unsigned char z) {
        if (y < 2) {
            return z * 2;
        }
        return z * 2 + 1;
    }

    /*
     * Questa funzione restituisce il l'indice del bit da modificare
    */
    unsigned char getBitIndex(unsigned char x, unsigned char y) {
        if (y % 1) {
            return x + 4;
        }
        return x;
    }

    /*
     * Questa funzione restituisce la maschera da applicare al char
     * per settare o resettare un bit
    */
    unsigned char getMaschera(unsigned char bitIndex, unsigned char stato) {
        unsigned char a = 1;
        unsigned char b;
        for (b = 0; b < bitIndex; b++) { // fino a quando b < bitIndex
            a << 1;                      // sposta tutti i bit a sx di una posizione
        }
        if (stato) {
            return a;                    // se devo accendere il led restituisco a
                                         // a ha tutti i bit a 0 tranne quello di indice
                                         // bitIndex che è a 1
        }
        return !a;                       // altrimenti il suo negato (mette i bit a 1 a 0 e viceversa)
    }

    /*
     * Questa funzione setta o resetta il bit corrispondente al led
     * Se stato = 1 --> led acceso, se stato = 0 --> led spento
    */
   
    void cambiaStato(unsigned char x, unsigned char y, unsigned char z, unsigned char stato) {
        unsigned char index = getIndex(y, z);
        unsigned char bitIndex = getBitIndex(x, y);
        unsigned char maschera = getMaschera(bitIndex, stato);
        if (stato) {
            // Devo mettere a 1 il bit corrispondente
            // Eseguo l'OR logico tra la maschera e il byte dell'array
            map[index] |= maschera; // equivale a map[index] = map[index] | maschera
        } else {
            // Devo mettere a 0 il bit corrispondente
            // Eseguo l'AND logico tra la maschera e il byte dell'array
            map[index] &= maschera; // equivale a map[index] = map[index] & maschera
        }
    }


Ora dovrebbe essere più semplice! Provali e fammi sapere se compila e se ti è tutto chiaro!


P.S. Ma dei latch per memorizzare lo stato dei led no vero?
O vuoi risparmiare energia???

[c1b8]

Ottimo.
A mio avviso per avere tutti metodi di base necessari a creare qualsiasi effetto manca solo un metodo: conoscere lo stato di un led per accenderlo o spegnerlo. Provo a postare il codice:

Codice: Seleziona tutto

        /*
         * Questa funzione restituisce lo stato del led alle coordinate x, y, z
         * Ristorna 0 se led spento, numero diverso da 0 se led acceso
        */
   unsigned char getStato(unsigned char x, unsigned char y, unsigned char z) {
      unsigned char index = getIndex(y, z);
      unsigned char bitIndex = getBitIndex(x, y);
      unsigned char maschera = getMaschera(bitIndex, 1);   // ottiene la maschera come
                                             //se dovesse accendere il led
        return (map[index] & maschera); // equivale a una AND logico tra map[index] e maschera
   }


Ora basta creare tanti metodi quanti sono gli effetti da realizzare.
Questi metodi saranno richiamati prima del ciclo for (tempo=0.....), ogni metodo utilizza la cambiaStato per settare lo stato dei singoli led in funzione dl gioco di luce che si desidera.
Quindi all'interno dei for presenti nella main (i 3 for x, for y, for z) si utilizza la getStato per decidere se accendere o meno un led.
Ed i giochi sono fatti.

[posta10100]

Perfetto, ora c'è tutto!
Però adesso vorrei che fosse galaxi a provarci!
Dai prova a scrivere qualcosa, se poi hai dubbi ti diamo una mano!

[Galaxi93]

Non so come ringraziarvi! Davvero!!
Allora, penso di avere capito. Se mi date un po' di tempo che lo rileggo bene bene così capisco tutto e provo a scrivere qualcosa (o almeno ci provo). Il compilatore mi da tutto ok.
La cosa che mi fa sentire un po' a "disagio" è il fatto che non capisco tutto al volo...
Però adesso, da una lettura veloce, da quel che ho capito, i valori di x, y e z sono compresi da 0 a 3?? Per me non è un grosso problema comunque.

Ora me lo stampo così me leggo con + tranquillità!

Grazie mille, siete mitici!!

Galaxi93.

[posta10100]

Però adesso, da una lettura veloce, da quel che ho capito, i valori di x, y e z sono compresi da 0 a 3?? Per me non è un grosso problema comunque.

Non è un problema così grosso: dove passi x, y, z basta che scrivi x-1, y-1, z-1 e sei a posto!

La cosa che mi fa sentire un po' a "disagio" è il fatto che non capisco tutto al volo...

Non puoi pretendere di capire tutto subito, non è un programmino che somma a + b... ha una certa complessità!
Non preoccuparti, con l'esperienza tutto verrà più facile!

Aspetto di vedere il tuo codice!

Luca.

[Galaxi93]

Oggi ho provato a scrivere queste poche righe per accendere i led quando vengono memorizzati accesi (1) e per spegnerli quando invece sono messi spenti (0).
Come era per me prevedibile (ormai ci sono abituato ), non funziona: quando accendo il circuito non mi fa niente, neanche il ben che minimo segno di vita... Ho fatto alcune prove, non tante, purtroppo, perché questo è un periodo molto intenso di verifiche e interrogazioni a scuola, e quindi devo studiare molto.
Vi posto qui il codice, e ditemi se un sistema del genere è funzionale o meno, e dove sta l'errore:

Codice: Seleziona tutto

//Questa funzione controlla quali led sono stati memorizzati come alti (1) e li
//li accende, oppure li spegne dove sono posti a basso (0).
void check_led(char tempo)
     {
     for (tempo=1; tempo<tempo_effetto; tempo++) //Questi cicli for servono per
         { for (z_led=1; z_led<5; z_led++)   //far lampeggiare in sequenza tutti
           { for (y_led=1; y_led<5; y_led++)     //i led in maniera velocissima.
             { for (x_led=1; x_led<5; x_led++)
               {
               char stato_led = getStato(x_led,y_led,z_led); //Controlla lo stato
               if (stato_led!=0)  //dei led e se è diverso da 0 (quindi acceso),
                  {
                  acc_led(x_led,y_led,z_led); //accende i led alla coordinata
                  }                           //corrispontende.
               else                      //Altrimenti (quindi 0, ovvero spento,
                   {
                   acc_led(0,0,0);       //lo spegne.
                   }
               }
             }
           }
         }
     }

Grazie di tutto,
Davide.

P.S: stasera e domani non penso di riuscire a fare delle prove “pratiche”, sicuramente giovedì potrò.
Per adesso, il circuito è ancora su bread-board (per c1b8 è sempre quello del video) poiché, per un disguido postale (che sfiga!!!) non mi sono ancora arrivate le basette millefori e i led.

[posta10100]

Ciao Davide,
la prima cosa che noto è che hai tralasciato il -1 negli indici:
questo

Codice: Seleziona tutto

char stato_led = getStato(x_led,y_led,z_led);

dovrebbe essere così

Codice: Seleziona tutto

char stato_led = getStato(x_led - 1,y_led - 1,z_led - 1);

perché la tua numerazione parte da 1, quella dell'array da 0.

Ovviamente devi prima aver settato tutti i led a 1. Se non lo hai ancora fatto puoi farlo semplicemente con

Codice: Seleziona tutto

unsigned char i;
for (i = 0; i < 8; i++) {
    map[i] = 255;
}


Credo che non necessiti di commento....

Come era per me prevedibile (ormai ci sono abituato ), non funziona

E' normale che non funzioni! Se va al primo colpo ti devi preoccupare

Ho fatto alcune prove, non tante, purtroppo, perché questo è un periodo molto intenso di verifiche e interrogazioni a scuola, e quindi devo studiare molto.

La scuola prima di tutto!

Ciao,
Luca.

[Galaxi93]

Si, il primo errore è una mia dimenticanza (quanto sono distratto!!!).

Mentre invece per il secondo, non ho capito il perché deve mettere tutto ad uno e dove lo devo mettere.

Grazie,
Davide.

[c1b8]

Ciao, due cosette.
Prima: la funzione void check_led(char tempo) che hai realizzato deve essere void check_led(char tempo_effetto), altrimenti devi cambiare il primo ciclo for al suo interno.
Secondo: Prima di richiamare questa funzione devi accendere i led (cioè impostare i bit della map[]) per creare l'effetto che vuoi.

Posta10100 ti suggeriva di accenderli tutti i led solo come test. Dovrai accendere/spegnere i led che servono per l'effetto desiderato. Comunque prima di richiamare la check_led

[Galaxi93]

Quindi, Luca (posso chiamarti per nome?), intendeva accendere tutto per fare una prova? Ahh, non avevo capito.

Prima: la funzione void check_led(char tempo) che hai realizzato deve essere void check_led(char tempo_effetto), altrimenti devi cambiare il primo ciclo for al suo interno.

Ecco un'altra distrazione, forse quella fatale...grazie Fabio.


Ciao,
Davide.