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.

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ística | Valor |
|---|---|
| Tela | TFT de 2,4 polegadas, 240×320 pixels |
| Cores | 16 bits (RGB565), 65.536 cores |
| Interface | Paralela de 8 bits (D0–D7) + 5 linhas de controle |
| Chip controlador | Varia: ILI9341, ILI9325, ST7781, SPFD5408, HX8347 e outros |
| Toque | Resistivo de 4 fios, compartilha pinos com o display |
| Slot SD | microSD via SPI (D10–D13) |
| Alimentação | 5 V (regulador de 3,3 V na placa) |
| Corrente | Cerca de 80–120 mA, a maior parte para a luz de fundo |
| Placas compatíveis | Arduino 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.

| Característica | Shield de 2,4" para Uno | Módulo SPI de 2,4" |
|---|---|---|
| Ligação | Encaixa em um Uno ou Mega, sem fios | 7 a 14 jumpers |
| Pinos usados | D2–D9, A0–A4 (D10–D13 com o SD) | 5 para o display, 8–9 com toque e SD |
| Velocidade de desenho em um Uno | Rápida (paralelo) | Mais lenta (SPI) |
| Biblioteca | MCUFRIEND_kbv | Adafruit_ILI9341, TFT_eSPI |
| Leitura do toque | Analógica, pinos compartilhados com o display | Chip XPT2046 via SPI |
| ESP32 e Pico | Não indicado | Indicado |
| Pinos livres para sensores | Quase nenhum | Muitos |
Tabela de pinos: quais pinos o shield usa?
| Pino do shield | Pino do Arduino Uno | Função |
|---|---|---|
| LCD_RD | A0 | Sinal de leitura |
| LCD_WR | A1 | Sinal de escrita (pode ser compartilhado com o toque) |
| LCD_RS (CD) | A2 | Comando ou dado? (compartilhado com o toque) |
| LCD_CS | A3 | Seleção do chip do display (pode ser compartilhado com o toque) |
| LCD_RST | A4 | Reset do display |
| LCD_D0, LCD_D1 | D8, D9 | Dois primeiros bits do barramento de dados |
| LCD_D2–LCD_D7 | D2–D7 | Os outros seis bits do barramento de dados |
| SD_SS / SD_DI / SD_DO / SD_SCK | D10 / D11 / D12 / D13 | Cartão microSD (SPI) |
| 5V, 3V3, GND | 5V, 3.3V, GND | Alimentação |
Instalando a biblioteca MCUFRIEND_kbv
- Abra o Gerenciador de Bibliotecas no Arduino IDE, procure por MCUFRIEND_kbv e instale.
- No mesmo lugar, instale a Adafruit GFX Library; as funções de texto, linha, círculo e botão vêm dela.
- Para o toque, instale a biblioteca Adafruit TouchScreen (no código, ela é incluída como TouchScreen.h).
- 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.
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 lido | Chip | O que fazer |
|---|---|---|
| 0x9341 | ILI9341 | O modelo mais comum; funciona de primeira |
| 0x9325 / 0x9328 | ILI9325 / ILI9328 | Mais antigo, mas confiável; funciona de primeira |
| 0x7783 | ST7781 | Funciona de primeira |
| 0x5408 | SPFD5408 | Funciona de primeira; não precisa da antiga biblioteca SPFD5408 |
| 0x4747 / 0x9595 | HX8347-D / HX8347-I | Funciona de primeira |
| 0x1505 / 0x0154 | R61505 / S6D0154 | Funciona de primeira |
| 0xD3D3 | Shield sem a linha de leitura conectada | Escreva o ID no código à mão; em um de 2,4", tente primeiro 0x9341 |
| 0x0000 ou 0xFFFF | Sem resposta | Shield 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:
| Sintoma | Causa provável | Solução |
|---|---|---|
| Tela branca com uma biblioteca antiga | A biblioteca não conhece o seu chip | Instale a MCUFRIEND_kbv e inicialize o display com o readID |
| Tela branca, ID 0x0000 ou 0xFFFF | Shield mal encaixado ou pino torto | Retire o shield, endireite os pinos e pressione-o até o fim |
| Tela branca, ID 0xD3D3 | Sem linha de leitura, então o ID não pode ser lido | Defina 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 é diferente | tft.invertDisplay(true) depois do begin |
| Vermelho e azul trocados | O ID definido à mão não corresponde ao chip | Use o ID que o readID encontra e atualize a biblioteca para a versão mais recente |
| Texto espelhado | O ID definido à mão não corresponde ao painel | Obtenha o ID com o readID; confira as quatro orientações com o exemplo aspect_kbv |
| A imagem se desfaz quando você toca na tela | A leitura do toque deixou os pinos compartilhados como entradas | Volte YP e XM para OUTPUT depois do getPoint |
| Funciona em um Uno, fica branca em um Mega | A biblioteca não conhece o mapeamento de pinos do Mega | A 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.
- Abra o exemplo TouchScreen_Calibr_native em Arquivo > Exemplos > MCUFRIEND_kbv e carregue-o.
- Abra o Monitor Serial em 9600 baud; o exemplo primeiro descobre sozinho os pinos do toque.
- Pressione, uma a uma, as cruzes que aparecem na tela, mantendo o dedo ou a caneta em cada uma até o texto mudar.
- 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=....
- Cole essas duas linhas no lugar dos valores de exemplo que ficam no topo dos sketches abaixo.
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.
| Sintoma | Causa | Solução |
|---|---|---|
| Tocar na direita coloca o ponto na esquerda | Eixo X invertido | Troque entre si os valores de TS_LEFT e TS_RT |
| Tocar em cima coloca o ponto embaixo | Eixo Y invertido | Troque entre si os valores de TS_TOP e TS_BOT |
| X e Y misturados no modo paisagem | O setRotation(1) girou os eixos | Mapeie p.y para x e p.x para y, ou fique no modo retrato |
| Nenhum toque é detectado | XP, XM, YP, YM estão errados | Rode de novo o exemplo de calibração e use os pinos que ele informar |
| Pontos aparecem sem ninguém tocar | Limiar de pressão baixo demais | Aumente o MINPRESSURE para 300–400 |
| Os pontos caem alguns pixels fora do lugar | A calibração foi feita às pressas | Calibre 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 Ω.
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.
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.
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.
Projetos para montar depois desta leitura
Ver todos os projetos
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…

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…

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.

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.

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.

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.

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.

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.
Mais artigos
App BlueGrays
Monte este circuito passo a passo pelo celular
Esquema do circuito, código e lista de componentes em uma só tela. Mais de 500 projetos com Arduino, ESP32 e Pico prontos para montar.
Escaneie com seu celular
Aponte a câmera para o código para abrir a loja de aplicativos do seu celular.
ou abrir a loja

