Nella Quinta Parte della Guida si Illustrerà come Leggere gli Ingressi Digitali e come Scrivere le Uscite Digitali di Arduino…
INTRO
Gli ingressi digitali, sono dei pin che ricevono delle tensioni in ingresso e le codificano come 1 logico oppure 0 logico. I livelli di tensione devono essere in un certo range per essere riconosciuti come 1 o 0 logico, per molti microcontrollori si ha uno 0 logico se la tensione è minore di 0.1*VCC mentre si ha un 1 logico se la tensione è maggiore di 0.7*VCC. Se la tensione di alimentazione è VCC=5V si ha uno 0 logico se sul pin di ingresso vi è una tensione minore uguale a 500mV mentre si ha un 1 logico se la tensione di ingresso è maggiore di 3.5V.
Per quanto riguarda le uscite digitali, esse forniscono una tensione prossima a 0V se in uscita vi è uno 0 logico mentre si ha una tensione prossima all’alimentazione (ovvero prossima a VCC, 5V se l’alimentazione è 5V) se si ha in uscita un 1 logico.
I pin digitali in realtà non sono solo ingressi o solo uscite, sono configurabili, ovvero si può decidere se sono ingressi o uscite nella parte “void setup{}” dello scratch di ARDUINO. Anche quelli che sulla scheda Arduino vengono illustrati come pin analogici possono essere configurati come pin digitali, sia come ingressi sia come uscite.
Oltre ai pin della scheda Arduino si può andare a cambiare direttamente la configurazione delle porte del microcontrollore, si possono configurare sia come ingressi che come uscite e inoltre si può sia scrivere che leggere l’intero banchi da 8 pin di porte di I/O.
LA CONFIGURAZIONI DELLE PORTE
Iniziamo ad analizzare come configurare come ingressi o uscite le porte della scheda Arduino. Di default le porte sono configurate come ingresso anche se conviene sempre dichiarare gli ingressi. Quando una porta del microcontrollore è configurata come ingresso vuol dire che essa avrà una tensione che dipende solo da quello che gli viene collegato, come ad esempio un segnale digitale proveniente da un sensore di temperatura o un pulsante. Vi sono 3 modi per configurare le porte della scheda Arduino:
#define sensore 8 //Definisco il pin 8 con il nome sensore void setup() { pinMode(sensore, INPUT); //pin chiamato sensore INGRESSO pinMode(9, OUTPUT); //pin 9 USCITA pinMode(1, INPUT); //pin 10 INGRESSO con resistenza di pull-up }
Prima di tutto si può scegliere di definire un ingresso con un determinato nome, ad esempio chiamiamo sensore il pin numero 8 con la prima linea di codice. Questa definizione si fa fuori dalla routine di “setup”. Nella routine di configurazione si va a definire il pin 8 (ovvero sensore) come ingresso, il pin 9 come uscita usando il numero del pin senza definirlo prima e infine si definisce il pin 10 sempre come ingresso ma si va a definirlo come ingresso con resistenza di pull-up.
La resistenza di pull-up è una struttura interna al microcontrollore ed è una resistenza tra la tensione di alimentazione e il pin definito come ingresso con resistenza di pull-up. Se inizializzo un pin come ingresso semplice la sa tensione senza nulla collegato non è definita, può fluttuare tra la tensione negativa e positiva. Sull’ingresso con pull-up se non vi è collegato nulla vi in ogni caso una tensione pari a quella di alimentazione. Questo serve ad esempio quando si ha un pulsante; se il pulsante non è premuto la tensione sul pin di ingresso è a livello alto grazie alla resistenza di pull-up, mentre quando il pulsante è premuto scorrerà una corrente nella resistenza di pull-up perché il pulsante la collega verso massa, quindi sul pin di ingresso vi sarà una tensione di 0V e quindi uno 0 logico. La resistenza di pull-up ha un valore tra 20 e 50 kΩ.
LA LETTURA E LA SCRITTURA DELLE PORTE DI I/O
Una volta configurate le porte di I/O si può andare a leggere gli ingressi e scrivere le uscite. Si va a leggere e si scrive un valore booleano, ovvero HIGH (1 logico) e LOW (0 logico). Le stringhe per scrivere e leggere i pin di I/O sono i seguenti:
#define LED 8 //Definisco il pin 8 con il nome LED #define sensore 10 //Definisco il pin 10 con il nome sensore int valore1 = 0; //Valore dove inserire ingresso int valore2 = 0; //Valore dove inserire ingresso void loop() { digitalWrite(LED, HIGH); //Porta a livello alto il pin 8 digitalWrite(9, LOW); //porta a livello basso il pin 9 valore1 = digitaRead(10); //Leggi il pin 10 valore2 = digitaRead(sensore); //Leggi il pin 11 }
Prima di tutto definisco il pin 8 e il pin 10 rispettivamente con il nome di LED e sensore, poi inizializzo due variabili, “valore1” e “valore2” dove inserire il valore degli ingressi. Nel ciclo di “loop” vado a scrivere il pin 8 (chiamato LED) con un valore logico 1 mentre vado a scrivere sul pin 9 un valore logico 0, quindi avrò in uscita dal pin 8 un valore pari alla tensione di alimentazione mentre sul pin 9 vi sarà una tensione pari a 0V.
Per andare a leggere gli ingressi invece si usa la routine “digitalRead” e nel primo caso inserisco in “valore1” il valore letto dal pin 19 mentre nel secondo caso vado a inserire in “valore2” il valore letto dal pin 10 chiamato sensore.
CONFIGURAZIONE, LETTURA E SCRITTURA DEI BANCHI DI PORTE I/O
Come è possibile vedere dallo schema allegato nei download Arduino UNO R3, esso dispone di un ATMEGA328 che dispone di 3 banchi di porte ovvero PORTD che ha all’interno 8 pin di I/O, PORTC che ha 7 pin di I/O e PORTD che dispone anch’esso di 8 pin di I/O.
Questi pin di I/O sono così connessi alla scheda Arduino UNO:
Abbiamo le PORTB connessi ai pin 8, 9, 10, 11, 12 e 13 con i pin PB0, PB1, PB2, PB3, PB4 e PB5 rispettivamente, tutti i pin di I/O delle PORTD da PD0 a PD7 connessi ai pin della scheda ARDUINO numerati da 0 a 7 mentre i pin da PC0 a PC5 sono connessi alle porte chiamate “analog in”. Tutti i pin non connessi alle uscite della scheda Arduino vengono usati da tale scheda per operazioni interne.
Per quanto riguarda Arduino MEGA 2560, esso dispone di molte porte di I/O e in particolare si hanno le PORTA, PORTB, PORTC, PORTD, PORTE e PORTF, ognuna da 8 pin, connesse come da schema allegato nei download alla scheda Arduino. Alcuni pin delle porte sono utilizzati nella scheda Arduino quindi non sono accessibili.
Per configurare le porte di I/O bisogna configurare i registri dell’ATMEGA e in particolare i registri prendono tre nomi seguiti dalla lettera che indica di quale banco di porte sono i registri. Si avrà:
- DDRx: Dove x può essere D, C o B per Arduino UNO oppure A, B, C, D, E o F in Arduino MEGA 2560. Questi registri selezionano se le porte sono ingressi o uscite. Se si scrive uno 0 si ha un ingresso, altrimenti una uscita se si scrive un uno logico nella posizione che rappresenta il pin. Questi registri possono essere sia letti che scritti.
- PORTx: Anche in questo caso x può essere D, C o B per Arduino UNO oppure A, B, C, D, E o F in Arduino MEGA 2560. Sono i registri per scrivere l’uscita dei pin di I/O. Questi registri possono essere sia letti che scritti.
- PINx: Anche in questo caso x può essere D, C o B per Arduino UNO oppure A, B, C, D, E o F in Arduino MEGA 2560. Questi registri servono per leggere gli ingressi e sono di solo lettura.
I registri vengono così configurati:
byte uscite = 20; //Variabile per cambiare le uscite byte ingressi = 0; //Variabile per contenere gli ingressi void setup() { DDRD = B11111111; //PORTD uscite DDRB = B00000000; //PORTB ingressi } void loop() { PORTD = B10000000; //PD7 livello alto, PD6 livello basso PORTD = uscite; //Usa la variabile uscite per scrivere PORTD ingressi = PINB; //Leggi gli ingressi da PINB (dalle PORTB) }
Prima di tutto vi saranno delle variabili per modificare le uscite oppure per contenere gli ingressi. Nel “setup” si vanno a configurare le PORTB come ingressi e le PORTD come uscite. Nel ciclo di “loop” si vanno a variare le uscite e possono essere variate sia scrivendo l’uscita in byte (con la B davanti agli 8 numeri in binario) oppure usando una variabile. Inoltre viene usata una variabile sulla quale copiare gli ingressi.
SCHEMA E CODICE DI ESEMPIO
Andiamo ora a realizzare un semplice esempio su come utilizzare gli ingressi e le uscite. Andiamo ad inizializzare due ingressi, uno con resistore di pull-up esterno e uno con resistore di pull-up interno al microcontrollore, due pulsanti per variare l’ingresso e due LED sulle due uscite.
Scriviamo un codice quindi con un ingresso, un ingresso con pull-up e due uscite che avranno lo stesso livello logico degli ingressi. In un caso usiamo un “IF…While” per controllare il LED nell’altro caso, ovvero per l’altro LED assegniamo direttamente il valore dell’ingresso all’uscita.
Il codice è il seguente:
#define ingresso 0 #define ingressoPU 1 #define LED1 2 #define LED2 3 int input=0; void setup() { pinMode(ingresso, INPUT); //pin 1 ingresso pinMode(ingressoPU, INPUT_PULLUP); //pin 2 ingresso con resistore di pull-up pinMode(LED1, OUTPUT); //pin 3 uscita per LED1 pinMode(LED2, OUTPUT); //pin 4 uscita per LED2 } void loop() { if (digitalRead(ingresso)==1) digitalWrite(LED1, HIGH); //Se ingresso a livello alto accendi LED1 else digitalWrite(LED1, LOW); //Se ingresso a livello basso spegni LED1 input = digitalRead(ingressoPU); //Leggi il valore dell'ingresso con pull-up digitalWrite(LED2, input); //Aggiorna il valore del LED2 in funzione dell'ingresso }
Prima di tutto definisco i pin con un certo nome e poi inizializzo una variabile per contenere il valore dell’ingresso. Inizializzo il pin 0 come ingresso, il 1 come ingresso con resistore di pull-up attivo, e i pin 2 e 3 come uscite. Nel loop invece vado con un IF a controllare se l’ingresso è a livello alto, se si accendo il LED1 altrimenti lo spengo. Nel secondo caso inserisco nella variabile il valore dell’ingresso e poi scrivo il LED2 con questo valore.
Lo schema è il seguente:
Connetto quindi l’alimentazione alla breadboard e connetto i 5V alla striscia rossa ovvero il positivo e GND alla striscia blu. Collego al capo del primo pulsante la massa, all’altro capo la resistenza esterna di pull-up da 1KOhm e poi sempre questo terminale lo connetto al pin 0. Per l’altro pulsante invece basta collegare un capo alla massa e l’altro al pin 1 che funge da ingresso visto che la resistenza di pull-up attiva è interna all’integrato.
I due LED sono invece connessi con il catodo a massa, l’anodo al capo di una resistenza da 470 Ohm che a sua volta ha l’altro terminale connesso all’uscita di Arduino rispettivamente il pin 2 e 3.
L’alimentazione può essere tramite USB o con il jack di alimentazione.
DOWNLOAD
Potete scaricare lo Sketch e lo schema interno di Arduino Mega e Arduino Uno al seguente LINK!!!
