Neste projeto, projetaremos um aplicativo simples usando um LCD TFT de 3,5 polegadas que exibe diferentes tipos de gráficos e mensagens de texto com Arduino.
Os LCDs TFT são os displays coloridos mais populares – os displays em smartphones, tablets e laptops são, na verdade, apenas os LCDs TFT. Existem shields LCD TFT disponíveis para Arduino em uma variedade de tamanhos, como 1,44″, 1,8″, 2,0″, 2,4″ e 2,8″. O Arduino é uma máquina bastante humilde quando se trata de processar ou controlar gráficos. Afinal, é uma plataforma de microcontrolador, e os aplicativos gráficos geralmente exigem recursos de processamento muito maiores. Ainda assim, o Arduino é capaz o suficiente para controlar pequenas unidades de exibição. Os LCDs TFT são telas de exibição coloridas que podem hospedar belas interfaces de usuário.
A maioria dos escudos TFT LCD menores podem ser controlados usando a biblioteca Adafruit TFT LCD. Há também uma tela LCD TFT maior de 3,5 polegadas, com um driver ILI9486 de 8 bits.
Escudo de tela de toque LCD MCUFRIEND TFT
A biblioteca Adafruit não suporta o driver ILI9486. Na verdade, a biblioteca Adafruit é escrita para controlar apenas displays TFT menores que 3,5 polegadas. Para controlar a tela de toque TFT LCD de 3,5 polegadas, precisamos de outra biblioteca. Esta é a MCUFRIEND_kbv. A biblioteca MCUFRIEND_kbv é, de fato, ainda mais fácil de usar em comparação à biblioteca Adafruit TFT LCD. Esta biblioteca requer apenas a instanciação de um objeto TFT e nem mesmo requer a especificação de conexões de pinos.
A tela de toque TFT LCD de 3,5 polegadas é quase do tamanho do Arduino UNO e, no topo da placa Arduino, o escudo parece realmente glamoroso.
Escudo de tela sensível ao toque TFT LCD MCUFRIEND no Arduino UNO
O LCD TFT de 3,5 polegadas pode ser usado para uma série de aplicações como –
- Para exibir texto e fontes.
- Para exibir gráficos e figuras interativas.
- Para exibir imagens bitmap.
- Para exibir fotos e imagens coloridas RGB.
- Para usar como tela sensível ao toque.
- Para hospedar interfaces gráficas com entrada por toque.
- Para acessar assinaturas digitais.
- Para hospedar videogames com entrada por toque.
- Para hospedar aplicativos de entrada por toque, como Paint e Calculadora.
O que você precisa?
- Arduino UNO/Mega2560/Leonardo/Due/Zero/MO-Pro x1
- Escudo de tela sensível ao toque TFT LCD de 3,5 polegadas
LCDs TFT para Arduino
Interfaces de usuário são uma parte essencial de qualquer aplicativo embarcado. A interface de usuário permite qualquer interação com o usuário final e torna possível o uso final do dispositivo. As interfaces de usuário são hospedadas usando uma série de dispositivos como sete segmentos, LCDs de caracteres, LCDs gráficos e LCDs TFT coloridos. De todos esses dispositivos, apenas os displays TFT coloridos são capazes de hospedar interfaces sofisticadas. Uma interface de usuário sofisticada pode ter muitos campos de dados para exibir ou pode precisar hospedar menus e submenus ou hospedar gráficos interativos. Um LCD TFT é um LCD de matriz ativa capaz de hospedar imagens de alta qualidade.
Arduino opera em baixa frequência. É por isso que não é possível renderizar imagens ou vídeos em alta definição com o Arduino. No entanto, o Arduino pode controlar uma pequena tela TFT que renderiza dados e comandos graficamente enriquecidos. Ao fazer a interface de uma tela de toque LCD TFT com o Arduino, é possível renderizar gráficos interativos, menus, tabelas, gráficos e painéis de usuário.
Alguns dos populares LCDs TFT coloridos disponíveis para Arduino incluem tela de 3,5 ″ 480 × 320, tela de 2,8 ″ 400 × 200, tela de 2,4 ″ 320 × 240 e tela de 1,8 ″ 220 × 176. Uma tela TFT de tamanho e resolução apropriados pode ser selecionada de acordo com uma determinada aplicação.
Se a interface do usuário tiver apenas dados gráficos e comandos, as placas Arduino Atmega328 podem controlar o display. Se a interface do usuário for um programa grande que hospeda vários menus e/ou submenus, o Arduino Mega2560 deve ser preferido para controlar o display TFT. Se a interface do usuário precisar hospedar imagens e movimentos de alta resolução, placas Arduino ARM core como a DUE devem ser usadas para controlar o display TFT.
Biblioteca MCUFRIEND_kbv
A biblioteca Adafruit TFT LCD suporta apenas pequenos monitores TFT. Para telas TFT grandes, como LCDs TFT de 3,5 polegadas, 3,6 polegadas, 3,95 polegadas, incluindo LCDs TFT de 2,4 e 2,8 polegadas, a biblioteca MCUFRIEND_kbv é útil. Esta biblioteca foi projetada para controlar escudos LCD TFT de 28 pinos para Arduino UNO. Também funciona com Arduino Mega2560. Além de UNO e Mega2560, a biblioteca também suporta LEONARDO, DUE, ZERO e M0-PRO. Ele também funciona em NUCLEO-F103 e TEENSY3.2 com adaptador Sparkfun. Os escudos estilo Mcufriend tendem a ter uma TouchScreen resistiva em A1, 7, A2, 6, mas nem sempre estão na mesma direção de rotação. A biblioteca MCUFRIEND_kbv pode ser incluída em um esboço do Arduino no gerenciador de biblioteca.
Biblioteca de escudos de tela sensível ao toque TFT LCD MCUFRIEND
O esboço também precisará da biblioteca Adafruit_GFX para desenhar texto e gráficos no display TFT.
Biblioteca Adafruit GFX para pequenos LCDs TFT
Conexões de circuito
A blindagem LCD TFT de 3,5 polegadas precisa ser conectada à placa Arduino. Os escudos estilo Mcufriend são projetados para caber em todas as placas Arduino mencionadas acima. Os escudos possuem tela sensível ao toque TFT que pode exibir imagens e interfaces coloridas e um leitor de cartão micro SD para salvar imagens e outros dados. Uma tela de toque LCD TFT de 3,5 polegadas possui o seguinte diagrama de pinos.
Diagrama de pinos do escudo da tela de toque LCD MCUFRIEND TFT
Guia de programação
No esboço do Arduino, as seguintes bibliotecas precisam ser essencialmente incluídas.
#incluir “Adafruit_GFX.h”#incluir “MCUFRIEND_kbv.h”
As bibliotecas a seguir podem ser incluídas dependendo de seus requisitos no aplicativo.
#include “TouchScreen.h” // somente quando você quiser usar a tela sensível ao toque
#include “bitmap_mono.h” // quando você deseja exibir uma imagem bitmap da biblioteca
#include “bitmap_RGB.h” // quando você deseja exibir uma imagem bitmap da biblioteca
#include “Fonts/FreeSans9pt7b.h” // quando você quiser outras fontes
#include “Fonts/FreeSans12pt7b.h” // quando você quiser outras fontes
#include “Fonts/FreeSerif12pt7b.h” // quando você quiser outras fontes
#include “FreeDefaultFonts.h” // quando você quiser outras fontes
#include “SPI.h” // usando sdcard para exibir imagem bitmap
#incluir “SD.h”
Primeiramente, um objeto da classe MCUFRIEND_kbv precisa ser instanciado para fornecer comunicação SPI entre LCD e Arduino.
MCUFRIEND_kbv tft;
Para iniciar o LCD TFT, seu ID precisa ser lido e fornecido ao método Begin .
uint16_t ID = tft.readID ;
tft.begin(ID);
A resolução da tela TFT pode ser determinada usando o seguinte código.
largura_tela = tft.largura ; //int16_t largura(void);
Serial.print(“Largura da tela LCD TFT: “);
Serial.println(largura_da_tela); altura_da_tela = tft. altura ; //int16_t altura(void);
Serial.print(“Altura da tela LCD TFT: “);
Serial.println(altura_da_tela);
A cor da tela pode ser definida usando o método a seguir.
tft.fillScreen
Este método pode receber qualquer um dos seguintes argumentos.
#define PRETO 0x0000
#define MARINHA 0x000F
#define VERDE ESCURO 0x03E0
#define CIANO ESCURO 0x03EF
#define MARROM 0x7800
#define ROXO 0x780F
#define OLIVEIRA 0x7BE0
#define CINZA CLARO 0xC618
#define DARKGREY 0x7BEF
#define AZUL 0x001F
#define VERDE 0x07E0
#define CIANO 0x07FF
#define VERMELHO 0xF800
#define MAGENTA 0xF81F
#define AMARELO 0xFFE0
#define BRANCO 0xFFFF
#define LARANJA 0xFD20
#define VERDE AMARELO 0xAFE5
#define ROSA 0xF81F
O método a seguir é usado para definir a posição do cursor no LCD TFT.
tft.setCursor(x,y); //setCursor(int16_t x, int16_t y)
Os métodos a seguir são usados para definir a cor do texto.
tft.setTextColor
tft.setTextColor(t,b); //setTextColor(uint16_t t, uint16_t b)
O método a seguir é usado para definir o tamanho do texto.
tft.setTextSize(s); //setTextSize(uint8_t s)
Os métodos a seguir são usados para exibir texto no LCD TFT.
tft.write(c); //escrever(uint8_t c)
tft.println(“www.Electropeak.com”);
tft.print(“www.Electropeak.com”);
A função drawPixel preenche um pixel na localização xey pela cor t. A função readPixel lê a cor de um pixel na localização xey.
tft.drawPixel(x,y,t); //desenhaPixel(int16_t x, int16_t y, uint16_t t)
tft.readPixel(x,y); //uint16_t readPixel(int16_t x, int16_t y)
A função drawFastVLine desenha uma linha vertical que começa na localização x, y, e seu comprimento é h pixel e sua cor é t. A função drawFastHLine desenha uma linha horizontal que começa na localização xey, e o comprimento é w pixel e a cor é t. A função drawLine desenha uma linha que começa em xi e yi, locationends está em xj e yj, e a cor é t. Esses métodos desenham linhas com espessura de 5 pixels.
tft.desenharVLineFast(x,y,h,t);
//drawFastVLine(int16_t x, int16_t y, int16_t h, uint16_t t)tft.drawFastHLine(x,y,w,t);
//desenharLinhaFastHLine(int16_t x, int16_t y, int16_t w, uint16_t t)tft.desenharLinha(xi,yi,xj,yj,t);
//desenharLinha(int16_t x0, int16_t y0, int16_t x1, int16_t y1, uint16_t t)
A função fillRect desenha um retângulo preenchido nas localizações x e y. w é a largura, h é a altura e t é a cor do retângulo. A função drawRect desenha um retângulo nas localizações x e y com largura w, altura h e cor t. A função fillRoundRect desenha um retângulo preenchido com raios r cantos arredondados na localização xey e largura w e altura h e cor t. A função drawRoundRect desenha um retângulo com raio r cantos arredondados na localização xey e largura w e altura h e cor t.
tft.fillRect(x,y,w,h,t);
//fillRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t)tft.drawRect(x,y,w,h,t);
//drawRect(int16_t x, int16_t y, int16_t w, int16_t h, uint16_t t)tft.fillRoundRect(x,y,w,h,r,t);
//fillRoundRect (int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R , uint16_t t)tft.drawRoundRect(x,y,w,h,r,t);
//desenharRetânguloRedondo(int16_t x, int16_t y, int16_t w, int16_t h, uint8_t R , uint16_t t)
A função drawCircle desenha um círculo em x e y localização e r raio e t cor. A função fillCircle desenha um círculo preenchido em x e y localização e r raio e t cor.
tft.desenharCírculo(x,y,r,t);
//drawCircle(int16_t x, int16_t y, int16_t r, uint16_t t)tft.fillCircle(x,y,r,t);
//preencherCírculo(int16_t x, int16_t y, int16_t r, uint16_t t)
A função drawTriangle desenha um triângulo com três localizações de canto x, y, z e cores t. A função fillTriangle desenha um triângulo preenchido com três localizações de canto x, y, z e cores t.
tft.drawTriangle(x1,y1,x2,y2,x3,y3,t);
//desenhaTriângulo(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3,// uint16_t t)tft.preencherTriângulo(x1,y1,x2,y2,x3,y3,t);
//fillTriangle(int16_t x1, int16_t y1, int16_t x2, int16_t y2, int16_t x3, int16_t y3,// uint16_t t)
A função a seguir gira a tela em um determinado ângulo.
tft.setRotation(r); //defineRotação(uint8_t r)
A função a seguir inverte as cores da tela.
tft.invertDisplay(i); //invertDisplay(booleano i)
A função a seguir fornece o código RGB e obtém o código de cor UTFT.
tft.color565(r,g,b); //uint16_t cor565(uint8_t r, uint8_t g, uint8_t b)
A função seguinte rola a tela. O Maxroll é a altura máxima da sua rolagem.
for (uint16_t i = 0; i < maxscroll; i++) {
tft.vertScroll(0, maxscroll, i);
atraso(10);}
A função a seguir redefine a tela.
tft.reset ;
Esboço do Arduino
Como funciona o projeto
O código preenche um retângulo e, em seguida, desenha um retângulo dentro do qual o texto “EEWORLDONLINE” é exibido. Em seguida, linhas, círculos, retângulos e quadrados são desenhados na tela. O projeto termina com uma saudação e uma mensagem.
Resultados
Escudo de tela sensível ao toque TFT LCD MCUFRIEND com Arduino UNO
