Az autóm akkumulátorával kapcsolatban egy ideje felmerült egy probléma.
Ha az autó csak néhány órát áll, az akkumulátor feszültségével látszólag minden rendben van. Hagyományos multiméterrel mérve nem tapasztaltam olyan jelenséget, ami egyértelműen megmagyarázná, hogy néhány nap állás után miért tud jelentősen lemerülni az akkumulátor.
A probléma az, hogy egy multiméterrel végzett néhány órás mérésből nem feltétlenül derül ki, ha például az autó valamelyik vezérlőegysége, riasztója, komfortelektronikája vagy más fogyasztó időnként felébred.
Ezért olyan egyszerű adatgyűjtőt szerettem volna készíteni, amely az autó álló helyzetében folyamatosan figyeli az akkumulátor feszültségét, és minden méréshez eltárolja a pontos időpontot is.
A cél tehát nem az volt, hogy az autó használata közben mérjek, hanem kifejezetten az, hogy az autó több órán vagy akár több napon keresztül álljon, miközben a készülék például tízpercenként feljegyzi az akkumulátor aktuális feszültségét.
Így utólag számítógépen meg lehet nézni, hogy mikor és milyen mértékben változott az akkumulátor feszültsége.
Az ötlet
A feladat valójában meglehetősen egyszerű:
akkumulátor - feszültségmérés - időbélyeg - SD-kártya
Ehhez egy Arduino Nano-t használtam, amelyhez egy DS1307 valós idejű óra (RTC) és egy MicroSD-kártya modul csatlakozik.
Az Arduino tízpercenként felébred, megméri az akkumulátor feszültségét, kiolvassa az aktuális dátumot és időt a DS1307-ből, majd egy CSV fájlba menti az adatokat.
A mérések között a Nano alvó módba kerül, így a fogyasztása jelentősen csökkenthető.
A hardver
A projektben szándékosan olyan alkatrészeket használtam, amelyek már rendelkezésre álltak, illetve olcsón beszerezhetők.
Felhasznált alkatrészek
Arduino Nano V3.0, ATmega328P
DS1307 RTC modul
MicroSD Card Adapter, szintillesztővel
MicroSD kártya
179,46 kΩ ellenállás - mért érték, a programban meg kell adni, hogy a mérés pontos legyen
12,16 kΩ ellenállás - mért érték, a programban meg kell adni, hogy a mérés pontos legyen
100 nF kerámia kondenzátor
MP1584 állítható DC-DC step-down modul
megfelelő vezetékek
Miért Arduino Nano?
Eredetileg felmerült az ESP32 használata is, de végül nem volt rá szükség.
Az Arduino Nano már rendelkezésre állt, és a feladat elvégzéséhez teljesen elegendő.
Az ESP32 előnyei, például a WiFi és a nagyobb számítási teljesítmény, ebben a projektben egyáltalán nem szükségesek.
A Nano:
kezeli az RTC-t,
kezeli az SD-kártyát,
elvégzi az analóg mérést,
időnként elmenti az adatokat,
a köztes időben pedig alvó módba kerül.
Ennyi feladathoz tökéletesen megfelel.
Az időmérés – DS1307
Az időbélyeghez egy meglévő DS1307 RTC modult használtam.
A DS1307 pontossága ehhez a feladathoz megfelelő. Nem laboratóriumi időalapra van szükség, hanem arra, hogy például egy többnapos mérés során meg tudjam mondani:
„Szombaton 23:40 körül még 12,6 V volt az akkumulátor, vasárnap hajnalban pedig már 12,2 V.”
Ehhez a DS1307 pontossága elegendő.
A modul saját elemmel rendelkezik, így az Arduino kikapcsolása után is tovább tartja az időt.
Az Arduino programjában az RTC automatikus beállítása ki van kapcsolva. Ez azért fontos, mert nem szeretném, hogy minden újraindításkor vagy programfeltöltéskor az óra visszaálljon.
Az egyszeri beállítás után az RTC önállóan tartja az időt.
Az akkumulátor feszültségének mérése
Az Arduino Nano analóg bemenete maximum a tápfeszültségéhez közeli feszültséget tud mérni, ezért a 12 V-os autóakkumulátort nem lehet közvetlenül az A0 bemenetre kötni.
Feszültségosztót használunk.
A kapcsolás:
Miért éppen ezek az ellenállások?
Nem ragaszkodtam laboratóriumi pontosságú ellenállásokhoz.
A rendelkezésre álló 5%-os ellenállások közül multiméterrel kiválasztottam a két legközelebbi értéket, majd magukat az ellenállásokat meg is mértem.
A tényleges értékek:
R1 = 179,46 kΩ
R2 = 12,16 kΩ
A programban ezért nem a névleges 180 kΩ és 12 kΩ érték szerepel, hanem a ténylegesen megmért érték.
Ez egyszerű módszerrel javítja a mérés pontosságát.
A feszültségosztó ellenőrzése
A kész áramkört először nem az autóban próbáltam ki.
Egy labor tápegységet használtam, amely körülbelül 13 V-ot adott.
A feszültségosztó középpontján multiméterrel körülbelül 0,819 V-ot mértem.
Ez megfelelt a várható értéknek.
Ezután az Arduino saját mérését is összehasonlítottam egy multiméterrel.
A labor tápegység ténylegesen: 12,899 V volt.
Az első Arduino-mérés a még nem kalibrált állapotban: 13,081 V volt.
Az Arduino belső 1,1 V-os referenciaértékét ezután a tényleges méréshez igazítottam.
A programban végül:
ADC_REFERENCE = 1,0847 V értéket használtam.
A kalibrálás után az Arduino által mért értékek például:
12,897 V
12,898 V
12,899 V
12,898 V
12,897 V
12,898 V
értékek körül mozogtak, miközben a multiméter 12,899 V-ot mutatott.
Ez számomra ehhez a feladathoz teljesen megfelelő pontosság.
Az SD-kártya
Az adatokat MicroSD kártyára mentem.
A használt modul:
Micro SD Card Adapter
A modulon szintillesztés is található, ezért az Arduino Nano-val használható.
A csatlakozások:
SD modul Arduino Nano
GND → GND
VCC → 5V
CS → D10
SCK → D13
MOSI → D11
MISO → D12
A naplófájl neve:
AKKU.CSV
Az adatok formátuma
A fájl CSV formátumú, így egyszerűen megnyitható például Excelben vagy más táblázatkezelőben.
A fejléc:
Datum, Ido, Feszultseg_V
Egy mérési sor például:
2026-09-09, 11:41:00, 13.081
Ez azért praktikus, mert később egyszerűen lehet belőle grafikont készíteni.
A tápellátás
Az Arduino Nano 5 V-os tápellátását egy MP1584 típusú, állítható DC-DC step-down modullal oldottam meg.
A modul kimenetét előzetesen multiméterrel pontosan 5,00 V-ra állítottam.
A feszültségmérő osztó ettől függetlenül közvetlenül az akkumulátor feszültségét méri.
Fogyasztás
A készülék fogyasztását külön is megmértem.
Nyugalmi állapotban körülbelül:
6 mA volt az áramfelvétel.
Amikor az SD-kártyára írt, az áram rövid időre körülbelül:
15 mA értékre ugrott, majd azonnal visszaesett.
Ez egy ilyen adatgyűjtő esetében számomra teljesen elfogadható.
A Nano a két mérés között alvó módba kerül, így nem dolgozik folyamatosan.
A mérési időköz
A végleges mérési időköz:
kb 10 perc.
Az Arduino a watchdog időzítő segítségével többször, körülbelül 8 másodperces szakaszokban alszik.
A végleges programban:
75 ciklus van beállítva.
A laboratóriumi tesztelés során ezt rövidebbre állítottam, hogy ne kelljen minden mérés között tíz percet várni.
Például 45 ciklussal körülbelül 6 és fél percenként készített méréseket.
A teszt során a következő eredményeket kaptam:
2026-09-09, 11:21:36, 13.037
2026-09-09, 11:28:04, 13.082
2026-09-09, 11:34:32, 13.075
2026-09-09, 11:41:00, 13.081
2026-09-09, 11:47:28, 13.069
A teszt során az RTC időpontjai folyamatosan és szabályosan haladtak, az SD-kártyára minden mérés bekerült.
Miért nem mérünk gyakrabban?
Az autó akkumulátorának ilyen jellegű vizsgálatánál nincs szükség másodpercenkénti mintavételre.
A cél nem az, hogy egy rövid indítási vagy terhelési eseményt rögzítsünk, hanem az, hogy hosszabb állás alatt lássuk az akkumulátor feszültségének változását.
Ha például egy vezérlőegység időnként felébred, és emiatt az akkumulátor feszültsége elkezd csökkenni, egy 10 perces mintavétel mellett is jól látható lesz a hosszabb távú tendencia.
A ritkább mérés egyben azt is jelenti, hogy a készülék kevesebb időt tölt aktív állapotban.
A próba
A készüléket nem akartam azonnal az autóba tenni.
Először asztalon próbáltam ki:
RTC ellenőrzés,
SD-kártya ellenőrzés,
fájl létrehozása,
feszültségmérés,
kalibrálás,
időbélyeges mentés,
hosszabb folyamatos működés.
A teszt során többször egymás után működött az adatmentés.
A félórás próba alatt az RTC sem veszítette el az időt, és minden mérés bekerült az SD-kártyára.
A végleges rendszer működése
A működés lényegében a következő:
A Nano:
felébred,
kiolvassa az időt a DS1307-ből,
megméri az akkumulátor feszültségét,
az értékeket elmenti az SD-kártyára,
visszatér alvó módba,
majd körülbelül tíz perc múlva újra elvégzi ugyanezt.
Mire szeretném használni?
A készülék végső célja egy hosszabb, például hétvégi mérés.
Az autó ilyenkor használaton kívül marad, a logger pedig folyamatosan naplózza az akkumulátor feszültségét.
Ha az autó valamelyik elektronikai rendszere időnként felébred, vagy valamilyen ismeretlen fogyasztó miatt az akkumulátor lassabban vagy gyorsabban merül, annak a hosszabb távú hatása már láthatóvá válhat a naplóban.
A mérés után az SD-kártyát egyszerűen ki lehet venni, a CSV fájlt számítógépen meg lehet nyitni, és akár grafikont is lehet készíteni az akkumulátor feszültségéről.
Fontos megjegyzés
Ez a készülék nem közvetlen áramfelvételt mér, hanem az akkumulátor feszültségének változását naplózza.
Ez fontos különbség.
A feszültség változásából következtetni lehet arra, hogy mi történik az akkumulátorral, de önmagában egy feszültséggörbe nem bizonyítja, hogy pontosan melyik fogyasztó okozta az akkumulátor merülését.
Ha a naplóban gyanús időpont vagy feszültségesés látható, akkor a következő lépés lehet az adott időszak célzott vizsgálata nyugalmiáram-méréssel.
Eredmény
A végeredmény egy egyszerű, olcsó és kis fogyasztású akkumulátor-feszültséglogger lett.
A rendszer:
Arduino Nano alapú,
DS1307 RTC-t használ,
MicroSD kártyára ment,
időbélyeggel együtt tárolja a méréseket,
10 percenként mér,
a mérés között alvó módot használ,
körülbelül 6 mA körüli nyugalmi fogyasztással működik,
és a feszültségmérés labor tápegységgel összehasonlítva nagyon jó egyezést adott.
A projekt legfontosabb része számomra az, hogy nem kell többé órákon keresztül a multimétert néznem.
Elég az autót állva hagyni, a logger pedig elvégzi helyettem a mérést és elmenti, hogy mikor mennyi volt az akkumulátor feszültsége.
Ha néhány nap után az akkumulátor ismét jelentősen lemerül, már lesz egy időbélyeges mérési sorozatom, amiből ki lehet indulni a hiba felderítéséhez.
Arduino program
A teljes, magyar kommentekkel ellátott Arduino program:
Kód: Egész kijelölése
/*
============================================================
AUTO AKKU LOGGER - VÉGLEGES PROGRAM
============================================================
FELADAT:
Az autó 12 V-os akkumulátorának feszültségét figyeli
álló autónál, és időbélyeggel együtt MicroSD kártyára menti.
HARDVER:
- Arduino Nano V3.0 (ATmega328P, 5 V / 16 MHz)
- DS1307 RTC óramodul
- MicroSD adapter
- 180 kΩ + 12 kΩ feszültségosztó
- 100 nF kondenzátor az A0 és GND között
MÉRÉSI IDŐKÖZ:
10 perc
FÁJL:
AKKU.CSV
============================================================
*/
// ------------------------------------------------------------
// KÖNYVTÁRAK
// ------------------------------------------------------------
#include <Wire.h> // I2C kommunikáció az RTC-vel
#include <RTClib.h> // DS1307 kezelése
#include <SPI.h> // SPI kommunikáció az SD-kártyával
#include <SD.h> // SD-kártya kezelése
#include <avr/sleep.h> // Alvó mód
#include <avr/wdt.h> // Watchdog időzítő
#include <avr/interrupt.h>
// ------------------------------------------------------------
// HARDVER BEÁLLÍTÁSOK
// ------------------------------------------------------------
// Az SD modul CS (Chip Select) lába a Nano D10-re van kötve.
const byte SD_CS_PIN = 10;
// Az akkumulátor feszültségosztójának középpontja az A0 bemenetre megy.
const byte BATTERY_PIN = A0;
// ------------------------------------------------------------
// FESZÜLTSÉGOSZTÓ
// ------------------------------------------------------------
//
// Az akkumulátor pozitív pólusa
// |
// 180 kΩ
// |
// +--------> A0
// |
// 12 kΩ
// |
// GND
//
// Az A0 és GND közé kerül a 100 nF kondenzátor.
//
// A 180 kΩ / 12 kΩ osztó miatt az akkumulátor feszültsége
// erősen le van osztva, így az Arduino A0 bemenetére nem kerül
// közvetlenül a 12-15 V.
//
// Példa:
// 12,6 V akkumulátor -> kb. 0,792 V az A0 bemeneten
//
// ------------------------------------------------------------
const float R1 = 179460.0; // ténylegesen mért érték: 179,46 kΩ
const float R2 = 12160.0; // ténylegesen mért érték: 12,16 kΩ
// ------------------------------------------------------------
// ADC REFERENCIA
// ------------------------------------------------------------
//
// A Nano belső 1,1 V-os referenciafeszültségét használjuk.
//
// A tényleges referenciafeszültség Arduino példányonként kicsit
// eltérhet. Ezért később egy multiméteres mérés alapján
// kalibrálható.
//
// Kezdőértéknek 1,100 V-ot használunk. Nálam az ellenőrző mérés
// után 1.087 V lett a pontos érték.
const float ADC_REFERENCE = 1.0847;
// ------------------------------------------------------------
// MÉRÉSI IDŐKÖZ
// ------------------------------------------------------------
//
// 10 perc = 600 másodperc.
//
// A watchdog maximum kb. 8 másodperces ébresztést tud,
// ezért a program több 8 másodperces alvást használ egymás után.
//
// 75 × 8 másodperc = kb. 600 másodperc.
//
// A valós időzítésnél a watchdog pontossága miatt lehet némi
// eltérés. Az RTC viszont minden mérésnél megadja a tényleges
// dátumot és időpontot.
//
const byte SLEEP_CYCLES = 75;
// ------------------------------------------------------------
// RTC OBJEKTUM
// ------------------------------------------------------------
RTC_DS1307 rtc;
// ------------------------------------------------------------
// WATCHDOG MEGSZAKÍTÁS
// ------------------------------------------------------------
//
// A watchdog felébreszti a Nano-t alvó állapotból.
// Itt nincs szükség külön műveletre, maga a megszakítás
// elegendő az ébresztéshez.
//
ISR(WDT_vect)
{
// Szándékosan üres.
// A watchdog megszakítás csak felébreszti a Nano-t.
}
// ============================================================
// SETUP
// ============================================================
void setup()
{
// Soros kommunikáció a számítógéppel.
// Hibakereséshez és ellenőrzéshez használjuk.
Serial.begin(9600);
delay(1000);
// ----------------------------------------------------------
// INDÍTÓ ÜZENET
// ----------------------------------------------------------
Serial.println();
Serial.println("==============================");
Serial.println(" AUTO AKKU LOGGER");
Serial.println("==============================");
Serial.println();
// ----------------------------------------------------------
// I2C BUSZ INDÍTÁSA
// ----------------------------------------------------------
Wire.begin();
// ----------------------------------------------------------
// DS1307 ELLENŐRZÉSE
// ----------------------------------------------------------
Serial.println("DS1307 ellenorzese...");
if (!rtc.begin())
{
Serial.println("HIBA: DS1307 nem talalhato!");
// Ha nincs RTC, nincs értelme tovább működni.
while (1);
}
Serial.println("DS1307: OK");
// ----------------------------------------------------------
// IDŐ BEÁLLÍTÁSA - NEM HASZNÁLJUK!
// ----------------------------------------------------------
//
// Ezt a sort csak az első beüzemeléskor használjuk az RTC
// beállítására.
//
// MOST KI VAN KOMMENTELVE!
//
// Így a program nem fogja minden feltöltéskor átállítani
// az órát a fordítás időpontjára.
//
// Ha egyszer, évekkel később teljesen lemerül az RTC eleme
// és az óra elveszíti az időt, ezt a sort ideiglenesen
// ki lehet venni a kommentből, feltölteni a programot,
// majd utána ismét vissza kell kommentelni.
//
// rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));
// ----------------------------------------------------------
// RTC AKTUÁLIS IDEJÉNEK KIÍRÁSA
// ----------------------------------------------------------
DateTime now = rtc.now();
Serial.print("RTC ido: ");
printDateTime(now);
Serial.println();
Serial.println("RTC idobeallitas nem tortenik.");
// ----------------------------------------------------------
// SD-KÁRTYA INDÍTÁSA
// ----------------------------------------------------------
Serial.println();
Serial.println("SD kartya ellenorzese...");
if (!SD.begin(SD_CS_PIN))
{
Serial.println("HIBA: SD kartya nem indul!");
// SD nélkül nincs adatmentés.
while (1);
}
Serial.println("SD kartya: OK");
// ----------------------------------------------------------
// AKKU.CSV FÁJL ELLENŐRZÉSE
// ----------------------------------------------------------
if (!SD.exists("AKKU.CSV"))
{
Serial.println("AKKU.CSV nem letezik.");
Serial.println("Fajl letrehozasa...");
File f = SD.open("AKKU.CSV", FILE_WRITE);
if (!f)
{
Serial.println("HIBA: AKKU.CSV nem hozhato letre!");
while (1);
}
// CSV fejléc.
f.println("Datum, Ido, Feszultseg_V");
f.close();
Serial.println("AKKU.CSV letrehozva.");
}
else
{
Serial.println("AKKU.CSV mar letezik.");
}
// ----------------------------------------------------------
// ANALÓG BEMENET
// ----------------------------------------------------------
pinMode(BATTERY_PIN, INPUT);
// ----------------------------------------------------------
// ELSŐ MÉRÉS
// ----------------------------------------------------------
//
// Bekapcsolás után nem kell 10 percet várni.
// Az első mérés azonnal bekerül a fájlba.
//
Serial.println();
Serial.println("Elso meres:");
writeMeasurement();
Serial.println();
Serial.println("Logger mukodik.");
Serial.println("Uj meres kb. 10 percenkent.");
}
// ============================================================
// LOOP
// ============================================================
void loop()
{
// ----------------------------------------------------------
// 10 PERCES ALVÁS
// ----------------------------------------------------------
//
// A Nano nem fut folyamatosan, hanem alszik.
// Ez csökkenti az ATmega328P saját fogyasztását.
//
// 75 × kb. 8 másodperc = kb. 10 perc.
//
for (byte i = 0; i < SLEEP_CYCLES; i++)
{
sleep8Seconds();
}
// ----------------------------------------------------------
// ÚJ MÉRÉS
// ----------------------------------------------------------
writeMeasurement();
}
// ============================================================
// FESZÜLTSÉGMÉRÉS
// ============================================================
//
// Több ADC-mérést végzünk, majd átlagoljuk őket.
//
// Ez csökkenti a pillanatnyi zajból származó ingadozást.
//
float measureBatteryVoltage()
{
// ----------------------------------------------------------
// BELSŐ 1,1 V-OS REFERENCIA BEKAPCSOLÁSA
// ----------------------------------------------------------
analogReference(INTERNAL);
// Kis várakozás, hogy a referencia stabilizálódjon.
delay(5);
// ----------------------------------------------------------
// ELSŐ MÉRÉS ELDOBÁSA
// ----------------------------------------------------------
//
// Referenciaváltás után az első ADC-érték néha nem teljesen
// megbízható, ezért ezt nem használjuk.
//
analogRead(BATTERY_PIN);
// ----------------------------------------------------------
// 16 MÉRÉS ÁTLAGOLÁSA
// ----------------------------------------------------------
const byte NUMBER_OF_READINGS = 16;
unsigned long total = 0;
for (byte i = 0; i < NUMBER_OF_READINGS; i++)
{
total += analogRead(BATTERY_PIN);
delay(2);
}
float averageADC =
(float)total / NUMBER_OF_READINGS;
// ----------------------------------------------------------
// ADC ÉRTÉK -> A0 FESZÜLTSÉG
// ----------------------------------------------------------
//
// A 10 bites ADC 0-1023 közötti értéket ad.
//
float voltageAtA0 =
averageADC * ADC_REFERENCE / 1023.0;
// ----------------------------------------------------------
// A0 FESZÜLTSÉG -> AKKUMULÁTOR FESZÜLTSÉGE
// ----------------------------------------------------------
//
// Feszültségosztó képlete:
//
// Uakku = UA0 × (R1 + R2) / R2
//
float batteryVoltage =
voltageAtA0 * (R1 + R2) / R2;
return batteryVoltage;
}
// ============================================================
// MÉRÉS ÉS SD-MENTÉS
// ============================================================
void writeMeasurement()
{
// ----------------------------------------------------------
// AKTUÁLIS IDŐ KIOLVASÁSA
// ----------------------------------------------------------
DateTime now = rtc.now();
// ----------------------------------------------------------
// AKKUFESZÜLTSÉG MÉRÉSE
// ----------------------------------------------------------
float voltage = measureBatteryVoltage();
// ----------------------------------------------------------
// ADAT KIÍRÁSA A SOROS MONITORRA
// ----------------------------------------------------------
printDateTime(now);
Serial.print(" ");
Serial.print(voltage, 3);
Serial.print(" V");
// ----------------------------------------------------------
// SD FÁJL MEGNYITÁSA
// ----------------------------------------------------------
File f = SD.open("AKKU.CSV", FILE_WRITE);
if (!f)
{
Serial.println(" SD: HIBA A FAJL MEGNYITASAKOR!");
return;
}
// ----------------------------------------------------------
// DÁTUM
// ----------------------------------------------------------
f.print(now.year());
f.print("-");
if (now.month() < 10)
f.print("0");
f.print(now.month());
f.print("-");
if (now.day() < 10)
f.print("0");
f.print(now.day());
f.print(", ");
// ----------------------------------------------------------
// IDŐ
// ----------------------------------------------------------
if (now.hour() < 10)
f.print("0");
f.print(now.hour());
f.print(":");
if (now.minute() < 10)
f.print("0");
f.print(now.minute());
f.print(":");
if (now.second() < 10)
f.print("0");
f.print(now.second());
f.print(", ");
// ----------------------------------------------------------
// AKKUFESZÜLTSÉG
// ----------------------------------------------------------
f.println(voltage, 3);
// ----------------------------------------------------------
// FÁJL LEZÁRÁSA
// ----------------------------------------------------------
//
// Ez nagyon fontos!
// A close() biztosítja, hogy az adat ténylegesen kiírásra
// kerüljön és a fájl megfelelő állapotban maradjon.
//
f.close();
Serial.println(" SD: OK");
}
// ============================================================
// DÁTUM ÉS IDŐ KIÍRÁSA
// ============================================================
void printDateTime(DateTime t)
{
Serial.print(t.year());
Serial.print("-");
if (t.month() < 10)
Serial.print("0");
Serial.print(t.month());
Serial.print("-");
if (t.day() < 10)
Serial.print("0");
Serial.print(t.day());
Serial.print(" ");
if (t.hour() < 10)
Serial.print("0");
Serial.print(t.hour());
Serial.print(":");
if (t.minute() < 10)
Serial.print("0");
Serial.print(t.minute());
Serial.print(":");
if (t.second() < 10)
Serial.print("0");
Serial.print(t.second());
}
// ============================================================
// NANO ALVÓ MÓD - KB. 8 MÁSODPERC
// ============================================================
//
// A watchdog időzítő kb. 8 másodperc után felébreszti
// a processzort.
//
// Ezt 75 alkalommal ismételjük a 10 perces mérési időközhöz.
//
// FONTOS:
// Az alvó mód az ATmega328P processzor fogyasztását csökkenti.
// A Nano panel többi része (pl. USB-soros áramkör, LED stb.)
// ettől még fogyaszthat áramot.
//
void sleep8Seconds()
{
// ----------------------------------------------------------
// WATCHDOG ELŐKÉSZÍTÉSE
// ----------------------------------------------------------
MCUSR &= ~(1 << WDRF);
// Watchdog módosítás engedélyezése.
WDTCSR |= (1 << WDCE) | (1 << WDE);
// Csak megszakítás legyen, ne reset.
// WDP3 + WDP0 = kb. 8 másodperc.
WDTCSR =
(1 << WDIE) |
(1 << WDP3) |
(1 << WDP0);
// ----------------------------------------------------------
// POWER-DOWN ALVÓ MÓD
// ----------------------------------------------------------
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable();
// ----------------------------------------------------------
// ALVÁS
// ----------------------------------------------------------
noInterrupts();
interrupts();
sleep_cpu();
// ----------------------------------------------------------
// IDE ÉBRED FEL A NANO
// ----------------------------------------------------------
sleep_disable();
// Watchdog kikapcsolása az ébredés után.
wdt_disable();
}