SENSORES/ATUADORES

INTERNET DAS COISAS (IoT)

Arduino Nano - Ethernet

Arduino Nano - Web Server

Arduino Nano - Display TFT LCD Touch ILI9341 ILI9488 ST7789 com Interface SPI

Este passo a passo leva você, etapa por etapa, ao uso de um display TFT SPI no Arduino Nano. O Nano reúne o mesmo ATmega328P do Uno em um formato compacto e adequado para protoboard - ele tem os mesmos pinos de SPI por hardware, então a ligação do TFT é idêntica à do Uno. A principal limitação a ter em mente são os 2KB de SRAM: evite bitmaps grandes na memória e use PROGMEM para os dados de imagem.

O que você vai percorrer:

Ligação de um display TFT SPI ao Arduino Nano.
Desenho de formas, linhas e áreas preenchidas.
Exibição de texto e números em vários tamanhos.
Desenho de imagens bitmap a partir da memória de programa (PROGMEM).
Desenho de imagens bitmap carregadas de um cartão SD.
Renderização de texto com uma fonte externa personalizada.
Leitura das coordenadas brutas de toque de um controlador XPT2046.
Desenho na tela arrastando o dedo.
Criação de botões de toque interativos.
Calibração da tela touch.
Uso de um barramento SPI secundário ou personalizado para o display.

Este passo a passo cobre displays TFT LCD SPI com e sem touch. Ele funciona com painéis de 1,3, 1,54, 2,2, 2,4, 2,8, 3,2 e 3,5 polegadas controlados pelos chips ILI9341, ILI9488 ou ST7789.

Hardware Necessário

1	×	Official Arduino Nano
1	×	Alternatively, DIYables Nano V3.0 Development Board
1	×	Cabo USB A para Mini-B
1	×	SPI TFT display module
1	×	5V to 3.3V Level Converter
1	×	Fios Jumper
1	×	(Recomendado) Placa de Expansão com Bornes de Parafuso para Arduino Nano
1	×	(Recomendado) Placa de Expansão Breakout para Arduino Nano
1	×	(Recomendado) Divisor de Alimentação para Arduino Nano

Or you can buy the following kits:

DIYables Sensor Kit (18 sensors/displays)

Divulgação: Alguns dos links desta seção são links de afiliado da Amazon. Podemos receber uma comissão pelas compras feitas por meio desses links, sem custo adicional para você. Agradecemos o seu apoio.

O Que É o Display TFT SPI?

Um módulo de display TFT SPI é um painel LCD colorido controlado por um chip driver por meio de um barramento SPI de 4 fios. A biblioteca DIYables_TFT_SPI suporta três chips driver populares:

ILI9341 - cor RGB565 de 16 bits, SPI de até 40 MHz.
ILI9488 - cor RGB666 de 18 bits via SPI, até 24 MHz.
ST7789 - cor RGB565 de 16 bits, SPI de até 40 MHz.

Recomendação: Se você ainda não comprou um display, recomendamos o driver ST7789. Ele é amplamente disponível, funciona na velocidade total de SPI de 40 MHz e é a escolha mais simples para novos projetos.

Todo o desenho é feito pela API Adafruit GFX, que oferece formas, texto, fontes e saída de bitmap.

Pinagem

A maioria dos displays TFT LCD SPI tem os seguintes pinos:

Pinos do display:

Pino	Função
VCC	Alimentação
GND	GND
CS	Chip Select — colocado em nível baixo para selecionar o display no barramento SPI
DC / RS	Seleção de Dados / Comando — alto para dados de pixel, baixo para comandos
RST	Reset por hardware — opcional; ligue ao 3.3V se não for usado
MOSI / SDI / SDA	Entrada de dados SPI (MCU → display)
SCK / CLK	Clock SPI
MISO / SDO	Saída de dados SPI (display → MCU) — opcional para uso apenas com display
LED / BL / BLK	Alimentação da luz de fundo — conecte ao 3.3V ou a um pino PWM para controlar o brilho

Pinos do cartão SD (se a sua aplicação precisar acessar o cartão SD):

Pino	Função
SD_CS / TF_CS	Chip Select do cartão SD
MOSI / SDI	MOSI — dados do MCU para o cartão SD
SCK / CLK	SCK — clock SPI
MISO / SDO	MISO — dados do cartão SD para o MCU

Nos displays TFT com suporte a touch, há pinos adicionais de toque (se a sua aplicação usar a função de toque e o display a suportar):

Pino	Função
T_CS	Chip Select do controlador de toque
T_CLK	SCK — clock SPI
T_DIN	MOSI — dados do MCU para o controlador de toque
T_DO	MISO — dados do controlador de toque para o MCU
T_IRQ	Interrupção de toque — opcional; sinaliza quando a tela está sendo tocada

Nota: Alguns módulos de display sem touch também expõem os pinos T_CS, T_CLK, T_DIN, T_DO e T_IRQ. Esses pinos não funcionam nessas placas — o CI controlador de toque não está montado. Eles aparecem porque a PCB reutiliza o mesmo layout da versão com touch para reduzir as variações de fabricação.

Diagrama de Ligação

Nota — conversor de nível opcional: Esses módulos de display TFT SPI incluem conversão de nível na própria placa nas linhas de sinal, então a lógica de 5V do Arduino Nano pode acionar MOSI, SCK, CS, DC, RST e T_CS (se usar touch) diretamente — essa ligação foi testada e funciona. Para uma montagem permanente, adicionar um Conversor de Nível de 5V para 3.3V nas linhas de sinal acionadas pelo MCU ainda é a escolha mais segura para confiabilidade a longo prazo. A linha MISO (display → MCU) nunca precisa de um.

Nota — SDO (MISO) é opcional: A linha SDO (MISO) só leva dados do display de volta para a placa. Nenhum dos códigos de exemplo deste tutorial lê dados do display, então esse pino pode ficar desconectado. Em módulos nos quais o controlador de toque compartilha o mesmo barramento SPI, uma linha SDO conectada pode interferir na comunicação, por isso recomenda-se deixá-la desconectada.

Sem Touch

Conecte MOSI ao D11, SCK ao D13 e MISO ao D12 no Nano. CS, DC e RST podem ser qualquer GPIO disponível — D10, D8 e D9 são usados nos exemplos.

Display:

Pino do TFT	Pino do Arduino Nano	Descrição
VCC	3.3V	Alimentação (somente 3.3V — o display funciona a 3.3V)
GND	GND	GND
CS	D10	Chip Select
DC / RS	D8	Seleção de Dados / Comando
RST	D9	Reset (opcional)
MOSI / SDI	D11	MOSI do SPI por hardware
SCK	D13	Clock do SPI por hardware
MISO / SDO	D12	MISO do SPI por hardware (opcional)
LED / BL	3.3V	Alimentação da luz de fundo

Cartão SD (se a sua aplicação precisar acessar o cartão SD):

Pino do SD	Pino do Arduino Nano	Descrição
SD_CS / TF_CS	qualquer GPIO livre	Chip Select do cartão SD
MOSI / SDI	D11	Compartilhado com o MOSI do display (D11)
SCK / CLK	D13	Compartilhado com o SCK do display (D13)
MISO / SDO	D12	Compartilhado com o MISO do display (D12)

Diagrama de ligação do display TFT SPI com Arduino Nano sem touch

This image is created using Fritzing. Click to enlarge image

Com Touch

Conecte o controlador de toque XPT2046 ao barramento SPI do Arduino Nano, compartilhando D11, D13 e D12 com o display.

Display:

Pino do TFT	Pino do Arduino Nano	Descrição
VCC	3.3V	Alimentação (somente 3.3V — o display funciona a 3.3V)
GND	GND	GND
CS	D10	Chip Select
DC / RS	D8	Seleção de Dados / Comando
RST	D9	Reset (opcional)
MOSI / SDI	D11	MOSI do SPI por hardware
SCK	D13	Clock do SPI por hardware
MISO / SDO	D12	MISO do SPI por hardware (opcional)
LED / BL	3.3V	Alimentação da luz de fundo

Controlador de toque (se a sua aplicação usar a função de toque e o display a suportar):

Pino de Toque	Pino do Arduino Nano	Descrição
T_CS	qualquer GPIO livre	Chip Select do toque
T_IRQ	qualquer GPIO livre	Interrupção de toque (opcional)
T_DIN	D11	Compartilhado com o MOSI do display (D11)
T_CLK	D13	Compartilhado com o SCK do display (D13)
T_DO	D12	Compartilhado com o MISO do display (D12)

Diagrama de ligação do display TFT SPI com Arduino Nano com touch

This image is created using Fritzing. Click to enlarge image

Veja A melhor forma de alimentar o Arduino Nano e outros componentes.

Se o seu MCU tem duas ou mais interfaces SPI por hardware, você pode atribuir cada periférico (display, cartão SD, controlador de toque) ao seu próprio barramento SPI dedicado. Se o seu MCU tem apenas uma interface SPI por hardware, os três periféricos compartilham as mesmas três linhas de dados (MOSI, SCK, MISO) — no Nano, são D11, D13 e D12. Cada periférico tem o seu próprio pino CS, então apenas um fica ativo por vez. A biblioteca DIYables_TFT_SPI gerencia tanto o display quanto o controlador de toque XPT2046 por uma única API — nenhuma biblioteca SPI separada é necessária para o lado do toque.

Configurando a Biblioteca

Conecte o Arduino Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE. Defina a placa como Arduino Nano e selecione a porta correspondente.
Vá ao painel Libraries à esquerda.
Digite "DIYables_TFT_SPI" na caixa de pesquisa. Procure a biblioteca da DIYables.
Clique em Install. Quando solicitado, instale todas as dependências.

Search for DIYables TFT SPI created by DIYables.io and click the Install button.

Newbiely | Arduino IDE 2.3.8

──

☐

Library Manager

DIYables TFT SPI

All

DIYables TFT SPI by DIYables.io

Works with both touch and non-touch versions of the same SPI TFT modules. Supports ILI9341 (240x320, 16-bit RGB565), ILI9488 (320x480, 18-bit RGB666), and ST7789 (240x320, 16-bit RGB565) displays over SPI. Includes built-in driver for XPT2046 / HR2046 / ADS7843 SPI touch controllers and 4-wire resistive touch panels - no separate touch library required. Use the display-only API for non-touch panels, or add initTouchSPI() to enable touch on modules that include a touch controller. Extends Adafruit GFX for full graphics support. Works with any Arduino-compatible board that has SPI. More info

1.0.3

INSTALL

Newbiely.ino

···

1 void setup() {

Output

Serial Monitor

Ln 1, Col 1

Arduino Nano on COM15

Nota: Se o seu Nano usa um bootloader mais antigo, selecione ATmega328P (Old Bootloader) em Processor no menu Tools.

Código Base

Todo sketch criado com a biblioteca DIYables_TFT_SPI parte desta base:

#include <DIYables_TFT_SPI.h> #define TFT_CS_PIN 10 #define TFT_DC_PIN 8 #define TFT_RST_PIN 9 // Uncomment the line that matches your driver chip: // DIYables_ILI9341_SPI TFT_display(240, 320, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); // DIYables_ILI9488_SPI TFT_display(320, 480, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); DIYables_ST7789_SPI TFT_display(240, 320, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); void setup() { TFT_display.begin(); TFT_display.setRotation(1); } void loop() { // drawing code here }

Passe ao construtor as dimensões físicas de pixel do painel. Um tamanho errado faz a imagem ser cortada ou deslocada.

Código Arduino Nano - Desenhar Formas

O exemplo DrawShapes desenha círculos, triângulos, retângulos, retângulos arredondados e linhas usando as primitivas do Adafruit GFX.

Acompanhe

Ligue o módulo TFT ao Nano usando a tabela acima.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
O display mostra uma grade repetida de formas coloridas.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
begin()	Inicializa o controlador do display.	TFT_display.begin();
setRotation(r)	Gira de 0 a 3. 1=paisagem.	TFT_display.setRotation(1);
fillScreen(color)	Pinta a tela inteira.	TFT_display.fillScreen(WHITE);
colorRGB(r,g,b)	Cria um valor de cor de 16 bits.	colorRGB(0,255,0)
fillCircle(x,y,r,color)	Círculo sólido.	TFT_display.fillCircle(60,60,30,RED);
drawRect(x,y,w,h,color)	Contorno de retângulo.	TFT_display.drawRect(10,10,80,50,BLUE);
fillTriangle(x0,y0,x1,y1,x2,y2,color)	Triângulo preenchido.	TFT_display.fillTriangle(60,10,10,110,110,110,GREEN);

Código Arduino Nano - Mostrar Texto e Número

O exemplo ShowTextAndNumber imprime strings e valores numéricos na tela usando o mecanismo de texto integrado do GFX.

Acompanhe

Faça a ligação e o upload como acima.
O display imprime várias linhas de texto e números.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
setTextColor(color)	Define a cor de frente para todo o texto seguinte.	TFT_display.setTextColor(WHITE);
setTextSize(size)	Escala o texto por um fator de pixels. Tamanho 1 = 6×8 px. Mantenha o tamanho pequeno para caber na tela pequena do Nano.	TFT_display.setTextSize(1);
setCursor(x, y)	Posiciona o cursor de texto em (x, y).	TFT_display.setCursor(0, 10);
print(value)	Imprime uma string ou um número no cursor. Mantenha as strings curtas para economizar SRAM.	TFT_display.print("Nano!");
println(value)	Imprime e quebra para a próxima linha.	TFT_display.println(42);

Código Arduino Nano - Desenhar Imagem

O exemplo DrawImage mostra na tela um bitmap RGB565 em cores completas. O Nano tem apenas 2 KB de SRAM, então os dados de pixel precisam ficar na flash de programa usando a palavra-chave PROGMEM. O arquivo auxiliar bitmap.h contém um array const uint16_t declarado como PROGMEM. A biblioteca lê diretamente da flash no momento do desenho, sem tocar na SRAM.

Coloque o bitmap.h na mesma pasta do sketch antes de compilar.

Acompanhe

Copie o bitmap.h para a mesma pasta do sketch.
Ligue o display TFT ao Nano usando a tabela de pinos acima (D11, D13, D12 para o SPI).
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
O display renderiza a imagem bitmap da PROGMEM.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
drawRGBBitmap(x,y,bitmap,w,h)	Desenha um bitmap RGB565 a partir de um array em PROGMEM. A posição (x, y) é o canto superior esquerdo.	TFT_display.drawRGBBitmap(0, 0, myImage, 240, 320);
fillScreen(color)	Limpa a tela com uma cor sólida antes de desenhar.	TFT_display.fillScreen(BLACK);

Código Arduino Nano - Desenhar Imagem do Cartão SD

O exemplo DrawImageSDcard lê um arquivo de imagem RGB565 bruto de um cartão SD e o envia ao display em pequenos blocos. Como os dados são transmitidos em fluxo, em vez de carregados em um buffer completo, até o Nano consegue exibir imagens grandes sem esgotar a SRAM.

Ligue o módulo SD aos mesmos pinos SPI do display (D11/D13/D12) e conecte a linha CS dele a um pino separado, definido como SD_CS_PIN.

Acompanhe

Ligue o módulo de cartão SD ao Nano. Compartilhe o barramento SPI: MOSI→D11, SCK→D13, MISO→D12. Conecte o CS do SD ao pino definido como SD_CS_PIN.
Copie uma imagem binária RGB565 bruta para a raiz do cartão SD. A largura e a altura da imagem devem corresponder ao seu painel.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
A imagem é lida do cartão e exibida na tela.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
startWrite()	Abre uma transação SPI direta, mantendo o CS do display ativo.	TFT_display.startWrite();
setAddrWindow(x0,y0,x1,y1)	Define a região retangular que vai receber os dados de pixel.	TFT_display.setAddrWindow(0, 0, 239, 319);
pushColors(buf, len)	Envia um buffer de valores de pixel RGB565 ao display. Mantenha o buffer pequeno para ficar dentro do limite de SRAM do Nano.	TFT_display.pushColors(buf, 256);
endWrite()	Fecha a transação SPI e libera o CS.	TFT_display.endWrite();

Código Arduino Nano - Usar Fonte Externa

O exemplo UseExternalFont troca a fonte bitmap 5×7 integrada por uma fonte personalizada mais nítida, compatível com o Adafruit GFX. Selecione a fonte passando um ponteiro para a sua struct a setFont(). Chame setFont(NULL) para voltar à fonte integrada a qualquer momento.

Acompanhe

Ligue o display TFT ao Nano usando a tabela de pinos acima.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
O display renderiza o texto usando a fonte personalizada.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
setFont(&FontName)	Ativa uma fonte personalizada compatível com o GFX. Passar NULL restaura a fonte integrada 5×7.	TFT_display.setFont(&FreeSans12pt7b);
setCursor(x, y)	Move o cursor de texto para a posição de pixel indicada.	TFT_display.setCursor(10, 40);
setTextColor(color)	Define a cor de frente do texto impresso.	TFT_display.setTextColor(WHITE);
print(text)	Imprime uma string usando a fonte ativa no cursor atual.	TFT_display.print("Nano!");

Código Arduino Nano - Obter Ponto de Toque

O exemplo TouchGetPoint lê valores brutos do ADC de um controlador de toque XPT2046 e os imprime no Serial Monitor. Percorra este exemplo primeiro para ver a faixa de coordenadas brutas que o seu painel produz - esses extremos são o que você vai usar depois na calibração.

Ligação: compartilhe o barramento SPI (D11/D13/D12) entre o XPT2046 e o display. Conecte T_CS ao D7 e T_IRQ ao D6.

Acompanhe

Ligue o XPT2046 ao Nano. Compartilhe D11 (MOSI), D13 (SCK) e D12 (MISO) com o display. T_CS→D7, T_IRQ→D6.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
Abra o Serial Monitor a 9600 baud. Pressione diferentes partes da tela para ver os valores brutos de X, Y e Z.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
initTouchSPI(cs, irq)	Inicia o XPT2046 no barramento SPI compartilhado. Passe -1 em irq se o pino de interrupção não estiver ligado.	TFT_display.initTouchSPI(7, 6);
readTouchRaw(x, y, z)	Retorna valores brutos de coordenada do ADC, sem nenhuma calibração aplicada. Retorna true quando a tela é tocada.	TFT_display.readTouchRaw(x, y, z);

Código Arduino Nano - Desenho por Toque

O exemplo TouchDraw cria um aplicativo de pintura com o dedo no Nano. Cada ponto em que o dedo encosta produz um pequeno círculo preenchido na coordenada de tela calibrada correspondente, e arrastar o dedo forma um traço contínuo.

Acompanhe

Ligue o XPT2046 ao Nano como descrito na seção Obter Ponto de Toque.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
Arraste um dedo pelo display para desenhar na tela. Levante e pressione de novo para começar um novo traço.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
initTouchSPI(cs, irq)	Inicia o XPT2046 no barramento SPI compartilhado.	TFT_display.initTouchSPI(7, 6);
setTouchCalibration(minX,maxX,minY,maxY)	Mapeia as leituras brutas do ADC para coordenadas de pixel da tela. Obtenha esses números no exemplo TouchCalibration.	TFT_display.setTouchCalibration(200, 3800, 300, 3700);
setTouchInvertX(invert) / setTouchInvertY(invert)	Inverte o eixo de toque quando X ou Y está espelhado no seu painel ou lote específico. Chame ANTES de setTouchCalibration().	TFT_display.setTouchInvertY(true);
getTouch(x, y)	Retorna as coordenadas de toque calibradas em pixels. Retorna true enquanto a tela está pressionada.	if (TFT_display.getTouch(x, y)) { ... }
fillCircle(x, y, r, color)	Desenha um pequeno ponto na posição do toque.	TFT_display.fillCircle(x, y, 3, RED);

Código Arduino Nano - Botão de Toque

O exemplo TouchButton desenha botões retangulares na tela e detecta toques na região de cada botão. Quando um botão é tocado, ele é destacado e dispara a sua ação. Essa é a base de um menu controlado por toque no Nano.

T_IRQ é opcional. Passe -1 como argumento irq se preferir não conectar o pino de interrupção.

Acompanhe

Conecte T_CS ao D7. T_IRQ pode ficar desconectado.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
Toque nos botões do display. Cada um deve mudar de cor quando pressionado.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
initTouchSPI(cs, irq)	Inicia o XPT2046. Passar -1 em irq desativa o pino de interrupção e usa polling no lugar.	TFT_display.initTouchSPI(7, -1);
setTouchCalibration(minX,maxX,minY,maxY)	Aplica a calibração para que getTouch() retorne posições de pixel precisas.	TFT_display.setTouchCalibration(200, 3800, 300, 3700);
setTouchInvertX(invert) / setTouchInvertY(invert)	Inverte o eixo de toque quando X ou Y está espelhado no seu painel ou lote específico. Chame ANTES de setTouchCalibration().	TFT_display.setTouchInvertY(true);
getTouch(x, y)	Obtém a posição de toque calibrada. Retorna true quando a tela está sendo tocada.	if (TFT_display.getTouch(x, y)) { ... }
fillRect(x, y, w, h, color)	Desenha o fundo do botão como um retângulo sólido.	TFT_display.fillRect(10, 10, 120, 60, BLUE);

Código Arduino Nano - Calibração do Toque

O exemplo TouchCalibration guia você na descoberta da faixa bruta do ADC do seu painel XPT2046. Toque em cada canto da tela em sequência e anote os valores mínimo e máximo de X e Y no Serial Monitor. Cole esses quatro números em setTouchCalibration() em todos os outros sketches de toque.

/* * Este código de Arduino Nano foi desenvolvido por pt.newbiely.com * Este código de Arduino Nano é disponibilizado ao público sem nenhuma restrição. * Para tutoriais completos e diagramas de ligação, visite: * https://pt.newbiely.com/tutorials/arduino-nano/arduino-nano-tft-lcd-touch-display-spi */ /* Touch Screen Calibration Example --------------------------------- This example measures the raw touch coordinates at all four screen corners and prints ready-to-use calibration values to the Serial Monitor. It uses readTouchRaw() directly — it does NOT rely on getTouch() or any existing calibration values, so it works even when touch is completely broken. INSTRUCTIONS: 1. Upload this sketch to your board. 2. Open the Serial Monitor (Ctrl+Shift+M) and set baud rate to 9600. 3. The screen shows a blinking red dot in each corner, numbered 1–4: 1 = Top-left 2 = Top-right 3 = Bottom-right 4 = Bottom-left 4. Press and HOLD firmly on the blinking dot. Keep holding until the Serial Monitor prints "Captured!" for that corner. 5. Release, then wait for the next dot to appear and repeat. 6. After all 4 corners, the Serial Monitor prints the calibration values and a ready-to-use setTouchCalibration() call. Copy it into your sketch. NOTE: While waiting, the Serial Monitor continuously prints the live raw Z/X/Y readings so you can confirm that touch is being detected. Created by DIYables This example code is in the public domain Product page: https://diyables.io */ // ============================================= // Single include brings in the base class plus all driver classes. // ============================================= #include <DIYables_TFT_SPI.h> // ============================================= // Wiring (Arduino Uno / Nano) // ============================================= // TFT pins (always required) // TFT module Arduino Uno / Nano // ------------ --------------------------------- // VCC -> 5V // GND -> GND // CS -> D10 (TFT_CS_PIN) // RESET -> D9 (TFT_RST_PIN) // DC / RS -> D8 (TFT_DC_PIN) // SDI / MOSI -> D11 (hardware SPI MOSI) // SCK -> D13 (hardware SPI SCK) // SDO / MISO -> D12 (only needed when reading from display) // LED -> 3.3V (or any GPIO via initBacklight) // // XPT2046 / HR2046 / ADS7843 SPI touch controller // (modules with pins: T_CS, T_CLK, T_DIN, T_DO, T_IRQ) // Touch pin Arduino Uno / Nano // ------------ --------------------------------- // T_CS -> D2 (TOUCH_CS_PIN) // T_IRQ -> D2 (TOUCH_IRQ_PIN, optional - use -1 to skip) // T_CLK -> D13 (shared with display SCK) // T_DIN -> D11 (shared with display MOSI) // T_DO -> D12 (shared with display MISO) // ============================================= // ============================================= // SPI pin definitions (adjust for your board) // ============================================= #define TFT_CS_PIN 10 #define TFT_DC_PIN 8 #define TFT_RST_PIN 9 // Panel resolution in native (portrait) orientation - change to match your module #define TFT_WIDTH 240 #define TFT_HEIGHT 320 // ============================================= // Touch pin definitions (XPT2046 / HR2046 SPI touch controller) // ============================================= #define TOUCH_CS_PIN 2 // T_CS (any GPIO) #define TOUCH_IRQ_PIN -1 // T_IRQ (any GPIO, or -1 if not connected) // ============================================= // ============================================= // Create display object (uncomment matching driver) // ============================================= // DIYables_ILI9341_SPI TFT_display(TFT_WIDTH, TFT_HEIGHT, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); // DIYables_ILI9488_SPI TFT_display(TFT_WIDTH, TFT_HEIGHT, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); DIYables_ST7789_SPI TFT_display(TFT_WIDTH, TFT_HEIGHT, TFT_CS_PIN, TFT_DC_PIN, TFT_RST_PIN); // Minimum pressure to count as a valid touch. #define TOUCH_Z_MIN 10 // How many consecutive valid samples required before a corner is accepted. #define SAMPLES_NEEDED 10 // Delay between samples (ms). #define SAMPLE_DELAY_MS 30 #define DOT_RADIUS 12 #define BLACK DIYables_TFT_SPI::colorRGB( 0, 0, 0) #define WHITE DIYables_TFT_SPI::colorRGB(255, 255, 255) #define RED DIYables_TFT_SPI::colorRGB(255, 0, 0) // Corner pixel positions — filled in setup() once display size is known. // Order: 0=top-left, 1=top-right, 2=bottom-right, 3=bottom-left int cx[4], cy[4]; // Captured averaged raw values per corner. int cap_x[4], cap_y[4]; // ----------------------------------------------------------------------- void drawDot(int corner, bool on) { uint16_t color = on ? RED : WHITE; TFT_display.fillCircle(cx[corner], cy[corner], DOT_RADIUS, color); TFT_display.setTextSize(2); TFT_display.setTextColor(BLACK, color); TFT_display.setCursor(cx[corner] - 6, cy[corner] - 8); TFT_display.print(corner + 1); } void captureCorner(int corner) { const char* names[] = { "Top-left", "Top-right", "Bottom-right", "Bottom-left" }; Serial.println(); Serial.print("Corner "); Serial.print(corner + 1); Serial.print(" ("); Serial.print(names[corner]); Serial.println(")"); Serial.println(" Press and HOLD firmly on the blinking dot."); Serial.println(" Keep holding until you see 'Captured!'"); unsigned long lastBlink = 0; unsigned long lastPrint = 0; bool dotOn = false; int goodSamples = 0; long sumX = 0, sumY = 0; while (true) { // Blink the dot if (millis() - lastBlink > 400) { lastBlink = millis(); dotOn = !dotOn; drawDot(corner, dotOn); } int raw_x, raw_y, z; TFT_display.readTouchRaw(raw_x, raw_y, z); // Print live readings every 500 ms if (millis() - lastPrint > 500) { lastPrint = millis(); Serial.print(" Z="); Serial.print(z); Serial.print(" X="); Serial.print(raw_x); Serial.print(" Y="); Serial.println(raw_y); } if (z >= TOUCH_Z_MIN) { sumX += raw_x; sumY += raw_y; goodSamples++; if (goodSamples >= SAMPLES_NEEDED) { cap_x[corner] = sumX / goodSamples; cap_y[corner] = sumY / goodSamples; Serial.print(" Captured! raw_x="); Serial.print(cap_x[corner]); Serial.print(" raw_y="); Serial.println(cap_y[corner]); drawDot(corner, false); delay(500); return; } } else { goodSamples = 0; sumX = 0; sumY = 0; } delay(SAMPLE_DELAY_MS); } } // ----------------------------------------------------------------------- void setup() { Serial.begin(9600); TFT_display.begin(); TFT_display.setRotation(0); // Always calibrate in rotation 0 TFT_display.fillScreen(WHITE); TFT_display.initTouchSPI(TOUCH_CS_PIN, TOUCH_IRQ_PIN); // If touch X is mirrored on your board, uncomment the line below // BEFORE calibrating (so the printed values match your panel): //TFT_display.setTouchInvertX(true); // If touch Y is mirrored on your board, uncomment: //TFT_display.setTouchInvertY(false); int w = TFT_display.width(); int h = TFT_display.height(); int m = DOT_RADIUS + 4; cx[0] = m; cy[0] = m; cx[1] = w - m; cy[1] = m; cx[2] = w - m; cy[2] = h - m; cx[3] = m; cy[3] = h - m; Serial.println("=== Touch Calibration ==="); for (int i = 0; i < 4; i++) { captureCorner(i); } // Derive calibration values from the four corners int min_x = (cap_x[0] + cap_x[3]) / 2; // left edge int max_x = (cap_x[1] + cap_x[2]) / 2; // right edge int min_y = (cap_y[0] + cap_y[1]) / 2; // top edge int max_y = (cap_y[2] + cap_y[3]) / 2; // bottom edge Serial.println(); Serial.println("=== Calibration Results ==="); Serial.print(" Left X (min_x): "); Serial.println(min_x); Serial.print(" Right X (max_x): "); Serial.println(max_x); Serial.print(" Top Y (min_y): "); Serial.println(min_y); Serial.print(" Bot Y (max_y): "); Serial.println(max_y); Serial.println(); Serial.println("Copy this line into your sketch:"); Serial.print(" TFT_display.setTouchCalibration("); Serial.print(min_x); Serial.print(", "); Serial.print(max_x); Serial.print(", "); Serial.print(min_y); Serial.print(", "); Serial.print(max_y); Serial.println(");"); TFT_display.fillScreen(WHITE); TFT_display.setTextColor(BLACK); TFT_display.setTextSize(2); TFT_display.setCursor(10, 10); TFT_display.println("Done! Check"); TFT_display.setCursor(10, 35); TFT_display.println("Serial Monitor"); } void loop() {}

Acompanhe

Ligue o XPT2046 ao Nano como descrito na seção Obter Ponto de Toque.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
Abra o Serial Monitor a 9600 baud. Toque em cada canto quando for solicitado.
Anote os quatro valores impressos e use-os em setTouchCalibration() nos seus outros sketches de toque.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
initTouchSPI(cs, irq)	Inicializa o controlador XPT2046.	TFT_display.initTouchSPI(7, 6);
readTouchRaw(x, y, z)	Lê os valores brutos do ADC usados para estabelecer a faixa de calibração.	TFT_display.readTouchRaw(x, y, z);
setTouchCalibration(minX,maxX,minY,maxY)	Armazena as quatro constantes de calibração para que getTouch() mapeie os valores brutos para coordenadas de pixel.	TFT_display.setTouchCalibration(200, 3800, 300, 3700);
setTouchInvertX(invert) / setTouchInvertY(invert)	Inverte o eixo de toque quando X ou Y está espelhado no seu painel ou lote específico. Chame ANTES de executar a calibração para que os valores armazenados correspondam ao seu painel.	TFT_display.setTouchInvertY(true);

Código Arduino Nano - SPI Personalizado

O exemplo CustomSPI demonstra como fornecer um ponteiro SPIClass explícito ao construtor do display. No Nano há um único barramento SPI por hardware (D11/D13/D12). Passar &SPI explicitamente permite controlar com precisão as configurações do SPI - por exemplo, reduzir a velocidade do clock ao usar fios longos até o display.

Acompanhe

Ligue o display TFT ao Nano como mostrado no diagrama de ligação.
Conecte o Nano ao seu computador com um cabo USB Mini-B.
Abra a Arduino IDE, escolha a placa e a porta, cole o código e clique em Upload.
O display inicia no barramento SPI configurado explicitamente e mostra um padrão de teste de barras de cores.

Visão Geral dos Métodos

Método	Explicação	Exemplo de Chamada
DIYables_ILI9341_SPI(w,h,cs,dc,rst,spi)	Construtor que recebe um ponteiro SPIClass explícito. Omita o último argumento para usar &SPI por padrão.	DIYables_ILI9341_SPI tft(240, 320, 10, 9, 8, &SPI);
begin()	Inicializa o display no barramento SPI configurado.	TFT_display.begin();

Solução de Problemas

Tela preta - Verifique CS (D10), DC (D8), MOSI (D11) e SCK (D13). Um pino CS flutuando é a causa mais comum.
Cores erradas ou pixels com lixo - Confirme que você descomentou o construtor do driver correto.
Estouro de SRAM - O Nano tem 2KB de SRAM. Armazene os bitmaps em PROGMEM usando a palavra-chave PROGMEM e o exemplo DrawImage.
O upload falha com "not in sync" - Tente selecionar ATmega328P (Old Bootloader) no menu Processor.

Plataformas Suportadas

A biblioteca usa apenas APIs padrão do Arduino (SPI, digitalWrite, millis) e funciona em todas as plataformas compatíveis com Arduino.

Tutoriais Relacionados

※ NOSSAS MENSAGENS

Fique à vontade para compartilhar o link deste tutorial. Porém, por favor, não use nosso conteúdo em outros sites. Investimos muito esforço e tempo para criar este conteúdo, por favor respeite nosso trabalho!