Archivi tag: arduino

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

Lascia una risposta

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 🙂

Arduino Plate – Quanto può essere utile un pezzo di compensato a scuola?

2 Repliche

La buona riuscita di una lezione in laboratorio dipende da moltissimi fattori, è sufficiente la mancanza di qualche componente elettronico o del filo elettrico e tutto diventa complicato… banale ma essenziale: la somma di tante piccole necessità, all’apparenza banali, rendono possibile avviare velocemente e con ordine un’attività di laboratorio, mi riferisco ad attrezzi ed elettronica di consumo.
Gli spazi sul banco di lavoro molto spesso sono ridotti ed è cosa frequente ritrovarsi componenti sparsi ovunque.
In modo analogo succede nelle esperienze con Arduino ed è tipico a scuola con gli allievi o per tutti i Maker allocare le schede su basi di legno o plexiglas, un Arduino Plate è la prima cosa che qualsiasi appassionato di elettronica realizza.

Basi di sperimentazioni che noi tutti realizziamo, ne esistono di preconfezionate che possiamo acquistare oppure le possiamo costruire, per esempio nell’immagine è mostrata una base di sperimentazione molto grande da 26×36 cm che utilizzo per prototipale velocemente le esercitazioni di laboratorio.

In commercio trovate delle basi di sperimentazioni che includono non solo spazi dedicate a schede e breadboard ma anche sensori ed attuatori, ma per chi incomincia con Arduino, mi riferisco soprattutto agli studenti, bisogna pensare a soluzioni economicamente accettabili e compatibili con le risorse scolastiche, partire quindi da una basetta di legno è più che sufficiente.

Domenica scorsa, durante il viaggio di rientro dalla Maker a Faire di Roma, ho disegnato velocemente una basetta di sperimentazione elettronica semplicissima dotata di una maniglia, fori per alloggiare una scheda Arduino Uno R3, un’area delimitata dove inserire una breadboard da 840 punti ed un’area costituita da 135 fori da 3mm dove fissare altri oggetti funzionali all’attività di sperimentazione.

Ovviamente altro non è che una basetta di legno, ma utile per mantenere ordine.

Su sollecitazione dei miei studenti stiamo pensando a basette che possano alloggiare altre tipologie di schede e che possano essere costituiti da cassetti in cui alloggiare la componentistica elettronica, insomma trasformare il tutto in un mini laboratorio trasportabile.

Questo è la prima azione di un percorso più lungo che sto pensando in cui gli studenti, in attività di project work a scuola progettano e realizzano i propri strumenti di lavoro, azioni credo utili per seminare passione e consapevolezza nel sentirsi soggetti attivi che partecipano alla costruzione del proprio apprendimento anche per miglioramento della scuola. L’idea è far percepire che è bello far parte di una comunità di apprendimento.

Insomma è il primo passo che spero possa portare alla valigetta del Maker per gli studenti. Come sempre per chi lo desidera condivido questo prima bozza che spero possa essere utile e migliorata da altri.

Per prelevare i sorgenti grafici per il taglio laser o la stampa 3D seguire il link su Thingiverse.

Buon Making a tutti 🙂

Errori comuni nell’uso di Arduino: nome istruzioni non corretto, terminazione istruzione, parentesi non chiuse

Lascia una risposta

Gli errori più frequenti sono:

errori nella scrittura del nome delle istruzioni;
punto e virgola alla fine di un’istruzione;
mancanza delle parentesi graffa di apertura o chiusura di un gruppo di istruzioni;
uso scorretto delle parentesi.

Uno qualsiasi dei problemi indicati sopra, come avete notato a lezione, interromperà la compilazione del programma segnalandovi l’errore nell’area di status al fondo della finestra di programmazione.

Prendo come esempio il codice utilizzato questa mattina in laboratorio su cui ho aggiunto io gli errori che ho rilevato nelle scorse lezioni e questa mattina:

Codice non corretto

Riga 8: manca ;
Riga 16: uso scorretto delle parentesi graffe { } da sostituire con parentesi tonde ( )
Riga 19: errore nel nome dell’istruzione: digitalwrite() invece di digitalWrite()
Riga 21: manca parentesi } di chiusura della funzione loop()

Codice corretto

Ognuno di questi errori impedirà la compilazione del vostro programma.
So che all’inizio può essere frustrante cercare gli errori nel codice ed imparare la sintassi di programmazione, ma si tratta di un piccolo scoglio iniziale superato il quale sarete in grado di realizzare progetti sempre più complessi ed interessanti.

All’inizio copiate il codice che ho sviluppato per le lezioni, modificatelo e miglioratelo in questo modo in poco tempo riuscirete a migliorare.

Ricordo inoltre che è buona regola utilizzare le funzioni “Formattazione Automatica” che consente di indentare (far rientrare) il codice in modo da evidenziare meglio la struttura del programma migliorando la leggibilità e mettendo quindi in evidenza la struttura logica del vostro sketch.

Nel caso di dubbi sull’uso di istruzioni e sintassi, utilizzate il comando “Cerca nella Guida”, sarà sufficiente evidenziare nel codice l’istruzione di cui volete informazioni, nell’esempio che segue “digitalWrite” e dal menù “Aiuto > Cerca nella guida” vi verrà mostrato la pagina della guida che fa riferimento all’istruzione cercata.

Compito per i miei studenti:

Leggere gli articoli che seguono in riferimento agli errori comuni nell’uso di Arduino

Messaggio per i miei allivi:

non si diventa Maker facendo un blink con Arduino…
studio e sperimentazione un po’ al giorno tutti i giorni.

P.S.
se non è tuo interesse diventare Maker allora sostiuisci la frase: “non si diventa maker facendo un blink con Arduino…” con la frase “non si ottiene la sufficienza sapendo fare solo un blink con Arduino…”

😉

Arduino: chiarimenti sulla modalità di alimentazione della scheda

1 Replica

Per i miei allievi di 3 Automazione.
Durante le prime sperimentazioni con Arduino molto spesso si incorre in dubbi ed errori riguarda l’alimentazione della scheda, mi preme quindi fare alcune precisazioni prima che le vostre schede personali o quelle della scuola possano rovinarsi ;-).

Riprendo quanto detto a lezione mostrando le mie slide (pagina 15) e affinché ciò non venga dimenticato ricordo che esistono diverse modalità di alimentazione di Arduino:

cavo USB;
batteria esterna;
alimentatore esterno

Come indicato dalle specifiche tecniche della scheda:

la tensione di alimentazione raccomandata può variare dai 7Vcc ai 12 Vcc
la tensioni limite di funzionamento variano dai 6Vcc ai 20Vcc

Ovviamente lavoreremo sempre nell’intervallo raccomandato.

Nel caso si operi con un alimentatore esterno è indispensabile non solo sapere la tensione fornita dall’alimentatore, ma anche la massima corrente erogabile dall’alimentatore.

Tipicamente nelle prime sperimentazioni si utilizzano alimentatori USB per cellulari che possono erogare correnti di diversa entità, in genere si oscilla dai 0,2A ai 0,5A ma si può arrivare anche ad 1A nel caso di un caricatore per iPhone o iPad, ma è possibile trovare caricatori che erogano correnti anche superiori come ad esempio quello dell’immagine che segue di 2A per uno smartphone Asus.

Dati di targa di alcuni alimentatori:

Per alimentare la nostra scheda Arduino UNO R3 sarà sufficiente collegarlo tramite cavo USB all’alimentatore:

Arduino dispone di un Jack di collegamento esterno da 2.1×5 mm (diametro foro interno x diametro foro esterno – foro interno + e foro esterno -) a cui collegare un alimentatore esterno:

Probabilmente se avete acquistato un kit Arduino, originale o compatibile, troverete questo Jack nella vostra confezione a cui è connesso un connettore per batterie da 9V, come quello indicato nell’immagine che segue:

nel caso non fosse presente potete leggere un piccolissimo tutorial che realizzai qualche anno fa per altri studenti: Alimentare Arduino con una batteria da 9V – jack di collegamento

Nel caso non desiderate effettuare saldatura in commercio esistono jack a cui collegare fili di collegamento mediante una morsettiera in cui i cavi vengono serrati con viti oppure a pressione, come indicato nelle immagini che seguono:

Ricordate che la tensione di funzionamento dei componenti sulla scheda Arduino è di 5V, il regolatore di tensione della scheda (nell’immagine che segue indicato dalla freccia rossa) consentirà di riportare a 5V cc tensioni di alimentazione superiore che vengono fornite da un alimentatore esterno, ma questo tipo di lavoro viene trasformato dal regolatore di tensione in calore, infatti in queste condizioni noterete un aumento di temperatura del dispositivo.

In una prossima esercitazione vi mostrerò come, usando un sensore di temperatura esterno, la temperatura del regolatore aumenta all’aumentare della tensione esterna fornita alla scheda.

Tenete in conto però che tensioni di 12VCC o superiori (max 20Vcc) possono essere necessarie nel caso in cui sia necessario alimentare un dispositivo elettrico funzionante a tensioni superiori ai 5VCC che dovrà essere collegato e controllato da Arduino.

In questo caso l’alimentazione per il dispositivo esterno potrebbe essere ricavata dal pin Vin presente sulla scheda, ma ATTENZIONE questa tensione è quella che viene fornita dall’alimentatore esterno, quindi su Vin abbiamo la stessa tensione dell’alimentatore, pertanto bisogna essere certi della tensione necessaria al funzionamento del dispositivo connesso alla Vin.

Per i miei allievi: prima di procedere chiedete 🙂

Domanda: “Prof. ma se non ho il Jack posso alimentare direttamente con una batteria da 9Vcc sul pin Vin?”

Sì è possibile farlo.

Domanda: “Prof. ma a cosa serve il pin 5V?”

Esiste un altro modo per alimentare Arduino, lo segnalo per indicarne la possibilità ma soprattutto i rischi.
Per alimentare la scheda è possibile collegare una tensione stabilizzata di 5Vcc direttamente al pin 5V di Arduino, ma questa procedura è sconsigliata in quanto questa tensione è quella che viene direttamente applicata al microcontrollore e ad altri dispositivi sulla scheda, quindi se non siete assolutamente sicuri che la tensione di alimentazione non sia di 5Vcc evitate la connessione… meglio evitate sempre 🙂

Se per qualche motivo vi trovate in questa condizione siate certi che non sia connessa altra fonte di alimentazione alla scheda Arduino tramite jack o USB della scheda.

Per i miei allievi: prima di procedere chiedete 🙂

Ricapitolando i modi per Alimentare Arduino sono:

Domanda: “Prof. ma a cosa serve il pin 3.3V?”

Risposta: Per esercizio leggere l’articolo: leggere e studiare quanto indicato al seguente link:Livelli logici TTL e CMOS – cosa si nasconde dietro un HIGH o LOW di una digitalWrite di Arduino?

… e poi approfondiamo in classe.

Alcune precisazioni sulla corrente erogata da una fonte di alimentazione.

Domanda: “Prof. ho collegato 10 led per fare l’effetto supercar, ma le batterie si sono subito scaricate! Perché?”

La quantità di corrente erogabile da una batteria è indicata in mAh (milliampere per ora: quantità di corrente che può essere erogata in 1 ora).
Nel caso di una tipica batterie alcalina non ricaricabili da 1,5Vcc AA (modello LR6) la corrente erogata oscilla tra i 2700 e i 3400 mAh

Nel caso in cui si utilizzi una batteria da 9Vcc Alcalina di tipo 6LR61 la capacità tipica è di 565 mAh.

In modo indicativo tenendo conto di un comportamento ideale e lineare delle batterie elettriche possiamo fare le considerazioni che seguono.

Arduino per il suo funzionamento assorbe tipicamente circa 45 mA – 50mA, lo dimostreremo in laboratorio, pertanto per conoscere per quanto tempo possiamo alimentare Arduino con la batteria da 9V indicata sarà sufficiente effettuare il seguente calcolo:

t = corrente erogata dalla batteria in 1 ora/consumo = 565 mAh / 45mA = 12,56 h

Nel caso in cui si utilizzi un pacco batterie costituito da 6 batterie da 1,5V cc collegate in serie per un totale di 9V ciascuna erogante 2700 mAh si avrà un tempo di alimentazione di:

t = capacità della batteria/consumo = 2700 mAh / 45mA = 60 h

tutto ciò ovviamente nel caso in cui non si colleghino altri dispositivi alla scheda Arduino, in caso contrario bisognerà tener conto dell’assorbimento di ogni singolo componente. Ad esempio nel caso di un LED abbiamo assorbimenti che oscillano tra i 15 e i 20 mA, pertanto nel caso della domanda dello studente avremo che 10 LED assorbiranno circa:

10×15 mA = 150 mA

Quindi ai 45 mA di Arduino bisognerà aggiungere i 150 mA dei LED per un totale di 195 mA quindi la durata del pacco batterie scenderà a:

t = capacità della batteria/(consumo Arduino + consumo 10 LED) = 2700 mAh / 195mA = 14 h (circa)

e quindi aggiungendo altri dispositivi aumenterà la corrente che dovrà essere erogata dall’alimentatore.

Ovviamente utilizzando un alimentatore stabilizzato esterno collegato alla rete elettrica potremo avere costantemente alimentazione ed un’erogazione di corrente massima indicata sui dati di targa dell’alimentatore.

Esistono tecniche per porre Arduino in una modalità a basso consumo ma per questo ve ne parlerò più avanti.

Si tenga conto inoltre che nel caso in cui si alimenti Arduino e i circuiti ad esso connesso tramite USB, la corrente massima erogata dalla USB del computer se di tipo USB 1.0 o 2.0 è di 500 mA, nel caso in cui il computer sia fornito di USB 3.0 la corrente massima erogata è di 900 mA.

Domanda: “Prof. ma cosa accade se la corrente assorbita da Arduino e dei dispositivi connessi alla scheda superano i valori limiti di corrente forniti dalla USB del computer?”

Nella maggior parte dei casi il controller USB viene posto, da parte del computer, in una modalità di protezione disattivando la periferica ad esso connessa (nel nostro caso Arduino), questa situazione rimane fino a quando non viene riavviato il computer.-
Nella situazione peggiore, in computer datati si rischia di bruciate il controller USB del computer o della scheda madre.

Domanda: “ Prof. ma cosa succede ad Arduino se in esso circola una corrente superiore ai 500 mA?”

Un assorbimento superiore ai 500 mA non danneggia solamente il computer ma anche Arduino che non può sopportare correnti così elevate.

Per evitare questo rischio sulla scheda Arduino è presente un fusibile termico resettabile noto anche come Termistore o PTC (Positive Temperature Coefficient: resistenza che cresce con l’aumentare della temperatura) che riduce drasticamente la corrente assorbita da Arduino nel caso in cui si superino i 500 mA ponendola quindi in protezione.
Questo fusibile è ben visibile, è collocato di fianco alla presa USB ed è costituito da terminali di color oro:

Nello schema elettrico di Arduino è indicato con F1:

Il fusibile verrà ripristinato automaticamente dopo circa 30 secondi dal momento in cui togliete alimentazione alla scheda Arduino.

Buona sperimentazione a tutti 🙂

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: