Aula — 03 de Novembro (Segunda feira) - theedwilk/JoystickRaspberry-HandsOn-DevTitans GitHub Wiki

Aula — 03 de novembro — Montagem do protótipo no protoboard e Firmwares testados no ESP32

Resumo:
Registro da aula do dia 03/11 — montagem do protótipo no protoboard, firmwares testados no ESP32 e a versão do módulo de kernel (joy_driver_module.c.save) usada para testes com evtest. Este documento descreve o material, montagem, firmwares, driver, procedimentos de build/instalação e logs de teste.

Objetivo da Aula

Documentar o estado do protótipo físico do joystick e validar a leitura dos botões e d-pad (analógico) pelo ESP32, bem como testar a captura desses dados no Linux via driver de kernel que interpreta um protocolo serial/bit-banged.

Material Utilizado

  • ESP32 DevKit v1
  • Protoboard
  • Joystick analógico (módulo)
  • 4 botões push (mais botões START / SELECT / ANALOG)
  • Resistores 10 kΩ (pull-down ou pull-up conforme montagem)
  • Cabos jumper
  • Máquina com Linux / Raspberry Pi / Orange Pi para testes do driver

Esquemático / Montagem (Fritzing)

  • Arquivo do projeto Fritzing: Joystick02.fzz
  • Imagem da montagem: JoystickDevTitans_bb.png

Firmwares testados (principais versões utilizadas)

1. firmware.ino — versão 02/11 (bit-banged sync + envio 16 bits)

Trechos principais / comportamento:

Define pinos de controle:

  • Define pinos de controle:

#define TX_PIN 5 #define CLK_PIN 4 #define SYNC_PIN 2

  • Pinos dos botões e eixos:

const int PIN_UP = 36; const int PIN_RIGHT = 39; const int PIN_DOWN = 34; const int PIN_LEFT = 35; const int PIN_START = 32; const int PIN_SELECT = 33; const int PIN_ANALOGB = 25;

const int PIN_AXIS_X = 26; const int PIN_AXIS_Y = 27;

  • Leitura com debounce (DEBOUNCE_MS = 25) e consolidação em allStates[11] (7 botões + 4 dpad).
  • Envio: sendJoystickData() monta dataToWrite com 11 bits usados e chama write_2_bytes(dataToWrite) — write_2_bytes implementa bit-banging sincronizado via SYNC_PIN e escreve bits em TX_PIN enquanto alterna CLK_PIN.
  • Serial: imprime 0/1 enquanto transmite (útil para debug).

Comportamento observado no Serial Monitor:

Joystick ESP32 iniciado.
UP,RIGHT,DOWN,LEFT,START,SELECT,ANALOG,DPAD_UP,DPAD_DOWN,DPAD_LEFT,DPAD_RIGHT
0000000010100000
0000000010100000
...

serial monitor

projeto

2. ControlJoystick02.ino — versão 03/11 (envia apenas quando há mudança)

Principais diferenças:

  • Usa pinos digitais A0/A1 para eixos (ou ports analógicos em uma placa diferente).

  • Mantém lastStates[11] e só transmite quando algo muda (stateChanged).

  • Protocolo serial simplificado: envia linha com prefixo J e valores separados por vírgula:

Serial.print("J");
for (i=0;i<7;i++){ Serial.print(allStates[i]); Serial.print(","); }
for (i=7;i<11;i++){ Serial.print(allStates[i]); Serial.print(","); }
Serial.println();

  • Baud de teste: 115200 (dependendo da versão)

  • Ajuda a reduzir tráfego serial e facilita parsing no lado do kernel/usuário.

Driver de Kernel (versão driver/joy_driver_module.c.save usada em 03/11)

Arquivos relevantes:

  • driver/joy_driver_module.c.save (versão de teste)

  • Arquivo contém: inicialização de input_device, timer, rotina read_2_bytes_uart_module() bit-banging para ler 16 bits via GPIO, processamento de bits para input_report_key().

Pontos chave do driver:

  • Define máscaras de botões e mapeia para códigos do input subsystem:
{A_BUTTON_MASK, BTN_SOUTH},
{B_BUTTON_MASK, BTN_EAST},
...

  • Usa gpio_to_desc(RX_GPIO_NUM) e gpiod_to_irq() para configurar interrupção no pino RX (borda de descida = start bit).

  • read_2_bytes_uart_module() — faz leitura bit-a-bit com udelay() (tempo por bit calculado a partir de BAUD_RATE).

  • processData() — compara input_data vs previous_data e emite input_report_key(...); input_sync(...);

  • Usa timer (joy_timer) com LOOP_INTERVAL_MS para loop periódico.

Resumo: Driver tenta decodificar a transmissão bit-banged enviada pelo ESP32 e transformar em eventos de botão do kernel.

Build e Instalação (passo a passo)

Firmware (ESP32)

1. Abrir o sketch correspondente no Arduino IDE (firmware.ino ou ControlJoystick02.ino).

2. Selecionar placa: ESP32 Dev Module (ou Node32s conforme versão).

3. Selecionar porta serial correta.

4. Upload (Ctrl+U).

Driver de Kernel (modo teste, em máquina Linux com headers)

OBSERVAÇÃO: Para compilar e inserir módulos no kernel do AOSP/Raspberry exige compatibilidade de versão. Além de uma máquina Linux com headers do kernel compatíveis.

1. Navegue até a pasta do driver:

cd driver
make

2. Inserir o módulo: sudo insmod joy_driver_module.ko

3. Verificar mensagens: dmesg | tail -n 40

4. Remover: sudo rmmod joy_driver_module

Testes e Logs

1. Serial Monitor (ESP32)

  • Serial prints mostram pacotes binários como 0000000010100000 (cada caractere é bit enviado por write_2_bytes() ou por Serial).

  • Nas versões com prefixo J, as linhas ficam no formato: J1,0,0,0,0,0,0,1,0,1,0,

2. evtest / dmesg (driver)

  • Ao carregar o driver e executando evtest /dev/input/eventX, foram observados eventos:
Event: time 1762286395.933030, type 1 (EV_KEY), code 304 (BTN_SOUTH), value 1
Event: time 1762286396.153005,    ---- SYN_REPORT ----
Event: time 1762286396.703015, type 1 (EV_KEY), code 305 (BTN_EAST), value 1
...
  • O terminal mostrou repetidamente joy_driver_module: Dados Síncronos Recebidos: 1280 = 0x0500 (mensagens de debug do driver).

O driver está recebendo dados e gerando eventos EV_KEY para os botões mapeados (BTN_SOUTH, BTN_EAST, BTN_NORTH, BTN_WEST, DPAD_* etc). O evtest confirma que eventos chegam ao subsistema de input.

Mudanças / Changelog (versão antiga → versão atual)

Firmware: firmware.ino (24/09) → firmware.ino (02/11) → ControlJoystick02.ino (03/11)

24/09 (versão inicial)

  • Leitura analógica e digital básica:
    • readAnalogs() fazia analogRead() e reportava valores X/Y (divididos por 10).
    • readButtons() fazia digitalRead() e imprimia mudanças (Serial.print("A:"), etc).
  • Baud em 115200 (debug rápido).
  • Envio contínuo de eventos (cada mudança era logada em serial indiscriminadamente).
  • Foco em debug dos valores analógicos e estados dos botões (linhas tipo X:, Y:, A:1).

02/11 (introdução do protocolo bit-banged)

Principais mudanças introduzidas:

  • Implementado protocolo bit-banged sincronizado com pinos:

    #define TX_PIN      5
#define CLK_PIN     4
#define SYNC_PIN    2

  • Novo método de transmissão write_2_bytes(uint16_t data) que:

    • Sincroniza com SYNC_PIN (espera bordas para garantir alinhamento).
    • Alterna CLK_PIN e escreve bits em TX_PIN.
    • Imprime 0/1 no Serial para debug durante a escrita (útil para análise temporal).

  • Estrutura de leitura:

    • readButtons() com debounce (25 ms).
    • readDPadFromAnalog() que converte eixos analógicos em 4 estados D-Pad.
    • readAllStates() consolida 11 sinais (7 botões + 4 dpad) em allStates[].

  • Envio: sendJoystickData() monta dataToWrite com bits e chama write_2_bytes(dataToWrite).

  • Comportamento observado: Serial mostra strings binárias como 0000000010100000 (debug do pacote enviado).

  • Objetivo: criar protocolo robusto para que o host (driver) leia bit-a-bit via GPIO.

Impacto: Introduziu sincronização por hardware e timing sensível; tornou o link mais determinístico, mas dependente do timing (baud) e da estabilidade do SYNC_PIN.

03/11 (ControlJoystick02.ino) — versão usada em aula Principais mudanças em relação à 02/11:

  • Envio somente quando há mudança de estado:
    • Mantém lastStates[11] e só chama sendJoystickData() se stateChanged == true.
    • Reduz tráfego serial e processamento no host.
  • Formato de saída textual:
    • Envia linhas com prefixo J e valores separados por vírgula: J1,0,0,0,0,0,0,1,0,1,0,
    • Facilita parsing do lado do host
  • Pinos e constantes adaptados:
    • Usa pinos digitais simples (ex.: const int PIN_UP = 2; ...) e PIN_AXIS_X = A0 etc — versão mais portátil para placas que exponham A0/A1.
  • Baud e debounce:
    • Serial em 115200 no exemplo; debounce mantém 25 ms; delay reduzido a 10 ms no loop.
  • Objetivo: tornar comunicação mais eficiente (menos ruído) e facilitar parsing no host sem exigir bit-bang sincronizado.