Controlar Luzes de Halloween com ESP32 a Bateria

Neste tutorial, vais aprender a fazer funcionar um ESP32 lite com baterias em modo deep-sleep para controlar luzes de Halloween. E para tornar tudo mais fixe, vamos usar isto para dar a um crânio de Halloween um par de olhos vermelhos brilhantes e assustadores 😉

Como parte deste projeto, vais aprender sobre a placa de desenvolvimento Lolin32 lite, o modo deep-sleep para poupar bateria, e como criar alguns efeitos simples de iluminação com LEDs.

Vamos divertir-nos.

Peças Necessárias

Makerguides is a participant in affiliate advertising programs designed to provide a means for sites to earn advertising fees by linking to Amazon, AliExpress, Elecrow, and other sites. As an Affiliate we may earn from qualifying purchases.

Abaixo encontras os componentes necessários para construir o projeto. Para este projeto estou a usar uma placa ESP32 mais antiga, que já foi descontinuada, mas ainda podes encontrá-la a um preço muito baixo. É a que está listada abaixo. Existe um modelo sucessor com especificações melhoradas, que podes encontrar here. Eu próprio ainda não experimentei esse, mas deverá funcionar da mesma forma.

Além disso, o crânio que usei é diferente do que listei abaixo. Acho que o que está abaixo até parece melhor, mas é um pouco mais pequeno. No entanto, experimentei e a placa e a bateria encaixam muito bem.

Finalmente, todas as baterias LiPo 903052 que encontrei têm o conector errado. Por isso, as sugeridas abaixo! Vais precisar de cortar o conector e substituí-lo por um conector JST PH 2 pinos de 2.0mm. Mas gosto do formato destas baterias, pois têm quase as mesmas dimensões da placa ESP32.

Ligação das Peças

Queremos construir um crânio de Halloween com um par de olhos vermelhos brilhantes. Para os olhos usamos dois LEDs vermelhos. Além disso, queremos que esses olhos pisquem ou mostrem algum outro efeito. O que significa que vamos precisar de um microcontrolador.

A imagem abaixo mostra como ligar essas peças.

Breadboard wiring of the ESP32 and the LEDs — Ligação dos LEDs ao ESP32

Como podes ver, é muito simples. Ligamos o pino GND da placa ESP32 com um fio azul aos cátodos dos dois LEDs (são os pinos mais curtos). Os ânodos (os pinos mais longos) dos LEDs estão ligados aos pinos 16 e 17 através de um 68Ω resistor (fio roxo e verde).

Não importa muito qual LED ligas a qual pino na placa. Só certifica-te de saber qual LED será o olho direito e qual será o esquerdo.

Por enquanto, usamos a porta USB para programação e alimentação. Portanto, não é necessário ligar a bateria.

Escrevendo o Software

Nesta secção, vou mostrar como implementar o software de controlo para os LEDs. Queremos o seguinte efeito:

uma fase de 5 segundos onde os olhos/LEDs escurecem lentamente com algum piscar aleatório no final
seguida por outra fase de 5 segundos, onde os LEDs estão completamente desligados.

Queremos dar a impressão de que o crânio acorda de repente, olha para ti com olhos vermelhos brilhantes e depois adormece lentamente até ficar a dormir por um tempo.

Se és completamente novo no mundo Arduino, talvez queiras ver primeiro o nosso tutorial How To Blink An LED Using Arduino. Caso contrário, dá uma vista rápida ao código abaixo. Vou explicar os detalhes nas secções seguintes.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;  

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

void loop() {
  dozingoff();
  sleeping();
}

Constantes

Começamos por definir algumas constantes. ledPin1 e ledPin2 são obviamente os pinos onde os LEDs estão ligados.

const int ledPin1 = 16;
const int ledPin2 = 17;

const int ts_ms = 10;               
const int dozingoff_ms = 5000;      
const uint64_t sleeping_ms = 5000;

Depois, temos algumas constantes de tempo. Usamos estas para regular a duração das fases de adormecer e de sono. Esses tempos estão em milissegundos (ms), por isso 5000ms são 5 segundos.

Podes alterar estas constantes como quiseres para tornar as duas fases mais curtas ou mais longas. Faz dozingoff_ms maior se quiseres um adormecer mais lento. E faz sleeping_ms maior se quiseres uma fase de sono mais longa.

Vamos falar sobre o passo de tempo ts_ms mais tarde.

Funções auxiliares

De seguida, implementamos algumas funções auxiliares úteis para manter o código bem estruturado e legível. Usamos a função set_brightness() para definir o brilho dos dois LEDs. Onde analogWrite() faz o trabalho real.

void set_brightness(int brightness) {
  analogWrite(ledPin1, brightness);
  analogWrite(ledPin2, brightness);
}

Note que precisaremos de um pino que suporte Pulse Width Modulation (PWM) para que analogWrite() funcione. Para a placa ESP32 que estamos a usar aqui isso não é problema. Os pinos 16 e 17 são pinos PWM, assim como quase todos os pinos dessa placa. Dá uma vista de olhos ao diagrama de pinagem em Pinout da placa ESP32.

O parâmetro brightness será um valor entre 0 e 255, onde 255 significa brilho máximo.

Para criar o efeito de adormecer, implementamos uma função chamada effect(). Surpresa, surpresa. Ela recebe um passo de tempo t como parâmetro e ao longo do tempo diminui o brilho do LED de 255 para 0. Para tornar mais interessante, adicionamos um piscar aleatório a meio do adormecer. Isto dará a impressão de que o crânio está a lutar contra o sono com pálpebras a piscar. Eu sei, crânios não têm pálpebras, no entanto…

int effect(int t) {
  long flutter = random(0, 30);
  int brightness = 255 * (dozingoff_ms - t) / dozingoff_ms;
  return brightness < 150 ? brightness + flutter : brightness;
}

Espero que o diagrama seguinte esclareça como isto funciona em detalhe.

Diagram of the dozing-off and sleeping phases that regulate the LED brightness

Função de adormecer

Vamos usar a função effect() na função dozingoff() mostrada abaixo. Esta função simplesmente itera sobre os passos de tempo de comprimento ts_ms, calcula o brilho via a função effect() e depois define o brilho do LED em conformidade.

void dozingoff() {
  for (int t = 0; t < dozingoff_ms / ts_ms; t++) {
    delay(ts_ms);
    int brightness = effect(t * ts_ms);
    set_brightness(brightness);
  }
}

Podes alterar o comprimento dos passos de tempo, o que resultará num efeito mais suave ou mais grosseiro. Eu escolhi 10ms, que funciona bem. Podes poupar bateria tornando-o mais longo, mas a animação não será tão suave.

Função de sono

Para fazer a cabeça dormir, poderíamos simplesmente definir o brilho dos LEDs para zero e depois esperar a duração da fase de sono. O código abaixo faz exatamente isso.

void sleeping() {
  set_brightness(0);
  delay(sleeping_ms);
}

No entanto, estaríamos a desperdiçar bateria valiosa, já que o microprocessador continua a funcionar sem fazer nada durante a fase de sono. Em vez disso, colocamos o microprocessador em modo deep-sleep mode, onde consome muito menos energia. O código abaixo mostra como isso é feito.

void sleeping() {
  esp_sleep_enable_timer_wakeup(sleeping_ms * 1000);
  esp_deep_sleep_start();
}

Primeiro, especificamos como queremos acordar. Existem diferentes formas de fazer isso, mas aqui definimos um temporizador via esp_sleep_enable_timer_wakeup (). Esta função recebe o tempo de sono em microssegundos. Por isso precisamos multiplicar sleeping_ms por 1000.

E na segunda linha simplesmente iniciamos o modo deep sleep chamando esp_deep_sleep_start(). Note que isto significa que a função setup e a loop vão correr, depois a placa adormece, acorda e repete o ciclo, começando por chamar a função setup.

Função setup

A nossa configuração é muito simples. Apenas colocamos os pinos que controlam os LEDs em modo output. Está feito.

void setup() {
  pinMode(ledPin1, OUTPUT);
  pinMode(ledPin2, OUTPUT);
}

Função loop

E graças às nossas funções auxiliares, a função loop também é muito simples. Adormecemos, depois dormimos e é isso.

void loop() {
  dozingoff();
  sleeping();
}

No entanto, nota que a função loop só vai correr uma vez, já que entramos em modo deep-sleep quando dormimos e depois reiniciamos a placa ao acordar.

Poupança de energia

Queremos fazer o nosso crânio assustador funcionar a bateria. E a pergunta óbvia é: quanto tempo vai funcionar e quanto ajuda o modo deep-sleep.

Estou a usar uma bateria 1200mAh LiPO. E medi a corrente durante a fase de adormecer (LEDs ligados) como 50mA. Em deep-sleep a placa consome apenas 0.054mA e se usar delay() em vez disso, o consumo sobe para 39mA . Agora, vamos fazer as contas.

Primeiro, convertemos a capacidade da bateria para Coulomb:

1200mA x 3600s = 4320000mC

Para a fase de adormecer, quando a placa está acordada por 5 segundos, consumimos

50mA x 5s = 250mC

Durante os 5 segundos em modo deep sleep, no entanto, consumimos apenas

0.054mA x 5s = 0.27mC

No total, consumimos 250mC + 0.27mC = 250.27mC a cada 10 segundos.

Portanto, temos um tempo de funcionamento contínuo de cerca de

10s * 4320000mC / 250.27mC ≈ 17263s ≈ 48 horas = 2 dias

Se não usarmos o modo deep-sleep, esse tempo é reduzido para metade. Se quiseres aumentar o tempo de funcionamento, torna a fase de sono mais longa (ou a fase de adormecer mais curta). Ou usa uma bateria maior, claro.

Pinout da placa ESP32

Nesta secção, quero destacar alguns aspetos específicos da placa Lolin32 lite que estamos a usar para este projeto. Encontras o pinout abaixo.

Pinout of the Lolin32 lite development board — Lolin32 lite

Esta placa é especialmente adequada para projetos alimentados a bateria, pois tem um conector de bateria e um circuito de carregamento com corrente máxima de 500mA. Isto significa que podes ligar uma bateria LiPo à placa, fazer a placa funcionar a bateria e carregar via porta USB. Muito bom!

Além disso, as correntes em deep sleep são bastante baixas. A especificação diz 125mA com WiFi ligado e 45mA com WiFi desligado, que é o que medi aproximadamente também.

Sem bateria ligada, e a placa alimentada via USB, vais ver um piscar contínuo do LED de carregamento. Isto é normal! Se ligares uma bateria, o piscar para. Se a bateria estiver a carregar, o LED fica azul fixo e desliga quando estiver totalmente carregada.

Note que a placa opera com nível lógico de 3.3V. Por isso, nem todos os módulos que encontras para Arduino funcionarão necessariamente com esta placa, já que o Arduino funciona a 5V.

Finalmente, uma palavra de aviso. O conector da bateria é um conector JST PH 2 pinos de 2.0mm. Mas a maioria das baterias com este conector tem polaridade invertida! Observa cuidadosamente as marcações da placa. Na imagem acima, o pino positivo está do lado esquerdo. Certifica-te que o fio vermelho da bateria está ligado ao pino positivo. Eu tive de cortar e inverter o conector da minha bateria.

Ligação do Crânio de Halloween

Embora a breadboard seja ótima para testar o circuito, não vai caber dentro do crânio. Depois de confirmares que tudo funciona, vais precisar de soldar os fios à placa e aos LEDs. Aqui está como a minha ligação ficou

Inside of the Halloween skull and its LED eyes

O crânio que comprei não tinha topo removível. Por isso tive de cortar a parte de baixo e furar dois buracos para os olhos. Também o repintei e adicionei algum desgaste. Mas estou muito satisfeito com o produto final

Especialmente depois de tudo estar bem arrumado:

Another Halloween skull with red glowing eyes

Conclusão

Neste artigo, explorámos como controlar luzes de Halloween usando um Lolin32 lite alimentado a bateria. Começámos por listar as peças necessárias, incluindo a placa LoLin32 Lite, que é uma ótima escolha para projetos alimentados a bateria. Depois discutimos o processo de ligar as peças e a fiação dos LEDs para o crânio de Halloween.

De seguida, escrevemos o software para o ESP32, que envolveu programá-lo para controlar as luzes e entrar em modo deep sleep para conservar a bateria. Isto permite que as luzes funcionem por um período prolongado sem necessidade de alimentação constante.

No geral, este projeto oferece uma forma divertida e criativa de adicionar um toque assustador às tuas decorações de Halloween. Usando o ESP32 e alguns componentes simples, podes controlar facilmente as tuas luzes de Halloween e criar uma experiência memorável para quem vier pedir doces.

Claro que poderíamos fazer muito mais. Adicionar um sensor PIR ou sensor radar para ligar as luzes só quando uma pessoa for detetada. Ou adicionar um módulo de som e mais efeitos de iluminação, ou controlar a cabeça via Wi-Fi. As possibilidades são infinitas.

Se tiveres alguma dúvida ou encontrares algum problema enquanto trabalhas neste projeto, consulta a secção de Perguntas Frequentes abaixo para mais orientações.

Perguntas Frequentes

Aqui estão algumas perguntas comuns sobre controlar LEDs usando ESP32 a bateria:

P: Posso usar qualquer placa ESP32 para este projeto?

R: Sim, podes usar qualquer placa ESP32 para este projeto. No entanto, neste artigo usamos especificamente a placa LoLin32 Lite, pois é fácil de usar com bateria.

P: Quanto tempo dura a bateria?

R: A duração da bateria depende de vários fatores, como a capacidade da bateria, o consumo das luzes e a duração do sono do ESP32. Recomenda-se usar uma bateria de alta capacidade e otimizar o código para minimizar o consumo de energia e prolongar a vida da bateria. Vê os cálculos acima.

Para formas mais avançadas de poupar energia, vê este excelente artigo: ESP32: Tips to increase battery life.

P: Posso usar luzes diferentes em vez do crânio de Halloween?

R: Absolutamente! Podes usar qualquer tipo de luzes que prefiras. A fiação e o código podem variar dependendo das luzes que escolheres, mas o conceito geral mantém-se. Uma boa ideia seria usar LEDs RGB para teres efeitos de cor.

P: É possível controlar vários conjuntos de luzes com um só ESP32?

R: Sim, é possível controlar mais luzes com um só ESP32. Podes ligar várias luzes em paralelo ou usar um multiplexador para controlá-las individualmente. No entanto, lembra-te que o consumo de energia aumentará, afetando a duração da bateria.

P: Posso modificar o código para adicionar mais funcionalidades?

R: Definitivamente! O código fornecido neste artigo é um exemplo básico para começares. Podes modificá-lo e expandi-lo para adicionar mais funcionalidades, como diferentes padrões de iluminação, controlo remoto ou integração com outros dispositivos inteligentes.

P: Posso alimentar o ESP32 usando um cabo USB em vez de bateria?

R: Sim, podes alimentar o ESP32 usando um cabo USB em vez de bateria. No entanto, o objetivo deste projeto é torná-lo portátil e sem fios usando uma bateria. Se preferires uma configuração com fios, podes ligar o ESP32 a uma fonte de energia via USB.

Links

Alguns links úteis com informação adicional estão listados abaixo.

Stefan Maetschke