nullo
Come visualizzare le immagini su un LCD TFT

Come visualizzare le immagini su un LCD TFT

2 aprile 2024

I display LCD TFT, ovvero i display a cristalli liquidi con transistor a film sottile, sono un tipo di LCD comunemente utilizzato in vari dispositivi, tra cui smartphone, tablet e televisori. I display LCD TFT sono noti per l'elevata qualità dell'immagine, i tempi di risposta rapidi e il basso consumo energetico.

Una delle applicazioni più comuni dei display LCD TFT è la visualizzazione di immagini. Ciò li rende ideali per vari progetti, come cornici digitali, segnaletica digitale e progetti fai da te. In questo articolo vi mostreremo come visualizzare immagini su un display LCD TFT utilizzando una scheda SD e Arduino Due.



Cose che vi serviranno


Tabella dei pin

Descrizione completa della piedinatura e dei collegamenti per il collegamento tra il display LCD TFT, la scheda di espansione per scheda SD e Arduino Due.

LCD TFT e piedinatura Arduino Due

Pin LCD Simbolo Connessione
1 GND GND
2 NC NC
3 NC NC
4 NC NC
5 NC NC
6 SDO NC
7 VDD 3.3V
8 VDDI 3.3V
9 SDA NC
10 CSX GND
11 DCX Pin 2 di Arduino
12 WRX Pin 11 di Arduino
13 RDX 3.3V
14 DB0 NC
15 DB1 NC
16 DB2 NC
17 DB3 NC
18 DB4 NC
19 DB5 NC
20 DB6 NC
21 DB7 NC
22 DB8 Pin 33 di Arduino
23 DB9 Pin Arduino 34
24 DB10 Pin 35 di Arduino
25 DB11 Pin 36 di Arduino
26 DB12 Pin 37 di Arduino
27 DB13 Pin 38 di Arduino
28 DB14 Pin Arduino 39
29 DB15 Pin 40 di Arduino
30 RESX 3.3V
31 IM0 3.3V
32 IM2 GND
33 GND GND
34 LED-K1 GND
35 LED-K2 GND
36 LED-K3 GND
37 LED-K4 GND
38 LED-A 3.3V
39 GND GND
40 TE NC

Pinout della scheda di espansione SD Card:

Pin di breakout SD Connessione
GND Pin SPI 6 di Arduino Due
MISO Pin SPI 1 di Arduino Due
SCK Pin SPI 3 di Arduino Due
MOSI Pin SPI 4 di Arduino Due
CS Pin 49 di Arduino Due
5V Pin SPI 2 di Arduino Due
3.3V NC

Schema elettrico

Lo schema elettrico riportato di seguito mostra come collegare il display LCD TFT e la scheda SD all'Arduino Due per visualizzare immagini e accedere alla scheda SD.

Schema di cablaggio tra un LCD TFT, una scheda SD e Arduino per visualizzare un'immagine sullo schermo Espandi icona Clicca per espandere
Schema di cablaggio tra un LCD TFT, una scheda SD e Arduino per visualizzare un'immagine sullo schermo.

Converti immagine in file di testo e salva su scheda SD

La maggior parte degli schermi LCD non interpreta direttamente i formati immagine standard come JPEG o PNG. Utilizzano invece dati pixel grezzi, spesso rappresentati in formato esadecimale. Per prima cosa è necessario convertire l'immagine in un array di dati immagine scaricando il software LCD Image Converter e seguendo questi passaggi:

  1. Aprire il software LCD Image Converter.
  2. Vai su Immagine -> Importa e apri l'immagine che desideri visualizzare sul display LCD. La risoluzione del file immagine deve corrispondere alla risoluzione del display LCD.
  3. Vai su Opzioni -> Conversione e assicurati che sia selezionata l'impostazione predefinita "Colore R5G6B5".
  4. Fai clic sulla scheda "Immagine". Nella sezione "Comune", deseleziona "Dividi in righe" e imposta la dimensione del blocco su "8 bit".
  5. Nella parte inferiore sinistra della finestra, clicca su "Mostra anteprima".
  6. Copia e incolla i valori esadecimali in un editor di testo e salva il file come "immagine1.txt".
  7. Trasferisci il file di testo su una scheda SD e inserisci la scheda SD nella scheda di espansione.

Copia il codice di esempio nell'IDE Arduino

Apri l'IDE Arduino e avvia un nuovo Sketch. Cancella qualsiasi codice preesistente, quindi copia e incolla il codice fornito di seguito.

/*
/Newhaven Display investe tempo e risorse nella fornitura di questo codice open source.
/Sostenete Newhaven Display acquistando i suoi prodotti! 
*
* Questo codice è fornito solo a titolo esemplificativo e senza alcuna garanzia da parte di Newhaven Display. 
* Newhaven Display non si assume alcuna responsabilità per eventuali problemi derivanti dal suo utilizzo.
* Lo sviluppatore dell'applicazione finale che incorpora qualsiasi parte di questo 
* codice di esempio è responsabile di garantirne il funzionamento sicuro e corretto
* e di qualsiasi conseguenza derivante dal suo utilizzo. 
* Per ulteriori dettagli, consultare la GNU General Public License.
*/
#include 
#include 
#include 
/****************************************************
*         PINOUT: Arduino Due -> 2.4" TFT           *
*****************************************************/
#define    RS   2     
#define    WR  11
const char slave = 0x38;
const int ChipSelect = 49;
int image_value = 0;
File myFile;
/****************************************************
*                 Function Commands                  *
******************************************************/
void comm_out(unsigned char c)
{
  PIOB -> PIO_CODR = 1 << 25;   //RS LOW
  REG_PIOC_ODSR = c << 1; 
  PIOD -> PIO_CODR = 1 << 7;    //WR LOW
  PIOD -> PIO_SODR = 1 << 7;    //WR HIGH
}
void data_out(unsigned char d)
{
  PIOB -> PIO_SODR = 1 << 25;   //RS HIGH
  REG_PIOC_ODSR = d << 1;
  PIOD -> PIO_CODR = 1 << 7;    //WR LOW
  PIOD -> PIO_SODR = 1 << 7;    //WR HIGH
}
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
//  Window Set Function
//-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=
void window_set(unsigned s_x, unsigned e_x, unsigned s_y, unsigned e_y)
{
  comm_out(0x2a);    //SET column address
  data_out((s_x)>>8);     //SET start column address
  data_out(s_x);
  data_out((e_x)>>8);     //SET end column address
  data_out(e_x);
  comm_out(0x2b);    //SET page address
  data_out((s_y)>>8);     //SET start page address
  data_out(s_y);
  data_out((e_y)>>8);     //SET end page address
  data_out(e_y);
}
/****************************************************
*         Initialization and Setup Routine          *
*****************************************************/
void setup()
{
  delay(100);
  pinMode(RS,OUTPUT);  
  pinMode(WR,OUTPUT);  
  PIOC->PIO_OER = 0xFFFFFFFF;
  digitalWrite(WR, LOW);
  comm_out(0x28);  //display off
  comm_out(0x11);  //exit SLEEP mode
  delay(100);
  comm_out(0x36);  //MADCTL: memory data access control
  data_out(0x10);  //changing from 0x88
  comm_out(0x21);  //display inversion
  comm_out(0x3A);  //COLMOD: Interface Pixel format  *** 65K-colors in 16bit/pixel (5-6-5) format when using 16-bit interface to allow 1-byte per pixel
  data_out(0x55);  //0x55 = 65k   //0x65 = 262k
  comm_out(0xB2);  //PORCTRK: Porch setting
  data_out(0x0C);
  data_out(0x0C);
  data_out(0x00);
  data_out(0x33);
  data_out(0x33);
  comm_out(0xB7);  //GCTRL: Gate Control
  data_out(0x35);
  comm_out(0xBB);  //VCOMS: VCOM setting
  data_out(0x2B);
  comm_out(0xC0);  //LCMCTRL: LCM Control
  data_out(0x2C);
  comm_out(0xC2);  //VDVVRHEN: VDV and VRH Command Enable
  data_out(0x01);
  data_out(0xFF);
  comm_out(0xC3);  //VRHS: VRH Set
  data_out(0x11);
  comm_out(0xC4);  //VDVS: VDV Set
  data_out(0x20);
  comm_out(0xC6);  //FRCTRL2: Frame Rate control in normal mode
  data_out(0x0F);
  comm_out(0xD0);  //PWCTRL1: Power Control 1
  data_out(0xA4);
  data_out(0xA1);
  comm_out(0xE0);  //PVGAMCTRL: Positive Voltage Gamma control  
  data_out(0xD0);
  data_out(0x00);
  data_out(0x05);
  data_out(0x0E);
  data_out(0x15);
  data_out(0x0D);
  data_out(0x37);
  data_out(0x43);
  data_out(0x47);
  data_out(0x09);
  data_out(0x15);
  data_out(0x12);
  data_out(0x16);
  data_out(0x19);
  comm_out(0xE1);  //NVGAMCTRL: Negative Voltage Gamma control  
  data_out(0xD0);
  data_out(0x00);
  data_out(0x05);
  data_out(0x0D);
  data_out(0x0C);
  data_out(0x06);
  data_out(0x2D);
  data_out(0x44);
  data_out(0x40);
  data_out(0x0E);
  data_out(0x1C);
  data_out(0x18);
  data_out(0x16);
  data_out(0x19);
  comm_out(0x2A);  //X address set
  data_out(0x00);
  data_out(0x00);
  data_out(0x00);
  data_out(0xEF);
  comm_out(0x2B);  //Y address set
  data_out(0x00);
  data_out(0x00);
  data_out(0x01);
  data_out(0x3F);
  delay(10);
  comm_out(0x29);  //display ON
  delay(10);
  SD.begin(ChipSelect);
}
/*****************************************************
*           Loop Function, to run repeatedly         *
*****************************************************/
void loop()
{ 
  SD_Card_Image(1);
  delay(5000);
  //SD_Card_Image(2);
  //delay(5000);
  //SD_Card_Image(3);
  //delay(5000);
  //SD_Card_Image(4);
  //delay(5000);
  //SD_Card_Image(5);
  //delay(5000);
}
void SD_Card_Image(unsigned char image){       /*The images used are in a textfile*/
    unsigned char dummy;
    unsigned int incr =0;
    switch (image){
      case 1: 
        image_value=1;
        myFile = SD.open("image1.txt");  
        break;
      case 2:
        image_value=2;
        myFile =SD.open("image2.txt");    
        break;    
      case 3:
        image_value=3;
        myFile = SD.open("image3.txt");   
        break;     
      case 4:
        image_value=4;
        myFile = SD.open("image4.txt");   
        break; 
      case 5:
        image_value=5;
        myFile = SD.open("image5.txt");   
        break;           
    }
  comm_out(0x2A);  /*X address set*/
  data_out(0x00);
  data_out(0x00);
  data_out(0x00);
  data_out(0xEF);
  comm_out(0x2B);  /*Y address set*/
  data_out(0x00);
  data_out(0x00);
  data_out(0x01);
  data_out(0x3F);      
  comm_out(0x2C);  /*command to begin writing to frame memory     */
  byte  data_in1,data_in2,data_in,data_out_value;
  uint8_t data_send;
  char data_conv[1]={0};
  int i;  
  int track ;
  while (myFile.available()){ /*convert the input char data to integers*/
        dummy = myFile.read(); 
        dummy = myFile.read(); 
        data_in1 = myFile.read(); 
        data_in2 = myFile.read(); 
        data_in=data_in1;
        if(data_in >=48 && data_in<=57){    /*if values are in range of 0-9 values*/
            data_in1 = data_in-48;
            track=1;
          }
          if(data_in <=102 && data_in>=97){ /*if values are in range of a-f*/
            data_in1 = data_in - 87; 
            track=1;
          }
          if( data_in ==32/*Space*/ || data_in==44 /*comma*/ || data_in == 120 /*x*/){
            dummy =data_in;
            track=0;
            data_in1 =0;
            data_in2 =0;
          }      
        data_in=data_in2;
        if(data_in >=48 && data_in<=57){   /*if values are in range of 0-9 values*/
            data_in2 = data_in-48;
            track=1;
          }
          if(data_in <=102 && data_in>=97){/*if values are in range of a-f*/
            data_in2 = data_in - 87; 
            track=1;
          }
          if( data_in ==32/*Space*/ || data_in==44 /*comma*/ || data_in == 120 /*x*/){/*skip dummy data*/
            dummy =data_in;
            track=0;
            data_in1 =0;
            data_in2 =0;
          }              
        dummy = myFile.read(); 
        dummy = myFile.read();  
        data_out_value = data_in1<<4 | data_in2;  
        data_out(data_out_value);
      }
      myFile.close();   
}
	

Carica il codice su Arduino

Il passo finale è caricare il codice sull'IDE Arduino.

  1. Collega Arduino al PC con il cavo USB-B.
  2. Nell'IDE Arduino, seleziona la scheda e la porta.
  3. Clicca sul pulsante "Carica" per programmare Arduino con il tuo codice.

Una volta caricato correttamente il codice, l'immagine dovrebbe apparire sullo schermo LCD.

Schema di cablaggio tra un LCD TFT, una scheda SD e Arduino per visualizzare un'immagine sullo schermo
Uno schermo LCD TFT Newhaven che visualizza un'immagine proveniente da una scheda SD, con l'elaborazione e il rendering dell'immagine gestiti da un Arduino Due.

Conclusione

Che tu stia imparando, realizzando prototipi o semplicemente divertendoti con l'elettronica, questo tutorial illustra le basi della lettura dei dati immagine esadecimali da una scheda SD e della loro visualizzazione su un display LCD TFT. Questo è solo un punto di partenza e le possibilità di espansione sono infinite. Ci auguriamo che questo tutorial ti sia piaciuto!