Shield display LCD TFT 2.4″ Touchscreen – Descobrindo o drive
No desenvolvimento de qualquer tipo de projeto, é indispensável o uso de uma interface que permita ao usuário ver todo o funcionamento do sistema. Entretanto, essa não é uma tarefa fácil, principalmente quando dispomos de sistemas de baixo poder computacional, como é o caso dos microcontroladores tais como os Arduino. Sabendo disso, neste tutorial você aprenderá a utilizar o display TFT 2.4″ com touchscreen embutido em conjunto a uma Placa Arduino Uno e descobriremos como resolver o problema da tela branca, comum ao usar esse LCD. Com esse display podemos criar interfaces interativas e supervisionar dados em tempo real.
É interessante ressaltar que uma das maiores dificuldade na utilização desse tipo de LCD se dá em achar a biblioteca adequada. Isso porque existe diversos modelos semelhantes o que gera uma grande confusão na hora de botar ele para funcionar. Pensando nisso, nesse conteúdo usamos uma biblioteca que faz a leitura do controlador usado pelo Display e nos informa qual é o driver através do monitor serial. Em seguida usamos o número do controlador para configurar a Biblioteca.
[toc]
O Shield Display LCD TFT 2.4″ Touchscreen
O shield Lcd 2.4″ possui uma resolução de 240×320, além de possuir uma interface touchscreen resistiva por onde é possível interagir com a tela sem a necessidade de botões. A tela conta com um total de 13 pinos distribuídos entre alimentação, controle do touch e controle do display. Se você deseja adicionar sensores em conjunto com a tela, recomendo que utilize o Arduino Mega, pois ao acoplar o shield em um Arduino uno você não terá espaço nem pinos para conectar outros dispositivos.
Esse shield também possui uma interface para cartões SD em sua parte traseira. Tal interface é muito comum em LCDs coloridos, seu propósito é armazenar imagens prontas para serem exibidas no Display. Além disso, esse módulo SD pode ser usado para armazenar outras informações que seja úteis ao seu projeto.
Ao utilizar essa tela no Arduino uno, se certifique que a parte do conector USB do arduino NÃO esteja tocando no shield, caso contrário pode ocorrer um curto circuito capaz de danificar o shield ou até o Arduino.
Mãos à obra – Construindo um sistema de controle de acesso utilizando a shield LCD
O projeto é divido em duas partes, na primeira descobrimos qual o controlador do nosso LCD e em seguida configuramos a biblioteca para se adequar ao modelos de Display que temos em mão.
Componentes Utilizados:
- 1x Placa Arduino Uno REV3 – Você pode usar o Arduino Mega
- 1x Shield Lcd TFT 2.4″ Touchscreen
Montando o projeto
Para realizar a montagem em um Arduino uno não existe muito segredo, basta encaixar o módulo em seu Arduino sempre deixando um espaço entre o conector usb e a shield. Tenha cuidado para não amassar uma das pernas de seu shield.
Caso tudo esteja funcionando corretamente o display deverá acender como mostra o gif abaixo:
Instalando Biblioteca da Tela
A utilização destas telas nem sempre é uma tarefa fácil, isso ocorre devido a grande quantidade de controladores disponíveis no mercado para este tipo de tela. Sabendo disso, neste tutorial iremos utilizar uma biblioteca que abrange uma grande quantidade de controladores, no caso a MCUFRIEND. A instalação da biblioteca pode ser feita de maneira bem simples, bastando seguir os seguintes passos:
- Clique em Sketch e vá até a opção Incluir Biblioteca como mostra a figura abaixo:
- Logo em seguida selecione a opção Gerenciar Bibliotecas, uma nova tela será aberta onde você pode gerenciar todas as bibliotecas disponíveis no repositório.
- Por fim, para instalar a biblioteca, basta digitar MCUF RIEND_kbv na barra de pesquisa e instalar a opção da imagem.
Ao fim do processo de instalação, reinicie a IDE do Arduino para diminuir a possibilidade de problemas de compatibilidade.
Descobrindo o Driver do Display LCD TFT 2.4″
Agora que temos a nossa biblioteca instalada, iremos testar se da forma como ela está já conseguimos renderizar informações na tela. Para isso execute o seguinte código:
#include <MCUFRIEND_kbv.h>
MCUFRIEND_kbv tft;
#define VERDE 0x07E0
#define BRANCO 0xFFFF
void setup() {
Serial.begin(9600);
uint16_t ID = tft.readID();
Serial.print("Identificador do display: ");
Serial.println(ID,HEX);
tft.begin(ID);
tft.setRotation(1);
tft.fillScreen(BRANCO);
tft.setCursor(20,100);
tft.setTextColor(VERDE);
tft.setTextSize(3);
tft.print("It's Alive !!!");
}
void loop() {
}
O código acima realiza uma leitura do registrador responsável por armazenar o código do circuito integrado que controla a tela através da função readID(). Com este código, a biblioteca sabe quais os registradores utilizados para entrada e saída de dados, podendo assim estabelecer uma comunicação com o display que é feita através da função begin(ID). Além de fazer isso, no monitor serial e escreve a mensagem “It’s Alive” em verde caso o código esteja funcionando corretamente.
Se tudo estiver ok, você verá a seguinte mensagem escrita em seu display:
Dessa forma, o nosso controlador é o driver LGPD4532.
Consertando bug da tela branca – Configurando a biblioteca para o nosso controlador
Caso a tela simplesmente continue branca, será necessário realizar uma modificação na biblioteca MCUFRIEND. Para isso você deve ir até a pasta onde a biblioteca está instalada:
- Windows: C:\Program Files (x86)\Arduino\libraries
- Linux: /home/Usuario/Arduino/libraries
Após encontrar a localização da biblioteca instalada, selecione a pasta MCUFRIEND_kbv e abra o arquivo MCUFRIEND_kbv.cpp com o seu editor de textos favorito
A biblioteca MCUFRIEND possui praticamente todos os controladores disponíveis para esse display, porém algumas são desabilitadas devido a pequena quantidade de memória disponível. Sabendo disso, iremos através dessa modificação habilitar este controlador. Para fazer isso, iremos precisar do identificador do controlador do display, que pode ser obtido através do código de teste apresentado logo acima. Neste exemplo estou utilizando o controlador 4532, então devemos habilitar o suporte a este controlador
Na linha correspondente ao controlador que foi mostrado no código de testes, basta “descomentar” a linha do controlador desejado.
Antes de realizar qualquer modificação em uma biblioteca, é altamente recomendado que se faça backup da versão anterior para que caso ocorre algum problema seja possível retornar ao estado anterior.
Logo após realizar as modificações, salve o arquivo e reinicie a IDE do Arduino. Se tudo tiver sido feito corretamente a mensagem It’s Alive irá aparecer na sua tela quando você fizer o upload do código novamente.
Programando
Agora que temos a biblioteca funcionando corretamente, iremos construir a interface do nosso controle de acesso. O código abaixo é responsável por renderizar todos os botões que iremos utilizar em nosso sistema.
#include "Adafruit_GFX.h" // Biblioteca Gráfica Adafruit
#include <MCUFRIEND_kbv.h> // Bibllioteca para controle do lcd
// Cores que iremos utilizar em nosso projeto
#define PRETO 0x0000
#define VERMELHO 0xF800
#define VERDE 0x07E0
#define BRANCO 0xFFFF
//---------------------------------------------//
MCUFRIEND_kbv tft; // Objeto de comunicação com display
void setup() {
uint16_t ID = tft.readID(); // Leitura do código de identificação do controlador
tft.begin(ID); // Inicialização da tela
telaInicial(); // Chamada da função responsável por renderizar o nosso painel de acesso
}
void telaInicial(){
tft.setRotation(1); // Display é rotacionado para modo paisagem
tft.fillScreen(BRANCO); // Tela é preenchida pela cor Branca
escreveTexto(50,0,"Controle de Acesso",2,PRETO); // Texto é escrito na posição (50,0)
criarBotao(60,50,200,30,"",PRETO); // Criamos uma pequena caixa onde será mostrada a senha digitada
criarBotao(50,100,30,30,"1",VERMELHO); // Criação do botão 1 do sistema
criarBotao(100,100,30,30,"2",VERMELHO); // Criação do botão 2 do sistema
criarBotao(150,100,30,30,"3",VERMELHO); // Criação do botão 3 do sistema
criarBotao(200,100,30,30,"4",VERMELHO); // Criação do botão 4 do sistema
criarBotao(250,100,30,30,"5",VERMELHO); // Criação do botão 5 do sistema
criarBotao(50,150,30,30,"6",VERMELHO); // Criação do botão 6 do sistema
criarBotao(100,150,30,30,"7",VERMELHO); // Criação do botão 7 do sistema
criarBotao(150,150,30,30,"8",VERMELHO); // Criação do botão 8 do sistema
criarBotao(200,150,30,30,"9",VERMELHO); // Criação do botão 9 do sistema
criarBotao(250,150,30,30,"0",VERMELHO); // Criação do botão 0 do sistema
criarBotao(50,200,120,30,"Apagar",VERMELHO); // Criação do botão Apagar
criarBotao(180,200,100,30,"Logar",VERMELHO); // Criação do botão Logar
}
void telaAcesso(bool acesso){ // Função que controla o acesso ao sistema
if (acesso){ // Se o acesso for permitido
tft.fillScreen(PRETO); // Tela é preenchida pela cor preta
tft.setCursor(10,100); // Cursor é deslocado para pixel de posição (10,100)
tft.setTextColor(VERDE); // Cor do texto é alterada para verde
tft.setTextSize(3); // Tamanho da fonte do texto é alterada para o tamanho 3 ( Grande )
tft.print("Acesso Autorizado"); // Texto é escrito em verde com mensagem Acesso Autorizado
delay(3000); // Sistema aguarda 3 segundos
telaInicial(); // Tela de acesso inicial é renderizada
}
else{ // Caso contrário
tft.fillScreen(PRETO); // Tela é preenchida pela cor preta
tft.setCursor(40,100); // Cursor é deslocado para pixel de posição (40,100)
tft.setTextColor(VERMELHO); // Cor do texto é alterada para vermelho
tft.setTextSize(3); // Tamanho da fonte do texto é alterada para o tamanho 3 ( Grande )
tft.print("Acesso Negado"); // Texto é escrito em vermelho com mensagem Acesso Negado
delay(3000); // Sistema aguarda 3 segundos
telaInicial(); // Tela de acesso inicial é renderizada
}
}
void escreveTexto(int posx,int posy, String texto,int tamanho,int cor){ // Função criada para facilitar escrita de texto
tft.setCursor(posx,posy); // Cursor é deslocado para posição passada como parâmetro
tft.setTextColor(cor); // Cor a ser escrita é alterada conforme valor recebido como parâmetro
tft.setTextSize(tamanho); // Tamanho da fonte é alterado conforme parâmetro recebido
tft.print(texto); // Texto passado por parâmetro é escrito na tela
}
void criarBotao(int posx,int posy, int largura, int altura,String texto,int cor) //
{
//Create Red Button
tft.fillRect(posx,posy, largura, altura, cor); // um quadrado começando em (posx,posy) é renderizado conforme parâmetros passados
tft.drawRect(posx,posy, largura, altura,PRETO); // um quadrado de cor preta é desenhado ao redor do quadrado vermelho
tft.setCursor(posx+8,posy+4); // Cursor é deslocado para o pixel de posição (posx+8,posy+4)
tft.setTextColor(BRANCO); // Cor do texto é alterada para Branco
tft.setTextSize(3); // Fonte é alterada para tamanho 3
tft.print(texto); // Texto é escrito em posição determinada
}
void loop() { // Cada uma das três telas que compõem o sistema é chamada a cada dois segundos
telaInicial();
delay(2000);
telaAcesso(true);
delay(2000);
telaAcesso(false);
delay(2000);
}
Colocando pra funcionar
Entendendo a Fundo
Software
– Incluindo bibliotecas a serem adicionadas ao projeto
Inicialmente podemos observar que necessitamos adicionar penas duas bibliotecas ao nosso projeto. A biblioteca Adafruit_GFX fornece uma série de funções que permitem o desenho de figuras geométricas de forma transparente. Já a biblioteca MCUFRIEND_kbv fornece o objeto com o qual iremos nos comunicar com o display.
#include "Adafruit_GFX.h" // biblioteca com funções Gráficas #include <MCUFRIEND_kbv.h> // biblioteca de acesso e comunicação com display
– Declarando objeto de comunicação com display
Para estabelecer uma comunicação com o nosso display, iremos criar um objeto de nome tft que ficará responsável por renderizar toda a informação que for requisitada pelo código.
MCUFRIEND_kbv tft; // Objeto de comunicação com a tela
O nome do objeto não precisa ser necessariamente tft, você pode nomear o objeto com o nome que preferir.
– Paleta de cores utilizada
Neste exemplo iremos utilizar um total de 4 cores, para desenhar botões e telas de acesso. Para facilitar o trabalho de digitar o código da cor utilizada, criaremos 4 defines contendo as cores utilizadas e seu respectivo código RGB.
#define PRETO 0x0000 #define VERMELHO 0xF800 #define VERDE 0x07E0 #define BRANCO 0xFFFF
– Função desenha botão
Para facilitar o processo de desenhar botões na tela, foi elaborada uma função que dada a posição inicial, dimensões, texto e cor um retângulo representando um botão é desenhado na tela. Seu funcionamento segue a seguinte lógica:
void criarBotao(int posx,int posy, int largura, int altura,String texto,int cor)
{
tft.fillRect(posx,posy, largura, altura, cor); // Cria um quadrado com inicio na posição (posx,posy) com altura e largura definidas na função
tft.drawRect(posx,posy, largura, altura,PRETO); // Cria uma borda ao redor do quadrado desenhado anteriormente
tft.setCursor(posx+8,posy+4); // Cursor de escrita é deslocado para centro do quadrado desenhado
tft.setTextColor(BRANCO); // Cor do texto é alterada para branco
tft.setTextSize(3); // Tamanho do texto é alterado para tamanho 3
tft.print(texto); // Texto é escrito na posição central da caixa desenhada
}
– Tft.fillRect()
Esse método recebe como parâmetros a posição inicial onde o quadrado deve começar, sua largura, altura e cor. Com todos esses dados o método irá renderizar na tela um quadrado da seguinte forma:
– Tft.drawRect
O método drawRect por sua vez, com base nos mesmos parâmetros irá criar uma borda sobre o quadrado que foi renderizado anteriormente
– Escrevendo texto
O processo para escrever informações na tela segue o seguinte fluxo:
- Primeiro através da função setCursor() iremos selecionar a posição onde o nosso texto começará a ser Escrito
- Logo em seguida configuramos a cor da fonte e seu tamanho através dos métodos setTextColor() e setTextSize().
- Por fim escrevemos o texto desejado através do método print()
– Função escreveTexto
Como foi possível observar na etapa onde escrevemos o texto dentro do retângulo, uma grande quantidade de comandos é necessária até que se escreva o texto em si. Para reduzir a quantidade de código escrita foi também criada uma função que já encapsula todo esse processo. Seu uso consiste em basicamente fornecer o ponto de inicio do texto, o texto a ser escrito, seu tamanho, e a cor do texto.
void escreveTexto(int posx,int posy, String texto,int tamanho,int cor){
tft.setCursor(posx,posy); // Move cursor para posição inicial onde o texto será escrito
tft.setTextColor(cor); // Muda a cor do texto
tft.setTextSize(tamanho); // Altera o tamanho da fonte
tft.print(texto); // Escreve texto na tela
}
– Função setup
dentro da nossa função setup iremos basicamente inicializar a nossa tela seguindo o seguinte fluxo
- Lemos o código de identificação do display através do método readID()
uint16_t ID = tft.readID();
- Inicializamos o nosso display através do método begin()
tft.begin(ID);
-
Mudamos o layout da tela para o modo paisagem através do método setRotation(1)
tft.setRotation(1);
- Por fim chamamos a função telaInicial() que irá renderizar na tela nosso painel de acesso
telaInicial();
– Função telaInicial
A função tela inicial tem como função básica renderizar todos os botões e o campo de texto que será responsável por mostrar a senha digitada. Para isso a função executa os seguintes passos:
- Mudamos a tela para o modo paisagem através do método setRotation(1)
tft.setRotation(1);
- Toda a tela é preenchida pela cor branca através do método fillScreen(BRANCO)
tft.fillScreen(BRANCO);
- Utilizando a função escreveTexto iremos escrever o texto: “Controle de acesso” na cor preta na parte superior da tela
escreveTexto(50,0,"Controle de Acesso",2,PRETO);
- Logo em seguida criamos uma caixa onde a senha digitada será armazenada conforme os botões forem clicados.
criarBotao(60,50,200,30,"",PRETO);
- Sequencialmente, criamos todos os 10 botões que serão utilizados para que o usuário digite a senha para acesso ao sistema. Isso é feito através do método criarBotao(), onda cada botão será desenhado na tela com uma distância de 50 pixels entre um e outro.
criarBotao(50,100,30,30,"1",VERMELHO); criarBotao(100,100,30,30,"2",VERMELHO); criarBotao(150,100,30,30,"3",VERMELHO); criarBotao(200,100,30,30,"4",VERMELHO); criarBotao(250,100,30,30,"5",VERMELHO); criarBotao(50,150,30,30,"6",VERMELHO); criarBotao(100,150,30,30,"7",VERMELHO); criarBotao(150,150,30,30,"8",VERMELHO); criarBotao(200,150,30,30,"9",VERMELHO); criarBotao(250,150,30,30,"0",VERMELHO);
- Por fim, criamos os dois botões responsáveis por apagar caracteres digitados incorretamente, e o botão responsável por validar a senha digitada.
criarBotao(50,200,120,30,"Apagar",VERMELHO); criarBotao(180,200,100,30,"Logar",VERMELHO);
– Função telaAcesso(bool autorizacao)
Agora que temos a nossa tela de controle de acesso criada, iremos precisar criar mais duas telas, uma para quando o acesso for permitido e outra para quando o acesso for negado. Para encapsular todo esse processo e deixa-lo mais transparente, foi criada uma função denominada telaAcesso que funciona da seguinte forma:
- Caso o argumento recebido seja verdadeiro significa que o acesso foi autorizado, então
- A Tela é preenchida pela cor preta através do método fillScreen()
tft.fillScreen(PRETO);
- O cursor é deslocado para o pixel de posição (10,100)
tft.setCursor(10,100);
- A cor do texto é alterada para verde
tft.setTextColor(VERDE);
- O tamanho da fonte do texto é alterada para o tamanho 3
tft.setTextSize(3);
- O texto acesso autorizado é escrito na tela
tft.print("Acesso Autorizado");
- Após 3 segundos o sistema volta para a tela inicial
- A Tela é preenchida pela cor preta através do método fillScreen()
- Caso contrário uma mensagem de acesso negado será escrita em vermelho na tela
– Função Loop()
A função loop por sua vez apenas alterna entre as três telas criadas em nosso sistema sendo cada uma das telas chamadas a cada dois segundos.
void loop() { // Cada uma das três telas que compõem o sistema é chamada a cada dois segundos
telaInicial();
delay(2000);
telaAcesso(true);
delay(2000);
telaAcesso(false);
delay(2000);
}
Desafio
Agora que você sabe como construir uma tela para controle de acesso, tente alterar as cores da paleta de cores, para cores que sejam do seu agrado. Adicione também novos botões ao sistema para que ele possa ter uma maior quantidade de combinações possíveis.
Considerações Finais
Este tutorial teve como objetivo ensinar uma forma de elaborar interfaces utilizando a shield display TfT. Além disso foi possível também aprender a como resolver um problema bastante recorrente neste display devido a grande diversidade de controladores utilizados. Este tutorial foi dividido em duas partes devido a complexidade dos passos apresentados, então aguardem que logo logo iremos adicionar a parte touch ao projeto. Espero que tenham gostado do conteúdo apresentado, sinta-se à vontade para nos dar sugestões, críticas ou elogios. Lembre-se de deixar suas dúvidas nos comentários abaixo.
Olá, tudo bem? Parabéns pelo artigo.
Poderia me ajudar se tem que fazer um código para o funcionamento no arduino mega? Pois fiz o teste no arduino uno e ficou igual ao seu. Já no arduino mega, a tela fico toda embaralhada e não plota nada coerente.
Boa noite excelente conteudo. eu utilizei num mega o programa funciona mas as cores não correspondem ao código hexa , alguem passou pelo mesmo
um olá a todos !
alguem conhece esse chip sm245ts display 2.4 pra arquino ?
Bom dia, o código funcionou muito bem no meu arduino UNO, mas não consigo ligar no MEGA, quais os possíveis erros? a biblioteca precisa de alteração?
Quais as conexões devo fazer no arduino mega?
Aguardando resposta, por gentileza!
Oi Danilo
A biblioteca MCUFRIEND suporta telas breakout?
Se sim, como seria as conexões, já que este não existe os pinos WR e RD, por exemplo?
Obrigado
Boa noite
Estou tendo problema abaixei na biblioteca mas não aparece no libraries o arquivo minha tela não comunica de jeito nenhum fica somente na tela branca algum por favor poderia me ajudar.
Boa noite alguém poderia me ajudar eu tenho já um programa para esse touch de 4 interruptores peguei aqui mesmo na internet eu queria que funciona-se da seguinte forma, eu tenho os pinos saída 10,11,12,13 como eu gostaria de transforma-la como entrada que quando acionadas envia o sinal para o touch me avisando que recebeu um sinal nos pinos 10,11,12,13 na tela sairá descrito a função que foi acionada. Se alguém precisar eu tenho o programa ele é bastante funcional meu sap 19-98992-4518 radiogoodtime@hotmail.com se alguém puder me ajudar na questão acima eu fico muito agradecido ….
MUITO BOM. EXCELENTE TUTORIAL. AJUDOU MUITO. OBRIGADO!!!
ESTOU CORRENDO ATRÁS DE AJUDA PARA COLOCAR FIGURAS JPEG NO DISPLAY, SE TIVER ALGO QUE POSSA INDICAR AGRADEÇO MAIS.
Boa tarde. O display tem alguma função semelhante ao Blink() / NoBlink() para mostrar o posicionamento do cursor piscando?
Nativamente não Marcelo, porém é possível implementar algo com alguma figura geométrica
// #include ; // biblioteca para o display TFT 2.4 LCD da MCUfriends de conector preto
Boa Noite Danilo, Bom artigo, Fiz um voltimetro e depois um termômetro utilizando o Arduino UNO com este display, quem quiser tentar pode usar o pino ANALOG 5, que está vago e não é utilizado pelo circuito do Display. No Termometro utilizei o LM 35 com sensor e ficou muito bom, para o Voltímetro usei também o mesmo pino.
Sobre o MCUFriends ..eu uso :
#include ; // biblioteca para o display TFT 2.4 LCD da MCUfriends de conector preto
–
–
// e depois uso :
// CS, CD, WR, RD, RESET
Adafruit_TFTLCD tft(A3, A2, A1, A0, A4);
SWTFT tft; // necessário para iniciar display TFT 2.4 da MCU Friends
// espero que ajude …
Retificando a bibiloteca no comentario acima:
#include ; // biblioteca para o display TFT 2.4 LCD da MCUfriends de conector preto
// CS, CD, WR, RD, RESET
Adafruit_TFTLCD tft(A3, A2, A1, A0, A4);
SWTFT tft; // necessário para iniciar display TFT 2.4 da MCU Friends
Finalizando a questão dos LCD’s que retornam uma leitura de ID = 0x9797… Descobri que já existe uma versão ainda mais atualizada da biblioteca MCUFRIEND_kbv (na qual não é mais necessário fixar manualmente o “tft.begin(0x1289) no corpo do código, mas apenas habilitar a linha do #define SUPPORT_1289”, conforme explicado no tutorial)… Ela se encontra disponível para download no site GitHub no link “https://github.com/prenticedavid/MCUFRIEND_kbv/archive/master.zip”.
Finalmente consegui rodar o seu programa de exemplo, mas para isso foi preciso excluir a linha “uint16_t ID = tft.readID();” e alterar a linha “tft.begin(ID);” para fazer constar nela diretamente o ID necessário da seguinte forma “tft.begin(0x1289)”… E para fazer as cores funcionarem corretamente precisei baixar da internet uma versão adaptada da biblioteca MCUFRIEND, na qual o autor fez modificações para o chip operar em 18 bits e não 16 bits como o padrão.
Como possivelmente mais pessoas acessarão essa página buscando informações para o misterioso funcionamento TFT que tem um driver que quando lido retorna “0x9797”, deixarei os links do fórum onde encontrei as explicações sobre o “problema” a biblioteca para download:
https://forum.arduino.cc/index.php?topic=567506.30
https://github.com/prenticedavid/MCUFRIEND_kbv/issues/64
https://github.com/prenticedavid/MCUFRIEND_kbv/files/2511227/MCUFRIEND_kbv.zip
OBSERVAÇÕES: Primeiro baixe a biblioteca MCUFRIEND tradicional por meio da própria IDE do Arduino, depois baixe o arquivo adaptado MCUFRIEND.zip disponível no link acima, descompacte-o e cole os dois arquivos resultantes dentro da pasta da biblioteca MCEUFRIEND lá do Arduino.
Boa noite, Danilo! Comprei um display desses e rodei o código para identificação do registrador, mas o resultado no monitor seruas foi “9797” que não existe na biblioteca mcufrind! Pesquisei em um forum gringo e cheguei a conclusão que “9797” poderia indicar o controlador SSD1289… Então habilitei na mcufrind a linha do #define 1289 e no programa de exemplo de teste da biblioteca forcei o tft.begin com o id 0x1289 e o display rodou o exemplo de teste!!! Mas com as cores erradas e os demais exemplos da biblioteca não consegui fazer rodar mais nenhum. Alguma dica sobre esse problema das cores? Ou sobre o fato de não existir “9797” na mcufrind?
muito legal, parabéns pela explicação, excelente. To procurando sobre o touch… to tendo uns problemas com essa parte, nos exemplos do adafruit não estão dando certo, só recebo a msg (BROKEN TOUCH).
Olá Wagner, fico feliz que a explicação tenha te ajudado. Fiz um tutorial sobre o touch também: https://portal.vidadesilicio.com.br/display-lcd-tft-2-4-primeiros-passos-com-touchscreen/
E completando minha duvida, observei que em códigos que utilizam as definicoes para LCD:
#include
#include
#define BRANCO 0xFFFF
#define PRETO 0x0000
# define LCD_CS A3
# define LCD_CD A2
# define LCD_WR A1
# define LCD_RD A0
# define LCD_RESET A4
Adafruit_TFTLCD tft ( LCD_CS , LCD_CD , LCD_WR , LCD_RD , LCD_RESET ) ;
void setup ( ) {
Serial.begin( 9600 ) ;
Serial.print( ” Iniciando … ” ) ;
tft.reset();
uint16_t ID = tft.readID();
tft.begin(ID);
tft.setRotation( 1 ) ;
tft.fillScreen(PRETO);
tft.setCursor( 100 , 30 ) ;
tft.setTextColor( BRANCO) ;
tft.setTextSize( 4 ) ;
tft.print(” Hello” ) ;
}
Nao inicializa meu TFT, ficando com a tela branca.
Já se eu utilizar:
#include “Adafruit_GFX.h” // Biblioteca Gráfica Adafruit
#include
MCUFRIEND_kbv tft;
void setup ( ) {
tft.reset();
uint16_t ID = tft.readID();
Serial.print(“Identificador do display: “);
Serial.println(ID,HEX);
tft.begin(ID);
tft.fillScreen(PRETO);
tft.setCursor( 100 , 30 ) ;
tft.setTextColor( BRANCO) ;
tft.setTextSize( 4 ) ;
tft.print(” Hello” )
}
Funciona normalmente.
Nao estou conseguindo entender o motivo.
Cara, excelente conteúdo. Sem estas informações fica praticamente impossível um iniciante desenvolver algum projeto com este tipo de display TFT. Eu tenho 3 aqui parados a 5 meses, por nao ter ainda encontrado um conteúdo que explicasse de forma tao clara. Os que até entao havia encontrado, simplesmente copiavam bibliotecas e códigos e jogavam para dentro do Arduino, sem explanação detalhada de nada..Obvio que há telas onde é possível utilizar softwares, que facilitam o trabalho, onde você arrasta os objetos para uma tela fictícia e lá atribui aos objetos, como botoes, bargrafics, sinaleiros as devidas funções, como é o caso do display Nextion TFT HMI, O dificil para o iniciante é entender a base inicial de tudo. Com estas dicas já da para começar a pensar melhor em outros projetos.
Envie-nos a part touch.
Obrigado por divulgar conhecimentos
Fico feliz que este tutorial tenha lhe agregado conhecimento Belmiro, a parte touch já se encontra no blog que pode ser acessado através deste link https://portal.vidadesilicio.com.br/display-lcd-tft-2-4-primeiros-passos-com-touchscreen/
Ah sim Danilo, obrigado. Vou estudar a parte touch.
Danilo sou iniciante em programacao e neste TFT também. Me responde uma coisa, alguns programadores definem os pinos das conexoes do TFT, como no exemplo:
int const LCD_CS = A3; // Chip Select – Pin analogico 3
int const LCD_CD = A2; // Command/Data – Pin Analogico 2 CD É O RS?
int const LCD_WR = A1; // LCD Write – Pin Analogico 1
int const LCD_RD = A0; // LCD Read – Pin Analogico 0
int const LCD_RESET = A4; // LCD Reset – Pin Analogico 4
e inicializam o TFT:
uint16_t ID = objetoTFT.readID();
objetoTFT.begin(ID);
outro detalhe é que ainda surge a linha
Adafruit_TFTLCD objetoTFT (LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET); mas já foi definido nos int const.
outro exemplo também usa: MCUFRIEND_kbv tft; // Objeto de comunicação com display
Ficou um pouco confuso.
No seu exemplo você nao define os pinos de conexão, qual a diferença? Pois ambos os programas funcionam.
Parabéns pelo tutorial e muito obrigado pela generosidade!
Por nada Luis, fico feliz que o tutorial tenha lhe ajudado de alguma forma :D
Muito bom o conteúdo do tutorial. Me ajudo pastante a entender a logica e bibliotecas utilizadas para trabalhar com a TFT LCD. Quando que vai sair o tutorial do Touch? Ansioso!!!
Fico feliz que o tutorial tenha lhe Ajudado Michael. Creio que o tutorial sai até no máximo semana que vem :D
CARAAAAAAAAACA Incrível esse Tutorial!
Danilo, pqp, incrível cara!
Obrigado por disponibilizar um conteúdo tão bem explicado.
Sensacional!
Obrigado mais uma vez!
Fico feliz que este tutorial tenha te Ajudado Matheus :D
Caro Danilo, boa noite. Seu post me ajudou muito, já estava desesperado com um LCD TFT ILI 9486 que só dava tela branca. Depois que entrei aqui e consegui o “Its alive!” foi um alívio. Obrigado! No entanto, um TFT HX8347i 2.8 teima em ficar com a tela branca. Tentei este procedimento e não consegui. Você teria alguma dica?
Opa, fico feliz que tenha conseguido resolver o problema com o ili9486 Valfredo. Dei uma pesquisa nesse display que você disse porém não achei nenhuma informação a respeito dele, e sem um datasheet fica complicado descobrir os registradores que ele utiliza para comunicação :/
Danilo, seu tutorial é incrivel! Estou precisando urgente aprender a ativar o touchscreen para um trabalho da faculdade, ajuda a gente! haha muito obrigada mesmo!
Há quando você pode para descomentar nos aquivos da biblioteca não tem a opção desse driver que no caso o que esta aparecendo na minha placa. No caso o driver “C5B2 “.
Nesse link tem as fotos do shield
http://www.piauino.com.br/pd-4f22ed-lcd-2-4-tela-display-shield-tft-touch-screen.html?ct=191075&p=1&s=1
Boa tarde Danilo quando uso o código que vc disponibiliza para descobrir o driver o valor que aparece é esse C5B2.
Boa noite Danilo muito legal esse projeto. Eu usei seu tutorial mais a biblioteca não funciona quando carrega o skect. a tela fica so branca. o driver ate da pra ver no meu caso é C5B2. Na biblioteca nao tem essa opção de driver sera se não funcionou devido a isso.
Olá Henio, envie mais informações a respeito. Se possível mande imagens do display e do código que aparece quando você carrega o código de descoberta de driver. Abraços
Quando é esse logo para a segunda parte? kkkk Estou ansioso pra aprender.
hehehe, logo logo eu posto ele. É um tutorial que vai ficar um pouco extenso pois precisamos passar pelo processo de calibração da tela também
Gostei muito do seu tutorial, pois normalmente colocam tutoriais mas não explicam como funciona, achando que todos nós somos expert em arduino e principalmente em dsplays. Valeu pela sua boa vontade de nos ajudar e pelo tutorial também. Abraço.
Fico feliz que o tutorial tenha lhe Ajudado Donizeti :D
Excelente! Salvou minha shield LCD de ir para o lixo, que só apresentava tela branca, rssss…
Aguardo ansioso a parte touch ao projeto.
Olá Danilo, Parabéns pelo artigo.
Para desenhar esse menu você utilizou algum programa para poder saber a posição dos itens? Por exemplo algum programa no qual você desenha os menus e descobre a posição do pixel para escrever no programa.
Na verdade fiz na mão Haroldo, porém é uma ótima ideia fazer um gerador de interfaces pra essa tela
Boa noite. Excelente artigo. Gostaria de saber quando sai o artigo sobre a parte touch?
Obrigado!
Fico feliz que tenha curtido Thyago. Em breve estarei liberando a segunda parte dele :)