ILI9341 Display LCD TFT SPI 2.8" 240×320 65K colori

Il display ILI9341 è un display LCD (cristalli liquidi) a matrice attiva TFT (Thin Film Transistor) . 

CARATTERISTICHE:

Il controller grafico del display è il driver della ILITEK ILI9341. Il display è da 2,8" pollci, ha un numero di colori pari a 65k ad alto contrasto con risoluzione di 320x240 pixel. Utilizza la tecnologia LCD è si presenta in due varianti: con il touch screen o senza touch screen. Nella variante con il touch screen è presente il chip HR2046, un integrato che gestisce il tocco su schermo. 

Il pannello touch screen è di tipo resistivo e con le versioni che presentano questa funzionalità è abbinato un pennino.

E' dotato di una retroilluminazione a LED bianchi che può essere controllata.

Il display è programmabile e può essere interfacciato con microcontrollori come ESP32, ARDUINO e RASPBERRY e altri circuiti integrati tramite un'interfaccia seriale SPI. Può essere alimentato a 3.3V o a 5V ed è utilizzabile con logica a 3.3V o a 5V.

Inoltre è presente un lettore per schede di memoria SD.

Tutti i collegamenti possono essere effetuati tramite due file di pin da 2,54 mm presenti sul display. Uno Slot da 14 pin che permette di alimentare e  collegare il display ad un controller, inclusi i pin dedicati al touch screen ove presente. Uno Slot da 4 pin dedicati alla scheda di memoria SD.

Il display può essere utilizzato in numerose applicazioni elettroniche, ad esempio la domotica e l'IOT. 

Inoltre possiamo trovare una versione con dimensioni e risoluzione dello schermo maggiori:  ILI9488 da 3,5" 480x320

COME LAVORA:

Un display LCD è costituito da un cristallo liquido racchiuso tra due substrati di vetro rivestiti di ossidi metallici saldati tra loro, che contengono lo stesso. All'esterno di questi tre strati, vengono posizionati i filtri polarizzanti per la luce. Gli LCD utilizzano una tecnologia trasmissiva a valvola di luce, in cui la luce bianca proveniente dalla retroilluminazione viene filtrata per variare la quantità di luce che passa attraverso il dispositivo, generando così la scala dei grigi. Per ottenere i colori, vengono aggiunti dei filtri colorati (rosso, verde e blu) in modo che ogni pixel corrisponda a tre elementi colorati. Il livello di luminosità di ogni pixel è ottenuto variando la tensione del campo elettrico applicato al cristallo liquido, poiché la posizione delle molecole del cristallo liquido e la quantità di luce che transita, è proporzionale alla tensione applicata. Nei display a matrice attiva, ad ogni elemento di ciascun pixel è associato un transistor, ottenendo così tempi di risposta e luminosità superiori rispetto a quelli con matrice passiva.

COME UTILIZZARLO:

Per utilizzare il display ILI9341 è necessario collegarlo ad una fonte di alimentazione a 3.3V o a 5V. Collegare i pin dell'interfaccia SPI ad un microcontrollore: CS, RESET, DC, SDI, SCK, LED e SDO.

Il controller può visualizzare 65k colori per pixel. L'mpostazione dell'indirizzo del pixel viene eseguito nell'ordine righe e colonne.

Il metodo di visualizzazione viene eseguito impostando l'indirizzo e poi il valore del colore.

Elenco dei pin:

• VCC(+): Alimentazione LCD (3.3V~5V)
• GND(-): Massa alimentazione LCD (GND)
• CS: Segnale di controllo selezione dispositivo LCD
• RESET: Segnale di controllo reset LCD
• DC: Segnale di controllo dei dati e del registro LCD
• SDI (MOSI): Segnale scrittura dati del bus SPI LCD
• SCK: Segnale di clock del bus SPI LCD
• LED: Segnale controllo retroilluminazione LCD, se non è necessario il controllo collegare a 3.3V
• SDO (MISO): Segnale lettura dati bus SPI LCD

Per le versioni con touch screen:

• T_CLK: Segnale di clock del bus SPI touch screen
• T_CS: Segnale di controllo selezione dispositivo touch screen 
• T_DIN: Segnale scrittura dati del bus SPI touch screen
• T_DO: Segnale lettura dati bus SPI touch screen
• T_IRQ: Segnale funzione interrupt touch screen

ESEMPIO DI UTILIZZO CON PLATFORMIO E ARDUINO IDE:

Per maggiori informazioni su PlatformIO.

Dispositivi utilizzati per l’esempio:

• Microcontrollore ESP32 DevKitC 38 PIN 
• ILI9341 Display LCD TFT SPI 2.8" 240x320 65K colori
• ESP32 DevKitC 38 PIN Screw Terminal Board o Breadboard

In alternativa all' ESP32 DevKitC 38 PIN Screw Terminal Board è possibile utilizzare:

•  ESP32 DevKitC Multimedia Board

Qui è possibile consultare ulteriori esempi sui display:

• https://ziotester.github.io/code/tft-espi/
• https://ziotester.github.io/code/lvgl/
• https://ziotester.github.io/retrogaming/nesp32/

Collegamenti:

• Pin Vcc display ➞ 3.3V Esp32
• Pin GND display ➞ GND Esp32 
• Pin CS display ➞ GPIO 22 Esp32
• Pin Reset display ➞ GPIO 17 Esp32
• Pin DC display ➞ GPIO 21 Esp32
• Pin SDI(MOSI) display ➞ GPIO 23 Esp32
• Pin SCK display ➞ GPIO 18 Esp32
• Pin LED display ➞ GPIO 5 Esp32
• Pin SDO(MISO) display ➞ GPIO 19 Esp32

Codice:

Platformio.ini:

[env:esp32dev]
platform = espressif32
board = esp32dev
framework = arduino
monitor_speed = 115200
upload_speed  = 921600
monitor_filters = esp32_exception_decoder
lib_deps = bodmer/TFT_eSPI @ ^2.5.0

Per l’esempio abbiamo aggiunto ed utilizzato la libreria: https://github.com/Bodmer/TFT_eSPI.

Main.cpp:

// specificare i collegamenti dei pin in User_Setup.h parte esp32 

#include <Arduino.h>
#include <TFT_eSPI.h>  // Includiamo la libreria specifica del progetto 

TFT_eSPI tft = TFT_eSPI(); 

void setup() {
  tft.init(); // Inizializziamo il diplay

}

void loop() {
  tft.init();
  // Selezioniamo l'orientamento dell'immagine sul display
  tft.setRotation(3); 
  // Posizione del cursore
  tft.setCursor(49, 30); 
   // Colore del testo
  tft.setTextColor(0xFFFF);
  // Dimensione del testo
  tft.setTextSize(3); 
  // Cancelliamo il contenuto del display
  tft.fillScreen(0xFC00); 
  delay(1000);
  // Scriviamo sul dispaly utilizzando la funzione tft.print
  tft.print("Z"); 
  delay(300);
  tft.print("I");
  delay(300);
  tft.print("O");
  delay(300);
  tft.print(" ");
  delay(300);
  tft.print("T");
  delay(300);
  tft.print("E");
  delay(300);
  tft.print("S");
  delay(300);
  tft.print("T");
  delay(300);
  tft.print("E");
  delay(300);
  tft.print("R");
  delay(300);
  tft.print(".");
  delay(300);
  tft.print("I");
  delay(300);
  tft.println("T");
  delay(500);
  // Disegnamo un rettangolo
  tft.drawRect(85, 87, 140, 20, 0xFFFF); 
  // Riempiamo il rettangolo
  tft.fillRect(85, 87, 140, 20, 0xFFFF); 
  // Disegniamo un carattere tramite la funzione drawChar
  tft.drawChar(90, 90, 0x50, 0xFC00, 0xFFFF, 2); 
  delay(200);  // P 
  tft.drawChar(100, 90, 0x4C, 0xFC00, 0xFFFF, 2);
  delay(200);  // L
  tft.drawChar(110, 90, 0x41, 0xFC00, 0xFFFF, 2);
  delay(200);  // A
  tft.drawChar(120, 90, 0x54, 0xFC00, 0xFFFF, 2);
  delay(200);  // T
  tft.drawChar(130, 90, 0x46, 0xFC00, 0xFFFF, 2);
  delay(200);  // F
  tft.drawChar(140, 90, 0x4F, 0xFC00, 0xFFFF, 2);
  delay(200);  // O
  tft.drawChar(150, 90, 0x52, 0xFC00, 0xFFFF, 2);
  delay(200);  // R
  tft.drawChar(160, 90, 0x4D, 0xFC00, 0xFFFF, 2);
  delay(200);  // M
  tft.drawChar(170, 90, 0x49, 0xFC00, 0xFFFF, 2);
  delay(200);  // I
  tft.drawChar(180, 90, 0x4F, 0xFC00, 0xFFFF, 2);
  delay(200);  // O
  tft.drawChar(190, 90, 0x2E, 0xFC00, 0xFFFF, 2);
  delay(200);  //.
  tft.drawChar(200, 90, 0x49, 0xFC00, 0xFFFF, 2);
  delay(200);  // I
  tft.drawChar(210, 90, 0x4F, 0xFC00, 0xFFFF, 2); 
  delay(1000); // O
  tft.setCursor(25, 150);
  tft.print("T");
  delay(250);
  tft.print("F");
  delay(250);
  tft.print("T");
  delay(250);
  tft.print(" ");
  tft.print("L");
  delay(250);
  tft.print("C");
  delay(250);
  tft.print("D");
  delay(250);
  tft.print(" ");
  tft.print("I");
  delay(250);
  tft.print("L");
  delay(250);
  tft.print("I");
  delay(250);
  tft.print("9");
  delay(250);
  tft.print("3");
  delay(250);
  tft.print("4");
  delay(250);
  tft.print("1");
  delay(250);
  tft.setCursor(130, 200);
  tft.print("2");
  delay(250);
  tft.print(".");
  delay(250);
  tft.print("4");
  delay(250);
  tft.setTextSize(2.5);
  tft.print("''");
  delay(2000);
  tft.fillScreen(0xFFFF);
  delay(1000);
}