Come usare un display LCD 16×2 con Arduino

Questo tutorial include tutto ciò che devi sapere per controllare un LCD a caratteri con Arduino. Ho incluso uno schema di collegamento e molti esempi di codice. Questi display sono ottimi per mostrare dati di sensori o testo e sono anche abbastanza economici.

La prima parte di questo articolo copre le basi per visualizzare testo e numeri. Nella seconda parte, entrerò più nel dettaglio su come mostrare caratteri personalizzati e come utilizzare le altre funzioni della LiquidCrystal libreria Arduino.

Come vedrai, servono parecchie connessioni per controllare questi display. Per questo mi piace usarli con un modulo I2C interface montato sul retro. Con questo modulo I2C, servono solo due collegamenti per controllare l’LCD. Dai un’occhiata al tutorial qui sotto se vuoi usare anche un modulo I2C:

Materiali

Componenti hardware

	16×2 character LCD	× 1	Amazon
	20×4 character LCD	× 1	Amazon
	Arduino Uno Rev3	× 1	Amazon
	Breadboard	× 1	Amazon
	Jumper wires	~ 10	Amazon
	10 kΩ potentiometer	× 1	Amazon
	USB cable type A/B	× 1	Amazon

Software

Arduino IDE

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Panoramica hardware

Questi LCD sono disponibili in molte dimensioni diverse (16×2 1602, 20×4 2004, 16×1 ecc.), ma usano tutti lo stesso HD44780chip controller LCD con interfaccia parallela di Hitachi. Questo significa che puoi facilmente sostituirli. Ti basterà cambiare le specifiche di dimensione nel codice Arduino.

Specifiche LCD 16×2

Tensione di funzionamento	5 V
Controller	Controller LCD Hitachi HD44780
Risoluzione schermo	2 righe x 16 caratteri
Risoluzione carattere	5 x 8 pixel
Dimensioni modulo	80 x 36 x 12 mm
Dimensioni area visibile	64.5 x 16.4 mm
Costo	Check price

Per maggiori informazioni, puoi consultare i datasheet qui sotto. I datasheet 16×2 e 20×4 includono le dimensioni dell’LCD e nel datasheet HD44780 trovi più dettagli sul driver LCD Hitachi.

Pinout LCD 16×2

L’LCD ha 16 pin di connessione, numerati da 1 a 16 da sinistra a destra.

Il pinout di un LCD standard HD44780 è riportato nella tabella seguente:

Numero pin	Simbolo	Connessione	Funzione
1	VSS	GND Arduino	Massa segnale
2	VDD	5 V Arduino	Alimentazione logica per LCD
3	V0	Potentiometro 10 kΩ	Regolazione contrasto
4	RS	Pin 2 Arduino	Segnale di selezione registro
5	R/W	GND Arduino	Segnale di selezione lettura/scrittura
6	E	Pin 3 Arduino	Segnale di abilitazione operazione
7 – 14	D0 – D7	–	Linee bus dati usate per modalità 8-bit
11 – 14	D4 – D7	Pin 4 – 7 Arduino	Linee bus dati usate per modalità 4-bit
15	A (LED+)	5 V Arduino	Anodo per retroilluminazione LCD
16	K (LED-)	GND Arduino	Catodo per retroilluminazione LCD

Testare l’LCD e regolare il contrasto

Per testare il display, devi fare i collegamenti come mostrato nella figura qui sotto.

La maggior parte degli LCD ha una resistenza in serie integrata per il LED della retroilluminazione. Dovresti trovarla sul retro dell’LCD collegata al pin 15 (Anodo). Se il tuo display non include una resistenza, dovrai aggiungerne una tra 5 V e il pin 15. È sicuro usare una resistenza da 220Ω, ma questo valore potrebbe rendere il display un po’ fioco. Puoi controllare il datasheet per la corrente massima della retroilluminazione e usarlo per scegliere un valore di resistenza adeguato.

Dopo aver collegato l’LCD, devi regolare il contrasto del display. Questo si fa ruotando il potenziometro da 10 kΩ in senso orario o antiorario.

Collega il connettore USB dell’Arduino per alimentare l’LCD. Dovresti vedere accendersi la retroilluminazione. Ora ruota il potenziometro finché non appare una (LCD 16×2) o due righe (LCD 20×4) di rettangoli.

Puoi regolare il contrasto anche in seguito, se necessario.

Come collegare l’LCD ad Arduino UNO

Per controllare l’LCD e visualizzare i caratteri, devi aggiungere qualche collegamento extra. Controlla lo schema di collegamento qui sotto e la tabella pinout dall’introduzione di questo articolo.

Useremo l’LCD in modalità 4-bit, quindi non serve collegare nulla a D0-D3. Il pin R/W è collegato a massa, questo lo porta a LOW e imposta l’LCD in modalità SCRITTURA.

Una volta collegato tutto, possiamo iniziare a programmare l’LCD.

Codice esempio Arduino per LCD a caratteri

Per controllare l’LCD useremo la LiquidCrystal libreria. Questa libreria dovrebbe essere preinstallata nell’IDE Arduino. La trovi andando su Sketch > Include Library > LiquidCrystal.

La libreria LiquidCrystal include molte funzioni integrate e rende il controllo degli LCD a caratteri molto semplice.

Il codice esempio qui sotto mostra come visualizzare un messaggio sull’LCD. Poi ti spiegherò come funziona il codice e come usare le altre funzioni della libreria LiquidCrystal.

/* Basic Arduino example code for displaying text 
  on 16x2, 20x4 etc. character LCDs. 
  www.www.makerguides.com */

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Dovresti vedere il seguente output sull’LCD:

Come funziona il codice

Dopo aver incluso la libreria, il passo successivo è creare una nuova istanza della classe LiquidCrystal. Questo si fa con la funzione LiquidCrystal(rs, enable, d4, d5, d6, d7). Come parametri usiamo i pin Arduino a cui abbiamo collegato il display. Nota che abbiamo chiamato il display ‘lcd’. Puoi dargli un nome diverso se vuoi, come ‘menu_display’. Dovrai cambiare ‘lcd’ con il nuovo nome nel resto dello sketch.

// Include the library:
#include "LiquidCrystal.h"

// Create an LCD object. Parameters: (RS, E, D4, D5, D6, D7):
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

Nel setup() l’LCD viene inizializzato con la funzione begin(cols,rows). Se usi un LCD 20×4 cambia questa riga in lcd.begin(20,4);

void setup() {
  // Specify the LCD's number of columns and rows. Change to (20, 4) for a 20x4 LCD:
  lcd.begin(16, 2);
}

Nel loop() il cursore viene posizionato alla terza colonna e prima riga dell’LCD con lcd.setCursor(2,0). Ricorda che il conteggio parte da 0, e il primo argomento specifica la colonna. Se non specifichi la posizione del cursore, il testo verrà stampato nella posizione predefinita (0,0) se il display è vuoto, o subito dopo l’ultimo carattere stampato.

Poi la stringa ‘Hello World!’ viene stampata con lcd.print("Hello World!"). Ricorda che devi mettere le virgolette (” “) intorno al testo. Se vuoi stampare numeri o variabili, non servono le virgolette.

void loop() {
  // Set the cursor on the third column and the first row, counting starts at 0:
  lcd.setCursor(2, 0);
  // Print the string 'Hello World!':
  lcd.print("Hello World!");
  // Set the cursor on the third column and the second row:
  lcd.setCursor(2, 1);
  // Print the string 'LCD tutorial':
  lcd.print("LCD tutorial");
}

Se vuoi vedere un esempio per visualizzare (modificare) variabili sull’LCD, dai un’occhiata al mio tutorial su How to use a HC-SR04 Ultrasonic Distance Sensor with Arduino.

Nell’esempio ho usato un display LCD I2C ma il codice dopo il setup è lo stesso per entrambi.

Altre funzioni della libreria LiquidCrystal

La libreria LiquidCrystal di Arduino ha molte altre funzioni integrate che potresti trovare utili. Qui sotto trovi una panoramica con spiegazioni e qualche snippet di codice.

clear()

Pulisce lo schermo LCD e posiziona il cursore nell’angolo in alto a sinistra (prima riga e prima colonna) del display. Puoi usare questa funzione per mostrare parole diverse in un ciclo.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  lcd.clear();
  lcd.print("Monday");
  delay(2000);
  lcd.clear();
  lcd.print("13:45");
  delay(2000);
}

home()

Posiziona il cursore nell’angolo in alto a sinistra dell’LCD. Usa clear() se vuoi anche pulire il display.

cursor()

Mostra il cursore LCD: un underscore (linea) nella posizione del prossimo carattere da stampare.

noCursor()

Nasconde il cursore LCD. L’esempio seguente crea un cursore lampeggiante alla fine di “cursor()”.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("cursor()");
}

void loop() {
  lcd.cursor();
  delay(500);
  lcd.noCursor();
  delay(500);
}

blink()

Crea un cursore LCD a blocco lampeggiante: un rettangolo lampeggiante nella posizione del prossimo carattere da stampare.

noBlink()

Disabilita il cursore a blocco lampeggiante. L’esempio seguente mostra il cursore lampeggiante per 5 secondi e poi lo disabilita per 2 secondi.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("blink() example");
}

void loop() {
  lcd.blink();
  delay(5000);
  lcd.noBlink();
  delay(2000);
}

display()

Questa funzione accende lo schermo LCD e mostra qualsiasi testo o cursore stampato sul display.

noDisplay()

Questa funzione spegne qualsiasi testo o cursore stampato sull’LCD. Il testo/dati non vengono cancellati dalla memoria dell’LCD. Questo significa che verranno mostrati di nuovo quando si chiama la funzione display().

L’esempio seguente crea un effetto di testo lampeggiante.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("Blinking text");
}

void loop() {
  lcd.display();
  delay(2000);
  lcd.noDisplay();
  delay(2000);
}

write()

Questa funzione può essere usata per scrivere un carattere sull’LCD. Vedi la sezione su come creare e mostrare caratteri personalizzati qui sotto per maggiori info.

scrollDisplayLeft()

Scorre il contenuto del display (testo e cursore) di uno spazio a sinistra. Puoi usare questa funzione nella sezione loop del codice insieme a delay(500), per creare un’animazione di testo scorrevole.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
  lcd.print("scrollDisplayLeft() example");
}

void loop() {
  lcd.scrollDisplayLeft();
  delay(500);
}

scrollDisplayRight()

Scorre il contenuto del display (testo e cursore) di uno spazio a destra.

autoscroll()

Questa funzione attiva lo scorrimento automatico dell’LCD. Questo fa sì che ogni carattere inviato al display spinga i caratteri precedenti di uno spazio. Se la direzione del testo è da sinistra a destra (default), il display scorre verso sinistra; se la direzione è da destra a sinistra, il display scorre verso destra. L’effetto è che ogni nuovo carattere viene mostrato sempre nella stessa posizione sull’LCD.

L’esempio seguente abilita lo scorrimento automatico e stampa i caratteri da 0 a 9 nella posizione (16,0) dell’LCD. Cambia in (20,0) per un LCD 20×4.

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

void setup() {
  lcd.begin(16, 2);
}

void loop() {
  lcd.autoscroll();
  lcd.setCursor(16, 0);
  for (int x = 0; x < 10; x++) {
    lcd.print(x);
    delay(500);
  }
  lcd.clear();
}

noAutoscroll()

Disabilita lo scorrimento automatico dell’LCD.

leftToRight()

Questa funzione fa scorrere il testo verso destra dal cursore, come se il display fosse allineato a sinistra (default).

rightToLeft()

Questa funzione fa scorrere il testo verso sinistra dal cursore, come se il display fosse allineato a destra.

Come creare e mostrare caratteri personalizzati?

Con la funzione createChar() è possibile creare e mostrare caratteri personalizzati sull’LCD. Questo è particolarmente utile se vuoi visualizzare un carattere che non fa parte del set ASCII standard.

Info tecnica: gli LCD basati sul controller Hitachi HD44780 hanno due tipi di memoria: CGROM e CGRAM (Character Generator ROM e RAM). La CGROM genera tutti i pattern di caratteri 5 x 8 punti dai codici carattere standard a 8 bit. La CGRAM può generare pattern di caratteri definiti dall’utente.

Per display 5 x 8 punti, la CGRAM può scrivere fino a 8 caratteri personalizzati e per display 5 x 10 punti 4. Per maggiori info consulta il datasheet.

Codice esempio Arduino per caratteri personalizzati

Lo sketch esempio seguente crea e mostra otto caratteri personalizzati (numerati da 0 a 7).

/* Example sketch to create and display custom characters on 
   character LCD with Arduino and LiquidCrystal library. 
   For more info see www.www.makerguides.com */

#include "LiquidCrystal.h"

// Creates an LCD object. Parameters: (RS, E, D4, D5, D6, D7)
LiquidCrystal lcd = LiquidCrystal(2, 3, 4, 5, 6, 7);

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};
byte Bell[] = {
  B00100,
  B01110,
  B01110,
  B01110,
  B11111,
  B00000,
  B00100,
  B00000
};
byte Alien[] = {
  B11111,
  B10101,
  B11111,
  B11111,
  B01110,
  B01010,
  B11011,
  B00000
};
byte Check[] = {
  B00000,
  B00001,
  B00011,
  B10110,
  B11100,
  B01000,
  B00000,
  B00000
};
byte Speaker[] = {
  B00001,
  B00011,
  B01111,
  B01111,
  B01111,
  B00011,
  B00001,
  B00000
};
byte Sound[] = {
  B00001,
  B00011,
  B00101,
  B01001,
  B01001,
  B01011,
  B11011,
  B11000
};
byte Skull[] = {
  B00000,
  B01110,
  B10101,
  B11011,
  B01110,
  B01110,
  B00000,
  B00000
};
byte Lock[] = {
  B01110,
  B10001,
  B10001,
  B11111,
  B11011,
  B11011,
  B11111,
  B00000
};

void setup() {
  // Specify the LCD's number of columns and rows:
  lcd.begin(16, 2);

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

  // Clears the LCD screen:
  lcd.clear();

  // Print a message to the lcd:
  lcd.print("Custom Character");
}

void loop() {
  // Print all the custom characters:
  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));
}

Dovresti vedere il seguente output sull’LCD:

Come funziona il codice

Dopo aver incluso la libreria e creato l’oggetto LCD, vengono definite le array dei caratteri personalizzati. Ogni array è composto da 8 byte, 1 byte per ogni riga. In questo esempio vengono creati 8 caratteri personalizzati.

// Make custom characters:
byte Heart[] = {
  B00000,
  B01010,
  B11111,
  B11111,
  B01110,
  B00100,
  B00000,
  B00000
};

Guardando da vicino l’array, vedrai quanto segue. Ogni riga è composta da 5 numeri corrispondenti ai 5 pixel in un carattere 5 x 8 punti. Uno 0 significa pixel spento e uno 1 significa pixel acceso.

È possibile modificare ogni riga a mano, ma consiglio di usare questo visual tool su GitHub. Questa applicazione crea automaticamente l’array del carattere e puoi cliccare sui pixel per accenderli o spegnerli.

Nel setup(), i caratteri personalizzati sono creati con lcd.createChar(num, data).

Il primo argomento di questa funzione è il numero del carattere personalizzato (0-7) e il secondo argomento è l’array del carattere che abbiamo creato.

  // Create a new characters:
  lcd.createChar(0, Heart);
  lcd.createChar(1, Bell);
  lcd.createChar(2, Alien);
  lcd.createChar(3, Check);
  lcd.createChar(4, Speaker);
  lcd.createChar(5, Sound);
  lcd.createChar(6, Skull);
  lcd.createChar(7, Lock);

Nel loop() tutti i caratteri sono mostrati con lcd.write(). Come parametro usiamo il numero del carattere che abbiamo riservato.

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

Conclusione

In questo articolo ti ho mostrato come usare un LCD alfanumerico con Arduino. Spero ti sia stato utile e informativo. Se hai domande, suggerimenti o pensi che manchi qualcosa in questo tutorial, lascia pure un commento qui sotto.

Buon divertimento con il fai-da-te 😉