Array e interpretazione dei puntatori

Buongiorno a tutti,
nell’ambito di un progetto con una matrice di led 10x10 realizzata con strip led WS2812b e libreria FastLed, ho la necessità di richiamare specifici led a formare delle parole finite. Pertanto ho creato degli array del tipo:

...
int acceso[] = {78, 77, 76, 75, 74,73};
int spento[] = {11, 10, 9, 8, 7,6};  
int pausa[] = {57, 58, 59, 60, 61};
...

e tante altre (una ventina in totale), che richiamo normalmente con il comando:

...

for (i = 0; i < 6; i++) {
   leds[spento[i]] = CRGB::White;
   FastLED.show();  
}
...

Ora vorrei trovare il modo per far sì che siano i sensori di input ad indicare al codice quali parole accendere, per evitare interminabili righe di istruzioni condizionali if… else if… else…
Ho pertanto creato una matrice vuota con dimensione sufficiente a contenere il massimo numero di led da accendere a formare la specifica parola:

...
if (temperatura <= 15) {
    strcpy(mex, "acceso");

if (temperatura >=22)  {
    strcpy(mex, "spento");
if.....
for (i = 0; i < strlen(mex); i++)
      {
        leds[mex[i]] = CRGB::White;
        FastLED.show();
      }
...

Questo codice in parte funziona, poichè se stampo su monitor seriale visualizzo esattamente il comando corretto quale:
leds[spento*] = CRGB::White;*
leds[acceso*] = CRGB::White;*
i quali comandi dovrebbero andare ad accendere i led appartenenti agli array:
acceso[] = {78, 77, 76, 75, 74,73};
*spento[] = {11, 10, 9, 8, 7,6}; *
Peccato che si accendono sì dei led, ma non quelli indicati dai rispettivi array.
Per mia evidente ignoranza non riesco a comprenderne il motivo, forse perchè in un formato diverso ? (bin, hex, dec, char. …???)
Riporto quanto sopra già inserito, il codice epurato di tutte le parti inutili, per una Vs./ più facile lettura, augurandomi che qualcuno riesca ad indicarmi la retta via, e scusandomi se non sono stato sufficientemente chiaro, ho avuto difficoltà già solo ad esporre il problema !!!
Grazie mille,

#include <FastLED.h>
#define LED_PIN     4
#define NUM_LEDS    100
CRGB leds[NUM_LEDS];
// ...
char ore_1[20] ;

// ...
int acceso[] = {78, 77, 76, 75, 74, 73};
int spento[] = {11, 10, 9, 8, 7, 6};
int pausa[] = {57, 58, 59, 60, 61};
// ...


void setup() {
  FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
  Serial.begin(57600);

  // ....
}

void loop() {
  FastLED.setBrightness(155);
  //....
  if (temperatura <= 15) {
    strcpy(mex, "acceso");
    if (temperatura >= 22)  {
      strcpy(mex, "spento");
      // if.....

      for (i = 0; i < strlen(mex); i++)
      {
        leds[mex[i]] = CRGB::White;
        FastLED.show();
      }
      // ...
    }

Buongiorno e benvenuto, :slight_smile:
essendo il tuo primo post, nel rispetto del regolamento della sezione Italiana del forum (… punto 13, primo capoverso), ti chiedo cortesemente di presentarti IN QUESTO THREAD (spiegando bene quali conoscenze hai di elettronica e di programmazione ... possibilmente evitando di scrivere solo una riga di saluto) e di leggere con molta attenzione tutto il su citato REGOLAMENTO ... Grazie. :slight_smile:

Guglielmo

P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione nell’apposito thread, nessuno ti potrà rispondere, quindi ti consiglio di farla al più presto. :wink:

Mi scuso.
Nonostante abbia letto le indicazioni non ho trovato quella relativa alla presentazione, che pur è logica ed abituale. Provvedo subito, grazie.
Paolo

Il nome dell’array, esempio acceso NULLA ha a che vedere con la stringa/frase “acceso”.

strcpy() copia delle stringhe, ovvero degli array dove ogni elemento (singola cella) è un char MA deve terminare con NULL ovvero carattere speciale ‘\0’
Per copiare delle zone di memoria devi usare memcpy() invece di strcpy() dicendogli QUANTI elementi copiare.

memcpy(mex, acceso,62); // 6 celle ogni cella int=2 byte 62
oppure
memcpy(mex, acceso, sizeof(mex) );

Poi.... se la libreria FastLED lavora con degli array dove ogni elemento è un CRGB, perchè tu fai degli array di interi ?
Il primo 78 di acceso cosa dovrebbe accedere? Che colore ti aspetti ?

La libreria usa CRGB che pare essere un triplo byte, con la parte R, G, B ovvero rosso, verde, blu ogni colore da 0 a 255

nid69ita:
Poi.... se la libreria FastLED lavora con degli array dove ogni elemento è un CRGB, perchè tu fai degli array di interi ?
Il primo 78 di acceso cosa dovrebbe accedere? Che colore ti aspetti ?

La libreria usa CRGB che pare essere un triplo byte, con la parte R, G, B ovvero rosso, verde, blu ogni colore da 0 a 255

Tra le molte, una delle istruzioni della libreria FastLED indica di utilizzare questa sintassi per accendere un generico led:
leds *= CRGB::White; *
se al posto di 'i' inserisco '78' si accenderà quindi il 78° della stripled ed avrà colore bianco, e tutto questo funziona.
Sono io che ho creato degli array poichè una parola è generata da una serie di led consecutivi (i.e. 78,77,76,75,74,73.
Nel mio progetto, al di sopra di questi led ci sono i caratteri A C C E S O ad illuminare la parola indicata.

nid69ita:
... Per copiare delle zone di memoria devi usare memcpy() invece di strcpy() dicendogli QUANTI elementi copiare.

memcpy(mex, acceso,62); // 6 celle ogni cella int=2 byte 62
oppure
memcpy(mex, acceso, sizeof(mex) );

Intanto ti ringrazio moltissimo per l'indicazione preziosa ed il tempo che mi hai dedicato.
Ho già provato a modificare il codice e con questa indicazione il problema si sta risolvendo, non è tuttavia ancora a posto.
Nelle dichiarazioni, ad inizio codice, io avevo inserito:
char mex=20; (anche se tu lo vedi nel mio primo post come char ore_1=20; per un mio errore)
evidentemente per questo motivo sizeof(mex) mi restituisce sempre 20.
Forse dovrei utilizzare memcpy(mex, acceso, sizeof(acceso) ); ?
Ho provato ma anche in questo caso senza successo.
Le parole si accendono, ma spesso le parole più lunghe vengono troncate, sono certo che il problema sia in questa dimensione.
Devo comunque studiare un pò questo comando memcpy e il discorso delle 6 celle ogni cella.... che purtroppo ho difficoltà ancora a comprendere, purtroppo per mancanza delle basi.....

Ho fatto anch'io un progetto con una matrice led rgb.
Nel mio caso 140 led disposti a matrice 20x7 dove visualizzo 4 cifre/caratteri.
Ho usato un approccio simile al tuo, con 2 array distinti:

  • uno con gli indirizzi dei led
  • uno con i valori dei singoli led nella cifra da visualizzare
    Poi con 3 cicli for visualizzi tutto.
    Posso postare il codice, il problema se sei agli inizi sarà riuscire a capirlo...

fratt:
..Posso postare il codice, il problema se sei agli inizi sarà riuscire a capirlo...

Grazie! tu prova a postarlo, io mi occuperò di studiarlo documentandomi anche in rete se necessario! mi interesserebbe capire meglio questo rapporto tra array indirizzi e l'altro array.

Questi sono i 2 array

//  INDICI CIFRE
//  Cifra 1                 Cifra 2                     Cifra 3                 Cifra 4
//  21  20  19  18    17    16  15  14  13    12  11    10   9   8   7     6     5   4   3   2
//  22  23  24  25    26    27  28  29  30    31  32    33  34  35  36    37    38  39  40  41
//  61  60  59  58    57    56  55  54  53    52  51    50  49  48  47    46    45  44  43  42
//  62  63  64  65    66    67  68  69  70    71  72    73  74  75  76    77    78  79  80  81
// 101 100  99  98    97    96  95  94  93    92  91    90  89  88  87    86    85  84  83  82
// 102 103 104 105   106   107 108 109 110   111 112   113 114 115 116   117   118 119 120 121
// 141 140 139 138   137   136 135 134 133   132 131   130 129 128 127   126   125 125 123 122

// array cifre display
const byte cifre[4][7][4] = {
                       {{  5,   4,   3,   2},  // cifra 4
                        { 38,  39,  40,  41},
                        { 45,  44,  43,  42},
                        { 78,  79,  80,  81},
                        { 85,  84,  83,  82},
                        {118, 119, 120, 121},
                        {125, 124, 123, 122}},
  
                       {{ 10,   9,   8,   7},  // cifra 3
                        { 33,  34,  35,  36},
                        { 50,  49,  48,  47},
                        { 73,  74,  75,  76},
                        { 90,  89,  88,  87},
                        {113, 114, 115, 116},
                        {130, 129, 128, 127}},
  
                       {{ 16,  15,  14,  13},  // cifra 2
                        { 27,  28,  29,  30},
                        { 56,  55,  54,  53},
                        { 67,  68,  69,  70},
                        { 96,  95,  94,  93},
                        {107, 108, 109, 110},
                        {136, 135, 134, 133}},

                       {{ 21,  20,  19,  18},  // cifra 1
                        { 22,  23,  24,  25},
                        { 61,  60,  59,  58},
                        { 62,  63,  64,  65},
                        {101, 100,  99,  98},
                        {102, 103, 104, 105},
                        {141, 140, 139, 138}}
                      };

// definizione numeri da visualizzare
const byte numeri[20][7] = {
                      {B0110,  // 0
                       B1001,
                       B1001,
                       B1001,
                       B1001,
                       B1001,
                       B0110},

                      {B0001,  // 1
                       B0011,
                       B0101,
                       B0001,
                       B0001,
                       B0001,
                       B0001},

                      {B1110,  // 2
                       B0001,
                       B0001,
                       B0110,
                       B1000,
                       B1000,
                       B0111},

                      {B1110,  // 3
                       B0001,
                       B0001,
                       B0110,
                       B0001,
                       B0001,
                       B1110},

                      {B0001,  // 4
                       B0011,
                       B0101,
                       B1001,
                       B1111,
                       B0001,
                       B0001},

                      {B1111,  // 5
                       B1000,
                       B1000,
                       B1110,
                       B0001,
                       B0001,
                       B1110},

                      {B0011,  // 6
                       B0100,
                       B1000,
                       B1110,
                       B1001,
                       B1001,
                       B0110},

                      {B1111,  // 7
                       B0001,
                       B0010,
                       B0010,
                       B0010,
                       B0100,
                       B0100},

                      {B0110,  // 8
                       B1001,
                       B1001,
                       B0110,
                       B1001,
                       B1001,
                       B0110},

                      {B0110,  // 9
                       B1001,
                       B1001,
                       B0111,
                       B0001,
                       B0001,
                       B0110},

                      {B0000,  // spazio
                       B0000,
                       B0000,
                       B0000,
                       B0000,
                       B0000,
                       B0000},

                      {B0100,  // T
                       B1111,
                       B0100,
                       B0100,
                       B0100,
                       B0101,
                       B0110},

                      {B1000,  // H
                       B1000,
                       B1000,
                       B1110,
                       B1001,
                       B1001,
                       B1001},

                      {B0000,  // +
                       B0000,
                       B0010,
                       B0111,
                       B0010,
                       B0000,
                       B0000},
                          
                      {B0000,  // -
                       B0000,
                       B0000,
                       B0111,
                       B0000,
                       B0000,
                       B0000},

                      {B0000,  // %
                       B1100,
                       B1101,
                       B0010,
                       B0100,
                       B1011,
                       B0011},

                      {B0111,  // S
                       B1000,
                       B1000,
                       B0110,
                       B0001,
                       B0001,
                       B1110},

                      {B0000,  // v
                       B0000,
                       B0000,
                       B1001,
                       B1001,
                       B1010,
                       B0100},

                      {B0000,  // n
                       B0000,
                       B1001,
                       B1101,
                       B1011,
                       B1001,
                       B1001},

                      {B0000,  // f
                       B0000,
                       B1111,
                       B1000,
                       B1110,
                       B1000,
                       B1000}

                      };

Come ho scritto sopra il mio “display” è organizzato in 7 righe per 20 colonne.
A me serviva visualizzare solo numeri e qualche simbolo / lettera, ma il principio è lo stesso anche per le altre lettere.

Questi i for che accendono i led

  // scorro le 4 cifre e le visualizzo sul display
  for (cifra=0; cifra<4; cifra++) {
    for (i=0; i<4; i++) {
      for (j=0; j<7; j++) {
        pos_led = cifre[cifra][j][i];

        switch (testo_vis[cifra]) {
          case ' ': tmp = 10; break;
          case 't': tmp = 11; break;
          case 'h': tmp = 12; break;
          case '+': tmp = 13; break;
          case '-': tmp = 14; break;
          case '%': tmp = 15; break;
          case 'S': tmp = 16; break;
          case 'v': tmp = 17; break;
          case 'n': tmp = 18; break;
          case 'f': tmp = 19; break;
          case '0' ... '9': tmp = testo_vis[cifra] - '0'; break;
          default:  tmp = 10; // carattere sconosciuto = spazio = nessun led acceso
        }

        if (bitRead(numeri[tmp][j],3-i) == 1) {
          leds[pos_led] = CRGB(rosso,verde,blu);
        } else {
          leds[pos_led] = CRGB(0,0,0);
        }
      }
    }
  }
  FastLED.show();

La variabile testo_vis è la stringa con i 4 caratteri da visualizzare
char testo_vis[5];

Per chiarezza:

  • l'array delle cifre contiene l'indice dei led. In base a come li hai connessi devi mettere i tuoi indici.
  • l'array dei numeri è organizzato sempre in "4 colonne e 7 righe" dove gli zero indicano che il led rimane spento e gli uno indicano che il led viene acceso.

Al posto delle variabili rosso, verde, blu metti i valori che ti servono.

grazie Fratt! tutto abbastanza chiaro, ragionerò bene sulle matrici che, rispetto ai semplici vettori, sicuramente consentono di meccanizzare parecchie operazioni, è poi molto interessante il comando bitRead che mi sono ora un pò studiato e che assieme a bitwrite ed agli altri comandi sui bit possono tornare estremamente utili!

This topic was automatically closed 120 days after the last reply. New replies are no longer allowed.