Nel precedente articolo abbiamo visto come eseguire un programma per Arduino servendoci del suo ide per scrivere, compilare e trasferire nella nostra schedina un semplice sketch di prova. Adesso ci addentreremo nei primi dettagli riguardanti la gestione delle variabili e dei tipi di dato nello sviluppo dei nostri progetti con Arduino.
Variabili e costanti
Qualunque programma ci appresteremo a scrivere per Arduino (e non solo), farà uso di variabili per immagazzinare le informazioni da gestire (dati provenienti da sensori, comandi da inviare ad attuatori, liste di record provenienti da file di testo, stream di dati da recepire tramite consumo di webservice ecc.). Le variabili non sono nient’altro che porzioni di memoria in cui andremo a conservare (e tramite le quali andremo a recuperare) tali informazioni. La sintassi è molto semplice e segue il seguente standard:
<tipo_di_dato> <nome_variabile> = <valore>dove <tipo_di_dato> è il tipo della variabile (ad. esempio un numero intero), <nome_variabile> è il nome che daremo alla variabile (e che per chiarezza nostra e di chiunque leggerà lo sketch è consigliabile sia il più possibile significativo) e <valore> è il valore che verrà assegnato alla variabile (in questo caso un qualunque numero intero.
Costanti
Le variabili possono cambiare durante l’esecuzione del programma, ma spesso è utile poter creare delle variabili che non possono essere modificate. In questo caso si fa uso delle costanti, che per convenzione sono sempre in maiuscolo e vengono dichiarate con la parola chiave const utilizzando la seguente sintassi:
const <tipo_di_dato> <NOME_COSTANTE> = <valore> Come per le variabili, il nome dovrebbe essere significativo (ad es. LED_PIN piuttosto che XYZ), ma il valore assegnato inizialmente sarà immutabile. È possibile anche usare la direttiva del preprocessore #define:
#define <NOME_COSTANTE> <valore>
Suggerimento: le costanti riducono lo spazio di memoria occupato dal programma; è bene abituarsi ad usarle sempre dato che saranno molto utili nei progetti più complessi. Tipi di dato byte, int e long
Solitamente un valore numerico assume uno dei tipi appena mensionati, in particolare:
- il tipo byte ha una dimensione compresa tra 0 e 255 e occupa un byte di memoria
- il tipo int ha una dimensione compresa tra -32768 e 32767; occupa due byte di memoria. Qualora dichiarato come unsigned può assumere valori tra 0 65535
- il tipo long occupa quattro byte e assume valori compresi tra -2147483648 e 2147483647 (nel caso di un unsigned long i valoro compresi vanno da 0 a 4294967295)
Ecco alcuni esempi di dichiarazione e inizializzazione di byte, int e long:
byte pin13 = 13;
int rele_1 = 9;
long minValue = -34099858390L;Tipi di dato float e double
I tipi float e double si utilizzano per memorizzare valori in virgola mobile. Occupano quattro byte, per valori compresi tra -3,4028235E+38 e -3,4028235E+38, ad es.
float min_temperature = -10.8;
double max_value = 232335.3453;Tipi di dato boolean
I tipi di dato boolean possono assumere solo uno tra i due valori true e false e occupano un byte di memoria. La sintassi da utilizzare è la seguente:
boolean isAvalable = true;Tipi di dato char
Le variabili char utilizzano valori compresi tra -128 e 127. Occupano un byte di memoria e corrispondono a simboli e caratteri del codice ASCII. Di seguito due esempi di assegnazione di una variabile di tipo char facendo uso sia di un valore letterale numerico che di uno carattere tra doppi apici:
char wVar = 87;
char wVar2 = 'W';Tipi di dato array
Gli array (o vettori) contengono insiemi di valori dello stesso tipo. Si può accedere a singoli elementi di un array tramite un indice che indica la posizione (gli indici vanno contati a partire da 0, quindi un array di quattro elementi avrà indici che assumeranno i valori 0, 1, 2, 3, 4). Di seguito un esempio di utilizzo di un array:
//dichiarazione di un intero di quattro elementi;
int ip[4]; //notare le parentesi quadre per indicare la capienza del vettore
//assegnazione dei valori ai singoli elementi dell'array indicandone la posizione tramite indice; l'indice del primo elemento si conta a partire da 0
ip[0] = 192; //assegnazione del primo valore alla posizione 0
ip[1] = 168; //assegnazione del primo valore alla posizione 1
ip[2] = 1; //assegnazione del primo valore alla posizione 2
ip[3] = 0; //assegnazione del primo valore alla posizione 3Classi
Una classe è sostanzialmente un tipo di dato creato dal programmatore, contenente variabili e metodi per svolgere un determinato compito. La libreria standard di Arduino mette a disposizione alcune classi di alto livello come la classe String per gestire le stringhe di testo (ad esempio per la concatenazione e sostituzione di parti di testo). Tratteremo di questo argomento in articoli più avanzati.
Un programma per testare i tipi di dato Arduino
Adesso che abbiamo una prima panoramica dei principali tipi di dato utilizzabili nei nostri programmi per Arduino possiamo approntare uno sketch per testarli – utilizzando l’ide ufficiale -, facendo uso del monitor seriale per visualizzare l’output di alcune variabili. Come già avvenuto nei seguenti articoli, faremo soltanto uso della funzione setup per evitare che il codice venga ripetuto in un ciclo infinito all’interno della funzione loop. E anche in questo caso i commenti chiarificano lo scopo di ogni riga di istruzione.
//pin relè motore est, uso della direttiva define per la dichiarazioni di costanti
#define RELAY_EST 2
//pin digitale accensione-spegnimento led
//dichiarazione di constante tramite la parola chiave const
const unsigned int LED_PIN = 11;
void setup() {
Serial.begin(9600); //impostiamo il baudrate della porta seriale
//carattere D nella tabella dei codici ascii
char dChar = 'D';
Serial.print("Carattere D nella tabella dei codici ascii: ");
Serial.println(dChar);
//stesso carattere espresso con valore numerico
char dCharNum = 68;
Serial.print("Stesso carattere espresso con valore numerico: ");
Serial.println(dCharNum);
//array di byte per l'inizializzazione di un indirizzo ip
byte gatewayArray[4] = { 192, 168, 1, 1 };
Serial.print("Indirizzo ip: ");
//stampa dei singoli valori dell'array con accesso tramite indice,
//utilizzando le parentesi quadre
Serial.print(gatewayArray[0]);
Serial.print(".");
Serial.print(gatewayArray[1]);
Serial.print(".");
Serial.print(gatewayArray[2]);
Serial.print(".");
Serial.print(gatewayArray[3]);
Serial.println();
//booleano per verificare ad es. se un device è pronto per la comunicazione
boolean isReady = false;
Serial.print("Device pronto: ");
Serial.println(isReady);
//tempo di attivazione di un motore
unsigned long timeToMove = 36000000L;
Serial.print("Tempo di attivazione: ");
Serial.println(timeToMove);
//valore di temperatura
float temperature = 15.5;
Serial.print("Temperatura: ");
Serial.println(temperature);
//stringa di testo
char text1[] = "Secondo sketch Arduino";
//altra modalità di assegnazione stringa di testo
char text2[] = {'S','e','c','o','n','d','o',' ','s','k','e','t','c','h',' ','A','r','d','u','i','n','o'};
//terza modalità
char text3[4] = {68, 79, 68, 79};
Serial.print("String 1: ");
Serial.println(text1);
Serial.print("String 2: ");
Serial.println(text2);
Serial.print("Animale estinto: ");
Serial.println(text3);
}
void loop() {
// put your main code here, to run repeatedly:
}Ecco l’output sul monitor seriale del nostro sketch:
Carattere D nella tabella dei codici ascii: D
Stesso carattere espresso con valore numerico: D
Indirizzo ip: 192.168.1.1
Device pronto: 0
Tempo di attivazione: 36000000
Temperatura: 15.50
String 1: Secondo sketch Arduino
String 2: Secondo sketch Arduino
Animale estinto: DODO
Conclusione
Abbiamo esplorato i tipi di dato utilizzabili nei nostri progetti Arduino e abbiamo scritto un semplice programma per iniziare a testarli. Nei prossimi articoli introdurremo gli operatori e i controlli del flusso di esecuzione, che permettono di eseguire cicli ed istruzioni condizionali che renderanno più “intelligenti” e interessanti i nostri progetti.
