# firmware.ino

- Project: [sla](https://flashesp.com/explore/2e2UWbcf0IO0ZN7S0iCJD.md) by artrabelo
- Board: ESP32-WROOM-DA Module
- Language: Arduino (C++)
- Web page: https://flashesp.com/explore/2e2UWbcf0IO0ZN7S0iCJD/files/y9qmN7HVvn60zK7dFyiJL

```cpp
/*
  =====================================================================
  MACRO PAD - ESP32 CYD 2.8" (2 USB)
  =====================================================================
  Mostra uma grade de 20 "botões de app" na tela touch.
  Ao tocar em um botão, o ESP32 manda um comando pela porta Serial
  (o mesmo cabo USB usado para gravar o código).

  Um script Python rodando no PC (pc_listener.py) fica "escutando"
  essa porta e executa a ação correspondente: abrir um programa,
  abrir um site, pesquisar algo, ou mutar o Discord.

  BIBLIOTECAS NECESSÁRIAS (Gerenciador de Bibliotecas do Arduino IDE):
    - TFT_eSPI          (por Bodmer)
    - XPT2046_Touchscreen (por Paul Stoffregen)

  IMPORTANTE: antes de compilar, copie o arquivo User_Setup.h desta
  pasta para dentro da pasta da biblioteca TFT_eSPI (substituindo o
  original). Veja o README.md para o passo a passo completo.
  =====================================================================
*/

#include <SPI.h>
#include <TFT_eSPI.h>
#include <XPT2046_Touchscreen.h>

// ---------------------- Pinagem do TOUCH (XPT2046) ----------------------
#define XPT2046_IRQ  36
#define XPT2046_MOSI 32
#define XPT2046_MISO 39
#define XPT2046_CLK  25
#define XPT2046_CS   33

// ---------------------- Pinagem do LED RGB (ativo em LOW) ---------------
#define LED_R 4
#define LED_G 16
#define LED_B 17

// ---------------------- Calibração do touch ------------------------------
// Se os toques estiverem "trocados" ou fora do lugar, ajuste estes valores.
#define TS_MINX 200
#define TS_MAXX 3800
#define TS_MINY 200
#define TS_MAXY 3800

SPIClass touchSPI = SPIClass(VSPI);
XPT2046_Touchscreen ts(XPT2046_CS, XPT2046_IRQ);
TFT_eSPI tft = TFT_eSPI();

// ---------------------- Layout da grade ----------------------------------
const int COLS = 5;
const int ROWS = 4;
const int SCREEN_W = 320;
const int SCREEN_H = 240;
const int CELL_W = SCREEN_W / COLS;
const int CELL_H = SCREEN_H / ROWS;
const int PADDING = 4;

// Tipos de ícone desenhado dentro do botão
enum IconType { ICON_NONE = 0, ICON_PLAY = 1, ICON_CHAT = 2, ICON_STAR = 3 };

struct AppButton {
  const char* id;     // ID enviado via Serial - deve casar com o dicionário do pc_listener.py
  const char* label;  // Texto mostrado na tela
  uint16_t color;      // Cor de fundo do botão
  IconType icon;        // Ícone desenhado
};

// =====================================================================
// >>> EDITE AQUI para trocar nome / cor / ícone de cada botão <<<
// O "id" é o que importa de verdade: ele tem que ser igual à chave
// usada no dicionário ACTIONS do arquivo pc_listener.py
// =====================================================================
AppButton apps[COLS * ROWS] = {
  {"PRIME",        "Prime",     0x04DF, ICON_PLAY},  // azul Prime Video
  {"DISCORD",      "Discord",   0x5A9E, ICON_CHAT},  // roxo/blurple Discord
  {"MUTE_DISCORD", "Mute Disc", 0x4A49, ICON_CHAT},
  {"BTN4",         "App 4",     TFT_DARKGREY, ICON_NONE},
  {"BTN5",         "App 5",     TFT_DARKGREY, ICON_NONE},

  {"BTN6",         "App 6",     TFT_DARKGREY, ICON_NONE},
  {"BTN7",         "App 7",     TFT_DARKGREY, ICON_NONE},
  {"BTN8",         "App 8",     TFT_DARKGREY, ICON_NONE},
  {"BTN9",         "App 9",     TFT_DARKGREY, ICON_NONE},
  {"BTN10",        "App 10",    TFT_DARKGREY, ICON_NONE},

  {"BTN11",        "App 11",    TFT_DARKGREY, ICON_NONE},
  {"BTN12",        "App 12",    TFT_DARKGREY, ICON_NONE},
  {"BTN13",        "App 13",    TFT_DARKGREY, ICON_NONE},
  {"BTN14",        "App 14",    TFT_DARKGREY, ICON_NONE},
  {"BTN15",        "App 15",    TFT_DARKGREY, ICON_NONE},

  {"BTN16",        "App 16",    TFT_DARKGREY, ICON_NONE},
  {"BTN17",        "App 17",    TFT_DARKGREY, ICON_NONE},
  {"BTN18",        "App 18",    TFT_DARKGREY, ICON_NONE},
  {"BTN19",        "App 19",    TFT_DARKGREY, ICON_NONE},
  {"BTN20",        "App 20",    TFT_DARKGREY, ICON_NONE},
};

unsigned long lastPressTime = 0;
const unsigned long DEBOUNCE_MS = 350;
bool wasTouched = false;

// ---------------------------------------------------------------------
void setLed(bool r, bool g, bool b) {
  // LED é ativo em LOW: false = aceso, true = apagado
  digitalWrite(LED_R, r ? LOW : HIGH);
  digitalWrite(LED_G, g ? LOW : HIGH);
  digitalWrite(LED_B, b ? LOW : HIGH);
}

// ---------------------------------------------------------------------
void drawIcon(int cx, int cy, IconType icon, uint16_t color) {
  uint16_t ic = TFT_WHITE;
  switch (icon) {
    case ICON_PLAY:
      // triangulo de "play" (video)
      tft.fillTriangle(cx - 8, cy - 10, cx - 8, cy + 10, cx + 10, cy, ic);
      break;
    case ICON_CHAT:
      // balão de chat genérico com dois "olhos"
      tft.fillRoundRect(cx - 14, cy - 9, 28, 18, 6, ic);
      tft.fillTriangle(cx - 4, cy + 8, cx + 2, cy + 8, cx - 6, cy + 14, ic);
      tft.fillCircle(cx - 6, cy, 2, color);
      tft.fillCircle(cx + 6, cy, 2, color);
      break;
    case ICON_STAR:
      tft.fillCircle(cx, cy, 8, ic);
      break;
    default:
      break;
  }
}

// ---------------------------------------------------------------------
void drawButton(int index, bool pressed) {
  int col = index % COLS;
  int row = index / COLS;
  int x = col * CELL_W + PADDING / 2;
  int y = row * CELL_H + PADDING / 2;
  int w = CELL_W - PADDING;
  int h = CELL_H - PADDING;

  AppButton &b = apps[index];
  uint16_t bg = pressed ? TFT_WHITE : b.color;

  tft.fillRoundRect(x, y, w, h, 6, bg);
  tft.drawRoundRect(x, y, w, h, 6, TFT_BLACK);

  if (b.icon != ICON_NONE) {
    drawIcon(x + w / 2, y + h / 2 - 8, b.icon, bg);
  }

  tft.setTextDatum(BC_DATUM); // base-center
  tft.setTextColor(pressed ? TFT_BLACK : TFT_WHITE, bg);
  tft.setTextFont(1);
  tft.setTextSize(1);
  tft.drawString(b.label, x + w / 2, y + h - 4);
}

void drawGrid() {
  tft.fillScreen(TFT_BLACK);
  for (int i = 0; i < COLS * ROWS; i++) {
    drawButton(i, false);
  }
}

// ---------------------------------------------------------------------
void sendCommand(const char* id) {
  Serial.print("CMD:");
  Serial.println(id);
}

// ---------------------------------------------------------------------
void setup() {
  Serial.begin(115200);

  pinMode(LED_R, OUTPUT);
  pinMode(LED_G, OUTPUT);
  pinMode(LED_B, OUTPUT);
  setLed(false, false, false);

  tft.init();
  tft.setRotation(1); // 1 ou 3 = paisagem (320x240). Troque se a imagem sair de cabeça pra baixo.

  touchSPI.begin(XPT2046_CLK, XPT2046_MISO, XPT2046_MOSI, XPT2046_CS);
  ts.begin(touchSPI);
  ts.setRotation(1);

  drawGrid();
  setLed(false, true, false); // pisca verde rápido = pronto
  delay(150);
  setLed(false, false, false);
}

// ---------------------------------------------------------------------
void loop() {
  bool touchedNow = ts.touched();

  if (touchedNow && !wasTouched) {
    unsigned long now = millis();
    if (now - lastPressTime > DEBOUNCE_MS) {
      TS_Point p = ts.getPoint();

      // Mapeia coordenadas cruas do touch para pixels da tela
      int x = map(p.x, TS_MINX, TS_MAXX, 0, SCREEN_W);
      int y = map(p.y, TS_MINY, TS_MAXY, 0, SCREEN_H);
      x = constrain(x, 0, SCREEN_W - 1);
      y = constrain(y, 0, SCREEN_H - 1);

      int col = x / CELL_W;
      int row = y / CELL_H;
      int index = row * COLS + col;

      if (index >= 0 && index < COLS * ROWS) {
        drawButton(index, true);
        setLed(false, false, true); // azul = comando enviado
        sendCommand(apps[index].id);
        delay(120);
        drawButton(index, false);
        setLed(false, false, false);
      }

      lastPressTime = now;
    }
  }

  wasTouched = touchedNow;
}
```
