Lilygo T-Display ESP32 S3 - Display não mostra nada

Ola,

Acabei de receber uma unidade do Lilygo T-Display ESP32 S3 que comprei no Aliexpress.

Estou usando o Arduino IDE 2.00, atualizei a biblioteca de acordo com a recomendação do fabricante e de alguns makers no youtube.

Estou tentando rodar um código de um youtuber famoso ( https://www.youtube.com/watch?v=j8THAc1sMww ).

O Arduino IDE compila e faz o upload do código na placa. Não há aviso de erro algum, porém o Display permanece apagado.

Alguém aqui com experiência nessa placa, ou alguma idéia de como resolver?

Exibições: 652

Responder esta

Respostas a este tópico

Bom dia,

Nunca usei este display.Qual biblioteca vc está usando? Link.

Veja se nela tem exemplos básicos de uso do display, e tente o mais simples para

ver se o display funciona corretamente.

Participo do fórum arduino.forum  e lá tenho lido muitos problemas com esta versão 2.0 da IDE.

Já tentou remove-la e instalar a 1.8.19?

RV mineirin

Oi, consegui fazer funcionar!

Tem um maker fantástico que está fazendo vários projetos com este display. Aqui o link do vídeo dele:

https://www.youtube.com/watch?v=gpyeMjM9cOU&t=338s

Eu desinstalei o Arduino IDE 2.00 e instalei o mesmo que o Volos usou V1.8.12, do zero e segui passo a passo o video dele.

Funcionou!  Display espetacular! 

Vou me inscrever nesse forum do arduino! Muito obrigado!!

Pergunta: qual a versão mais estável antes desta 2.00? Seria a 1.8.19?

Bom dia.

Sim, 1.8.19

RV mineirin

Funcionou também com a V 1.8.19!

Muito obrigado! Boa sorte a todos, excelente placa!

Como funcionou com a versão 1.8.19 e não funcionou com a versão 2.0,

sugiro que se você se cadastrar no  fórum do arduino, reporte lá a sua experiência

com este produto e com as 2 versões.

Isto ajudará os desenvolvedores da versão 2.0 a procurar e corrigir bugs.

https://forum.arduino.cc/c/software/arduino-ide-2-0/93

RV mineirin

Obrigado, vou fazer isso!

Boa tarde.

Vi lá no fórum o seu tópico.  Legal 

O pessoal do time do arduino está solicitando uns procedimento para identificar o problema.

O Sr. já viu lá o pedido deles?

RV mineirin

Vou lá agora! Obrigado!

Ola, 

Eles analisaram o problema, parece que a biblioteca TFT_eSPI  V. 2.4.72 não funciona com esta placa.

A recomendação é copiar e colar a biblioteca TFT_eSPI V.2.4.71, que funciona, sobre os arquivos da V.2.4.72, mudar a placa para outra qualquer, pedir para "Verificar/Compilar" (isso faz com que o cache do IDE seja preenchido com os dados da V2.4.71), mudar para a placa T-Display e na sequencia fazer upload.

Feito isso,  A V.2.0.0. começa a funcionar!

Para mais detalhes: 

https://forum.arduino.cc/t/arduino-ide-2-00-and-lilygo-t-display-es...

Amigos, o bom filho à casa torna!

Estou programando pela primeira vez uma LilyGo com processador RP2040 e display 1,4 polegadas, mas não consigo programar o display!

Testei vários códigos e bibliotecas, como TFT_eSPI, Adafruit GFX e Adafruit_ST7789, tomando o cuidado de configurar corretamente os pinos.

Seguindo as instruções deste tópico, também testei diferentes versões da IDE Arduino, e até das bibliotecas, mas o resultado é sempre o mesmo:

O código carrega, o led da porta 25 pisca normalmente, e a saida serial da IDE Arduino imprime "Ligado" e "Desligado", mas o display não dá sinal de vida.

A placa é novinha e funciona perfeitamente com as configurações de fábrica, mas não consigo fazer o display funcionar com meus códigos, e nem os códigos de exemplos de nenhuma dessas bibliotecas.

Alguém tem idéia do que pode estar errado?

/*
| Pins | RP2040 |
| ---------- | --------------- |
| TFT Driver | ST7789(240*135) |
| TFT_MISO | N/A |
| TFT_MOSI | 3 |
| TFT_SCLK | 2 |
| TFT_CS | 5 |
| TFT_DC | 1 |
| TFT_RST | 0 |
| TFT_BL | 4 |
| PWR_ON | 22 |
| BOTTON1 | 6 |
| BOTTON2 | 7 |
| RedLED | 25 |

1 - GP0 - E/UART0_RX - I2C0_SDA - PWM
2 - GP1 - UART0_TX - I2C0_SCL - PWM
3 - GP2 - UART1_TX - SPI1_SCK - PWM
4 - GP3 - UART1_RX - SPI1_MOSI - PWM
5 - GP4 - SPI1_MISO - PWM
6 - GP5 - SPI1_CS - I2C0_SDA - PWM
7 - GP6 - IO - PWM
8 - GP7 - IO - PWM
9 - GP8 - IO - PWM
10 - GP9 - IO - PWM
11 - GP10 - IO - PWM
12 - GP11 - IO - PWM
13 - GP12 - IO - PWM
14 - GP13 - IO - PWM
15 - GP14 - UART1_RX - SPI1_MISO - PWM
16 - GP15 - UART1_TX - SPI1_CS - PWM
17 - GP16 - IO - PWM
18 - GP17 - IO - PWM
19 - GP18 - IO - PWM
20 - GP19 - IO - PWM
21 - GP20 - IO - PWM
22 - GP21 - IO - PWM
23 - GP22 - IO - PWM
24 - GP26 - IO
25 - GP27 - IO
26 - GP28 - IO
27 - GP29 - IO
28 - GP30 - IO
29 - GP31 - IO
*/

#include <Adafruit_GFX.h> // Include the Adafruit GFX library
#include <Adafruit_ST7789.h> // Include the Adafruit ST7789 library

#define TFT_MOSI 3
#define TFT_MISO 14
#define TFT_SCLK 2
#define TFT_BL 4 // LED back-light
#define TFT_CS 5 // Chip select control pin D8
#define TFT_DC 1 // Data Command control pin
#define TFT_RST 0 // Reset pin (could connect to NodeMCU RST, see next line)


#define LAMP_X 80 // Define the X coordinate of the lamp
#define LAMP_Y 80 // Define the Y coordinate of the lamp
#define LAMP_WIDTH 50 // Define the width of the lamp
#define LAMP_HEIGHT 80 // Define the height of the lamp

const int LED_PIN = 25;
const int t=1000;

Adafruit_ST7789 tft = Adafruit_ST7789(TFT_CS, TFT_DC, TFT_RST); // Initialize the TFT display

void setup()

{
Serial.begin(115200);
pinMode(TFT_BL, OUTPUT); // Set the TFT backlight pin as an output
digitalWrite(TFT_BL, HIGH); // Turn on the backlight
pinMode(LED_PIN, OUTPUT);
tft.init(135, 240); // Initialize the TFT display with 240x240 resolution
tft.fillScreen(ST77XX_BLUE); // Fill the screen with blue color
}

void loop()

{
digitalWrite(TFT_BL, HIGH); // Turn on the backlight
digitalWrite(LED_PIN, HIGH);
tft.fillRect(LAMP_X, LAMP_Y, LAMP_WIDTH, LAMP_HEIGHT, ST77XX_BLUE); // Fill the lamp area with blue color
Serial.println("Aceso");
delay(t); // Wait for 1 second
tft.fillRect(LAMP_X, LAMP_Y, LAMP_WIDTH, LAMP_HEIGHT, ST77XX_YELLOW); // Fill the lamp area with yellow color
digitalWrite(LED_PIN, LOW);
Serial.println("Apagado");
delay(t); // Wait for 1 second
}

Grato pela ajuda!

Resolvido!

Após instalar a biblioteca TFT_eSPI no repositório do fabricante neste link, precisamos instalar também a biblioteca TTF, que parece necessária para controlar o display ST7789.

Depois disso, o arquivo firmware.ino, na pasta exemplos, é o nosso Blink (código abaixo).

Mamão com açúcar: é quase igual programar um Arduino, só mudam os números e configurações dos pinos de IO.

Neste arquivo firmware.ino, na linha 3, vemos a chamada #include "picoImage.h". Refere-se ao arquivo picoImage.h, onde a imagem do logotipo do Rasp fica armazenado, mas não em formato gráfico, e sim em formato de tabela, com 32400 numeros hexadecimais, que descrevem os 240 x 135 pixels da tela.

Editando esses pixels no arquivo picoImage.h, fica fácil trocar a cor de fundo original do logotipo, de branco para azul (fotos).

Editando o arquivo firmware.ino do mesmo jeito que estamos acostumados no Arduino, podemos alterar o texto da tela, inserir leituras de sensores, botões, temperatura, umidade, pressão, ou adicionar menus interativos, o que bem entender, daqui prá frente, resumindo: temos uma mini-CLP com IHM interativa e totalmente programável.

Seguem o firmware.ino, no ponto que estou agora, e fotos.

#include <TFT_eSPI.h> // Biblioteca para controle da tela TFT
#include <User_Setups/Setup135_ST7789.h> // Arquivo de setup para controlar o display ST7789 135 x 240 no ESP8266
#include "picoImage.h" // Imagens que serão carregadas na tela
#include <stdio.h>
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "hardware/adc.h"

// Definindo os pinos de hardware que serão usados
#define TFT_BL 4
#define PWR_ON 22
#define BOTTON1 6
#define BOTTON2 7
#define RedLED 25
#define BatVol 26

// Definindo funções para controlar o brilho da tela e do LED vermelho
#define dark() \
for (int i = 0xff; i > 0; i--) \
{ \
delay(5); \
analogWrite(TFT_BL, i); \
} \
digitalWrite(RedLED, !digitalRead(RedLED));

#define light() \
for (int i = 0; i < 0xff; i++) \
{ \
delay(5); \
analogWrite(TFT_BL, i); \
} \
digitalWrite(RedLED, !digitalRead(RedLED));

// Inicialização do objeto tft
TFT_eSPI tft = TFT_eSPI();

// Fator de conversão para a leitura do valor da bateria
const float conversion_factor = 3.3f / (1 12);
const int t=5000;

void setup()
{
// Configuração dos pinos do hardware
pinMode(PWR_ON, OUTPUT);
digitalWrite(PWR_ON, 1);
pinMode(BatVol, INPUT);
pinMode(TFT_BL, OUTPUT);
pinMode(RedLED, OUTPUT);
digitalWrite(TFT_BL, 0);
analogWrite(TFT_BL, 0);

// Inicialização do objeto Serial e da leitura analógica do valor da bateria

Serial.begin(115200); // Inicialização da comunicação serial
adc_init(); // Inicialização do conversor analógico-digital
adc_gpio_init(26); // Configura o pino 26 para leitura analógica
adc_select_input(0); // Seleciona o canal analógico 0 para leitura

tft.init(); // Inicialização da tela TFT
tft.setRotation(1); // Define a rotação da tela
tft.setTextSize(3); // Define o tamanho da fonte
tft.setSwapBytes(true); // Configura a troca de bytes
tft.pushImage(0, 0, 240, 135, pico); // Exibe uma imagem inicial

delay(t);
// Ligar a luz de fundo da tela e imprimir uma mensagem na porta serial
light(); // Liga a luz de fundo
Serial.println("Hello Pico"); // Imprime a mensagem "Hello Pico" na porta serial

}

void loop()
{
static uint8_t select;
tft.fillScreen(TFT_NAVY);
tft.setCursor(0, 0);
//tft.setTextColor(random(TFT_GREEN));
tft.setTextColor(TFT_YELLOW);
tft.printf("Bat: %3.2fV", 2 * adc_read() * conversion_factor);
tft.setTextColor(TFT_WHITE);
tft.printf("\n");
tft.printf("\nAravecchia");
tft.setTextColor(TFT_YELLOW);
tft.printf("\n");
tft.printf("\nLabDeGaragem");
delay(t);
tft.pushImage(0, 0, 240, 135, pico); // Exibe uma imagem inicial

delay(t);
// light();
}


/*
Aqui está uma lista de algumas das cores com nomes pré-definidos que são suportados pela biblioteca TFT_eSPI:

TFT_BLACK
TFT_NAVY
TFT_DARKGREEN
TFT_DARKCYAN
TFT_MAROON
TFT_PURPLE
TFT_OLIVE
TFT_LIGHTGREY
TFT_DARKGREY
TFT_BLUE
TFT_GREEN
TFT_CYAN
TFT_RED
TFT_MAGENTA
TFT_YELLOW
TFT_WHITE

Além disso, a biblioteca TFT_eSPI também oferece a possibilidade de definir uma cor personalizada,
usando o método tft.color565(red, green, blue) em que red, green e blue são inteiros que variam de 0 a 255,
representando as intensidades de cada componente RGB.

Comentários escritos em ChatGPT
*/

RSS

© 2024   Criado por Marcelo Rodrigues.   Ativado por

Badges  |  Relatar um incidente  |  Termos de serviço