Arduino

L'installazione sotto Windows

  • Queste note sono state cortesemente fornite da Franco Cattafesta
  • per chi ha Windows 7 consiglio un bel video su YouTube, il titolo è: Installing Arduino Software and UNO on Windows 7
    l'URL è: http://www.youtube.com/watch?v=9PUbfliMZZk

L'installazione sotto Windows

  • Resoconto della mia esperienza (con il contributo del video):
    1. Collegare Arduino ad una USB
    2. Lasciare che Windows tenti (inutilmente) l'installazione del driver
    3. Andare in "Gestione dispositivi" di Windows e cercare il dispositivo sconosciuto, poi fare l'aggiornamento del driver (click destro). N.B.: Contrariamente a quanto letto su alcuni articoli, il driver va cercato nella cartella DRIVERS e non nelle sue sottocartelle.
    4. Dopo aver caricato il driver, in "Gestione dispositivi" compare "Porte (COM e LPT)" con la porta fittizia COM3 assegnata alla scheda ARDUINO

L'installazione sotto Windows

  • Grazie, Franco

Che cosa è

Immagine slide
  • Arduino è una piattaforma di prototipazione hardware open source italiana
  • Arduino è una scheda a microprocessore basata sul processore Atmel AtMega 328
  • Arduino è programmabile in linguaggio Arduino, basato su Wiring, ma praticamente C
  • Per programmarlo si utilizza un semplice IDE, che si basa sul compilatore GCC per AVR
  • Basta premere un bottone dell'IDE per scaricare il programma sulla scheda, connessa tramite il cavo USB

L'IDE

Immagine slide
  • Uno dei punti di forza di Arduino è l'IDE che consente di scrivere programmi e scaricarli sulla piattaforma in un attimo
  • L'IDE è disponibile alla pagina http://arduino.cc/en/Main/Software per Windows, Linux (32 e 64 bit) e Mac OS
  • L'IDE è ance inserito nelle distribuzioni Ubuntu (dalla 10.10 - Maverick) e Debian (dalla 6.0 - Squeeze)
  • Purtroppo in queste distribuzioni la versione disponibile è alquanto datata, quindi, una volta installata andrà sostituita con la 1.0

Salvare ed eseguire - La toolbar dell'IDE

Immagine slide
  • Per prima cosa dovremo salvare utilizzando l'icona 5. Ci verrà richiesto il nome del nostro sketch (il nostro progetto)
  • Lo sketch viene salvato automaticamente nella cartella degli sketch di Arduino.
  • Potremo ora verificare se il nostro sketch presenta degli errori. Premeremo l'icona 1 e il risultato della compilazione ci verrà mostrato nella finestra in basso dell'IDE
  • Per poter scaricare sull'Arduino ed provare lo sketch dovremo aver configurato l'IDE per il tipo di Arduino e per la porta seriale che possediamo.

Salvare ed eseguire - La toolbar dell'IDE

Immagine slide
  • Nel menù Tools->Serial Port troveremo l'elenco delle porte seriali tra cui scegliere e nel menù Tools->Board l'elenco delle schede
  • Una volta configurato l'ambiente, potremo premere l'icona 2 per compilare lo sketch e scaricare il programma sulla scheda
  • Se vogliamo ricaricare uno sketch salvato in precedenza potremo premere l'icona 4, che ci presenterà l'elenco di tutti gli sketch che abbiamo salvato e tutti gli sketch di esempio distribuiti con l'ambiente. Lo sketch sostituirà quello correntemente caricato

Salvare ed eseguire - La toolbar dell'IDE

Immagine slide
  • Attenzione che gli sketch di esempio vengono aperti direttamente e non copiati, quindi se li modificate non potrete più recuperare gli originali. Meglio copiarli prima in un nuovo sketch
  • Per creare un nuovo sketch utilizzeremo l'icona 3, che svuota la finestra e si predispone per un nuovo sketch

Installare l'IDE sotto Linux

  • Su Ubuntu da 10.10 in su, digitare il comando:
    sudo apt-get install arduino
  • Su Debian Squeeze fate login come root (o digitate su - in un terminale) e digitate;
    aptitude install arduino
  • Su Ubuntu 10.04 LTS dovete per prima cosa scaricare arduino-core (http://packages.ubuntu.com/maverick/arduino-core) ed arduino (http://packages.ubuntu.com/maverick/arduino), quindi installarli nell'ordine (prima arduino-core poi arduino) con GDebi (basta cliccarci sopra

Installare l'IDE sotto Linux

  • Una volta installata la versione vecchia, occorrerà scaricare la versione nuova dal sito di Arduino ( http://arduino.googlecode.com/files/arduino-1.0-linux.tgz se avete una versione a 32 bit o http://arduino.googlecode.com/files/arduino-1.0-linux64.tgz se avete una versione a 64 bit)
  • A questo punto potete scompattare la nuova versione, ad esempio cliccando con il tasto destro sull'icona del file e scegliendo Estrai qui. Verrà creata la cartella arduino-1.0
  • A questo punto aprite un terminale ed entrate in modalità superutente, con il comando sudo bash in Ubuntu e su - in Debian

Installare l'IDE sotto Linux

  • Entrate nella cartella dove avete scompattato il file con il comando:
    cd <cartella_del_file>
    che potrebbe essere Scricati in Ubuntu, o /home/<vostro_utente>/Scaricati in Debian
  • Ora copiate la nuova versione in una posizione comoda con il comando:
    cp -r arduino-1.0 /usr/share
  • Ora spostatevi nella cartella con i comandi con:
    cd /usr/bin
  • Archiviate la vecchia versione con il comando:
    mv arduino arduino_0022

Installare l'IDE sotto Linux

  • E preparate il nuovo comando per lanciare arduino:
    echo '#!/bin/bash' > arduino
    echo cd /usr/share/arduino-1.0 >> arduino
    echo ./arduino >> arduino
    chmod a+x arduino
  • E per finire occorre garantire il permesso di accedere alla seriale al vostro utente con il comando:
    gpasswd -a <vostro_utente> dialout
  • Ricordate che l'ultimo comando ha effetto solo dopo che avete fatto logout e di nuovo login (ad esempio scegliendo Termina sessione... dal menù di spegnimento in Ubuntu o Sistema->Termina sessione di <utente>... in Debian)

Il primo programma - Lampeggio del LED

  • Per prima cosa, a livello globale, il LED è connesso al piedino digitale 13, quindi predisporremo una #define per questo piedino:
    #define LEDPIN 13
  • Quindi nella funzione setup () occorre richiamare la funzione che imposta in uscita il piedino del LED:
    pinMode(LEDPIN, OUTPUT);

Il primo programma - Lampeggio del LED

  • Per finire, dovremo mettere le istruzioni nella funzione loop () per eseguire un solo lampeggio; sarà poi il sistema che ripeterà all'infinito la funzione loop () per reiterare il lampeggio:
    digitalWrite(LEDPIN, HIGH); // Accende il LED 'L'
    delay (250); // Attende 1/4 di secondo
    digitalWrite(LEDPIN, LOW); // Spegne il LED 'L'
    delay (750); // Attende 3/4 di secondo

Utilizziamo la seriale

  • Il nostro Arduino contiene un convertitore USB-Seriale che consente di programmarlo
  • Questo convertitore e questa seriale possono anche essere utilizzati dai nostri sketch per colloquiare con il PC collegato
  • Per prima cosa dovremo, nella funzione setup (), inizializzare la velocità della seriale (ad esempio utilizzando la velocità standard di 9600 Baud) con la funzione Serial.begin (9600); (che in realtà è un metodo della classe Serial)

Utilizziamo la seriale

  • Dentro la funzione loop () potremo utilizzare Serial.read() che ritorna un carattere letto dalla seriale, se disponibile o -1 se non ci sono più caratteri disponibili
  • Serial.print (<valore>) converte <valore> in stringa e lo stampa. Questo metodo è sovraccaricato per tutti i tipi di dato diponibile, comprese le stringhe.
  • Serial.println(<valore>) è identica alla Serial.print(<valore>), salvo che va a capo al termine della stampa
  • Serial.write (<valore>) stampa il <valore> senza alcuna conversione (stampa binaria)

Utilizziamo la seriale

  • L'esempio allegato legge i caratteri uno ad uno e ne stampa il valore ascii ed i carattere stesso.
  • Per provarlo apriremo il terminale con il menù Tools->Serial Monitor. Quello che scriveremo nella linea di input verrà inviato premendo invio o il bottone Send all'Arduino, mentre quello che l'Arduino invierà verrà visualizzato nella finestra in basso

La schedina nuda

  • Come fornita, la scheda Arduino possiede
    1. Un processore con la circuiteria per funzionare
    2. Una connessione seriale al processore, tramite adattatore USB-Seriale
    3. Un LED programmabile (L1)
  • Il processore funziona a 16 MHz e contiene 32 KiB di Flash EPROM per il programma e 2KiB di RAM per i dati

La schedina nuda

  • Quindi, con la sola scheda Arduino è possibile scrivere programmi che:
    • Fanno lampeggiare il LED L1
    • Comunicano con il PC tramite la seriale

Lo Shield del Fermi

Immagine slide
  • Per questa lezione è stato reralizzato un semplice shield che consente una serie di esperimenti
  • Questo shield contiene
    • un display numerico a 7 segmenti connesso ad 8 uscite digitali
    • tre tasti connessi a tre ingressi digitali
    • un sensore di luce realizzato con una fotoresitenza, connesso all'ingresso analogico 1
    • un sensore di temperatura realizzato tramite un resistore a coefficiente di temperatura negativo NTC, connesso all'ingresso analogico 0

Lo Shield del Fermi

Immagine slide

La struttura di un programma Arduino

  • Un programma per Arduino si compone sempre di due funzioni di base, che dovremo scrivere.
  • La prima, void setup () {}, serve per configurare la scheda indicando, ad esempio, la velocità della seriale e l'uso dei piedini che comunicano con l'esterno
  • Questa funzione viene eseguita una sola volta, all'accensione (reset) della scheda
  • La seconda, void loop() {}, contiene le azioni che la scheda eseguirà
  • Questa funzione, se termina, viene ripetuta all'infinito fino a che non si spegne la scheda

I componenti esterni e gli shield

  • Abbiamo detto all'inizio che Arduino è una piattaforma di prototipazione hardware
  • Questo significa che lo scopo principale di Arduino è quello di controllare componenti elettrici connessi ai suoi connettori
  • I componenti esterni possono essere collegati direttamente inserendo i fili dei componenti nei connettori
  • Altrimenti possiamo utilizzare sempre dei fili inseriti nei connettori per collegare delle schede esterne con dei circuiti elettronici

I componenti esterni e gli shield

  • Per finire è possibile creare delle schedine che posseggano dei connettori che si inseriscano direttamente nei connettori di Arduino. Queste schedine prendono il nome di shield
  • Il mercato fornisce una ampia gamma di shield che eseguono le operazioni più disparate come sistemi di comunicazione a radiofrequenza, antenne GPS, schede di rete ed altro

Leggiamo un numero intero

  • Un altro esempio potrebbe essere quello di leggere un numero intero.
  • Potremo utilizzare la funzione char getc() scritta per l'esempio precedente
  • Potremo ora scrivere una funzione int getint () che legga caratteri finché sono compresi tra 0 e 9 e converta i caratteri letti in un intero. Ritornerà al primo carattere non compreso nell'intervallo.
  • Ricordo che per convertire un carattere tra 0 e 9 nel suo valore numerico basta sottrarre il carattere '0'

Leggiamo un numero intero

  • Potremo utilizzare il metodo di leggere le cifre dalla più significativa (la prima che viene digitata), moltiplicare quanto già convertito per la base 10 ed aggiungere il valore della nuova cifra al risultato.
  • Anche per utilizzare questo programma dobbiamo ricordarci di configurare il terminale in modo da inviare un a capo alla fine di ogni riga inviata
  • Per fare questo occorre selezionare NewLine al posto di No line ending dalla lista a destra in basso nella finestra del terminale

Le connessioni dello shield

Immagine slide
  • Vediamo ora i piedini dell'Arduino che servono per pilotare/leggere le varie periferiche

Le connessioni dello shield

Immagine slide
  • I segmenti del display sono collegati nel seguente modo (come visualizzato nell'immagine a lato):
    • Digital 4 - Segmento e
    • Digital 5 - Segmento d
    • Digital 6 - Segmento c
    • Digital 7 - dp - Punto Decimale
    • Digital 9 - Segmento b
    • Digital 10 - Segmento a
    • Digital 11 - Segmento f
    • Digital 12 - Segmento g

Le connessioni dello shield

Immagine slide
  • I tre pulsanti sono collegati ai seguenti piedino:
    • Digital 2 - Tasto S3
    • Digital 3 - Tasto S2
    • Digital 8 - Tasto S1
  • E per finire i sensori, analogici:
    • Analog 0 - Fotoresistenza - Luce
    • Analog 1 - NTC - Temperatura

Primo programma con lo shield - test del display

  • Il primo programma che potremo fare con il nostro nuovo shield è quello che verifica il corretto funzionamento del display
  • Per fare questo accendere mo i segmenti ed il punto uno ad uno per un quarto secondo cadauno
  • Per prima cosa, per rendere più chiaro il programma definiremo delle constanti per i numeri dei piedini
  • Dovendo configurare, accendere e spegnere otto uscite, ho pensato di utilizzare un array di costanti, che mi mettano in relazione i segmenti da a a g ed il punto ai relativi numeri di piedino

Primo programma con lo shield - test del display

  • A questo punto il programma diventa molto semplice
  • Nella funzione setup () fare o un ciclo for che imposti tutti i piedini elencati nel vettore in uscita tramite la funzione pinMode(segments , OUTPUT);
  • Nella funzione loop faremo ancora un ciclo for su tutti i segmenti ed il punto, accendendo un segmento, attendendo un secondo e spegnendo il segmento:
    digitalWrite(segments , LOW); // Accende il LED
    delay (250); // Attende 1/4 di secondo
    digitalWrite(segments , HIGH); // Spegne il LED

Visualizziamo una cifra

  • Il dipsplay a 7 segmenti nasce per visualizzare delle cifre
  • Accendendo opportunamente i vari segmenti del display potremo rappresentare tutte le 10 cofre decimali dallo 0 a 9 oltre alle lettere da a ad f per rappresentare una cifra decimale o esadecimale
  • Per questo nuovo programma partiremo dal precedente, che già contiene l'inizializzazione e la definizione dei dati

Visualizziamo una cifra

  • Per semplificare il lavoro, definisco una matrice di costanti boolean che, per ognuna delle cifre esadecimali da 0 a f indichi quali dei segmenti accendere (true) o spegnere (false)
  • Scriveremo ora una funzione void digit (int n) che, dopo aver limitato il numero passato come parametro al campo da 0 a f, lo visualizzerà sul display.
  • Per fare questo farà un semplice ciclo for sulle colonne della riga il cui indice è la cifra da rappresentare, accendendo (true) o spegnendo (false) il piedino corrispondente al segmento, il cui indice deriva dal vettore della volta scorsa.

Visualizziamo una cifra

  • Per decidere se accendere o spegnere il piedino utilizzo l'operatore ternario del C, quindi la riga che esegue il lavoro diventa: digitalWrite(segments , (cifre[n]) ? LOW : HIGH); dove ovviamente n è la cifra da visualizzare, mentre i è il segmento corrente (0 = a, 6 = g)
  • Completeremo il tutto con un semplice ciclo for, nella funzione loop(), che richiami la nostra funzione per le cifre da 0 a 15, con intervallo di mezzo secondo

Conteggio avanti/indietro

  • Proviamo ad utilizzare i tasti. Per prima cosa dovremo programmare nella funzione setup() i relativi tre piedini in ingresso, con le seguenti tre righe:
    pinMode(S1PIN, INPUT);
    pinMode(S2PIN, INPUT);
    pinMode(S3PIN, INPUT);
  • Per come sono stati collegati i tasti, se il piedino ritorna true, il tasto è rilasciato, mentre se torna false è premuto
  • A questo punto occorre fare alcuni ragionamenti

Conteggio avanti/indietro

  • Per prima cosa, il tasto rimarrà premuto per un certo periodo (non siamo certo in grado di fare un "pressione istantanea" per quanto veloci noi siamo a mollare il tasto), ma l'azione associata al tasto andrà fatta una volta per ogni pressione, quindi dovremo attendere il rilascio prima di ripetere l'azione
  • A complicare le cose, la meccanica del tasto fa si che il tasto rimbalzi alcune volte sui contatti prima di restare definitivamente chiuso, aprendosi e richiudendosi, quando lo premiamo. Lo stesso succede al rilascio.

Conteggio avanti/indietro

  • Per risolvere questo problema potremo, dopo aver trovato il tasto premuto, attendere un certo tempo che si esauriscano i rimbalzi, quindi ricontrollare. Se dopo il ritardo:
    • il tasto è ancora premuto, lo resterà fino al rilascio, quindi eseguiremo l'azione
    • non è più premuto allora abbiamo rilevato un rimbalzo sul rilascio, e non dobbiamo ripetere l'azione

Conclusione

  • Questi sono solo alcuni semplici esempi.
  • Non sono state toccate le funzioni relative alle interruzioni, che consentono di gestire eventi molto veloci
  • Non si è parlato dell'interfaccia I2C che consente di parlare con reti di sensori digitali
  • Non si è parlato di molti altri argomenti
  • Ho però cercato di presentarvi un diverso modo di intendere l'informatica: l'informatica embedded

Conclusione

Esercizi - 02 - tipo di carattere

  • Scrivere un programma che legga caratteri da seriale e per ogni carattere scriva sulla seriale codice ascii in decimale, lettera scritta in ascii, tipo di carattere (maiusola, minuscola, numero, segno o carattere di controllo)

Esercizi - 02 - tipo di carattere

  • Ricordo che:
    • le lettere maiuscole vanno da 'A' a 'Z'
    • le lettere minuscole vanno da 'a' a 'z'
    • i numeri da '0' a '9'
    • i caratteri di controllo da 0 a 31
    • tutti gli altri sono simboli

Esercizi - 04 - Lettura della luce sul terminale

  • Modifichiamo l'esempio della lettura della luce, scrivendo il valore letto anche sul terminale
  • Questo esercizio prevede semplicemente di "mischiare" il primo esempio della seriale con l'esempio della lettura della luce

L'anatomia di Arduino

Immagine slide
  • Vediamo ora, uno per uno, cosa sono i componenti della scheda Arduino, a partire dall'angolo in alto a destra
  • 1 è il pulsante di reset; serve per riavviare a mano il programma, a partire dall'inizializzazione
  • 2 è il connettore che consente di collegarsi agli ingressi/uscite digitali. Alcune di queste uscite possono anche produrre tensioni a più valori con la tecnica del PWM
  • 3 è il connettore USB. Serve sia per alimentare la schedina che per programmarla o comunicare con essa

L'anatomia di Arduino

Immagine slide
  • 4 Questo componente converte l'USB del PC nella seriale che usa il microprocessore ATMega
  • 5 Questo è il quarzo che regola la velocità del convertitore da USB a Seriaòle
  • 6 Questo secondo quarzo sereve per regolare la velocità del processore ATMega di Arduino
  • 7 questo circuito regola la tensione di aliemntazione principale a 5V del sistema, quando non viene alimentato dall'USB
  • 8 Questo è il processore ATMega che fa funzionare il nostro sistema, sarà il processore che programmeremo.

L'anatomia di Arduino

Immagine slide
  • 9 Questo è il connettroe di alimentazione. Potrremo usarlo per alimentare la scheda se deve funzionare da sola, non connessa al PC, quindi non alimentata tramite USB. Potremo connettere una pila da 9 o 12 V.
  • 10 Questo è il circuito che produce la tensione di alimentazione secondaria a 3.3V per alimentare alcuni circuiti.
  • 11 Questo connettore mette a disposizione le tensioni di alimentazione di Arduino per alimentare le schede o i componentiu esterni

L'anatomia di Arduino

Immagine slide
  • 12 e questo ultimo connettore consente di misurare con l'Arduino delle tensioni prodotte da dei sensori, come ad esempio il livello di luce tramite un sensore di luce, oppure la temperatura ambiente

Esercizi - 03 - misura dei riflessi

  • Scrivere un programma che accenda casualmente i due segmenti a destra (a e b) o i due a sinistra (d ed e) e misuri entro quanto tempo l'utente preme il tasto S1 o S3 (quello dallo stesso lato)
  • La prova comincerà premendo S2
  • Dopo 10 tentativi il display visualizzerà il tempo medio di reazione, in decimi di secondo
  • Sulla seriale verranno invece stampati il tempo di reazione minimo, massimo e medio, direttamente in microsecondi

Esercizi - 03 - misura dei riflessi

  • Per fare questo esercizio occorre utilizzare la funzione randomSeed(analogRead(5)); per inizializzare i numeri casuali
  • Ci servirà il generatore di numeri casuali random(<max>) o random(<min>,<max>) che ritorna un numero intero casuale
  • Per finire dovremo utilizzare la funzione micros() che ritorna il numero di microsecondi trascorsi dall'accensione della scheda - la differenza tra due valori ci darà la prontezza di riflessi
  • L'esercizio è abbastanza complesso - decisamente di più di tutti gli altri esempi

Il codice di gestione del tasto

  • Per tradurre in programma il ragionamento fatto, abbiamo la seguente struttura:
    • se il pulsante è premuto
      • attendo un tempo di 50ms
      • se il pulsante è ancora premuto
        • eseguo l'azione
        • faccio un ciclo while per attendere il rilascio del pulsante

Il codice di gestione del tasto

  • Riporto il tratto di codice che gestisce il pulsante S1:
      if (!digitalRead(S1PIN)) {  // Pulsante 1 premuto delay(10);  // Ritardo per attendere la fine dei rimbalzi if (!digitalRead(S1PIN)) {  // Il tasto e' ancora premuto i = (i + 1) % 16; digit (i); while (!digitalRead(S1PIN));  // Attende il rilascio } }
  • Nella funzione loop() questo codice verrà replicato per i tre pulsanti. Le azioni associate saranno aumentare il valore, ridurre il valore e riportare il valore a zero

Uscite analogiche

  • L'ultimo esempio tocca l'ultima caratteristica base dell'Arduino: quella di poter fornire una tensione analogica, che varia da 0V a 5V, in 256 passi
  • In realtà Arduino non produce una tensione costante sui suoi piedini, ma una forma d'onda il cui valor medio è la tensione richiesta, secondo al tecnica Pulse Width Modulation o PWM
  • Per ottenere una tensione continua occorrerebbe un filtro che elimini la componente alternata del segnale, restituendone il valor medio.

Uscite analogiche

  • Nel nostro caso, dato che regoleremo la luce dei led del display, questo filtro non serve perché è il nostro stesso occhio che non rileva la componente alternata
  • Non tutte le uscite digitali dell'Arduino possono produrre il segnale PWM, ma alcuni segmenti (a, b, c, d ed f) possono essere regolati
  • Scriveremo allora una semplice funzione luce(<livello>) che regolerà la luminosità dei segmenti regolabili su 16 diversi livelli

Uscite analogiche

  • All'interno di questa funzione utilizzeremo la funzione analogWrite (<segmento>,i); dove i è il livello di luminosità, tra 0 e 255 e <segmento> il segmento di cui regolare la luminosità
  • Dato che non tutti i segmenti sono regolabili, questa volta li regoleremo chiamando la funzione singolarmente per ogni segmento interessato
  • Nella funzione loop() modificheremo il codice dei tasti dell'esempio precedente per aumentare, ridurre o riportare al 50% la luminosità

Esercizi - 01 - sos

  • Scrivere un programma che faccia lampeggiare il LED L con il codice morse dell'SOS
  • Il codice dell'SOS è composto da tre punti (s), tre linee (o), tre punti (s)
  • Ogni punto o linea è separato dal successivo della stessa lettere ad una breve pausa di 100 mS
  • Un punto è un lampo di luce di 100 ms
  • Una linea è un lampo di luce più lungo, diciamo di 300 mS
  • Una lettera è separata dalla successiva da una pausa di 300 mS

Esercizi - 01 - sos

  • Per finire, una parola è separata dalla successiva da una pausa di 500 mS

Esercizi - 05 - Variazione di temperaura

  • Modificare il programma della fotocellula per leggere l'NTC.
  • Utilizzare il pulsante S2 per centrare la lettura sul valore corrente (il display deve riportarsi al valore 8)
  • La differenza della lettura deve essere visualizzata con la massima precisione possibile
  • Manterremo la stampa del valore esatto sul terminale
  • Una cosa alla quale stare attenti è che i valori delle variabili della funzione loop() si resettano ad ogni "giro"

Esercizi - 05 - Variazione di temperaura

  • Naturalmente il valore di preset deve permanere tra un giro e l'altro, dopo che lo avremo impostato
  • Per ottenere questo potremo definire questa variabile globale, quindi al di fuori di ogni funzione

Esercizi - 06 - Calibrazione fotocellula

  • Modificare il programma della fotocellula per usare il pulsante S1 per impostare la luce minima e il pulsante S3 per impostare la luce massima
  • Manterremo ancora la stampa sul terminale
  • Ancora dovremo definire globali il minimo ed il massimo

Leggiamo una riga di testo

  • Se invece di trattare i singoli caratteri vogliamo leggere una intera riga, dovremo per prima cosa allocare un buffer per la riga letta
  • Dovremo stare attenti perché il processore ha 2 KiB di RAM ed il compilatore non ci indica quanta ne usa il nostro programma, quindi sta a noi economizzarla
  • Potremo poi scrivere una funzione char * gets (char *buf, int buflen) che legga l'intera riga; questa funzione farà un loop di lettura caratteri fino alla ricezione del carattere di fine riga.

Leggiamo una riga di testo

  • Per aiutarci, potremmo anche scriverci una funzione char getc () che attenda un carattere, piuttosto che ritornare -1 se il carattere non è disponibile, facendo un loop sulla Serial.read().
  • Per utilizzare questo programma dobbiamo ricordarci di configurare il terminale in modo da inviare un a capo alla fine di ogni riga inviata
  • Per fare questo occorre selezionare NewLine al posto di No line ending dalla lista a destra in basso nella finestra del terminale

Visualizziamo la misura della luce ambiente

  • Adesso che abbiamo un sistema che rappresenta delle cifre, utilizziamolo per visualizzare la misura della luce ottenuta tramite la fotoresisztenza
  • Recupereremo il nostro programma precedente e ne modificheremo solo molto semplicemente la funzione loop()
  • Gli ingressi analogici non devono essere programmati. Basta richiamare la funzione analogRead(<piedino>) per ottenere un numero tra 0 e 1023 che corrisponde alla tensione sul piedino (0 = 0V, 1023 = 5V)
  • Dato però che il nostro display può rappresentare solo numeri tra 0 e 15, divideremo la quantità letta per 64 (16 * 64 = 1024)

Visualizziamo la misura della luce ambiente

  • Ora la nostra funzione loop() conterrà solo la riga digit (analogRead(LUCE)/64); che richiama la funzione digit(<numero>) passando il valore letto. Aggiungeremo poi un ritardo per evitare che la cifra cambi troppo rapidamente.
[any material that should appear in print but not on the slide]