Tipi di display per Arduino: LCD, OLED, TFT, e-paper e 7 segmenti
Display per Arduino a confronto: LCD 16x2, OLED, TFT, e-paper, TM1637, MAX7219 e Nextion; risoluzione, pin, memoria, consumi e quale scegliere nei progetti.
I tipi di display per Arduino all'inizio confondono: la stessa parola "display" indica un LCD da 16 caratteri, un OLED grande come un'unghia, un TFT colorato come lo schermo di un telefono e un e-paper che conserva l'immagine anche senza corrente. Risoluzione, colore, tipo di collegamento, memoria ed energia cambiano moltissimo dall'uno all'altro. Una scelta sbagliata finisce con un Uno senza RAM, un indicatore illeggibile al sole o un sensore che svuota la batteria in un giorno.
In questa guida esaminiamo una per una le sette famiglie di display più usate nei progetti con Arduino: LCD a caratteri (16x2 e 20x4), OLED (SSD1306 e SH1106), TFT a colori (ILI9341 e ST7789), e-paper, 7 segmenti e TM1637, matrici LED MAX7219 e display touch Nextion. Prima trovi una grande tabella di confronto, poi una breve presentazione e un codice di esempio funzionante per ogni display, e alla fine una tabella "quale display per quale progetto" e gli errori più comuni.

Tipi di display per Arduino: tabella di confronto rapido
| Display | Risoluzione | Colore | Interfaccia | Pin dati | Corrente tipica | Prezzo |
|---|---|---|---|---|---|---|
| LCD a caratteri 16x2 / 20x4 | 16×2 o 20×4 caratteri | Monocromatico, retroilluminato | Parallela o modulo I2C | 6 (parallela) / 2 (I2C) | 20–40 mA | Molto economico |
| OLED SSD1306 / SH1106 | 128×64 (0,96" e 1,3") | Monocromatico (bianco, blu, giallo-blu) | I2C o SPI | 2 (I2C) / 5 (SPI) | 10–25 mA | Economico |
| TFT ILI9341 | 240×320 (2,4–3,2") | 65 mila colori | SPI o parallela a 8 bit | 5 (SPI) | 50–100 mA | Medio |
| TFT ST7789 | 240×240, 240×320, 135×240 | 65 mila colori | SPI | 4–5 | 30–80 mA | Medio |
| E-paper (e-ink) | 200×200, 296×128, 250×122 | Bianco e nero (alcuni rosso/giallo) | SPI | 6 (BUSY compreso) | 5–20 mA solo durante l'aggiornamento | Medio-alto |
| 7 segmenti / TM1637 | 1–8 cifre | LED a un colore | Diretto o 2 fili (TM1637) | 8–12 / 2 | 20–80 mA | Molto economico |
| Matrice LED MAX7219 | 8×8, in cascata 32×8 e oltre | LED a un colore | 3 fili (simile a SPI) | 3 | 20–300 mA secondo la luminosità | Economico |
| Nextion HMI | Da 320×240 a 800×480 | 65 mila colori, touch | UART (TX/RX) | 2 | 90–500 mA | Costoso |
Il numero di "pin dati" nella tabella non comprende l'alimentazione (VCC e GND). Le correnti variano molto con retroilluminazione e luminosità; l'e-paper consuma solo mentre l'immagine cambia e poi quasi niente. I prezzi sono ordinati l'uno rispetto all'altro: con il prezzo di un Nextion compri circa dieci LCD 16x2.
Cosa guardare quando scegli un display
- Cosa devi mostrare? Solo numeri: 7 segmenti; qualche riga di testo: LCD a caratteri; grafica e icone: OLED; interfaccia a colori o foto: TFT.
- Dove verrà letto? E-paper e LCD si leggono bene al sole; OLED e TFT soffrono con luce forte. Al buio invece il nero di un OLED è nero davvero e non affatica la vista.
- Quanti pin hai liberi? I display I2C si accontentano di due fili; un LCD in parallelo ne vuole sei, un TFT SPI cinque e un e-paper sei. Per il conto dei pin guarda gli articoli su I2C e SPI.
- La memoria della scheda basta? I 2 KB di RAM dell'Uno contengono a malapena il buffer di un OLED e mai quello di un TFT a colori. Su ESP32 e Pico il problema quasi non esiste.
- Funzionerà a batteria? L'e-paper, che conserva l'immagine senza consumare, non ha rivali per i sensori che lavorano per mesi.
- Livello di tensione: la maggior parte dei moduli TFT ed e-paper lavora con logica a 3,3 V; con un Uno può servire un traslatore di livello.
- Supporto delle librerie: i display che funzionano con librerie diffuse come Adafruit GFX, U8g2, TFT_eSPI e LiquidCrystal_I2C rendono molto più facile trovare esempi e risolvere i problemi.
LCD a caratteri: 16x2 e 20x4
Gli LCD a caratteri con controller HD44780 sono il display classico di Arduino. Ogni carattere è formato da 5×8 punti; il modello 16x2 mostra 2 righe da 16 caratteri e il 20x4 4 righe da 20. Poiché è il controller del display a conservare l'immagine, su Arduino non consuma quasi RAM. Con il collegamento diretto servono 6 pin (RS, E e D4–D7) più un potenziometro per il contrasto; abbiamo spiegato questo metodo nell'articolo Collegamento in parallelo dell'LCD 16x2. Con un modulo I2C basato sul PCF8574 saldato sul retro bastano SDA e SCL. Puoi definire fino a 8 caratteri personalizzati per disegnare il simbolo dei gradi, un'icona della batteria o lettere accentate. L'uso dettagliato è nell'articolo Display LCD I2C.
1// I2C 16x2 LCD: sıcaklık gibi bir değeri göstermek / I2C 16x2 LCD: showing a value such as temperature
2// SDA -> A4, SCL -> A5, VCC -> 5V, GND -> GND
3#include <Wire.h>
4#include <LiquidCrystal_I2C.h>
5
6LiquidCrystal_I2C lcd(0x27, 16, 2); // adres 0x27 ya da 0x3F / address 0x27 or 0x3F
7
8byte degree[8] = { // kendi karakterin: derece işareti / custom character: degree sign
9 0b00110, 0b01001, 0b01001, 0b00110,
10 0b00000, 0b00000, 0b00000, 0b00000
11};
12
13void setup() {
14 lcd.init();
15 lcd.backlight();
16 lcd.createChar(0, degree); // 8 özel karakterden ilki / first of 8 custom characters
17 lcd.setCursor(0, 0);
18 lcd.print("BlueGrays LCD");
19}
20
21void loop() {
22 int raw = analogRead(A0); // A0'a bağlı bir sensör / a sensor on A0
23 float value = raw * 100.0 / 1023.0;
24 lcd.setCursor(0, 1);
25 lcd.print("Deger: ");
26 lcd.print(value, 1);
27 lcd.write(byte(0)); // derece işaretini yaz / print the degree sign
28 lcd.print(" "); // eski karakterleri sil / clear leftover characters
29 delay(500);
30}OLED: SSD1306 e SH1106

Nei display OLED ogni pixel produce la propria luce; non c'è retroilluminazione, il contrasto è altissimo e l'immagine è nitida da ogni angolazione. I modelli da 0,96 pollici di solito usano il controller SSD1306, quelli da 1,3 pollici quasi sempre l'SH1106. Da fuori sono uguali, ma la memoria interna dell'SH1106 ha 132 colonne; pilotando un SH1106 con una libreria per SSD1306 l'immagine si sposta di due pixel e sul bordo compare una striscia disturbata. La soluzione è scegliere la libreria o il costruttore adatti al controller. La libreria U8g2 li supporta entrambi e, grazie alla modalità a pagine, sull'Uno funziona con un buffer di soli 128 byte. Trovi le basi dell'SSD1306 nell'articolo Display OLED (SSD1306).
1// U8g2 ile 1,3" SH1106 OLED (sayfa modu, Uno'da az RAM) / 1.3" SH1106 OLED with U8g2 (page mode, low RAM on the Uno)
2// SDA -> A4, SCL -> A5. 0,96" SSD1306 için yorumdaki satırı kullan / for a 0.96" SSD1306 use the commented line
3#include <U8g2lib.h>
4#include <Wire.h>
5
6U8G2_SH1106_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
7// U8G2_SSD1306_128X64_NONAME_1_HW_I2C oled(U8G2_R0, U8X8_PIN_NONE);
8
9void setup() {
10 oled.begin();
11}
12
13void loop() {
14 int level = map(analogRead(A0), 0, 1023, 0, 120); // A0'daki potansiyometre / potentiometer on A0
15 oled.firstPage();
16 do { // her sayfa için aynı çizim tekrarlanır / the same drawing repeats per page
17 oled.setFont(u8g2_font_ncenB08_tr);
18 oled.drawStr(0, 12, "BlueGrays OLED");
19 oled.drawFrame(0, 40, 124, 14); // çubuk çerçevesi / bar frame
20 oled.drawBox(2, 42, level, 10); // dolu çubuk / filled bar
21 } while (oled.nextPage());
22 delay(100);
23}Il _1_ nel nome del costruttore significa che lo schermo viene disegnato a pagine di 8 righe: il ciclo firstPage() / nextPage() ripete lo stesso disegno otto volte e ogni volta invia una striscia dello schermo. È un po' più lento, ma usa 128 byte di RAM invece di 1 KB. Su ESP32 e Pico, dove la memoria abbonda, puoi scegliere la versione _F_ con buffer completo e ottenere animazioni più fluide.
TFT a colori: ILI9341 e ST7789

Se vuoi grafici, menu, icone e indicatori a colori, passi ai display TFT. Ogni pixel ha un colore a 16 bit (RGB565), cioè circa 65 mila colori. I due controller più diffusi sono l'ILI9341 e l'ST7789. L'ILI9341 si usa su schermi 240×320 da 2,4 a 3,2 pollici e spesso arriva con un controller touch XPT2046. L'ST7789 si trova su schermi quadrati da 1,3 e 1,54 pollici (240×240) e su quelli da 135×240 di schede come la TTGO T-Display. Funzionano con l'Uno, ma lentamente: anche solo riempire una volta tutto lo schermo richiede un tempo visibile. Sull'ESP32, con SPI a 40 MHz e librerie ottimizzate come TFT_eSPI, si ottengono interfacce fluide. Per i dettagli vedi gli articoli Display TFT ILI9341 e Display TFT ST7789.
| Caratteristica | ILI9341 | ST7789 |
|---|---|---|
| Dimensioni comuni | 2,4", 2,8", 3,2" | 1,14", 1,3", 1,54", 2,0" |
| Risoluzione | 240×320 | 135×240, 240×240, 240×320 |
| Interfaccia | SPI (le versioni shield per Uno usano la parallela a 8 bit) | SPI (alcuni modelli senza pin CS) |
| Touch | Touch resistivo XPT2046 sulla maggior parte dei modelli | Di solito assente |
| Libreria | Adafruit_ILI9341, TFT_eSPI | Adafruit_ST7789, TFT_eSPI |
| Dimensione del buffer a schermo intero | 153.600 byte | 115.200 byte (240×240) |
1// ESP32 + 2,8" ILI9341 TFT: renkli sıcaklık göstergesi / colour temperature gauge
2// SCK 18, MOSI 23, MISO 19 (isteğe bağlı / optional), CS 5, DC 16, RST 17, VCC 3V3, LED 3V3
3#include <SPI.h>
4#include <Adafruit_GFX.h>
5#include <Adafruit_ILI9341.h>
6
7const int TFT_CS = 5;
8const int TFT_DC = 16;
9const int TFT_RST = 17;
10
11Adafruit_ILI9341 tft(TFT_CS, TFT_DC, TFT_RST); // donanım SPI (VSPI) / hardware SPI (VSPI)
12
13void setup() {
14 tft.begin(40000000); // 40 MHz SPI
15 tft.setRotation(1); // yatay 320x240 / landscape 320x240
16 tft.fillScreen(ILI9341_BLACK);
17 tft.setTextColor(ILI9341_WHITE);
18 tft.setTextSize(2);
19 tft.setCursor(10, 10);
20 tft.print("BlueGrays TFT");
21 tft.drawRect(10, 180, 300, 30, ILI9341_WHITE); // çubuk çerçevesi / bar frame
22}
23
24void loop() {
25 float temp = 20.0 + (analogReadMilliVolts(34) / 3300.0) * 20.0; // örnek değer / example value
26 uint16_t color = temp < 26 ? ILI9341_GREEN : (temp < 33 ? ILI9341_YELLOW : ILI9341_RED);
27
28 tft.fillRect(10, 60, 300, 80, ILI9341_BLACK); // yalnız değişen alanı sil / clear only the changing area
29 tft.setTextSize(6);
30 tft.setTextColor(color);
31 tft.setCursor(20, 70);
32 tft.print(temp, 1);
33 tft.print(" C");
34
35 int w = (int)((temp - 20.0) / 20.0 * 296);
36 tft.fillRect(12, 182, w, 26, color);
37 tft.fillRect(12 + w, 182, 296 - w, 26, ILI9341_BLACK);
38 delay(500);
39}Display e-paper (e-ink)
L'e-paper è la tecnologia di visualizzazione dei lettori di ebook. Forma l'immagine spostando minuscole capsule di pigmento bianco e nero con un campo elettrico; una volta disegnata, l'immagine resta sullo schermo anche se manca la corrente. Insieme alla modalità deep sleep dell'ESP32 è quindi ideale per stazioni che si svegliano una volta all'ora, aggiornano il meteo e funzionano per mesi a batteria. Poiché sembra carta, al sole si legge perfettamente. Il difetto è la velocità: un aggiornamento completo richiede circa 2 secondi e lo schermo lampeggia più volte; sui modelli con aggiornamento parziale si scende sotto il mezzo secondo, ma aggiornamenti parziali frequenti possono lasciare deboli immagini fantasma. Si collega via SPI e richiede MOSI, SCK, CS, DC, RST e un pin BUSY che segnala che il display è occupato. La libreria più usata è GxEPD2.
| Caratteristica | Valore |
|---|---|
| Dimensioni comuni | 1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300) |
| Colore | Bianco e nero; i modelli a tre colori aggiungono rosso o giallo (aggiornamento di 10–15 secondi) |
| Aggiornamento completo | Circa 1–3 secondi |
| Aggiornamento parziale | 0,3–0,5 secondi sui modelli che lo supportano |
| Corrente a riposo | Quasi zero mentre conserva l'immagine |
| Alimentazione | 3,3 V (la maggior parte dei moduli accetta 5 V grazie a un regolatore) |
Display a 7 segmenti e TM1637

Se devi mostrare solo numeri, i display a 7 segmenti restano l'opzione più leggibile: grandi, luminosi e visibili a diversi metri. Un display a una cifra richiede 8 pin per i 7 segmenti e il punto, più una resistenza per segmento; uno a 4 cifre multiplexato usa 12 pin. Abbiamo spiegato questi collegamenti e la differenza tra anodo comune e catodo comune nell'articolo Display a 7 segmenti. Il modo più semplice per uscire dal problema dei pin è il modulo TM1637: colleghi il display a 4 cifre, che ha il suo driver, con soli CLK e DIO e regoli la luminosità via software in 8 livelli. Anche se il protocollo del TM1637 somiglia all'I2C, non usa indirizzi; per questo può andare su due pin digitali qualsiasi e ogni modulo richiede la propria coppia di pin.
1// TM1637 4 haneli gösterge ile sayaç ve saat / Counter and clock with a TM1637 4-digit display
2// CLK -> D2, DIO -> D3, VCC -> 5V, GND -> GND
3#include <TM1637Display.h>
4
5TM1637Display display(2, 3); // CLK, DIO
6unsigned long lastTick = 0;
7int seconds = 0;
8
9void setup() {
10 display.setBrightness(4); // 0 (sönük) - 7 (en parlak) / 0 (dim) - 7 (brightest)
11 display.clear();
12}
13
14void loop() {
15 if (millis() - lastTick >= 1000) {
16 lastTick = millis();
17 seconds++;
18 int mm = (seconds / 60) % 100;
19 int ss = seconds % 60;
20 // 0b01000000: ortadaki iki nokta / the colon in the middle
21 display.showNumberDecEx(mm * 100 + ss, 0b01000000, true);
22 }
23}Matrice LED MAX7219

Il MAX7219 è un integrato che pilota da solo 64 LED (una matrice 8×8 o un display a 7 segmenti a 8 cifre) e comunica su tre fili, DIN, CLK e CS, con un protocollo simile a SPI. I moduli si possono collegare in cascata; con i comuni moduli 4 in 1 si realizzano pannelli a scritta scorrevole da 32×8, con due file da 32×16. La luminosità e la leggibilità a distanza lo rendono ideale per pannelli messaggi, segnapunti e orologi. Su Arduino si usano soprattutto le librerie MD_Parola e MD_MAX72XX; i dettagli sono nell'articolo Matrice LED MAX7219. Qui sotto pilotiamo una singola matrice 8×8 con un Raspberry Pi Pico senza librerie, scrivendo direttamente nei registri:
1# Raspberry Pi Pico: kütüphanesiz MAX7219 8x8 matris / MAX7219 8x8 matrix without a library
2# GP18 -> CLK, GP19 -> DIN, GP17 -> CS, VCC -> VBUS (5 V), GND -> GND
3from machine import Pin, SPI
4import time
5
6spi = SPI(0, baudrate=1_000_000, polarity=0, phase=0, sck=Pin(18), mosi=Pin(19))
7cs = Pin(17, Pin.OUT, value=1)
8
9def write_reg(reg, value):
10 cs.value(0)
11 spi.write(bytearray([reg, value])) # önce yazmaç, sonra değer / register first, then value
12 cs.value(1)
13
14def init():
15 write_reg(0x0F, 0x00) # test modu kapalı / display test off
16 write_reg(0x09, 0x00) # kod çözme yok (matris) / no decode (matrix)
17 write_reg(0x0B, 0x07) # 8 satırın hepsi / scan all 8 rows
18 write_reg(0x0A, 0x03) # parlaklık 0-15 / brightness 0-15
19 write_reg(0x0C, 0x01) # uyku modundan çık / leave shutdown mode
20
21SMILE = [0x3C, 0x42, 0xA5, 0x81, 0xA5, 0x99, 0x42, 0x3C]
22HEART = [0x00, 0x66, 0xFF, 0xFF, 0xFF, 0x7E, 0x3C, 0x18]
23
24def show(image):
25 for row in range(8):
26 write_reg(row + 1, image[row]) # satır yazmaçları 1-8 / row registers 1-8
27
28init()
29while True:
30 show(SMILE)
31 time.sleep(1)
32 show(HEART)
33 time.sleep(1)Perché i LED brillino bene, il MAX7219 va alimentato a 5 V; per questo il VCC del modulo va al pin VBUS del Pico. Secondo il datasheet, con alimentazione a 5 V gli ingressi devono ricevere almeno 3,5 V per essere letti come HIGH; i segnali a 3,3 V del Pico funzionano senza problemi sulla maggior parte dei moduli, ma se noti instabilità aggiungi un traslatore di livello sulle linee DIN, CLK e CS. La corrente cresce con la luminosità e con il numero di LED accesi: con tutti e quattro i moduli completamente accesi alla massima luminosità si possono assorbire centinaia di milliampere.
Display touch HMI Nextion
Nextion è un display touch intelligente con processore e memoria propri. Progetti l'interfaccia con pulsanti, cursori e indicatori sul computer in Nextion Editor con il trascinamento e la carichi sul display; Arduino invia solo brevi comandi come t0.txt="25" tramite la porta seriale (UART) e legge gli eventi touch. Così tutto il lavoro di disegno spetta al display, e anche una scheda piccola come l'Uno può gestire un'interfaccia a colori da 7 pollici. La velocità predefinita è 9600 baud. Gli svantaggi sono il prezzo, un consumo di 90 mA già sul modello da 2,4 pollici e fino a 500 mA su quello da 7, e la progettazione in un programma separato. Sull'Uno la seriale hardware è condivisa con l'USB, quindi usare SoftwareSerial o scegliere schede con più porte seriali, come Mega ed ESP32, semplifica le cose.
Memoria necessaria: quale display sta su un Uno?
La maggior parte delle librerie per display grafici disegna prima l'immagine in un buffer in RAM e poi la invia tutta allo schermo. Dimensione del buffer = larghezza × altezza × bit per pixel / 8. Se ricordi che Arduino Uno ha solo 2 KB di RAM, di cui una parte va a variabili, porta seriale e librerie, il limite salta subito all'occhio. Abbiamo raccolto le soluzioni generali ai problemi di memoria nell'articolo Arduino con memoria insufficiente.
| Display | Buffer completo | Arduino Uno (2 KB) | ESP32 (520 KB) / Pico (264 KB) |
|---|---|---|---|
| LCD 16x2 | Non serve (lo conserva il display) | Nessun problema | Nessun problema |
| OLED 128×64 | 1.024 byte | Al limite; consigliata la modalità a pagine (128 byte) | Nessun problema |
| OLED 128×32 | 512 byte | Nessun problema | Nessun problema |
| E-paper 296×128 | 4.736 byte | Solo disegnando pagina per pagina | Nessun problema |
| TFT ST7789 240×240 | 115.200 byte | Impossibile; si disegna direttamente sullo schermo | Possibile sull'ESP32, metà della RAM sul Pico |
| TFT ILI9341 240×320 | 153.600 byte | Impossibile; si disegna direttamente sullo schermo | Possibile, ma di solito si preferiscono piccoli sprite |
Consumi e uso a batteria
In un progetto a batteria il display consuma spesso più energia del microcontrollore. La sola retroilluminazione di un LCD 16x2 può superare i 20 mA; se la spegni (lcd.noBacklight()), il display resta leggibile al sole ma non al buio. La corrente di un OLED è proporzionale ai pixel accesi: un testo bianco sottile su fondo nero consuma diverse volte meno di un fondo bianco. Nei TFT i LED della retroilluminazione sono sempre accesi; controllare il pin della retroilluminazione con un transistor o in PWM fa risparmiare molto. L'e-paper non consuma quasi nulla finché non cambi l'immagine. Per calcolare l'autonomia puoi usare il metodo dell'articolo sui mAh.
Quale display per quale progetto?
| Progetto | Display consigliato | Perché? |
|---|---|---|
| Indicatore di temperatura e umidità | LCD 16x2 I2C o OLED da 0,96" | Economico, due fili, bastano poche righe di testo |
| Orologio digitale e conto alla rovescia | TM1637 o MAX7219 | Cifre grandi e luminose; leggibili da lontano |
| Gioco tascabile (Pong, serpente, T-Rex) | OLED 128×64 o matrice 8×8 | Aggiornamento rapido, disegno a livello di pixel |
| Stazione meteo (a batteria) | E-paper + deep sleep dell'ESP32 | L'immagine resta senza consumare, leggibile al sole |
| Pannello di controllo e menu a colori | ILI9341 con touch o Nextion | Colori, icone e ingresso touch |
| Scritte scorrevoli e pannello messaggi | Moduli MAX7219 in cascata | Visibile a metri di distanza, si allunga con un solo CS |
| Dispositivo compatto con ESP32 | ST7789 da 1,14" o 1,3" | Piccolo, a colori e veloce via SPI |
Errori comuni e soluzioni
| Sintomo | Causa probabile | Soluzione |
|---|---|---|
| L'LCD mostra solo rettangoli pieni | Contrasto non regolato o display non inizializzato | Gira il potenziometro del contrasto, controlla l'indirizzo e la chiamata lcd.init() |
| Immagine spostata e disturbi sul bordo di un OLED da 1,3" | Un display SH1106 pilotato con una libreria per SSD1306 | Usa il costruttore SH1106 di U8g2 o la libreria Adafruit SH110X |
| Lo sketch OLED si carica ma l'Uno si blocca | Il buffer del display ha esaurito la RAM | Usa la modalità a pagine di U8g2, metti i testi in F() |
| Il TFT resta tutto bianco | Controller sbagliato, pin sbagliati o segnale a 5 V | Verifica il controller (ILI9341, ST7789), controlla i pin DC e CS, rispetta il livello a 3,3 V |
| L'e-paper non cambia mai | Pin BUSY non collegato o modello sbagliato | Collega BUSY e scegli in GxEPD2 la classe esatta del tuo pannello |
| Alcuni segmenti del display a 7 segmenti sono deboli | Anodo comune e catodo comune confusi o resistenza mancante | Controlla il tipo di display, metti una resistenza su ogni segmento |
| Il MAX7219 accende LED a caso | Filo allentato, alimentazione debole o segnale a 3,3 V al limite | Accorcia i fili, rinforza l'alimentazione a 5 V, aggiungi un traslatore di livello se serve |
Il display giusto dipende da cosa mostra il tuo progetto, da dove verrà letto e da come è alimentato: LCD per il testo, OLED per piccoli grafici, TFT o Nextion per interfacce a colori, e-paper per i dispositivi a batteria, 7 segmenti e MAX7219 per cifre grandi. Nell'app BlueGrays trovi progetti con LCD I2C, giochi e schermata meteo su OLED, orologio TM1637 e matrice di punti MAX7219, passo dopo passo con schemi del circuito e codice.
Domande frequenti
Qual è il miglior display per Arduino?
Non esiste un unico display migliore; la scelta dipende dal progetto. Per qualche riga di testo va bene un LCD 16x2 I2C, per piccoli grafici un OLED da 0,96 pollici, per un'interfaccia a colori un TFT ILI9341 e per i dispositivi a batteria un e-paper.
Meglio OLED o LCD?
L'OLED è più nitido, ha un contrasto elevato, può disegnare grafici e si legge benissimo al buio. L'LCD a caratteri costa meno, si legge meglio al sole e su Arduino non consuma quasi RAM.
Arduino Uno può gestire un display TFT a colori?
Sì, i TFT SPI come l'ILI9341 o l'ST7789 funzionano con l'Uno, ma poiché manca la RAM per un buffer a schermo intero, si disegna direttamente sullo schermo e lentamente. Per interfacce a colori fluide è meglio un ESP32 o un Raspberry Pi Pico.
Che differenza c'è tra SSD1306 e SH1106?
Sono entrambi controller per OLED 128×64; l'SSD1306 si trova di solito sugli schermi da 0,96 pollici e l'SH1106 su quelli da 1,3. Poiché la memoria dell'SH1106 ha 132 colonne, con una libreria per SSD1306 l'immagine si sposta; serve una libreria adatta come U8g2 o Adafruit SH110X.
Un display e-paper conserva l'immagine senza corrente?
Sì. L'e-paper forma l'immagine spostando capsule di pigmento e, una volta disegnata, l'immagine resta sullo schermo senza energia. Per questo è ideale per dispositivi a batteria che si aggiornano una volta all'ora.
Il TM1637 è I2C?
No. Il protocollo a due fili del TM1637 somiglia all'I2C, ma non usa indirizzi e non va su un bus I2C. Si collega a due pin digitali qualsiasi e si pilota con la sua libreria (ad esempio TM1637Display); più moduli richiedono ciascuno la propria coppia di pin.
Progetti da realizzare dopo questo articolo
Vedi tutti i progetti
Utilizzo dello schermo LCD con I2C
Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

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…

Gioco delle Racchette - SSD1306
Una pallina, due racchette e tu: giochi a ping pong, uno dei primissimi videogiochi, su un piccolo display OLED.

OLED T-Rex Run: Gioco del dinosauro con Arduino
Il gioco del dinosauro che compare quando salta internet, ora sulla tua scrivania: il dinosauro corre sul piccolo display OLED, i cactus gli vengono incontro e tu salti con un solo pulsante.

ESP32 HTTPClient + API meteo (con display OLED SSD1306)
L'ESP32 effettua via internet una chiamata REST a un'API meteo (wttr.in) con HTTPClient.h. A differenza della versione con LCD I2C, qui usiamo un display OLED SSD1306 (128×64), con testo grande e icone vettoriali per una resa più ricca. Sette icone meteo (sole, pioggia, neve e altre) vengono disegnate al volo, senza file bitmap.

ESP32 TM1637 Display a 7 segmenti a 4 cifre
Stiamo controllando un modulo display a 7 segmenti a 4 cifre con driver TM1637 tramite ESP32. Utilizzando solo 2 GPIO (CLK e DIO), gestiamo un contatore compreso tra 0 e 9999, regoliamo il livello di luminosità e visualizziamo il carattere dei due punti centrali (:) in formato orologio. Grazie alla libreria TM1637Display, il controllo di numeri, valori esadecimali, segmenti e stringhe è molto semplice.

Orologio e calendario a matrice di punti (MAX7219, DS1307)
Un pannello luminoso per la scrivania o la parete che mostra ora e data con scritte scorrevoli.

Orologio digitale con display a 7 segmenti a 4 cifre
Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.
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

