Lembrete de aniversário que dura 50 anos
Componentes e suprimentos
 |
| × | 1 | |||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
| × | 1 | ||||
 |
| × | 3 | |||
 |
| × | 2 |
Ferramentas e máquinas necessárias
| ||||
 |
|
Aplicativos e serviços online
| ||||
 |
|
Sobre este projeto
Sim, você leu o título correto. Você já se esqueceu do seu aniversário, que precisa de outra pessoa para lembrá-lo? Ou que tal se você pudesse dar um presente para alguém que você ama, um dispositivo que desejará a ela no aniversário por 50 vezes ? Não estou brincando, este simples alarme de aniversário com Arduino que funciona em uma célula única moeda CR2450 pode desejar aos seus entes queridos (ou a você) um feliz aniversário por 50 anos, antes que a bateria acabe.
Acho que é a primeira vez que alguém faz um alarme de aniversário como este, porque tentei pesquisar projetos semelhantes, mas não encontrei nada. Este projeto também está disponível no site do meu projeto pessoal em - https://www.vishnumaiea.in/projects/hardware/birthday-reminder-device-that-will-run-for-50-years-on-a-coin- célula
Eu construí isso como parte do Hackaday Coin Cell Challenge. Essa coisa de alarme de aniversário simplesmente surgiu na minha mente e comecei a pesquisar por quanto tempo podemos executar algo em um celular moeda. Nunca usei os modos de espera de nenhum microcontrolador antes. Então eu tive que aprender tudo sobre como fazer os MCUs funcionarem em correntes insanamente baixas e economizar toda a energia de uma célula. Foi um desafio mesmo! Usei o ATmega168P como microcontrolador (na verdade, modifiquei um Arduino Nano que tem o ATmega168P removendo todos os componentes indesejados, como regulador de tensão, ponte USB etc.) e usei o Arduino IDE para desenvolver o firmware.
A hora e a data de aniversário podem ser programadas via monitor serial via USB. Assim que a hora e o alarme forem definidos, o MCU vai para o modo de hibernação. Quando a hora RTC atual corresponder ao seu aniversário todos os anos, o LED piscará por um minuto e imprimirá uma mensagem de feliz aniversário no monitor serial. O consumo médio de corrente está em torno de 1,2 uAh (incluindo autodescarga), o que permite operá-lo por mais de 50 anos em uma célula tipo moeda de lítio CR2450 (540mAh).
Recursos
- Cerca de 1,22 uAh consumo médio de corrente, incluindo autodescarga da célula ( 608 nA sem considerar a autodescarga, medida pelo amperímetro, na célula CR2450N)
- Os tempos de operação reais em diferentes tipos de células tipo moeda de lítio são:> 29 anos em CR2023 (225 mAh), > 50 anos em CR2450N (540 mAh) e > 64 anos em CR2477N (950 mAh). [o tempo de operação real depende da saúde física e química da bateria durante o período]
- O aniversário pode ser definido e atualizado por meio de qualquer software de monitor serial via USB com comandos simples.
- O botão de configuração de horário dedicado permite definir, ver e atualizar o horário sempre que desejar.
- Configuração de software de tempo significa que pode ser definido com bastante precisão com um aplicativo em execução em um computador (um software de configuração de tempo / sincronização baseado em Processing está em desenvolvimento)
- Código aberto - todos os arquivos de design e códigos de software estão disponíveis para download com documentação detalhada e imagens de alta resolução.
Agora, vou orientá-lo nas instruções sobre como construir isso e mostrar o teste de consumo atual real.
Etapa 1:Modificando o Arduino Nano
Para este projeto, você pode usar um microcontrolador simples ou um Arduino Nano ou Mini Pranchas. Tudo o que é necessário é que devemos executá-lo com oscilador interno (1 MHz) e na faixa de operação total de 1,8 - 5V. O CR2450 ou células de lítio semelhantes têm uma tensão nominal de 3 V e, portanto, podemos operar o MCU sem usar um regulador de tensão. Clones chineses ou Nano e Mini são extremamente baratos que você pode comprá-los pelo preço do chip! Eu usei um clone Nano que tem CH340G como a ponte USB para serial. Abaixo está o que usei.
Eu tinha as versões ATmega168 e 328. Comprei as 168 versões por engano há alguns anos (agora descobri um uso para elas). Nesta placa em particular, você precisa remover,
- O IC de ponte USB para serial, que aqui é o CH340G.
- O diodo Shchottky que está conectado ao USB 5V.
- Dois resistores de 1K conectados aos pinos TX e RX do CH340G.
- LEDs RX, TX e PWR (SMD)
- O regulador de tensão AMS1117 5V.
Usei o LED no pino 13 para depuração e como o pisca-pisca principal e, portanto, não o removi. Os capacitores não precisam ser removidos, pois ajudam a atenuar o ruído. Uma vez que o regulador é removido, você precisa fazer um curto nas almofadas do regulador de tensão, conforme mostrado na imagem. Isso se deve ao roteamento usado no projeto do PCB. Não remova o oscilador de cristal do MCU ainda porque vamos precisar dele para trocar os bits do fusível. Os MCUs terão o boot-loader padrão do Arduino e as configurações de fusível que o tornam executado em cristal externo de 16 MHz. Se removermos o cristal antes de definir o fusível para usar o OSC interno, simplesmente não poderemos programar o chip com um programador ISP. Abaixo está a versão modificada do Arduino Nano.
Etapa 2:Troca dos bits do fusível de ATmega168P
Normalmente, os chips nas placas Arduino virão com o bootloader do Arduino e bits de fusível. Precisamos mudar isso para executar o MCU no modo de energia mais baixa. Para conseguir isso, precisamos,
- Faça o MCU funcionar a 1 MHz. Podemos habilitar o oscilador interno e também o bit "dividir por 8" para produzir clock de 1 MHz a partir de 8 MHz. Menos velocidade de clock, menor será o consumo de energia. Não vamos processar nenhum número aqui, então 1 MHz é mais do que suficiente.
- Desative o módulo de detecção de brown-out (BOD).
- Desative todos os módulos internos, como ADC, temporizadores, etc. Faremos isso no software.
- Desative o cronômetro de watchdog (WDT).
- Faça todas as entradas de pinos IO e BAIXAS, exceto os pinos 13, 2 e 3.
Acima estão as configurações de fusíveis para ATmega168P. Observe que você precisa das versões "P" dos chips ATmega porque eles têm o recurso pico-power. As versões normais (não P) não suportam esses modos extras de economia de energia. Portanto, certifique-se de obter as versões P. Agora você deve estar se perguntando por que estou usando 168 em vez de 328. Isso porque quando eu estava testando o circuito, 328 parecia consumir cerca de 30uA para o mesmo código e configuração que usei para 168, que consumiu apenas cerca de 2uA. Eu não sei por que isso. Como eu disse antes, esta é a primeira vez que estou brincando com os modos de economia de energia, como o sono profundo. Então, posso estar faltando alguma coisa. Se você souber de alguma coisa sobre isso, por favor me avise nos comentários.
Para mudar os bits do fusível, precisamos de um programador ISP. Existem muitos programadores de ISP e softwares compatíveis. Eu usei o USBasp como programador e ProgISP como software de programação. O ID do chip ou assinatura do ATega168P-AU que usei é 1E940B . Isso pode mudar dependendo da versão que você possui. Para mudar os bits do fusível:
- Conecte o USBasp ao Nano. Normalmente, o USBasp terá um conector de 10 pinos, mas o Nano tem um conector ISP de 6 pinos. Então, fiz um adaptador simples de 10 pinos para 6 pinos. Pode ser necessário fazer algo semelhante ou encontrar um cabo.
- Selecione o modelo MCU da lista e verifique a assinatura com o RD botão.
- Defina as caixas de seleção e os bits de fusível conforme mostrado na imagem abaixo e use o Automático botão ou o Escrever botão na janela de configuração do fusível para atualizar os bits do fusível.
Se for bem-sucedido, uma mensagem será impressa no console. De agora em diante, você precisará do ISP para fazer o flash do MCU. Abaixo está o USBasp que usei.
Etapa 3:Compilando e enviando
Agora que alteramos os bits de fusível de nosso microcontrolador, também precisamos informar o software Arduino e o compilador sobre as alterações que fizemos para que possamos compilar o código corretamente dentro do IDE do Arduino. Fazemos isso adicionando uma definição de placa personalizada ao "boards.txt" arquivo que reside no diretório de instalação do Arduino, que normalmente está em
Assim que localizarmos o arquivo boards.txt, você precisará adicionar uma definição personalizada de um novo Arduino Pro Mini borda. Por volta da linha 655 será o início das definições existentes de placa Pro Mini. Haverá muitas versões das placas. Portanto, precisamos adicionar uma nova variante. Adicione a seguinte definição a ele e salve.
## Arduino Pro ou Pro Mini (3,3V, 1 MHz) com ATmega168 ## ------------------------- ------------------------- pro.menu.cpu.1MHzatmega168 =ATmega168 (3,3V, 1 MHz) pro.menu.cpu.1MHzatmega168.upload .maximum_size =14336 pro.menu.cpu.1MHzatmega168.upload.maximum_data_size =1024 pro.menu.cpu.1MHzatmega168.upload.speed =19200 pro.menu.cpu.1MHzatmega168.bootloader.cpu.1MHzatmega168.upload.speed =19200 pro.menu.cpu.1MHzatmega168.bootloader.cpu.1MHzatmega662 pro.menu , .menu.cpu.1MHzatmega168.build.f_cpu =1000000L E aqui está uma captura de tela.
Você precisa editar o boards.txt enquanto o Arduino não está em execução. Depois de salvar o novo arquivo boards.txt e reiniciar o IDE do Arduino, você verá a nova placa que acabamos de adicionar à lista. Dê uma olhada nas imagens abaixo.
Agora estamos prontos para compilar códigos Arduino para nossa nova placa. Como não estamos usando o carregador de inicialização Arduino (BL) , precisamos criar um arquivo hexadecimal do programa e usar USBasp e ProgISP para fazer o flash do microcontrolador. Podemos fazer isso usando o "Exportar binário compilado" opção do menu Sketch do IDE ou pressione Ctrl + Alt + S . Quando fazemos isso, dois arquivos hex (formato intel) será criado no mesmo diretório em que reside o nosso esboço. Um arquivo hexadecimal está com BL e o outro sem BL.
Assim que tivermos o arquivo hexadecimal, no ProgISP escolha o Carregar Flash opção para carregar o arquivo hexadecimal com o qual queremos fazer o flash do MCU e, em seguida, pressione Auto botão. Se o upload for bem-sucedido, ele será impresso no console do ProgISP.
Etapa 4:Intersil ISL1208 I2C RTC
O Intersil ISL1208 é um chip RTC de baixa potência com interface I2C. Ele usa um cristal externo de 32,768 KHz para controlar o tempo. Possui registros de alarme mês-dia-hora-minuto-segundo. Consome apenas cerca de 400 nA em operação VBAT e um máximo de 1,2 uA em VDD. A tensão de operação é de 1,8 V a 5,5 V. O que o torna um bom candidato é o consumo de energia e o recurso de alarme com data do mês. RTCs normais como o DS1307 não têm uma configuração de mês no registro de alarme, sem a qual não podemos gerar um alarme de aniversário a cada ano. Tem um pino de saída de interrupção que irá gerar um 250 ms sinal LOW ativo quando a hora atual coincide com a data e hora do alarme. Usaremos isso para acordar o MCU do modo de hibernação, o que explicarei com mais detalhes a seguir.
Recursos do ISL1208
- Relógio / calendário em tempo real
- - Acompanha o tempo em horas, minutos e segundos
- - Dia da semana, dia, mês e ano
- 15 saídas de frequência selecionáveis
- Alarme único
- - Definível para o segundo, minuto, hora, dia da semana, dia ou mês
- - Evento único ou modo de interrupção de pulso
- Backup automático para bateria ou supercapacitor
- Detecção de falha de energia
- Compensação de oscilador no chip
- SRAM de usuário com bateria de 2 bytes
- Interface I2C
- - Taxa de transferência de dados de 400 kHz
- Corrente de alimentação da bateria 400nA
- A mesma pinagem dos dispositivos ST M41Txx e Maxim DS13xx
Como eu tinha uma versão SMD do ISL1208, tive que fazer uma placa breakout para poder ser conectada à minha placa principal. Abaixo está o que eu fiz.
Etapa 5:Célula tipo moeda CR2450N
Especificações
- Sistema químico - Li / MnO2 (de acordo com IEC 60086)
- Tensão nominal - 3 V
- Capacidade nominal - 540 mAh
- Corrente de descarga padrão - 0,8 mA
- Máx. Cont. Corrente de descarga - 3,0 mA
- Peso médio - 5,9 g
- Temperatura operacional * - -40 - +85 ° C
- Auto-descarga a 23 ° C - <1% / ano
- Prazo de validade - até 10 anos
Etapa 6:esquemático
Use o esquema acima para soldar os módulos em uma perfboard. Os dois resistores de 4.7K são os pull-ups I2C . Os valores podem variar de 3,3K a mais de 5,6K. O R2 e R3 são pull-ups para os pinos de interrupção. O Arduino Nano tem dois pinos de interrupção de hardware - pino digital 3 e 2. O pino digital 2 será usado para a interrupção de despertar do alarme do RTC e o pino digital 3 será usado para despertar o MCU quando você precisar definir a hora. Abaixo está o CP2102 Módulo USB para serial que usei.
O módulo USB-para-Serial será usado para se comunicar através do monitor serial. Os pinos RX e TX do CP2102 são conectados aos pinos RX e TX do Nano, respectivamente. Observe que você não deve conectar o + 5V do USB à tensão VCC principal.
Etapa 7:como funciona?
O funcionamento do dispositivo realmente silencioso simples. Vamos ver como o algoritmo principal funciona,
- Defina a hora atual no RTC por meio do monitor serial.
- Defina a hora e a data do alarme no RTC.
- O MCU vai para o modo de hibernação após definir a hora e o alarme, desativando os periféricos internos, incluindo temporizadores e ADC.
- Quando a hora atual corresponde à data e hora do alarme (MM, DD, hh, mm, ss, p), o RTC irá gerar, interromper e despertar o MCU do repouso.
- Ao acordar, o MCU habilitará os periféricos internos necessários e imprimirá uma mensagem de feliz aniversário no monitor serial. Ele também pisca o LED dentro da cúpula em um determinado padrão.
- Depois de desejar um feliz aniversário, o MCU entrará no modo de hibernação novamente e só acordará no seu aniversário no ano que vem.
- Mas você pode ver a hora e atualizá-la sempre que necessário girando o botão de atualização de hora ATIVADO.
Quando ligado pela primeira vez, todos os registradores RTC serão zero e não serão incrementados até que primeiro escrevamos em qualquer um deles. Para definir a hora no RTC,
- Ligue o interruptor de atualização de hora (conecte o pino digital 3 ao GND). Não podemos definir o tempo sem puxar o pino 3 BAIXO.
- Primeiro conecte o dispositivo ao computador com um cabo USB. Uma porta COM será estabelecida em seu PC para a comunicação.
- Encontre a porta COM do dispositivo no gerenciador de dispositivos.
- Abra qualquer software de monitor serial ou monitor serial Arduino com a porta COM do dispositivo.
O MCU imprimirá a mensagem abaixo no monitor serial.
Estabelecido em série. Pronto para atualizar a hora. - Enviando "t" o comando imprimirá a hora atual, "a" irá imprimir a data e hora do alarme e "c" irá cancelar a operação de configuração de tempo e colocar o MCU no modo de hibernação após 6 segundos.
- Você precisa enviar a hora atual no formato mostrado abaixo,
TYYMMDDhhmmssp # Onde:
- T =indica informações de tempo
- AA =dígitos menos significativos de um ano (por exemplo, 18 para 2018, intervalo de 00 a 99)
- MM =mês (por exemplo, 01 para janeiro, intervalo de 01 a 12)
- DD =data (por exemplo, 24, intervalo de 01 a 31)
- hh =horas (por exemplo, 06, o intervalo é de 01 a 12 para o formato de 12 horas)
- mm =minutos (por exemplo, 55, o intervalo é de 00 a 59)
- ss =segundos (por exemplo, 30, o intervalo é de 00 a 59)
- p =período do dia para o formato de 12 horas (0 =AM, 1 =PM)
- # =delimitador
Por exemplo, para definir a hora e a data "08:35:12 AM, 05-01-2018", devemos enviar:
T1801050835120 # Para o dispositivo onde:
- T =indica informações de tempo
- 18 =o ano 2018
- 01 =mês de janeiro
- 05 =data
- 08 =horas
- 35 =minutos
- 12 =segundos
- 0 =AM
- # =delimitador
Se a operação for bem-sucedida, o MCU imprimirá a hora recebida no console como:
Atualização de horário recebida =T1801050835120 Data e hora são 8:35:12 AM, 5-1-18 Se a sequência de tempo que você inseriu for inválida, a mensagem abaixo será impressa:
Entrada de tempo inválida - , Depois de definir a hora com sucesso, o RTC irá controlá-la enquanto houver energia disponível para ele. Você pode verificar a hora que acabou de definir enviando o "t" comando. Definir o alarme é semelhante a este, exceto que o formato dos dados é diferente. Para definir o alarme, você precisa enviá-lo como:
AMMDDhhmmssp # Onde:
- A =indica informações de alarme
- MM =mês
- DD =data
- hh =horas
- mm =minutos
- ss =segundos
- p =período de tempo (0 =AM, 1 =PM)
- # =delimitador
Observe que não há informações de ano com a string de alarme porque obviamente não precisamos dela. Por exemplo, para definir meu aniversário "08:00:00 AM, 28-08", preciso enviar:
A08240800000 # Você pode verificar a hora do alarme a qualquer momento com o comando "a" . Assim que a hora e a data do alarme forem definidas, é hora de colocar o MCU em hibernação. Portanto, o dispositivo imprimirá a seguinte mensagem:
Tudo pronto. Desative o pino de configuração de tempo agora. Agora você precisa desligar o interruptor de configuração de tempo, ou seja, puxar o pino digital 3 HIGH (o pull-up de 10K fará isso). O sistema não irá dormir até que você faça isso. Quando a chave de configuração de tempo está DESLIGADA, o dispositivo entrará no modo de hibernação em 6 segundos e imprimirá a mensagem abaixo antes disso.
Muito bem! Dormir em 6 segundos .. Então é assim que você define a hora e o alarme. Agora, sempre que você precisar verificar a hora ou atualizá-la, pode ligar a chave de configuração do temporizador e o sistema será ativado, estabelecerá a comunicação serial e solicitará que você envie a hora. Irá imprimir a seguinte mensagem ao acordar,
Estabelecido em série. Ativação da atualização do horário. Pronto para atualizar o horário. Se você está apenas verificando se a hora está correta e não deseja alterar nada, envie "c" comando para cancelar a operação e colocar o sistema em hibernação novamente. Você também precisa desabilitar a chave de configuração de tempo neste momento.
Quando a hora atual coincide com a hora do alarme, ou seja, seu aniversário, o RTC irá gerar um sinal de interrupção de 250mS para o pino digital 2 do Nano. Este sinal irá despertar o sistema. Ao acordar, o dispositivo saberá que é seu aniversário e estabelecerá a comunicação serial (somente se você tiver o USB conectado) e imprimirá a seguinte mensagem,
Tada! É seu aniversário! Feliz B'Day :) Nos vemos no seu próximo aniversário! TC. Tchau! Dormindo em 6 segundos. E também piscará o LED conectado ao pino digital 13. Aqui está uma captura de tela do monitor serial do Arduino enquanto eu testava o sistema.
Então é assim que você opera este dispositivo. Para entender isso no nível do código, leia a próxima seção.
Etapa 8:Código
Este projeto é totalmente de código aberto e, portanto, publiquei o código-fonte do firmware em meu GitHub em https://github.com/vishnumaiea/Birthday-Alarm/ sob a licença MIT. Você é livre para se adaptar, modificar e redistribuir sem quaisquer restrições. Se você adicionar um backlink a este projeto a partir do seu modificado, será apreciado. Comentei minuciosamente o código e o tornei simples sempre que possível.
Temos um total de 13 funções / procedimentos no código. Eles são:
1. void setup () Esta é a função de configuração do Arduino que inicializará tudo e definirá os registros de configuração do ISl1208 RTC.
2. void loop () A função de loop principal.
3. void sleepNow () Esta função termina todas as comunicações, desabilita os periféricos internos do MCU, conecta as interrupções aos pinos digitais 3 e 2 e coloca o sistema no modo de hibernação. Em qualquer interrupção, a execução do programa continua a partir da linha após
sleep_mode () . Observe que antes que a execução normal do programa seja retomada, o MCU teria concluído as rotinas de serviço de interrupção associadas aos pinos de interrupção que são alarmInterrupt () e timeUpdateInterrupt () 4. void alarmInterrupt () O ISR associado ao INT0 interrupção no pino digital 2.
5. void timeUpdateInterrupt () O ISR associado ao INT1 interrupção no pino digital 3.
6. void fetchTime () fetchTime () lê os registros de tempo do RTC e imprimirá a hora atual no console. 7. void blinkLED () Pisca os LEDs obviamente.
8. bool EstablSerial () Estabelece comunicação serial com a ajuda do módulo USB-para-Serial.
9. bool endSerial () Termina a comunicação serial.
10. byte bcdToDec (byte) Aceita um BCD (Binary Coded Digits) valor e traduzi-lo no valor decimal correspondente. Precisamos disso porque o RTC registra apenas armazena e aceita valores BCD. Portanto, precisamos converter de e para BCD ocasionalmente.
11. byte decToBcd (byte) Aceita um valor decimal e o converte no valor BCD correspondente.
12. void printTime () Lê os registros de hora RTC e imprime a hora atual no console quando "t" o comando é recebido.
13. void printAlarmTime () Lê os registros de alarme RTC e imprime a hora e a data do alarme no console quando o "a" o comando é recebido.
Etapa 9:Teste
Esta seria a parte mais interessante deste projeto onde você saberá como acabei fazendo um dispositivo que funciona por 50 anos em uma célula tipo moeda! Primeiro, criei um protótipo de todo o circuito em uma placa de ensaio e finalizei o design. Usei uma bateria de íons de lítio (3,6 V) para fins de teste, a fim de salvar minhas novas células tipo moeda. Eu usei meu Fluke 87 True RMS multímetro para as medições atuais. Tem um 0,1 uA precisão para a faixa de micro amperes.
Vamos ver como podemos colocar o Atmega168P no modo de hibernação e reduzir drasticamente o consumo de corrente.
noInterrupts (); // desativa temporariamente as interrupções set_sleep_mode (SLEEP_MODE_PWR_DOWN); // Escolha nosso modo de suspensão preferido:sleep_enable (); // Define o bit de habilitação de hibernação (SE):ADCSRA =0; // desativa ADC power_all_disable (); // desativa todos os módulos digitalWrite (LED_PIN, LOW); // desliga o LED para indicar interrupções de sono (); // reativar interrupções sleep_mode (); // vai dormir Como eu disse antes, esta é a primeira vez que usei modos de hibernação em um microcontrolador (MCU) porque nunca precisei deles antes. A maioria das informações relacionadas aos modos de hibernação do AVR foram encontradas neste tópico do fórum e na documentação da biblioteca do AVR.
ATmega168P tem cinco modos de hibernação.
-
SLEEP_MODE_IDLE- menor economia de energia -
SLEEP_MODE_ADC SLEEP_MODE_PWR_SAVESLEEP_MODE_STANDBYSLEEP_MODE_PWR_DOWN– most power savings
More info on the sleep modes can be found here and in this video. We're using the SLEEP_MODE_PWR_DOWN mode as you can see there. At this mode, the current consumption at 3.6V is only around 0.2 uA See the below graph from the ATmega168PA datasheet that shows the relation between active current vs supply voltage and power down current vs supply voltage.
Here's the actual reading of the current consumed by sleeping ATmega168P @1MHz.
The value hops between 0.1 uA and 0.2 uA due to the lack of precision. But such a precise measurement isn't necessary but would've been interesting to see.
The power consumption of ISL1208 RTC at max is 1.2 uA . So if we add this with the power down mode current consumption of the MCU we get 1.2 + 0.2 =1.4 uA . My meter measured between 1.4 uA and 1.6 uA which justifies the calculations. The variations is only due to the lack of precision and our approximation or rounding of numbers.
Here's an unlisted video from my YouTube channel where I show the testing.
Now let's do the simple math to find how long we can the system on a coin cell. The CR2450N from Reneta has a nominal capacity of 540mAh . I have two red SMD LEDs on the system which consume about 6 mA (even with two LEDs) with when turned ON. So that's the peak current consumption of the device at worst. How long these LEDs light up can be summarized as,
1. As long as the time setting switch is activated while you're setting the time (but you don't have to do this every year)
2. The 6 second delay before sleep.
3. LED flashes on your birthday and stay ON for about 19 seconds.
Let's not be accurate here but just make an approximation. Let's assume the time setting requires 2 minutes (LEDs will be ON for 2 mins) and and additional 1 minute ON time for other things including the birthday flashing. So it's total 3 minutes or 180 seconds for which the system consumes 3 mA atual. Let's take the sleep or idle current as 1.6 uA , though it's lower actually. There's 31557600 seconds in a year of 365.25 days. If LEDs stay ON for 180 seconds in a year and OFF for (31557600 - 180) seconds, then the average current consumption will be,
Average Current =[((6 x 10^-3) x 180) + ((1.6 x 10^-6) x 31557420))] / 31557600 =(1.08 + 50.491872) / 31557600 =51.571872 / 31557600 =1.634 x 10^-6 =1.634 uAh If the average current consumption is 1.634 uAh, then the 540 mAh cell can run the device for:
Time Span (approx) =(540 x 10^-3) / (1.634 x 10^-6) =330477.3562 hours =13769.88 days =37.699 years Note than this approximation is do not consider self-discharge of the battery. It'll be taken into account later. You can also use the ElectroDroid app to calculate battery life. Here's a screenshot of the calculations we just did.
BUT WAIT...
Can we reduce the current consumption further ? YES WE CAN! I made further optimizations to my design to limit the average current consumption to 0.6 uA , yes I did that. Not let's see what optimizations I did,
1. To remove the extra red SMD LED to reduce the current when the system is active/running. Before it was 6 mA at max with two LEDs. So with one LED, it'll be reduced to half, ie 3 mA.
2. To reduce the current consumption of RTC, we need to disconnect the VDD pin of the ISL1208 RTC from the VBAT pin. Previously the VDD pin was connected to the VBAT pin where I supplied the 3V from the cell (you can see this in the schematic). In that configuration, I also had the LOW_POWER mode bit (LPMOD ) of the RTC set to 1 activating the low power mode. So now you might think if the low power mode is set, then the chip might be consuming the lowest current. But that's not the case when we have the VDD tied to VBAT. Because low power mode bit is only useful if we have VDD> VBAT all the time. At such situation, the RTC's internal power switch will select VBAT as power source reducing the current further by 600 nA when VDD>=VBAT (from typical 1.2 uA which I've mentioned before). But if we can run the RTC in VBAT only with VDD =0, the current consumption can be reduced to the minimum ie, 400 nA as per the datasheet. So what I did is, first I disabled the low power mode by setting LPMOD to 0. Then added a jumper to the RTC breakout board to disconnect the VDD pin from VBAT when I don't need it. Why need the jumper is because, the VDD pin must be greater than or equal to VBAT in order for the I2C to work. So I can connect the jumpers when I need I2C while I'm setting the time, and can disconnect it after. This will let the RTC to consume the targeted 400 nA current. Tada! We did it!
Now that we have reduced the current consumption of the RTC from 1.2 uA to 0.4 uA (400 nA), we can do the math again!
System Active Current =3 mAh max
System Sleep Mode Current =0.4 uA (RTC) + 0.2 uA (MCU) =0.6 uAh
System ON time =60 s (time setting) + 19 s (birthday flashing) + 6 s (before sleep) =85 seconds
System Sleeping Time =31557600 s - 85 s =31557515 seconds
Total time in a year =31557600 seconds
Battery capacity =540 mAh
Here's the current consumption test video after the optimizations and mods.
If we put those new values to the ElectroDroid's battery life calculator, we get, 101 years and 136 days. A theoretical operating time of more than a century! The average current consumption is now only 608 nA . Here's the screenshot.
Okay, What's the actual operating time ?
Batteries aren't perfect, nor anything we design. So let's also consider the 1% self discharge of the cell into account.
1% of initial capacity of 540 mAh CR2450N =5.4 mAh
Self-discharge current =5.4 mA per year or 616.4 nAh (5.4 mA / hours in a year)
Adding this 616.4 nAh with the 600 nAh sleep current =1.216 uAh
Expected operating time with average current of 1.224 uAh =50 years, and 131 days.
That's the actual operating time if the cell will be fine
Here's a table of actual operating times of different types of coin cells with the 1% self-discharge of initial capacity every year.
The main practical concerns associated with running the device for such long periods are,
1. Will the battery retain the charge and voltage for that long ?
2. The effects of environmental variations on the circuit and battery performance.
3. And you screwing up things! XD (don't drop it, chew it, sit on it, run your car through it or launch it into space!)
Coin cells are usually made to last for 10 years, which is their shelf life , and some even last longer than that. But that doesn't mean they'll start to disintegrate to an useless state after that. If the cell is physically fine, it can still power things. As per Renata datasheet, the self-discharge rate of CR2450N is less than 1% of the capacity every year. As per this datasheet from Energizer, that 1% figure is of the fresh capacity. Below is a chart that shows the standard discharge time in years (this doesn't consider the self-discharge or other exceptions). It clearly shows the theoretical expected operating time is way too longer than 10 years.
Self-discharging not only reduces the capacity but also reduces the voltage. Both ATmega168P and ISL1208 are designed to be operated fine at voltages as low as 1.8V. So the reduction in voltage might not be a problem. You can learn more about running systems with coin cells here.
To ensure long operating span, we must make sure the device is properly concealed against much of the environmental changes such as temperature, humidity, corrosion etc. These are some things you can do to protect your circuits,
1. Coat the PCB with long lasting conformal coating.
2. Place a pack of silica gel inside the enclosure.
3. Seal the enclosure with less temperature conductive materials and make it air tight.
4. Place it somewhere safe from naughty hands!
Step 10:Building
I used a perfboard to solder everything as per the schematic. I used berg connectors for the battery, switch and LED so that it'll be easy to remove them if needed. Below are the some images of the PCB.
To build the enclosure I used a 4" x 4" switch box which I bought from an electrical shop. I made two rectangular holes for the switch and USB. You can 3D print an enclosure if you want; sadly I don't have one. The dome was snatched from a cheap LED light and used super glue to fix it on the box. I painted it with silver spray paint.
Use your ingenuity to build it.
What missing is some decorations . I'm not good at decorating things. If you are going to gift this to someone, you know what to do.
The final output is satisfying to the extend of my hardwork. I might find someone else to decorate it.
Step 11 :Improvements
There's always room for improvement. Some of my suggestions are,
1. Using a Nokia 5110 LCD with or instead of the LED bulb. The LCD controller only consumes a couple of 100 uA at normal operating modes without the LED backlighting of course. Monochrome LCDs only consume extremely low currents. So using it would be better than a flashing LED, where you can actually print the happy birthday message on the screen itself. I might do this in future because I have couple of them lying around here.
2. A software that runs on the computer that'll set/sync the time accurately and automatically. I'm thinking of developing a simple one using Processing.
3. Flashing the LEDs to indicate the current age - for example if it's your 5th birthday (OMG are you're reading this ?!), it'll flash a sequence for 5 times. Currently you can not set the current age in the system. You may add this.
4. Designing a dedicated PCB in eagle (planned).
5. If blinking LED isn't your thing you can actually make this more exciting with for example using an opto-coupler you can turn on an AC alarm, music player, lights or anything you want to blink, move and scream on the birthday of the one you wish. You can even exclude the microcontroller and only use the interrupt from the RTC. Everything's possible!
So what are you waiting for ? Make one, decorate it with stickers, color papers, glitter or anything and gift to your loved ones or even yourself! And tell them to wait for this magical device to wish them happy birthday.
What you see here is actually a prototype of a device that'll refine and release in future. So stay tuned. Please feel free to share if you have found any errors with this documentation or have any improvement suggestions. Happy making :)
Código
Birthday Alarm
https://github.com/vishnumaiea/Birthday-AlarmEsquemas
Schematic of Arduino clone.
Fechadura de porta protegida por senha baseada em Arduino e Android
Robô de 4 rodas feito com Arduino controlado por Dabble
Processo de manufatura
- Indústria 4.0 e a IoT:Tendências de mercado para os próximos anos
- 10 fatores para encontrar a opção perfeita para seu aplicativo
- NVIDIA:Computador CUDA-X AI que executa todos os modelos AI
- Kontron:switch 40 Gigabit Ethernet para uso em ambientes hostis
- Não bata nesse rolamento! Instruções adequadas para montagem a frio
- Para os cibercriminosos, COVID é o presente que continua sendo oferecido
- 7 sinais que indicam que é hora de atualizar o gerador
- 3 sinais que indicam que é hora de rebobinar o motor
- Práticas que explicam a montagem perfeita de PCB
- Existe um robô para isso!