Componenti · 10 min di lettura

Collegare LCD 16x2 ad Arduino senza I2C: 4 bit e contrasto

Come collegare un LCD 16x2 ad Arduino senza modulo I2C: i 16 pin, modalità 4 bit, contrasto, LiquidCrystal, soluzione ai quadratini neri e LCD 20x4.

Quando colleghi un LCD 16x2 ad Arduino senza modulo I2C usi 12 dei 16 pin del display: sei vanno a pin digitali di Arduino, gli altri servono per alimentazione, contrasto e retroilluminazione. Sembrano tanti fili, ma questo collegamento ti fa capire davvero come funziona il display, ti risparmia la ricerca dell'indirizzo I2C, è più veloce dell'I2C e non blocca il progetto se non hai un modulo I2C. Del resto, la maggior parte degli LCD dei kit base di Arduino arriva senza modulo I2C.

In questa guida imparerai la funzione di ciascuno dei 16 pin, perché usiamo solo 4 linee dati (modalità a 4 bit), come collegare il potenziometro del contrasto e i comandi della libreria LiquidCrystal. Poi disegnerai caratteri personalizzati per una barra che si riempie con un potenziometro, passerai a un LCD 20x4 e userai lo stesso display con ESP32 e Raspberry Pi Pico. Nelle ultime sezioni troverai come risolvere i problemi più comuni, come i "quadratini neri" e lo "schermo vuoto", e quando conviene passare a un modulo I2C.

Display LCD a caratteri 16x2
LCD 16x2: caratteri da 5 × 8 pixel su 16 colonne e 2 righe. I 16 pin sul bordo superiore si collegano direttamente, senza modulo I2C.

Come funziona un LCD 16x2?

Il chip nero a goccia sul retro del display è il driver HD44780 (o un clone identico), la lingua comune di quasi tutti gli LCD a caratteri. Arduino gli invia due tipi di byte: comandi (pulisci lo schermo, porta il cursore in una posizione, accendi il display) e caratteri (il codice della lettera da mostrare). Il pin RS indica cosa viene inviato: con RS LOW il byte è un comando, con RS HIGH è un carattere. Il pin E (enable) è il segnale "dato pronto, leggilo ora": dopo aver messo il byte sulle linee dati, E va brevemente HIGH e il chip legge il byte sul fronte di discesa. Dentro il chip ci sono una memoria video da 80 caratteri (DDRAM), una ROM con 208 caratteri incorporati e una piccola memoria (CGRAM) per gli 8 caratteri personalizzati che disegnerai.

CaratteristicaValore
Chip driverHD44780 o compatibile (KS0066, SPLC780)
Display16 colonne × 2 righe, caratteri da 5 × 8 pixel
Alimentazione4,5–5,5 V (esistono anche versioni speciali a 3,3 V)
Corrente della logicaCirca 1–2 mA
Corrente della retroilluminazioneCirca 15–30 mA (LED, secondo il modello)
Bus datiParallelo a 8 o 4 bit
Caratteri personalizzati8 (CGRAM)
Durata dei comandiLa maggior parte 37 µs, clear() e home() circa 1,5 ms

La funzione dei 16 pin

PinNomeFunzioneCollegamento
1VSSMassaGND
2VDDAlimentazione della logica5V
3V0 (VO, VEE)Regolazione del contrastoCursore di un potenziometro da 10 kΩ
4RSSelezione comando (LOW) o carattere (HIGH)Arduino D12
5RWLettura (HIGH) o scrittura (LOW)GND (scriviamo soltanto)
6EImpulso di dato validoArduino D11
7–10D0–D3Bit di dati bassiLiberi in modalità 4 bit
11D4Bit di dati 4Arduino D5
12D5Bit di dati 5Arduino D4
13D6Bit di dati 6Arduino D3
14D7Bit di dati 7Arduino D2
15A (LED+)Anodo della retroilluminazione5V tramite 220 Ω
16K (LED−)Catodo della retroilluminazioneGND
Su alcuni LCD l'ordine dei pin è diverso, oppure i pin 15 e 16 della retroilluminazione si trovano all'inizio. Prima di collegare controlla le scritte sulla scheda e il segno del pin 1. Non collegare la retroilluminazione direttamente ai 5 V senza resistenza: se il modulo non ha una resistenza in serie, il LED assorbe troppa corrente e si rovina. Sul retro di solito c'è una resistenza di circa 100 Ω siglata R8 o R9; se non sei sicuro, aggiungi comunque quella da 220 Ω. Il valore giusto lo trovi con il calcolatore della resistenza per LED.

Modalità 4 bit: perché 4 linee dati invece di 8?

L'HD44780 può ricevere un byte in un colpo solo su 8 linee dati (modalità 8 bit) oppure in due metà sulle linee D4–D7 (modalità 4 bit). In modalità 4 bit si invia prima la metà alta del byte, poi quella bassa, con un impulso su E per ciascuna. Ci vuole il doppio del tempo, ma in pratica non si nota: scrivere un carattere richiede sempre circa 50 µs e aggiornare tutto lo schermo meno di 2 ms. In cambio si liberano quattro pin di Arduino. La libreria LiquidCrystal sceglie da sola la modalità 4 bit quando passi sei pin al costruttore; lasciare D0–D3 scollegati è sicuro perché il chip ha delle pull-up interne su questi pin.

Il potenziometro del contrasto

Potenziometro da 10 kΩ
Per il contrasto basta un potenziometro da 10 kΩ: piedini esterni a 5V e GND, quello centrale al V0 dell'LCD.

È la tensione sul pin V0 a decidere se il testo è visibile. Quello che fa ruotare il cristallo liquido è la differenza tra VDD e V0; nei moduli standard a 5 V l'immagine migliore si ottiene di solito con V0 intorno a 0,3–1 V. Quando V0 si avvicina a 0 V si scurisce anche lo sfondo dei caratteri e le celle vuote appaiono come quadratini neri; quando si avvicina a 5 V il testo sparisce del tutto. Per questo nel primo montaggio la soluzione più pratica è un potenziometro: un piedino esterno a 5V, l'altro a GND e quello centrale a V0, poi ruotalo lentamente finché il testo è nitido. Trovata la regolazione, puoi sostituire il potenziometro con una resistenza fissa: 1–2,2 kΩ tra V0 e GND vanno bene sulla maggior parte dei moduli.

Passo passo: il primo testo con Arduino

  1. Salda una striscia di 16 pin maschio sull'LCD e inserisci il display nella breadboard; su una breadboard lunga resta spazio per i fili ai due lati.
  2. Porta il 5V e il GND di Arduino sulle linee di alimentazione della breadboard. Collega i pin 1 (VSS) e 16 (K) dell'LCD a GND, il pin 2 (VDD) a 5V e il pin 15 (A) a 5V tramite 220 Ω. Quando colleghi Arduino alla USB, la retroilluminazione deve accendersi.
  3. Collega il potenziometro e ruotalo. Ancora prima di caricare il codice, sulla riga superiore dovrebbero comparire 16 quadratini neri: significa che display e contrasto funzionano.
  4. Collega il pin 5 (RW) a GND. Poi RS a D12, E a D11 e D4–D7 rispettivamente a D5, D4, D3 e D2.
  5. Verifica nel Gestore librerie che LiquidCrystal sia installata (è inclusa nell'Arduino IDE) e carica il codice qui sotto.
  6. Quando i quadratini spariscono e compare il testo, regola un'ultima volta il contrasto con il potenziometro.
C++ (Arduino IDE)
1// 16x2 LCD, I2C modülü olmadan (4-bit mod) / 16x2 LCD without an I2C module (4-bit mode)
2// RS -> D12, E -> D11, D4 -> D5, D5 -> D4, D6 -> D3, D7 -> D2, RW -> GND, V0 -> pot
3#include <LiquidCrystal.h>
4
5const int RS = 12, EN = 11, D4 = 5, D5 = 4, D6 = 3, D7 = 2;
6LiquidCrystal lcd(RS, EN, D4, D5, D6, D7);
7
8void setup() {
9  lcd.begin(16, 2);              // 16 sütun, 2 satır / 16 columns, 2 rows
10  lcd.print(F("Merhaba Arduino!"));
11  lcd.setCursor(0, 1);           // sütun 0, satır 1 / column 0, row 1
12  lcd.print(F("Sure:"));
13}
14
15void loop() {
16  unsigned long s = millis() / 1000;
17  lcd.setCursor(6, 1);
18  lcd.print(s);
19  lcd.print(F(" sn   "));      // eski haneleri boşlukla sil / overwrite old digits with spaces
20  delay(200);
21}

Il codice usa due piccole ma importanti abitudini. Primo, prima di scrivere il valore che cambia si sposta in quella posizione con setCursor() invece di chiamare clear(), e aggiunge qualche spazio dopo il numero. clear() è un comando pesante che richiede circa 1,5 ms e, usato nel loop, fa sfarfallare lo schermo; inoltre non serve cancellare e riscrivere tutto. Gli spazi evitano che una cifra vecchia resti a schermo quando il numero si accorcia (per esempio da 100 a 99). Secondo, i testi fissi sono scritti con la macro F(), così restano nella memoria programma invece che in RAM. Su un display 16x2 stanno al massimo 16 caratteri per riga; un testo più lungo esce a destra e non si vede.

ComandoCosa fa
lcd.begin(16, 2)Avvia il display e imposta colonne e righe
lcd.print(valore)Scrive testo, un intero o un decimale; lcd.print(3.14159, 2) mostra due decimali
lcd.setCursor(colonna, riga)Sceglie dove scrivere; si conta da 0
lcd.clear()Pulisce lo schermo e riporta il cursore all'inizio (1,5 ms)
lcd.cursor() / lcd.noCursor()Mostra o nasconde il cursore a trattino
lcd.blink() / lcd.noBlink()Attiva o disattiva il cursore a blocco lampeggiante
lcd.display() / lcd.noDisplay()Accende o spegne l'immagine senza cancellare la memoria
lcd.scrollDisplayLeft()Sposta tutto il display di una colonna a sinistra
lcd.createChar(n, array)Carica un carattere personalizzato nella posizione 0–7
lcd.write(byte(n))Scrive un carattere personalizzato o un codice della ROM

Caratteri personalizzati: una barra che si riempie con un potenziometro

Ogni cella di carattere è una griglia di 5 colonne e 8 righe di pixel. Per definire un carattere personalizzato scrivi ogni riga come un numero a 5 bit: 1 indica un pixel acceso, 0 uno spento. L'HD44780 permette 8 caratteri personalizzati alla volta. L'esempio seguente usa cinque di queste posizioni per blocchi con 1, 2, 3, 4 e 5 colonne piene da sinistra. Con 16 celle × 5 colonne ottieni una barra da 80 passi che si riempie e si svuota in modo fluido con un potenziometro; ideale per volume, livello della batteria o la percentuale di un sensore. Come disegnare le lettere turche (ş, ğ, ı, ç) lo abbiamo spiegato nell'articolo sull'LCD I2C; lo stesso comando createChar funziona allo stesso modo anche con il collegamento parallelo.

C++ (Arduino IDE)
1// Özel karakterlerle 80 adımlık çubuk grafik / 80-step bar graph with custom characters
2// Potansiyometre orta ucu -> A0 / potentiometer wiper -> A0
3#include <LiquidCrystal.h>
4
5LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
6
7byte bars[5][8];                       // 1..5 sütun dolu bloklar / blocks with 1..5 columns filled
8
9void buildBars() {
10  for (int n = 0; n < 5; n++) {
11    byte row = 0;
12    for (int c = 0; c <= n; c++) row |= (0b10000 >> c);   // soldan doldur / fill from the left
13    for (int r = 0; r < 8; r++) bars[n][r] = row;
14    lcd.createChar(n, bars[n]);        // karakter 0 = 1 sütun ... 4 = 5 sütun / char 0 = 1 column ... 4 = 5 columns
15  }
16}
17
18void setup() {
19  lcd.begin(16, 2);
20  buildBars();
21  lcd.setCursor(0, 0);                 // createChar sonrası konum ayarla / set position after createChar
22  lcd.print(F("Seviye / Level"));
23}
24
25void loop() {
26  int raw = analogRead(A0);
27  int steps = map(raw, 0, 1023, 0, 80);  // 16 hücre x 5 sütun / 16 cells x 5 columns
28  int percent = map(raw, 0, 1023, 0, 100);
29
30  lcd.setCursor(12, 0);
31  if (percent < 100) lcd.print(' ');
32  if (percent < 10) lcd.print(' ');
33  lcd.print(percent);
34  lcd.print('%');
35
36  lcd.setCursor(0, 1);
37  for (int cell = 0; cell < 16; cell++) {
38    int fill = steps - cell * 5;       // bu hücreye düşen sütun / columns in this cell
39    if (fill >= 5) lcd.write(byte(4));
40    else if (fill > 0) lcd.write(byte(fill - 1));
41    else lcd.print(' ');
42  }
43  delay(50);
44}

Il comando createChar sposta il cursore dalla memoria video a quella dei caratteri; per questo, dopo aver caricato i caratteri personalizzati, prima di scrivere devi chiamare setCursor(), altrimenti il primo testo potrebbe non comparire. I caratteri sono salvati solo nella CGRAM e si perdono quando il display resta senza alimentazione, quindi si ricaricano in setup() a ogni avvio. Se cambi la definizione di un carattere mentre è sullo schermo, tutte le celle che lo mostrano cambiano insieme; le piccole animazioni si fanno proprio con questo trucco.

LCD 20x4: stesso collegamento, schermo più grande

Gli LCD da 20 colonne e 4 righe usano lo stesso chip HD44780 e gli stessi 16 pin; il collegamento è identico e nel codice basta scrivere lcd.begin(20, 4). La loro retroilluminazione assorbe un po' di più (40–60 mA), quindi evita di ridurre la resistenza in serie per non affaticare la linea dei 5V di Arduino nell'uso prolungato. L'unica stranezza da conoscere è l'ordine delle righe: nella memoria video la fine della riga 1 continua sulla riga 3 e quella della riga 2 sulla riga 4. Se scrivi un testo lungo senza setCursor(), passa quindi dalla riga 1 alla 3 e non alla 2. Chiamare setCursor(0, riga) all'inizio di ogni riga elimina del tutto il problema.

C++ (Arduino IDE)
1// 20x4 LCD: aynı bağlantı, begin(20, 4) / 20x4 LCD: same wiring, begin(20, 4)
2#include <LiquidCrystal.h>
3
4LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
5
6void setup() {
7  lcd.begin(20, 4);
8  for (int row = 0; row < 4; row++) {
9    lcd.setCursor(0, row);             // her satırı açıkça seç / select every row explicitly
10    lcd.print(F("Satir / Row "));
11    lcd.print(row + 1);
12  }
13}
14
15void loop() {
16  lcd.setCursor(15, 3);
17  lcd.print(millis() / 1000 % 100000);  // 5 haneye sığsın / fit in 5 digits
18  delay(500);
19}

LCD parallelo con ESP32

Un LCD 16x2 standard non dà abbastanza contrasto se non è alimentato a 5 V, mentre i pin dell'ESP32 sono a 3,3 V. La buona notizia: finché RW è collegato a GND, l'LCD non mette mai tensione sulle linee, si limita ad ascoltare. Dato che l'HD44780 a 5 V considera HIGH già un ingresso di circa 2,2 V, i segnali a 3,3 V dell'ESP32 bastano e non serve un convertitore di livello. Collega il VDD dell'LCD al pin VIN della scheda ESP32 (5 V dalla USB). La libreria LiquidCrystal funziona allo stesso modo sull'ESP32; evita solo i pin con funzioni speciali all'avvio, come GPIO 0, 2, 12 e 15.

C++ (Arduino IDE)
1// ESP32 + 16x2 LCD (paralel, 4-bit) / ESP32 + 16x2 LCD (parallel, 4-bit)
2// RS -> GPIO 22, E -> GPIO 21, D4 -> 19, D5 -> 18, D6 -> 26, D7 -> 25
3// VDD -> VIN (5 V), RW -> GND, V0 -> pot, A -> 220 ohm -> VIN
4#include <LiquidCrystal.h>
5
6LiquidCrystal lcd(22, 21, 19, 18, 26, 25);
7
8void setup() {
9  lcd.begin(16, 2);
10  lcd.print("ESP32 + LCD");
11}
12
13void loop() {
14  lcd.setCursor(0, 1);
15  lcd.print("Heap: ");
16  lcd.print(ESP.getFreeHeap() / 1024);   // boş bellek (KB) / free memory (KB)
17  lcd.print(" KB   ");
18  delay(1000);
19}

LCD parallelo con Raspberry Pi Pico (MicroPython)

Per il Raspberry Pi Pico vale la stessa logica: alimenta l'LCD a 5 V da VBUS (pin 40), collega RW a GND e porta i segnali direttamente sui pin GP. MicroPython non ha una libreria LiquidCrystal pronta, quindi qui sotto trovi un breve driver che gestisce da solo la modalità 4 bit. Segue la sequenza di inizializzazione del datasheet dell'HD44780: aspetta 50 ms dopo l'accensione, forza tre volte la modalità 8 bit, poi passa a 4 bit e accende il display. Ogni carattere viene inviato in due metà (nibble), con un breve impulso su E dopo ciascuna.

MicroPython
1# Raspberry Pi Pico: I2C'siz 16x2 LCD sürücüsü (4-bit) / 16x2 LCD driver without I2C (4-bit)
2# RS -> GP16, E -> GP17, D4 -> GP18, D5 -> GP19, D6 -> GP20, D7 -> GP21
3# VDD -> VBUS (pin 40, 5 V), RW -> GND, V0 -> pot
4from machine import Pin
5import time
6
7
8class LCD4:
9    def __init__(self, rs, e, d4, d5, d6, d7):
10        self.rs = Pin(rs, Pin.OUT, value=0)
11        self.e = Pin(e, Pin.OUT, value=0)
12        self.data = [Pin(p, Pin.OUT, value=0) for p in (d4, d5, d6, d7)]
13        time.sleep_ms(50)                 # güç geldikten sonra bekle / wait after power-up
14        for _ in range(3):
15            self._nibble(0x03)            # 8-bit moda zorla / force 8-bit mode
16            time.sleep_ms(5)
17        self._nibble(0x02)                # 4-bit moda geç / switch to 4-bit mode
18        self.command(0x28)                # 4 bit, 2 satır, 5x8 / 4-bit, 2 lines, 5x8
19        self.command(0x0C)                # ekran açık, imleç kapalı / display on, cursor off
20        self.clear()
21        self.command(0x06)                # soldan sağa yaz / write left to right
22
23    def _nibble(self, value):
24        for i, pin in enumerate(self.data):
25            pin.value((value >> i) & 1)
26        self.e.value(1)                   # E darbesi / E pulse
27        time.sleep_us(1)
28        self.e.value(0)
29        time.sleep_us(50)                 # komut süresi (37 µs) / command time (37 µs)
30
31    def _write(self, value, rs):
32        self.rs.value(rs)
33        self._nibble(value >> 4)          # önce üst yarı / upper half first
34        self._nibble(value & 0x0F)
35
36    def command(self, cmd):
37        self._write(cmd, 0)
38
39    def clear(self):
40        self.command(0x01)
41        time.sleep_ms(2)                  # clear yaklaşık 1,5 ms / clear takes about 1.5 ms
42
43    def move_to(self, col, row):
44        offsets = (0x00, 0x40, 0x14, 0x54)   # 16x2 ve 20x4 satır adresleri / row addresses
45        self.command(0x80 | (offsets[row] + col))
46
47    def putstr(self, text):
48        for ch in text:
49            self._write(ord(ch), 1)
50
51
52lcd = LCD4(rs=16, e=17, d4=18, d5=19, d6=20, d7=21)
53lcd.move_to(0, 0)
54lcd.putstr("Merhaba Pico!")
55count = 0
56while True:
57    lcd.move_to(0, 1)
58    lcd.putstr("Sayac: {:<9d}".format(count))
59    count += 1
60    time.sleep(1)

Quadratini neri, schermo vuoto e altri problemi

Quasi tutti i problemi di un LCD parallelo assomigliano a uno di pochi sintomi, ed è il display stesso a dirti dove guardare. L'indizio più importante è questo: se vedi 16 quadratini neri solo sulla riga superiore, alimentazione e contrasto sono a posto, ma il chip non è mai stato inizializzato. All'accensione l'HD44780 parte in modalità a una riga e pilota solo la prima; finché il codice non riesce a inizializzare il display, l'immagine non cambia. In quel caso il problema è quasi sempre nei fili RS, E o D4–D7 o nell'ordine dei pin nel costruttore. Se vedi quadratini tenui su entrambe le righe, il display funziona e il contrasto è semplicemente troppo alto.

SintomoCausa probabileSoluzione
16 quadratini neri solo sulla riga superioreDisplay non inizializzato: fili RS, E, D4–D7 o ordine dei pin nel costruttore sbagliati, oppure codice non caricatoControlla i fili con la tabella e l'ordine LiquidCrystal lcd(RS, E, D4, D5, D6, D7)
Quadratini tenui su entrambe le righeContrasto troppo alto (V0 troppo vicino a GND)Ruota il potenziometro
Retroilluminazione accesa ma non si vede nullaContrasto troppo basso o V0 non collegatoVerifica che il cursore del potenziometro vada a V0 e ruotalo
La retroilluminazione non si accendePin 15 e 16 non collegati, invertiti o senza resistenzaCollega A a 5V tramite 220 Ω e K a GND
Caratteri senza senso o che si spostanoUn filo dati allentato, D4–D7 scambiati, disturbi da motori o relèFissa i fili, aggiungi 100 µF sull'alimentazione, se serve reinizializza con lcd.begin()
Il testo sfarfallaSi usa lcd.clear() nel loopSovrascrivi con setCursor() e cancella le cifre vecchie con spazi
Resta una cifra vecchia quando il numero si accorciaIl nuovo valore è più corto del precedenteAggiungi spazi dopo il valore
Dopo un carattere personalizzato non compare il testocreateChar ha spostato il cursore nella memoria dei caratteriChiama setCursor() dopo createChar
Nei progetti con motori, relè o servo, l'LCD a volte dopo qualche ora inizia a mostrare caratteri senza senso: un calo di tensione ha portato il chip in uno stato indefinito. Chiamare lcd.begin(16, 2) a intervalli, per esempio una volta al minuto, e ridisegnare lo schermo risolve il problema senza che l'utente se ne accorga.

Conviene passare a un modulo I2C?

Modulo I2C per LCD (PCF8574)
Il modulo I2C basato su PCF8574 si salda sul retro dell'LCD e riduce i 16 pin a soli quattro fili.

Grazie al chip PCF8574 sul retro, il modulo I2C porta tutti i segnali dell'LCD su due fili (SDA e SCL); anche il potenziometro del contrasto e il transistor della retroilluminazione sono sulla scheda. Quando il progetto cresce questa comodità conta: un Uno ha solo 20 pin digitali e analogici e un LCD parallelo ne occupa sei da solo. D'altra parte il collegamento parallelo è più veloce, non ha conflitti di indirizzo I2C e non richiede moduli. La tabella riassume quando conviene l'uno o l'altro; per il montaggio con modulo I2C vedi l'articolo sul display LCD I2C.

CaratteristicaParallelo (4 bit)Con modulo I2C
Pin di Arduino usati62 (A4, A5)
Numero di fili12 (alimentazione e potenziometro inclusi)4
Aggiornamento di tutto lo schermoMeno di 2 msCirca 20–30 ms a 100 kHz
Regolazione del contrastoPotenziometro esternoTrimmer sul modulo
Spegnere la retroilluminazione via softwareServe un transistor in piùlcd.noBacklight()
LibreriaLiquidCrystal (inclusa nell'IDE)LiquidCrystal I2C (da installare)
Problemi tipiciGroviglio di fili, contatti instabiliIndirizzo (0x27 / 0x3F) e pull-up

Idee di progetti con un LCD 16x2

  • Termometro digitale: mostra in grande temperatura e umidità di un NTC o di un DHT11, scrivendo il simbolo dei gradi con lcd.write(223).
  • Serratura a codice: mostra con asterischi il codice digitato su un tastierino e attiva un relè se è corretto.
  • Indicatore di distanza: mostra insieme in centimetri e con una barra la distanza misurata da un HC-SR04.
  • Cronometro e conto alla rovescia: avvia, ferma e azzera con due pulsanti, mostrando il tempo come minuti:secondi:centesimi.
  • Minigioco: disegna con i caratteri personalizzati un corridore e degli ostacoli e fallo saltare con un pulsante.
  • Sistema di menu: crea un menu da scorrere e regolare con un encoder rotativo e salva le scelte nella EEPROM.

Collegare un LCD 16x2 senza modulo I2C all'inizio può sembrare un groviglio di fili, ma una volta capito come il display riceve i comandi puoi usare qualsiasi LCD a caratteri, il 20x4 e perfino altri microcontrollori con la stessa logica. Nell'app BlueGrays i progetti "Scrivere un messaggio su un LCD 16x2", "Testo che rimbalza sull'LCD" e "Misurare la distanza con un LCD" ti guidano passo passo in questo collegamento con schema e codice pronto.

Domande frequenti

Perché il mio LCD 16x2 mostra quadratini neri?

Se i quadratini compaiono solo sulla riga superiore, alimentazione e contrasto sono a posto ma Arduino non è riuscito a inizializzare il display; controlla i fili RS, E e D4–D7 e l'ordine dei pin nel costruttore di LiquidCrystal. Se ci sono quadratini tenui su entrambe le righe, il contrasto è troppo alto e basta ruotare il potenziometro.

Perché l'LCD è illuminato ma non mostra testo?

La causa più comune è un contrasto troppo basso: quando V0 resta vicino a 5 V i caratteri non si vedono. Controlla che il cursore del potenziometro sia collegato a V0 e ruotalo lentamente. Se il contrasto è giusto e sulla riga superiore compaiono quadratini, il problema è nei fili dati o nel codice.

Si può usare un LCD 16x2 senza potenziometro?

Sì. Una resistenza fissa da 1–2,2 kΩ tra V0 e GND dà un buon contrasto sulla maggior parte dei moduli a 5 V. Il modo più affidabile è trovare il valore una volta con un potenziometro e poi sostituirlo con una resistenza fissa. Puoi anche collegare V0 a un pin PWM tramite un filtro RC e regolare il contrasto via software.

Dove si collega il pin RW dell'LCD?

Se scriverai soltanto sul display, collega RW (pin 5) a GND; così l'LCD resta sempre in modalità scrittura, che è il modo in cui lavora la libreria LiquidCrystal. Se RW resta scollegato, il display può passare a caso in modalità lettura, pilotare le linee dati e non mostrare nulla. RW a GND protegge anche i pin delle schede a 3,3 V.

Che differenza c'è tra LiquidCrystal e LiquidCrystal_I2C?

LiquidCrystal pilota l'LCD direttamente dai pin di Arduino ed è inclusa nell'Arduino IDE; si usa con il collegamento parallelo. LiquidCrystal_I2C invia gli stessi comandi tramite un modulo I2C con PCF8574 e va installata a parte. La maggior parte dei comandi (print, setCursor, createChar) è uguale in entrambe; la versione I2C aggiunge lcd.init() per l'avvio e backlight() per la retroilluminazione.

Il codice per LCD 16x2 funziona su un 20x4?

Sì, perché collegamento e comandi sono gli stessi; devi solo cambiare lcd.begin(16, 2) in lcd.begin(20, 4). Su un display 20x4 le righe in memoria seguono l'ordine 1, 3, 2, 4, quindi la soluzione più pulita è spostarsi su ogni riga con setCursor(0, riga). La retroilluminazione assorbe un po' di più.

Vedi tutti i progetti
Visualizzare un messaggio su display LCD 2x16
AR-29Avanzato
Premium

Visualizzare un messaggio su display LCD 2x16

Il tuo primo passo per scrivere testo su uno schermo. Il display LCD a due righe mostra prima un messaggio di attesa, poi scrive un saluto sulla riga in alto e batte una parola lettera per lettera su…

4.6(37)
51
Testo che rimbalza a destra e sinistra su LCD
AR-30Avanzato
Premium

Testo che rimbalza a destra e sinistra su LCD

Sulla riga in alto del display LCD, la scritta BLUEGRAYS scorre da un bordo all'altro e rimbalza come una palla contro il muro, ancora e ancora senza fine.

4.5(29)
40
Misurazione della distanza tramite display LCD
AR-31Avanzato
Premium

Misurazione della distanza tramite display LCD

Uno strumento che misura le distanze senza righello: muovi la mano avanti e indietro davanti al sensore e guarda il numero cambiare.

4.6(45)
59
Misura di temperatura con NTC e display Lcd 2x16
AR-44Principiante
Premium

Misura di temperatura con NTC e display Lcd 2x16

Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

4.5(33)
44
DS1302 Orologio RTC con display LCD
AR-46Intermedio
Premium

DS1302 Orologio RTC con display LCD

Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

4.7(41)
51
Voltmetro digitale con display LCD
AR-56Intermedio
Premium

Voltmetro digitale con display LCD

Scopri quanta tensione dà una pila o un alimentatore con uno strumento costruito da te.

4.5(27)
36
Serratura con password, tastierino 4x4 e LCD
AR-64Avanzato
Premium

Serratura con password, tastierino 4x4 e LCD

Una piccola serratura elettronica che non fa entrare chi non conosce il codice. Premi il tasto cancelletto e digiti il codice sul tastierino; se è giusto, lo schermo indica accesso consentito, si…

4.8(59)
75
Gioco runner su LCD con Arduino
AR-96Intermedio
Premium

Gioco runner su LCD con Arduino

Gioco endless runner a scorrimento laterale su schermo LCD a 16x2 caratteri. L'eroe corre automaticamente, il giocatore salta gli ostacoli premendo il pulsante. Sulla riga superiore e inferiore compaiono ostacoli casuali. Il cicalino passivo riproduce la melodia di apertura, il suono di salto, il suono di celebrazione dei 50 punti e la melodia di fine gioco. All'avvio viene visualizzata la schermata iniziale "BlueGrays - Arduino Projects".

4.6(32)
56