16 Botões, 1 Lâmpada WiFi e um Agente de AI: Projeto de Sexta-Feira

Como eu combinei uma lâmpada WiFi de $15, uma mesa controladora MIDI de 16 botões coloridos e o Kiro CLI para criar um controlador de cores físico — projeto de sexta-feira para se divertir no fim de semana!

Fala galera! Há 15 anos atrás eu criei o jHome Automation, um sistema de automação residencial baseado em Arduino com Java da época que nem chamávamos de Internet of Things. De lá pra cá, muita coisa mudou. Os módulos WiFi se popularizaram, o preço caiu absurdamente, e a inteligência artificial mudou completamente a velocidade com que a gente consegue hackear as coisas.

Neste post eu vou mostrar em detalhes como combinei uma lâmpada WiFi de $15, uma mesa controladora MIDI com 16 botões coloridos e o Kiro CLI para criar um controlador de cores físico — um projetinho de sexta-feira que você pode replicar no fim de semana.

O Hardware

Kauf Bulb — a lâmpada inteligente de $15

A Kauf Bulb é uma lâmpada WiFi que custa cerca de $15 na Amazon — apenas uns $4 a mais que uma lâmpada WiFi convencional. O diferencial dela é que ela vem com um ESP32 dentro e já roda o firmware ESPHome, o que significa que:

• Você consegue controlar via REST na sua rede local (sem nuvem!)
• Você pode configurar um broker MQTT e controlar remotamente
• Você pode trocar o firmware se quiser customizar ainda mais

Sem depender de app proprietário, sem cloud obrigatório. Conectou na WiFi, já tem uma API REST pronta.

Presonus ATOM — a mesa de 16 pads

A Presonus ATOM (~$136) é uma interface originalmente feita para produção musical / DJ, mas que funciona perfeitamente como interface de controle genérica. Ela tem:

• 16 pads sensíveis a velocidade com LEDs RGB programáveis
• 4 knobs rotativos (encoders relativos)
• Conectividade USB — plug and play, sem drivers
• Comunicação via MIDI — protocolo universal e simples

O que eu fiz com ela: cada pad virou uma cor, e os 4 knobs controlam a intensidade (brightness) e os canais Red, Green e Blue da lâmpada.

Configurando a Lâmpada com ESPHome

A primeira coisa que fiz foi configurar a Kauf Bulb para se conectar ao meu broker MQTT. O ESPHome usa um arquivo YAML de configuração. Basicamente você define:

• A rede WiFi
• O endereço do broker MQTT
• O topic prefix para as mensagens

wifi:
  ssid: "SuaRedeWiFi"
  password: "SuaSenha"

mqtt:
  broker: broker.hivemq.com
  port: 1883
  topic_prefix: playground/bulb1

Com o ESPHome CLI, subi essa configuração para a lâmpada:

esphome run kauf_bulb.yaml

A partir daí, a lâmpada já aceita comandos tanto via REST local quanto via MQTT. A documentação do ESPHome é bem direta, e se tiver qualquer dúvida, o Kiro CLI te ajuda — eu inclusive usei ele para gerar os arquivos de configuração. Pedi "set up my ESPHome MQTT config" e ele já sabia o que fazer.

O Código: Controlando a Lâmpada com Python

A Paleta de 16 Cores

Cada um dos 16 pads tem uma cor atribuída. Defini valores RGB separados para os LEDs dos pads (range 0-127, padrão MIDI) e para a lâmpada (range 0-255):

COLORS = [
    ("Red",         127,   0,   0,   255,   0,   0),
    ("Orange",      127,  40,   0,   255,  80,   0),
    ("Yellow",      127, 127,   0,   255, 255,   0),
    ("Lime",         64, 127,   0,   128, 255,   0),
    ("Green",         0, 127,   0,     0, 255,   0),
    ("Mint",          0, 127,  64,     0, 255, 128),
    ("Cyan",          0, 127, 127,     0, 255, 255),
    ("Sky",           0,  64, 127,     0, 128, 255),
    ("Blue",          0,   0, 127,     0,   0, 255),
    ("Purple",       64,   0, 127,   128,   0, 255),
    ("Magenta",     127,   0, 127,   255,   0, 255),
    ("Pink",        127,   0,  64,   255,   0, 128),
    ("White",       127, 127, 127,   255, 255, 255),
    ("Warm White",  127,  90,  40,   255, 180,  80),
    ("Cool White",   80, 100, 127,   160, 200, 255),
    ("Coral",       127,  50,  40,   255, 100,  80),
]

Quando o programa inicia, todos os pads acendem com suas cores — você tem uma paleta física na sua mesa:

 Red      Orange   Yellow   Lime
 Green    Mint     Cyan     Sky
 Blue     Purple   Magenta  Pink
 White    Warm Wh  Cool Wh  Coral

Apertou um pad, a lâmpada muda pra aquela cor. Simples assim.

Versão REST (Rede Local)

A primeira versão controla a lâmpada via HTTP direto na rede local:

def bulb_color(r, g, b):
    url = f"{BULB}/{LIGHT}/turn_on?r={r}&g={g}&b={b}"
    urllib.request.urlopen(urllib.request.Request(url, method='POST'), timeout=2)

def bulb_brightness(bright):
    url = f"{BULB}/{LIGHT}/turn_on?brightness={bright}"
    urllib.request.urlopen(urllib.request.Request(url, method='POST'), timeout=2)

Funciona muito bem quando a lâmpada e o computador estão na mesma rede. Zero latência perceptível.

Versão MQTT (Controle Remoto)

Depois troquei para MQTT, o que abre possibilidades de controle remoto e integração com outros sistemas:

import paho.mqtt.client as mqtt

MQTT_BROKER = "broker.hivemq.com"
MQTT_PORT = 1883
MQTT_TOPIC = "playground/bulb1/light/kauf_bulb/command"

client = mqtt.Client()
client.connect(MQTT_BROKER, MQTT_PORT)
client.loop_start()

def bulb_color(r, g, b):
    payload = json.dumps({"state": "ON", "color": {"r": r, "g": g, "b": b}})
    client.publish(MQTT_TOPIC, payload)

def bulb_brightness(bright):
    payload = json.dumps({"state": "ON", "brightness": bright})
    client.publish(MQTT_TOPIC, payload)

A mesma interface, os mesmos pads, os mesmos knobs — mas agora os comandos viajam via MQTT. Você pode controlar a lâmpada de qualquer lugar, ter múltiplas lâmpadas no mesmo topic, ou integrar com Home Assistant, Node-RED, etc.

Os Desafios (e como o Kiro resolveu)

Desafio 1: Encoder Relativo vs. Absoluto

O Kiro gerou a primeira versão rapidinho. Funcionou de primeira para as cores dos pads. Mas quando fui controlar a intensidade com o knob, o comportamento era estranho — a intensidade ficava travada em ~50% e parecia invertida.

O problema: o Kiro tratou o knob como um controlador absoluto (valores de 0 a 127), mas a Presonus ATOM usa encoders relativos. Cada tick do knob manda:

• value = 1 → sentido horário (aumentar)
• value = 65 → sentido anti-horário (diminuir)

A correção foi manter o estado da intensidade manualmente e incrementar/decrementar a cada tick:

brightness = 255  # estado inicial: máximo
STEP = 8

def knob_delta(value):
    if value == 1:
        return STEP      # clockwise → aumenta
    if value == 65:
        return -STEP     # counter-clockwise → diminui
    return 0

# No loop MIDI:
brightness = clamp(brightness + knob_delta(msg.value))

Esse é o tipo de detalhe que só se descobre rodando no hardware real. Expliquei o comportamento pro Kiro e ele corrigiu na hora.

Desafio 2: Debounce — a lâmpada piscando

Com o encoder corrigido, a intensidade funcionava perfeitamente... até eu girar o knob rápido. A lâmpada ficava piscando porque cada tick disparava uma requisição HTTP/MQTT, e a lâmpada não conseguia processar tão rápido.

A solução é uma técnica clássica da eletrônica chamada debounce: ao invés de enviar a cada tick, você espera uns 200ms sem atividade e só então envia. Se o usuário continua girando, o timer reseta.

_brightness_timer = None
_timer_lock = threading.Lock()

def schedule_brightness_update():
    global _brightness_timer
    with _timer_lock:
        if _brightness_timer:
            _brightness_timer.cancel()
        _brightness_timer = threading.Timer(
            0.1, lambda: bulb_brightness(brightness)
        )
        _brightness_timer.daemon = True
        _brightness_timer.start()

O estado atualiza instantaneamente na memória, mas a chamada de rede é coalescida. Resultado: giro suave, sem flicker.

Desafio 3: De REST para MQTT

A primeira versão usava REST direto na rede local. Quando configurei o broker MQTT na lâmpada, precisei trocar o transporte no código Python. Falei pro Kiro: "troca de REST pra MQTT" e ele substituiu as chamadas HTTP por client.publish() mantendo toda a lógica de MIDI e debounce intacta.

O Resultado Final

O programa roda no terminal. Quando inicia:

1. Conecta ao broker MQTT
2. Abre a interface MIDI
3. Acende todos os 16 pads com suas cores
4. Inicializa a lâmpada em branco, intensidade máxima

A partir daí:

• Aperta um pad → lâmpada muda pra aquela cor instantaneamente
• Gira o Knob 1 → controla a intensidade (brightness)
• Gira o Knob 2 → ajusta o canal Red
• Gira o Knob 3 → ajusta o canal Green
• Gira o Knob 4 → ajusta o canal Blue

Você pode escolher uma cor base no pad e depois refinar com os knobs. Quer um pink? Aperta o vermelho, depois aumenta um pouco de blue no knob 4. Quer um verde mais escuro? Aperta o green, depois diminui a intensidade no knob 1.

Por que Interfaces Minimalistas?

Eu estou pirando nessa ideia de interfaces minimalistas — e tem um motivo. Com a computação agêntica e AI, a gente vai conseguir comandar computadores com poucos botões. Muitas das operações que hoje exigem mouse, teclado, navegar em menus — acessar conta bancária, ver saldo, abrir aplicativos — o agente de AI já vai fazer pra gente.

Na minha visão, não vamos precisar de computadores completos com teclado e monitor para tudo. Você pode juntar um Raspberry Pi, uma interface dessas, um audiozinho e ter um sistema completo para controlar a automação da sua casa.

O projeto re:Button já faz muito mais do que controlar lâmpada:

• Demos de palestra — botão 1 é uma demo, botão 2 é outra, botão 3 toca um áudio, botão 4 roda um vídeo
• Atalhos de sistema — volume, screenshots, respostas rápidas em reuniões
• Lançar projetos — cada pad abre um workspace diferente no Kiro
• Smart home — controlar lâmpadas, ventiladores, cenas

Como Rodar

Dependências

pip install mido python-rtmidi paho-mqtt

Versão REST (rede local)

# Edite o IP da lâmpada no arquivo
python3 rebutton-lamp.py

Versão MQTT

python3 rebutton-lamp-mqtt.py

Não precisa ser uma Presonus ATOM — qualquer controlador MIDI com pads funciona, basta ajustar os números das notas. Não precisa ser uma Kauf Bulb — qualquer lâmpada compatível com ESPHome ou MQTT serve.

O Papel do Kiro CLI

O Kiro CLI foi meu parceiro em todo o processo:

1. Gerou a primeira versão completa — listener MIDI, chamadas REST, mapeamento de cores, setup dos LEDs dos pads
2. Ajudou a configurar o ESPHome — gerou os arquivos YAML de configuração do MQTT
3. Corrigiu o bug do encoder — expliquei o sintoma, ele entendeu e reescreveu a lógica
4. Implementou o debounce — descrevi o problema do flicker, ele escolheu o padrão correto com threading.Timer
5. Portou de REST para MQTT — trocou a camada de transporte preservando toda a lógica existente
6. Adicionou os 4 knobs — generalizou o padrão de um knob para quatro com debounce independente

Nos dias de hoje, a gente consegue fazer as coisas muito rápido. O tempo total de desenvolvimento das quatro versões foi menos de uma hora.

Conclusão

Projetinho de sexta-feira: uma lâmpada WiFi de $15, uma mesa MIDI, Python e o Kiro CLI. O resultado é uma interface física, tátil, colorida, que controla a iluminação da sua casa sem abrir nenhum app.

É o tipo de projeto pra se divertir no fim de semana com a família e transformar a sua casa em um parque tecnológico.

Se você montar o seu, me conta nos comentários!