Display TFT 2.8" 320x240 - ILI9341

Il display TFT qui illustrato ha una risoluzione di 320×240 con una dimensione del display pari a 2,8″ di diagonale. La sua superficie rappresenta un touch screen del tipo resistivo.
Il modulo è venduto da ELEGOO è può essere istallato direttamente su una scheda Arduino UNO o Mega2560 senza cablaggio.

Indice

Descrizione

Il display TFT (Thin Film Transistor), in italiano transistor a pellicola sottile) è una tecnologia applicata ai display piatti a cristalli liquidi (LCD) o OLED (Organic Light Emitting Diode ovvero diodo organico ad emissione di luce). Quest’ultimi vengono in questo modo, identificati come display a matrice attiva.
Sulla scheda è già compreso il circuito di conversione del livello 5V-3.3V, per cui sono supporta tutti i chip a 3,3 V, 5 V, per la riduzione dell’alimentazione è presente un regolatore AMS1117 (Datasheet) .
La scheda presenta una risoluzione dello display tft 320×240 e può essere fornita con due tipi di chip controller: LCD ILITEK ILI9341 (Datasheet) oppure il driver LGDP4535.
Le librerie non sono intercambiabili, per questo fare riferimento a quanto presente sul mini CD che viene fornito insieme alla scheda (contenuto del CD).

L’interfaccia MCU è impostata su un bus dati a 8 bit parallelo e pertanto richiede 8 pin per i dati e altri 5 pin per il controllo. Si noti inoltre che non è possibile modificare o disattivare la retroilluminazione accedendo al registro corretto, poiché il pin di controllo della retroilluminazione è permanentemente collegato a VCC.
Il touch screen contiene naturalmente un sensore tattile resistivo e uno slot per scheda SD accessibile da un’interfaccia SPI.
I driver includono il supporto per il sensore tattile, ma devono ancora essere integrati con il driver dello schermo, quindi non possono ancora essere utilizzati insieme in un programma client.

Caratteristiche

Supporto Arduino UNO e Mega2560 senza cablaggio.
Include il circuito di conversione del livello 5V-3.3V, supporta tutti i chip a 3,3 V, 5 V.
Risoluzione dello schermo 320X240 con funzione touch screen.
Utilizzo di bus parallelo a 8 bit, Più veloce e semplice rispetto a SPI
Disponibili librerie Arduino per semplificare lo sviluppo delle applicazioni.
Con circuito scheda Micro-SD.

Touch screen resistivo

I touch screen resistivi sono stati i primi modelli di schermo tattile realizzati e il loro funzionamento si basa sulla leggera pressione dello schermo che l’utente deve esercitare per interagire con il dispositivo tramite dito o qualsiasi altro oggetto, ed è detto resistivo perché il loro funzionamento, è legato alla presenza di particolari componenti elettrici detti resistori. Fu molto utilizzato nei vecchi palmari.

Dove trovare il display

Il display potrà essere trovato per esempio presso il sito Amazon

<br />

Definizione dell’interfaccia del modulo

Istruzioni per il cablaggio Arduino

Seguono per ogni pin del modulo, a quale pin della scheda Uno o Mega. Come visibili sono occupati quasi tutti i pin disponibili. Non sono utilizzati solamente i pin 0 e 1

Librerie

Per il funzionamento del display occorre caricare tre librerie, queste sono presenti sul CD presente nella confezione.

Adafruit_GFX
Adafruit_TFTLCD
TouchScreen

NOTA: si è notato che i programmi demo presenti nel CD non funzionano con gli ultimi aggiornamenti delle librerie. Per cui il consigli è di utilizzare per la programmazione è di utilizzare le librerie presenti nel CD.

Immagini

Seguono alcune foto relative alla confezione fornita dalla Elegoo

Esempio di utilizzo

Il display potrebbe essere utilizzato come cornice digitale

Sketch cornice foto

#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_TFTLCD.h> // Hardware-specific library
#include <SD.h>
#include <SPI.h>

#define LCD_CS A3 // Chip Select goes to Analog 3
#define LCD_CD A2 // Command/Data goes to Analog 2
#define LCD_WR A1 // LCD Write goes to Analog 1
#define LCD_RD A0 // LCD Read goes to Analog 0
#define PIN_SD_CS 10 // Adafruit SD shields and modules: pin 10

#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin

// Assign human-readable names to some common 16-bit color values:
#define	BLACK   0x0000
#define	BLUE    0x001F
#define	RED     0xF800
#define	GREEN   0x07E0
#define CYAN    0x07FF
#define MAGENTA 0xF81F
#define YELLOW  0xFFE0
#define WHITE   0xFFFF

Adafruit_TFTLCD tft(LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

#define MAX_BMP         10                      // bmp file num
#define FILENAME_LEN    20                      // max file name length

const int __Gnbmp_height = 320;                 // bmp hight
const int __Gnbmp_width  = 240;                 // bmp width

unsigned char __Gnbmp_image_offset  = 0;        // offset

int __Gnfile_num = 3;                           // num of file

char __Gsbmp_files[3][FILENAME_LEN] =           // add file name here
{
  "Immage1.bmp",
  "Immage2.bmp",
  "Immage3.bmp",
};
File bmpFile;


#define BUFFPIXEL       60                      // must be a divisor of 240 
#define BUFFPIXEL_X3    180                     // BUFFPIXELx3

void bmpdraw(File f, int x, int y)
{
  bmpFile.seek(__Gnbmp_image_offset);

  uint32_t time = millis();

  uint8_t sdbuffer[BUFFPIXEL_X3];                 // 3 * pixels to buffer

  for (int i = 0; i < __Gnbmp_height; i++) {
    for (int j = 0; j < (240 / BUFFPIXEL); j++) {
      bmpFile.read(sdbuffer, BUFFPIXEL_X3);

      uint8_t buffidx = 0;
      int offset_x = j * BUFFPIXEL;
      unsigned int __color[BUFFPIXEL];

      for (int k = 0; k < BUFFPIXEL; k++) {
        __color[k] = sdbuffer[buffidx + 2] >> 3;                    // read
        __color[k] = __color[k] << 6 | (sdbuffer[buffidx + 1] >> 2); // green
        __color[k] = __color[k] << 5 | (sdbuffer[buffidx + 0] >> 3); // blue

        buffidx += 3;
      }

      for (int m = 0; m < BUFFPIXEL; m ++) {
        tft.drawPixel(m + offset_x, i, __color[m]);
      }
    }
  }

  Serial.print(millis() - time, DEC);
  Serial.println(" ms");
}

boolean bmpReadHeader(File f)
{
  // read header
  uint32_t tmp;
  uint8_t bmpDepth;

  if (read16(f) != 0x4D42) {
    // magic bytes missing
    return false;
  }

  // read file size
  tmp = read32(f);
  Serial.print("size 0x");
  Serial.println(tmp, HEX);

  // read and ignore creator bytes
  read32(f);

  __Gnbmp_image_offset = read32(f);
  Serial.print("offset ");
  Serial.println(__Gnbmp_image_offset, DEC);

  // read DIB header
  tmp = read32(f);
  Serial.print("header size ");
  Serial.println(tmp, DEC);

  int bmp_width = read32(f);
  int bmp_height = read32(f);

  if (bmp_width != __Gnbmp_width || bmp_height != __Gnbmp_height)  {   // if image is not 320x240, return false
    return false;
  }

  if (read16(f) != 1)
    return false;

  bmpDepth = read16(f);
  Serial.print("bitdepth ");
  Serial.println(bmpDepth, DEC);

  if (read32(f) != 0) {
    // compression not supported!
    return false;
  }

  Serial.print("compression ");
  Serial.println(tmp, DEC);

  return true;
}

// LITTLE ENDIAN!
uint16_t read16(File f)
{
  uint16_t d;
  uint8_t b;
  b = f.read();
  d = f.read();
  d <<= 8;
  d |= b;
  return d;
}

// LITTLE ENDIAN!
uint32_t read32(File f)
{
  uint32_t d;
  uint16_t b;

  b = read16(f);
  d = read16(f);
  d <<= 16;
  d |= b;
  return d;
}

void setup(void) {
  Serial.begin(9600);
  Serial.println(F("TFT LCD test"));

#ifdef USE_ADAFRUIT_SHIELD_PINOUT
  Serial.println(F("Using Adafruit 2.4\" TFT Arduino Shield Pinout"));
#else
  Serial.println(F("Using Adafruit 2.4\" TFT Breakout Board Pinout"));
#endif

  Serial.print("TFT size is "); Serial.print(tft.width()); Serial.print("x"); Serial.println(tft.height());

  tft.reset();

  uint16_t identifier = tft.readID();

  if (identifier == 0x9325) {
    Serial.println(F("Found ILI9325 LCD driver"));
  } else if (identifier == 0x9328) {
    Serial.println(F("Found ILI9328 LCD driver"));
  } else if (identifier == 0x4535) {
    Serial.println(F("Found LGDP4535 LCD driver"));
  } else if (identifier == 0x7575) {
    Serial.println(F("Found HX8347G LCD driver"));
  } else if (identifier == 0x9341) {
    Serial.println(F("Found ILI9341 LCD driver"));
  } else if (identifier == 0x8357) {
    Serial.println(F("Found HX8357D LCD driver"));
  } else if (identifier == 0x0101)
  {
    identifier = 0x9341;
    Serial.println(F("Found 0x9341 LCD driver"));
  } else {
    Serial.print(F("Unknown LCD driver chip: "));
    Serial.println(identifier, HEX);
    Serial.println(F("If using the Adafruit 2.8\" TFT Arduino shield, the line:"));
    Serial.println(F("  #define USE_ADAFRUIT_SHIELD_PINOUT"));
    Serial.println(F("should appear in the library header (Adafruit_TFT.h)."));
    Serial.println(F("If using the breakout board, it should NOT be #defined!"));
    Serial.println(F("Also if using the breakout, double-check that all wiring"));
    Serial.println(F("matches the tutorial."));
    identifier = 0x9341;

  }

  tft.begin(identifier);
  tft.fillScreen(BLUE);

  //Init SD_Card
  pinMode(10, OUTPUT);

  if (!SD.begin(10)) {
    Serial.println("initialization failed!");
    tft.setCursor(0, 0);
    tft.setTextColor(WHITE);
    tft.setTextSize(1);
    tft.println("SD Card Init fail.");
  } else
    Serial.println("initialization done.");
}

void loop(void) {
  for (unsigned char i = 0; i < __Gnfile_num; i++) {
    bmpFile = SD.open(__Gsbmp_files[i]);
    if (! bmpFile) {
      Serial.println("didnt find image");
      tft.setTextColor(WHITE);    tft.setTextSize(1);
      tft.println("didnt find BMPimage");
      while (1);
    }

    if (! bmpReadHeader(bmpFile)) {
      Serial.println("bad bmp");
      tft.setTextColor(WHITE);    tft.setTextSize(1);
      tft.println("bad bmp");
      return;
    }

    bmpdraw(bmpFile, 0, 0);
    bmpFile.close();
    delay(1000);
    delay(1000);
  }
}

#include <Adafruit_GFX.h> // Core graphics library

#include <Adafruit_TFTLCD.h> // Hardware-specific library

#include <SD.h>

#include <SPI.h>

#define LCD_CS A3 // Chip Select goes to Analog 3

#define LCD_CD A2 // Command/Data goes to Analog 2

#define LCD_WR A1 // LCD Write goes to Analog 1

#define LCD_RD A0 // LCD Read goes to Analog 0

#define PIN_SD_CS 10 // Adafruit SD shields and modules: pin 10

#define LCD_RESET A4 // Can alternately just connect to Arduino's reset pin

// Assign human-readable names to some common 16-bit color values:

#define BLACK 0x0000

#define BLUE 0x001F

#define RED 0xF800

#define GREEN 0x07E0

#define CYAN 0x07FF

#define MAGENTA 0xF81F

Altri display

Altre informazione sui display possono essere trovati in questo articolo