Blanking Leadig Zero modulo Max7219 seven-segment Led

Progetti Arduino
Rispondi
DinamiteBla
Messaggi: 4
Iscritto il: ven 22 apr 2022, 11:11

Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da DinamiteBla »

Saluti.
Ho comprato Arduino!
... per me è come far mangiare carne ad un vegetariano :D

Purtroppo ho dovuto cedere, stavolta con i miei amatissimi CMOS mi sarebbe venuta una cosa grande quanto una cassa di angurie :glisteringmelonslice: :D

Premessa:
avevo, (avevo perchè dalla scatola, e partendo da sottozero, fino al lavoro finito ho impiegato,
studiando, scopiazzando ed adattando le mie conoscenze di C++, solo 4 pomeriggi e per me è una bella soddisfazione)
... mi sono talmente impegnato che non non ho ancora avuto tempo di far lampeggiare il primo fatidico Led
... ma spero di farlo entro Natale....

Dicevo, avevo necessità di un contatore su unico display seven-segment 8 Digit che mi contasse contemporaneamente
timecode orari con modulo diverso fra di loro alla cui commutazione in base al modulo impostato mi indicasse
di ciascuno il valore (ben 8 moduli orari di conteggio)
Come display ho utilizzato un "fattoapposta" preassemblato Max7219 a sette segmenti a Led

I timecode vengono contati in Up/Down da 0.00.00.00 a 9.59.59.xx oppure a -9.59.59.xx
(xx sono i fotogrammi in base ai moduli di conteggio).
Oltre tale valore non ho necessità di contare e, soprattutto, un Digit (quello più a sinista con ID 7)
dovevo riservarlo per il segno "-".
Fin qui tutto OK.

Vengo al dunque:
Ho la necessità del Blanking degli Zero iniziali (e successivamente, se non ci riesco da solo, anche lo shift del segno meno vesro destra)
L'idea è quella di usare un Array, e spegnere gli zero iniziali, tenendo conto che il primo Digit
da valutare è quello con ID 6, ovvero il secondo da sinistra, perchè il primo da sinistra al momento è riservato
all'eventuale segno -.
Pur avendo capito la logica, in base all'esempio fornito con la libreria LedControl.h
di cui allego solo la parte dello sketch di esempio e funzionante, non riesco (perchè non sono ancora capace)
ad adattarli al mio caso perché mentre nell'esempio i numeri aumentano o diminuiscono progressivamente,
(tutto molto semplice) nella mia applicazione i numeri cambiano progressivamente ma effettuano un conteggio orario Up/Down in base ai moduli utilizzati nelle formule e ciscun Digit visualizza il risultato di un calcolo diverso da quello degli altri Digit.

Ovviamente, ogni altra idea e suggerimento per una soluzione ottimale sono ben accetti!

Questo è lo sketch di esempio fornito con la libreria LedControl.h basato su Array:

Codice: Seleziona tutto

/*
 * LedControl library: https://github.com/wayoda/LedControl
 * 
 */

#include "LedControl.h"

// Initialise the LedControl library
// pin 12 on DIN, 
// pin 11 on Clk, 
// pin 10 on LOAD
// number of displays: 1
LedControl lc = LedControl(12, 11, 10, 1); 

int i = 0;

void setup() {

  // On startup, the MAX72XX chip is in power-safe mode
  // we are waking this chip for device 0 with the shutdown command
  lc.shutdown(0, false);

  // Set the intensity of the screen on device 0 with a value between 0 and 15
  lc.setIntensity(0, 5);
  
  // Clear the display of device 0
  lc.clearDisplay(0);
}


void printNumber3(long number) {

  // Array of 8 bytes for each postion on the LED display
  
  // questi valori nella mia applicazione sono:
  // {vuoto o segno -, da 0 a 9, da 0 a 5, da 0 a 9, da 0 a 5, da 0 a 9, da 0 a x, da 0 a x}  in base al modulo di x
  // Siccome questo esempio si basa sul conteggio progressivo della variabile i definita in testa al listato
  // non so cosa metterci al posto della variabile number definita nel for
  
  byte digits[8] = {0, 0, 0, 0, 0, 0, 0, 0};   

  // Loop over each position to determine the number to show
  for (int i; i < 8; i++) {
      digits[i] = number % 10;
      number = number / 10;   
  }

  // True when we've found the first non-zero digit
  bool firstNonZeroFound = false;

  // Loop backwards from 7 to 0
  for (int i = 7; i >= 0; i--) {

      // If the number is not equal to 0
      if(digits[i] != 0) {
        firstNonZeroFound = true;
      } 

      // If the first non-zero number is found show this on the LED display
      if (firstNonZeroFound) {
        lc.setDigit(0, i, digits[i], false);
      }
  }
  
}

void loop() { 
  lc.clearDisplay(0);
  printNumber3(i);
  i++;
  delay(100);
}


Bene, siccome è il mio primo post dopo la presentazione di qualche settimana fa,
ho voluto dirla tutta e farla lunga...
Difficilmente chiedo aiuti, non voglio pappe pronte perchè devo capire, preferisco sbattere la testa,
ma stavolta ho bisogno di essere instradato.
Grazie per la pazienza di aver letto.

...Adesso la soluzione, grazie ! :D
Avatar utente
pgv
Messaggi: 335
Iscritto il: gio 17 set 2020, 13:16
Località: Ginevra

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da pgv »

OK, prima della riflessione alcuni commenti al codice postato. Poi prometto di suggerire una soluzione...

<comincio la disquisizione, chi non vuol sapere che cosa fa il programma salti pure>

Non sembra, ma ci sono TRE variabili chiamate "i" nel codice:

Codice: Seleziona tutto

(a riga 15) int i = 0;
<omissis>
(a riga 43)   for (int i; i < 8; i++)
<omissis>
(a riga 52)   for (int i = 7; i >= 0; i--) {
La prima linea di codice citata dichiara una variabile globale, che e' visibile da tutto il programma tranne quando una variabile con lo stesso nome viene dichiarata localmente. La seconda e la terza dichiarano una variabile automatica che nasce, vive e muore all'interno del loop "for" dove sono dichiarate. E' un po' come dire "mi serve un indice per un ciclo loop, dammene una, ti restituisco la memoria appena finisce il loop".

Ora veniamo ad altre due linee di codice:

Codice: Seleziona tutto

(a riga 31) void printNumber3(long number) {
<omissis>
(a riga 69)  printNumber3(i);
Nel primo caso, "number" e' dichiarato come parametro della funzione printNumber3(), mentre nel secondo caso stiamo chiamando la funzione printNumber3() con la variabile (globale di cui sopra) "i" al posto del parametro, che significa che stiamo passando alla funzione il valore di "i" (quello che ha nel momento in cui eseguiamo la riga 69) per "riempire" il parametro "number". Quindi all'interno di printNumber3() in questo caso "number" avra' il valore che aveva "i" al momento della chiamata.

Il flusso logico del programma e' il seguente:

Le inizializzazioni di variabili globali alle righe 13 e 15 dichiarano due variabili globali, che mantengono i loro valori durante tutta l'esecuzione della totalita' del programma.

La funzione (obbligatoria in un programma Arduino) setup() viene eseguita una volta sola, all'accensione/restart dell'Arduino, e inizializza il controllore LED - inizialmente lo "risveglia", seleziona il valore "5" per la luminosita', e infine azzera il display.

A questo punto comincia ad eseguire la funzione loop() (e continua ad eseguire per sempre, se termina riparte subito dall'inizio senza pero' richiamare setup() e continua "per sempre"). La loop() inizia azzerando il display, chiama la funzione printNumber3() con il valore della variabile globale "i" come rimpiazzo per il parametro "number", incrementa la variabile globale "i" (si sarebbero potute anche unificare le righe 69 e 70, rimpiazzandole con printNumber3(i++); dato che l'operazione "i++" e' un "postincremento" e quindi incrementa il valore contenuto nella "i" DOPO la chiamata alla funzione, ma insomma), dorme per 100 millisecondi e termina l'esecuzione. Immediatamente, viene rieseguita, e siccome "i" e' una variabile globale rimane in memoria e mantiene il valore precedente, quindi se la volta prima loop() ci ha trovato il valore 12 quella dopo ci trovera' il valore 13 e cosi' via... Dunque, il programma fin qui inizializza il display, e chiama printNumber3() con un valore per "number" che aumenta tutti i 100 millisecondi (circa).

Che cosa succede dentro printNumber3()? Il valore passato attraverso "number" viene suddiviso in 8 singole cifre decimali (righe 43-46) dalla meno significativa (unita') a quella piu' significativa (decine di milioni). Per esempio, il numero 85213 verrebbe spacchettato in { 3, 1, 2, 5, 8, 0, 0, 0}. Queste cifre vengono esaminate una dopo l'altra, a partire da quella piu' significativa (righe 52-73), e viene cercata la prima cifra diversa da zero (righe 54-57). Finche' le cifre sono tutte zeri, non succede nulla. Dal momento in cui troviamo il primo non-zero, ce lo annotiamo (riga 56) e da questo momento in poi inviamo la cifra in questione, nella posizione corrispondente, al display (riga 61).

<finita la disquisizione>

A questo punto possiamo estrapolare la conoscenza acquisita dall'analisi dell'esempio alla nostra applicazione. Vediamo se ho ben capito le specifiche:

1. abbiamo dei timecode che possono assumere i valori tra -9.59.59.xx e 9.59.59.xx che devono apparire sul display;
2. vogliamo eliminare i "leading zeros", gli zeri iniziali;
3. il segno "-", ove necessario, deve apparire a sinistra del primo non-zero sul display;
4. siccome abbiamo solo 8 elementi nel display, i separatori "." verranno omessi.

Indipendentemente dal formato dei timecode, possiamo separare e salvare le cifre in un array di byte come nell'esempio. Semmai ne parleremo separatamente. Procediamo:

Codice: Seleziona tutto

/*
 * LedControl library: https://github.com/wayoda/LedControl
 * 
 */

#include "LedControl.h"

// Initialise the LedControl library
// pin 12 on DIN, 
// pin 11 on Clk, 
// pin 10 on LOAD
// number of displays: 1
LedControl lc = LedControl(12, 11, 10, 1); 

// Dichiariamo l'array, magari globale, cosi' sara' accessibile da tutto il programma
byte cifre[7];
// Dichiariamo anche una nuova variabile destinata a contenere il carattere "-" (meno) nel caso vada spedito al display
bool meno;

// La funzione printNumber3() ci serve ancora ma dobbiamo modificarla e non passiamo piu' il numero come argomento
void printNumber4(void) {
  // L'array di bytes non e' piu' interno alla funzione ma e' globale, la funzione loop() lo riempie e la printnumber4() lo passa al display
  // questi valori nella mia applicazione sono:
  // {vuoto o segno -, da 0 a 9, da 0 a 5, da 0 a 9, da 0 a 5, da 0 a 9, da 0 a x, da 0 a x}  in base al modulo di x

  // Ho rimosso la parte che spacchettava "number" nelle sue 8 cifre
  
  // True when we've found the first non-zero digit
  bool firstNonZeroFound = false;

  // E l'array e' piu' corto di una cifra rispetto a quello originale
  // Loop backwards from 6 to 0
  for (int i = 6; i >= 0; i--) {

      // If the number is not equal to 0
      if(cifre[i] != 0) {
        firstNonZeroFound = true;
// A questo punto infiliamo il segno "-" una cifra prima, SE NECESSARIO
        if (meno) {
          lc.setChar(0, i-1, '-', false);
        }
      } 

      // If the first non-zero number is found show this on the LED display
      if (firstNonZeroFound) {
        lc.setDigit(0, i, cifre[i], false);
      }
  }
}

void setup() {
  // Copiata bellamente
  // On startup, the MAX72XX chip is in power-safe mode
  // we are waking this chip for device 0 with the shutdown command
  lc.shutdown(0, false);

  // Set the intensity of the screen on device 0 with a value between 0 and 15
  lc.setIntensity(0, 5);
  
  // Clear the display of device 0
  lc.clearDisplay(0);
}

void loop() {
  // L'istruzione seguente fa si' che il contenuto delle "{..}" che si aprono subito dopo venga ripetuto per sempre
  while(1) {
// Riempiamo l'array con un timecode a caso, 2.14.08.35 per esempio
    cifre[0] = 5;
    cifre[1] = 3;
    cifre[2] = 8;
    cifre[3] = 0;
    cifre[4] = 4;
    cifre[5] = 1;
    cifre[6] = 2;
// In C, gli array partono da 0 e quindi un array con 7 elementi ha gli elementi 0, 1, 2, 3, 4, 5 e 6 ma non 7

// Siccome il timecode e' positivo, il segno meno non compare
    meno = false;
    printNumber4();
// Lasciamo passare 10 secondi per vedere il display con comodo
    delay(10000);
  
// Ora ripetiamo con un timecode negativo, sono pigro e lascio le cifre come prima, cambio solo il segno meno
    meno = true;
    printNumber4();
// Lasciamo passare 10 secondi per vedere il display con comodo
    delay(10000);
  } // Altro giro altra corsa, si ricomincia da subito dopo while(1)
}
Caveat - non posseggo i display,
DinamiteBla
Messaggi: 4
Iscritto il: ven 22 apr 2022, 11:11

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da DinamiteBla »

E doveroso ringraziarti per la paziente, analitica e dettagliata risposta.

Avevo notato che la prima "i" fosse globale, ma delle "i" locali ho fatto tutto un fascio!
...ho preso un periodo di turni di notte: di giorno non ho la solita lucidità.

Sinceramente il codice leggendolo al 90% l'ho capito ed anche il comportamento mi è molto chiaro. Insomma è come capire una lingua straniera leggendola, ma poi non sapersi esprimere a parole.

Quello che mi impedisce di comprenderlo a fondo e di apportare le dovute modifiche è proprio il "passaggio di parametri", una cosa che mi ha sempre messo in difficoltà, anche ai tempi in cui mi dilettavo un po di più, perchè non sono mai riuscito ad assimilarlo pienamente e non me lo sono fatto mai spiegare da nessuno.

Avevo abozzato una soluzione molto simile alla tua con la differenza di aver dichiarato ciascun Array in locale.
Mi sono fermato perchè non so come passare all'Array ciascuna cifra del conteggio.

Nel tuo esempio, nell' Array hai messo dei valori definiti per ciascuna cifra e siccome mi mancano dei concetti, questo non mi aiuta a capire.
Quello che non sono capace di fare è mettere nell'Array i valori di 7 variabili diverse (ciascuna corrispondente al risultato di un calcolo) e non ho capito bene come nel tuo esempio questi vengono passati nell' Array.
...e poi non ho capito questa: void printNumber4(void), Il void tra parentesi che significato assume?

In mattinata cerco di applicare i tuoi suggerimenti al listato.

Grazie.
Avatar utente
pgv
Messaggi: 335
Iscritto il: gio 17 set 2020, 13:16
Località: Ginevra

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da pgv »

Io non ho idea di come siano formattati i timecode, per cui ho inizializzato l'array a mano.

void funzione(void) {} e' semplicemente una funzione che non restituisce nessun valore (il primo void) e che non accetta nessun parametro (il secondo void). Per esempio, se devi aprire o chiudere una valvola che e' sempre la stessa, e magari l'operazione e' complicata, puoi scrivere due funzioni:

void apriValvola(void) {
// Fa un sacco di cose complicate
}

e

void chiudiValvola(void) {
// come sopra
}

mentre se hai un certo numero di valvole conviene scrivere sotto forma di

apriValvola(int qualeValvola) {
// fa sempre un sacco di cose complicate ma ai danni della valvola specificata come parametro
}

e cosi' via.
Avatar utente
blue3121
Messaggi: 544
Iscritto il: dom 24 gen 2021, 7:22

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da blue3121 »

DinamiteBla ha scritto: ven 2 set 2022, 3:58 Quello che mi impedisce di comprenderlo a fondo e di apportare le dovute modifiche è proprio il "passaggio di parametri", una cosa che mi ha sempre messo in difficoltà, anche ai tempi in cui mi dilettavo un po di più, perchè non sono mai riuscito ad assimilarlo pienamente e non me lo sono fatto mai spiegare da nessuno.
Premessa.
il C++ di Arduino è solo un piccolissimo sottoinsieme del C++, quindi è impossibile programmare Arduino studiando il C++ "reale".
Io non lo definirei neanche C++.
Diciamo che è un altro linguaggio che ha copiato dal C++ alcune caratteristiche, parole chiave (in realtà molto poche) e alcuni costrutti sintattici.
Quindi se vuoi imparare a programmare Arduino studia il "suo" linguaggio e non il C++ come tale.

Visibilità ("scope") delle variabili con nomi uguali.
Segui una regola semplicissima: la variabile accessibile è l'ultima instanziata che esiste e nasconde le altre nel contesto ("scope") in cui è stata creata (in un loop, tra due { }, nel codice di una funzione, ecc) e scompare appena esci da quel contesto rendendo accessibile la variabile con lo stesso nome nello "scope" precedentemente attivo. Questo vuol dire che gli "scope" per le variabili sono nidificati con un meccanismo a matrioska.
Accedi alla variabile dello "scope" più interno in cui l'hai instanziata.
Se non hai instanziato nessuna variabile con nome già usato, accedi a quella dello "scope" immediatamente più esterno e così via.

Passaggio parametri.
I parametri passati / restituiti ad / da una funzione (se sono dichiarati) sono "variabili locali" create all'atto della chiamata della funzione.
Esistono solo all'interno della funzione (vedi "scope" sopra) e in esse viene copiato il contenuto durante la chiamata (uscita) della funzione nel resto del codice.

Spero sia stato abbastanza chiaro.

Nel linguaggio di Arduino (per quello che conosco, l'ho usato pochissime volte) esistono solo queste caratteristiche (quindi dimentica passaggio per reference, uso di puntatori, scope espliciti, ecc ecc).
“...dentro i confini del computer, sei tu il creatore. Controlli - almeno potenzialmente - tutto ciò che vi succede. Se sei abbastanza bravo, puoi essere un dio. Su piccola scala.”
L. Torvalds
_________________
Guido C.
DinamiteBla
Messaggi: 4
Iscritto il: ven 22 apr 2022, 11:11

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da DinamiteBla »

Chiarissimo, chiarissimo anche pvg. Devo solo fare tanta palestra!
Effettivamente mi sono lanciato con le mie conoscenze di C++, ma ho subito intuito che il Wiring è un suo "surrogato"
Se non metto in pratica sbattendoci la testa non assimilerò mai.
Purtroppo (frase detta e ridetta e superinflazionata) non ho più quella età per per dilettarmi spensieratamente.
Ma quando ho uno scopo mi autoriduco anche il sonno.

Tornando al Topic, faccio una domanda un po più chiara e terra-terra che può servirmi a scalare i gradini:

Se avessi alcune variabili globali o locali, il cui valore cambia e PER CIASCUNA corrisponde al conteggio di una serie di Pulse (high/low) irregolari, ovvero che quando arrivano arrivano (se arrivano) e provenienti dall'esterno (nel mio caso provengono da un Trigger di Schmitt),

Posso utilizzare queste variabili (che cambiano) nelle posizioni di un Array?
insomma posso definire una posizione di un Array in queta maniera ?

int mioArray....
mioArray[0]=variabileCheVariaDaSolaNonSiSaQuando;
mioArray[1]=variabileCheVariaDaSolaNonSiSaQuandoDiversaDallAltra;
ecc.
...e se si può, come si fa sintatticamente?

Insomma in giro ho visto soltanto Array le cui posizioni sono occupate sempre da valori ben definiti e conosciuti
sin dall'inizio, ad esempio:
int mioArray...
mioArray[0]=1;
mioArray[1]=50;
mioArray[2]=32;

e' questo che voglio capire, altrimenti devo cambiare filosofia di ragionamento
Avatar utente
pgv
Messaggi: 335
Iscritto il: gio 17 set 2020, 13:16
Località: Ginevra

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da pgv »

Ovviamente fatte salve eventuali routine che caricano valori in una variabile come risposta ad una interruzione esterna o interna, no. Non e' possibile "associare" un elemento di un array ad un'altra variabile ed aspettarsi che i valori nell'array "seguano" i cambiamenti delle variabili "associate". Ci sono i puntatori, per cui sarebbe possibile definire un vettore di puntatori (indirizzi in memoria) ed assegnare a ciascun elemento del vettore l'indirizzo di una variabile (visibile al momento dell'assegnazione, per cui non funziona con variabili "interne" a funzioni che scompaiono alla fine dell'esecuzione della funzione) ma non sarebbe piu' semplice scrivere i valori desiderati direttamente in un bell'array globale, dichiarato in cima al programma e visibile da tutte le funzioni?

Ovviamente e' possibile, in qualsiasi punto del programma (purche' array e variabili siano visibili, "in scope" in inglese) copiare il valore di una variabile in un qualsivoglia elemento dell'array. Pero' va fatto esplicitamente con l'operazione "array[elemento] = variabile;" ogni volta che si vuole copiare un valore.

Per completezza, aggiungo un breve esempio in cui utilizzo un vettore di puntatori per accedere in effetti delle variabili indipendenti. Non e' un esempio intelligente ma e' didattico. Tutto quello che fa e' creare un vettore di puntatori ed associarne gli elementi a quattro variabili indipendenti, e poi a dimostrare che l'accesso tramite il vettore di puntatori o direttamente alla variabile hanno lo stesso effetto.

Codice: Seleziona tutto

// Creo un vettore di quattro puntatori
// Attenzione:
// puntatori[] e' un vettore di (4) puntatori ad oggetti di tipo int
// puntatori[indice] accede il contenuto dell'elemento "indicesimo" del vettore
// ossia un puntatore ad un oggetto di tipo int
// *puntatori[indice] accede il valore dell'oggetto di tipo int il cui
// indirizzo e' contenuto nell'elemento specificato puntatori[indice]
int *puntatori[4];

// Creo quattro variabili e le inizializzo con la lunghezza del loro nome
int cane = 4;
int gatto = 5;
int cammello = 8;
int ciambella = 9;

void setup() {
  // Inizializzo i quattro puntatori del mio vettore con gli indirizzi delle
  // mie quattro variabili di tipo int
  // Da notare che cane rappresenta una variabile di tipo int, mentre &cane
  // rappresenta il suo indirizzo in memoria
  puntatori[0] = &cane;
  puntatori[1] = &gatto;
  puntatori[2] = &cammello;
  puntatori[3] = &ciambella;

  // Inizializziamo anche la porta seriale per poter stampare qualcosa sul
  // Serial Monitor. Occhio alla velocita' selezionata!
  Serial.begin(115200);
}

void loop() {
  int indice;
  while(1) {
    // Scorriamo il vettore di puntatori e stampiamone il contenuto
    for (indice = 0; indice < 4; indice++) {
      Serial.print("L'elemento numero "); // Non andiamo a capo
      Serial.print(indice); // Neanche adesso andiamo a capo
      Serial.print(" contiene il valore "); // Resistiamo!
      Serial.println(*puntatori[indice]); // Non ce l'ho fatta piu'

      // Verifichiamo che si tratti proprio delle nostre variabili
      // L'istruzione "switch/case" permette di selezionare risposte
      // diverse per ciascun valore previsto di una variabile, e siccome
      // ho utilizzato quattro variabili scompagnate me ne servo per
      // accedere quella corrispondente a ciascun elemento del vettore
      // di puntatori
      switch(indice) {
        case 0:
        Serial.print("La variabile cane contiene ");
        Serial.println(cane);
        break;
        case 1:
        Serial.print("La variabile gatto contiene ");
        Serial.println(gatto);
        break;
        case 2:
        Serial.print("La variabile cammello contiene ");
        Serial.println(cammello);
        break;
        case 3:
        Serial.print("La variabile ciambella contiene ");
        Serial.println(ciambella);
        break;
        default:
        Serial.println("Non capisco come sia potuto arrivare fin qui!");
      }
      // Cambiamo valore alle variabili ATTRAVERSO I PUNTATORI
      *puntatori[indice] = 10 - *puntatori[indice];
    }
    // Lasciamo passare 5 secondi per poter leggere il Serial Monitor
    delay(5000);
  }
}
Avatar utente
blue3121
Messaggi: 544
Iscritto il: dom 24 gen 2021, 7:22

Re: Blanking Leadig Zero modulo Max7219 seven-segment Led

Messaggio da blue3121 »

blue3121 ha scritto: sab 3 set 2022, 0:37 Nel linguaggio di Arduino (per quello che conosco, l'ho usato pochissime volte) esistono solo queste caratteristiche (quindi dimentica passaggio per reference, uso di puntatori, scope espliciti, ecc ecc).
Chiedo venia... ho scritto una caz...volata...

Galeotto fu l'esempio di pgv che mi ha "svegliato" sul linguaggio di Arduino che, ripeto, ho usato poco quanto niente.

Passata qualche ora su documentazione varia ma soprattutto facendo prove con l' IDE di Arduino (ver. 1.8.13) noto che sono state implementate molte funzionalità del C++: puntatori, reference, strutture, classi (anche virtuali) con i canoni della OOP, allocazione dinamica, variabili statiche e volatili, risoluzione dello scope "globale" (ma assenza dei namespace), ecc ecc. solo per citarne qualcuna.
Ho solo visto se il compilatore si "inchioda" o meno su questi costrutti, senza fare prove "reali" (non avendo a portata di mano un Arduino su cui caricare il sw).

Chiedo scusa per il commento, a dir poco superficiale, nei precedenti post.
“...dentro i confini del computer, sei tu il creatore. Controlli - almeno potenzialmente - tutto ciò che vi succede. Se sei abbastanza bravo, puoi essere un dio. Su piccola scala.”
L. Torvalds
_________________
Guido C.
Rispondi