Guide · 10 min di lettura

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.

Display LCD 16x2 con modulo I2C
LCD a caratteri 16x2 con modulo I2C: il display per Arduino più economico e più facile da leggere, collegato con soli due fili di dati.

Tipi di display per Arduino: tabella di confronto rapido

DisplayRisoluzioneColoreInterfacciaPin datiCorrente tipicaPrezzo
LCD a caratteri 16x2 / 20x416×2 o 20×4 caratteriMonocromatico, retroilluminatoParallela o modulo I2C6 (parallela) / 2 (I2C)20–40 mAMolto economico
OLED SSD1306 / SH1106128×64 (0,96" e 1,3")Monocromatico (bianco, blu, giallo-blu)I2C o SPI2 (I2C) / 5 (SPI)10–25 mAEconomico
TFT ILI9341240×320 (2,4–3,2")65 mila coloriSPI o parallela a 8 bit5 (SPI)50–100 mAMedio
TFT ST7789240×240, 240×320, 135×24065 mila coloriSPI4–530–80 mAMedio
E-paper (e-ink)200×200, 296×128, 250×122Bianco e nero (alcuni rosso/giallo)SPI6 (BUSY compreso)5–20 mA solo durante l'aggiornamentoMedio-alto
7 segmenti / TM16371–8 cifreLED a un coloreDiretto o 2 fili (TM1637)8–12 / 220–80 mAMolto economico
Matrice LED MAX72198×8, in cascata 32×8 e oltreLED a un colore3 fili (simile a SPI)320–300 mA secondo la luminositàEconomico
Nextion HMIDa 320×240 a 800×48065 mila colori, touchUART (TX/RX)290–500 mACostoso

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.

C++ (Arduino IDE)
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}
Se un LCD I2C non mostra nulla, gira prima il potenziometro blu del contrasto sul retro del modulo; spesso esce dalla fabbrica regolato male. Se resta vuoto, l'indirizzo potrebbe essere 0x3F invece di 0x27; uno sketch scanner I2C ti mostra l'indirizzo giusto in pochi secondi.

OLED: SSD1306 e SH1106

Display OLED I2C da 0,96 pollici
OLED I2C da 0,96 pollici: 128×64 pixel che producono la propria luce e solo 4 pin di collegamento.

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).

C++ (Arduino IDE)
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

Modulo display TFT a colori ILI9341
TFT a colori da 2,8 pollici con controller ILI9341: 240×320 pixel, 65 mila colori e collegamento SPI; alcuni modelli hanno anche pannello touch e slot per scheda SD.

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.

CaratteristicaILI9341ST7789
Dimensioni comuni2,4", 2,8", 3,2"1,14", 1,3", 1,54", 2,0"
Risoluzione240×320135×240, 240×240, 240×320
InterfacciaSPI (le versioni shield per Uno usano la parallela a 8 bit)SPI (alcuni modelli senza pin CS)
TouchTouch resistivo XPT2046 sulla maggior parte dei modelliDi solito assente
LibreriaAdafruit_ILI9341, TFT_eSPIAdafruit_ST7789, TFT_eSPI
Dimensione del buffer a schermo intero153.600 byte115.200 byte (240×240)
C++ (Arduino IDE)
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}
La maggior parte dei moduli TFT SPI lavora con logica a 3,3 V e non ha un traslatore di livello a bordo. Collegare direttamente i pin a 5 V dell'Uno può danneggiare il display col tempo; metti in mezzo delle resistenze in serie o un traslatore di livello. Gli shield TFT da 2,4 pollici che si innestano direttamente sull'Uno occupano quasi tutti i pin e non lasciano spazio ad altri moduli. ESP32 e Pico lavorano nativamente a 3,3 V e non hanno questo problema.

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.

CaratteristicaValore
Dimensioni comuni1,54" (200×200), 2,13" (250×122), 2,9" (296×128), 4,2" (400×300)
ColoreBianco e nero; i modelli a tre colori aggiungono rosso o giallo (aggiornamento di 10–15 secondi)
Aggiornamento completoCirca 1–3 secondi
Aggiornamento parziale0,3–0,5 secondi sui modelli che lo supportano
Corrente a riposoQuasi zero mentre conserva l'immagine
Alimentazione3,3 V (la maggior parte dei moduli accetta 5 V grazie a un regolatore)

Display a 7 segmenti e TM1637

Modulo display a 7 segmenti TM1637 a 4 cifre
Modulo TM1637 a 4 cifre: un display da orologio con i due punti al centro, collegato solo con i fili CLK e DIO.

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.

C++ (Arduino IDE)
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

Modulo matrice di punti LED MAX7219 8x32
Modulo MAX7219 8×32 formato da quattro matrici 8×8: collegato in cascata su una sola linea CS per scritte scorrevoli, orologi e semplici animazioni.

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:

MicroPython
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.

DisplayBuffer completoArduino Uno (2 KB)ESP32 (520 KB) / Pico (264 KB)
LCD 16x2Non serve (lo conserva il display)Nessun problemaNessun problema
OLED 128×641.024 byteAl limite; consigliata la modalità a pagine (128 byte)Nessun problema
OLED 128×32512 byteNessun problemaNessun problema
E-paper 296×1284.736 byteSolo disegnando pagina per paginaNessun problema
TFT ST7789 240×240115.200 byteImpossibile; si disegna direttamente sullo schermoPossibile sull'ESP32, metà della RAM sul Pico
TFT ILI9341 240×320153.600 byteImpossibile; si disegna direttamente sullo schermoPossibile, 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?

ProgettoDisplay consigliatoPerché?
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 rovesciaTM1637 o MAX7219Cifre grandi e luminose; leggibili da lontano
Gioco tascabile (Pong, serpente, T-Rex)OLED 128×64 o matrice 8×8Aggiornamento rapido, disegno a livello di pixel
Stazione meteo (a batteria)E-paper + deep sleep dell'ESP32L'immagine resta senza consumare, leggibile al sole
Pannello di controllo e menu a coloriILI9341 con touch o NextionColori, icone e ingresso touch
Scritte scorrevoli e pannello messaggiModuli MAX7219 in cascataVisibile a metri di distanza, si allunga con un solo CS
Dispositivo compatto con ESP32ST7789 da 1,14" o 1,3"Piccolo, a colori e veloce via SPI

Errori comuni e soluzioni

SintomoCausa probabileSoluzione
L'LCD mostra solo rettangoli pieniContrasto non regolato o display non inizializzatoGira 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 SSD1306Usa il costruttore SH1106 di U8g2 o la libreria Adafruit SH110X
Lo sketch OLED si carica ma l'Uno si bloccaIl buffer del display ha esaurito la RAMUsa la modalità a pagine di U8g2, metti i testi in F()
Il TFT resta tutto biancoController sbagliato, pin sbagliati o segnale a 5 VVerifica il controller (ILI9341, ST7789), controlla i pin DC e CS, rispetta il livello a 3,3 V
L'e-paper non cambia maiPin BUSY non collegato o modello sbagliatoCollega BUSY e scegli in GxEPD2 la classe esatta del tuo pannello
Alcuni segmenti del display a 7 segmenti sono deboliAnodo comune e catodo comune confusi o resistenza mancanteControlla il tipo di display, metti una resistenza su ogni segmento
Il MAX7219 accende LED a casoFilo allentato, alimentazione debole o segnale a 3,3 V al limiteAccorcia i fili, rinforza l'alimentazione a 5 V, aggiungi un traslatore di livello se serve
Prima di inserire un display nel tuo progetto, esegui l'esempio fornito con la libreria. Se l'esempio funziona e il tuo codice no, il problema è nel codice; se non funziona neanche l'esempio, concentrati su collegamenti, indirizzo o scelta del controller. Questo semplice passo trasforma ore di tentativi in pochi minuti.

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.

Vedi tutti i progetti
Utilizzo dello schermo LCD con I2C
AR-32Principiante
Premium

Utilizzo dello schermo LCD con I2C

Regala al tuo Arduino uno schermo tutto suo e fagli scrivere il primo messaggio.

4.8(53)
70
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
Gioco delle Racchette - SSD1306
AR-86Intermedio
Premium

Gioco delle Racchette - SSD1306

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

4.5(47)
65
OLED T-Rex Run: Gioco del dinosauro con Arduino
AR-87Avanzato
Premium

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.

4.7(33)
53
ESP32 HTTPClient + API meteo (con display OLED SSD1306)
ES-32Avanzato
Premium

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.

4.3(10)
22
ESP32 TM1637 Display a 7 segmenti a 4 cifre
ES-23Intermedio
Premium

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.

4.7(20)
32
Orologio e calendario a matrice di punti (MAX7219, DS1307)
AR-84Intermedio
Premium

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.

5.0(37)
59
Orologio digitale con display a 7 segmenti a 4 cifre
AR-48Intermedio
Premium

Orologio digitale con display a 7 segmenti a 4 cifre

Un orologio digitale luminoso a quattro cifre, simile a quello del forno in cucina.

4.8(56)
73