Corso base su arduino Seconda parte

Transcript

1 Corso base su arduino Seconda parte Gli ingressi digitali Gli stessi piedini utilizzati come uscite digitali possono essere impiegati come ingressi digitali. I livelli logici sono ancora di tipo TTL (livello basso = 0V, livello alto = 5V). Cosa si può collegare a tali ingressi? Il caso più frequente consiste nella lettura dello stato di uno o più pulsanti, ma trovano applicazione anche nella lettura di un fotoaccoppiatore, di un sensore ad effetto Hall (di tipo ON-OFF), di un tastierino numerico, di un segnale impulsivo ad onda rettangolare, dello stato di un sensore PIR, di sensori con uscita digitale, ecc In questa sede tratterò l esempio classico della gestione di un singolo pulsante normalmente aperto. Innanzitutto, come si collega un pulsante alla scheda arduino? Ci sono due modalità possibili: attivo alto quando premo il pulsante mando alla scheda un livello alto, quando lo rilascio alla scheda arriva un livello basso; attivo basso il contrario del caso precedente, premo il pulsante e mando un livello basso. Gli schemi di collegamento sono riportati nella figura seguente Nella parte superiore vediamo un pulsante attivo basso, nelle posizioni aperto (sinistra) e chiuso (destra). Nella parte inferiore notiamo lo schema di collegamento di un pulsante attivo alto. La freccia centrale di tutte e 4 le immagini va collegata ad un piedino di ingresso digitale di arduino, la 1

2 freccia superiore va al terminale 5V e la massa al terminale GND. Il valore consigliato delle resistenze è di 10 KΩ. Nota: le porte di arduino hanno già al loro interno delle resistenze di pullup che si possono attivare nel modo seguente: nella funzione setup() si definisce il piedino come ingresso con l istruzione pinmode(numero_del_piedino, INPUT_PULLUP); Per definire un piedino come ingresso digitale, è necessario inserire nella funzione setup() l istruzione pinmode(numero_del_piedino, INPUT); dove numero_del_piedino può essere una costante da 0 a 13 o una variabile con lo stesso campo di valori. Una volta definito un piedino come ingresso, per leggere lo stato dell ingresso digitale si utilizza la funzione digitalread(numero_del_piedino) che può ritornare solo due valori: HIGH (è stato rilevato un livello alto) oppure LOW (è stato rilevato un livello basso). Per chiarire quanto esposto, vediamo come scrivere un programma che legge lo stato di un pulsante attivo alto e, se questo è premuto, accende il LED L della scheda arduino Uno. Supponiamo di collegare il pulsante al piedino 7 come nello schema di cablaggio seguente: Il programma che accende il LED L può essere: 2

3 #define LED 13 #define PULSANTE 7 LED sul piedino 13 (interno alla scheda) Piedino a cui è collegato il pulsante int val = 0; variabile dove salvo lo stato del pulsante void setup(){ pinmode(led, OUTPUT); Piedino 13 come uscita digitale pinmode(pulsante, INPUT); Piedino 7 come ingresso digitale void loop(){ per sempre val = digitalread(pulsante); salvo in val lo stato del pulsante if (val == HIGH) se lo stato del pulsante è alto digitalwrite(led, HIGH); accendo il LED else digitalwrite(led, LOW); altrimenti spengo il LED Modi alternativi per dichiarare LED e PULSANTE: const int LED = 13; const int PULSANTE = 7; oppure: int LED = 13; int PULSANTE = 7; Programma in forma più compatta: #define LED 13 #define PULSANTE 7 LED sul piedino 13 (interno alla scheda) Piedino a cui è collegato il pulsante void setup(){ pinmode(led, OUTPUT); Piedino 13 come uscita digitale pinmode(pulsante, INPUT); Piedino 7 come ingresso digitale void loop(){ per sempre if (digitalread(pulsante) == HIGH) se lo stato del pulsante è alto digitalwrite(led, HIGH); accendo il LED else digitalwrite(led, LOW); altrimenti spengo il LED Proponiamoci ora di modificare il programma in questo modo: vogliamo che ad ogni pressione del pulsante il LED cambi stato. Premo una volta e il LED si accende, premo un altra volta e il LED si spegne, e così via Non dovrebbe essere così difficile, basta introdurre un ulteriore variabile che memorizzi lo stato del pulsante in questo modo: ogni volta che premo il pulsante la variabile cambia valore da 0 a 1 e viceversa. Poi, se questa variabile vale 0, spengo il LED, se vale 1, lo accendo. 3

4 #define LED 13 #define PULSANTE 7 LED sul piedino 13 (interno alla scheda) Piedino a cui è collegato il pulsante int val = 0; variabile dove memorizzo il livello logico letto dal pulsante variabile dove salvo lo stato del pulsante int stato = 0; void setup(){ pinmode(led, OUTPUT); Piedino 13 come uscita digitale pinmode(pulsante, INPUT); Piedino 7 come ingresso digitale void loop(){ per sempre val = digitalread(pulsante); leggo il livello logico del pulsante if (val == HIGH) se il pulsante è premuto stato = 1 stato; cambio stato if (stato == 1) digitalwrite(led, HIGH); accendo il LED else digitalwrite(led, LOW); altrimenti spengo il LED Il programma appena visto non funziona nel modo previsto ed il comportamento del LED è imprevedibile. Ciò è dovuto, come molti già sapranno, al fatto che le istruzioni contenute nella funzione loop() vengono eseguite in tempi molto più rapidi rispetto ai normali riflessi di una persona e al rimbalzo dei contatti del pulsante Ogni volta che premo o rilascio il pulsante genero un treno di impulsi che complessivamente ha una durata di qualche millisecondo. L immagine, trovata in rete ( si riferisce ad un pulsante attivo alto, ma il fenomeno è lo stesso nel caso di un pulsante attivo basso. Esistono molte tecniche per rimediare a questo problema, sia hardware (uso di reti RC, porte logiche trigger di schmitt) che software. Esiste addirittura una libreria di arduino, denominata Bounce (rimbalzo). Vediamo allora una possibile soluzione di tipo software. Introdurremo una nuova variabile (vecchio_valore) dove verrà memorizzato il valore letto dal pulsante in precedenza e aggiungeremo un po di ritardo nel punto opportuno del programma. #define LED 13 #define PULSANTE 7 LED sul piedino 13 (interno alla scheda) Piedino a cui è collegato il pulsante int val = 0; variabile dove memorizzo il livello logico letto dal pulsante int vecchio_valore = 0; int stato = 0; variabile dove salvo lo stato del pulsante void setup(){ 4

5 pinmode(led, OUTPUT); Piedino 13 come uscita digitale pinmode(pulsante, INPUT); Piedino 7 come ingresso digitale void loop(){ per sempre val = digitalread(pulsante); leggo il livello logico del pulsante if ((val == HIGH) && (vecchio_valore == LOW)) { transizione avvenuta stato = 1 stato; cambio stato delay(100); attendi 100 millisecondi (sperimentale) vecchio_valore = val; memorizzo l ultimo valore letto dal pulsante if (stato == 1) digitalwrite(led, HIGH); accendo il LED else digitalwrite(led, LOW); altrimenti spengo il LED Il monitor seriale di arduino In precedenza abbiamo visto che cos è e come si attiva dalla IDE il monitor seriale. Ecco come si presenta: Sul bordo superiore della finestra viene riportata la porta seriale a cui è collegato arduino (la schermata è relativa ad un sistema operativo linux, su Windows viene riportata la porta COMx). Appena sotto c è un area di testo in cui si possono inserire dei caratteri da inviare alla scheda arduino qualora si premesse il pulsante invia. Proseguendo verso il basso, troviamo un area più ampia dove appariranno i caratteri inviati da arduino verso il PC. Sul bordo inferiore, la zona più importante è costituita dal menù a scomparsa posto sul lato destro e recante la scritta 9600 baud. Quest ultima rappresenta la velocità (baud = bit/secondo, perché la comunicazione è a soli due livelli 0 e 1) con cui il PC e la scheda arduino si scambiano i dati. A cosa può servire? 5

6 Rappresenta l equivalente di printf / scanf o cin /cout, pertanto può servire per visualizzare stringhe di caratteri, valori di variabili oppure inviare caratteri che il programma residente su arduino potrà interpretare come comandi. Il canale attraverso cui viaggiano i dati è costituito dalla porta seriale presente nel microcontrollore che comunica col PC tramite il cavo USB. Come si fa a stampare qualcosa? Come prima cosa, occorre inserire la seguente chiamata di funzione all interno della funzione setup(): Serial.begin(9600); Questa ha lo scopo di inizializzare il serial monitor e impostare la velocità di comunicazione (in questo caso a 9600 baud). La velocità deve essere uguale a quella impostata nella finestra del serial monitor. Per i C++isti: si fa riferimento ad un istanza della classe Serial e begin rappresenta l invocazione di un metodo di tale classe. Poi, quando vogliamo visualizzare qualcosa sul serial monitor, all interno del nostro programma inseriamo la chiamata alla funzione Serial.print oppure alla funzione Serial.println (si scrive print elle enne). Ad esempio, se vogliamo stampare una stringa costante di caratteri, possiamo scrivere: Serial.print( Maramao ); Serial.println( Cacao ); viene visualizzato Maramao viene visualizzato Cacao e va a capo della riga successiva Se vogliamo stampare il valore di una variabile: int cubetti_di_porfido = 17; Serial.print(cubetti_di porfido); viene visualizzato 17 La differenza tra Serial.print e Serial.println è che la seconda, dopo aver stampato, va a capo della riga successiva. Queste due funzioni (print e println) consentono di specificare un secondo parametro opzionale che rappresenta il formato e può essere: BIN (base binaria), DEC (base 10), OCT (base 8), HEX (base 16). Esempi: Serial.print(78, BIN) visualizza Serial.print(78, OCT) visualizza 116 Serial.print(78, DEC) visualizza 78 Serial.print(78, HEX) visualizza 4E Nel caso di numeri o variabili float, il secondo parametro è una cifra che rappresenta il numero di decimali da visualizzare (per arrotondamento). Esempi: Serial.println( , 0) visualizza 1 Serial.println( , 2) visualizza 1.23 Serial.println( , 4) visualizza Notare l ultima cifra! Vediamo un esempio di programma che fa uso di queste funzioni per visualizzare un conteggio da 0 in poi. 6

7 int number = 0; il numero di partenza void setup() { Serial.begin(9600); imposto la velocità di comunicazione in baud void loop(){ Serial.print( Numero = ); Serial.println(number); delay(1000); number++; Scrive Numero = scrive il valore della variabile e va a capo pausa di 1 secondo incrementa la variabile ripete dall inizio di loop() Dal monitor seriale è possibile anche inviare caratteri al programma che risiede nella scheda. In base al carattere inviato, si potranno poi prendere diverse decisioni. Il singolo carattere da inviare va scritto sulla riga di testo superiore, a sinistra del pulsante invia, che va poi premuto. Cosa succede se scrivo una stringa di più caratteri? Viene letto solo il primo carattere. C è modo di inviare una stringa di più caratteri? Sì, mediante Serial.readString(), ma esula dal presente corso. Nel programma su arduino, prima di poter leggere il carattere inviato, occorre accertarsi che la porta seriale abbia ricevuto dei caratteri e a tale scopo si invoca la funzione Serial.available() che ritorna il numero di caratteri presenti nel buffer della seriale. Una volta stabilito che la seriale ha ricevuto dei caratteri, la funzione che ci permette di leggere il primo carattere inviato è Serial.read(). Per chiarire quanto esposto, vediamo un esempio di programma che legge un carattere dal monitor seriale, se il carattere è 1, accende il LED sul piedino 13 (L) e visualizza sul monitor seriale la scritta LED acceso, se il carattere è 2, spegne il LED L e visualizza sul monitor seriale la scritta LED spento. Un carattere diverso da 1 o 2 comporterà la visualizzazione della scritta Comando ignoto: seguita dal codice ASCII del carattere stesso. int LED = 13; il piedino dove è collegato il LED void setup() { Serial.begin(9600); imposto la velocità di comunicazione in baud pinmode(led, OUTPUT); piedino 13 impostato come uscita digitale void loop(){ if (Serial.available()>0) { se la seriale ha ricevuto caratteri int comando = Serial.read(); leggo primo carattere if (comando == 1 ) { se è stato ricevuto il carattere 1 digitalwrite(led, HIGH); accende il LED L Serial.println( LED acceso ); stampa stringa e va a capo else if (comando == 2 ) { è stato ricevuto il car. 2 digitalwrite(led, LOW); spegne il LED Serial.println( LED spento ); else { nessuno dei due Serial.print( Comando ignoto: ); Serial.println(comando); stampa carattere non riconosciuto 7

8 fine if (Serial.available().... fine loop() Il display alfanumerico LCD Il monitor seriale risulta molto comodo nella fase di stesura del programma, ma richiede la presenza del PC collegato alla scheda arduino tramite cavo USB. Nelle applicazioni comuni della scheda arduino, il PC è inutile, ingombrante e dispensioso. Come fare allora per visualizzare informazioni numeriche o testuali? Pensate ad un distributore di bevande o di merendine, ad un termostato per caldaia, alla lavatrice, ecc, le informazioni vengono visualizzate su display alfanumerici o grafici a cristalli liquidi (LCD) di piccole dimensioni. Limitandoci ai display LCD alfanumerici, i più comuni visualizzano 2 o 4 righe di 16, 20 o più caratteri e sono dotati, in gran parte, di un interfaccia standard. Normalmente, la gestione di questi display non è semplice, ma arduino dispone di una libreria di funzioni che rende tutto più facile. Prima di trattare l aspetto software però, vediamo come si interfaccia un display 16 x 2 (due righe da 16 caratteri, compatibile HD44780) dal punto di vista dei segnali elettrici. l display retroilluminati hanno normalmente 16 piedini e di solito è presente un riferimento scritto che indica qual è il primo, l ultimo, oppure entrambi. Il piedino 1 va collegato a massa (GND di arduino) e il 2 a +5 V. Il terzo piedino serve per regolare il contrasto; va collegato al cursore di un potenziometro (10 KΩ, valore non critico) i cui terminali estremi vanno a GND e +5V. Il piedino RS (register select) serve per far capire al display, tramite un livello logico alto o basso, se gli stiamo inviando un carattere oppure un comando. Va collegato ad un uscita digitale di arduino. Il piedino R/W ci permette di leggere (livello alto) oppure scrivere (livello basso) nella memoria del 8

9 display. Usualmente si inviano caratteri per poterli visualizzare, quindi questo piedino viene posto stabilmente a livello basso (collegato a GND). Il piedino E (Enable) serve per sincronizzare la scrittura di un comando o di un carattere. In pratica, si fornisce il carattere / comando ai piedini dei dati del display e si provoca una breve variazione di livello logico, di durata predefinita, su questo piedino. In questo modo, il carattere / comando viene visualizzato / eseguito. Anche questo va collegato ad un uscita digitale di arduino. I successivi 8 piedini sono quelli che ricevono il carattere / comando in forma binaria e vanno collegati anch essi alle uscite digitali di arduino. Restano altri due piedini, utilizzati per la retroilluminazione del display. Vengono trattati come un LED pertanto, il catodo (piedino 16) va posto a GND e l anodo a +5V con in serie un resistore da 330 Ω. (Alcuni display non necessitano di resistore in serie, va consultato il datasheet). Facendo i conti, per pilotare un display di questo tipo servirebbero 10 uscite digitali della scheda arduino, un po troppe! Fortunatamente, esiste una modalità di comunicazione che sfrutta solo le 4 linee dati più significative del display (da D4 a D7), riducendo il numero di uscite digitali impegnate a 6 (RS, E, D4, D5, D6, D7). Il carattere / comando viene spezzato in due gruppi di 4 bit ciascuno e inviato in due scritture successive. Volendo ridurre ulteriormente il numero di uscite impegnate, si deve ricorrere a display con interfaccia su bus i2c, che costano qualcosina di più ma comunicano mediante 2 soli piedini (clock e dati, SCL e SDA). Ecco un esempio grafico di come va effettuato il collegamento tra la scheda arduino Uno ed un display LCD: In questo esempio, che non è vincolante come vedremo, RS è collegato al piedino 12 di arduino, E al piedino 11, D4, D5, D6, D7 rispettivamente ai piedini 5, 4, 3, 2. Notate la presenza del trimmer per la regolazione del contrasto, della resistenza in serie all anodo della retroilluminazione e il segnale R/W posto a massa (display sempre in scrittura). 9

10 Gestione software del display, la libreria LiquidCrystal Gestire un display LCD alfanumerico partendo da zero non è per niente semplice. La cosa diventa praticabile se ci si appoggia all apposita libreria già presente nel software di arduino. Innanzitutto, bisogna includere la libreria con l istruzione #include <LiquidCrystal.h> attenzione alle maiuscole e minuscole! La libreria ci mette a disposizione diverse funzioni (metodi C++), ma prima bisogna dichiarare un oggetto di tipo LiquidCrystal che di solito assume il nome di lcd e indicare a quali piedini di arduino sono collegati i segnali del display. La modalità d uso più comune è la seguente: LiquidCrystal lcd(rs, enable, d4, d5, d6, d7); dove, al posto dei termini dentro alle parentesi, vanno scritti i numeri dei piedini. Esempio che coincide con lo schema di cablaggio riportato in precedenza: LiquidCrystal lcd(12,11, 5, 4, 3, 2); Possiamo anche utilizzare altri piedini digitali al posto di quelli indicati, basta cambiare il cablaggio tra display e scheda arduino. Esistono altre modalità per dichiarare il display che prevedono di includere il piedino R/W e / o tutti e 8 i segnali dati (da D0 a D7), ma quella riportata è la più usata perché spreca meno piedini. Creato l oggetto lcd, nella funzione setup() bisogna inizializzare il display e specificare il numero di colonne e di righe dello stesso: lcd.begin(16,2); Inizializzo un display che si chiama lcd, con 16 colonne e 2 righe di caratteri A questo punto, abbiamo a disposizione le seguenti funzioni (metodi): lcd.clear(); Cancella lo schermo e posiziona il cursore sul primo carattere della prima riga lcd.home(); Non cancella, posiziona solo il cursore sul primo carattere della prima riga lcd.setcursor(colonna, riga); /* posiziona il cursore su colonna e riga indicate (possono essere numeri o variabili). La numerazione parte da 0 in entrambi i casi, quindi nel display in figura le colonne vanno da 0 a 15 e le righe da 0 a 1. Le successive scritture partiranno da tale posizione.*/ lcd.print (dato); dato può essere char, byte, int, float, stringa di caratteri Esempi: lcd.print( Mammalucco ); visualizza la stringa Mammalucco a partire dalla posizione del cursore float temp = 12.1; lcd.print(temp); visualizza il valore 12.1 assegnato alla variabile temp int i = 123; lcd.print(i); visualizza il valore 123 assegnato alla variabile i lcd.print(i, BIN); visualizza , cioè il valore di i in binario 10

11 lcd.print(i,hex); visualizza 7B, cioè il valore di i in esadecimale lcd.write(dato); visualizza il carattere (uno solo) assegnato a dato lcd.cursor() ; mostra il cursore (normalmente non si vede) lcd.nocursor(); nasconde il cursore lcd.blink(); fa lampeggiare il cursore (solo il cursore, non il testo!) lcd.noblink(); cursore fisso, non lampeggiante lcd.display(); mostra il contenuto del display lcd.nodisplay(); nasconde il testo nel display, assieme si possono usare per far lampeggiare il testo presente sul display lcd.scrolldisplayleft(); sposta il testo di un carattere verso sinistra lcd.scrolldisplayright(); sposta il testo di un carattere verso destra Inserite in un ciclo possono spostare il testo di un certo numero di caratteri a sinistra o a destra. lcd.autoscroll(); ogni volta che viene scritto un carattere, sposta il testo che lo precede di un carattere verso sinistra lcd.noautoscroll(); cessa l autoscroll lcd.createchar(num,data); permette di creare fino a 8 simboli personalizzati. Vedere documentazione su internet. Quello che segue è un piccolo programma dimostrativo di alcune delle funzionalità della libreria LiquidCrystal. Programma dimostrativo delle funzionalità della libreria LiquidCrystal A. Visentini Display 16x2 HD44780 compatibile collegato: pin 1 GND, pin 2 5V, pin 3 contrasto trimmer 10k, pin 4 Register Select a pin 12 arduino pin 5 Read/Write a GND pin 6 Enable a pin 11 arduino pin 11 DB4 a pin 5 arduino pin 12 DB5 a pin 4 arduino pin 13 DB6 a pin 3 arduino pin 14 DB7 a pin 2 arduino pin 15 Backlight anodo a +5V con in serie 330 ohm pin 16 Backlight catodo a GND #include <LiquidCrystal.h> LiquidCrystal lcd(12, 11, 5, 4, 3, 2); RS, E, D4, D5, D6, D7 int i; void setup() { lcd.begin(16, 2); 11 display 16 colonne 2 righe

12 void loop() { lcd.clear(); pulisce il display lcd.print("dimostrazione"); lcd.setcursor(0,1); riga inferiore delay(500); lcd.print("della libreria"); delay(1500); lcd.clear(); lcd.print("liquidcrystal"); delay(1000); for (i = 0; i < 13; i++) { lcd.scrolldisplayleft(); delay(200); for (i = 0; i < 13; i++) { lcd.scrolldisplayright(); delay(200); for (i = 0; i < 10; i++) { lcd.nodisplay(); delay(200); lcd.display(); delay(200); lcd.clear(); lcd.print("variabile = "); for ( i = 0; i < 10; i++){ lcd.setcursor(13, 0); lcd.print(i); delay(1000); Gli esempi svolti in classe e le esperienze di laboratorio proposte agli studenti La parte teorica della gestione dei pulsanti è quella riportata all inizio di questa dispensa. Per la parte laboratoriale, propongo le seguenti esperienze: Collegare 4 LED ed un pulsante alla scheda arduino e fare in modo che ad ogni pressione del pulsante si accenda un LED in sequenza. Ad esempio, numerando i LED da 1 a 4 e partendo con tutti i LED spenti, premo il pulsante e si accende il LED 1, premo ancora e si accende il LED 2 e così via fino al LED 4, poi si ricomincia dal LED 1. Naturalmente occorre inserire nel codice la tecnica antirimbalzo. Collegare alla scheda arduino un display a 7 segmenti ed un pulsante. Ad ogni pressione del pulsante la cifra visualizzata deve incrementarsi di una unità. La cifra deve partire da 0 ed arrivare a 9, per poi ripartire da 0. Come la precedente, ma con due pulsanti; col primo incremento il conteggio fino al massimo di 9, col secondo lo decremento fino al minimo di 0. Un po come i tasti per il controllo del volume di certe autoradio o lettori mp3. Interfacciamento di un sensore PIR (sensibile al calore umano) con arduino. Quando il sensore rileva una presenza si accende un LED e resta acceso per alcuni secondi anche dopo che il soggetto si è allontanato dal sensore. 12

13 Le esperienze che si possono realizzare col display LCD sono, a questo punto del programma svolto, le seguenti: Visualizzare un conteggio. Controllare attentamente i collegamenti perché il display è delicato e non sopporta inversioni di tensione. Far lampeggiare una scritta. In seguito, dopo aver spiegato il funzionamento degli ingressi analogici e del sensore ad ultrasuoni, le possibilità d uso del display LCD si ampliano notevolmente. Materiale extra: porta seriale virtuale per arduino Abbiamo visto che la porta seriale di arduino, che fa capo ai piedini digitali 0 e 1, viene utilizzata per trasferire i programmi dal PC alla scheda e per il monitor seriale. A volte è necessario utilizzarla per interfacciare altri dispositivi seriali (moduli GPS, moduli Bluetooth, moduli mp3, ecc ); in tal caso, la procedura da seguire prevede prima di inviare il programma alla scheda e poi,tolta l alimentazione, collegare il dispositivo seriale ai piedini 0 e 1. Converrete che la tecnica risulta oltremodo scomoda. Fortunatamente, la IDE di arduino ha già al suo interno una libreria che permette di emulare una porta seriale su qualsiasi coppia di piedini digitali. Tale libreria, denominata SoftwareSerial, non raggiunge le prestazioni della seriale hardware del microcontrollore, ma è utilizzabile senza problemi fino a 9600 baud e oltre. La SoftwareSerial mette a nostra disposizione le stesse funzioni (metodi) della seriale standard, pertanto possiamo utilizzarla per inviare e ricevere caratteri, stringhe, numeri interi e float. Come si usa? Prima di tutto, bisogna includere la libreria nel nostro programma con: #include <SoftwareSerial> Poi bisogna definire una coppia di piedini da utilizzare per la ricezione e per la trasmissione dei dati, ad esempio: int rxpin = 3; int txpin = 2; A questo punto, creare un oggetto di tipo SoftwareSerial al quale possiamo attribuire un nome valido di identificatore, ad esempio: SoftwareSerial la_mia_porta_seriale(rxpin, txpin); Nella funzione setup(), inserire l inizializzazione della porta con i parametri di trasmissione: la_mia_porta_seriale.begin(9600); 9600 baud 8N1 (8bit, no parità, 1 bit di stop) Ora è possibile utilizzarla con le stesse funzioni della seriale standard, avendo cura di sostituire la parola Serial con l identificatore che abbiamo scelto. Nel nostro esempio: 13

14 la_mia_porta_seriale.print( Bella giornata ); if (la_mia_porta_seriale.available()) la_mia_porta_seriale.read(); eccetera Materiale extra: Arduino e Bluetooth In commercio sono reperibili, a costi contenuti, dei moduli che permettono ad una scheda arduino di comunicare tramite protocollo Bluetooth 2.0. A dire il vero, sono apparsi ultimamente anche moduli BLE (Bluetooth Low Energy) a basso consumo, ma il loro costo e la difficoltà di gestione li rende, al momento, poco interessanti. I moduli a cui faccio riferimento sono gli HC-05 e HC-06; il primo costa 8-9 euro (Amazon) e dispone di maggiori funzionalità (può operare sia come master che come slave, tra l altro), il secondo costa intorno agli 8 euro (Amazon, molto meno su ebay, Ali express, Banggood, ecc ) e opera solo come slave. Nella maggior parte delle applicazioni è sufficiente lo HC-06. Entrambi comunicano con arduino mediante protocollo seriale, vengono alimentati a 5 V con un assorbimento di circa 20 ma, dispongono di un LED che fa vedere se sono accoppiati con un dispositivo Bluetooth (tablet, smartphone, PC) ed hanno un range di una decina di metri. Come si interfacciano? Con 4 terminali: Vcc, GND, TX, RX (HC-05 ne possiede altri 2 che non tratterò). Attenzione: i livelli logici dei piedini RX e TX del modulo Bluetooth operano con livelli logici (0V, 3,3V). Il piedino Vcc di HC va collegato al piedino 5V di arduino, il piedino GND di HC va collegato al piedino GND di arduino, il piedino TX di HC va collegato al piedino che useremo come RX di arduino (senza problemi di interfacciamento), il piedino RX di HC va collegato al piedino che useremo come TX di arduino, interponendo un partitore di tensione formato da 2 resistenze. Dal TX di arduino colleghiamo in serie una R = 1 K al piedino RX del modulo HC e da quest ultimo, una R = 2 K verso GND (vedere schema pratico più avanti). (Trasmissione di arduino alla ricezione del modulo Bluetooth e viceversa.) Esempio di utilizzo Come esempio, proposto anche ai miei studenti, vediamo come si possono comandare 4 carichi ONOFF (io ho usato 4 LED) collegati alla scheda arduino, tramite una app residente in uno smartphone o tablet android (gli iphone, ipad non vanno bene perché limitano l uso del Bluetooth. Se sapete come fare, ditemelo). Il collegamento sarà di tipo bi-direzionale, nel senso che inviando un comando tramite app accenderemo o spegneremo uno dei LED e nella app vedremo una frase inviata da arduino che ce lo confermerà. La app utilizzata si chiama Blueterm2, ma ce ne sono a bizzeffe che fanno le stesse cose. Prima di tutto, lo schema di cablaggio: 14

15 Vediamo adesso il programma, tenendo presente quanto segue: scrivendo 1 sulla tastiera della app, accenderemo il LED sul piedino 4, premendo 2 lo spegneremo, scrivendo 3 accenderemo il LED sul piedino 5, premendo 4 lo spegneremo, e così via fino a 8. Notate che è stata utilizzata la libreria SoftwareSerial, attribuendo RX al pin 3 di arduino e TX al pin 2. Il programma non è stato ottimizzato volutamente, per renderlo più comprensibile agli studenti. Prima di poterlo usare, occorre fare il pairing tra il Bluetooth dello smartphone e quello del modulo. La password del modulo è 1234 (si può cambiare). Poi, dall interno della app, è necessario connettersi con il modulo (di serie si chiamano HC-05, HC-06, i nomi si possono modificare). /* Comanda accensione 4 LED collegati ai pin 4, 5, 6 e 7 di arduino con R in serie da 330 ohm. Su terminale Bluetooth Android connesso: 1 accende led1 2 spegne led1 3 accende led2 4 spegne led2 5 accende led3 6 spegne led3 7 accende led4 8 spegne led4 Collegare pin 3 arduino a pin TX modulo Bluetooth. 15

16 Collegare pin 2 arduino a R2=1K e altro capo di R1 a RX Bluetooth. Collegare R2=2K tra RX Bluetooth e GND. Modulo Bluetooth alimentato a 5V. Provato con HC05 e HC06 */ #include <SoftwareSerial.h> includo libreria seriale virtuale int rxpin = 3; pin 3 arduino = RX seriale virtuale int txpin = 2; pin 2 arduino = TX seriale virtuale SoftwareSerial bluetooth(rxpin, txpin); associo TX e RX alla seriale virtuale che ho chiamato bluetooth char comando; variabile char che conterrà il comando ricevuto const int Led1 = 4; piedini associati ai LED const int Led2 = 5; const int Led3 = 6; const int Led4 = 7; void setup() { Serial.begin(9600); Inizializzo monitor seriale bluetooth.begin(9600); Inizializzo seriale virtuale chiamata bluetooth pinmode(led1,output); piedini con i LED come uscite digitali pinmode(led2,output); pinmode(led3,output); pinmode(led4,output); void loop(){ while(bluetooth.available()){ finchè ci sono caratteri nel buffer comando=bluetooth.read(); leggo carattere e lo assegno a comando if(!bluetooth.available()){ elaboro l ultimo carattere ricevuto switch (comando){ case '1': se comando = 1 digitalwrite(led1, HIGH); accendo LED1 bluetooth.println("led1 ON"); invio conferma alla app Serial.println("Led1 ON"); e anche al monitor seriale delay(20); piccolo ritardo comando=' '; sostituisco comando con uno non valido break; case '2': digitalwrite(led1, LOW); bluetooth.println("led1 OFF"); Serial.println("Led1 OFF"); delay(20); comando=' '; break; case '3': digitalwrite(led2, HIGH); bluetooth.println("led2 ON"); Serial.println("Led2 ON"); delay(20); comando=' '; break; case '4': digitalwrite(led2, LOW); bluetooth.println("led2 OFF"); Serial.println("Led2 OFF"); delay(20); comando=' '; break; case '5': 16

17 digitalwrite(led3, HIGH); bluetooth.println("led3 ON"); Serial.println("Led3 ON"); delay(20); comando=' '; break; case '6': digitalwrite(led3, LOW); bluetooth.println("led3 OFF"); Serial.println("Led3 OFF"); delay(20); comando=' '; break; case '7': digitalwrite(led4, HIGH); bluetooth.println("led4 ON"); Serial.println("Led4 ON"); delay(20); comando=' '; break; case '8': digitalwrite(led4, LOW); bluetooth.println("led4 OFF"); Serial.println("Led4 OFF"); delay(20); comando=' '; fine switch fine if(!bluetooth.available()) fine loop() 17