Archivi tag: arduino

Arduino – Approfondimenti sulla modulazione di larghezza di impulso (PWM)

Scrivo questo post ad integrazione della lezione: Arduino – lezione 06: modulazione di larghezza di impulso (PWM) che sto utilizzando con i miei studenti di 4′ informatica per illustrare le modulazioni di tipo digitali. L’obiettivo è quello di mostrare sull’oscilloscopio come varia il Duty Cycle di un’onda quadra su un pin di tipo PWM di Arduino utilizzato per impostare l’intensità luminosa di un LED mediante una regolazione applicata attraverso un trimmer connesso al pin A0 di Arduino.

Oltre alla visualizzazione sull’oscilloscopio si desidera, come riscontro, la stampa sulla Serial Monitor dei seguenti valori:

Tensione in input sul pin A0
Valore restituito dalla funzione analogRead() – (tra 0 e 1023)
Valore restituito dall’analogWrite – (tra 0 e 254)
Valore percentuale del Duty Cycle (tra 0% e 100%)

Il circuito da realizzare con l’indicazione delle connessioni all’oscilloscopio è il seguente:

Sul canale X verrà visualizzata l’onda quadra in uscita dal pin 11 il cui Duty Cycle sarà regolato agendo sul trimmer.

Sul canale Y verrà visualizzata la tensione continua in input sul pin A0, che sarà convertita dal convertitore Analogico Digitale di Arduino in un valore compreso tra 0 e 1023 (risoluzione di 10 bit). Ricordo che tale conversione sarà fatta con l’istruzione analogRead(pin).

Poiché uno degli obiettivi è quello di visualizzare la tensione rilevata sul pin A0, ricordo che tale misurazione viene fatta utilizzando la funzione analogRead(pin) che legge il valore di tensione (compreso tra 0 e 5V) applicato sul piedino analogico ‘pin’ con una risoluzione di 10 bit e la converte in un valore numerico compreso tra 0 e 1023, corrispondente quindi ad un intervallo di 1024 valori, pertanto ogni intervallo corrisponde ad un valore di tensione Vu di:

Per sapere quindi il valore di tensione rilevato (nell’intervallo tra 0V e 5V) sarà sufficiente moltiplicare la tensione unitaria Vu per il valore restituito dalla funzione analogRead(pin), valore quantizzato indicato con Vq compreso tra 0 e 1023:

Sapendo che Vu corrisponde a 4,88 mV

possiamo anche scrivere che:

Questa formula sarà inserita all’interno dello sketch.

Di seguito la schermata dell’oscilloscopio che visualizza la situazione indicata dai dati stampati sulla Serial Monitor:

Vmax(2) indica la tensione in ingresso ad A0 (la piccola discrepanza tra valore indicato sull’oscilloscopio e la stampa sulla Serial Monitor dipende dalle approssimazioni di calcolo).
Vmax(1) indica il valore di picco della tensione sul pin 11.

La spiegazione del funzionamento dello sketch sono dettagliate nei commenti:

/* Prof. Michele Maffucci
   03.06.2019
 
   Regolazione luminosità LED mediante
   trimmer, si utilizza la funzione map

   Stampa sulla seriale:
   - del valore di tensione sul pin A0
   - del valore restituito dall'analogRead
   - del valore restituito dall'analogWrite
   - del valore del Duty Cycle %
 
   Questo codice è di dominio pubblico 
*/

// pin analogico su cui inviare la tensione analogica (pin A0)
int misura = 0;

// pin a cui è connesso il LED
int pinLed = 11;

// variabile in cui conservare il valore inserito su A0
long val = 0;

// variabile in cui memorizzare il Duty Cycle
int inputVal = 0;

const long VoltRiferimento = 5.0; // valore di riferimento


void setup(){
  Serial.begin(9600);      // inizializzazione della comunicazione seriale
  pinMode(pinLed, OUTPUT); // definizione di ledPin come output
}

void loop(){
  // analogRead leggerà il valore su A0 restituendo un valore tra 0 e 1023
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Qd
  val = analogRead(misura);

  // analogWrite() accetta come secondo parametro (PWM) valori tra 0 e 254
  // pertanto "rimappiamo" i valori letti da analogRead() nell'intervallo
  // tra 0 e 254 usando la funzione map
  // per approfondimenti si consulti il link: http://wp.me/p4kwmk-1Tu
  inputVal = map(val, 0, 1023, 0, 254);
  
  // accendiamo il LED con un valore del Duty Cycle pari a val
  analogWrite(pinLed,inputVal);

  // Tensione inviata sul pin analogico A0.
  // Valore in virgola mobile.

  float volt = (VoltRiferimento/1024.0)*val;

  // visualizzazione il valore della tensione su A0,
  // del valore restituito dalla analogRead,
  // del valore restituito dall'analogWrite
  // e del Duty Cycle %

  // per approfondimenti sull'uso di String si consulti il link: https://www.arduino.cc/reference/en/language/variables/data-types/stringobject/
  
  Serial.println(String("Tensione su A0: ") + volt + "V" + String(";  ") + "analogRead: " + val + String(";  ") + String("Valore analogWrite: ") + inputVal + String("; ") + String("Duty Cycle %: ") + (inputVal/255.0)*100 + String("%;"));
  delay(500); // stampa una strina di valori ogni mezzo secondo
}

Buon Coding a tutti 🙂

Appunti di programmazione su Arduino: esercizi di approfondimento su istruzione switch..case, display a 7 segmenti, Serial.read

Lascia una risposta

Durante le scorse settimane ho svolto una serie di esercitazioni di laboratorio che avevano l’obiettivo di insegnare l’uso dell’istruzione switch…case e la modalità di ricezione dati seriali in Arduino.

La prima lezione è introdotta nel post:

Appunti di programmazione su Arduino: controllo di flusso – istruzione switch..case

Nell’articolo trovate due link che fanno riferimento a due guide sul sito Arduino in cui viene mostrato come utilizzando l’istruzione switch…case:

per inviare un output specifico sulla Serial monitor in funzione del valore letto dal sensore;
usare la Serial input per accendere uno specifico LED.

La seconda lezione è basata sul tutorial:

Arduino – lezione 08: display a 7 segmenti e creazione di librerie

In cui viene mostrato come pilotare un display a 7 segmenti realizzando un contatore da 0 a 9, e cicli di visualizzazione di numeri pari e numeri dispari. Nella parte finale del tutorial viene mostrato come realizzare una libreria dedicata alla gestione del display a 7 segmenti.

La terza lezione mostra come ricevere dati dalla seriale in Arduino.

Per questa parte è indispensabile svolgere le esercitazioni che trovate nelle slide:

Alfabeto di Arduino – Lezione 3 da pagina 53 a pagina 62

Successivamente aggiungo gli esercizi che di seguito condivido, in cui riprendendo la gestione del display a 7 segmenti, però questa volta inviamo dati dal computer mediante la tastiera al display comandato da Arduino.

Per lo svolgimento di questa parte è necessario effettuare una piccola variazione rispetto al circuito mostrato in: Arduino – lezione 08: display a 7 segmenti e creazione di librerie in questa lezione volutamente utilizzo tra tutti i pin il piedino 1 di Arduino che viene utilizzato normalmente come pin TX e ciò provoca un comportamento anomalo di accensione del LED e del display, ciò mi permette di spiegare l’utilizzo dei pin 0 e 1 di Arduino.

Il circuito da realizzare per la terza lezione è il seguente (i pin di controllo di Arduino sono presi in maniera sequenziale dal pin 6 al pin 12)

Esercitazione 1

Realizzare un contasecondi da 0 a 9 utilizzando un display 7 segmenti a catodo comune

Soluzione

// Prof. Michele Maffucci
// 14.04.2019

// Conteggio 9 secondi con display 7 segmenti a catodo comune

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a=12;
const int b=11;
const int c=10;
const int d=9;
const int e=8;                           
const int f=7;
const int g=6;

// variabile che definisce la velocità con cui appaiono i numeri
const int pausa = 1000;

void setup()
{
  // inizializzazione dei pin ad OUTPUT
  for (int i=6; i<13; i++) {
    pinMode(i, OUTPUT); 
  }
}

void loop ()
{
  for (int i=0;i<10;i++) 
  {
    LedAcceso(i);
    delay (pausa);
  }
}

void LedAcceso(int n)
{
  switch(n)
  {
  case 0:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, LOW);
    break;

  case 1:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 2:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, LOW); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;
  case 3:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, HIGH);
    break;

  case 4:
    digitalWrite(a, LOW);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 5:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 6:
    digitalWrite(a, HIGH);
    digitalWrite(b, LOW);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 7:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, LOW); 
    digitalWrite(e, LOW);
    digitalWrite(f, LOW);
    digitalWrite(g, LOW);
    break;

  case 8:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, HIGH);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;

  case 9:
    digitalWrite(a, HIGH);
    digitalWrite(b, HIGH);
    digitalWrite(c, HIGH); 
    digitalWrite(d, HIGH); 
    digitalWrite(e, LOW);
    digitalWrite(f, HIGH);
    digitalWrite(g, HIGH);
    break;
  }
}

Esercitazione 2

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviene quando si preme invio.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;
      
    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

Esercitazione 3

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f 

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;
  }
}

Esercitazione 4

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  for (int i = 0; i < 6; i++) {
      digitalWrite(a, HIGH);
      delay(intervallo);
      digitalWrite(a, LOW);
      delay(intervallo);
      digitalWrite(b, HIGH);
      delay(intervallo);
      digitalWrite(b, LOW);
      delay(intervallo);      
      digitalWrite(c, HIGH);
      delay(intervallo);
      digitalWrite(c, LOW);
      delay(intervallo);      
      digitalWrite(d, HIGH);
      delay(intervallo); 
      digitalWrite(d, LOW);
      delay(intervallo);      
      digitalWrite(e, HIGH);
      delay(intervallo);
      digitalWrite(e, LOW);
      delay(intervallo);      
      digitalWrite(f, HIGH);
      delay(intervallo);
      digitalWrite(f, LOW);
      delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      digitalWrite(a, LOW);
      digitalWrite(b, LOW);
      digitalWrite(c, LOW);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      roll();
  }
}

Esercitazione 5

Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9.
La scrittura avviene quando viene premuto l’invio della tastiera.
All’avvio del programma deve essere mostrato un gioco di luci con accensione e spegnimento veloce in sequenza dei led: a, b, c, d, e, f del display.
Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

void roll() {
  // spegnimento di tutti i led del display
  digitalWrite(a, LOW);
  digitalWrite(b, LOW);
  digitalWrite(c, LOW);
  digitalWrite(d, LOW);
  digitalWrite(e, LOW);
  digitalWrite(f, LOW);
  digitalWrite(g, LOW);

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    digitalWrite(a, HIGH);
    delay(intervallo);
    digitalWrite(a, LOW);
    delay(intervallo);
    digitalWrite(b, HIGH);
    delay(intervallo);
    digitalWrite(b, LOW);
    delay(intervallo);
    digitalWrite(c, HIGH);
    delay(intervallo);
    digitalWrite(c, LOW);
    delay(intervallo);
    digitalWrite(d, HIGH);
    delay(intervallo);
    digitalWrite(d, LOW);
    delay(intervallo);
    digitalWrite(e, HIGH);
    delay(intervallo);
    digitalWrite(e, LOW);
    delay(intervallo);
    digitalWrite(f, HIGH);
    delay(intervallo);
    digitalWrite(f, LOW);
    delay(intervallo);
  }
}

void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

Esercitazione 6

Realizzare le stesse funzionalità dell’esercizio 5 ma ottimizzare la funzione roll() in modo che lo spegnimento iniziale dei LED sia costituito da un ciclo for e l’accensione e lo spegnimento sequenziale sia realizzato da due cicli for annidati.

Soluzione

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione in cui la funzione roll() è stata ottimizzata
// Lo spegnimento iniziale dei LED è costituito da un ciclo for e l'accensione e lo spegnimento sequenziale
// è realizzato da due cicli for annidati.

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}


void loop()
{
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int m = 0; m < 6; m++) {
    for (int p = 12; p > 6; p--) {
      digitalWrite(p, HIGH);
      delay(intervallo);
      digitalWrite(p, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

Esercitazione 7

Realizzare le stesse funzionalità dell’esercizio 6 realizzando una libreria di gestione “LedAcceso.h” richiamata dallo sketch principale. Per l’esecuzione di questo esercizio seguire le indicazioni fornite al fondo del tutorial: Arduino – lezione 08: display a 7 segmenti e creazione di librerie

Soluzione

LedAcceso.cpp

/* display_sette_segmenti.cpp
libreria che consente il controllo di un display a 7 segmenti a catodo comune
del tipo HDSP 5503
*/

#include "Arduino.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

// funzione per gioco di luci
void roll() {

  // spegnimento di tutti i led del display
  for (int i = 6; i < 13; i++) {
    digitalWrite(i, LOW);
  }

  // ciclo di sei accensioni e spegnimenti dei led a, b, c, d, e, f
  for (int i = 0; i < 6; i++) {
    for (int j = 12; j > 6; j--) {
      digitalWrite(j, HIGH);
      delay(intervallo);
      digitalWrite(j, LOW);
      delay(intervallo);
    }
  }
}

// la funzione LedAcceso prende come input il carattere numerico che deve essere mostrato su display
// prima che venga stampato il numero viene eseguita la funzione roll()
void LedAcceso(int n)
{
  switch (n)
  {
    case '0':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, LOW);
      break;

    case '1':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '2':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, LOW);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '3':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, HIGH);
      break;

    case '4':
      roll();
      digitalWrite(a, LOW);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '5':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '6':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, LOW);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '7':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, LOW);
      digitalWrite(e, LOW);
      digitalWrite(f, LOW);
      digitalWrite(g, LOW);
      break;

    case '8':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, HIGH);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    case '9':
      roll();
      digitalWrite(a, HIGH);
      digitalWrite(b, HIGH);
      digitalWrite(c, HIGH);
      digitalWrite(d, HIGH);
      digitalWrite(e, LOW);
      digitalWrite(f, HIGH);
      digitalWrite(g, HIGH);
      break;

    default:
      roll();
  }
}

LedAcceso.h

/* LedAcceso.h
   header file della libreria LedAcceso
*/
 
#include "Arduino.h"
 
void LedAcceso(int n);  // prototipo della funzione
void roll();            // prototipo della funzione

sketch

// Prof. Michele Maffucci
// 14.04.2019
// Scrittura mediante tastiera (su serial monitor) di un numero da 0 a 9
// La scrittura avviena quando si preme invio.
// All'avvio del programma gioco di luci con accensione veloce dei led: a, b, c, d, e, f
// Alla pressione di un tasto diverso dai numeri da 0 a 9, gioco di luci e spegnimento del display.
// Alla pressione di un numero da 0 a 9 prima della comparsa del numero mostrare gioco di luci

// Versione con inclusione della libreria di gestione dell'accensione del display

// definizione delle variabili a cui collegare ogni segmento del display
// la lettera rappresenta il segmento del display il numero il pin
// digitale di Arduino a cui è collegato il corrispondente pin del display

#include "LedAcceso.h"

const int a = 12;
const int b = 11;
const int c = 10;
const int d = 9;
const int e = 8;
const int f = 7;
const int g = 6;

const int intervallo = 10;

void setup()
{
  // inizializzazione della seriale
  Serial.begin(9600);

  // inizializzazione dei pin ad OUTPUT
  for (int i = 6; i < 13; i++) {
    pinMode(i, OUTPUT);
  }
  roll();
}

void loop()
{
  // verifica se sulla serial monitor è presente un carattere,
  // se la condizione è vera viene letto il carattere presente sulla serial monitor
  if (Serial.available()) {
    int selettore = Serial.read();
    LedAcceso(selettore);
  }
}

Buon Coding a tutti 🙂

Appunti di programmazione su Arduino: controllo di flusso – istruzione switch..case

Lascia una risposta

Nella scorsa settimana e in quella che verrà, con gli allievi di 3A e 3B Automazione ho svolto e svolgerò alcune esercitazioni sul controllo di flusso per gestire valori provenienti da sensori e controllare l’attivazione di motori elettrici mediante tastiera del computer e tastierino numerico esterno. Al fine di approfondire l’uso in C del controllo di flusso aggiungo alcune informazioni aggiuntive sull’uso dell’istruzione switch..case, per le altre istruzioni sul controllo di flusso si consulti su questo sito la sezione: Usare Arduino -> Appunti di Programmazione -> controllo di flusso

Come accade per l’istruzione if, l’istruzione switch…case, che viene chiamata anche istruzione di selezione multipla, permette il controllo di flusso dei vostri programmi permettendo di specificare porzioni diverse di codice da eseguire in funzione di una serie di condizioni impostate.

In particolare, l’istruzione switch (interruttore) confronta il valore intero costante con i valori specificati nelle etichetta case (caso). Quando viene trovata un’istruzione case il cui valore corrisponde a quello passato dallo switch, viene eseguito il codice contenuto nel case.

Nel caso in cui non venga riscontrata nessuna occorrenza del valore passato dalla switch, sarà eseguita la sezione default.

L’istruzione break consente l’uscita dall’istruzione switch e viene in genere utilizzata alla fine di ogni case, portando il controllo del programma a continuare con la prima istruzione dopo l’istruzione switch.

Nel caso in cui il break non venga inserita all’interno del case, l’istruzione switch continuerà ad eseguire le istruzioni che seguono, comportamento che viene chiamato “falling-through”, fino all’interruzione o alla fine dell’istruzione switch.

Nel caso in cui il break non fosse inserito in ognuno dei case, ogni volta che fosse incontrata una corrispondenza con uno dei case, verrebbero eseguite anche tutte le istruzioni dei case rimanenti, nel caso in cui non venga riscontrata nessuna occorrenza del valore passato dalla switch, sarà eseguita la sezione default e successivamente visualizzato un messaggio di errore.

Si faccia attenzione che quando si utilizza il comando switch, ogni singolo case può essere utilizzato solamente per controllare una espressione intera costante, cioè ogni combinazione di costanti di carattere e interi che possono essere valutati come valori interi, le costanti intere sono semplicemente dei valori interi ed una variabile di tipo carattere è rappresentata con il carattere specifico posto tra apici singoli, come ‘M’. Si ricordi che i caratteri sono in realtà dei valori interi memorizzati in un byte.

Sintassi

switch (variabile) { 
   case label:
   // istruzioni
   break;
case label:
   // istruzioni
   break;
default: 
   // istruzioni
   break;
}

Vi rimando al reference on-line sul sito di Arduino per analizzare alcuni esempi che svilupperemo con ulteriori esercitazioni tratte dalle mie slide e che svolgeremo a lezioni:

Buon lavoro 🙂

Utilizzo dell’LCD 16×2 Hitachi HD44780 1602 con modulo I2C PCF8574T

Lascia una risposta

Addendum al progetto EduRobot.

Una settimana è bastata per scatenare la fantasia di giovani studenti alle prese con EduRobot per l’attività di Alternanza Scuola Lavoro. Le relazioni di lavoro mettono in evidenza soluzioni alternative originali, la richiesta è di continuare ad aggiungere funzionalità ad EduRobot, vedremo nelle prossime settimane come proseguire con i lavori, ma sicuramente in questa prima fase mi posso ritenere soddisfatto! 😊

Tra le richieste che mi sono state fatte vi è quella di inserire un display per aggiungere interattività con il robot. Tra le possibilità ho suggerito l’utilizzo di un LCD 16×2 Hitachi HD44780 1602 quelli in dotazione con molti kit Arduino. Per rendere più agevole la gestione e i collegamenti, visto l’elevato numero di connessioni presenti su EduRobot, ho consigliato l’utilizzo di un modulo PCF8574T per il controllo in I2C, poiché gli studenti sono giovani ed ancora non hanno affrontato questo argomento, con questo post voglio dare un piccolo aiuto.

Disponiamo dei moduli della sunfounder su cui è già saldato il modulo i2C:

l’utilizzo è identico ai più comuni expander esterni come quelli indicati nell’immagine che segue:

Il display è costituito da 4 pin di connessione, due dedicati all’alimentazione e due alla comunicazione i2C.

Le connessioni tra LCD1602 i2C ed Arduino sono i seguenti:

LCD1602 —> Arduino
GND -> GND
Vcc -> 5V
SDA -> A4
SCL -> A5

Per poter utilizzare questo display è necessario installare la libreria LiquidCrystal_I2C dal seguente link: https://github.com/fdebrabander/Arduino-LiquidCrystal-I2C-library

Prelevate il file .zip ed installate la libreria direttamente dall’IDE di Arduino:

in alternativa potete scompattare e copiare il tutto nella cartella libraries di Arduino.

Piccolo avvertimento, sicuramente nelle vostre sperimentazioni prenderete spunto da sketch che troverete on-line, alcune volte questi esempi sono datati e si riferiscono ad una versione dell’ide di qualche anno fa in cui si poteva inizializzare l’LCD nel setup con: lcd.init(), ciò non è più possibile sostituitela con la classe lcd.begin() così come indicato negli esempi che seguono.

Includo a questo post una serie di sketch tutti tratti dal reference di Arduino e riadattati per un uso con il modulo PCF8574T in modo da accelerare le attività di sperimentazione dei miei allievi.

Il funzionamento di ogni esempio è dettagliato con commenti all’interno degli sketch.

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 1: scrittura testo su due righe
 */

#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
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
}
//-----------------------------


void loop()
{
  lcd.setCursor(2,0);
  lcd.print("Ciao Ragazzi");
  lcd.setCursor(0,1);
  lcd.print("Io sono EduRobot");
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 2: noBlink - Blink
 */

#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
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
}
//-----------------------------

void loop() {
  // Turn off the blinking cursor:
  lcd.noBlink();
  delay(3000);
  // Turn on the blinking cursor:
  lcd.blink();
  delay(3000);
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 3: noDisplay - Display
 */

#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
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
  lcd.print("EduRobot");
}
//-----------------------------

void loop() {
  // disattiva il display
  lcd.noDisplay();
  delay(500);
  // attiva il display
  lcd.display();
  delay(500);
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 4: scrollDisplayLeft() - scrollDisplayRight()
 */

#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
//-----------------------------
void setup()
{
  lcd.begin();      // inizializzazione dell'LCD
  lcd.backlight();  // attivazione della retroilluminazione
  lcd.print("EduRobot");
  delay(1000);
}
//-----------------------------

void loop() {
  // sposta di 8 posizioni (lunghezza della tringa: EduRobot) a sinistra
  for (int positionCounter = 0; positionCounter < 8; positionCounter++) {
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    lcd.scrollDisplayLeft();
    // aspetta un momento:
    delay(150);
  }

  // sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a destra
  for (int positionCounter = 0; positionCounter < 24; positionCounter++) {
    // sposta di una posizione a destra
    lcd.scrollDisplayRight();
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    delay(150);
  }

  // sposta di 24 posizioni (lunghezza della tringa + lunghezza del siplay(n. colonne)) a sinistra
  // to move it back to center:
  for (int positionCounter = 0; positionCounter < 24; positionCounter++) {
    // sposta di una posizione a sinistra
    lcd.scrollDisplayLeft();
    // per far percepire la variazione di posizione del testo mettiamo in pausa per un breve istante
    delay(150);
  }

  // al termine di un ciclo di uno spostamento destra e sinistra
  // attesa di 1 secondo
  delay(1000);
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 5: Serial Input
 */

#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
//-----------------------------
void setup()
{
  lcd.begin();        // inizializzazione dell'LCD
  lcd.backlight();    // attivazione della retroilluminazione
  Serial.begin(9600); // inizializzazione della porta seriale
}
//-----------------------------


void loop() {
  // quando un carattere viene inviato alla serial monitor...
  if (Serial.available()) {
    // attende un momento prima di inviare il testo sulla seril monitor
    delay(100);
    // cancella lo schermo
    lcd.clear();
    // legge tutti i caratteri disponibili sulla seriale
    while (Serial.available() > 0) {
      // visualizza i caratteri sul display
      lcd.write(Serial.read());
    }
  }
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 6: setCursor()
 */

#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
//-----------------------------

const int numRows = 2;
const int numColonne = 16;

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


void loop() {
  // stampa in loop i caratteri ASCII da 'a' a 'z':
  for (int lettera = 'a'; lettera <= 'z'; lettera++) {
    // ciclo per le colonne
    for (int  riga = 0; riga < numRows; riga++) {
      // ciclo per le righe
      for (int colonna = 0; colonna < numColonne; colonna++) {
        // imposta la posizione del cursore
        lcd.setCursor(colonna, riga);
        // stama il carattere
        lcd.write(lettera);
        delay(200);
      }
    }
  }
}

/* Prof. Michele Maffucci
 * Utilizzo di un display LCD 16×2 Hitachi HD44780 1602
 * con modulo i2C PCF8574T
 * Esempio 7: leftToRight() - rightToLeft()
 */

#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
//-----------------------------

int lettera = 'a';

void setup()
{
  lcd.begin();        // inizializzazione dell'LCD
  lcd.backlight();    // attivazione della retroilluminazione
  lcd.cursor();       // attiva il cursore
}
//-----------------------------


void loop() {
  // cambia direzione (da destra a sinistra)
  // quando l'ultima lettera stampata è la 'm':
  if (lettera == 'm') {
    // sposta il cursore a destra per stampare la lettera successiva
    lcd.rightToLeft();
  }
  // cambia direzione (da sinistra a destra)
  // // quando l'ultima lettera stampata è la 's':
  if (lettera == 's') {
    // sposta il cursore a sinistra per stampare la lettera successiva
    lcd.leftToRight();
  }
  // reset quando atriviamo alla 'z':
  if (lettera > 'z') {
    // spostare il cursore a (0,0):
    lcd.home();
    // ricomincia dalla posizione 0
    lettera = 'a';
  }
  // stampa il carattere
  lcd.write(lettera);
  // aspetta un secondo
  delay(1000);
  // incrementa la lettera
  lettera++;
}

Buona sperimentazione 🙂

Errori comuni nell’uso di Arduino – confondere pin analogici con pin digitali

Lascia una risposta

Come sicuramente saprete i pin analogici di Arduino UNO, da A0 a A5 possono essere utilizzati anche in modalità digitale e questa caratteristica alcune volte crea qualche confusione in quanto i pin se vengono utilizzati in modalità analogica non è necessario dichiararne il pinMode all’interno del setup(), ciò ovviamente non accade se bisogna usarli in modalità digitale.
Dopo un po’ questa funzionalità viene memorizzata, un modo per non dimenticare questa caratteristica potrebbe essere quella di inserire una dichiarazione “inutile” che ne rammenta la modalità di utilizzo:

void setup() {
   Serial.begin(9600);
   analogRead(A2); // Sensore di luminosità
   pinMode(13, OUTPUT);
   pinMode(2, INPUT);
}

In ogni caso, per i miei studenti chiedo di ricordare a mente senza aggiungere dichiarazioni inutili, ma se si è all’inizio tale notazione può essere accettata.

Un’altra cosa che noto confonde è l’uso della notazione Ax per i pin digitali e non del valore decimale.
In Arduino.h viene definito ad esempio A2 come una costante di tipo intero. Su Arduino UNO ad A2 è assegnato il valore numerico 16 e poiché è una costante di tipo intero possiamo trattare a tutti gli effetti A2 come se si trattasse del numero 16.

Per completezza ricordo che:

A0 -> 14
A1 -> 15
A2 -> 16
A3 -> 17
A4 -> 18
A5 -> 19

In generale sconsiglio di indicare i pin analogici con il loro valore numerico per due motivi:

la notazione Ax immediatamente mette in evidenza che si tratta di pin analogico,
se utilizziamo su una scheda con più pin I/O, come un Arduino Mega non andremo in confusione e non rischieremo far andare in collisione un pin digitale con un pin analogico nel caso ad esempio che stessimo mettendo mano ad uno sketch funzionante su Arduino Uno e che vogliamo far funzionare sul Mega, infatti su Arduino UNO l’A0 corrisponde al pin 14 della scheda mentre sull’Arduino Mega corrsiponde al pin 54 della scheda, se usiamo la notazione Ax non ci sbagliamo.

Ricordate inoltre che se all’interno del nostro loop() passiamo ad una digitalRead un valore da 0 a 5 non intendiamo segnalare un pin digitale da 0 a 5, ma uno dei pin da A0 ad A5.

Buon lavoro 🙂

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati:

Condividi:

Articoli correlati: