Ingressi e uscite

ISTRUZIONI PER GESTIRE INGRESSI E USCITE (=> Diapositiva)


Lez. precedente<= | 14 pin di I/O Digitali e 6 ingressi Analogici | =>Lez. successiva


Arduino uno ha 14 pin di I/O digitali (D0 – D13 quelli sopra alla linea DIGITAL) e 6 ingressi analogici (A0- A5 quelli sotto alla linea ANALOG IN)

|<= pinMode()


Cominciamo con gli I/O DIGITALI osservando che l’istruzione pinMode (13, OUTPUT)  imposta il pin 13 come output mentre  pinMode (13, INPUT) lo imposta come input.

Nel programma Blink (lampeggia):
void setup() {
pinMode (13, OUTPUT);
}
void loop() {
digitalWrite (13, HIGH);
delay (1000);
digitalWrite (13, LOW); 

delay (1000);

l’istruzione pinMode (13, OUTPUT) setta come output il piedino 13 (collegato al led L della scheda Arduino). Tale istruzione è messa nella funzione setup() perchè deve essere eseguita una sola volta.
L’istruzione seguente è digitalWrite (13, HIGH) e scrive HIGH sul piedino 13 nel senso che ci mette la tensione alta (5 V), dopo di che il led L si accende.
L’istruzione successiva delay (1000) ritarda (delay) di 1000 msec cioè di 1 secondo.
Dopo un secondo viene eseguita l’istruzione digitalWrite(13, LOW) che scrive LOW nel senso che mette la tensione bassa (0 V) sul piedino 13, dopo di che il led L si spegne.
L’ultima istruzione delay(1000) ritarda di 1000 ms.

A questo punto viene eseguita di nuova la prima istruzione della funzione loop(), che corrisponde alla funzione main() del C con la differenza che le istruzioni dentro a loop() vengono ripetute continuamente fino a che non si toglie l’alimentazione.


|<= digitalRead()


Se il piedino il cui numero è nella variabile intera pin è impostato come input, allora si può andare a leggerlo mettendo il suo valore nella variabile intera val con val=digitalRead(pin).

Es.:
int pin=7;
int val;
pinMode (val, INPUT);
val = digitalRead (pin);
scrive 0 oppure 1 in val a secondo se la tensione trovata sul piedino 7 è bassa o alta.

|<= digitalWrite()


Se invece pin è impostato come output si può scrivere su di esso alto con l’istruzione digitalWrite (pin, HIGH) o ci si può scrivere basso con digitalWrite (pin, LOW) (la tensione HIGH è di 5 V e quella LOW è di 0 V; la corrente massima, erogata se l’uscita è High e assorbita se l’uscita è Low, è di 40 mA)


|<= anolgWrite()


Se però il pin di Output è uno di quelli con la tilde  (3, 5, 6, 9, 10, 11) in grado di fornire uscite PWM , ovvero onde quadre a duty cycle (DC) variabile, allora la Write non deve specificare H o L ma un valore compreso tra 0 (DC = 0 ovvero sempre L) e 255 (DC = 100% ovvero sempre H). Trattandosi di un’uscita “analogica” nel senso che è un’onda quadra e quindi non è sempre alta o sempre bassa ma “varia”, si ricordera più facilmente che l’istruzione da usare non è digitalWrite(…) ma  analogWrite(pin, value)

Pertanto analogWrite (3, 0) manda sul piedino 3 un’onda quadra con duty cicle 0% (il duty cycle è 0 diviso 255 ovvero 0%).
analogWrite (3, 255) manda sul piedino 3 un’onda quadra con duty cycle 100% perché 255/255 fa 1 ovvero 100%
Se il secondo valore specificato in analogWrite è 63 l’onda quadra avrà duty cycle 24,7% (perché 63/255 = 0,247 = 24,7%).
Se il valore specificato è 127 allora l’onda quadra avrà duty cycle 49,8% perché 127/255 fa 0,498.
Se il valore specificato è 191 allora l’onda quadra avrà duty cycle 74,9% perché 191/255 fa 0,749

In ogni caso la frequenza dell’onda quadra è di circa 490 Hz


|<= analogRead()


Su ognuno dei 6 ingressi analogici (A0-A5) si può mettere una V compresa tra 0 e 5 V, che verrà convertita da un convertitore A/D con risoluzione da 10 bit in un numero intero compreso tra 0 e 1023.

Se pin è un intero compreso tra 0 e 5 l’istruzione val = analogRead(pin) mette nella variabile intera val un numero da 0 a 1023 (se la V del piedino specificato in pin è 2,5V allora in val ci andrà 1023/2 = 511,5 = 511; se V=1V in val ci andrà 1023/5 = 204,6 = 205 e così via.
Supponiamo di aver montato il circuito mostrato qui sotto, collegando l’ingresso A0 con il centrale di un potenziometro che ha tra gli altri due capi 5V. La tensione su A0 dipenderà dalla paosizione del centrale e potrà andare da 0V (centrale tutto in basso) a 5V (centrale tutto in alto).
Cosa ci sarà scritto nella variabile sensorValue (dichiarata variabile di tipo int nella stessa istruzione) dopo l’esecuzione dell’istruzione int sensorValue = analog(A0) ?
Ci sarà un numero variabile da 0 a 1023, a secondo della posizione del centrale del potenziometro.


|<= analogReference()


L’istruzione analogReference(INTERNAL) imposta a 1.1 V la tensione massima sugli ingressi analogici A0-A5, convertendo questo valore di tensione col numero 1023.

Se non mi sta bene che la tensione massima degli ingressi analogici sia di 5V o di 1.1V, posso usare l’istruzione analogReference(EXTERNAL) che  imposta come tensione massima degli ingressi analogici la tensione applicata al pin AREF (sul quale andrò a mettere la tensione massima desiderata da me). ATTENZIONE: Se si applica una tensione sul piedino AREF senza dare l’istruzione analogReference(EXTERNAL), si può danneggiare la scheda.

Per tornare ad avere come tensione massima analogica 5V dopo una analogReference con parametro INTERNAL o EXTERNAL, devo dare l’istruzione analogReference(DEFAULT), che rispristina la tensione massima al valore di default (coincidente con la tensione di alimentazione prevista per la scheda, che è di 5V in Arduino uno ma che in altre schede Arduino può essere diversa)


|<= Serial.begin() e Serial.println() per mandare un dato al PC


I pin 2 e 3 dell’ATmega328 sono inviate ai pin 0 (RX) e 1 (TX) ma anche all’USB via ATmega 16 per stabilire una comunicazione seriale col PC.
Per provare tale comunicazione montiamo il circuito sottostante, composto da un pulsante normalmente aperto, nel qual caso la tensione sul resistore e sull’ingresso D2 sarà 0V (per cui leggendo D2 si otterrà il numero 0). Pigiando il pulsante la tensione di 5V arriva sul resistore e quindi sull’ingresso D2 (per cui leggendo D2 si otterrà il numero 1)
Poi preleviamo dalla cartella Examples, sottocartella basic, il programma DigitalReadSerial e lo inviamo ad Arduino.
L’istruzione Serial.begin(9600) – nella quale non bisogna dimenticare il punto che ci dice che all’interno del programma Serial è definita una funzione begin() –  ha l’effetto di attivare una comunicazione seriale col PC impostando la sua velocità a 9600 bps.
Il manuale di riferimento dice che per comunicare col computer si deve usare una di queste velocità: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, o 115200.
L’istruzione Serial.println (sensorValue) invia al PC il numero contenuto nella variabile sensorValue.
Cliccando sull’icona posta sulla destra della finestra Arduino, si apre il serial monitor (una finestra dove compaiono i dati inviati da Arduino via USB)
Se è attivo l’autoscroll, sulla sinistra compaiono una serie di 0, perché se non facciamo nulla la variabile sensorValue riceve continuamente il valore tensione bassa e numericamente riceve sempre 0
Se teniamo premuto il pulsante, la variabile sensorValue riceve continuamente il livello alto e sul serial monitor vediamo stampati una serie di 1.
Se il dato assegnato alla variabile sensorValue fosse stato 1023, invece che 0 oppure 1), sul serial monitor avremmo letto una serie di 1023.

|<= Serial.available() e Serial.read() per mandare un dato ad Arduino


Per vedere le due istruzioni per la comunicazione inversa, ovvero dal PC ad Arduino, esaminiamo il seguento frammento di programma:
La funzione Serial.available() restituisce il numero di byte presenti nel buffer della porta seriale in attesa di essere letti.
Se tale buffer è vuoto perché il PC non ha inviato nulla di ancora non letto, allora Serial.available() restituisce 0 e il corpo dell’IF non viene eseguito.
Quando l’IF parte perché è disponibile almeno un byte, entra in gioco la seconda istruzione usata in questo invio ovvero la Serial.read() che legge il primo byte disponibile e lo assegna alla variabile inByte.
I dati accettati da questo programma sono numeri esadecimali di 6 cifre che cominciano con cancelletto inviati dal PC e infatti prima si controlla che il primo byte acquisito sia il carattere cancelletto. Se è così, si ripete 6 volte la lettura della seriale con l’istruzione Serial.read() accumulando nel vettore buffer i 6 esadecimali del dato inviato dal PC ad Arduino.

Lez. precedente<= | Inizio pagina | =>Lez. successiva

Lascia una risposta

L'indirizzo email non verrà pubblicato. I campi obbligatori sono contrassegnati *