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.

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.
| Caratteristica | Valore |
|---|---|
| Chip driver | HD44780 o compatibile (KS0066, SPLC780) |
| Display | 16 colonne × 2 righe, caratteri da 5 × 8 pixel |
| Alimentazione | 4,5–5,5 V (esistono anche versioni speciali a 3,3 V) |
| Corrente della logica | Circa 1–2 mA |
| Corrente della retroilluminazione | Circa 15–30 mA (LED, secondo il modello) |
| Bus dati | Parallelo a 8 o 4 bit |
| Caratteri personalizzati | 8 (CGRAM) |
| Durata dei comandi | La maggior parte 37 µs, clear() e home() circa 1,5 ms |
La funzione dei 16 pin
| Pin | Nome | Funzione | Collegamento |
|---|---|---|---|
| 1 | VSS | Massa | GND |
| 2 | VDD | Alimentazione della logica | 5V |
| 3 | V0 (VO, VEE) | Regolazione del contrasto | Cursore di un potenziometro da 10 kΩ |
| 4 | RS | Selezione comando (LOW) o carattere (HIGH) | Arduino D12 |
| 5 | RW | Lettura (HIGH) o scrittura (LOW) | GND (scriviamo soltanto) |
| 6 | E | Impulso di dato valido | Arduino D11 |
| 7–10 | D0–D3 | Bit di dati bassi | Liberi in modalità 4 bit |
| 11 | D4 | Bit di dati 4 | Arduino D5 |
| 12 | D5 | Bit di dati 5 | Arduino D4 |
| 13 | D6 | Bit di dati 6 | Arduino D3 |
| 14 | D7 | Bit di dati 7 | Arduino D2 |
| 15 | A (LED+) | Anodo della retroilluminazione | 5V tramite 220 Ω |
| 16 | K (LED−) | Catodo della retroilluminazione | GND |
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

È 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
- 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.
- 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.
- 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.
- Collega il pin 5 (RW) a GND. Poi RS a D12, E a D11 e D4–D7 rispettivamente a D5, D4, D3 e D2.
- Verifica nel Gestore librerie che LiquidCrystal sia installata (è inclusa nell'Arduino IDE) e carica il codice qui sotto.
- Quando i quadratini spariscono e compare il testo, regola un'ultima volta il contrasto con il potenziometro.
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.
| Comando | Cosa 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.
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.
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.
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.
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.
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| 16 quadratini neri solo sulla riga superiore | Display non inizializzato: fili RS, E, D4–D7 o ordine dei pin nel costruttore sbagliati, oppure codice non caricato | Controlla i fili con la tabella e l'ordine LiquidCrystal lcd(RS, E, D4, D5, D6, D7) |
| Quadratini tenui su entrambe le righe | Contrasto troppo alto (V0 troppo vicino a GND) | Ruota il potenziometro |
| Retroilluminazione accesa ma non si vede nulla | Contrasto troppo basso o V0 non collegato | Verifica che il cursore del potenziometro vada a V0 e ruotalo |
| La retroilluminazione non si accende | Pin 15 e 16 non collegati, invertiti o senza resistenza | Collega A a 5V tramite 220 Ω e K a GND |
| Caratteri senza senso o che si spostano | Un 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 sfarfalla | Si usa lcd.clear() nel loop | Sovrascrivi con setCursor() e cancella le cifre vecchie con spazi |
| Resta una cifra vecchia quando il numero si accorcia | Il nuovo valore è più corto del precedente | Aggiungi spazi dopo il valore |
| Dopo un carattere personalizzato non compare il testo | createChar ha spostato il cursore nella memoria dei caratteri | Chiama setCursor() dopo createChar |
Conviene passare a un modulo I2C?

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.
| Caratteristica | Parallelo (4 bit) | Con modulo I2C |
|---|---|---|
| Pin di Arduino usati | 6 | 2 (A4, A5) |
| Numero di fili | 12 (alimentazione e potenziometro inclusi) | 4 |
| Aggiornamento di tutto lo schermo | Meno di 2 ms | Circa 20–30 ms a 100 kHz |
| Regolazione del contrasto | Potenziometro esterno | Trimmer sul modulo |
| Spegnere la retroilluminazione via software | Serve un transistor in più | lcd.noBacklight() |
| Libreria | LiquidCrystal (inclusa nell'IDE) | LiquidCrystal I2C (da installare) |
| Problemi tipici | Groviglio di fili, contatti instabili | Indirizzo (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ù.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
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…

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.

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.

Misura di temperatura con NTC e display Lcd 2x16
Misura la temperatura dell'ambiente con un sensore che sembra una piccola perlina.

DS1302 Orologio RTC con display LCD
Un piccolo orologio da scrivania che non dimentica l'ora nemmeno se manca la corrente.

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

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…

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".
Altri articoli
App BlueGrays
Costruisci questo circuito passo passo sul telefono
Schema, codice ed elenco componenti in un’unica schermata. Oltre 500 progetti Arduino, ESP32 e Pico da realizzare.
Inquadra con il telefono
Punta la fotocamera sul codice: si apre lo store del tuo telefono.
oppure apri lo store

