Archivi tag: arduino

Errori comuni nell’uso di Arduino – dimenticare il punto e virgola dopo il return

Errore:

if (contatore < 60)
    return    // manca il punto e virgola
contatore = contatore + 1;

Il codice sopra viene compilato come se fosse:

if (contatore < 60)
return contatore = contatore + 1;

Si ricorda che dopo un return incondizionato il codice che segue non verrà mai eseguito.

Ad esempio:

contatore = contatore + 1;
return contatore;
contatore = 10; // questa linea di codice non verrà mai eseguita

Esercizio (semplice semplice 🙂 ) per i miei studenti di terza:

Realizzare due sketch che accettano un input numerico intero da tastiera (sulla Serial Monitor) che dimostrano le due situazioni esposte nella spiegazione precedente.

Controllo di un motore passo-passo bipolare NEMA17 con Driver L298N

I motori “passo-passo” o “stepper” sono motori elettrici sincroni il cui avanzamento avviene a passo singolo corrispondente ad uno specifico angolo di rotazione, pertanto è possibile farli ruotare a piacimento di un angolo preciso. Uno stepper è in grado di mantenere con precisione velocità di rotazione e posizione senza la necessitò di utilizzo di trasduttori di feedback come dinamo tachimetriche o encoder.
I motori passo-passo sono ampiamente utilizzati nell’ambito dell’automazione industriale: robotica, stampanti, scanner, o per esempio come stanno facendo alcuni miei allievi, per regolare l’inclinazione di un pannello solare per realizzare un inseguitore solare.

Rispetto ad altre tipologie di motori elettrici il motore passo-passo non modifica la velocità di rotazione in funzione della coppia a cui è sottoposto l’albero rotante, la mantiene costante e nel caso in cui la coppia aumenti il motore si ferma.

I motori stepper per essere pilotati richiedono una sequenza di impulsi generati da appositi circuiti elettronici di controllo.

In laboratorio vedremo come controllare il movimento di un motore passo-passo bipolare con Arduino mediante l’uso di un Motor Driver L298N. Su questo sito ho dettagliato l’uso di questa scheda per controllare motori in CC per robot didattici, però con questo tutorial voglio indicare ai miei studenti come effettuare il controllo di un motore passo passo NEMA17 che dovranno utilizzare nelle prossime esperienze di laboratorio.

Richiami teorici

Lo stepper motor o motore passo-passo è definito anche come “trasduttore elettromeccanico” in quanto converte impulsi elettrici di comando in passi elementari (step) di ampiezza angolare fissata in funzione del tipo di motore.

Questo tipo di motore elettrico per poter funzionare deve essere collegato ad un circuito di alimentazione specifico e ad un sistema di controllo elettronico in grado di governare l’angolo e la velocità di rotazione.
Come per tutti i motori elettrici anche il motore passo-passo è costituito da una parte fissa detta statore ed una parte mobile detta rotore su cui è connesso un albero di rotazione dotato di cuscinetti:

Nello statore sono disposti gli avvolgimenti di rame, costituiti da bobine di rame smaltato (isolato), mentre il rotore è costituito da materiale magnetico.

Esistono tre tipi di motori passo passo:

  • a magnete permanente (PM)
  • a riluttanza variabile (VR)ibrido (HY)

Gli avvolgimenti dello statore sono collegati in modo da realizzare un sistema bifase, ma esistono anche sistemi trifase e polifase ma sono più rari.

I motori passo-passo si suddividono a loro volta in due famiglie:

  • motori bipolari (la corrente negli avvolgimenti statorici scorre nei due versi)
  • motori unipolari (la corrente negli avvolgimenti statorici scorre in un solo verso)

In questa guida prenderà in considerazione solamente i motori a magneti permanenti (PM) e di questi considereremo solamente i motori passo-passo bipolari. La spiegazione teorica e l’utilizzo delle altre tipologie di motori sarà argomento di successive lezioni.

Motore a magnete permanente – motore passo-passo bipolare

Il principio di funzionamento di questa tipologia di motori è basato sull’attrazione di due poli magnetici che presentano polarità differenti. Un polo è costituito da un magnete permanete (calamita) mentre l’altro è il polo di un elettromagnete il cui magnetismo è generato da una corrente che fluisce in spire avvolte su un materiale ferromagnetico.

Si ricorda che facendo scorrere una corrente su una bobina avvolta su un nucleo di ferro viene generato un campo magnetico che presenterà una polarità Nord-Sud secondo la “regola della mano destra”:

immaginiamo di impugnare l’avvolgimento con la mano destra in modo che le dita indichino il verso di percorrenza della corrente, il pollice indicherà la direzione del vettore campo elettromagnetico e la punta del pollice indica il verso del vettore individuando il Nord magnetico:

Per far muovere il rotore dovremo quindi modificare il verso di percorrenza della corrente nelle bobine dello statore in modo che la forza di attrazione Nord-Sud tra i poli dello statore e del rotore generi il moto rotatorio.

Nello statore sono presenti due magneti disposti in maniera ortogonale uno rispetto all’altro su cui sono avvolte due bobina i cui terminali sono nominati: A+ e A-, B+ e B- così sono indicati nelle tabelle tecniche di questi dispositivi (i segni + e – a fianco alle lettere A e B non sono da confondere con la polarità), mentre il rotore è costituito da un magnete permanente costituito quindi da un polo Nord e un polo Sud.

Movimento del rotore

Facendo circolare una corrente continua nell’avvolgimento statorico A+ e A- viene generato un campo magnetico che porterà il rotore a ruotare e a bloccarsi nella posizione in cui le polarità magnetiche saranno opposte, così come indicato nel disegno che segue:

Togliendo alimentazione all’avvolgimento statorico A+ A- e alimentando l’avvolgimento statorico B+ B- si avrà una configurazione differente dei magneti statorici ed una conseguente rotazione di 90° del rotore in senso antiorario, come indicato nel disegno che segue:

Togliendo alimentazione all’avvolgimento statorico B+ B- e alimentando in senso opposto (polarità inversa) l’avvolgimento statorico A+ A- si invertiranno le polarità del campo magnetico ed una rotazione di 90° in senso antiorario del rotore così come indicato nel disegno che segue:

Da ciò si comprende che invertendo il verso di percorrenza della corrente prima prima in un avvolgimento statorico e poi nell’altro si otterrà ogni volta una rotazione di 90° del rotore.
L’alimentazione di una fase alla volta (di un avvolgimento statorico alla volta) è detto a “full step”, cioè passo intero.

La sequenza completa di rotazione è costituita da 4 passi (o 4 fasi) e quindi per ottenere una rotazione continua del rotore bisognerà realizzare la seguente sequenza di alimentazione:

La sequenza di movimento, secondo la tabella sopra indicata, sarà quella dell’immagine che segue dove per semplicità di esposizione è stato semplificato il disegno del motore:

Per invertire il senso di rotazione degli elettromagneti sarà sufficiente quindi invertire la sequenza con cui vengono alimentate le bobine statoriche.

Il movimento del motore può avvenire anche alimentando contemporaneamente entrambe le bobine statoriche, in questo modo il rotore si disporrà a 45° rispetto alla posizione precedente. La tabella delle singole fasi diventa:

la posizione del rotore sarà quella descritta dai disegni che seguono:

Controllo

I fili che costituisco i due poli sono distinti da colori diversi e il controllo del motore passo-passo deve essere effettuato da un driver bipolare, nel nostro caso un L298N.

La sequenza di eccitazione, sarà realizzata da un microcontrollore, nel nostro caso Arduino ed in una successivamente lezione vedremo come controllare uno stepper mediante PLC Siemens 1200 con un’altro tipo di driver.

Il driver bipolare, può essere paragonato in estrema sintesi a 8 interruttori, 4 interruttori per ogni bobina statorica

Elettronicamente il driver bipolare è costituito da un circuito elettronico a doppio ponte H, il nostro L298N, che consente di invertire il senso della corrente nelle bobine statoriche. Gli interruttori del circuito precedente vengono realizzati con transitor mosfet o bjt. Comandando la polarizzazione di coppie di transitor per ogni ponte H sarà possibile alimentare le bobine con polarità diverse.

Nell’esempio che segue viene preso in considerazione un solo ponte H.

Nel circuito sono presenti 4 transitor due NPN (Tr2 e Tr3) e due PNP (Tr1 e Tr4), collegati come indicato nel disegno che segue:

Mediante l’utilizzo di due output digitali di un microcontrollore invieremo sui pin IN1 e IN2 valori HIGH e LOW (tensioni di 5V e 0V) in modo da controllare la polarizzazione dei transitor e il conseguente verso di percorrenza della corrente che circola nella bobina statorica del motore.

Quando nel punto IN1 si ha un valore HIGH e su IN2 un valore LOW, andranno in conduzionei transistor Tr4 e Tr2 provocando la rotazione in un senso del motore

quando nel punto IN1 il segnale è LOW e su IN2 il segnale è HIGH i transistor che andranno in conduzione saranno il Tr1 e il Tr3, provocando la rotazione nel senso opposto al passo precedente:

La modalità di collegamento del circuito impedisce di alimentare contemporaneamente la coppia di transitor evitando così cortocircuiti.
I quattro diodi sono detti diodi di ricircolo ed il loro scopo è quello di proteggere i transistor dalla sovratensione generata dalla bobina statorica (induttanze) nel momento dell’apertura del circuito, infatti quando i transitor passano dalla condizione di conduzione a quella di interdizione (si apre l’interruttore) la corrente circolante dovrebbe andare istantaneamente a zero, ma l’induttore (la bobina statorica del motore) tende ad impedire questa brusca variazione, la tensione sul collettore del transitor tende ad aumentare a valori molto elevati.

Se immaginate il transitor in interdizione come ad un interruttore aperto, che quindi assume una resistenza elevatissima, l’induttore si comporterà per un breve istante come un generatore di tensione cercando di far passare in questa resistenza elevatissima la stessa corrente che era presente quando il bjt si comportava come interruttore chiuso, ma per la legge di ohm (V = RxI) la tensione sul collettore del bjt raggiunge valori molto alti, superiori alla tensione di alimentazione danneggiando il bjt.
Per evitare la distruzione del bjt viene inserito un diodo con catodo rivolto verso il positivo dell’alimentazione.

Durante la conduzione del transistor, il diodo non sarà polarizzato direttamente, mentre quando non sarà polarizzato (interruttore aperto) la corrente non passerà più attraverso il transistor, ma attraverso il diodo polarizzato direttamente.

Realizzazione del circuito

Il NEMA 17 richiede un’alimentazione tipica di 12V. La rotazione completa di 360° del rotore si ottiene facendo compiere 200 passi al motore. Ogni passo corrisponderà ad un angolo di 1,8°. La velocità massima che questo tipo di motore può raggiungere è di 60 RPM (dall’inglese revolutions per minute in italiano rotazioni per minuto giri/min).

Prima di collegare il motore alla scheda motori è necessario individuare i cavi A+, A-, B+ e B- sul motore. La maniera migliore è quella di consultare la scheda tecnica del motore in cui vi è una corrispondenza tra colore filo e cavo. In alternativa potete utilizzare un multimetro in modalità ohmmetro e misurare la resistenza tra le coppie dei cavi, quando misurerete un valore tra i 2 e i 4 ohm tra due terminali avrete individuato una delle bobine.

Collegare l’alimentazione esterna a 12V al terminale VCC e mantenere posizionare i jumper (i ponticelli) ENA ed ENB come indicato nell’immagine che segue in modo che il motore passo passo sia sempre abilitato al funzionamento.

Effettuare il collegamento dei pin di ingresso (IN1, IN2, IN3 e IN4) del modulo L298N a quattro pin di uscita digitale Arduino, nell’esempio sono stati utilizzati i pin: 8, 9, 10 e 11.

Collegare i fili A +, A-, B + e B- dal motore passo-passo al modulo come mostrato nell’immagine che segue.

Lo sketch indicato di seguito, che potrete utilizzare come base di partenza per le vostre sperimentazioni, permetterà di controllare il motore passo-passo facendogli compiere ripetutamente un giro in senso orario ed uno in senso antiorario.

// Inclusione della libreria stopper
#include <Stepper.h>

// Numero di step (passi) per effettuare una rotazione completa
const int stepPerRotazione = 200;

// Creazione dell’istanza dello Stepper
Stepper mioStepper(stepPerRotazione, 8, 9, 10, 11);

void setup()
{
    // impostazione della rotazione a 60 rpm:
    mioStepper.setSpeed(60);
    // inizializzazione della porta seriale:
    Serial.begin(9600);
}

void loop()
{
    // una rotazione in una direzione
    Serial.println("Rotazione oraria");
    mioStepper.step(stepPerRotazione);
    delay(500);

    // una rotazione in una direzione
    Serial.println("Rotazione antioraria");
    mioStepper.step(-stepPerRotazione);
    delay(500);
}

Questo sketch include la libreria Stepper https://www.arduino.cc/en/Reference/Stepper.
La libreria avrà il compito di sequenziare gli impulsi verranno inviati al motore stepper.

// Inclusione della libreria stopper
#include <Stepper.h>

Definizione della variabile stepPerRotazione che stabilisce il numero di passi per un’intera rivoluzione, in questo caso 200 che corrispondono a 1,8 gradi per passo.

// Numero di step (passi) per effettuare una rotazione completa
const int stepPerRotazione = 200;

Creazione di un’istanza della libreria stepper. La creazione dell’istanza prevede l’indicazione del numero di step per rivoluzione e l’indicazione dei 4 pin digitali di Arduino a cui dovranno essere collegati i pin IN1, IN2, IN3, IN4 della scheda L298N.

// Creazione dell’istanza dello Stepper
Stepper mioStepper(stepPerRotazione, 8, 9, 10, 11);

Nel setup:

  • impostiamo la velocità del motore passo-passo invocando la funzione setSpeed()
  • impostiamo la velocità di comunicazione della Serial Monitor
void setup()
{
    // impostazione della rotazione a 60 rpm:
    mioStepper.setSpeed(60);
    // inizializzazione della porta seriale:
    Serial.begin(9600);
}

Nel loop() invochiamo la funzione step() che permette di stabilire il numero di passi, valori negativi consentono di invertire il senso di rotazione del motore.

void loop()
{
    // una rotazione in una direzione
    Serial.println("Rotazione oraria");
    mioStepper.step(stepPerRotazione);
    delay(500);

    // una rotazione in una direzione
    Serial.println("Rotazione antioraria");
    mioStepper.step(-stepPerRotazione);
    delay(500);
}

Esercizi per i miei studenti

Esercizio 1
Realizzare un sistema che permetta la marcia e l’arresto del motore passo passo mediante l’uso di due pulsanti.

Esercizio 2
Realizzare un sistema che permetta la marci e l’arresto ed il controllo del senso di rotazione del motore. Usare pulsanti per il controllo della marcia e dell’arresto e dell’inversione di marcia.

Esercizio 3
Realizzare un sistema che mediante serial monitor permetta l’impostazione del numero di rotazioni e del senso di rotazione.

Esercizio 4
Realizzare un sistema che mediante tastierino esterno consenta di impostare il numero di rotazioni del sistema e il senso di rotazione del motore.
Utilizzare un display 16×2 I2C da usare per messaggi e allarmi.

Sul display dovrà essere visualizzato:

  • Numero di giri in tempo reale
  • Passi del motore
  • Senso di rotazione

Esercizio 5
Svolgere le stesse funzionalità dell’esercizio 4 ed aggiungere un sensore di temperatura TPM36 che superato un valore limite di temperatura di riscaldamento del motore passo passo attivi una ventola che lo raffreddi riportando la temperatura nel range di sicurezza stabilito, cessato l’allarme la ventola di raffreddamento si deve fermare.

ATOM Matrix tra le mie mani


Come sicuramente avrete notato sto sperimentando in questi mesi l’uso dei prodotti M5Stack, ne ho acquistati diversi perché credo che abbiano caratteristiche tecniche che possono essere ben sfruttate in campo didattico, ne sto valutando le potenzialità ed integrazione con il curricolo scolastico in ogni ordine di scuola., ne ho acquistati diversi perché credo che abbiano caratteristiche tecniche che possono essere ben sfruttate in campo didattico, ne sto valutando le potenzialità ed integrazione con il curricolo scolastico in ogni ordine di scuola.

Ho ricevuto da qualche giorno il nuovissimo Atom Matrix la scheda più piccola prodotta da M5Stack, ha una dimensione di 24×24 mm, dispone di una GPIO da 6 pin. Atom Matrix è adatto per lo sviluppo di dispositivi embedded di piccole dimensioni.

Il cuore del dispositivo è un microcontrollore ESP32-PICO-D4, dispone di 4 MB di memoria flash, Wi-Fi e Bluetooth SPI integrata, IMU (MPU6886 ) ed un’interfaccia PH2.0. Sono disponibili un led infrarosso ed una matrice LED RGB 5×5 nella parte frontale. Come sistema di input è possibile utilizzare un pulsante programmabile disposto sotto la matrice di LED, quindi per essere utilizzato dovrete fisicamente premere sul display. E’ presente una porta USB-C utilizzabile per l’upload e l’esecuzione dei programmi ed una porta GROVE.

Atom Matrix si programma con l’IDE Arduino installando un’apposita libreria indicata nel video allegato

Caratteristiche

  • USB Type-C
  • ESP32 PICO-based
  • 4 MByte flash
  • 1 pulsante programmabile
  • matrice led 5×5 RGB LED
  • LED infrarosso
  • Pulsante di reset
  • Antenna 2.4G SMD: Proant 440
  • IMU: MPU6886
  • GPIO da 6 pin (Dupont Pins)
  • interfaccia PH2.0 4Pin
  • Piattaforma di programmazione: Arduino
  • Dimensione:24 x 24 x 14mm
  • Peso: 1g

Caratteristiche ESP32

  • 240 MHz dual core Tensilica LX6 microcontroller da 600 DMIPS
  • Memoria integrata 520 KB SRAM
  • 802.11b/g/n HT40 Wi-Fi transceiver, baseband, stack e LWIP integrati
  • Bluetooth dual mode integrato (classic e BLE)
  • Hall sensor
  • interfaccia capacitiva touch 10x
  • Quarzo da 32 kHz
  • PWM/timer input/output disponibile su ogni pin GPIO
  • SDIO master/salve 50MHz
  • supporto SD-card

Per poter aggiornate il firmware del prodotto è indispensabile utilizzare l’applicativo EasyLoader, attualmente disponibile solo per piattaforma Windows.

Dopo aver scaricato il software fate doppio clic sull’applicazione per eseguirla, collegate ATOM Matrix al computer tramite il cavo USB C ed impostate la velocità di comunicazione che per questo dispositivo è di 750000 o 115200.

Riferimenti PIN

RGB Led – G27
Btn – G39
IR – G12
SCL – G21
SDA – G25

La pagina di riferimento su GitHub è: https://github.com/m5stack/M5Atom
da cui potrete scaricare anche il programma: Atom pixel tool che permette di disegnare caratteri ed icone ed inviarli direttamente sul display.

Allego il video tutorial che mostra come configurare l’IDE Arduino per poter utilizzare ATOM Matrix

Realizzerò in prossimi post esempi di utilizzo.

Buon Making a tutti 🙂

Disegnare caratteri personalizzati con Arduino per un LCD 16×2

Durante le attività di sperimentazione capita spesso la necessità di utilizzare caratteri speciali o icone che non fanno parte del set di caratteri ASCII standard (https://www.asciitable.com) visualizzatili su un display 16×2. Ovviamente un display LCD 16×2 non permette risoluzioni elevate, ma la qualità che si riesce ad ottenere è più che accettabile.

Tutti i display LCD basati sul controller Hitachi HD44780 hanno due tipi di memorie in cui vengono memorizzati i caratteri: CGROM e CGRAM (Character Generator ROM & RAM). La memoria CGROM non è volatile e non può essere modificata mentre la memoria CGRAM è volatile e può essere modificata in qualsiasi momento.

CGROM è usato per memorizzare tutti i caratteri permanenti che possono essere visualizzati usando il loro codice ASCII. Ad esempio, se scriviamo 0x4D, sul display viene visualizzato il carattere “M”. CGRAM è un’altra memoria che può essere utilizzata per la memorizzazione di caratteri definiti dall’utente.

Questa RAM è limitata a 64 byte, cioè implica che per LCD a 5 × 8 pixel come LCD 16×2 Hitachi HD44780, nel CGRAM possono essere memorizzati fino a 8 caratteri definiti dall’utente.

Un carattere sul display viene realizzato utilizzando una matrice di pixel 5 × 8, quindi per definire un nostro carattere dovremo lavorare in quest’area.

La definizione del carattere personale avviene utilizzando la funzione createChar() della libreria LiquidCrystal.

Prima di utilizzare la libreria createChar() è necessario impostare un array di 8 byte ed ognuno di essi definisce una riga della matrice costituita dalla lettera b che definisce il tipo del dato (byte) e la serie di 1 e 0 definiscono i pixel attivi o disattivi: nell’array i bit a 1 indicano i pixel attivi, mentre gli 0 indicano i pixel disattivi.

Nell’esempio che segue viene utilizzato un display 16×2 i2c

Per quanto riguarda la libreria LiquidCrystal_I2C vi rimando alla lezione:
Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Nel caso abbiate necessità di sviluppare in modo più semplice ed agevole i vostri caratteri personalizzati potete utilizzare una soluzione grafica che immediatamente vi permettessi impostare l’array di byte, fate riferimento a questi due link:

da cui ho realizzato velocemente le icone, il codice corrispondenti è poi stato inserito all’interno dello sketch come si può evincere dallo sketch che segue:

/*
 *  Prof. Michele Maffucci
 *  Crezione di caratteri personali
 *  Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 *  con modulo i2C PCF8574T
 *  Data: 17.01.2020 - v01
*/

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

// inizializzazione della libreria in cui è descritta la modalità di utilizzo dei pin
LiquidCrystal_I2C lcd(0x27, 16, 2); // impostazione dell'indirizzo dell'LCD 0x27 di 16 caratteri e 2 linee

// caratteri personalizzati

byte lucchettoChiuso[8] = {
  0b01110,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte lucchettoAperto[8] = {
  0b01110,
  0b10000,
  0b10000,
  0b10000,
  0b11111,
  0b11011,
  0b11011,
  0b11111
};

byte Altoparlante[8] = {
  0b00001,
  0b00011,
  0b01111,
  0b01111,
  0b01111,
  0b00011,
  0b00001,
  0b00000
};

byte batteriaMezza[8] = {
  0b01110,
  0b11011,
  0b10001,
  0b10001,
  0b10001,
  0b11111,
  0b11111,
  0b11111
};

byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};


byte pacmanBoccaChiusa[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11111,
  0b11000,
  0b11111,
  0b11111,
  0b01110
};

byte pacmanBoccaAperta[8] = {
  0b01110,
  0b11101,
  0b11111,
  0b11100,
  0b11000,
  0b11000,
  0b11111,
  0b01110
};

byte fantasmino[8] = {
  0b01110,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b11111,
  0b11111,
  0b10101
};

void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);

  // Cancella il display
  lcd.clear();

  // Stampa la stringa
  lcd.print("maffucci.it");

}

void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));

}

Dopo aver incluso la libreria, è necessario inizializzare l’array che definisce il carattere personalizzato definito da 8 byte.

...
byte alieno[8] = {
  0b10001,
  0b01010,
  0b11111,
  0b10101,
  0b11111,
  0b11111,
  0b01010,
  0b11011
};
...

Nel setup() bisogna inizializzare il carattere personalizzato mediante la funzione createChar(), che accetta due parametri, il primo, compreso tra  0 e 7 è utilizzato come indirizzo ad uno degli 8 caratteri creati personalizzati, il secondo parametro definisce il nome dell’array di byte che definisce il carattere personalizzato.

  // creazione nuovi caratteri
  lcd.createChar(0, lucchettoChiuso);
  lcd.createChar(1, lucchettoAperto);
  lcd.createChar(2, Altoparlante);
  lcd.createChar(3, batteriaMezza);
  lcd.createChar(4, alieno);
  lcd.createChar(5, pacmanBoccaChiusa);
  lcd.createChar(6, pacmanBoccaAperta);
  lcd.createChar(7, fantasmino);

Successivamente nel loop, per la visualizzazione del carattere personalizzato viene utilizzata la funzione write() che ha come parametro il numero (l’indirizzo) assegnato al carattere.

...
void loop()
{
  lcd.setCursor(0, 1);
  lcd.write(byte(0));

  lcd.setCursor(2, 1);
  lcd.write(byte(1));

  lcd.setCursor(4, 1);
  lcd.write(byte(2));

  lcd.setCursor(6, 1);
  lcd.write(byte(3));

  lcd.setCursor(8, 1);
  lcd.write(byte(4));

  lcd.setCursor(10, 1);
  lcd.write(byte(5));

  lcd.setCursor(12, 1);
  lcd.write(byte(6));

  lcd.setCursor(14, 1);
  lcd.write(byte(7));
}
...

Esercizi per i miei studenti

Esercizio 1

Realizzare uno sketch che mostra un omino che cammina da sinistra verso destra e ritorno, in modo continuo. Il movimento deve essere accompagnato dall’emissione di due note che mettono in evidenza il passo.

Esercizio 2

Realizzare un Pac Man che partendo dalla riga 0 colonna 0 mangi una serie di puntini , scende alla riga 1 colonna 0 e prosegue fino alla riga 1 colonna 15 dove si trova un fantasma che deve essere mangiato. Predisporre un buzzer che emette due tipi di suoni, uno che identifica quando Pac Man mangia un puntino ed uno quando Pac Man mangia il fantasma. Quando il fantasma viene mangiato il display fa un 3 blink e l’azione comincia nuovamente con il Pac Man che si posizione in riga 0 colonna 0.

Esercizio 3

Realizzare un sistema che rilevi il livello di carica di batterie da 1,5V.
Utilizzare 7 icone che definiscono livelli diversi di carica della batteria e a fianco di ogni icona deve anche apparire in modo numerico il valore di tensione misurato.

Esercizio 4

Realizzare uno sketch che valuta in percentuale la quantità di luce in una stanza e la mostra su display mediante numero in percentuale e una barra di livello realizzata con caratteri personalizzati che può aumentare o diminuire in funzione della quantità di luce che colpisce l’LDR.
Mediante la pressione di un pulsante viene attivata la calibrazione del sistema, questa fase dura 5 secondi in cui viene misurate il valore minimo di luce (comprendo con mano il sensore) e valore massimo della luce (togliendo la mano dal sensore). La fase di calibrazione deve essere evidenziato dalla scrittura su display del messaggio: “calibrazione” e icone animate che dovete inventare.

Utilizzare un orologio RTC con Arduino – Modulo Tiny RTC I2C

Scrivo questo post come base di partenza per le sperimentazioni che farò svolgere ai miei studenti nei prossimi giorni sull’uso degli RTC. L’acronimo RTC si riferisce a Real Time Clock, un orologio in tempo reale. Un RTC ed è alla base di moltissime automazioni in cui è indispensabile gestire una serie di processi in funzione di una specifica data e ora, si pensi ad esempio alla semplice gestione dell’illuminazione di un locale oppure alla realizzazione di un data logging o ancora la gestione del condizionamento automatico di un locale in funzione della data e dell’ora.
Ricordo ai miei studenti che nella sessione ordinaria del 2018 dell’esame di maturità per l’indirizzo elettronica ed elettrotecnica, articolazione di automazione, si faceva riferimento ad un sito archeologico in cui erano presenti due locali affrescati in cui era necessario controllare il numero massimo di persone presenti, gestire la temperatura in maniera diversa nel periodo invernale ed estivo ed inoltre doveva essere controllata anche l’umidità relativa.
Erano presenti inoltre domande in riferimento all’illuminazione massima all’interno dei locali ed altri quesiti a cui darete risposta durante le esercitazioni di laboratorio nelle prossime settimane.

Cito parte del testo dell’esame di maturità:


a) la temperatura deve essere mantenuta tra i 6°C e i 12°C nel periodo invernale e tra i 20°C e i 24°C nel periodo estivo; quando la temperatura scende al di sotto dei valori minimi si attivano delle piccole piastre riscaldanti, poste a 1 metro dal pavimento, fino al raggiungimento della temperatura media, mentre se la temperatura è troppo elevata si attiva il sistema di aerazione che al raggiungimento della temperatura media si disattiva;

b) l’umidità relativa deve essere mantenuta nel range 45% ±5% per evitare la proliferazione di muffe; tale livello viene garantito azionando per 10 minuti, se si è fuori dal range, gli aeratori o il sistema di nebulizzazione a pompa posto a muro.

L’obiettivo di questo post è quello di mostrare come gestire un RTC.

Il modulo utilizzato è un Tiny RTC I2C dotato di un integrato DS1307 I2C RTC di cui allego datasheet. Sulla scheda è presente una batteria tampone ricaricabile al litio LIR2032 che permette il funzionamento dell’RTC in assenza di alimentazione esterna, ovvero il mantenimento dell’ora e della data anche quando viene disconnesso dal microcontrollore che lo utilizza.

Il pilotaggio dell’RTC avviene mediante il protocollo I2C, che come già spiegato in precedenti lezioni, permette la comunicazione tra due o più dispositivi I2C utilizzando un bus a due fili più un terzo filo per il riferimento di massa comune a tutti i dispositivi.
Poiché il protocollo I2C utilizza 7 bit per indirizzare il dispositivo sul bus, il numero massimo di dispositivi collegabili sul bus è di 128 dispositivi, però il numero scende a 112 in quanto 16 indirizzi sono riservati.
Il bus è costituito da una linea dati SDA (Serial Data line), una line di clock SCL (Serial Clock line) e come detto sopra al filo di massa comune a tutti i dispositivi.

Per collegare il Tiny RTC I2C si faccia riferimento allo schema che segue:

Per poter pilotare il DS1307 è necessario installare una libreria specifica, ne esistono diverse quella che utilizzeremo sarà quella di Adafruit la RTClib. Installate la libreria: Sketch > Include Library > Manage Libraries

Si aprirà il gestore librerie, nel campo di ricerca inserite il testo RTClib come indicato nell’immagine che segue e procedere con l’installazione dell’ultima versione disponibile:

Al termine dell’installazione apparirà la voce INSTALLED a fianco della libreria installata

Con la libreria vengono resi disponibili una serie di sketch di esempio che potete aprire direttamente da: File > Examples > RTClib.

Aprite lo schetch: DS1307 di seguito indicato:

// Date and time functions using a DS1307 RTC connected via I2C and Wire lib
#include "RTClib.h"

RTC_DS1307 rtc;

char daysOfTheWeek[7][12] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday"};

void setup () {
  while (!Serial); // for Leonardo/Micro/Zero

  Serial.begin(57600);
  if (! rtc.begin()) {
    Serial.println("Couldn't find RTC");
    while (1);
  }

  if (! rtc.isrunning()) {
    Serial.println("RTC is NOT running!");
    // following line sets the RTC to the date & time this sketch was compiled
    // rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
    // This line sets the RTC with an explicit date & time, for example to set
    // January 21, 2014 at 3am you would call:
    // rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));
  }
}

void loop () {
    DateTime now = rtc.now();

    Serial.print(now.year(), DEC);
    Serial.print('/');
    Serial.print(now.month(), DEC);
    Serial.print('/');
    Serial.print(now.day(), DEC);
    Serial.print(" (");
    Serial.print(daysOfTheWeek[now.dayOfTheWeek()]);
    Serial.print(") ");
    Serial.print(now.hour(), DEC);
    Serial.print(':');
    Serial.print(now.minute(), DEC);
    Serial.print(':');
    Serial.print(now.second(), DEC);
    Serial.println();

    Serial.print(" since midnight 1/1/1970 = ");
    Serial.print(now.unixtime());
    Serial.print("s = ");
    Serial.print(now.unixtime() / 86400L);
    Serial.println("d");

    // calculate a date which is 7 days, 12 hours, 30 minutes, and 6 seconds into the future
    DateTime future (now + TimeSpan(7,12,30,6));

    Serial.print(" now + 7d + 12h + 30m + 6s: ");
    Serial.print(future.year(), DEC);
    Serial.print('/');
    Serial.print(future.month(), DEC);
    Serial.print('/');
    Serial.print(future.day(), DEC);
    Serial.print(' ');
    Serial.print(future.hour(), DEC);
    Serial.print(':');
    Serial.print(future.minute(), DEC);
    Serial.print(':');
    Serial.print(future.second(), DEC);
    Serial.println();

    Serial.println();
    delay(3000);
}

Nello sketch sono presenti due righe fondamentali, che risultano commentate e che secondo necessità possiamo decommentare ed utilizzare.

Se desideriamo che l’ora e la data venga impostata non appena viene caricato sulla scheda lo sketch bisogna decommentare la riga:

rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));

che permette di leggere la data e l’ora corrente in cui sono presenti le costanti predefinite all’interno dell’IDE Arduino: DATE e TIME, che si riferiscono alla data e all’ora di compilazione dello sketch, quindi non appena compilate vengono impostate e passate all’orologio che assume queste come data e ora corrente.

Nel caso si desidera impostare manualmente l’ora e la data bisognerà decommentare la riga:

rtc.adjust(DateTime(2014, 1, 21, 3, 0, 0));

inserendo data e ora corrente, ad esempio facendo riferimento alla data 08/01/2020 ore 01:37 dovrete scrivere:

rtc.adjust(DateTime(2020, 1, 8, 1, 37, 0));

La parte restante del codice si occupa di stampare sulla Serial Monitor data e ora corrente. Nel codice è presente una parte in cui viene stampato una data futura ed il numero di secondi trascorsi da una specifica data.

Ricordate che, come specificato nella setup() la seriale è impostata con una velocità di 57600 caratteri al secondo e quindi nella finestra della Serial Monitor dovrete impostare questa velocità per visualizzare il testo:

Questo il risultato:

Per i miei studenti:

Esercizio 1

Convertire nel formato italiano data e ora ottenendo un output come quello indicato nell’immagine che segue:

Esercizio 2

Realizzare uno sketch che permette l’accensione di un led connesso al pin 3 ogni minuto nell’intervallo da 0 a 15 secondi, spento nei restanti secondi all’interno del minuto. Visualizzare sulla Serial Monitor l’ora corrente.

Esercizio 3

Fare in modo che il led dal 50° al 59° secondo incominci a lampeggiare velocemente e nell’intervallo da 0 a 15 secondi sia acceso.

Esercizio 4

Stesse specifiche dell’esercizio 4 però facendo aumentare progressivamente la frequenza di lampeggio del LED all’approssimarsi del 59° secondo.

Buon lavoro 🙂