Componentes · 10 min de leitura

ESP32 Cheap Yellow Display (CYD): pinagem, configuração e LVGL

Guia do ESP32 Cheap Yellow Display (ESP32-2432S028R): pinagem completa, configuração da TFT_eSPI e do toque XPT2046, calibração, cartão SD, alto-falante e uma primeira interface com LVGL.

O ESP32 Cheap Yellow Display (CYD, para abreviar), vendido com o nome de modelo ESP32-2432S028R, é uma placa de desenvolvimento pronta que reúne em uma única placa de circuito amarela um ESP32, um display colorido de 2,8 polegadas sensível ao toque, um slot para microSD, um LED RGB, um sensor de luz e uma saída para alto-falante. O apelido já diz tudo: a placa é amarela, é barata e tem um display. Conecte um cabo USB, carregue o seu sketch e você tem uma interface de toque sem soldar nada nem ligar um único jumper.

Neste guia você vai ver o que existe na placa, como diferenciar as versões e a pinagem completa. Depois vai configurar as bibliotecas TFT_eSPI e XPT2046_Touchscreen na Arduino IDE, escrever texto na tela, calibrar o painel de toque, acender o LED RGB com botões na tela, gravar dados em um cartão microSD e montar a sua primeira interface de verdade com a LVGL. As últimas seções trazem ideias de projeto, como um display de previsão do tempo e um painel de casa inteligente, além das soluções para os problemas mais comuns.

Módulo de display TFT de 2,8 polegadas com driver ILI9341
Um módulo TFT ILI9341 vendido separadamente: o display de 2,8 polegadas do CYD usa o mesmo driver; a diferença é que o ESP32 e o circuito de toque ficam na mesma placa.

O que é o ESP32 Cheap Yellow Display e o que existe na placa?

No coração da placa fica um módulo ESP32-WROOM-32: processador de dois núcleos que roda a até 240 MHz, 520 KB de SRAM, 4 MB de flash, Wi-Fi de 2,4 GHz e Bluetooth. Tudo o que você aprendeu em O que é o ESP32? também vale aqui. O display está ligado ao barramento HSPI do ESP32, enquanto o chip XPT2046, que lê o painel de toque resistivo, fica no segundo barramento SPI (VSPI), com pinos próprios. Esse detalhe é importante, porque os exemplos genéricos de TFT partem do princípio de que o toque divide o barramento com o display, e por isso não funcionam no CYD. A placa não tem PSRAM; então, em vez de guardar o quadro inteiro na memória, a imagem é desenhada em pedaços.

CaracterísticaValor
Módulo do processadorESP32-WROOM-32 (dois núcleos, 240 MHz)
Memória520 KB de SRAM, 4 MB de flash, sem PSRAM
DisplayTFT de 2,8 polegadas, 240×320 pixels, cor de 16 bits (RGB565)
Driver do displayILI9341 (normalmente ST7789 na versão com dois USB)
ToquePainel resistivo, controlador XPT2046
ArmazenamentoSlot para cartão microSD (SPI)
ExtrasLED RGB, sensor de luz LDR, saída para alto-falante (amplificador SC8002B)
USB e alimentaçãoMicro-USB, chip USB-serial CH340, 5 V
BotõesBOOT (GPIO 0) e RST

Versões da placa: o que significa ESP32-2432S028R?

O nome do modelo é um resumo: 2432 é a resolução (240×320), S028 é o tamanho do display (2,8 polegadas) e o R no final indica toque resistivo. A mesma família também tem placas terminadas em C (toque capacitivo) e em N (sem toque). Como os vendedores chamam todas de “Cheap Yellow Display”, confira o nome exato do modelo antes de comprar: o mapeamento dos pinos e o driver do display podem mudar de uma versão para outra.

PlacaDisplayComo reconhecerAtenção
ESP32-2432S028R (um USB)2,8" 240×320, ILI9341Só a porta micro-USBA versão em que a maioria dos exemplos, e este guia, se baseia
ESP32-2432S028R (dois USB)2,8" 240×320, normalmente ST7789Micro-USB e USB-C lado a ladoAs cores podem aparecer invertidas; é preciso trocar o driver ou ajustar o invertDisplay
ESP32-2432S0242,4" 240×320Display menorOs pinos e o chip de toque podem ser diferentes
ESP32-2432S0323,2" 240×320Placa maiorA versão capacitiva lê o toque por I2C
ESP32-3248S0353,5" 320×480, ST7796Resolução maiorPrecisa de uma configuração própria da TFT_eSPI
Nos CYDs com duas portas USB (micro-USB + USB-C), o display normalmente tem um driver ST7789. Com a configuração do ILI9341 a tela até pode acender, mas as cores ficam parecendo um negativo: branco no lugar do preto, amarelo no lugar do azul. Nesse caso, selecione ST7789_DRIVER no User_Setup.h ou acrescente tft.invertDisplay(1) logo depois de tft.init().

Pinagem do CYD

ParteSinal e GPIOObservação
Display (ILI9341)MOSI 13, MISO 12, SCK 14, CS 15, DC 2Barramento HSPI; RST ligado ao EN
Luz de fundoGPIO 21HIGH = acesa; dá para reduzir o brilho com PWM
Toque (XPT2046)CLK 25, MOSI 32, MISO 39, CS 33, IRQ 36Barramento VSPI, separado do display
microSDSCK 18, MISO 19, MOSI 23, CS 5Pinos padrão do VSPI
LED RGBVermelho 4, verde 16, azul 17Ânodo comum: LOW = aceso
Sensor de luz LDRGPIO 34Somente entrada, lido com analogRead
Alto-falanteGPIO 26Amplificador SC8002B, conector SPEAK
Botão BOOTGPIO 0Também pode ser lido como botão no seu sketch
Porta serial (P1)TX 1, RX 3Compartilhada com o chip USB-serial
Pinos livresGPIO 22, 27 (CN1), GPIO 35 (P3)O 35 é somente entrada

Os pequenos conectores JST (passo de 1,25 mm) na borda da placa são a sua porta para o mundo externo. O CN1 traz GND, GPIO 22, GPIO 27 e 3,3 V, o que é perfeito para um sensor I2C: chame Wire.begin(27, 22) e ligue diretamente um sensor como o BME280. O P3 expõe os GPIO 35, 22 e 21, e o P1 traz a entrada de 5 V e as linhas seriais TX/RX. Para conferir esses pinos junto com as restrições gerais do ESP32, abra a ferramenta Pinagem.

O GPIO 21 do conector P3 também aciona a luz de fundo do display; se você ligar alguma coisa ali e levar o pino a LOW, a tela escurece. O GPIO 35 funciona somente como entrada, então não consegue acionar um LED nem um relé. Ao alimentar um componente externo pelo pino de 3,3 V do CN1, não puxe centenas de miliamperes dele; a placa já consome uma corrente considerável com o display e o Wi-Fi.

Configuração da Arduino IDE: ajustes da placa e bibliotecas

  1. Instale o pacote de placas ESP32 na Arduino IDE (esp32 by Espressif no Gerenciador de Placas) e selecione ESP32 Dev Module como placa.
  2. Conecte a placa com um cabo USB. Se nenhuma porta aparecer, instale o driver CH340 e confirme que o seu cabo transmite dados, e não só energia.
  3. Instale a TFT_eSPI (Bodmer) e a XPT2046_Touchscreen (Paul Stoffregen) pelo Gerenciador de Bibliotecas.
  4. Substitua o conteúdo do User_Setup.h, na pasta da TFT_eSPI, pelos ajustes da próxima seção.
  5. Se o carregamento parar com “Failed to connect”, segure o botão BOOT enquanto o carregamento começa; os detalhes estão em ESP32 Failed to connect.

Configuração da TFT_eSPI: User_Setup.h

A TFT_eSPI é uma biblioteca muito rápida, e ela tira essa velocidade de ajustes de pinos fixados na hora da compilação. Eles ficam no arquivo User_Setup.h, dentro da pasta da biblioteca (Documentos > Arduino > libraries > TFT_eSPI). Faça um backup do arquivo, apague tudo o que há nele e cole as linhas abaixo. Quando a biblioteca é atualizada, esse arquivo volta ao padrão; por isso guarde a sua cópia em um lugar seguro e copie-a de volta depois de cada atualização.

C++ (Arduino IDE)
1// TFT_eSPI/User_Setup.h: CYD (ESP32-2432S028R) ayarı / setup for the CYD
2#define ILI9341_2_DRIVER       // iki USB'li kartta ST7789_DRIVER / two-USB board: ST7789_DRIVER
3#define TFT_WIDTH  240
4#define TFT_HEIGHT 320
5#define TFT_BL   21            // arka ışık / backlight
6#define TFT_BACKLIGHT_ON HIGH
7#define TFT_MISO 12
8#define TFT_MOSI 13
9#define TFT_SCLK 14
10#define TFT_CS   15
11#define TFT_DC    2
12#define TFT_RST  -1            // EN'e bağlı / tied to EN
13#define USE_HSPI_PORT          // ekran HSPI hattında / display on the HSPI bus
14
15#define LOAD_GLCD
16#define LOAD_FONT2
17#define LOAD_FONT4
18#define LOAD_FONT6
19#define LOAD_FONT7
20#define LOAD_FONT8
21#define LOAD_GFXFF
22#define SMOOTH_FONT
23
24#define SPI_FREQUENCY       55000000   // sorun olursa 27000000 / use 27000000 if unstable
25#define SPI_READ_FREQUENCY  20000000
26#define SPI_TOUCH_FREQUENCY  2500000

Primeiro teste: texto na tela e desenho com o toque

C++ (Arduino IDE)
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5// Dokunmatik (XPT2046) kendi SPI hattında / touch (XPT2046) on its own SPI bus
6#define XPT2046_IRQ  36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK  25
10#define XPT2046_CS   33
11
12SPIClass touchSpi(VSPI);
13XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
14TFT_eSPI tft;
15
16void setup() {
17  Serial.begin(115200);
18  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
19  ts.begin(touchSpi);
20  ts.setRotation(1);               // ekranla aynı yön / same orientation as the screen
21
22  tft.init();
23  tft.setRotation(1);              // yatay 320x240 / landscape 320x240
24  tft.fillScreen(TFT_BLACK);
25  tft.setTextColor(TFT_WHITE, TFT_BLACK);
26  tft.drawCentreString("BlueGrays CYD", 160, 10, 4);
27  tft.drawCentreString("Ekrana dokun / Touch the screen", 160, 40, 2);
28}
29
30void loop() {
31  if (ts.tirqTouched() && ts.touched()) {
32    TS_Point p = ts.getPoint();
33    // Ham değerleri piksele çevir / convert raw values to pixels
34    int x = map(p.x, 200, 3700, 0, 319);
35    int y = map(p.y, 240, 3800, 0, 239);
36    x = constrain(x, 0, 319);
37    y = constrain(y, 0, 239);
38    tft.fillCircle(x, y, 3, TFT_YELLOW);
39    Serial.printf("ham/raw x=%d y=%d z=%d -> piksel/pixel %d,%d\n", p.x, p.y, p.z, x, y);
40  }
41}

A linha mais importante é SPIClass touchSpi(VSPI): ela coloca o controlador de toque no segundo barramento SPI, com pinos próprios e independente do display. ts.setRotation(1) e tft.setRotation(1) precisam usar o mesmo valor; se forem diferentes, o ponto que você toca e o ponto desenhado na tela não vão coincidir. Na horizontal, as coordenadas vão de 0 a 319 em x e de 0 a 239 em y. Depois de carregar o código, tente escrever na tela com uma caneta de toque; se os traços acompanharem a sua mão, o display e o toque estão configurados corretamente.

Calibração da tela de toque (XPT2046)

O XPT2046 não informa pixels, e sim valores brutos entre 0 e 4095. Os números 200, 3700 e 240, 3800 do código são a parte dessa faixa bruta que corresponde às bordas da tela, e eles variam um pouco de placa para placa. Para calibrar, abra o Monitor Serial a 115200 baud, toque nos quatro cantos com uma caneta de toque e anote os menores e os maiores valores brutos de x e de y. Coloque esses quatro números nas linhas com map() e o desvio entre o seu toque e o ponto desenhado cai para poucos pixels. O painel resistivo também mede a pressão: a função touched() da biblioteca já retorna true somente quando o toque é firme o bastante, mas, se você notar valores tremidos perto das bordas, pode definir um limite mais alto para p.z.

LED RGB, LDR e alto-falante: um painel de controle por toque

O LED RGB, o LDR e a saída para alto-falante na parte de trás da placa bastam para o seu primeiro projeto. O código abaixo desenha três botões grandes; ao tocar em um botão, a cor correspondente do LED liga ou desliga e o alto-falante toca um clique curto. A barra amarela na parte de baixo mostra a leitura do sensor de luz e é atualizada a cada meio segundo.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <TFT_eSPI.h>
3#include <XPT2046_Touchscreen.h>
4
5#define XPT2046_IRQ  36
6#define XPT2046_MOSI 32
7#define XPT2046_MISO 39
8#define XPT2046_CLK  25
9#define XPT2046_CS   33
10
11const int LED_PINS[3] = {4, 16, 17};   // RGB LED: kırmızı, yeşil, mavi (LOW = yanar) / red, green, blue (LOW = on)
12const int LDR_PIN = 34;                // ışık sensörü / light sensor
13const int SPEAKER_PIN = 26;            // hoparlör yükselticisi / speaker amplifier
14const char* NAMES[3] = {"RED", "GREEN", "BLUE"};
15const uint16_t COLORS[3] = {TFT_RED, TFT_GREEN, TFT_BLUE};
16
17SPIClass touchSpi(VSPI);
18XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
19TFT_eSPI tft;
20
21bool ledOn[3] = {false, false, false};
22bool wasTouched = false;
23unsigned long lastLdr = 0;
24
25void drawButton(int i) {
26  int x = 8 + i * 104;                                  // 3 düğme yan yana / 3 buttons side by side
27  tft.fillRoundRect(x, 60, 96, 80, 10, ledOn[i] ? COLORS[i] : TFT_DARKGREY);
28  tft.setTextColor(TFT_WHITE);
29  tft.drawCentreString(NAMES[i], x + 48, 92, 2);
30}
31
32void setup() {
33  for (int i = 0; i < 3; i++) {
34    pinMode(LED_PINS[i], OUTPUT);
35    digitalWrite(LED_PINS[i], HIGH);                    // HIGH = sönük / HIGH = off
36  }
37  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
38  ts.begin(touchSpi);
39  ts.setRotation(1);
40  tft.init();
41  tft.setRotation(1);
42  tft.fillScreen(TFT_BLACK);
43  tft.setTextColor(TFT_WHITE, TFT_BLACK);
44  tft.drawString("BlueGrays panel", 8, 12, 4);
45  for (int i = 0; i < 3; i++) drawButton(i);
46}
47
48void loop() {
49  bool touchedNow = ts.tirqTouched() && ts.touched();
50  if (touchedNow && !wasTouched) {                      // yalnız ilk dokunuşta / only on the first touch
51    TS_Point p = ts.getPoint();
52    int x = map(p.x, 200, 3700, 0, 319);
53    int y = map(p.y, 240, 3800, 0, 239);
54    if (y > 60 && y < 140) {
55      int i = constrain((x - 8) / 104, 0, 2);
56      ledOn[i] = !ledOn[i];
57      digitalWrite(LED_PINS[i], ledOn[i] ? LOW : HIGH);
58      drawButton(i);
59      tone(SPEAKER_PIN, 2000, 30);                      // kısa tık sesi / short click sound
60    }
61  }
62  wasTouched = touchedNow;
63
64  if (millis() - lastLdr > 500) {                       // yarım saniyede bir / every half second
65    lastLdr = millis();
66    int light = analogRead(LDR_PIN);                    // 0-4095
67    tft.fillRect(8, 170, 304, 20, TFT_BLACK);
68    tft.fillRect(8, 170, map(light, 0, 4095, 0, 304), 20, TFT_YELLOW);
69    tft.setTextColor(TFT_WHITE, TFT_BLACK);
70    tft.drawString("LDR: " + String(light) + "    ", 8, 200, 2);
71  }
72}

Como o LED RGB está ligado em ânodo comum, a lógica é invertida: escrever LOW acende a cor e HIGH apaga, e é por isso que o setup() começa colocando os três pinos em HIGH. A variável wasTouched impede que um botão fique alternando sem parar enquanto o seu dedo continua na tela; só conta o instante em que o toque começa. A leitura do LDR pode ficar dentro de uma faixa estreita por causa do resistor do divisor que existe na placa, então meça os valores de escuro e de claro no seu próprio ambiente e escolha o limite a partir deles. Você pode ligar um pequeno alto-falante de 8 Ω ao conector do alto-falante e tocar bipes e melodias simples com tone().

Gravando dados no cartão microSD

O slot do cartão usa os pinos VSPI padrão do ESP32 (18, 19, 23 e 5 para o CS), então basta chamar SD.begin(5). Formate o cartão em FAT32; cartões de até 32 GB funcionam sem problemas. O exemplo abaixo acrescenta a hora e o nível de luz ao arquivo log.csv a cada cinco segundos, e depois você pode abrir o arquivo em qualquer programa de planilhas. Para o uso geral de cartões SD, veja o guia do módulo de cartão SD.

C++ (Arduino IDE)
1#include <SPI.h>
2#include <SD.h>
3
4const int SD_CS = 5;          // microSD: SCK 18, MISO 19, MOSI 23, CS 5
5const int LDR_PIN = 34;
6
7void setup() {
8  Serial.begin(115200);
9  if (!SD.begin(SD_CS)) {     // varsayılan SPI pinleri / default SPI pins
10    Serial.println("SD kart yok / no SD card");
11    return;
12  }
13  Serial.printf("SD: %llu MB\n", SD.cardSize() / (1024 * 1024));
14}
15
16void loop() {
17  File f = SD.open("/log.csv", FILE_APPEND);   // dosyanın sonuna ekle / append to the file
18  if (f) {
19    f.printf("%lu,%d\n", millis() / 1000, analogRead(LDR_PIN));
20    f.close();
21  }
22  delay(5000);
23}
O controlador de toque e o cartão SD usam o mesmo periférico VSPI, mas em pinos diferentes. Se você precisar dos dois no mesmo sketch, escolha uma biblioteca que leia o painel de toque por SPI via software (por exemplo, a XPT2046_Bitbang) ou reinicie o barramento SPI com os pinos certos antes e depois de cada acesso ao SD. Caso contrário, um deles para de responder enquanto o outro está em uso.

A sua primeira interface com LVGL

Desenhar botões, controles deslizantes e gráficos com um fillRect de cada vez cansa rápido. A LVGL é uma biblioteca gráfica de código aberto que oferece widgets no estilo dos de celular (botões, controles deslizantes, listas, gráficos, abas) e cuida da entrada por toque para você. Desde a versão 9 ela já vem com suporte à TFT_eSPI embutido, então você não precisa mais escrever a sua própria função de flush para o display.

  1. Instale a biblioteca lvgl (versão 9.x) pelo Gerenciador de Bibliotecas.
  2. Copie o lv_conf_template.h da pasta libraries/lvgl para um nível acima, ao lado da pasta lvgl, e renomeie-o para lv_conf.h.
  3. Troque o #if 0 no início do arquivo por #if 1 e defina LV_USE_TFT_ESPI como 1.
  4. Para fontes maiores, defina também como 1 linhas como LV_FONT_MONTSERRAT_20; cada fonte ocupa espaço na memória flash.
C++ (Arduino IDE)
1#include <SPI.h>
2#include <lvgl.h>
3#include <TFT_eSPI.h>
4#include <XPT2046_Touchscreen.h>
5
6#define XPT2046_IRQ  36
7#define XPT2046_MOSI 32
8#define XPT2046_MISO 39
9#define XPT2046_CLK  25
10#define XPT2046_CS   33
11#define SCREEN_WIDTH  240
12#define SCREEN_HEIGHT 320
13#define DRAW_BUF_SIZE (SCREEN_WIDTH * SCREEN_HEIGHT / 10 * (LV_COLOR_DEPTH / 8))
14
15SPIClass touchSpi(VSPI);
16XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
17uint32_t drawBuf[DRAW_BUF_SIZE / 4];   // ekranın 1/10'u kadar tampon / buffer for 1/10 of the screen
18lv_obj_t* valueLabel;
19
20// LVGL'e dokunuşu bildir / report touches to LVGL
21void touchRead(lv_indev_t* indev, lv_indev_data_t* data) {
22  if (ts.tirqTouched() && ts.touched()) {
23    TS_Point p = ts.getPoint();
24    data->point.x = map(p.x, 200, 3700, 1, SCREEN_WIDTH);
25    data->point.y = map(p.y, 240, 3800, 1, SCREEN_HEIGHT);
26    data->state = LV_INDEV_STATE_PRESSED;
27  } else {
28    data->state = LV_INDEV_STATE_RELEASED;
29  }
30}
31
32uint32_t tickMs() { return millis(); }   // LVGL'in saat kaynağı / LVGL time source
33
34void onLedButton(lv_event_t* e) {
35  lv_obj_t* btn = lv_event_get_target_obj(e);
36  bool on = lv_obj_has_state(btn, LV_STATE_CHECKED);
37  digitalWrite(4, on ? LOW : HIGH);      // kırmızı LED / red LED
38}
39
40void onSlider(lv_event_t* e) {
41  lv_obj_t* slider = lv_event_get_target_obj(e);
42  lv_label_set_text_fmt(valueLabel, "%d %%", (int)lv_slider_get_value(slider));
43}
44
45void lvglSetup() {
46  pinMode(4, OUTPUT);
47  digitalWrite(4, HIGH);
48  touchSpi.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
49  ts.begin(touchSpi);
50  ts.setRotation(2);
51
52  lv_init();
53  lv_tick_set_cb(tickMs);
54  lv_display_t* disp = lv_tft_espi_create(SCREEN_WIDTH, SCREEN_HEIGHT, drawBuf, sizeof(drawBuf));
55  lv_display_set_rotation(disp, LV_DISPLAY_ROTATION_270);   // yatay kullanım / landscape
56  lv_indev_t* indev = lv_indev_create();
57  lv_indev_set_type(indev, LV_INDEV_TYPE_POINTER);
58  lv_indev_set_read_cb(indev, touchRead);
59
60  lv_obj_t* title = lv_label_create(lv_screen_active());
61  lv_label_set_text(title, "BlueGrays + LVGL");
62  lv_obj_align(title, LV_ALIGN_TOP_MID, 0, 10);
63
64  lv_obj_t* btn = lv_button_create(lv_screen_active());
65  lv_obj_set_size(btn, 120, 50);
66  lv_obj_align(btn, LV_ALIGN_CENTER, 0, -30);
67  lv_obj_add_flag(btn, LV_OBJ_FLAG_CHECKABLE);              // aç-kapa düğmesi / toggle button
68  lv_obj_add_event_cb(btn, onLedButton, LV_EVENT_VALUE_CHANGED, NULL);
69  lv_obj_t* btnLabel = lv_label_create(btn);
70  lv_label_set_text(btnLabel, "LED");
71  lv_obj_center(btnLabel);
72
73  lv_obj_t* slider = lv_slider_create(lv_screen_active());
74  lv_obj_set_width(slider, 220);
75  lv_obj_align(slider, LV_ALIGN_CENTER, 0, 40);
76  lv_obj_add_event_cb(slider, onSlider, LV_EVENT_VALUE_CHANGED, NULL);
77  valueLabel = lv_label_create(lv_screen_active());
78  lv_label_set_text(valueLabel, "0 %");
79  lv_obj_align_to(valueLabel, slider, LV_ALIGN_OUT_BOTTOM_MID, 0, 10);
80}
81
82void lvglLoop() {
83  lv_timer_handler();                    // LVGL çizim ve olayları / LVGL drawing and events
84  delay(5);
85}

Acrescente setup() e loop() ao final deste código: chame somente lvglSetup() no setup() e somente lvglLoop() no loop(). A tela é desenhada em pedaços por meio de um buffer com um décimo do tamanho da tela (cerca de 15 KB), o que é um bom equilíbrio para um CYD sem PSRAM. Como a própria LVGL cuida da rotação, as coordenadas de toque são passadas na ordem vertical (240×320) e a LVGL as converte para a tela na horizontal. O botão é do tipo liga/desliga (checkable), então cada toque alterna o LED vermelho, e o controle deslizante escreve a sua porcentagem no rótulo logo abaixo.

Ideias de projeto com o CYD: estação meteorológica e painel de casa inteligente

  • Display de previsão do tempo: use o guia da API de previsão do tempo com ESP32 para mostrar a temperatura, a umidade e a previsão do dia com ícones.
  • Painel de casa inteligente: controle lâmpadas e tomadas com botões na tela via MQTT e Home Assistant.
  • Relógio de mesa: mostre a hora da internet obtida por NTP em dígitos grandes e reduza a luz de fundo à noite de acordo com o LDR.
  • Painel de sensores: desenhe em um gráfico ao vivo a temperatura, a umidade e a pressão de um sensor I2C ligado ao CN1.
  • Datalogger: salve as leituras no cartão microSD e mostre um gráfico das últimas 24 horas.
  • Jogos de toque: crie um jogo da velha, um jogo da cobrinha ou um jogo da memória para jogar com a caneta.

Problemas comuns e soluções

SintomaCausa provávelSolução
A tela fica toda branca ou pretaUser_Setup.h não configurado ou driver erradoCopie os ajustes deste guia; em uma placa com dois USB, teste o ST7789
As cores parecem um negativoO driver ou o ajuste de inversão de cores não correspondeAcrescente tft.invertDisplay(1) ou troque o driver
O toque não respondePresumiu-se que o toque divide o barramento SPI com o displayUse touchSpi(VSPI) com os pinos 25, 32, 39, 33
O ponto tocado e o desenho ficam deslocadosOs valores de calibração não servem para a placaMeça os valores brutos dos cantos e atualize as linhas com map()
Tela tremendo ou linhas embaralhadasClock do SPI alto demaisReduza o SPI_FREQUENCY para 27000000
Reinicia quando o Wi-Fi ligaA porta USB ou o cabo não fornece corrente suficienteUse um cabo curto e de boa qualidade e uma fonte de pelo menos 1 A
O carregamento não começaSem driver CH340 ou placa fora do modo de downloadInstale o driver e pressione BOOT quando o carregamento começar
Se a placa fica reiniciando ao conectar ao Wi-Fi e o Monitor Serial mostra “Brownout detector was triggered”, o problema está na alimentação, não no seu código; veja os detalhes em Brownout e Guru Meditation no ESP32.

O ESP32 Cheap Yellow Display é o caminho mais curto para um projeto de ESP32 com tela: sem emaranhado de fios, sem solda, só código. Se você prefere trabalhar com módulos separados, o guia do display TFT ILI9341 mostra o mesmo driver em uma protoboard. No app BlueGrays você encontra os projetos de previsão do tempo, relógio NTP, servidor web e LDR com esquemas do circuito e códigos passo a passo, prontos para irem para a tela do CYD.

Perguntas frequentes

Qual placa devo selecionar na Arduino IDE para o Cheap Yellow Display?

Selecione ESP32 Dev Module, porque o CYD usa um módulo ESP32-WROOM-32 padrão. Deixe o tamanho da flash em 4 MB e, se o carregamento falhar, reduza a velocidade de upload para 115200. Se nenhuma porta aparecer, instale o driver CH340.

Por que a tela do meu CYD fica branca?

Tela branca significa que a luz de fundo está acesa, mas o driver do display não está recebendo dados válidos. Quase sempre o arquivo User_Setup.h da TFT_eSPI não foi configurado para o CYD ou o driver selecionado está errado. Confira os ajustes dos pinos e, nas placas com duas portas USB, teste o driver ST7789 no lugar do ILI9341.

Quais pinos GPIO posso usar no ESP32 Cheap Yellow Display?

Os pinos utilizáveis são os GPIO 22 e 27, no conector CN1, e o GPIO 35, no P3; o GPIO 35 é somente entrada. Para sensores I2C, chame Wire.begin(27, 22) e alimente o sensor pelos pinos de 3,3 V e GND do CN1. Não mexa no GPIO 21, porque ele aciona a luz de fundo.

A LVGL roda no CYD sem PSRAM?

Sim, a LVGL 9 roda com fluidez no CYD. Como não há PSRAM, você usa um buffer de desenho com um décimo da tela (cerca de 15 KB) em vez de um quadro inteiro. Se você acrescentar muitas fontes grandes ou imagens, a flash e a RAM passam a ser o limite real; por isso desative no lv_conf.h as fontes que não usa.

Posso usar a tela de toque e o cartão SD ao mesmo tempo?

Sim, mas é preciso uma configuração extra, porque os dois usam o periférico VSPI do ESP32 em pinos diferentes. O jeito mais fácil é uma biblioteca de toque que use SPI via software. A outra opção é reiniciar o barramento SPI com os pinos do SD antes de cada acesso ao cartão e com os pinos do toque logo depois.

O Cheap Yellow Display pode funcionar com bateria?

A placa funciona com 5 V e normalmente consome de 100 a 250 mA com a luz de fundo e o Wi-Fi ligados. Para alimentar com bateria, use uma célula Li-ion com um carregador TP4056 e um conversor boost de 5 V, ou simplesmente um power bank. Para a bateria durar mais, desligue a tela e o Wi-Fi quando a placa estiver ociosa e coloque o ESP32 para dormir.

Ver todos os projetos
Leitura da intensidade da luz com módulo LDR e ESP32
ES-11Iniciante

Leitura da intensidade da luz com módulo LDR e ESP32

Acompanhe em tempo real no Monitor Serial o valor bruto do ADC do módulo LDR e a porcentagem relativa de luz calculada a partir de referências de escuridão e claridade. Essa porcentagem não é uma medida em lux. O projeto ensina a lógica de calibração do módulo. É ideal fazê-lo antes do projeto 10, pois ajuda a determinar o valor do limiar.

4.6(36)
55
ESP32 HTTPClient + API de clima (com display OLED SSD1306)
ES-32Avançado
Premium

ESP32 HTTPClient + API de clima (com display OLED SSD1306)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Diferentemente da versão anterior com LCD I2C, aqui usamos um display OLED SSD1306 (128×64), que permite usar fontes grandes, ícones vetoriais e uma apresentação visual rica em uma única tela. Sete ícones vetoriais de condições do tempo (ensolarado, parcialmente nublado, nublado, chuvoso, com neve, com tempestade e com neblina) são desenhados durante a execução, sem arquivos bitmap.

4.3(10)
22
ESP32 HTTPClient + API de clima (com display LCD)
ES-31Avançado
Premium

ESP32 HTTPClient + API de clima (com display LCD)

Neste projeto, usamos o ESP32 para fazer uma chamada REST à API de clima wttr.in pela internet com HTTPClient.h. Interpretamos a resposta JSON com ArduinoJson v7 e mostramos cidade, temperatura, umidade, condições do tempo e vento em um display LCD I2C, em turco e inglês. O wttr.in é grátis e não exige chave de API — basta informar o nome de uma cidade para consultar o clima atual. Os dados se atualizam sozinhos a cada 30 minutos, e o LED dá um retorno visual diferente para cada tela.

4.7(13)
20
Hora exata pela internet com ESP32 e NTP
ES-26Avançado
Premium

Hora exata pela internet com ESP32 e NTP

O ESP32 se conecta ao Wi-Fi e obtém a hora exata com precisão de milissegundos de servidores NTP (Network Time Protocol). Com a função configTzTime(), o fuso horário configurado (TRT, UTC+3 neste exemplo) é aplicado automaticamente, e as mudanças nos países que adotam horário de verão são gerenciadas automaticamente por uma string POSIX TZ. A hora é exibida tanto no Monitor Serial quanto em um LCD I2C opcional.

4.5(13)
22
Servidor web assíncrono com ESP32 (IP no LCD)
ES-27Avançado

Servidor web assíncrono com ESP32 (IP no LCD)

Neste projeto, transformamos o ESP32 em um servidor web assíncrono que você pode controlar pelo celular ou computador na mesma rede Wi-Fi. Com a biblioteca ESPAsyncWebServer, o servidor processa várias requisições ao mesmo tempo (ao contrário do WebServer.h tradicional, que bloqueia a execução ao processar uma requisição). Você poderá abrir o endereço IP do ESP32 no navegador e clicar nos botões ON/OFF (as rotas /on e /off) para ligar e desligar o LED conectado ao GPIO 5.

4.8(16)
26
Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)
ES-40Avançado
Premium

Registrador de temperatura com ESP32 (DHT22 + DS1307 RTC + microSD + OLED)

Monte um registrador de temperatura com data e hora usando ESP32. O DHT22 mede a temperatura e a umidade a cada minuto, o DS1307 RTC fornece a hora real e cada leitura é gravada em CSV no cartão microSD. O OLED mostra em letras grandes a temperatura atual, além da umidade, da data e hora e do total de registros. Abra o arquivo /temp_log.csv no Excel, no Google Sheets ou com pandas para acompanhar uma estufa ou a temperatura de casa.

4.7(7)
12
Controle de LED RGB com ESP32
ES-9Iniciante

Controle de LED RGB com ESP32

Gere inúmeras cores com um único LED RGB em vez de 3 LEDs separados. Como no Arduino, ajustamos os valores R/G/B com analogWrite() para criar uma transição de arco-íris. Você vê a teoria das cores na prática, como vermelho + verde = amarelo.

4.6(29)
52
Melodia com buzzer e ESP32
ES-12Iniciante
Premium

Melodia com buzzer e ESP32

Toque uma melodia simples (Brilha, brilha, estrelinha) com um buzzer passivo. Usamos as funções tone() e noTone() para tocar as notas, como no Arduino. A mesma sintaxe funciona com ESP32 Arduino Core 3.0+. É preciso usar um buzzer passivo, pois o ativo não toca melodias.

4.8(30)
55