Lembrete de Aniversário Baseado em Arduino: Solução Confiável de 50 Anos

Componentes e Materiais

Componente	Quantidade	Observações
Arduino Nano R3	1	Clones chineses Nano ou Mini com ATmega168P-AU
RTC Intersil ISL1208	1
Célula de moeda Renata CR2450N	1
Módulo USB-Serial CP2102	1
Programador USBasp	1
Cristal 32.768 KHz	1
Chave SPST	1
LEDs SMD	1
Cúpula LED transparente	1
Caixa de interruptor 4" x 4"	1	Ou imprima gabinete 3D
Perfboard	1
Conectores Berg (M e F)	1
Resistor 4.75k ohm	3
Resistor 10k ohm	2

Ferramentas e Máquinas Necessárias

• Dremel
• Ferro de solda (genérico)

Aplicativos e Serviços Online

• ProgISP - Para programar fuses e flash
• Arduino IDE - Para desenvolvimento do firmware

Sobre o Projeto

Sim, você leu o título corretamente. Já esqueceu seu próprio aniversário, precisando que alguém o lembrasse? E se você pudesse presentear alguém querido com um dispositivo que os parabeniza no aniversário por 50 vezes? Não estou brincando: este simples Alerta de Aniversário alimentado por Arduino que roda em uma única célula de moeda CR2450 pode desejar feliz aniversário aos seus entes queridos (ou a você mesmo) por 50 anos, antes que a bateria acabe.

Acredito que esta seja a primeira vez que alguém faz um alarme de aniversário assim, pois procurei projetos semelhantes e não encontrei nada. Este projeto também está disponível no meu site pessoal: vishnumaiea.in

Construí isso como parte do Hackaday Coin Cell Challenge. A ideia do alarme de aniversário surgiu e comecei a pesquisar quanto tempo podemos rodar algo com uma célula de moeda. Nunca tinha usado modos de sleep de microcontroladores antes. Tive que aprender tudo sobre fazer MCUs rodarem em correntes insanamente baixas e economizar cada bit de energia da célula. Foi um desafio real! Usei ATmega168P como microcontrolador (modifiquei um Arduino Nano com ATmega168P removendo componentes desnecessários como regulador de tensão, bridge USB, etc.) e usei Arduino IDE para desenvolver o firmware.

A hora e a data do aniversário podem ser programadas via monitor serial sobre USB. Uma vez definidos, o MCU entra em modo sleep. Quando a hora atual do RTC coincide com seu aniversário a cada ano, o LED pisca por um minuto e imprime mensagem de feliz aniversário no monitor serial. O consumo médio de corrente é cerca de 1.2 uAh (incluindo auto-descarga), permitindo rodar por mais de 50 anos em uma célula de lítio CR2450 (540mAh).

Características

• Consumo médio de corrente de ~1.22 uAh incluindo auto-descarga da célula (608 nA sem considerar auto-descarga, medido por amperímetro, na célula CR2450N)
• Tempo de operação real em diferentes células de lítio: >29 anos em CR2023 (225 mAh), >50 anos em CR2450N (540 mAh), >64 anos em CR2477N (950 mAh) [tempo real depende da saúde física e química da bateria ao longo do período]
• Aniversário pode ser definido e atualizado via qualquer software de monitor serial sobre USB com comandos simples
• Chave dedicada de ajuste de tempo permite definir, ver e atualizar hora quando quiser
• Configuração de tempo por software permite ajuste preciso com app rodando no computador (software de sincronização baseado em Processing em desenvolvimento)
• Open source - todos os arquivos de design e códigos disponíveis para download com documentação detalhada e imagens de alta resolução

Passo 1: Modificando o Arduino Nano

Para este projeto, pode usar microcontrolador nu ou placas Arduino Nano ou Mini. O requisito é rodar com oscilador interno (1MHz) e na faixa completa de 1.8-5V. A CR2450 ou células de lítio similares têm tensão nominal de 3V, então podemos rodar o MCU sem regulador de tensão. Clones chineses de Nano e Mini são extremamente baratos. Usei um clone Nano com CH340G como bridge USB-serial.

Nesta placa específica, remova:

• CI USB-Serial (CH340G)
• Diodo Schottky conectado ao 5V USB
• Dois resistores de 1K conectados aos pinos TX e RX do CH340G
• LEDs RX, TX e PWR (SMD)
• Regulador de tensão AMS1117 5V

Não removi o LED do pino 13 (uso para debug e flash principal). Os capacitores não precisam ser removidos (ajudam a atenuar ruído). Após remover o regulador, curto-circuite os pads do regulador conforme imagem (devido ao roteamento do PCB). Não remova o cristal do MCU ainda, pois precisaremos dele para alterar os fuse bits. Os MCUs vêm com bootloader Arduino padrão e fuses para rodar a 16MHz cristal externo. Se removermos o cristal antes de configurar fuses para oscilador interno, não conseguimos programar o chip com programador ISP.

Passo 2: Alterando Fuse Bits do ATmega168P

Os chips nas placas Arduino vêm com bootloader e fuse bits padrão. Precisamos alterar para rodar em modo de baixa potência:

• Rodar MCU a 1MHz: habilitar oscilador interno e bit "divide by 8" para produzir 1MHz a partir de 8MHz. Menor clock = menor consumo. Não faremos cálculos pesados, 1MHz basta.
• Desabilitar detecção de brown-out (BOD)
• Desabilitar módulos internos (ADC, Timers, etc.) - faremos via software
• Desabilitar watchdog timer (WDT)
• Colocar todos pinos I/O como entrada e LOW, exceto pinos 13, 2 e 3

Usei USBasp como programador e ProgISP como software. O chip ID do ATmega168P-AU que usei é 1E940B. Para alterar fuses: conecte USBasp ao Nano (precisa adaptador 10-pinos para 6-pinos), selecione modelo MCU, verifique assinatura com botão RD, configure checkboxes e fuses conforme imagem e use botão Auto ou Write.

Importante: Use versões "P" dos chips ATmega (pico-power). Versões normais não suportam modos extras de economia. Notei que ATmega328P consumia ~30uA com mesmo código/configuração que 168P consumia ~2uA. Não sei por quê; pode ser algo que perdi. Se souber algo, comente.

Passo 3: Compilando e Carregando

Após alterar fuses, precisamos avisar o Arduino IDE. Adicione definição de placa personalizada no arquivo boards.txt (normalmente em <instalado>/Arduino/hardware/arduino/avr/boards.txt no Windows). Adicione a definição de um novo Arduino Pro Mini (3.3V, 1 MHz) w/ ATmega168 por volta da linha 655. Após salvar e reiniciar IDE, a nova placa aparecerá na lista.

Como não usamos bootloader Arduino, crie arquivo hex via Export compiled binary (Sketch menu ou Ctrl+Alt+S). Dois arquivos hex serão criados; use o sem bootloader. No ProgISP, escolha Load Flash, carregue o hex e clique Auto.

Passo 4: RTC I2C Intersil ISL1208

O Intersil ISL1208 é RTC de baixa potência com interface I2C. Usa cristal externo 32.768 KHz. Tem registradores de alarme mês-dia-hora-min-seg. Consome ~400 nA em operação VBAT e máx 1.2 uA em VDD. Tensão de operação 1.8V a 5.5V. O que o torna bom candidato: consumo de energia e recurso de alarme com mês. RTCs normais como DS1307 não têm configuração de mês no registrador de alarme, sem o qual não podemos gerar alarme de aniversário anual. Tem pino de interrupção que gera sinal ativo LOW de 250 mS quando a hora atual coincide com data/hora do alarme. Usamos isso para acordar o MCU do sleep.

Como tinha versão SMD do ISL1208, fiz uma breakout board para plugar na placa principal.

Passo 5: Célula de Moeda CR2450N

Especificações: Sistema químico Li/MnO2 (IEC 60086), Tensão nominal 3V, Capacidade nominal 540 mAh, Corrente de descarga padrão 0.8 mA, Máx. contínua 3.0 mA, Peso médio 5.9g, Temp. operação -40 a +85°C, Auto-descarga a 23°C <1%/ano, Vida de prateleira até 10 anos.

Passo 6: Esquemático

Use o esquemático para soldar módulos na perfboard. Dois resistores 4.7K são pull-ups I2C (valores 3.3K a 5.6K). R2 e R3 são pull-ups para pinos de interrupção. Arduino Nano tem dois pinos de interrupção hardware: pino digital 3 e 2. Pino 2 para interrupção de alarme do RTC; pino 3 para acordar MCU quando precisar ajustar hora. O módulo CP2102 USB-Serial comunica via monitor serial. RX e TX do CP2102 conectam a RX e TX do Nano. Não conecte +5V do USB ao VCC principal.

Passo 7: Como Funciona

Algoritmo principal:

1. Defina hora atual no RTC via monitor serial
2. Defina data/hora do alarme no RTC
3. MCU entra em sleep desabilitando periféricos internos (timers, ADC)
4. Quando hora atual coincide com data/hora do alarme (MM, DD, hh, mm, ss, p), RTC gera interrupção e acorda MCU
5. Ao acordar, MCU habilita periféricos necessários e imprime mensagem de feliz aniversário no monitor serial. Também pisca LED na cúpula em padrão específico
6. Após parabenizar, MCU volta ao sleep e só acordará no próximo aniversário
7. Mas você pode ver/atualizar hora quando quiser ligando a chave de atualização de tempo ON

Configuração inicial: Ao ligar pela primeira vez, todos registradores RTC serão zero e não incrementam até escrevermos neles. Para definir hora:

1. Ligue chave de atualização ON (conecte pino digital 3 ao GND). Não é possível definir hora sem puxar pino 3 LOW.
2. Conecte dispositivo ao computador via USB. Porta COM será estabelecida.
3. Encontre porta COM no gerenciador de dispositivos.
4. Abra monitor serial (Arduino ou outro) na porta COM do dispositivo.

O MCU imprimirá: Serial Established. Ready to update time.

• Comando "t" imprime hora atual, "a" imprime data/hora do alarme, "c" cancela operação e coloca MCU em sleep após 6 segundos.
• Envie hora atual no formato: TYYMMDDhhmmssp#

Onde: T=indica info de tempo, YY=ano (2 dígitos, ex: 18 para 2018), MM=mês (01-12), DD=dia (01-31), hh=horas (01-12 formato 12h), mm=minutos (00-59), ss=segundos (00-59), p=período (0=AM, 1=PM), #=delimitador.

Exemplo: para "08:35:12 AM, 05-01-2018" envie: T1801050835120#

Se bem-sucedido: Time update received = T1801050835120 Date and Time is 8:35:12 AM, 5-1-18

Se inválido: Invalid time input - <string original>, <comprimento>

Verifique hora enviando "t". Definir alarme é similar, formato: AMMDDhhmmssp# (sem ano, pois alarme é anual). Exemplo: para meu aniversário "08:00:00 AM, 28-08" envio: A08240800000# (assumindo 24/08). Verifique alarme com "a".

Após definir, dispositivo imprimirá: Everything's set. Please disable the time set pin now. Desligue chave (pino 3 HIGH via pull-up 10K). Sistema não dormirá até você fazer isso. Ao desligar, entrará em sleep em 6 segundos: Well done! Sleeping in 6 seconds..

Quando precisar verificar/atualizar hora, ligue chave de tempo. Sistema acordará, estabelecerá serial e solicitará envio. Imprimirá: Serial Established. Time update wake up. Ready to update time. Se só verificar, envie "c" para cancelar e dormir novamente. Desligue chave neste ponto.

Quando hora atual coincide com alarme (seu aniversário), RTC gera interrupção de 250mS no pino digital 2 do Nano. Sistema acorda, sabe que é seu aniversário, estabelece serial (se USB conectado) e imprime: Tada! It's your birthday! Happy B'Day <seu nome> :) See you on your next birthday! TC. Bye! Sleeping in 6 seconds.. Também pisca LED no pino 13.

Passo 8: Código

Projeto totalmente open source. Código no GitHub: github.com/vishnumaiea/Birthday-Alarm sob licença MIT. Livre para adaptar, modificar, redistribuir. Código comentado.

13 funções principais:

1. setup() - Inicializa tudo e configura registradores do ISL1208
2. loop() - Loop principal
3. sleepNow() - Termina comunicações, desabilita periféricos, anexa interrupções aos pinos 3 e 2, entra em deep sleep. Ao acordar, continua após sleep_mode()
4. alarmInterrupt() - ISR associada à interrupção INT0 no pino 2
5. timeUpdateInterrupt() - ISR associada à interrupção INT1 no pino 3
6. fetchTime() - Lê registradores de tempo do RTC e imprime hora atual
7. blinkLED() - Pisca LEDs
8. establishSerial() - Estabelece comunicação serial via módulo USB-Serial
9. endSerial() - Encerra comunicação serial
10. bcdToDec(byte) - Converte BCD para decimal (RTC armazena em BCD)
11. decToBcd(byte) - Converte decimal para BCD
12. printTime() - Imprime hora atual no console ao receber "t"
13. printAlarmTime() - Imprime alarme no console ao receber "a"

Passo 9: Testes

Prototipei tudo em protoboard e finalizei design. Usei bateria Li-Ion (3.6V) para testes (preservar células novas). Usei multímetro Fluke 87 True RMS (precisão 0.1 uA na faixa microampere).

Para colocar ATmega168P em deep sleep e reduzir consumo drasticamente:

noInterrupts();
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
ADCSRA = 0; // desabilita ADC
power_all_disable(); // desabilita todos módulos
digitalWrite(LED_PIN, LOW);
interrupts();
sleep_mode();

ATmega168P tem 5 modos de sleep: IDLE (menos economia), ADC, PWR_SAVE, STANDBY, PWR_DOWN (mais economia). Usamos SLEEP_MODE_PWR_DOWN. A 3.6V, consumo em power-down é ~0.2 uA.

Consumo do ISL1208 no máx: 1.2 uA. Total sleep: 1.2 + 0.2 = 1.4 uA. Meu multímetro mediu entre 1.4 e 1.6 uA (justifica cálculos).

Cálculo de vida da bateria: CR2450N Renata = 540mAh. Dois LEDs SMD vermelhos consomem ~6 mA (mesmo com dois) quando ligados. Tempo LEDs ligados: ~2 min ajuste + 1 min outros (aniversário) = 3 min = 180s/ano a 3mA. Ano = 31.557.600s. Média = 1.634 uAh → ~37.7 anos (sem auto-descarga).

OTIMIZAÇÃO ADICIONAL: Reduzi consumo médio para 0.6 uA!

1. Removi um LED vermelho SMD extra (ativo cai de 6mA para 3mA)
2. Desconectei pino VDD do ISL1208 do VBAT. Antes VDD=VBAT com bit LPMOD=1 (low power mode). Mas low power mode só reduz corrente se VDD > VBAT sempre. Se rodar RTC só em VBAT com VDD=0, consumo cai para 400 nA (datasheet). Desabilitei LPMOD (0) e adicionei jumper na breakout para desconectar VDD de VBAT quando não precisar de I2C. Jumper conectado durante ajuste de hora (I2C precisa VDD >= VBAT), desconectado depois. RTC consome 400 nA alvo!

Novo cálculo: Ativo 3mA máx, Sleep 0.6 uA (0.4 RTC + 0.2 MCU), Tempo ativo 85s/ano (60s ajuste + 19s aniversário + 6s antes sleep). Média = 608 nA → 101 anos e 136 dias teóricos!

Tempo Real de Operação (com auto-descarga)

Baterias não são perfeitas. Considere 1% auto-descarga/ano da capacidade inicial.

1% de 540 mAh = 5.4 mAh/ano → 616.4 nAh. Somando 616.4 nAh + 600 nAh sleep = 1.216 uAh médio.

Tempo esperado com 1.224 uAh médio = 50 anos e 131 dias.

Tabela de tempos reais com auto-descarga 1%/ano para diferentes células.

Preocupações práticas para operação tão longa:

1. Bateria manterá carga e tensão por tanto tempo?
2. Efeitos de variações ambientais no circuito e bateria.
3. Você estragando as coisas! (não derrube, mastigue, sente, passe carro, lance ao espaço!)

Células de moeda feitas para durar 10 anos (vida de prateleira), mas não se desintegram depois. Se fisicamente OK, ainda alimentam. Datasheet Renata: auto-descarga <1%/ano. Datasheet Energizer: 1% da capacidade fresca. Gráfico mostra tempo teórico de descarga muito >10 anos.

Auto-descarga reduz capacidade E tensão. ATmega168P e ISL1208 operam bem até 1.8V. Redução de tensão pode não ser problema.

Para garantir longa duração: revestir PCB com coating conformal duradouro, colocar sílica gel no gabinete, vedar gabinete com materiais pouco condutores térmicos e hermético, colocar em local seguro.

Passo 10: Construção

Usei perfboard soldando conforme esquemático. Conectores Berg para bateria, chave e LED (fácil remoção). Gabinete: caixa de interruptor 4"x4" de loja elétrica. Fiz dois furos retangulares para chave e USB. Cúpula retirada de luz LED barata, fixada com super cola. Pintei com spray prata.

Falta decoração. Se for presentear, decore com adesivos, papéis coloridos, glitter, etc.

Passo 11: Melhorias Futuras

1. Usar LCD Nokia 5110 com ou no lugar do LED. Controlador consome centenas de uA sem backlight. LCD monocromático consome correntes extremamente baixas. Melhor que LED piscante: mostra mensagem na tela.
2. Software no PC para definir/sincronizar hora automaticamente (planejo desenvolver em Processing).
3. Piscar LEDs indicando idade atual (ex: 5 anos = 5 piscadas). Atualmente não define idade no sistema.
4. Projetar PCB dedicado no Eagle (planejado).
5. Se LED piscante não agrada, use optoacoplador para ligar alarme AC, música, luzes, etc. Pode até excluir microcontrolador e usar só interrupção do RTC. Tudo é possível!

Então, o que espera? Faça um, decore e presenteie! Diga a eles para esperar este dispositivo mágico parabenizá-los. O que vê aqui é protótipo de dispositivo que refinarei e lançarei no futuro. Fique ligado. Compartilhe se encontrar erros ou tiver sugestões. Feliz criação :)

Código

Código completo no GitHub: github.com/vishnumaiea/Birthday-Alarm

Esquemáticos

Esquemático do clone Arduino.