La mia prima scheda Arduino, Arduino MKR WiFi 1010 : Manuale d’uso e programmazione in Italiano!

Condividi questo articolo :

Premessa

Il linguaggio di programmazione è una vera e propria lingua con la quale possiamo dire ad un computer, cellulare o in questo caso ad una scheda programmabile come quella di Arduino le operazioni da eseguire in base a determinate condizioni. Per definire un linguaggio di programmazione quest’ultimo deve dare la possibilità di dichiarare le varibili, le quali sono una sorta di contenitore nel quale è possibile inserire un valore di vario tipo. I linguaggi come l’HTML, il CSS e cosi via NON sono linguaggi di programmazione ma solamente di formattazione, poichè permettono soltanto di posizionare e modificare visivamente oggetti a schermo tramite degli schemi più o meno semplici. I linguaggi come PHP, C#(c sharp), C++(c plus plus), JavaScript e cosi via sono definiti invece linguaggi di programmazione, poiché appunto ci permettono la dichiarazione delle variabili. Il linguaggio di programmazione che usa Arduino è un linguaggio derivato dal C++ e si chiama Writing.

In questo manuale cercheremo di offrirvi un’infarinatura chiara e completa su tutto quello che concerne il linguaggio di programmazione di Arduino e l’uso che possiamo farne della scheda in questione.

Immagini e documentazione sono di proprietà della redazione di Filo Connesso, tutto il materiale in questa pagina è distribuito con licenza CC (Distribuisci allo stesso modo, non è consentito uso commerciale). Puoi condividere il manuale in versione integrale e suggerire correzioni e miglioramenti, confidando nella tua collaborazione e nel tuo rispetto per il nostro lavoro, ti auguriamo buona lettura!

Creato con ❤️ da Filo Connesso.

CAPITOLO 1. Software utili

Nel corso del manuale potete trovare degli schemi fatti al pc che raffigurano in modo semplice e chiaro i vari collegamenti che potrete realizzare tra la vostra scheda Arduino e i vari componenti. Il programma che usiamo per realizzare questi schemi si chiama Fritzing e lo potete scaricare da qui. Fritzing permette di trascinare gli oggetti su un piano di lavoro e successivamente permette di collegarli tra di loro risultando un ottimo modo per la realizzazione di circuiti ancor prima di mettere mano a saldatore e stagno :

Vi segnaliamo anche un altro software che può essere molto utile durante lo sviluppo di un progetto con Arduino, si chiama Tinkercad e lo trovate a
questo indirizzo. Tinkercad al contrario di Fritzing, non permette l’importazione di componenti personalizzati e aggiuntivi ma permette la simulazione dei circuiti direttamente dal computer e di conseguenza verificarne il corretto funzionamento!

CAPITOLO 2. Software OpenSource e Software Proprietario

Iniziamo nel dire che c’è da fare un distinzione tra i vari software specificando che esistono software opensource e software proprietari. I software opensource, che tra l’altro è il gruppo a cui appartine anche Arduino, oltre ad essere gratuiti (non sempre però), permettono a sviluppatori esterni e/o indipendenti rispetto al prodotto di collaborare per migliorarne l’usabilità, di creare derivate e/o espansioni e di conseguenza, quasi sempre, i software opensource sono supportati da community di utenti molto vaste. I prodotti e i software opensource fanno pensare sempre a prodotti che sono sostanzialmente gratuiti, anche se questo è un mito da sfatare, poiché la fisolosofia dell’opensource è prettamente legata al sapere e al concetto intellettivo del prodotto e non al prodotto stesso, infatti Arduino si compra, nonostante sia opensource ma ci è permesso di ricrearlo a casa con gli schemi presenti sul sito ufficiale. Il software proprietario invece, come potrebbe essere Windows, il sistema operativo che quasi sicuramente è installato sul tuo computer, non può essere toccato e tutti i diritti sui miglioramenti applicabili al suo codice sono di proprietà del produttore, cioè Microsoft. Avere una copia craccata di Windows (attivazione fatta con programmi senza pagare il software) equivale ad aver modificato il software e di conseguenza significa aver commesso un reato, poiché è stato modificato un software proprietario.

CAPITOLO 3. La scheda Arduino

La scheda Arduino è sostanzialmente un computer dalle dimensioni di una carta di credito (alcuni modelli) che opportunamente programmato permette di interagire con il mondo esterno usando pulsanti, led, motori ecc ecc. Arduino è un progetto Italiano nato nel 2006 da Massimo Banzi e lo scopo iniziale della scheda era quella di semplificare l’implementazione di un cuore elettronico per prototipi e oggetti di design per uso scolastico.

Ad oggi Arduino è la piattaforma di prototipazione elettronica più famosa e diffusa al mondo e dal primo modello ne ha fatto di strada, tanto che adesso in commercio sono disponibili addirittura modelli Wi-Fi e GSM!

Questo manuale sarà basato su Arduino MKR Wi-Fi 1010, una piattaforma fresca e un prodotto che riteniamo effettivamente un buon connubio tra semplicità di utilizzo e completezza per chi si affaccia a questo mondo per la prima volta, poiché avendo a disposizione un sensore Wi-Fi integrato, permette di avvicinarsi rapidamente all’attuale mondo dell’IOT ma allo stesso tempo non si allontana dall’uso “classico” di una normale scheda Arduino.

Se non hai un Arduino MRK Wi-Fi 1010 non preoccuparti, il manuale è strutturato al 95% per essere seguito e studiato anche per schede diverse da quella trattata. In caso tu sia interessato all’acquisto della scheda usata in questa documentazione, cosa che noi consigliamo, puoi acquistarla dallo store ufficiale o da questo link.

Ebbene, prima di iniziare a fare qualcosa di pratico è normale conoscere un pochino più da vicino il nostro nuovo giocattolo e capire cosa può fare e cosa non può fare. La prima cosa che è molto evidente notare su qualsiasi scheda Arduino è senza ombra di dubbio la presenza di pin, i quali servono per connettere i vari componenti(sensori, pulsanti ecc ecc) alla scheda :

Vediamo di conoscerli :

  1. AREF : Permette di regolare la tensione massima (Volt) di risoluzione sui pin analogici.
  2. A0, A1, A2, A3, A4, A5 e A6 : Sono pin Analogici, normalmente di input (ingresso), ma che possono essere programmati anche come uscite.
  3. 0,1,2,3,4,5,6,7,8,9,10,11,12,13 e 14 : Sono pin digitali di input(ingresso) e output(uscita) i quali possono essere programmati per fare una sola funzione in base alle nostre necessità.
  4. RESET : Permette di resettare (riavviare il codice al suo interno) collegandolo con GND.
  5. GND : Pin negativo o massa.
  6. VCC : Pin di alimentazione (max 3.3v) .
  7. VIn : Pin di ingresso alimentazione supplementare (max 5V) .
  8. 5V : Pin per alimentare componenti esterni a 5V.

Tra i pin digitali ci sono alcuni pin che non possono essere usati normalmente e alcuni che hanno funzioni particolari ma che possono comunque essere usati per ingresso e uscita :

  1. 8 MOSI : Pin di comunicazione utile per display.
  2. 9 SCK : Pin di comunicazione utile per display.
  3. 10 MISO : Pin di comunicazione utile per display.
  4. 11 SDA : Pin bus per I2C (non può essere utilizzato per scopi diversi dall’I2C).
  5. 12 SCL : Pin bus per I2C (non può essere utilizzato per scopi diversi dall’I2C).
  6. 13 RX : Pin di lettura seriale.
  7. 14 TX : Pin di scrittura seriale.

I pin con il simbolo d’onda (~) sono chiamati pin PWM e permettono di variare la loro tensione. Questa tipologia di pin è utilizzata per regolare ad esempio la velocità di un motorino elettrico. Assieme ai pin analogici (A0, A1, A2…), i pin PWM sono utilizzati anche per ricevere segnali analogici da diversi tipi di sensori.

Sotto la scheda abbiamo a disposizione la serigrafia della pedinatura, comoda nel caso in cui utilizziamo i pin (tipo maschio) per collegarli con dei cavetti dupont e riconoscere i pin anche se la scheda non è nel verso giusto :

Inoltre, cosa che apprezzeremo senza ombra di dubbio, è la possibilità di sfruttare i pin (tipo maschio) sotto la scheda per alloggiarla su una breadboard :

In fine, impariamo a riconoscere i componenti che lo compongono :

  1. Sensore Wi-Fi U-BLOX NINA-W10 Series Low Power 2.4GHz IEEE® 802.11 b/g/n.
  2. Led RGB.
  3. Processore SAMD21 Cortex-M0+ 32bit Low Power ARM MCU affiancato da CrypoChip ECC508.
  4. Pulsante di reset, se premuto 2 volte ripetutamente si entra in bootloader (utile per risolvere alcuni problemi di caricamento).
  5. Connettore per batterie lipo (max 3.7V).
  6. Integrato di gestione alimentazione e ricarica attraverso le batterie lipo.
  7. Led di stato per la carica della batterie.
  8. Connettore bus I2C.
  9. Led di stato “L” collegato al pin I/0 digitale 6.
  10. Connettore Micro USB per programmare la scheda e eventualmente alimentarla.C

CAPITOLO 4. L’ambiente di sviluppo (IDE)

Tutti i linguaggi di programmazione per essere scritti hanno bisogno di un software principale chiamato IDE, Arduino ha a disposizione il suo IDE omonimo che permette appunto di scrivere il codice, compilarlo e successivamente caricarlo sulla scheda.

Il codice scritto è definito di alto livello poiché la comprensione di quest’ultimo è stata semplificata usando parole in inglese e in definitiva è leggibile anche da un umano. I linguaggi a basso livello, invece, hanno la particolarità di essere elaborati direttamente dalla macchina senza compilazioni, un esempio di linguaggio a basso livello può essere l’assembly guarda qui ,il quale è formato da centinaia di valori difficili da comprendere ammenoché non siamo degli esperti del settore.

Il processo di compilazione permette quindi di trasformare un linguaggio di programmazione in un linguaggio dedicato al processore di Arduino, il quale non comprenderebbe il codice scritto in Writing.

La compilazione avviene ogni volta che si preme il pulsante “Carica” presente nell’IDE di Arduino.

Per scaricare tutto il necessario che ci servirà per programmare Arduino possiamo avvalerci del sito ufficiale e da questa pagina potremo scaricare il software o in alternativa potremmo usare la versione Web direttamente dal nostro browser di navigazione internet.

Una volta scaricato e avviato il software ci troveremo davanti a questa finestra :

Analizziamo velocemente l’interfaccia del software per capirne le potenzialità :

  1. Barra dei menu : permette di accedere alle impostazioni di Arduino e ad altre impostazioni che vedremo in seguito.
  2. Pulsante compilazione : Premendo il pulsante della compilazione è possibile compilare il codice e effettuare un controllo di quest’ultimo, qualora si verificasse qualche errore l’IDE ci informa di che errore si tratta e da li potremmo risolvere il problema.
  3. Pulsante caricamento : Premendo il pulsante del caricamento è possibile dapprima compilare il codice e automaticamente caricarlo sulla scheda qualora non si verifichino errori.
  4. Pulsante nuovo : Permette di aprire una nuova finestra con un nuovo file vuoto.
  5. Pulsanti Apri e Salva : Permettono di aprire un nuovo file (.ino) o di salvare il codice corrente.
  6. Pulsante Monitor Seriale : Permette di aprire il Monitor Seriale, uno strumento molto utile che come vedremo successivamente diventerà il nostro compagno di avventure!
  7. Barra schede : Qui vengono mostrate tutte le schede, ogni scheda rappresenta una pagina di lavoro dove possiamo scrivere il codice. Con il pulsante con la freccia verso il basso (▼) possiamo gestire le varie schede aperte e crearne di nuove.

Subito dopo troviamo l’area di scrittura dove appunto scriveremo il nostro codice :

Notate che in base alla tipologia di “comando” il codice viene colorato di colori diversi, questo migliora la leggibilità e la distinzione tra le varie porzioni di codice. Questo sistema di riconoscimento del codice viene definito Syntax Highlight, appunto evidenziazione della sintassi.

In basso nella finestra troviamo l’area di debug, quest’ultima ci mostrerà lo stato dei caricamenti, eventuali errori e altre informazioni importanti utilissime durante lo sviluppo di un programma :

Abbiamo inoltre informazioni molto utili, come in basso a sinistra il numero della riga di codice dove è posizionato il cursore di scrittura e a destra troveremo il tipo di scheda collegata con annessa la sua porta COM in riferimento all’USB. Nel nostro caso abbiamo collegato un Arduino MKR WiFi 1010 e il computer ha assegnato a quest’ultimo la porta COM8.

Al primo avvio troveremo già parte del codice base scritto, con due sezioni principali che vengono definite funzioni :

void setup() {
    // put your setup code here, to run once:
}

La funzione setup() conterrà tutte le istruzioni che verranno eseguite una sola volta al momento che diamo alimentazione ad Arduino.

void loop() {
// put your main code here, to run repeatedly:
}

La funzione loop() conterrà tutte le istruzioni che verranno eseguite per sempre affinché Arduino è alimentato e acceso, infatti il comportamento del processore di Arduino è ciclico e quindi eseguirà all’infinito il codice che scriveremo nella funzione loop().

Come vedremo nei prossimi capitoli, sarà possibile creare e aggiungere al codice le nostre funzioni in base alle nostre esigenze, ma è bene sapere che le funzioni sono porzioni di codice che possono essere richiamate in qualsiasi momento e che ci permettono di snellire le istruzioni all’interno del nostro programma.

Le righe di codice precedute dal doppio slash “//” sono definiti commenti e servono solamente per velocizzare il riconoscimento delle porzioni di codice di nostro interesse. Nel caso di un nuovo file il commento all’interno di setup() ci indica che il codice inserito in quella funzione verrà avviato una sola volta all’avvio della scheda, mentre il commento nel loop() ci indica che il codice scritto al suo interno verrà ripetuto all’infinito. E’ inutile dire che possiamo creare i nostri commenti per semplificarci la vita, per esempio :

int risultato; //dichiaro la variabile "risultato"
int a = 12; //dichiaro la variabile "a"
int b = 12; //dichiaro la variabile "b"
risultato = a + b; //eseguo la somma delle variabili "a" e "b" inserendo il risultato nella variabile "risultato"

Come potete notare ad ogni riga di codice è stato inserito un commento che descrive la funzione di quella riga di codice, non è utilissimo ? 😀

CAPITOLO 5. Collegare correttamente la scheda.

Abbiamo visto che l’IDE di Arduino ci indica quale scheda è collegata al computer e ce la mostra nella barra di stato/debug, ma se cosi non fosse ? Possiamo selezionare la nostra scheda e eventualmente capire se è realmente riconosciuta dal nostro computer andando nel menu Strumenti e successivamente nel sottomenu Porta :

Nel menu porta ci verrà comodamente suggerito anche il modello di scheda collegato, che dovremo selezionare anche nel menu Scheda il quale è posto sempre nel menu Strumenti :

Potrebbe capitare che per far riconoscere l’Ide la nuova scheda MKR WiFi 1010 bisogna installarla dal gestore schede, per fare ciò basta recarsi sul Gestore schede presente nel menu Strumenti e cercare il supporto schede scrivendo “mkr”, successivamente fare click su Installa e infine chiudere la finestra con OK e Chiudi :

Fatto questo possiamo iniziare a programmare Arduino, ovviamente partendo dalle basi 😁.

CAPITOLO 6. Il programma Blink ? No, iniziamo dal punto e virgola!

Ogni linguaggio di programmazione ha una sintassi ben precisa da seguire, la quale se non rispettata ci fa incorrere in errori micidiali🤣.

Nel linguaggio di programmazione di Arduino la cosa da ricordarsi sempre e comunque è che ogni riga di codice, tranne per rare eccezioni, deve essere completa di un punto e virgola “;” finale che fa capire al compilatore quando una determinata istruzione è finita e si inizia con una nuova nel rigo successivo :

//dichiarazione costanti prima che il codice venga compilato, non serve il punto e virgola
#define a
#define b
#define c
//dichiarazione variabili, serve il punto e virgola
int a;
int b;
int c;
//costrutto decisionale, non serve il punto e virgola
if(condizione) {
riga codice 1;
riga codice 2;
riga codice 3;
} else {
riga codice 1;
riga codice 2;
riga codice 3;
}
//funzione, non serve il punto e virgola
void funzione() {
riga codice 1;
riga codice 2;
riga codice 3;
}

Come potete notare le porzioni di codice attinenti alla dichiarazione di costanti (variabili con valore fisso e non modificabile) precedute da #define non necessitano di un ; finale, mentre la dichiarazione di variabili necessita l’interruzione della riga. Nel caso di costrutti decisionali e/o funzioni il punto e virgola va usato solo nelle righe al loro interno e non affianco alle parentesi graffe, adesso non spaventatevi poiché quando entreremo nel vivo dell’azione sarà tutto più chiaro!

CAPITOLO 7. Le variabili e le costanti

Come abbiamo detto in precedenza un linguaggio di programmazione può essere definito tale solamente se permette la creazione di variabili. La creazione di una variabile viene chiamata in gergo tecnico “dichiarazione” e qualsiasi variabile può essere dichiarata a inizio codice o all’interno del codice. Se una variabile viene dichiarata a inizio codice è considerata come variabile globale o pubblica poiché quest’ultima può essere richiamata in qualsiasi momento da qualsiasi funzione all’interno del codice stesso. Se una variabile viene dichiarata all’interno di una funzione, questa non può essere richiamata da qualsiasi parte del codice ma solo all’interno della funzione stessa e di conseguenza risulta privata.

Ma proviamo a fare qualche esempio di variabile globale o pubblica :

Nel caso mostrato qui sopra potremmo richiamare la variabile variabilePubblica in qualsiasi parte del codice senza problemi. Ma se dichiarassimo la variabile nel setup(), nel caso in cui andassimo a richiamarla nel loop(), ci verrà restituito un errore poiché per il compilatore la variabile utilizzata non è dichiarata per quel determinato scopo :

Adesso approfondiamo l’argomento introducendo in questo manuale una vera spiegazione sulla dichiarazione delle variabili. Come detto in precedenza le variabili possono contenere un valore di diverso tipo, questo significa che per far capire al compilatore di che tipo è una determinata variabile questa deve essere dichiarata in modo opportuno. Esistono vari tipi di variabile e linea di massima prenderemo in analisi solo alcune di loro, magari quelle più frequentemente usate per programmare Arduino e essere utilizzate nei vari progetti :

a. Le variabili numeriche

Come suggerisce il nome, le variabili numeriche sono utilizzate per contenere dei valori numerici (cifre e numeri) e in base alla natura del valore possono essere :

  1. int : cifre e numeri interi.
  2. float : cifre e numeri decimale.
  3. long : numeri enormi da -2.147.483.648 a 2.147.483.647.
  4. double : doppia precisione con la virgola fino a 1,7976931348623157×10^308.
  5. boolean : variabile logica che può contenere solo 0 o 1.

Esitono inoltre due tipologie di variabile int e long che vengono precedute da prefisso unsingned e sostanzialmente sono delle variabili numeriche senza componente negativa.

Qualsiasi variabile può essere dichiarata inizializzandola, questo vuol dire che può essere dichiarata assegnandole un valore iniziale :

Potremmo al contrario dichiarare ma non inizializzare le variabili in questione :

Da notare che per assegnare un valore decimale si deve usare sempre il punto (.) per separare la componenti intera da quella decimale, usando la virgola ci restituirebbe un errore :

Essendo che stiamo trattando le variabili numeriche, sappiate che è possibile effettuare operazioni matematiche tra le varie variabili in modo semplice e veloce :

All’interno della variabile risultato ci sarà il valore 9.

b. Le variabili stringa

Le variabili stringa a differenza di quelle numeriche possono contenere sia numeri che lettere. La dichiarazione di una variabile stringa è uguale a quella delle variabili numeriche anche se l’inizializzazione va fatta inserendo il valore all’interno dei doppi apici (es. “cane” o “a”). La tipologia di variabile Stringa è String.

La loro dichiarazione come detto prima è identica a quella delle variabili numeriche ma vanno inizializzate in questo modo :

E’ possibile anche concatenare varie variabili che contengono pezzi di una frase che vanno uniti insieme usando il segno + come fosse una somma tra numeri :

Se vogliamo inserire un valore numerico in una variabile stringa possiamo convertire il valore numerico in stringa, questo ci permette per esempio di creare delle frasi con la lettura di un valore proveniente da un sensore :

c. Le variabili char e byte

Le variabili char e byte sono due tipologie di variabile particolari e che vengono usate in ambiti leggermente più avanzati degli esempi che abbiamo visto fino ad adesso. Le variabili char possono contenere solo un carattere il quale deve essere inizializzato all’interno di un singolo apice (es. ‘A’ o ‘5’ o ‘F’) che però all’interno di Arduino verrà salvato con il numero corrispondente in char. Le variabili byte possono contenere dei numeri da 0 a 255 e ogni varibile byte occupa 1 byte (8 bit).

La dichiarazione e l’eventuale inizializzazione è identica al metodo già visto in precedenza :

d. Le costanti const e #define

Le costanti sono simili alle variabili ma al contrario di quest’ultime non hanno un valore che può essere modificato durante l’esecuzione del programma e per creare una costante basterà inserire il prefisso const ad una normale variabile, qualsiasi sia la sua tipologia :

Tuttavia, le costanti devono essere obbligatoriamente inizializzate altrimenti producono un errore :

Ovviamente, essendo delle costanti, se cercheremo di modificarne il valore all’interno del programma questo restituirà un errore poichè le costanti sono di sola lettura :

Un altro tipo di costante è quello dichiarato con il prefisso #define , questa tipologia di costante è una costante eseguita prima della compilazione e viene riconosciuta da Arduino cosi come la scriviamo.

Una caratteristica interessante delle costanti #define è che non necessitano di essere dichiarate specificandone la tipologia e non necessitano del segno uguale (=) per essere inizializzate, tuttavia, come le costanti “classiche” hanno bisogno obbligatoriamente di essere inizializzate a inizio codice :

Come potete notare nell’esempio, le costanti #define non hanno bisogno del punto e virgola finale.

CAPITOLO 8. Array

Abbiamo posizionato gli Array subito dopo le variabili perché sono molto simili ma più complessi nella struttura, anche gli Array permettono di immagazzinare dei valori al loro interno, anzi in realtà permettono di immagazzinare più valori al loro interno!

La struttura di un Array è la medesima :

Come si può notare dall’esempio, la prima parte della dichiarazione di un Array è identica a quella delle variabili, tuttavia, al nome della variabile viene aggiunto un numero tra le parentesi quadre (es. [4]) per indicare il numero di valori che vanno inseriti all’interno dell’array, successivamente dopo l’uguale vanno indicati i vari valori tra le parentesi graffe e ogni valore va separato con una virgola.

Se vogliamo prelevare un determinato valore di un array è possibile farlo in questo modo :

Infatti sarà possibile prelevare un determinato valore, in questo caso dell’array parole, selezionando la posizione del valore desiderato con parole[2]. Adesso, come ben si possa pensare il valore dovrebbe corrispondere a cane, ma in realtà sarà amico poiché l’array numera i valori al suo interno partendo da 0, quindi avremo questa numerazione :

0 = casa, 1 = cane, 2 = amico, 3 = giardino

Per cambiare un determinato valore di un array, magari volendo sostituire giardino con palazzo è necessario scrivere in questo modo, metodo che è uguale pressoché al cambiare un valore ad una variabile ma selezionando la posizione da aggiornare :

L’array è molto utile in caso in cui dovremmo immagazzinare più valori, magari un centinaio di valori di natura numerica e successivamente ricavarne la media utilizzando sostanzialmente una sola variabile invece che 100 variabili! Sappiamo che vi stiamo stuzzicando l’appetito, ma ci vuole del tempo, abbiate pazienza! 😜

CAPITOLO 9. Funzioni

Un’altra caratteristica apprezzatissima di un linguaggio di programmazione sono le funzioni, quest’ultime permettono di creare porzioni di codice le quali possono essere richiamate in qualsiasi momento e in qualsiasi posizione del programma. Le due funzioni base e non modificabili di Arduino sono setup() e loop(). Le funzioni hanno una struttura uguale a questa e non possono essere create all’interno di un’altra funzione :

void miaFunzione() {
//qui va il codice della funzione
}

Il codice della funzione va necessariamente inserito all’interno delle parentesi graffe ed è importante che le parentesi graffe vengano aperte e chiuse per non incorrere in errori.

la dicitura void prima del nome della funzione viene scritta per rilasciare un valore nullo della funzione stessa, ma in alternativa potremmo creare delle funzioni che possono rilasciare un valore stringa o numerico usando rispettivamente la sintassi corrente :

String miaFunzioneStringa() {

}
int miaFunzioneNumerica() {

}

E’ importante ricordarsi che non può essere creata più di una funzione con lo stesso nome altrimenti il compilatore restituirebbe un errore :

Una volta che abbiamo creato la nostra funzione sarà possibile richiamarla all’interno del nostro programma ogni qualvolta che ne avremo bisogno :

Oltre alla possibilità di creare delle funzioni che contengono una porzione di codice, la quale possiamo richiamare ogni volta senza riscriverla, possiamo dare in pasto alla nostra funzione dei valori chiamati Argomenti. Gli Argomenti sono sostanzialmente delle variabili utilizzate esclusivamente dalla funzione che vengono dichiarate all’interno delle parentesi tonde presenti a destra del nome della funzione :

void miaFunzione(String argomento1, int argomento2, char argomento3) {
//codice
}

ogni argomento dovrà essere separato da una virgola.

Successivamente potremmo inserire all’interno di ogni argomento il valore desiderato stando attenti a rispettare le solite regole dell’inizializzazione delle variabili e quindi usando i doppi apici quando diamo un valore a un argomento di tipo stringa, ad non usare nulla quando abbiamo a che fare con argomenti di tipo numerico e infine a usare un singolo apice per gli argomenti char :

miaFunzione("casa",34,'A');

Per chiarire il tutto creeremo una funzione che permetta di sommare due numeri ed infine inserire il risultato in una variabile globale, ecco un esempio :

Nel caso mostrato i due Argomenti sono di tipo numerico e vengono riempiti con i numeri 3 e 5, successivamente all’interno della funzione viene riempito il valore della somma tra x e y all’interno della variabile risultato la quale infine può essere utilizzata come vogliamo all’interno del nostro codice. Con questo sistema potremmo richiamare ogni qualvolta vogliamo la funzione funzioneSomma dandogli in pasto ogni volta dei valori diversi :

E’ logico che ogni volta che richiameremo la funzione, la variabile risultato cambierà il suo valore corrente.

Se in una funzione abbiamo deciso di creare degli argomenti è importante ricordare che questi argomenti vanno soddisfatti e non trascurati, quindi se in una funzione abbiamo per esempio 3 argomenti, quest’ultimi vanno riempiti obbligatoriamente con un valore per non incorrere in errori :

Nel’esempio riportato sopra abbiamo omesso un valore, riempiendo solo 2 dei 3 argomenti della funzione e infatti il compilatore ci dirà che non tutti gli argomenti della funzione sono stati correttamente inizializzati.

CAPITOLO 10. Operatori e costanti di default

Da adesso in poi verranno proposti esempi di codice dove all’interno sono presenti degli operatori matematici e condizionali, questi permettono di controllare se si raggiunge una determinata condizione o magari per controllare se una variabile assume un valore maggiore di un’altra variabile.

Prima di affrontare quindi nuovi argomenti sulla programmazione di Arduino è bene conoscere i vari operatori.

Operatori matematiciDescrizione
==Operatore di uguaglianza per controllare se due valori sono identici.
!=Operatore di disuguaglianza per controllare se due valori sono diversi.
<Operatore “minore di” per controllare se un valore è minore di un altro valore.
>Operatore “maggiore di” per controllare se un valore è maggiore di un altro valore.
<=Operatore “minore uguale di” per controllare se un valore è minore uguale di un altro valore.
>=Operatore “maggiore uguale di” per controllare se un valore è maggiore uguale di un altro valore.
++Incrementa di uno il valore della variabile numerica interessata (es. variabile++).
Decrementa di uno il valore della variabile numerica interessata (es. variabile–).

Poi esistono operatori condizionali :

Operatori condizionaliDescrizione
OROperatore condizionale corrispondente alla congiunzione “o” (es. se si verifica questa condizione O quest’altra condizione).
ANDOperatore condizionale corrispondente alla congiunzione “e” (es. se si verifica questa condizione E quest’altra condizione).

Constanti di default :

Constanti di defaultDescrizione
LED_BUILTINConstante di default che va a richiamare in automatico il numero del pin collegato al led L saldato su Arduino.
HIGHConstante di default contenente il valore 1.
LOWConstante di default contenente il valore 0.

CAPITOLO 11. Cicli

I cicli sono delle interessanti funzioni le quali eseguono il codice al loro interno fino a quando una determinata condizione non viene soddisfatta. Le tipologie di cicli usate comunemente sono i cicli FOR e i cicli WHILE .

a. Ciclo FOR

Il ciclo FOR esegue il codice al suo interno basandosi su una condizione che viene regolata da un argomento ben specifico chiamato variabile di indice, la quale, essendo di natura numerica, può essere incrementata o decrementata.

La struttura di un ciclo FOR è la medesima :

for(int indice = 0; indice < 12; indice++) { 
//qui il codice
}

Come si può ben notare abbiamo chiamato la variabile indice con il nome appunto di indice, ma come tutte le variabili potrete cambiarle il nome come meglio credete, difatti normalmente viene indicata solamente con la lettera i :

for(int i = 0; i < 12; i++) { 
//qui il codice
}

gli argomenti del ciclo FOR sono facili da comprendere e vengono elencati in modo logico :

int i = 0; //dichiaro e inizializzo la variabile indice partendo da 0
i < 12; //condizione da soddisfare di esempio : eseguo il codice del ciclo affinchè il valore dell'indice è minore di 12
i++; //aumento di 1 il valore dell'indice ogni volta che il ciclo completa un'esecuzione del codice

Questa funzione particolare permette di seguire in ripetizione alcune porzioni di codice.

Con questa funzione potremmo, per esempio, impostare tutti i pin di Arduino in uscita e spegnerli all’accensione della scheda :

O ancora incrementare il valore di una variabile affinché non arrivi a valere 100 :

Magari potrebbe essere utile per creare una barra di caricamento.

b. Ciclo WHILE

Il ciclo WHILE ha una struttura più semplice del ciclo FOR e si presenta in questo modo :

while(condizione da soddisfare) {

}

La condizione da soddisfare nel ciclo WHILE può essere semplicemente una condizione di tipo matematico o più articolata, per esempio magari per controllare se la nostra scheda è connessa al Wi-FI.

Per esempio se vogliamo incrementare un valore per 10 volte potremmo scrivere qualcosa del genere :

In questo caso il ciclo si fermerà non appena la variabile valoreDaIncrementare avrà raggiunto il valore 10.

CAPITOLO 12/A. Costrutti decisionali (if, else if e else)

I costrutti decisionali sono molto utili per eseguire una porzione di codice in base ad una condizione ben precisa e permettono quindi di far prendere delle decisioni al programma in modo autonomo.

Un costrutto decisionale base è if (se) e ha questa struttura :

if(condizione) {
//il codice qui
}

In base alla condizione alla condizione presente nella parentesi tonde, verrà eseguito il codice all’interno delle parentesi graffe.

In un costrutto decisione è possibile inserire più di una condizione con il costrutto else if(altrimenti se) :

if(prima condizione) {
//il codice qui
} else if(seconda condizione) {
//il codice qui
} else if(terza condizione) {
//il codice qui
}

In questo caso sono 3 le condizioni che possono essere soddisfatte e nel caso in cui una delle condizioni viene soddisfatta verrà eseguito il codice attinente a quella condizione.

In fine, ma non in ordine di importanza, esiste il costrutto else(altrimenti) che può essere usato in extremis se nessuna delle condizioni precedenti è stata soddisfatta, come fosse una situazione di emergenza :

if(prima condizione) {
//il codice qui
} else if(seconda condizione) {
//il codice qui
} else if(terza condizione) {
//il codice qui
} else {
//il codice di emergenza qui
}

Iniziamo con un esempio semplice, mettiamo il caso che abbiamo a disposizione una variabile chiama x con il valore al suo interno pari a 10 :

In questo caso il codice all’interno del costrutto decisionale non potrà essere eseguito poiché richiede che x sia minore di 10 e quindi non cambierà il suo valore in 5. Aggiungiamo una condizione al codice :

Anche in questo caso x non cambierà di valore poiché nessuna della condizioni viene soddisfatta! Proviamo ancora :

In questo caso x cambierà di valore in 8 poiché la terza condizione viene soddisfatta, infatti il doppio uguale (==) è utilizzato per controllare l’uguaglianza di due valori. Come potete ben vedere con i costrutti decisionali possiamo cambiare il comportamento di un programma molto semplicemente in base a varie cose che possono succedere durante la sua esecuzione.

E’ possibile concatenare più condizioni insieme usando gli operatori OR e AND :

Nel caso mostrato sopra solo il secondo costrutto decisionale eseguirà le operazioni richieste poichè una delle condizioni viene soddisfatta e di conseguenza variabile1 resterà vuota e variabile2 assumerà il valore 5.

CAPITOLO 12/B. Costrutti decisionali (switch case)

Nel gruppo dei costrutti decisionali abbiamo a disposizione una tipologia in grado di controllare un determinato caso e successivamente eseguire un codice scelto. I costrutti decisionali switch case permetto di eseguire un codice in base ad un’opzione, il valore scelto come opzione è numerico e verrà controllato in una serie di case break :

La variabile opzione è impostata su 0 e lo switch va a controllare il valore inserito all’interno di opzione, successivamente all’interno dello switch viene controllato quale valore ha all’interno la variabile opzione, in questo caso 0 e di conseguenza x assume il valore 10.

Se cambiamo il valore ad opzione, magari con la cifra 2, x assumerà il valore 9.

CAPITOLO 13. Seriale e delay

Finalmente iniziamo ad analizzare alcune funzioni prettamente legate al linguaggio di programmazione di Arduino e non alla programmazione in generale, parliamo per l’appunto della Seriale e della funzione Serial. La seriale permette di scrivere sostanzialmente dei dati direttamente all’interno della connessione USB che intercorre tra Arduino e il computer e tramite questa funzione sarà possibile scrivere informazioni importanti che possono essere utili durante lo sviluppo di un programma.

La seriale deve essere aperta e al momento dell’apertura di una connessione seriale va indicato il baudrate, ossia la velocità di trasmissione dei dati che normalmente viene impostata con il valore di 9600.

Proviamo a utilizzare la seriale per la prima volta facendo scrivere ad Arduino un semplice frase :

Inizializziamo una una variabile stringa chiamata messaggio con una frase di esempio e successivamente apriamo la nostra seriale con la funzione Serial.begin(), impostiamo come detto prima il baudrate a 9600, questo va fatto nel setup() e infine scriviamo con Serial.print() il valore della variabile messaggio, attendendo però 5 secondi prima di scrivere.

Per attendere 5 secondi abbiamo usato un delay(), questa funzione mette in pausa l’esecuzione del codice per il periodo indicato in millisecondi all’interno delle parentesi tonde, in questo caso 5000 millisecondi (5 secondi).

Possiamo usare un dalay() con il tempo di pausa che desideriamo in qualsiasi parte del codice.

Per la prima volta possiamo fare click sul pulsante Carica (➜) per caricare il codice sulla scheda, successivamente potete aprire il Monitor Seriale dal menu Strumenti per osservare il risultato del nostro codice, ricordatevi che dovete aspettare qualche secondo per via del delay() che ci darà anche il tempo di aprire l’utility per la seriale :

E dopo qualche secondo…

Se non vediamo nulla del genere potete aumentare i millisecondi a disposizione prima che Arduino scriva sulla seriale o se ancora non vedete nulla controllate che i parametri del Monitor Seriale siano impostati correttamente :

Se vogliamo scrivere su più righe possiamo impostare il codice in questo modo :

Usando la funzione Serial.println() Arduino scrive una riga vuota, mandando a capo il testo del Serial.print() successivo :

Oltre che scrivere, possiamo leggere dalla seriale con la funzione Serial.readString() nel caso in cui vogliamo far leggere un valore stringa o al contrario, se vogliamo leggere un valore numerico utilizzeremo Serial.read().

Cercheremo adesso di continuare a scrivere il programma attuale facendo leggere ciò che scriveremo nella seriale, in questo caso il nostro nome, scrivendo nel loop() ciò che segue :

Il codice è già commentato per capire come funzionano le varie istruzioni ma in linea di massima verrà controllato se scriveremo qualcosa nella seriale, successivamente verrà inserito all’interno di una variabile chiamata risposta e infine ci verrà mostrato un messaggio che ci saluterà con il nostro nome. Per fare ciò abbiamo creato anche una variabile numerica a inizio codice :

questa variabile permette di controllare quando una risposta è già stata data, la variabile si chiama rispostaData e viene inizializzata a inizio codice con il valore 0. Una volta che abbiamo dato la nostra risposta con il nome la variabile rispostaData assume il valore 1 e impedisce di inserire un altro nome, azionando l’ultima parte di codice che ci informa che non possiamo dare più nomi :

Adesso potete caricare il codice e testare il corretto funzionamento dal Monitor Seriale, scrivendo nella barra di testo superiore il nostro nome e successivamente premendo invio :

E se proviamo a ridare un nuovo nome, il programma ci informa che già abbiamo dato un nome :

In questa fase abbiamo visto nuovi metodi di che approfondiremo più avanti, tuttavia è bene ricordare che le funzioni come Serial, ma anche altre funzioni presenti nel linguaggio di programmazione di Arduino hanno vari argomenti e parametri secondari da poter richiamare ogni qualvolta ci servono. Qui sotto trovi alcuni dei parametri della funzione Serial più usati :

ParametroDescrizione
Serial.begin(baudrate);Parametro base della funzione Serial, permette di aprire una connessione Seriale all’interno dell’USB specificandone il baudrate.
Serial.println();Parametro che permette di scrivere una riga vuota (mandare a capo) all’interno della seriale.
Serial.print(valore);Permette di scrivere un valore su una riga all’interno della seriale.
Serial.avaiable();Restituisce 0 se la seriale non riceve dati o un valore maggiore di 0 in base al dato ricevuto. (es. if(Serial.avaiable() > 0) { //codice } )
Serial.read();Permette di leggere il dato corrente della seriale, utilizzato per valori numerici. (es. int variabile = Serial.read(); )
Serial.readString();Permette di leggere il dato corrente della seriale, utilizzato per valori stringa. (es. String variabile = Serial.readString(); )
Serial.flush(); Pulische la cache della seriale.
Serial.end();Chiude e disabilita la connessione seriale.

CAPITOLO 14. Accendere e spegnere le cose

Quando si acquista una scheda Arduino la prima cose che ci viene in mente è accendere e spegnere un led, questa operazione è già presente negli esempi di Arduino e la più conosciuta è il Blink. L’esempio Blink permette di accendere e spegnere un led, nello specifico il led L(LED_BUILTIN), facendolo appunto lampeggiare di continuo con un intervallo selezionabile grazie a una funzione di delay.

Possiamo aprire l’esempio dal menu File, successivamente Esempi, poi Basics e infine Blink :

Il codice dell’esempio è questo :

La prima cosa che dobbiamo ricordare che prima di comandare un pin di Arduino, questo deve essere impostato come pin di uscita (OUTPUT) o pin di ingresso (INPUT) e questa configurazione va fatta nella funzione setup(). Per impostare un pin o come uscita o come ingresso possiamo avvalerci della funzione pinMode() :

pinMode(pin_da_inizializzare,parametro);

Nel caso dell’esempio aperto poc’anzi possiamo notare che nella funzione setup() troviamo la seguente istruzione :

pinMode(LED_BUILTIN,OUTPUT); 

LED_BUILTIN contiene il numero del pin da comandare al quale è collegato il pin L, il quale viene assegnato a questa costante in base alla scheda Arduino che stiamo utilizzando. Su un Arduino UNO, per esempio, il pin equivalente al led L è il pin 13, mentre il pin equivalente al led L presente sulla tua MKR è il pin 6 e grazie a questa costante potremmo creare dei programmi compatibili con vari modelli di scheda e nel caso in cui dovessimo comandare il led L, non dovremmo preoccuparci sue quale pin andare ad agire per accenderlo e spegnerlo.

Il paramento dopo la virgola imposta il pin, che nel nostro caso è il pin 6, come uscita con OUTPUT.

Nel loop() troviamo una nuova istruzione che ci permetterà di accendere e spegnere un pin digitale :

digitalWrite(pin_da_comandare,parametro);

La funzione digitalWrite() permette per l’appunto di comandare un pin, scrivendo il suo stato. Per impostare uno stato ad un pin possiamo avvalerci di due costanti e cioè di HIGH(acceso) e LOW(spento) difatti i due valori equivalgono rispettivamente a 1 e 0.

Nel nostro caso comandiamo il led L e cioè con LED_BUILTIN e quindi lo accenderemo con :

digitalWrite(LED_BUILIN,HIGH);

aspettando 1 secondo con delay(1000) e spegnendolo con :

digitalWrite(LED_BUILIN,LOW);

E usando la nostra MRK WiFi 1010 sarà l’equivalente di scrivere le seguenti istruzioni :

digitalWrite(6,1); //accende il pin 6
delay(1000); //aspetto 1 secondo
digitalWrite(6,0); //spegne il pin 6
delay(1000); //aspetto 1 secondo

Bene, carichiamo il codice sulla nostra schedina e osserviamo il risultato :

Sul pin 6 potremmo collegare un led come mostrato in questo schema o addirittura un relè :

CAPITOLO 15. Comandare i pin PWM

Sulla tua scheda MKR quasi tutti i pin sono PWM, nonostante che siano indicati solo i pin 2, 3, 4 e 5 con il simbolo (~).

I pin PWM sono pin che possono essere gestiti sia con la funzione digitalWrite() che con una nuova funzione, mai trattata fino ad adesso e ciè la funzione analogWrite(). La struttura di entrambi le funzioni è la stessa, tuttavia invece di usare le costanti LOW e HIGH, nella funzione analogWrite() si utilizzano dei numeri da 0 a 255. Tale caratteristica permette quindi di variare la tensione sul pin scelto e di conseguenza, per esempio, aumentare e diminuire la luminosità di un led.

La struttura del codice è la seguente :

analogWrite(pin_da_comandare,0~255);

Per farvi un esempio abbiamo scritto un piccolo programmino che fa lampeggiare il led sulla scheda in modo graduale, creando un effetto chiamato “fade” :

Il risultato è il seguente :

CAPITOLO 16. Leggere un valore da un pin : Il primo progetto con un fotoresitore!

Adesso che abbiamo imparato a controllare i pin è ora di mettere mano un pochino a qualche componente e provare a leggere dai pin e utilizzeremo un fotoresistore per controllare la densità di luce all’interno della stanza. Per prima cosa realizziamo un circuito del genere, utilizzando i seguenti componenti :

  1. x1 fotoresistore : Link Amazon
  2. x1 resistore da 10k : Cosa sono e come funzionano i resistori ? e Link Amazon
  3. x3 cavetti dupon per collegare i vari componenti tra di loro : Link Amazon
  4. x1 breadboard : Link Amazon

E potete collegare il tutto seguendo queso semplice schema :

Adesso introdurremo una nuova funzione che viene usata per leggere un valore da un pin analogico o PWM e cioè analogRead(). analogRead() richiede un solo parametro e cioè il numero del pin da leggere :

analogRead(numero_pin_da_leggere);

Nel nostro caso il pin da controllare è A0 (pin analogico 0) e quindi andrà scritto in questo modo :

analogRead(A0);

E’ interessante sapere che potremmo inserire il valore letto dal pin direttamente dentro una variabile numerica :

int valorePin = analogRead(A0);

Procediamo con il codice…

E’ importante ricordare che i pin Analogici non necessitano di inizializzazione (es. pinMode(A0,INPUT); ) nel setup(), poichè per loro natura sono tutti in ingresso.

Per il nostro progetto andremo a riempire una variabile con il valore che arriverà dal fotoresistore collegato sul pin A0 e infine scriveremo il valore all’interno della seriale, qui di seguito un esempio di codice che potrete modificare a piacimento :

Possiamo a questo punto caricare il codice e aprire il Monitor Seriale per osservare il comportamento del sensore :

Se sul sensore impatta più luce possibile questo dovrà restituire un valore che si aggira a circa 1024, se mettiamo la mano sul sensore e quindi facciamo ombra su di esso il valore dovrebbe scendere :

A questo punto creiamo un’applicazione pratica e andiamo ad aggiungere un costrutto decisionale if che controlla il valore misurato, nel caso in cui quest’ultimo scenda sotto i 600 accende un led, magari quello sul pin 6 :

Adesso caricate il codice e controllate se tutto funziona accendendo e spegnendo la luce della stanza, ovviamente il sensore deve stare al buio per funzionare, quindi magari possibilmente fatelo con porte e finestre chiuse 🤣🤣🤣

E’ inutile dire che se al posto del led si collega un relè, potremmo creare per esempio un piccolo sensore crepuscolare per accendere una luce in giardino 😍

A tal proposito guarda questo prodotto interessante.

Se avete problemi a far accendere il led vi basterà modificare il valore minimo da controllare nell’if in base alle vostre esigenze!

CAPITOLO 17. Le librerie e i file aggiuntivi

Arduino è un prodotto espandibile e a tal proposito esistono sensori di qualsiasi tipo che aggiungono funzionalità alla scheda, per usare queste espansioni per la nostra scheda quest’ultima ha bisogno della librerie. Le librerie sono file aggiuntivi da includere nei nostri progetti e che servono sostanzialmente a far capire ad Arduino come funziona un determinato sensore o componente, poiché all’interno delle librerie troveremo le istruzioni giuste per il componente aggiuntivo e addirittura potrebbero aggiungere funzioni in più a quelle che abbiamo visto fino ad adesso.

Per includere una libreria è molto semplice. Se si conosce il nome della libreria ci basterà inserire a inizio codice la seguente dicitura :

#include <NomeLibreria.h>

Tutte le librerie di Arduino hanno come estensione il “.h” e sono semplicemente dei file nella cartella Librerie di Arduino che troverete nelle seguenti posizioni :

  1. Windows : C:\Users\nome_utente\Documents\Arduino\libraries
  2. MacOS : Documenti\Arduino\libraries

Ovviamente le librerie vanno scaricate e installate all’interno dell’Ide di Arduino e ci sono vari modi per farlo :

  1. Installare le librerie dal Gestore librerie di Arduino (semplice).
  2. Scaricare e installare le librerie da internet, per esempio da siti come GitHUB. (meno semplice)
a. Installazione libreria dal Gestore librerie

Possiamo trovare il gestore librerie nel menu Sketch dell’Ide di Arduino :

Entrati in Gestione librerie abbiamo la possibilità di cercare la libreria di nostro interesse e di installarla cliccando su installa, a tal proposito cerchiamo la libreria WiFiNINA, poiché ci servirà a breve :

Una volta installata la libreria interessata possiamo chiudere il gestore delle librerie con Chiudi

Possiamo includere la nostra nuova libreria cercandola nel menu Sketch, #include libreria :

Il programma provvederà ad aggiungere in automatico la riga per l’inclusione della libreria scelta :

La libreria WiFiNINA ci permette di sfruttare tutte le funzionalità del sensore Wi-Fi incluso sulla nostra MKR.

b. Installazione libreria da internet

Questo procedimento richiede un qualche minuto in più. Andiamo sul sito GitHUB e cerchiamo WiFiNINA :

Facciamo click sul primo risultato :

In ogni pagina di GitHUB troviamo sempre il pulsante Clone or download di colore verse e se lo clicchiamo potremmo accedere al pulsante Download ZIP :

Torniamo sull’Ide di Arduino e andiamo ad aprire il pacchetto zip appena scaricato tramite l’apposita funzione per aggiungere una libreria da un pacchetto .zip presente nel menu Sketch :

Andiamo a selezionare il file zip scaricato che presumibilmente è nella cartella Download del nostro computer :

L’ide ci confermerà la corretta aggiunta della libreria scelta con un messaggio di conferma nell’area di debug :

E come ci suggerisce, con lo stesso procedimento fatto precedentemente, potremmo aggiungere la libreria scegliendola dal menu Sketch.

Come noterete, nel menu Sketch->#include libreria ci sono anche delle librerie già installate di default e che fanno del gruppo librerie sviluppato da Arduino (non tutte).

Oltre alle librerie è possibile includere nel nostro progetto altri file contenenti parti del programma, questo permette di lavorare a un grande progetto organizzando il tutto in più file in modo tale da semplificarne lo sviluppo.

Per aggiungere un file al progetto possiamo farlo sempre dal menu Sketch :

Nell’aggiunta dei file è importante ricordarsi che questi devono essere presenti o nella cartella delle librerie di Arduino o nella stessa cartella contenente il progetto a cui stiamo lavorando. L’utilità dei file è pressoché identica a quella delle librerie con la sola differenza che per realizzare una Libreria ci vorrà molta esperienza nel settore, mentre per i file possiamo usarli per semplificarci il lavoro e scrivere lo stesso programma in più sezioni.

CAPITOLO 18. Led RGB

Sulla nostra scheda MKR WiFi 1010 è disponibile un led RGB (led a tre colori) che può essere controllato a nostro piacimento. Il led RGB fa parte del sensore WiFi e quindi per funzionare ha bisogno della libreria WiFiNINA, quest’ultima è incaricata di dire alla scheda come funziona il sensore WiFi e ci permette di gestirlo e utilizzarlo.

Per usare il led RGB, quindi, dovremo includere la libreria WiFiNINA e includere un ulteriore file “wifi_drv.h” :

A questo punto nel nostro progetto, oltre ad aver incluso il supporto per il WiFi, abbiamo aggiunto delle nuove funzioni per controllare il led, poiché il classici analogWrite() e digitalWrite() non basteranno. Infatti è possibile gestire il tutto con il WiFiDrv che come possiamo notare qui sotto si applica alle funzioni base del controllo dei pin che abbiamo già visto in precedenza :

I pin 25, 26 e 27 possono essere utilizzati soltanto per controllare il led e sono integrati nella scheda.

Successivamente, come abbiamo fatto in precedenza con il led L, possiamo usare degli analogWrite() per regolare la luminosità di ogni singolo led impostato e impostando 0 per spegnerli :

Nel caso mostrato si accederà solo il led rosso.

Utilizzando questo sito potete provare a miscelare i vari led insieme per ottenere nuovi colori :

Per esempio il colore viola ha i valori 255 (R), 51 (G) e 204 (B) e potremo impostarli ai led in questo modo :

E infatti, caricando il codice… 😍

Potremmo usare il led RGB per segnalare un problema, magari diventando rosso o ancora, facendolo diventare verde per informarci quando la scheda è connessa a internet, fa sempre comodo avere un responso visivo in assenza di un display e ogni colore può indicare uno stato specifico del programma!

Senza contare che il led RGB non occupa i pin della scheda, poiché è saldato su di essa e quindi avremo spazio per altre cose. 😍

CAPITOLO 19. Collegare la scheda al Wi-Fi

Una cosa interessante della MKR WiFi 1010 è senza ombra di dubbio la possibilità di collegarla alla nostra rete domestica tramite WiFi, questo ci permette di accedere alla scheda se siamo collegati alla stessa rete, quindi non da remoto o come vedremo in seguito anche da remoto usando servizi esterni! Per collegare la nostra scheda alla rete Wi-Fi includiamo la libreria SPI e WiFiNINA :

#include <SPI.h>
#include <WiFiNINA.h>

Successivamente creiamo due variabili char che conterranno rispettivamente il nome della nostra connessione WiFi e la password :

char nome_connessione[] = "TP-LINK_BDE0";
char password_connessione[] = "65402078";

Create successivamente una variabile che conterrà lo stato della connessione :

int stato_connessione;

Nel setup(), invece, inizializziamo una connessione seriale con :

Serial.begin(9600);

E poi controlliamo e se il modulo WiFi è pronto con un if :

if (WiFi.status() == WL_NO_MODULE) {
Serial.println("Inizializzazione WiFi fallita!");
while (true);
}

Poi attendete la connessione alla rete affinchè non avviene con un ciclo WHILE :

while (stato_connessione != WL_CONNECTED) {
Serial.print("Connessione a :");
Serial.println(nome_connessione);
int stato_connessione = WiFi.begin(nome_connessione, password_connessione);
delay(10000);
}

Infine, scriviamo nella seriale l’indirizzo IP della nostra scheda con :

Serial.print("IP Scheda :");
Serial.println(WiFi.localIP());

Avrete cosi scritto il codice in questo modo :

Successivamente possiamo caricare il nostro sketch nella scheda e subito dopo aver ricevuto la conferma del caricamento completato possiamo accedere al Monitor Seriale per verificare la corretta connessione con il router :

Se vi viene mostrato l’indirizzo IP univoco che il router/modem assegna alla vostra scheda, che nel nostro caso è 192.168.0.101 (il vostro sarà sicuramente diverso), vuol dire che la scheda è connessa al vostro router e che tecnicamente è raggiungibile dalla rete!

In aggiornamento…

Manuale in aggiornamento… Passa più tardi per leggere nuovi capitoli!

VIDEO LEZIONI (LINGUAGGIO DI PROGRAMMAZIONE)

IN SINTESI

Valutazione della redazioneCPU e RAMConnettivitàAdatto ai neofitiShield aggiuntiveI2CNumero I/0
★★★★★
Dispositivo ottimo
SAMD21 Cortex-M0+Si, Wi-Fiè Perfetta per i neofiti e ha tutto quello che serve per iniziareSiSi22

Condividi questo articolo :

Redazione Filo Connesso

Redazione Filo Connesso

Siamo un gruppo di ragazzi appassionati di Informatica, elettronica e robotica. Abbiamo creato Filo Connesso per offrire materiale educativo e informativo dedicato ai nostri settori di interesse.

Potrebbero interessarti anche...

Lascia un commento

Il tuo indirizzo email non sarà pubblicato. I campi obbligatori sono contrassegnati *