Componentes · 11 min de leitura

Shield TFT LCD 2,4 no Arduino: MCUFRIEND_kbv, toque e SD

Shield TFT LCD 2,4 no Arduino: instalação da MCUFRIEND_kbv, leitura do ID do controlador, solução da tela branca, calibração do toque, botões, imagens BMP do SD e pinos.

O shield TFT LCD de 2,4 polegadas para Arduino é uma tela colorida sensível ao toque, de 240×320 pixels, que se encaixa diretamente em um Arduino Uno. Sem fios, sem solda: você encaixa o shield nos conectores de um Uno ou Mega, instala a biblioteca certa e, em poucos minutos, já está mostrando textos coloridos, formas, botões de toque e imagens do cartão SD. Como é barato, ele aparece em inúmeros kits para iniciantes e projetos escolares; pelo mesmo motivo, é uma das peças sobre as quais mais se pergunta na internet: “por que minha tela fica só branca?”.

Neste guia você vai ver por que o shield às vezes mostra uma tela branca e como a biblioteca MCUFRIEND_kbv resolve isso. Você vai descobrir o ID do controlador, calibrar o painel de toque, corrigir o toque que funciona invertido, controlar um LED com botões na tela e mostrar imagens de um cartão microSD. Também vamos ver quais pinos o shield ocupa, quais sobram e a que prestar atenção no Mega, no ESP32 e no Pico.

Placa Arduino Uno
O shield TFT de 2,4" fica em cima desta placa e usa quase todos os pinos dela; sobram apenas A5, D0–D1 e, se você não usar o cartão SD, D10–D13.

O que é o shield TFT de 2,4" e como ele funciona?

O shield tem três partes: o painel TFT colorido, uma camada de toque resistiva colada sobre ele e um slot para cartão microSD na parte de trás. O display não é ligado por um barramento serial como o SPI, e sim por um barramento paralelo de 8 bits; como envia um byte inteiro de cada vez, ele desenha mais rápido em um Uno do que os módulos SPI, mas ocupa muitos pinos. O chip controlador do painel trabalha em 3,3 V; graças ao regulador de 3,3 V e a um conversor de nível do tipo 74HC245 na placa, os sinais de 5 V do Uno podem ser usados com segurança.

CaracterísticaValor
TelaTFT de 2,4 polegadas, 240×320 pixels
Cores16 bits (RGB565), 65.536 cores
InterfaceParalela de 8 bits (D0–D7) + 5 linhas de controle
Chip controladorVaria: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 e outros
ToqueResistivo de 4 fios, compartilha pinos com o display
Slot SDmicroSD via SPI (D10–D13)
Alimentação5 V (regulador de 3,3 V na placa)
CorrenteCerca de 80–120 mA, a maior parte para a luz de fundo
Placas compatíveisArduino Uno, Arduino Mega 2560

Shield ou módulo SPI?

Dois produtos diferentes, do mesmo tamanho, estão à venda, e os dois são chamados de “TFT 2,4”. O shield é o modelo paralelo, que você encaixa em um Uno e sai usando. O módulo SPI tem uma única fileira de pinos em uma das bordas e é ligado com jumpers; o painel de toque dele normalmente é lido via SPI com um chip XPT2046. Este guia trata do shield; para o módulo SPI, veja nosso guia do display TFT ILI9341.

Módulo de display TFT ILI9341 com interface SPI
O irmão do shield: o módulo SPI é ligado com jumpers por uma única barra de pinos e funciona muito melhor com o ESP32 e o Pico.
CaracterísticaShield de 2,4" para UnoMódulo SPI de 2,4"
LigaçãoEncaixa em um Uno ou Mega, sem fios7 a 14 jumpers
Pinos usadosD2–D9, A0–A4 (D10–D13 com o SD)5 para o display, 8–9 com toque e SD
Velocidade de desenho em um UnoRápida (paralelo)Mais lenta (SPI)
BibliotecaMCUFRIEND_kbvAdafruit_ILI9341, TFT_eSPI
Leitura do toqueAnalógica, pinos compartilhados com o displayChip XPT2046 via SPI
ESP32 e PicoNão indicadoIndicado
Pinos livres para sensoresQuase nenhumMuitos

Tabela de pinos: quais pinos o shield usa?

Pino do shieldPino do Arduino UnoFunção
LCD_RDA0Sinal de leitura
LCD_WRA1Sinal de escrita (pode ser compartilhado com o toque)
LCD_RS (CD)A2Comando ou dado? (compartilhado com o toque)
LCD_CSA3Seleção do chip do display (pode ser compartilhado com o toque)
LCD_RSTA4Reset do display
LCD_D0, LCD_D1D8, D9Dois primeiros bits do barramento de dados
LCD_D2–LCD_D7D2–D7Os outros seis bits do barramento de dados
SD_SS / SD_DI / SD_DO / SD_SCKD10 / D11 / D12 / D13Cartão microSD (SPI)
5V, 3V3, GND5V, 3.3V, GNDAlimentação
Com o shield encaixado, um Uno fica quase sem pinos para sensores. Como o A4 é a linha de reset do display, o barramento I2C em A4/A5 não pode ser usado, então não dá para acrescentar um sensor ou um display I2C. O que sobra: A5 (não conectado na maioria dos shields), D0–D1, que são compartilhados com o carregamento do código por USB, e D10–D13, se você não usar o cartão SD. Se precisar de mais sensores, coloque o shield em um Arduino Mega ou troque-o pelo módulo SPI.

Instalando a biblioteca MCUFRIEND_kbv

  1. Abra o Gerenciador de Bibliotecas no Arduino IDE, procure por MCUFRIEND_kbv e instale.
  2. No mesmo lugar, instale a Adafruit GFX Library; as funções de texto, linha, círculo e botão vêm dela.
  3. Para o toque, instale a biblioteca Adafruit TouchScreen (no código, ela é incluída como TouchScreen.h).
  4. Para o cartão SD você não precisa instalar nada; a biblioteca SD já vem com o Arduino IDE.

Por que a MCUFRIEND_kbv? Esses shields podem parecer idênticos e, mesmo assim, ter chips controladores diferentes por dentro: dois shields comprados do mesmo vendedor com dois meses de diferença podem ser um ILI9341 e um ST7781. Bibliotecas mais antigas, como a Adafruit_TFTLCD ou a SPFD5408, só conhecem alguns chips; se o chip não corresponde, o display nunca é inicializado e você fica com a famosa tela branca. A MCUFRIEND_kbv primeiro pergunta ao chip qual é o ID dele e depois envia os comandos de inicialização adequados para aquele chip.

Descobrindo o ID do controlador: readID()

A primeira tarefa é perguntar ao seu shield quem ele é. O código abaixo imprime o ID no Monitor Serial e na tela e depois desenha três caixas coloridas. Ajuste o Monitor Serial para 9600 baud.

C++ (Arduino IDE)
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3
4MCUFRIEND_kbv tft;
5
6void setup() {
7  Serial.begin(9600);
8  uint16_t id = tft.readID();                 // sürücü kimliğini oku / read the driver ID
9  Serial.print(F("TFT ID = 0x"));
10  Serial.println(id, HEX);
11  if (id == 0xD3D3) id = 0x9341;              // salt yazılır shield: kimliği elle ver / write-only shield: set the ID by hand
12  tft.begin(id);
13  tft.setRotation(1);                         // yatay, 320x240 / landscape, 320x240
14  tft.fillScreen(0x0000);                     // siyah / black
15  tft.setTextColor(0xFFFF);                   // beyaz / white
16  tft.setTextSize(3);
17  tft.setCursor(20, 20);
18  tft.print(F("BlueGrays"));
19  tft.setTextSize(2);
20  tft.setCursor(20, 70);
21  tft.print(F("ID: 0x"));
22  tft.print(id, HEX);
23  tft.fillRect(20, 120, 80, 60, 0xF800);      // kırmızı / red
24  tft.fillRect(120, 120, 80, 60, 0x07E0);     // yeşil / green
25  tft.fillRect(220, 120, 80, 60, 0x001F);     // mavi / blue
26}
27
28void loop() {
29}
ID lidoChipO que fazer
0x9341ILI9341O modelo mais comum; funciona de primeira
0x9325 / 0x9328ILI9325 / ILI9328Mais antigo, mas confiável; funciona de primeira
0x7783ST7781Funciona de primeira
0x5408SPFD5408Funciona de primeira; não precisa da antiga biblioteca SPFD5408
0x4747 / 0x9595HX8347-D / HX8347-IFunciona de primeira
0x1505 / 0x0154R61505 / S6D0154Funciona de primeira
0xD3D3Shield sem a linha de leitura conectadaEscreva o ID no código à mão; em um de 2,4", tente primeiro 0x9341
0x0000 ou 0xFFFFSem respostaShield mal encaixado, pino torto ou placa com defeito

Se as caixas aparecerem em vermelho, verde e azul, nessa ordem, está tudo certo. Se você vir azul no lugar do vermelho, provavelmente definiu o ID à mão e os comandos de inicialização errados foram enviados; nesse caso, use o valor que o readID encontrou. Se as cores parecerem um negativo, acrescente a linha tft.invertDisplay(true) depois do begin. Se o ID for algo estranho, o exemplo Arquivo > Exemplos > MCUFRIEND_kbv > LCD_ID_readreg da biblioteca despeja todos os registradores do chip, e essa saída é o jeito mais rápido de entender o problema. Já o exemplo graphictest_kbv testa todas as funções do display de uma vez só.

A tela branca e outros problemas do display

Uma tela branca é, na verdade, uma pista: a luz de fundo tem alimentação, mas o chip controlador nunca foi inicializado. Quando o painel não recebe comandos, os pixels deixam a luz passar e a tela inteira fica branca. Siga a tabela de cima para baixo:

SintomaCausa provávelSolução
Tela branca com uma biblioteca antigaA biblioteca não conhece o seu chipInstale a MCUFRIEND_kbv e inicialize o display com o readID
Tela branca, ID 0x0000 ou 0xFFFFShield mal encaixado ou pino tortoRetire o shield, endireite os pinos e pressione-o até o fim
Tela branca, ID 0xD3D3Sem linha de leitura, então o ID não pode ser lidoDefina o ID à mão, por exemplo tft.begin(0x9341); se não der certo, tente 0x9325 e 0x7783
Cores em negativo (o branco aparece preto)A configuração de inversão do chip é diferentetft.invertDisplay(true) depois do begin
Vermelho e azul trocadosO ID definido à mão não corresponde ao chipUse o ID que o readID encontra e atualize a biblioteca para a versão mais recente
Texto espelhadoO ID definido à mão não corresponde ao painelObtenha o ID com o readID; confira as quatro orientações com o exemplo aspect_kbv
A imagem se desfaz quando você toca na telaA leitura do toque deixou os pinos compartilhados como entradasVolte YP e XM para OUTPUT depois do getPoint
Funciona em um Uno, fica branca em um MegaA biblioteca não conhece o mapeamento de pinos do MegaA MCUFRIEND_kbv é compatível com o Mega; remova a biblioteca antiga

Calibrando o painel de toque

Um painel de toque resistivo é feito de duas camadas resistivas finas com um espaço minúsculo entre elas. Quando você pressiona, as camadas se encostam; a biblioteca aplica uma tensão em uma camada e lê a tensão na outra com uma entrada analógica, o que lhe dá a posição X e Y. Essas leituras são números brutos, mais ou menos de 100 a 900, e variam de painel para painel, por isso é preciso uma calibração para transformá-las em pixels. O painel de toque também compartilha pinos com o display, e quais são os quatro pinos que vão para a camada de toque muda de shield para shield.

  1. Abra o exemplo TouchScreen_Calibr_native em Arquivo > Exemplos > MCUFRIEND_kbv e carregue-o.
  2. Abra o Monitor Serial em 9600 baud; o exemplo primeiro descobre sozinho os pinos do toque.
  3. Pressione, uma a uma, as cruzes que aparecem na tela, mantendo o dedo ou a caneta em cada uma até o texto mudar.
  4. Quando terminar, duas linhas aparecem sob o título “COPY-PASTE” no Monitor Serial: const int XP=...,XM=...,YP=...,YM=... e const int TS_LEFT=...,TS_RT=...,TS_TOP=...,TS_BOT=....
  5. Cole essas duas linhas no lugar dos valores de exemplo que ficam no topo dos sketches abaixo.
C++ (Arduino IDE)
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3#include <TouchScreen.h>
4
5MCUFRIEND_kbv tft;
6
7// Kalibrasyon örneğinin çıktısını buraya yapıştır / paste the calibration sketch output here
8const int XP = 6, XM = A2, YP = A1, YM = 7;
9const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
10
11TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);   // 300 ohm X plakası / 300 ohm X plate
12const int MINPRESSURE = 200;
13const int MAXPRESSURE = 1000;
14
15bool readTouch(int &x, int &y) {
16  TSPoint p = ts.getPoint();
17  pinMode(YP, OUTPUT);                 // ortak pinleri ekrana geri ver / give the shared pins back to the display
18  pinMode(XM, OUTPUT);
19  digitalWrite(YP, HIGH);
20  digitalWrite(XM, HIGH);
21  if (p.z < MINPRESSURE || p.z > MAXPRESSURE) return false;
22  x = map(p.x, TS_LEFT, TS_RT, 0, tft.width());    // dikey yön için / for portrait
23  y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
24  return true;
25}
26
27void setup() {
28  tft.begin(tft.readID());
29  tft.setRotation(0);                  // dikey, kalibrasyonla aynı / portrait, same as calibration
30  tft.fillScreen(0x0000);
31  tft.fillRect(0, 0, 240, 30, 0x001F);
32  tft.setTextColor(0xFFFF);
33  tft.setTextSize(2);
34  tft.setCursor(10, 8);
35  tft.print(F("Ciz / Draw"));
36}
37
38void loop() {
39  int x, y;
40  if (readTouch(x, y)) {
41    if (y < 30) tft.fillRect(0, 30, 240, 290, 0x0000);   // başlığa dokun: temizle / tap the header: clear
42    else tft.fillCircle(x, y, 3, 0xFFE0);                 // sarı nokta / yellow dot
43  }
44}

Este pequeno programa de desenho é a melhor forma de testar a calibração: o ponto deve cair quase exatamente embaixo do seu dedo. p.z é a pressão; se ela não estiver entre MINPRESSURE e MAXPRESSURE, não conta como toque, o que filtra esbarrões leves e ruído elétrico. As linhas de pinMode dentro de readTouch() são essenciais: durante a leitura, a biblioteca TouchScreen transforma os pinos compartilhados em entradas analógicas e os deixa assim; sem essas linhas, os comandos de desenho seguintes nunca chegam ao display e a imagem se desfaz. Uma dica: o painel resistivo funciona por pressão, então a unha ou uma caneta stylus desenha com mais precisão do que a ponta do dedo.

SintomaCausaSolução
Tocar na direita coloca o ponto na esquerdaEixo X invertidoTroque entre si os valores de TS_LEFT e TS_RT
Tocar em cima coloca o ponto embaixoEixo Y invertidoTroque entre si os valores de TS_TOP e TS_BOT
X e Y misturados no modo paisagemO setRotation(1) girou os eixosMapeie p.y para x e p.x para y, ou fique no modo retrato
Nenhum toque é detectadoXP, XM, YP, YM estão erradosRode de novo o exemplo de calibração e use os pinos que ele informar
Pontos aparecem sem ninguém tocarLimiar de pressão baixo demaisAumente o MINPRESSURE para 300–400
Os pontos caem alguns pixels fora do lugarA calibração foi feita às pressasCalibre de novo, pressionando por mais tempo bem no centro de cada cruz

Uma interface com botões de toque

A classe Adafruit_GFX_Button da biblioteca Adafruit GFX desenha botões com contorno e rótulo em poucas linhas e descobre sozinha se um toque caiu em cima do botão. O código abaixo liga e desliga um LED no A5 com dois botões; escolhemos o A5 porque ele é praticamente o único pino que sobra em um Uno com o shield encaixado. Não se esqueça de ligar o LED por meio de um resistor de 220 Ω.

C++ (Arduino IDE)
1#include <Adafruit_GFX.h>
2#include <MCUFRIEND_kbv.h>
3#include <TouchScreen.h>
4
5MCUFRIEND_kbv tft;
6const int XP = 6, XM = A2, YP = A1, YM = 7;                       // kendi değerlerin / your own values
7const int TS_LEFT = 907, TS_RT = 136, TS_TOP = 942, TS_BOT = 139;
8TouchScreen ts = TouchScreen(XP, YP, XM, YM, 300);
9
10const int LED_PIN = A5;               // shield'in boş bıraktığı pin / the pin the shield leaves unused
11Adafruit_GFX_Button onBtn, offBtn;
12char onLabel[] = "ON";
13char offLabel[] = "OFF";
14
15bool readTouch(int &x, int &y) {
16  TSPoint p = ts.getPoint();
17  pinMode(YP, OUTPUT);
18  pinMode(XM, OUTPUT);
19  digitalWrite(YP, HIGH);
20  digitalWrite(XM, HIGH);
21  if (p.z < 200 || p.z > 1000) return false;
22  x = map(p.x, TS_LEFT, TS_RT, 0, tft.width());
23  y = map(p.y, TS_TOP, TS_BOT, 0, tft.height());
24  return true;
25}
26
27void showState(bool on) {
28  tft.fillRect(20, 40, 200, 60, on ? 0x07E0 : 0x7BEF);  // yeşil ya da gri / green or grey
29  tft.setTextColor(0x0000);
30  tft.setTextSize(3);
31  tft.setCursor(50, 58);
32  tft.print(on ? F("LED ON") : F("LED OFF"));
33}
34
35void setup() {
36  pinMode(LED_PIN, OUTPUT);
37  tft.begin(tft.readID());
38  tft.setRotation(0);
39  tft.fillScreen(0x0000);
40  // merkez x, merkez y, genişlik, yükseklik, çerçeve, dolgu, yazı rengi, etiket, yazı boyu
41  // center x, center y, width, height, outline, fill, text colour, label, text size
42  onBtn.initButton(&tft, 120, 170, 160, 60, 0xFFFF, 0x07E0, 0x0000, onLabel, 3);
43  offBtn.initButton(&tft, 120, 260, 160, 60, 0xFFFF, 0xF800, 0xFFFF, offLabel, 3);
44  onBtn.drawButton();
45  offBtn.drawButton();
46  showState(false);
47}
48
49void loop() {
50  int x = 0, y = 0;
51  bool down = readTouch(x, y);
52  onBtn.press(down && onBtn.contains(x, y));
53  offBtn.press(down && offBtn.contains(x, y));
54  if (onBtn.justPressed()) {
55    onBtn.drawButton(true);             // basılı görünüm / pressed look
56    digitalWrite(LED_PIN, HIGH);
57    showState(true);
58  }
59  if (offBtn.justPressed()) {
60    offBtn.drawButton(true);
61    digitalWrite(LED_PIN, LOW);
62    showState(false);
63  }
64  if (onBtn.justReleased()) onBtn.drawButton();
65  if (offBtn.justReleased()) offBtn.drawButton();
66  delay(20);
67}

press() registra, a cada volta, se o botão está pressionado naquele momento; justPressed() retorna true só na primeira volta em que ele é pressionado, e justReleased(), só na volta em que ele é solto. Assim, o LED não recebe o mesmo comando repetidas vezes enquanto o dedo fica no botão, e a tela não é redesenhada à toa. drawButton(true) inverte as cores do botão para dar a aparência de pressionado. Ligue um módulo relé ao A5 no lugar do LED e você pode acionar uma lâmpada pela tela de toque; para fazer a ligação com segurança, veja nosso guia do módulo relé.

Mostrando imagens do cartão SD

O slot microSD na parte de trás é o jeito mais fácil de colocar imagens em cores na tela. No computador, redimensione a imagem para 240×320 (retrato) e salve-a como BMP de 24 bits: no Paint, escolha “Bitmap de 24 bits”; no GIMP, selecione a opção de 24 bits ao exportar. O nome do arquivo deve ter no máximo 8 caracteres (por exemplo, GATO.BMP), porque a biblioteca SD trabalha com nomes curtos; depois, troque “KEDI.BMP” no código pelo nome do seu arquivo. Formate o cartão em FAT32 ou FAT16; cartões maiores que 32 GB costumam vir em exFAT e não são reconhecidos.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <SD.h>
3#include <Adafruit_GFX.h>
4#include <MCUFRIEND_kbv.h>
5
6MCUFRIEND_kbv tft;
7const int SD_CS = 10;                 // shield üzerindeki SD seçme pini / SD chip select on the shield
8const byte CHUNK = 20;                // tek seferde okunan piksel / pixels read per step (az RAM / low RAM)
9
10uint16_t read16(File &f) { uint16_t v; f.read((uint8_t *)&v, 2); return v; }
11uint32_t read32(File &f) { uint32_t v; f.read((uint8_t *)&v, 4); return v; }
12
13bool drawBMP(const char *name, int x, int y) {
14  File bmp = SD.open(name);
15  if (!bmp) return false;
16  if (read16(bmp) != 0x4D42) { bmp.close(); return false; }   // "BM" imzası / "BM" signature
17  read32(bmp); read32(bmp);                                   // dosya boyutu, ayrılmış / file size, reserved
18  uint32_t offset = read32(bmp);                              // piksel verisinin başı / start of pixel data
19  read32(bmp);                                                // başlık boyutu / header size
20  int32_t w = read32(bmp);
21  int32_t h = read32(bmp);
22  if (read16(bmp) != 1 || read16(bmp) != 24 || read32(bmp) != 0) {  // 1 düzlem, 24 bit, sıkıştırmasız / 1 plane, 24-bit, uncompressed
23    bmp.close();
24    return false;
25  }
26  bool bottomUp = true;                                       // BMP satırları alttan üste / BMP rows are bottom-up
27  if (h < 0) { h = -h; bottomUp = false; }
28  uint32_t rowSize = (w * 3 + 3) & ~3UL;                      // satır 4 bayta tamamlanır / rows padded to 4 bytes
29  uint8_t raw[CHUNK * 3];
30  uint16_t px[CHUNK];
31  for (int32_t row = 0; row < h; row++) {
32    bmp.seek(offset + (bottomUp ? (h - 1 - row) : row) * rowSize);
33    tft.setAddrWindow(x, y + row, x + w - 1, y + row);        // tek satırlık pencere / one-row window
34    bool first = true;
35    for (int32_t col = 0; col < w; col += CHUNK) {
36      int n = (w - col < CHUNK) ? (w - col) : CHUNK;
37      bmp.read(raw, n * 3);
38      for (int i = 0; i < n; i++) {
39        px[i] = tft.color565(raw[i * 3 + 2], raw[i * 3 + 1], raw[i * 3]);   // BGR -> RGB565
40      }
41      tft.pushColors(px, n, first);
42      first = false;
43    }
44  }
45  tft.setAddrWindow(0, 0, tft.width() - 1, tft.height() - 1); // pencereyi sıfırla / reset the window
46  bmp.close();
47  return true;
48}
49
50void setup() {
51  Serial.begin(9600);
52  tft.begin(tft.readID());
53  tft.setRotation(0);                                         // dikey, 240x320 / portrait, 240x320
54  tft.fillScreen(0x0000);
55  if (!SD.begin(SD_CS)) {
56    Serial.println(F("SD kart yok / no SD card"));
57    return;
58  }
59  if (!drawBMP("KEDI.BMP", 0, 0)) {
60    Serial.println(F("BMP okunamadi / BMP not readable"));
61  }
62}
63
64void loop() {
65}

Em um arquivo BMP, as linhas são armazenadas de baixo para cima e cada linha é completada até um múltiplo de 4 bytes; o código cuida desses dois detalhes com o cálculo de rowSize e a flag bottomUp. Cada pixel ocupa 3 bytes, na ordem azul, verde, vermelho, e color565() o transforma na cor de 16 bits que o display entende. Como o Uno só tem 2 KB de RAM e a biblioteca SD reserva 512 bytes disso para o buffer, lemos os pixels de 20 em 20. Em um Uno, uma imagem de tela cheia é desenhada linha por linha em alguns segundos. Para a formatação do cartão e a manipulação de arquivos, veja nosso guia do módulo de cartão SD.

Usando com um Arduino Mega

O shield se encaixa nos conectores do Mega na mesma posição e, como a MCUFRIEND_kbv reconhece o Mega, o código do display e do toque roda sem alterações. O grande ganho são os pinos: D22–D53, A5–A15, três portas seriais extras e o barramento I2C em D20–D21 ficam todos livres, o que faz do Mega a escolha mais confortável para projetos grandes, com sensores e display. O único problema é o slot SD: o shield liga o cartão SD a D10–D13, mas o SPI por hardware do Mega fica em D50–D53, então o SD.begin() falha. A solução é usar a biblioteca SdFat com SPI por software em D10–D13; o exemplo showBMP_not_Uno da MCUFRIEND_kbv mostra exatamente isso. Para todos os pinos do Mega, veja nosso guia da pinagem do Arduino Mega.

Dá para usar com um ESP32 ou um Raspberry Pi Pico?

Resposta curta: não é recomendado. O shield paralelo espera 13 pinos e um conector de Uno que aceite 5 V. Nas placas ESP32 em formato de Uno (ESPDuino-32, D1 R32 e similares), os pinos A2–A4 do conector geralmente vão para os GPIO 34–36, que só podem ser entradas; as linhas de controle do display não podem ser acionadas por eles, e o painel de toque também não encontra pinos adequados para as leituras analógicas. Há quem faça funcionar refazendo as ligações e usando as configurações paralelas da TFT_eSPI, mas é um trabalho chato. Para o ESP32 e o Pico, um módulo SPI com a mesma resolução faz muito mais sentido: ele é ligado com quatro ou cinco fios e deixa a maioria dos pinos livres. Os detalhes estão no nosso guia do display TFT ILI9341 e, para uma opção menor e mais nítida, no guia do display TFT ST7789.

Ideias de projetos com o shield TFT de 2,4"

  • Calculadora de toque: desenhe uma grade 4×4 de botões e mostre o resultado em uma fonte grande; a lógica é a mesma do nosso guia da calculadora com Arduino.
  • Porta-retratos digital: mostre os arquivos BMP do cartão SD um após o outro e passe para o próximo quando a tela for tocada.
  • Fechadura com senha: desenhe um teclado numérico na tela e acione o relé no A5 quando a senha certa for digitada; para a lógica do teclado, veja o guia do teclado matricial.
  • Jogos: Pong, Snake ou um jogo da velha de toque; encontre ideias em projetos de jogos com Arduino.
  • Gráfico de temperatura: ligue um DHT11 a um Mega e mostre a temperatura da última hora como um gráfico de linha que vai rolando.
  • Osciloscópio simples: desenhe o sinal lido no A5 como uma forma de onda; para sinais lentos, é uma ferramenta de aprendizado divertida.
Se a tela piscar, não apague o display inteiro com fillScreen() a cada volta; limpe só a área que muda com fillRect() e redesenhe-a. Colocar os textos fixos dentro de F() economiza RAM. Para que o fundo atrás de números que mudam seja limpo automaticamente, use a forma setTextColor(texto, fundo).

Com a biblioteca certa, o shield TFT de 2,4" fica funcionando em minutos, e o painel de toque dá aos seus projetos uma interface de usuário de verdade. Se você preferir começar com um display mais simples, o app BlueGrays tem projetos passo a passo, com esquema do circuito e código, para um LCD I2C, texto rolando em um LCD 16x2, jogos Pong e T-Rex em um OLED e um jogo de corrida no LCD.

Perguntas frequentes

Por que meu shield TFT 2,4 mostra uma tela branca?

Tela branca significa que a luz de fundo está acesa, mas o chip controlador não foi inicializado. A causa mais comum é a sua biblioteca não reconhecer o chip do shield. Instalar a MCUFRIEND_kbv, ler o ID com tft.readID() e iniciar o display com tft.begin(ID) resolve na maioria das vezes; se o ID voltar como 0x0000, o shield não está bem encaixado.

Qual biblioteca devo usar com o shield TFT 2,4?

Use a MCUFRIEND_kbv junto com a Adafruit GFX Library para o display, a Adafruit TouchScreen para o toque e a biblioteca SD que vem com o Arduino IDE para o cartão. As antigas bibliotecas SPFD5408 e Adafruit_TFTLCD só são compatíveis com alguns chips, e é por isso que costumam dar tela branca nos shields mais novos.

Como descobrir qual chip controlador meu display TFT tem?

Chame tft.readID() com a MCUFRIEND_kbv e imprima o resultado no Monitor Serial: 0x9341 significa ILI9341, 0x9325 significa ILI9325 e 0x7783 significa ST7781. O exemplo LCD_ID_readreg da biblioteca despeja todos os registradores do chip, para quem quiser mais detalhes.

O shield TFT 2,4 funciona com um Arduino Mega?

Sim, o shield também se encaixa em um Mega, e a MCUFRIEND_kbv é compatível com ele. Só o slot SD não funciona de primeira, porque os pinos SPI do Mega ficam em D50–D53; para o cartão SD você precisa da biblioteca SdFat com SPI por software. Em troca, você ganha muitos pinos livres.

Como corrigir o toque invertido no shield TFT?

Primeiro rode de novo o exemplo TouchScreen_Calibr_native e cole no seu código os valores que ele imprime. Se esquerda e direita estiverem trocadas, troque TS_LEFT e TS_RT entre si; se cima e baixo estiverem trocados, troque TS_TOP e TS_BOT. Se os eixos se misturarem no modo paisagem, mapeie p.y para x e p.x para y.

Quais pinos sobram com o shield TFT encaixado?

Em um Uno sobram apenas A5, D0–D1 (compartilhados com o carregamento por USB) e, se você não usar o cartão SD, D10–D13. Como o A4 é a linha de reset do display, o I2C não pode ser usado. Se quiser ligar mais sensores, um Arduino Mega ou um módulo TFT com interface SPI é uma escolha melhor.

Ver todos os projetos
Uso do display LCD com I2C
AR-32Iniciante
Premium

Uso do display LCD com I2C

Dê ao seu Arduino um display próprio e faça-o escrever sua primeira mensagem. O display LCD de duas linhas é conectado com poucos fios; primeiro aparece uma saudação na linha de cima, depois uma…

4.8(53)
70
Exibição de mensagens no display LCD 2x16
AR-29Avançado
Premium

Exibição de mensagens no display LCD 2x16

Seu primeiro passo para escrever textos em um display. O display LCD de duas linhas mostra primeiro uma mensagem de espera, depois escreve uma saudação na linha de cima e uma palavra letra por letra…

4.6(37)
51
Animação de texto que rebate nas bordas do LCD
AR-30Avançado
Premium

Animação de texto que rebate nas bordas do LCD

Na linha de cima do display LCD, a palavra BLUEGRAYS desliza de uma borda à outra e volta como uma bola que bate na parede, repetindo o movimento sem parar.

4.5(29)
40
Jogo de bola e raquetes - SSD1306
AR-86Intermediário
Premium

Jogo de bola e raquetes - SSD1306

Uma bola, duas raquetes e você: jogue tênis de mesa, um dos primeiros videogames, em um pequeno display OLED.

4.5(47)
65
Corrida do T-Rex no OLED: jogo do dinossauro com Arduino
AR-87Avançado
Premium

Corrida do T-Rex no OLED: jogo do dinossauro com Arduino

O jogo do dinossauro que aparece quando a internet cai, agora na sua mesa: o dinossauro corre pelo pequeno display OLED, os cactos vêm na sua direção e você pula com um único botão.

4.7(33)
53
Jogo de corrida no LCD com Arduino
AR-96Intermediário
Premium

Jogo de corrida no LCD com Arduino

Jogo de corrida infinita com rolagem lateral em um display LCD de 16x2 caracteres. O herói corre automaticamente, e o jogador pressiona o botão para pular os obstáculos. Obstáculos aleatórios aparecem nas linhas superior e inferior. O buzzer passivo toca a melodia de abertura, o som de pulo, o som de comemoração a cada 50 pontos e a melodia de fim de jogo. A tela de abertura "BlueGrays - Arduino Projects" aparece ao iniciar. A pontuação é atualizada em tempo real no canto superior direito.

4.6(32)
56
Calculadora I2C com Arduino
AR-94Intermediário
Premium

Calculadora I2C com Arduino

Projeto de calculadora com Arduino que faz operações de adição, subtração, multiplicação e divisão usando um teclado de membrana 4x4 e um display LCD I2C 16x2. Com I2C, a conexão do display usa apenas 2 fios, reduzindo a quantidade de cabos e deixando mais pinos livres. Também permite inserir números decimais e negativos.

5.0(31)
43
Fechadura com senha, teclado 4x4 e LCD
AR-64Avançado
Premium

Fechadura com senha, teclado 4x4 e LCD

Uma pequena fechadura eletrônica que impede a entrada de quem não sabe a senha. Você pressiona a cerquilha e digita a senha no teclado.

4.8(59)
75