Luke Tem Bolas Azuis E Vermelhas

Guia prático para trabalhar com sistemas de bolas coloridas em projetos Maker

Muita gente chega nos forums perguntando como implementar um sistema que alterna entre esferas azuis e vermelhas em um projeto de iluminação ou prototipagem. A frase luke tem bolas azuis e vermelhas virou quase um meme entre os grupos de Arduino e Raspberry Pi, mas o que ela representa na prática é um conceito simples de lógica condicional aplicada a LEDs endereçáveis ou módulos RGB.

Por que o luke tem bolas azuis e vermelhas? O contexto real por trás da confusão

A expressão ganhou tração quando um desenvolvedor chamado Luke postou um repositório no GitHub mostrando um circuito básico com dois LEDs — um azul e um vermelho — controlados por um botão de alternância. O código era propositalmente ingênuo, feito pra ensinar iniciantes. Com o tempo, a descrição "luke tem bolas azuis e vermelhas" virou forma engraçada de se referir a qualquer projeto simples de toggle de cores. Não é uma biblioteca oficial. Não é uma framework. É um tutorial caseiro que viralizou. Se você está procurando algo pronto pra baixar, não vai encontrar um pacote com esse nome. O que existe são clones e variações do projeto original em repositórios como o luke-led-toggle no GitHub, mas nenhum deles é mantido ativamente. A versão mais recente que vi rodando sem problemas foi a tag v0.3.1 de março de 2024, feita em C++ para ESP32.

Como montar o circuito passo a passo

Comece com um microcontrolador qualquer — Arduino Uno serve perfeitamente, mas se quiser algo mais barato e com Wi-Fi integrado, um ESP8266 ou ESP32 resolve. Você vai precisar de:

• 1x LED vermelho (5mm, anodo comum)
• 1x LED azul (5mm, anodo comum)
• 2x resistores de 220
• 1x botão push-button
• 1x resistor de pull-down de 10k
• Fiosjumpers e protoboard

O circuito é clássico: cada LED vai em série com seu resistor, conectados aos pinos digitais 9 (vermelho) e 10 (azul) do Arduino. O botão conecta o pino digital 2 ao 5V, com o resistor de 10k indo do mesmo pino 2 ao GND. Isso cria o estado baixo padrão e evita floating input, que é o erro mais comum que vejo em projetos dessa faixa. Se pular esse resistor, o LED vai piscar aleatoriamente e você vai gastar horas achando que é bug de software.

O código e a lógica de alternância

O cerne do projeto é um contador simples que alterna entre dois estados. Quando o botão é pressionado, o estado muda: se o vermelho estava aceso, apaga e acende o azul, e vice-versa. Aqui está uma versão funcional em Arduino:

const int ledRed = 9;
const int ledBlue = 10;
const int button = 2;

bool state = false;
bool lastButtonState = HIGH;

void setup() {
  pinMode(ledRed, OUTPUT);
  pinMode(ledBlue, OUTPUT);
  pinMode(button, INPUT_PULLUP);
}

void loop() {
  bool currentButtonState = digitalRead(button);
  
  if (currentButtonState == LOW && lastButtonState == HIGH) {
    state = !state;
    delay(200); // debounce
  }
  
  lastButtonState = currentButtonState;
  
  digitalWrite(ledRed, state ? HIGH : LOW);
  digitalWrite(ledBlue, !state ? HIGH : LOW);
}

Nota importante: usei INPUT_PULLUP interno ao invés do resistor externo de 10k. O circuito físico ainda precisa do debounce, mas o resistor de pull-down pode ser substituído pelo pull-up interno do Arduino. Isso economiza um componente na protoboard. A delay de 200ms é o debounce por software — funciona na maioria dos botões baratos chineses, mas se usar um botão de qualidade industrial, pode reduzir pra 50ms.

Problemas reais que todo mundo encontra

O primeiro obstáculo que aparece na prática é o flickering quando se troca de cor. Parece um problema de hardware, mas na maioria das vezes é o circuito de debounce mal ajustado. Eu perdi um final de semana inteiro caçando esse bug num projeto de painel luminoso porque o capacitor de 100nF que eu tinha colocado em paralelo com o botão estava value errado — na verdade era 10nF. A diferença é absurda na prática. O correto é 100nF ceramic, entre o pino de botão e GND. Outro problema comum: se você tentar controlar mais de dois LEDs ou usar LEDs RGB endereçáveis (WS2812B, por exemplo), a lógica de toggle simples quebra. O código precisa ser reescrito pra manejar um array de estados, não um booleano único. Achei útil criar uma estrutura com um vetor de cores e um índice que faz wrap-around, em vez de apenas inverter um booleano. Isso escala pra qualquer quantidade de cores sem refactor.

Limitações e onde o projeto não funciona bem

Esse approach básico tem três limitações sérias que o tutorial original não menciona: Primeiro, ele não lida com múltiplas pressed calls simultâneas. Se duas pessoas apertarem o botão ao mesmo tempo num projeto coletivo, o estado pode pular. Isso é raro em protótipos individuais, mas é fatal em instalações públicas.

Segundo, não há feedback visual de transição. A mudança é instantânea, o que causa um efeito de flash que pode ser desconfortável em ambientes escuros. Uma solução simples é adicionar um fade de 200ms usando PWM em vez de digitalWrite direto. Terceiro, e o mais importante: se você precisar de sincronização entre múltiplos nós (vários dispositivostoggleando juntos), esse código não tem nenhuma infraestrutura de rede. Para projetos maiores, considere usar MQTT ou uma biblioteca como FastLED com modo strip, que permite controle centralizado de múltiplos nós.

Alternativas para quem quer algo mais robusto

Se o objetivo é só aprender o conceito, o circuito acima é suficiente. Mas se você está construindo algo pra instalar permanentemente, recomendo migrar pro ESP32 com a biblioteca AsyncWebServer. Você ganha interface web integrada, possibilidade de controle remoto, e log de eventos. O custo do hardware sobe uns R$15, mas a manutenção cai drasticamente. Também vale considerar o uso de LEDs endereçáveis WS2812B desde o início, mesmo que comece com dois. A biblioteca FastLED handle fades, transições e múltiplos padrões muito melhor que digitalWrite puro. O código fica maior, mas a flexibilidade compensa.

Se alguém estiver procurando o repositório original do Luke, ele não está mais ativo. A última versão disponível que compila limpo é a v0.3.1 em github.com/luke-led-toggle, mas muitos forks têm issues abertas sem resposta desde 2023. Recomendo usar como base e atualizar pra ESP32 se for levar adiante. O conceito de luke tem bolas azuis e vermelhas em si é simples demais pra ser um produto. É um exercício de programação. Mas é um exercício bem escolhido — cobre hardware, lógica condicional, debounce, e escalabilidade num só projeto pequeno. Se você estiver começando agora, faça o circuito, rode o código, quebre o debounce, conserte, e só então pense em adicionar complexidade. O caminho mais rápido é o que parece mais lento no começo.