# 3. Proposta de reprodução com ESP32 [Voltar ao índice](README.md) ## 3.1 Descrição conceitual A reprodução proposta é um **macropad split de atalhos programáveis**, que reaproveita a arquitetura do Corne (duas metades, matriz de teclas com diodos e comunicação serial entre as metades) em um MVP construído com **ESP32 WROOM** e firmware próprio em **C (ESP-IDF)**. Cada tecla dispara um atalho ou macro no PC, útil para acelerar fluxos repetitivos, como atalhos de editor, navegação e comandos de terminal. A comunicação é **inteiramente serial** (*full serial*): ``` metade escrava --(serial / UART)--> metade mestre --(serial / USB)--> PC (daemon) ``` **Por que ESP32 WROOM?** O módulo do kit da disciplina oferece: - GPIOs suficientes para a matriz de botões; - UART nativa para o link entre as metades (sobre cabo TRRS); - conexão serial com o PC pelo chip USB-serial do DevKit (CP2102 / CH340), que cria uma porta serial virtual; - suporte ao ESP-IDF, permitindo escrever todo o firmware em C. **Conexão com o PC.** O DevKit liga ao PC por um **cabo USB comum** (o mesmo usado para gravar o firmware). Esse cabo alimenta a placa e, através do chip USB-serial, expõe uma porta serial (`/dev/ttyUSB0` no Linux). A metade mestre envia os eventos de tecla como mensagens seriais simples (por exemplo, `KEY:SEND`). Um **daemon escrito em C** no PC lê a porta serial com `termios` e injeta o atalho correspondente usando o subsistema **`uinput`** do kernel Linux, que cria um teclado virtual e funciona tanto em X11 quanto em Wayland. **Diferença para o produto original.** O Corne usa USB HID (reconhecido como teclado, sem software extra). A nossa abordagem troca o HID por **serial + daemon**: o firmware embarcado fica mais simples (sem pilha USB-HID nem BLE), ao custo de um pequeno programa rodando no PC. ## 3.2 Mapeamento Corne → ESP32 | Função do Corne | Componente original | No MVP com ESP32 | |-----------------|---------------------|-------------------| | Teclas | Chaves mecânicas MX | Botões em matriz | | Anti-ghosting | Diodo 1N4148 | Diodo 1N4148 (mantido) | | Controle central | ATmega32U4 / nRF52840 | ESP32 WROOM-32 | | Link entre metades | UART via TRRS / BLE | UART via TRRS (serial) | | Interface com o PC | USB HID / BLE HID | Serial (chip USB-serial) + daemon | | Firmware | QMK / ZMK | Firmware próprio em C (ESP-IDF) | ## 3.3 Componentes do MVP e a lista da disciplina Todos os componentes da reprodução proposta correspondem a itens da [Lista de Sensores e Atuadores Disponíveis](../Lista_de_Sensores.md) da disciplina. As chaves mecânicas do Corne original são representadas, no MVP, por **botões** (eletricamente idênticos, contato momentâneo), e os demais componentes têm correspondência direta: | Componente do Corne | Item da lista da disciplina | |---------------------|-----------------------------| | Chave mecânica (tecla) | Botão | Assim, o MVP é construído inteiramente com componentes simples disponíveis no kit, mantendo a fidelidade funcional ao produto original. ## 3.4 Diagrama de blocos do MVP ``` ┌───────────────────────────────────────────────────────────────┐ │ METADE ESQUERDA (escrava) │ │ │ │ [B1][B2][B3] Botões em matriz 2×3 │ │ [B4][B5][B6] + diodos 1N4148 │ │ │ │ │ ┌────▼────────────────────┐ │ │ │ ESP32 WROOM-32 │ │ │ │ Varredura de matriz │ │ │ │ Debounce por software │ │ │ │ UART TX ──────────────┼──── TX ─────┐ │ │ └─────────────────────────┘ │ TRRS │ └──────────────────────────────────────────┼────────────────────┘ │ ┌──────────────────────────────────────────┼────────────────────┐ │ METADE DIREITA (mestre) │ │ │ │ │ │ [B7][B8][B9] Botões em matriz 2×3 │ │ │ [B10][B11][B12] + diodos 1N4148 │ │ │ │ │ │ │ ┌────▼────────────────────┐ │ │ │ │ ESP32 WROOM-32 │ │ │ │ │ Varredura de matriz │ │ │ │ │ UART1 RX ◄───────────┼──── RX ─────┘ │ │ │ Agregação de eventos │ │ │ │ Protocolo serial │ │ │ │ UART0 TX (USB-serial) ├── cabo USB (CP2102/CH340) ─► PC │ │ │ │ porta serial virtual │ │ └─────────────────────────┘ │ └───────────────────────────────────────────────────────────────┘ │ ┌────────────▼──────────────┐ │ PC — daemon em C │ │ termios (lê a serial) │ │ uinput (injeta atalho) │ └───────────────────────────┘ ``` ## 3.5 Layout de teclas proposto O layout abaixo é um exemplo voltado para um fluxo de terminal e edição; como o firmware é próprio, qualquer tecla é totalmente remapeável. ``` ESQUERDA (controle) DIREITA (ação) ┌──────┬──────┬──────┐ ┌──────┬──────┬──────┐ │ Esc │ Layer│ Novo │ │ Send │ Aceit│ Rejei│ │ │ │ │ │Enter │ │ │ ├──────┼──────┼──────┤ ├──────┼──────┼──────┤ │ Up │ Down │ Alt │ │ Copy │ Clear│ ? │ └──────┴──────┴──────┘ └──────┴──────┴──────┘ ``` Cada tecla envia uma mensagem serial (`KEY:xxx`) para o daemon no PC, que injeta o atalho correspondente. ## 3.6 Limitações e desafios | Limitação | Detalhe | |-----------|---------| | Sem USB HID nativo | O ESP32 WROOM-32 não tem controlador USB; a comunicação com o PC é serial, não plug-and-play | | Daemon obrigatório no PC | A abordagem serial exige um programa em C lendo a porta e injetando os atalhos | | Firmware do zero | Sem QMK/ZMK no ESP32; é preciso reimplementar matriz, debounce e o protocolo serial | | Sincronização mestre/escravo | O protocolo serial entre as metades precisa tratar latência e erros | | Dependência de driver | O chip USB-serial (CP2102/CH340) pode exigir driver no Windows; Linux e macOS têm suporte nativo | | Alimentação do escravo | A corrente disponível pela linha VCC do TRRS é limitada | [Voltar ao índice](README.md)