Começar com o Matouch 1.28″ ToolSet_Controller

O Matouch 1.28″ ToolSet_Controller é uma placa de desenvolvimento compacta ESP32-S3 com muitas funcionalidades. Vem com um ecrã táctil RGB redondo de 1,28 polegadas com um anel codificador rotativo, Wi-Fi, Bluetooth 5.0 e feedback tátil por vibração. Inclui também um RTC, slot para cartão micro-SD e conectores para I²C, UART, SPI e GPIO.

Neste guia de introdução, aprenderá como configurar a placa para programação com o Arduino IDE. Dois exemplos de código mostrarão como usar o ecrã, o ecrã táctil, o codificador rotativo e o motor para feedback tátil.

Vamos começar…

Peças Necessárias

Vai precisar de uma placa Matouch 1.28″ ToolSet_Controller da Makerfabs e de um cabo USB-C para programar a placa e testar os exemplos de código.

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

O Matouch 1.28″ ToolSet_Controller

O Matouch 1.28″ ToolSet_Controller é alimentado pelo microcontrolador ESP32-S3, que possui processamento dual-core juntamente com conectividade Wi-Fi e Bluetooth 5.0. No centro encontra-se um ecrã IPS RGB redondo de 1,28 polegadas com resolução de 240 por 240 pixels. O ecrã suporta toque capacitivo para interação precisa. À volta do ecrã há um anel codificador rotativo com funcionalidade de botão de pressão, que permite uma entrada intuitiva como rolar, ajustar volume ou navegar em menus.

Componentes do Matouch 1.28″ ToolSet_Controller

Além do ecrã e controlo rotativo, a placa integra um motor de vibração tátil que fornece feedback táctil. Um relógio em tempo real (RTC) assegura a manutenção precisa do tempo mesmo quando o dispositivo está em modo de sono profundo. Para armazenamento local de dados, o slot para cartão micro-SD facilita o registo de informações ou armazenamento de media.

A placa mede 60 por 60 milímetros. Este design compacto e quadrado facilita a integração em controladores portáteis, ferramentas de secretária e interfaces de utilizador. A expansão é suportada através de conectores acessíveis para pinos I²C, UART, SPI e GPIO, permitindo o uso de sensores externos, atuadores ou outros módulos. A alimentação é gerida por um sistema onboard que suporta tanto USB Type-C como bateria externa, mas sem circuito de carregamento.

Pinout do Matouch 1.28″ ToolSet_Controller

A imagem abaixo mostra o pinout do Matouch 1.28″ ToolSet_Controller. Estão disponíveis 15 pinos GPIO e pinos de alimentação de 5V ou 3.3V:

O Matouch 1.28″ ToolSet_Controller é ideal para projetos que precisam de uma interface pequena mas capaz. Aplicações típicas incluem um controlador de media de secretária para ajustar volume ou mudar faixas, um painel de controlo para casa inteligente ou uma ferramenta de configuração de dispositivos.

Especificações Técnicas

A tabela abaixo resume as especificações técnicas da placa.

Especificação	Detalhes
Microcontrolador	ESP32-S3 dual-core, Xtensa LX7
Sem fios	Wi-Fi 802.11 b/g/n, Bluetooth 5.0
Ecrã	IPS RGB redondo de 1,28″, 240 × 240 pixels, toque capacitivo
Entrada rotativa	Anel codificador rotativo com botão de pressão
Vibração	Motor tátil
Armazenamento	Slot para cartão micro-SD
Relógio	Relógio em tempo real (RTC)
Expansão	I²C, UART, SPI, GPIO
Alimentação	USB Type-C, bateria externa
Dimensões	60 × 60 mm
Suporte open-source	Arduino IDE, projetos de exemplo no GitHub

Finalmente, pode encontrar os esquemas do Matouch 1.28″ ToolSet_Controller no seguinte link:

Instalação do Core ESP32

Se este for o seu primeiro projeto com uma placa da série ESP32, precisará instalar primeiro o core ESP32. Se as placas ESP32 já estiverem instaladas no seu Arduino IDE, pode saltar esta secção.

Comece por abrir o diálogo de Preferências selecionando “Preferences…” no menu “File”. Isto abrirá o diálogo de Preferências mostrado abaixo.

Na aba Settings encontrará uma caixa de edição na parte inferior do diálogo rotulada “Additional boards manager URLs“:

Neste campo copie a seguinte URL:

https://espressif.github.io/arduino-esp32/package_esp32_dev_index.json

Isto permitirá ao Arduino IDE saber onde encontrar as bibliotecas core do ESP32. A seguir, vamos instalar as placas ESP32 usando o Gestor de Placas.

Abra o Gestor de Placas via “Tools -> Boards -> Board Manager”. Verá o Gestor de Placas aparecer na barra lateral esquerda. Digite “ESP32” no campo de pesquisa no topo e deverá ver dois tipos de placas ESP32; as “Arduino ESP32 Boards” e as placas “esp32 by Espressif”. Queremos as “esp32 libraries by Espressif”. Clique no botão INSTALL e aguarde até o download e instalação estarem completos.

Seleção da Placa

Finalmente, precisamos selecionar uma placa ESP32. No caso do Matouch 1.28″ ToolSet_Controller, escolhemos o genérico “ESP32S3 Dev Module”. Para isso, clique no menu suspenso e depois em “Select other board and port…”:

Isto abrirá um diálogo onde pode digitar “esp32s3 dev” na barra de pesquisa. Verá a placa “ESP32S3 Dev Module” em Boards. Clique nela e selecione a porta COM para ativá-la e depois clique em OK:

Note que precisa de ligar a placa ao computador via cabo USB antes de poder selecionar uma porta COM.

Instalar Biblioteca Adafruit GFX

Depois de instalar o código ESP32, o próximo passo é instalar a Arduino_GFX biblioteca de moononournation, que usaremos para desenhar no ecrã Matouch 1.28″. Abra o LIBRARY MANAGER, escreva “GFX Library for Arduino” na barra de pesquisa, encontre a “GFX Library for Arduino” por Moon, e clique no botão INSTALL:

Agora está tudo pronto para escrever e executar código no Matouch 1.28″ ToolSet_Controller.

Código para Encoder, Motor e Ecrã

Neste primeiro sketch aprenderá a usar o ecrã, o encoder e o motor para feedback tátil.

Usaremos o anel do encoder para alterar o brilho do ecrã entre 1% e 100% e mostraremos o valor do brilho no ecrã. Uma vibração curta sinalizará se o anel for rodado além do limite (<1%, >100%). Finalmente, pressionar o botão do encoder alternará o ecrã ligado ou desligado. A foto abaixo mostra o ecrã desligado, com brilho a 4% e a 100%:

Dê uma vista rápida ao código completo primeiro e depois discutiremos os detalhes:

#include <Arduino_GFX_Library.h>

#define TFT_BLK 45
#define TFT_RES 21
#define TFT_CS 1
#define TFT_MOSI 2
#define TFT_MISO -1
#define TFT_SCLK 42
#define TFT_DC 46

#define ENCODER_BTN 17
#define ENCODER_CLK 48
#define ENCODER_DT 47

#define MOTOR_PIN 41

int brightness = 50;
bool btn_display = true;
int enc_state = 0;
int old_state = -1;
bool has_changed = true;

Arduino_ESP32SPI *bus = new Arduino_ESP32SPI(TFT_DC, TFT_CS, TFT_SCLK,
                                             TFT_MOSI, TFT_MISO, HSPI, true);
Arduino_GFX *gfx = new Arduino_GC9A01(bus, TFT_RES, 0 /* rotation */, true /* IPS */);

void encoder_irq() {
  enc_state = digitalRead(ENCODER_CLK);
  if (enc_state != old_state) {
    brightness = digitalRead(ENCODER_DT) == enc_state ? brightness + 1 : brightness - 1;
  }
  old_state = enc_state;
  has_changed = true;
}

void button_irq() {
  btn_display = !btn_display;
  has_changed = true;
}

void draw_text() {
  gfx->setTextSize(2);
  gfx->setCursor(60, 55);
  gfx->println(F("Makerguides"));
}

void limit_brightness() {
  if (brightness > 100 || brightness < 0) {
    digitalWrite(MOTOR_PIN, HIGH);
    delay(50);
    digitalWrite(MOTOR_PIN, LOW);
  }
  brightness = constrain(brightness, 0, 100);
}

void update_brightness() {
  gfx->fillRect(65, 95, 120, 65, WHITE);
  gfx->setTextSize(6);
  gfx->setCursor(65, 100);
  gfx->printf("%3d", brightness);

  int b = map(brightness, 0, 100, 1, 255);
  analogWrite(TFT_BLK, btn_display ? b : 0);
}

void init_display() {
  gfx->begin();
  gfx->fillScreen(WHITE);
  gfx->setTextColor(BLACK);
}

void init_pins() {
  pinMode(TFT_BLK, OUTPUT);
  digitalWrite(TFT_BLK, HIGH);

  pinMode(MOTOR_PIN, OUTPUT);

  pinMode(ENCODER_BTN, INPUT);
  pinMode(ENCODER_CLK, INPUT);
  pinMode(ENCODER_DT, INPUT);

  attachInterrupt(ENCODER_CLK, encoder_irq, CHANGE);
  attachInterrupt(ENCODER_BTN, button_irq, FALLING);
}

void setup(void) {
  Serial.begin(115200);
  init_pins();
  init_display();
  draw_text();
}

void loop() {
  if (has_changed) {
    has_changed = false;
    limit_brightness();
    update_brightness();
  }
}

Importações

O programa começa por incluir a biblioteca gráfica para o ecrã redondo GC9A01. Este cabeçalho traz os drivers do ecrã, constantes de cor como WHITE, BLACK, ou RED, e primitivas de desenho.

#include <Arduino_GFX_Library.h>

Constantes de Pinos e Hardware

Constantes nomeadas associam etiquetas significativas aos pinos GPIO do ESP32. Definem o pino PWM da luz de fundo TFT, reset, chip-select, pinos SPI, dados/comando do ecrã, o botão de pressão do codificador rotativo e dois canais de quadratura, e o pino de controlo do motor de vibração. Defini-los aqui torna o resto do código mais legível.

#define TFT_BLK 45
#define TFT_RES 21
#define TFT_CS 1
#define TFT_MOSI 2
#define TFT_MISO -1
#define TFT_SCLK 42
#define TFT_DC 46

#define ENCODER_BTN 17
#define ENCODER_CLK 48
#define ENCODER_DT 47

#define MOTOR_PIN 41

Variáveis Globais de Estado

Algumas variáveis globais guardam o brilho atual, estado do ecrã ligado/desligado, o nível lógico mais recente do encoder e o seu valor anterior, e uma flag “dirty” que indica ao loop principal quando algo mudou devido a uma interrupção. O brilho inicial é 50%, o ecrã começa ativado, e old_state é inicializado com um valor impossível (-1) para que a primeira leitura do encoder seja vista como uma mudança.

int brightness = 50;
bool btn_display = true;
int enc_state = 0;
int old_state = -1;
bool has_changed = true;

Objetos do Bus e Driver do Ecrã

Dois objetos configuram o ecrã. Arduino_ESP32SPI configura o bus SPI e os pinos de controlo para o TFT. O construtor seleciona os pinos DC, CS, SCLK, MOSI e MISO, escolhe o periférico HSPI e ativa DMA para transferências mais rápidas. Arduino_GC9A01 é o driver específico para o painel redondo de 1,28″; recebe o objeto do bus SPI, o pino de reset, rotação e flag IPS. O objeto resultante gfx expõe métodos de desenho usados ao longo do sketch.

Arduino_ESP32SPI *bus = new Arduino_ESP32SPI(TFT_DC, TFT_CS, TFT_SCLK,
                                             TFT_MOSI, TFT_MISO, HSPI, true);
Arduino_GFX *gfx = new Arduino_GC9A01(bus, TFT_RES, 0 /* rotation */, true /* IPS */);

Rotina de Serviço de Interrupção: encoder_irq

Esta ISR executa sempre que a linha CLK do encoder muda. Lê o nível atual do CLK e compara com o anterior. Se ocorreu uma transição, verifica a linha DT para determinar a direção: quando DT é igual ao novo nível CLK, o brilho incrementa, caso contrário decrementa. Depois guarda o novo estado e marca a UI como alterada para que o loop principal redesenhe e aplique o novo brilho. Usar uma ISR torna o encoder responsivo sem espera ativa no loop().

void encoder_irq() {
  enc_state = digitalRead(ENCODER_CLK);
  if (enc_state != old_state) {
    brightness = digitalRead(ENCODER_DT) == enc_state ? brightness + 1 : brightness - 1;
  }
  old_state = enc_state;
  has_changed = true;
}

Rotina de Serviço de Interrupção: button_irq

Esta ISR alterna se o ecrã deve estar ligado. Cada borda de descida no botão do encoder inverte btn_display e sinaliza que houve uma mudança para que o loop principal atualize o ecrã e a luz de fundo.

void button_irq() {
  btn_display = !btn_display;
  has_changed = true;
}

Auxiliar de Desenho: draw_text

Este auxiliar coloca uma etiqueta fixa “Makerguides” perto do topo do ecrã redondo. Define um tamanho de texto pequeno, move o cursor e imprime a string da memória flash (F() macro).

void draw_text() {
  gfx->setTextSize(2);
  gfx->setCursor(60, 55);
  gfx->println(F("Makerguides"));
}

Auxiliar Lógico: limit_brightness

Esta função impõe o intervalo válido de brilho e sinaliza tátilmente quando o utilizador tenta ultrapassá-lo. Se o valor atual estiver fora de [0, 100], ativa brevemente o motor de vibração para indicar o limite, depois limita o valor ao intervalo usando constrain. O feedback do motor só dispara quando é detectada uma condição fora do intervalo, assim os limites “buzzam” mas os passos normais não.

void limit_brightness() {
  if (brightness > 100 || brightness < 0) {
    digitalWrite(MOTOR_PIN, HIGH);
    delay(50);
    digitalWrite(MOTOR_PIN, LOW);
  }
  brightness = constrain(brightness, 0, 100);
}

Atualização da UI e Luz de Fundo: update_brightness

Esta função atualiza a leitura numérica no ecrã e aplica o novo nível PWM da luz de fundo. Primeiro pinta um retângulo branco sobre o número anterior para apagá-lo, define um tamanho de texto maior, posiciona o cursor e imprime o brilho como um valor de três dígitos alinhado à direita. Depois mapeia 0–100% para o intervalo PWM 1–255 e escreve esse ciclo de trabalho no pino da luz de fundo. Se o ecrã foi desligado com o botão, força o ciclo de trabalho a zero para desligar a luz de fundo sem alterar o valor armazenado do brilho.

void update_brightness() {
  gfx->fillRect(65, 95, 120, 65, WHITE);
  gfx->setTextSize(6);
  gfx->setCursor(65, 100);
  gfx->printf("%3d", brightness);

  int b = map(brightness, 0, 100, 1, 255);
  analogWrite(TFT_BLK, btn_display ? b : 0);
}

Inicialização do Ecrã: init_display

No arranque, o driver do ecrã é inicializado, o ecrã é limpo para branco e a cor do texto padrão é definida para preto. Estes passos garantem um estado de desenho conhecido antes de qualquer elemento da UI ser renderizado.

void init_display() {
  gfx->begin();
  gfx->fillScreen(WHITE);
  gfx->setTextColor(BLACK);
}

Inicialização dos Pinos e Ligação das Interrupções: init_pins

Todos os modos GPIO são configurados aqui. O pino da luz de fundo é definido como saída e inicialmente ativado para que o painel seja visível durante o arranque. O pino do motor é definido como saída. O botão do encoder, CLK e DT são entradas. Note que o encoder tem resistores pull-up internos de 10K, por isso INPUT_PULLUP não é necessário aqui (embora apareça em alguns exemplos).

Finalmente, as interrupções de hardware são ligadas: o CLK do encoder usa CHANGE para captar bordas de subida e descida para máxima resolução, enquanto o botão usa FALLING para disparar uma vez por pressão. Esta configuração mantém o loop principal simples e responsivo.

void init_pins() {
  pinMode(TFT_BLK, OUTPUT);
  digitalWrite(TFT_BLK, HIGH);

  pinMode(MOTOR_PIN, OUTPUT);

  pinMode(ENCODER_BTN, INPUT);
  pinMode(ENCODER_CLK, INPUT);
  pinMode(ENCODER_DT, INPUT);

  attachInterrupt(ENCODER_CLK, encoder_irq, CHANGE);
  attachInterrupt(ENCODER_BTN, button_irq, FALLING);
}

Setup

A função setup() inicializa a serial para debugging, configura pinos e interrupções, prepara o ecrã e desenha a etiqueta estática. Após setup(), o dispositivo está pronto para responder a movimentos do encoder e pressões do botão.

void setup(void) {
  Serial.begin(115200);
  init_pins();
  init_display();
  draw_text();
}

Loop Principal

O loop() é intencionalmente minimalista. Só reage quando uma ISR marcou has_changed. Quando essa flag está ativa, limpa-a, impõe os limites de brilho com feedback tátil se necessário, e atualiza o número no ecrã e o PWM da luz de fundo. Este padrão evita redesenhos e escritas PWM desnecessárias, mantendo a UI rápida e eficiente em energia.

void loop() {
  if (has_changed) {
    has_changed = false;
    limit_brightness();
    update_brightness();
  }
}

Como o Encoder Controla o Brilho e o Feedback Tátil

O encoder fornece dois sinais em onda quadrada, CLK e DT, cuja fase relativa indica a direção. Em cada transição do CLK, a ISR compara DT com o novo nível CLK para decidir se adiciona ou subtrai um ao brightness. Quando o utilizador ultrapassa os limites, limit_brightness() vibra o motor por 50 milissegundos e limita o valor para ficar dentro de [0, 100]. O valor numérico no ecrã reflete sempre o número limitado, enquanto o brilho visível real vem do PWM no TFT_BLK, que é definido para o ciclo de trabalho mapeado ou zero quando o botão desligou o ecrã.

Código para Ecrã Táctil

No próximo exemplo de código aprenderá a usar o ecrã táctil do display. Vamos escrever o texto “Touch” no centro do ecrã e desenhar um círculo preto onde o ecrã for tocado. A foto abaixo mostra o ecrã do controlador antes e depois de alguns toques:

Como antes, sugiro que dê uma vista rápida ao código completo antes de discutirmos os detalhes:

#include <Wire.h>
#include <Arduino_GFX_Library.h>

#define TFT_BLK 45
#define TFT_RES 21
#define TFT_CS 1
#define TFT_MOSI 2
#define TFT_MISO -1
#define TFT_SCLK 42
#define TFT_DC 46

#define TOUCH_INT 40
#define TOUCH_SDA 38
#define TOUCH_SCL 39
#define TOUCH_RST 18

#define MOTOR_PIN 41

Arduino_ESP32SPI *bus = new Arduino_ESP32SPI(TFT_DC, TFT_CS, TFT_SCLK,
                                             TFT_MOSI, TFT_MISO, HSPI, true);
Arduino_GFX *gfx = new Arduino_GC9A01(bus, TFT_RES, 0 /* rotation */, true /* IPS */);

int read_touch(int *x, int *y) {
  byte data_raw[7];
  i2c_read(0x15, 0x02, data_raw, 7);
  int event = data_raw[1] >> 6;
  if (event == 2) {
    *x = (int)data_raw[2] + (int)(data_raw[1] & 0x0f) * 256;
    *y = (int)data_raw[4] + (int)(data_raw[3] & 0x0f) * 256;
    return 1;
  } 
  return 0;  
}

int i2c_read(uint16_t addr, uint8_t reg_addr, uint8_t *reg_data, uint32_t length) {
  Wire.beginTransmission(addr);
  Wire.write(reg_addr);
  if (Wire.endTransmission(true))
    return -1;
  Wire.requestFrom(addr, length, true);
  for (int i = 0; i < length; i++) {
    *reg_data++ = Wire.read();
  }
  return 0;
}

void init_pins() {
  pinMode(TFT_BLK, OUTPUT);
  digitalWrite(TFT_BLK, HIGH);

  Wire.begin(TOUCH_SDA, TOUCH_SCL);
  pinMode(MOTOR_PIN, OUTPUT);
}

void init_display() {
  gfx->begin();
  gfx->fillScreen(WHITE);
  gfx->setTextColor(BLACK);  
  gfx->setTextSize(3);
  gfx->setCursor(80, 105);
  gfx->print(F("Touch"));
}

void setup(void) {
  Serial.begin(115200);
  init_pins();
  init_display();
}

void loop() {
  static int x, y;
  if (read_touch(&x, &y) == 1) {
    gfx->fillCircle(x, y, 5, BLACK);
    digitalWrite(MOTOR_PIN, HIGH);
    delay(20);
    digitalWrite(MOTOR_PIN, LOW);
  }
}

Importações

O programa inclui a biblioteca I²C para comunicar com o controlador táctil e a mesma biblioteca gráfica que viu anteriormente para desenhar no ecrã circular GC9A01. A biblioteca Wire fornece begin, beginTransmission, write, endTransmission, e requestFrom para acesso a nível de registo I²C, enquanto Arduino_GFX_Library.h traz o driver do ecrã, primitivas de desenho e constantes de cor que usou antes.

#include <Wire.h>
#include <Arduino_GFX_Library.h>

Constantes de Pinos e Hardware

Os pinos do ecrã espelham o sketch anterior e identificam a luz de fundo, reset, chip-select SPI e linhas do bus, e o pino D/C. Constantes adicionais definem a interrupção do controlador táctil, SDA, SCL e pinos de reset. O pino do motor controla novamente o motor de vibração tátil. Neste sketch, as linhas de interrupção e reset do toque são definidas para completude, mas só as linhas I²C são realmente usadas.

#define TFT_BLK 45
#define TFT_RES 21
#define TFT_CS 1
#define TFT_MOSI 2
#define TFT_MISO -1
#define TFT_SCLK 42
#define TFT_DC 46

#define TOUCH_INT 40
#define TOUCH_SDA 38
#define TOUCH_SCL 39
#define TOUCH_RST 18

#define MOTOR_PIN 41

Objetos do Bus e Driver do Ecrã

A configuração do ecrã segue o mesmo padrão de antes. Um objeto Arduino_ESP32SPI liga o periférico HSPI do ESP32 com os pinos escolhidos e DMA ativado, e um objeto Arduino_GC9A01 controla o painel IPS redondo de 1,28″. O objeto resultante gfx expõe a mesma API de desenho que já usou.

Arduino_ESP32SPI *bus = new Arduino_ESP32SPI(TFT_DC, TFT_CS, TFT_SCLK,
                                             TFT_MOSI, TFT_MISO, HSPI, true);
Arduino_GFX *gfx = new Arduino_GC9A01(bus, TFT_RES, 0 /* rotation */, true /* IPS */);

Leitor de Toque: read_touch

Esta função interroga o controlador táctil via I²C, analisa um pacote e devolve as coordenadas do toque através de parâmetros ponteiro. Primeiro lê sete bytes começando no registo 0x02 do endereço do dispositivo 0x15. O controlador codifica um “evento” nos dois bits superiores do byte alto de X; deslocar seis bits para a direita obtém esse código de evento.

Só quando o evento é igual a 2 a função trata o pacote como um contacto válido do dedo e calcula as coordenadas. A posição X é formada tomando o byte baixo e adicionando os quatro bits inferiores do byte alto multiplicados por 256, reconstruindo uma coordenada típica de 12 bits; Y é decodificado da mesma forma a partir dos seus bytes alto e baixo.

Quando um toque válido é decodificado, a função armazena x e y através dos ponteiros e retorna 1. Para qualquer outro evento retorna 0.

int read_touch(int *x, int *y) {
  byte data_raw[7];
  i2c_read(0x15, 0x02, data_raw, 7);
  int event = data_raw[1] >> 6;
  if (event == 2) {
    *x = (int)data_raw[2] + (int)(data_raw[1] & 0x0f) * 256;
    *y = (int)data_raw[4] + (int)(data_raw[3] & 0x0f) * 256;
    return 1;
  } 
  return 0;  
}

Auxiliar I²C: i2c_read

Este auxiliar executa uma transação comum de “escrever registo, depois ler dados”. Começa uma transmissão para o endereço de 7 bits, escreve o endereço do registo e verifica endTransmission. Um resultado diferente de zero indica erro e retorna -1. Depois solicita o número especificado de bytes e lê-os de Wire.read() para o buffer do chamador, retornando 0 para sucesso. Esta é a peça de baixo nível que read_touch usa para obter o pacote de toque.

int i2c_read(uint16_t addr, uint8_t reg_addr, uint8_t *reg_data, uint32_t length) {
  Wire.beginTransmission(addr);
  Wire.write(reg_addr);
  if (Wire.endTransmission(true))
    return -1;
  Wire.requestFrom(addr, length, true);
  for (int i = 0; i < length; i++) {
    *reg_data++ = Wire.read();
  }
  return 0;
}

Inicialização dos Pinos e Bus: init_pins

A configuração GPIO espelha o sketch anterior para a luz de fundo e motor. O pino da luz de fundo é configurado como saída e ativado para que o ecrã seja visível imediatamente. O pino do motor é configurado como saída pronto para pulsos táteis. O bus I²C é iniciado nos pinos SDA e SCL especificados usando Wire.begin(TOUCH_SDA, TOUCH_SCL), que seleciona os pinos alternativos do ESP32 definidos para o controlador táctil. Nenhuma interrupção de toque é ligada aqui; este sketch opta por polling simples.

void init_pins() {
  pinMode(TFT_BLK, OUTPUT);
  digitalWrite(TFT_BLK, HIGH);

  Wire.begin(TOUCH_SDA, TOUCH_SCL);
  pinMode(MOTOR_PIN, OUTPUT);
}

Inicialização do Ecrã: init_display

A inicialização do ecrã segue os mesmos passos que viu antes. O driver gfx é iniciado, o ecrã é limpo para branco e a cor do texto é definida para preto. Uma etiqueta amigável “Touch” é renderizada no meio com tamanho de texto maior para indicar a interação esperada. O macro F() mantém o literal na memória flash.

void init_display() {
  gfx->begin();
  gfx->fillScreen(WHITE);
  gfx->setTextColor(BLACK);  
  gfx->setTextSize(3);
  gfx->setCursor(80, 105);
  gfx->print(F("Touch"));
}

Setup

O arranque é semelhante em estrutura ao sketch anterior. A porta serial é aberta para debugging, os pinos e o bus I²C são inicializados, e o ecrã é preparado e rotulado. Após setup retornar, o dispositivo está pronto para interrogar toques e desenhar feedback.

void setup(void) {
  Serial.begin(115200);
  init_pins();
  init_display();
}

Loop

O loop principal interroga continuamente o controlador táctil e reage imediatamente quando um contacto válido é reportado. As variáveis x e y são declaradas static para que o seu armazenamento persista entre iterações, permitindo que read_touch escreva através dos ponteiros.

Quando read_touch retorna 1, um círculo preto preenchido de raio cinco pixels é desenhado nas coordenadas reportadas para marcar o toque. Um pulso curto de 20 milissegundos ativa o motor de vibração para fornecer confirmação tátil do toque.

void loop() {
  static int x, y;
  if (read_touch(&x, &y) == 1) {
    gfx->fillCircle(x, y, 5, BLACK);
    digitalWrite(MOTOR_PIN, HIGH);
    delay(20);
    digitalWrite(MOTOR_PIN, LOW);
  }
}

Como Isto Se Relaciona com o Sketch Anterior

A criação do ecrã, inicialização, API de desenho e controlo do motor seguem os mesmos padrões que já usou. Em vez de interrupções do encoder e uma flag has_changed, este sketch interroga o controlador táctil via I²C e ativa o feedback tátil em cada contacto válido do dedo, em vez de nos limites de brilho.

A luz de fundo é simplesmente ativada e não modulada por PWM, porque não há estado de brilho aqui. Os pinos de interrupção e reset do toque são definidos mas não usados; adicionar uma interrupção externa em TOUCH_INT poderia permitir dormir entre toques, enquanto usar TOUCH_RST poderia realizar um reset hardware do IC táctil se necessário.

Conclusões

Neste tutorial aprendeu como começar com o Matouch 1.28″ ToolSet_Controller. Os dois exemplos de código sobre o ecrã, o ecrã táctil, o codificador rotativo e o feedback tátil devem facilitar o arranque do seu próprio projeto.

Não discutimos Wi-Fi, Bluetooth 5.0, o cartão SD ou o suporte RTC neste tutorial. Mas pode encontrar exemplos em Makerfabs’s Github repo for the Matouch display. Se quiser aprender mais sobre codificadores rotativos, dê uma vista de olhos no nosso tutorial How To Interface A Quadrature Rotary Encoder.

A base quadrada do Matouch 1.28″ ToolSet_Controller pode ser um pouco grande para algumas aplicações. Se procura um ecrã semelhante com codificador rotativo mas base redonda, veja o CrowPanel 1.28inch-HMI ESP32 Rotary Display. E se precisar apenas de um ecrã redondo (sem o anel codificador rotativo), o tutorial Digital Clock on CrowPanel 1.28″ Round Display pode ser útil.

Caso contrário, sinta-se à vontade para deixar qualquer dúvida na secção de comentários.

Boas experiências a criar 😉