Verjaardagsherinnering die 50 jaar geldig is

Over dit project

Ja, je leest de titel goed. Ben je ooit je verjaardag vergeten, dat je iemand anders nodig hebt om je eraan te herinneren? Of wat als je iemand van wie je houdt een cadeau kunt doen, een apparaat dat hem 50 keer zijn verjaardag zal wensen ? Ik maak geen grapje, dit eenvoudige Arduino-aangedreven verjaardagsalarm die draait op een enkele CR2450 knoopcel kan uw dierbaren (of uzelf) 50 jaar lang een gelukkige verjaardag wensen, voordat de batterij leeg is.

Ik denk dat dit de eerste keer is dat iemand zo'n verjaardagsalarm maakt, omdat ik heb geprobeerd naar soortgelijke projecten te zoeken maar niets gevonden. Dit project is ook beschikbaar op mijn persoonlijke projectwebsite op - https://www.vishnumaiea.in/projects/hardware/birthday-reminder-device-that-will-run-for-50-years-on-a-coin- cel

Ik heb dit gebouwd als onderdeel van de Hackaday Coin Cell Challenge. Dit verjaardagsalarm kwam gewoon in me op en ik begon te onderzoeken hoe lang we iets op een knoopcel kunnen laten lopen. Ik heb nog nooit de slaapstanden van microcontrollers gebruikt. Dus ik moest alles leren over het laten werken van MCU's met waanzinnig lage stromen en om elk beetje energie van een cel te besparen. Het was echt een uitdaging! Ik gebruikte ATmega168P als microcontroller (eigenlijk heb ik een Arduino Nano aangepast met ATmega168P erop door alle ongewenste componenten zoals de spanningsregelaar, USB-brug enz. te verwijderen) en gebruikte Arduino IDE om de firmware te ontwikkelen.

De tijd en verjaardagsdatum kunnen via een seriële monitor via USB worden geprogrammeerd. Zodra de tijd en het alarm zijn ingesteld, gaat de MCU naar de slaapmodus. Wanneer de huidige RTC-tijd elk jaar overeenkomt met uw verjaardag, knippert de LED een minuut lang en drukt een gelukkige verjaardagsboodschap af op de seriële monitor. Het gemiddelde stroomverbruik ligt rond de 1,2 uAh (inclusief zelfontlading), wat het mogelijk maakt om het meer dan 50 jaar te laten werken op een CR2450 (540mAh) Lithium knoopcelbatterij.

Functies

• Ongeveer 1,22 uAh gemiddeld stroomverbruik inclusief zelfontlading van de cel (608 nA zonder rekening te houden met zelfontlading, gemeten met een ampèremeter, op cel CR2450N)
• De werkelijke bedrijfstijden van verschillende typen lithium-knoopcellen zijn:>29 jaar op CR2023 (225 mAh), >50 jaar op CR2450N (540 mAh), en >64 jaar op CR2477N (950 mAh). [werkelijke gebruiksduur hangt af van de fysieke en chemische toestand van de batterij gedurende de periode]
• Verjaardag kan worden ingesteld en bijgewerkt via elke seriële monitorsoftware via USB met eenvoudige commando's.
• Met een speciale schakelaar voor het instellen van de tijd kun je de tijd instellen, bekijken en bijwerken wanneer je maar wilt.
• Software-instelling van tijd betekent dat deze vrij nauwkeurig kan worden ingesteld met een app die op een computer wordt uitgevoerd (een tijdinstelling/synchronisatiesoftware op basis van Processing is in ontwikkeling)
• Open source - alle ontwerpbestanden en softwarecodes kunnen worden gedownload met gedetailleerde documentatie en afbeeldingen met hoge resolutie.

Nu zal ik je door de instructies leiden om dit te bouwen en je de daadwerkelijke stroomverbruiktest laten zien.

Stap 1:De Arduino Nano aanpassen

Voor dit project kun je een kale microcontroller gebruiken of een Arduino Nano of Mini planken. Het enige dat nodig is, is dat we het moeten laten werken met een interne oscillator (1 MHz) en op het volledige werkbereik van 1,8 - 5 V. De CR2450 of vergelijkbare lithiumcellen hebben een nominale spanning van 3V, en dus kunnen we de MCU gebruiken zonder een spanningsregelaar te gebruiken. Chinese klonen of Nano en Mini zijn extreem goedkoop dat je ze kunt kopen voor de prijs van de chip! Ik heb zo'n Nano-kloon gebruikt die CH340G . heeft als de USB naar seriële brug. Hieronder is degene die ik heb gebruikt.

Ik had zowel ATmega168- als 328-versies. Ik heb een paar jaar geleden per ongeluk de 168-versies gekocht (nu heb ik er een toepassing voor gevonden). In dit specifieke bord moet je verwijderen,

• Het USB-naar-seriële brug-IC, hier de CH340G.
• De Shchottky-diode die is aangesloten op de USB 5V.
• Twee 1K-weerstanden aangesloten op de TX- en RX-pinnen van de CH340G.
• RX, TX en PWR LED's (SMD)
• De AMS1117 5V spanningsregelaar.

Ik heb de LED op pin 13 gebruikt voor debuggen en als hoofdflitser, en dus heb ik hem niet verwijderd. De condensatoren hoeven niet te worden verwijderd, omdat ze ruis helpen dempen. Nadat de regelaar is verwijderd, moet u de pads van de spanningsregelaar kortsluiten, zoals weergegeven in de afbeelding. Dit komt door de routing die wordt gebruikt in het PCB-ontwerp. Verwijder de kristaloscillator van de MCU nog niet omdat we deze nodig hebben om de zekeringbits te vervangen. De MCU's hebben de standaard Arduino-bootloader en zekeringinstellingen waardoor ze op een extern 16MHz-kristal werken. Als we het kristal verwijderen voordat we de zekering instellen om interne OSC te gebruiken, kunnen we de chip gewoon niet programmeren met een ISP-programmeur. Hieronder staat de aangepaste versie van de Arduino Nano.

Stap 2:Zekeringbits van ATmega168P vervangen

Normaal gesproken worden de chips op de Arduino-boards geleverd met de Arduino-bootloader en fuse-bits. We moeten dit wijzigen om de MCU in een lagere energiemodus te laten werken. Om dit te bereiken moeten we,

• Laat de MCU draaien op 1 MHz. We kunnen de interne oscillator en ook de "deel door 8" bit inschakelen om 1 MHz-klok te produceren vanaf de 8 MHz. Minder kloksnelheid, minder zal het stroomverbruik zijn. We zullen hier geen cijfers kraken, dus 1 MHz is meer dan genoeg.
• Schakel de brown-out detectie (BOD)-module uit.
• Schakel alle interne modules uit, zoals ADC, Timers enz. We doen dit in software.
• Watchdog-timer (WDT) uitschakelen.
• Maak alle IO-pins ingangen en LOW behalve pin 13, 2 en 3.

Hierboven staan ​​de zekeringinstellingen voor ATmega168P. Merk op dat je de "P"-versies van de ATmega-chips nodig hebt omdat ze de pico-power-functie hebben. De normale versies (niet P) ondersteunen deze extra energiebesparende modi niet. Zorg er dus voor dat je de P-versies krijgt. Je kunt je nu afvragen waarom ik 168 gebruik in plaats van 328. Dat komt omdat toen ik het circuit aan het testen was, 328 ongeveer 30uA leek te verbruiken voor dezelfde code en instelling die ik gebruikte voor 168, die slechts ongeveer 2uA verbruikte. Ik weet niet waarom dit is. Zoals ik al eerder zei, dit is de eerste keer dat ik speel met energiebesparende modi zoals diepe slaap. Dus misschien mis ik iets. Als je er iets van weet, laat het me dan weten in de comments.

Om de zekeringbits te wijzigen, hebben we een ISP-programmeur nodig. Er zijn veel ISP-programmeurs en compatibele software. Ik heb de USBasp . gebruikt als programmeur en ProgISP als programmeersoftware. De chip-ID of handtekening van de ATega168P-AU die ik heb gebruikt, is 1E940B . Dit kan veranderen afhankelijk van de versie die je hebt. Om de zekeringbits te wijzigen:

• Sluit de USBasp aan op Nano. Normaal gesproken heeft USBasp een 10-pins connector, maar Nano heeft een 6-pins ISP-header. Dus maakte ik een eenvoudige 10-pins naar 6-pins adapter. Misschien moet je iets soortgelijks maken of een kabel zoeken.
• Selecteer het MCU-model uit de lijst en verifieer de handtekening met de RD knop.
• Stel de selectievakjes en zekeringbits in zoals weergegeven in de onderstaande afbeelding en gebruik de Auto knop of de Schrijf knop op het venster voor het instellen van de zekering om de zekeringbits bij te werken.

Als dit is gelukt, wordt er een bericht naar de console afgedrukt. Vanaf nu heb je de ISP nodig om de MCU te flashen. Hieronder staat de USBasp die ik heb gebruikt.

Stap 3:Compileren en uploaden

Nu we de fuse-bits van onze microcontroller hebben gewijzigd, moeten we de Arduino-software en de compiler ook informeren over de wijzigingen die we hebben aangebracht, zodat we de code correct kunnen compileren in de Arduino IDE. Hoe we dit doen, is door een aangepaste borddefinitie toe te voegen in de "boards.txt" bestand dat zich in de Arduino-installatiemap bevindt die zich normaal op /Arduino/hardware/arduino/avr/boards.txt" bevindt op Windows-systemen. Dit kan voor u anders zijn, afhankelijk van het besturingssysteem dat u heeft of de versie van de IDE die u heeft. Ik gebruik de IDE-versie 1.8.5

Zodra we het bestand boards.txt hebben gevonden, moet u een aangepaste definitie van een nieuwe Arduino Pro Mini toevoegen bord. Rond lijn 655 zal het begin zijn van de bestaande Pro Mini-borddefinities. Er zullen veel versies van de borden zijn. We moeten dus een nieuwe variant toevoegen. Voeg de volgende definitie toe en sla op.

## Arduino Pro of Pro Mini (3,3V, 1 MHz) met 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.low_fuses=0x62 pro.menu.cpu.1MHzatmega168 .bootloader.high_fuses=0xDF pro.menu.cpu.1MHzatmega168.bootloader.extended_fuses=0xF9 pro.menu.cpu.1MHzatmega168.bootloader.file=atmega/ATmegaBOOT_168_pro_8MHz.hex pro.menu.cpu.1MHzatmega168.build. .menu.cpu.1MHzatmega168.build.f_cpu=1000000L  

En hier is een screenshot.

U moet de boards.txt bewerken terwijl de Arduino niet actief is. Zodra je het nieuwe board.txt-bestand hebt opgeslagen en Arduino IDE opnieuw hebt opgestart, zie je het nieuwe bord dat we zojuist hebben toegevoegd in de lijst. Bekijk de screenshots hieronder.

Nu zijn we klaar om Arduino-codes te compileren voor ons nieuwe bord. Omdat we de Arduino bootloader (BL) . niet gebruiken , moeten we een hex-bestand van het programma maken en USBasp en ProgISP gebruiken om de microcontroller te flashen. We kunnen dit doen met behulp van de "Gecompileerde binaire bestanden exporteren" optie uit het Sketch-menu van de IDE of druk op Ctrl + Alt + S . Als we dat doen, worden twee hex-bestanden (intel-formaat) wordt gemaakt in dezelfde map waarin onze schets zich bevindt. Eén hex-bestand is met BL en de andere is zonder BL.

Zodra we het hex-bestand hebben, kiest u in de ProgISP de Load Flash optie om het hex-bestand te laden waarmee we de MCU willen flashen en druk vervolgens op Auto knop. Als het uploaden is gelukt, wordt het afgedrukt naar de console van de ProgISP.

Stap 4:Intersil ISL1208 I2C RTC

De Intersil ISL1208 is een low power RTC-chip met I2C-interface. Het gebruikt een extern 32.768 KHz-kristal om de tijd bij te houden. Heeft maand-datum-uur-min-sec alarmregisters. Het verbruikt slechts ongeveer 400 nA bij VBAT-gebruik en maximaal 1,2 uA bij VDD. De bedrijfsspanning is van 1.8V tot 5.5V. Wat dit een goede kandidaat maakt, is het stroomverbruik en de alarmfunctie voor de maanddatum. Normale RTC's zoals DS1307 hebben geen maandinstelling in het alarmregister, zonder welke we niet elk jaar een verjaardagsalarm kunnen genereren. Het heeft een interrupt-uitgangspin die een 250 mS . zal genereren actief LOW-signaal wanneer de huidige tijd overeenkomt met de alarmdatum en -tijd. We zullen dit gebruiken om de MCU uit de slaapstand te halen, wat ik hieronder verder zal uitleggen.

Kenmerken van ISL1208

• Realtime klok/kalender
• -Houdt tijd bij in uren, minuten en seconden
• - Dag van de week, dag, maand en jaar
• 15 selecteerbare frequentie-uitgangen
• Enkel alarm
• - Instelbaar op seconde, minuut, uur, dag van de week, dag of maand
• - Enkele gebeurtenis of pulsonderbrekingsmodus
• Automatische back-up naar batterij of supercondensator
• Detectie stroomuitval
• On-Chip Oscillator Compensatie
• 2 bytes batterijgevoede gebruikers-SRAM
• I2C-interface
• - 400 kHz gegevensoverdrachtsnelheid
• 400nA voedingsstroom batterij
• Dezelfde pin-out als ST M41Txx- en Maxim DS13xx-apparaten

Omdat ik een SMD-versie van de ISL1208 had, moest ik een breakout-bord maken om op mijn moederbord te kunnen worden aangesloten. Hieronder is wat ik heb gemaakt.

Stap 5:CR2450N knoopcel

Specificaties

• Chemisch systeem - Li / MnO2 (volgens IEC 60086)
• Nominale spanning - 3 V
• Nominale capaciteit - 540 mAh
• Standaard ontlaadstroom - 0,8 mA
• Max. vervolg Ontlaadstroom - 3,0 mA
• Gemiddeld gewicht - 5,9 g
• Bedrijfstemperatuur* - -40 - +85 °C
• Zelfontlading bij 23°C - <1% / jaar
• Houdbaarheid - tot 10 jaar

Stap 6 :Schematisch

Gebruik het bovenstaande schema om de modules op een perfboard te solderen. De twee 4.7K-weerstanden zijn de I2C pull-ups . De waarden kunnen variëren van 3,3K tot meer dan 5,6K. De R2 en R3 zijn pull-ups voor de interrupt-pinnen. Arduino Nano heeft twee hardware-interrupt-pinnen - digitale pin 3 en 2. Digitale pin 2 wordt gebruikt voor de alarm-ontwaak-interrupt van de RTC en digitale pin 3 wordt gebruikt om de MCU te wekken wanneer je de tijd moet instellen. Hieronder staat de CP2102 USB-naar-serieel module die ik heb gebruikt.

De USB-naar-serieel-module wordt gebruikt om via de seriële monitor te communiceren. De RX- en TX-pinnen van de CP2102 zijn respectievelijk verbonden met de RX- en TX-pinnen van Nano. Houd er rekening mee dat u de +5V van de USB niet moet aansluiten op de VCC-hoofdspanning.

Stap 7:Hoe werkt het?

De werking van het toestel is eigenlijk stil simpel. Laten we eens kijken hoe het hoofdalgoritme werkt,

• Stel de huidige tijd in op de RTC via seriële monitor.
• Stel de alarmtijd en -datum in op de RTC.
• De MCU gaat naar de slaapstand na het instellen van de tijd en het alarm door de interne randapparatuur, inclusief timers en ADC, uit te schakelen.
• Als de huidige tijd overeenkomt met de alarmdatum en -tijd (MM, DD, hh, mm, ss, p), genereert en onderbreekt de RTC de MCU en wordt deze uit de slaapstand gehaald.
• Bij het ontwaken schakelt de MCU de vereiste interne randapparatuur in en drukt een gelukkige verjaardagsboodschap af op de seriële monitor. Het knippert ook de LED in de koepel in een bepaald patroon.
• Na je een gelukkige verjaardag te hebben gewenst, gaat de MCU weer naar de slaapstand en wordt hij pas volgend jaar op je verjaardag wakker.
• Maar je kunt de tijd zien en deze zo nodig bijwerken door aan de schakelaar voor tijdupdate te draaien AAN.

Wanneer voor de eerste keer ingeschakeld, zijn alle RTC-registers nul en wordt deze niet verhoogd totdat we voor het eerst naar een van hen schrijven. Om de tijd op de RTC in te stellen,

• Zet de tijdupdateschakelaar AAN (verbind de digitale pin 3 met GND). We kunnen de tijd niet instellen zonder de pin 3 LAAG te trekken.
• Sluit het apparaat eerst aan op uw computer met een USB-kabel. Er wordt een COM-poort op uw pc ingesteld om te communiceren.
• Zoek de COM-poort van het apparaat in Apparaatbeheer.
• Open elke seriële monitorsoftware of Arduino seriële monitor met de COM-poort van het apparaat.

De MCU drukt het onderstaande bericht af op de seriële monitor.

Serial Established.Ready to update time. 

• Verzenden "t" commando zal de huidige tijd afdrukken, "a" zal de alarmdatum en -tijd afdrukken, en "c" annuleert de tijdinstelling en zet de MCU na 6 seconden in de slaapstand.
• U moet de huidige tijd verzenden in het onderstaande formaat,

TYYMMDDuummssp# 

Waar:

• T =geeft tijdinformatie aan
• JJ =minst significante cijfers van een jaar (bijv. 18 voor 2018, bereik is van 00 tot 99)
• MM =maand (bijv. 01 voor januari, bereik is 01 tot 12)
• DD =datum (bijv. 24, bereik is 01 tot 31)
• uu =uur (bijv. 06, bereik is 01 tot 12 voor 12-uursnotatie)
• mm =minuten (bijv. 55, bereik is 00 tot 59)
• ss =seconden (bijv. 30, bereik is 00 tot 59)
• p =periode van de dag voor 12 uur formaat (0 =AM, 1 =PM)
• # =scheidingsteken

Om bijvoorbeeld de tijd en datum "08:35:12 AM, 05-01-2018" in te stellen, moeten we sturen:

T1801050835120# 

Naar het apparaat waar:

• T =geeft tijdinformatie aan
• 18 =het jaar 2018
• 01 =maand januari
• 05 =datum
• 08 =uur
• 35 =minuten
• 12 =seconden
• 0 =AM
• # =scheidingsteken

Als de bewerking succesvol is, zal de MCU de ontvangen tijd naar de console afdrukken als:

Tijdsupdate ontvangen =T1801050835120Datum en tijd is 8:35:12, 5-1-18 

Als de ingevoerde tijdreeks ongeldig is, wordt het onderstaande bericht afgedrukt:

Ongeldige tijdinvoer - ,  

Nadat u de tijd met succes hebt ingesteld, houdt de RTC deze bij zolang er stroom voor beschikbaar is. U kunt de zojuist ingestelde tijd controleren door de "t" . te sturen opdracht. Het instellen van het alarm is vergelijkbaar met dit, behalve dat het gegevensformaat anders is. Om het alarm in te stellen, moet je het verzenden als:

AMMDDhhmmssp# 

Waar:

• A =geeft alarminformatie aan
• MM =maand
• DD =datum
• uu =uur
• mm =minuten
• ss =seconden
• p =tijdsperiode (0 =AM, 1 =PM)
• # =scheidingsteken

Houd er rekening mee dat er geen jaarinformatie is bij de alarmreeks, omdat we deze uiteraard niet nodig hebben. Om mijn verjaardag bijvoorbeeld in te stellen op "08:00:00 AM, 28-08" moet ik het volgende verzenden:

A08240800000# 

U kunt de alarmtijd op elk moment controleren met het commando "a" . Zodra de alarmtijd en -datum zijn ingesteld, is het tijd om de MCU in de slaapstand te zetten. Het apparaat drukt dus het volgende bericht af:

Alles is ingesteld. Schakel de ingestelde tijdpin nu uit. 

Nu moet u de tijdinstellingsschakelaar UIT zetten, dwz trek de digitale pin 3 HOOG (de 10K pull-up zal dat doen). Het systeem slaapt pas als u dit doet. Wanneer de schakelaar voor het instellen van de tijd is uitgeschakeld, gaat het apparaat binnen 6 seconden naar de slaapstand en drukt het onderstaande bericht ervoor af.

Goed gedaan! Slapen in 6 seconden.. 

Zo stel je dus de tijd en het alarm in. Wanneer u nu de tijd moet controleren of bijwerken, kunt u de schakelaar voor de timerinstelling aanzetten en het systeem zal ontwaken, seriële communicatie tot stand brengen en u vragen de tijd te verzenden. Het zal het volgende bericht afdrukken bij het wakker worden,

Serial Established.Time update wake up.Ready to update time. 

Als je alleen wilt controleren of de tijd klopt en niets wilt veranderen, stuur dan "c" commando om de bewerking te annuleren en het systeem weer in de slaapstand te zetten. U moet op dit moment ook de schakelaar voor het instellen van de tijd uitschakelen.

Wanneer de huidige tijd overeenkomt met de alarmtijd, bijv. uw verjaardag, genereert de RTC een onderbrekingssignaal van 250 mS naar de digitale pin 2 van de Nano. Dit signaal zal het systeem wakker maken. Wanneer u wakker wordt, weet het apparaat dat u jarig bent en brengt het seriële communicatie tot stand (alleen als u de USB hebt aangesloten) en drukt het het volgende bericht af,

Tada! Het is jouw verjaardag! Fijne B'Day  :)Tot ziens op je volgende verjaardag! TC. Dag! Slapen in 6 seconden.. 

En het zal ook de LED knipperen die is aangesloten op digitale pin 13. Hier is een screenshot van de Arduino seriële monitor terwijl ik het systeem aan het testen was.

Zo bedient u dit apparaat dus. Lees het volgende gedeelte om dit op codeniveau te begrijpen.

Stap 8:Codeer

Dit project is volledig open source en daarom heb ik de broncode voor de firmware op mijn GitHub gepubliceerd op https://github.com/vishnumaiea/Birthday-Alarm/ onder MIT-licentie. U bent vrij om zonder enige beperking aan te passen, te wijzigen en te verspreiden. Als u een backlink naar dit project zou toevoegen vanuit uw gewijzigde, zou dat op prijs worden gesteld. Ik heb de code grondig becommentarieerd en waar mogelijk rechttoe rechtaan gemaakt.

We hebben in totaal 13 functies/procedures in de code. Dit zijn:

1. ongeldige setup() 

Dit is de setup-functie van de Arduino die alles initialiseert en de configuratieregisters van de ISl1208 RTC instelt.

2. void loop() 

De hoofdlusfunctie.

3. ongeldig sleepNow() 

Deze functie beëindigt alle communicatie, schakelt de interne randapparatuur van de MCU uit, verbindt de onderbrekingen met digitale pinnen 3 en 2 en zet het systeem in de diepe slaapmodus. Bij elke interrupt gaat de uitvoering van het programma verder vanaf de regel na sleep_mode() . Merk op dat voordat deze normale programma-uitvoering wordt hervat, de MCU de interruptserviceroutines zou hebben voltooid die zijn gekoppeld aan de interrupt-pinnen die alarmInterrupt() zijn en timeUpdateInterrupt()

4. ongeldig alarmInterrupt() 

De ISR die is gekoppeld aan de INT0 onderbreken op digitale pin 2.

5. void timeUpdateInterrupt() 

De ISR die is gekoppeld aan de INT1 onderbreken op digitale pin 3.

6. void fetchTime() 

fetchTime() leest de tijdregisters van de RTC en drukt de huidige tijd af op de console.

7. ongeldig blinkLED() 

Knippert duidelijk met de LED's.

8. bool vestigingSerial() 

Brengt seriële communicatie tot stand met behulp van een USB-naar-serieel module.

9. bool endSerial() 

Beëindigt seriële communicatie.

10. byte bcdToDec(byte) 

Accepteert een BCD (Binary Coded Digits) waarde en vertaal deze naar de corresponderende decimale waarde. We hebben dit nodig omdat de RTC alleen BCD-waarden opslaat en accepteert. We moeten dus af en toe converteren van en naar BCD.

11. byte decToBcd(byte) 

Accepteert een decimale waarde en vertaalt deze naar de overeenkomstige BCD-waarde.

12. void printTime() 

Leest de RTC-tijdregisters en drukt de huidige tijd af naar de console wanneer "t" commando is ontvangen.

13. ongeldig printAlarmTime() 

Leest de RTC-alarmregisters en drukt de alarmtijd en -datum af naar de console wanneer de "a" commando is ontvangen.

Stap 9:Testen

Dit zou het meest interessante deel van dit project zijn, waar je zult weten hoe ik uiteindelijk een apparaat heb gemaakt dat 50 jaar op een knoopcelbatterij draait! Ik maakte eerst een prototype van het hele circuit op een breadboard en voltooide het ontwerp. Ik heb een Li-Ion-batterij (3,6 V) gebruikt voor testdoeleinden om mijn gloednieuwe knoopcellen te sparen. Ik gebruikte mijn Fluke 87 True RMS multimeter voor de huidige metingen. Het heeft een 0,1 uA precisie voor het micro-ampèrebereik.

Laten we eens kijken hoe we de Atmega168P in diepe slaapstand kunnen zetten en het stroomverbruik drastisch kunnen verminderen.

noInterrupts (); //interrupts tijdelijk uitschakelen set_sleep_mode (SLEEP_MODE_PWR_DOWN); // Kies onze favoriete slaapmodus:sleep_enable(); // Set sleep enable (SE) bit:ADCSRA =0; // schakel ADC power_all_disable uit (); // schakelt alle modules digitalWrite uit (LED_PIN, LOW); // schakel LED uit om slaaponderbrekingen aan te geven (); //onderbrekingen opnieuw inschakelen sleep_mode(); //gaat slapen  

Zoals ik al eerder heb gezegd, is dit de eerste keer dat ik de slaapmodus in een microcontroller (MCU) gebruik, omdat ik deze nog nooit eerder nodig heb gehad. De meeste informatie met betrekking tot AVR-slaapstanden is gevonden in deze forumthread en de documentatie van de AVR-bibliotheek.

ATmega168P heeft vijf slaapstanden.

• SLEEP_MODE_IDLE – least power savings
• SLEEP_MODE_ADC
• SLEEP_MODE_PWR_SAVE
• SLEEP_MODE_STANDBY
• SLEEP_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 current. 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 :)