Režimy spánku ESP32 v MicroPythonu

24. díl „volného seriálu“ článků

V minulém dílu našeho seriálu jsme slíbili, že se podíváme na nějaké čidlo komunikující přes sběrnici I²C, ale sliby chyby! Dnes uděláme malý krok stranou. Proč? Rozhodli jsme se, že nebudeme pokračovat v nekonečném popisování různých senzorů, ale místo toho se zaměříme na širší téma, které může zlepšit využití těch, které jsme tu již prozkoumali. A pokud se přitom naučíme něco nového, bude to skvělé.

Obsah článku:

Režimy spánku modulu ESP32
Probuzení časovačem
Externí probuzení
- Externí probuzení – ext0
- Externí probuzení – ext1
Probuzení dotykovým (kapacitním) pinem

V dnešním článku se tedy budeme věnovat jedné z klíčových funkcí modulu ESP32– jeho režimům spánku. Ukážeme si, jak rozlišit mezi lehkým a hlubokým spánkem a jak tyto režimy využít. Spojení efektivního spánku s chytrým probouzením může přinést zcela nový přístup k řízení senzorů a optimalizaci celkového výkonu systému.

Režimy spánku modulu ESP32

Než se pustíme do praktických ukázek s MicroPythonem na modulu ESP32, je dobré si nejprve osvěžit trochu teorie, abychom pochopili, co všechno nás čeká.

Modul ESP32 nabízí tři hlavní režimy úspory energie: light sleep (lehký spánek), deep sleep (hluboký spánek) a hibernaci (neoficiálně lze považovat za extrémní podmnožinu režimu deep sleep). Každý z těchto režimů se liší nejen v míře spotřeby energie, ale také v rychlosti probuzení a možnosti zachování aktuálního stavu systému. V tomto článku se zaměříme pouze na dva základní režimy, které se ukážou jako nejpraktičtější pro běžné aplikace:

1. Light sleep (lehký spánek)

Spotřeba energie: Tento režim nabízí výrazně nižší spotřebu energie než běžný provoz, ale stále více než režim deep sleep. Při lehkém spánku jsou některé komponenty, jako WiFi, Bluetooth nebo CPU, vypnuté, ale základní procesy stále běží, což umožňuje rychlé probuzení do aktivního režimu.
Běh programu: Když modul přechází do režimu light sleep, program neukončuje svou činnost úplně. To znamená, že ESP32 „usne“, ale po probuzení může pokračovat tam, kde přestal, aniž by došlo k resetu. To je výhodné v případech, kdy využíváme časovače nebo signály z GPIO pro probuzení – kód může pokračovat plynule, jakmile je zařízení opět aktivní.
Probouzení: Modul se může probudit na základě různých podnětů, jako je signál z GPIO pinů (např. stisknuté tlačítko nebo signál od senzoru) nebo po uplynutí nastaveného časového intervalu. Probouzení je v tomto režimu mnohem rychlejší než u hlubokého spánku.
Použití: Tento režim je ideální pro aplikace, které potřebují nízkou spotřebu energie, ale zároveň je nutné na ně rychle reagovat – například u dotykových senzorů, detekce pohybu nebo jiných situací, kdy je potřeba udržet zařízení v připravenosti bez plného aktivování všech funkcí.

2. Deep sleep (hluboký spánek)

Spotřeba energie: V tomto režimu dosahuje ESP32 nejnižší spotřeby energie. Většina komponent, včetně CPU, WiFi a Bluetooth, je vypnutá, což znamená, že zařízení je v podstatě „vypnuté“. Přesto může reagovat na některé externí podněty, jako je přerušení z GPIO nebo jiné signály.
Běh programu: Při přechodu do deep sleep se celý program zastaví. Modul ESP32 se prakticky vypne, a když se probudí (například na základě časovače nebo externího přerušení), začne běžet znovu od začátku. To znamená, že stav programu, proměnné, RAM a procesy se ztratí – vše začíná od nuly.
Probouzení: Probouzení z deep sleep vyžaduje hardwarový reset. Po probuzení začne modul vykonávat kód uložený v souboru, jako je například main.py. ESP32 dokáže detekovat příčinu resetu, takže v programu lze rozpoznat, zda došlo k probuzení po vypnutí, nebo k jinému typu resetu.
Použití: Tento režim je vhodný pro aplikace, kde je kladen důraz na extrémně nízkou spotřebu energie, například u zařízení napájených bateriemi, které mají dlouhou výdrž a nevyžadují časté interakce s procesorem.

Poznámka:: V souvislosti s režimy spánku se někdy setkáme i s termínem „modern sleep“, který se objevuje především v novějších verzích SDK (Software Development Kit) pro ESP32, zejména ve frameworku ESP-IDF od společnosti Espressif. Tento pojem není oficiálním označením režimu spánku na úrovni hardwaru, ale spíše se jedná o souhrnný název pro nový způsob řízení spotřeby energie. Ten se zaměřuje na efektivní spolupráci s operačním systémem FreeRTOS a periferiemi.; Modern sleep představuje vylepšený systém řízení napájení, který automaticky rozhoduje, kdy může čip přejít do režimu light sleep, aniž by to musel ručně nastavovat vývojář. Tento mechanismus využívá pokročilou strategii plánování úloh a nečinnosti procesoru, která je doplněná o přerušení od periferií. Cílem je minimalizovat spotřebu energie, aniž by došlo k přerušení běhu úloh.; Nicméně je důležité zmínit, že MicroPython (stav k roku 2025) tuto funkcionalitu nepodporuje. Modern sleep je totiž silně závislý na integraci s ESP-IDF a FreeRTOS, což jsou systémy, které MicroPython využívá jen v omezené míře.; Z tohoto důvodu se této technologii v našem článku věnovat nebudeme. ☹

Když mluvíme o režimech spánku, nemůžeme opomenout ani možnost, jak modul ESP32 z těchto režimů probudit. 😊

Zdroje probuzení

Po přepnutí modulu ESP32 do režimu spánku existuje hned několik způsobů, jak ho znovu aktivovat:

Použití časovače: Modul se probudí automaticky po uplynutí předem nastaveného časového intervalu.
Externí probuzení: ESP32 se může probudit, pokud dojde ke změně stavu na některém z jeho pinů, například na základě signálu z čidla nebo tlačítka.
Probuzení dotykovým pinem: Tento způsob probuzení je v podstatě speciálním typem externího probuzení. Vzhledem k jeho specifickým vlastnostem si jej ukážeme v následujícím textu zvlášť.

Poznámka:: Občas se v souvislosti se zdroji probuzení zmiňuje také možnost využití tzv. koprocesoru ULP (Ultra Low Power), což je malý procesor uvnitř modulu ESP32, který běží nezávisle na hlavním CPU. Tento koprocesor je velmi úsporný, jeho spotřeba se pohybuje v řádu mikroampérů, a dokáže provádět různé úkoly, jako je čtení z ADC, monitorování GPIO pinů, měření napětí, snímání analogových senzorů a podobně. Hlavní výhodou je, že může probudit hlavní CPU, když splní určité podmínky, které si můžeme naprogramovat.; ALE:; MicroPython sice (již) podporuje možnost probuzení z hlubokého spánku pomocí ULP (Ultra-Low-Power) koprocesoru, který běží nezávisle na hlavním jádře ESP32. Aby však bylo možné tuto funkci využít, je nutné mít připravený binární kód (tzv. ULP program), který bude v koprocesoru spuštěn. Tvorba takového programu není zcela triviální – vyžaduje buď znalost assembleru, nebo využití předkompilovaných binárních souborů, které musí být navíc kompatibilní s verzí MicroPythonu a hardwarem daného zařízení.; Z těchto důvodů se v našem dalším výkladu budeme věnovat jiným způsobům probuzení ze spánku, které jsou jednodušší na implementaci a nevyžadují hlubší zásahy do systému.; Takže se ani této funkci nebudeme věnovat. ☹

Hluboký vs. Lehký spánek

V úvodním programu si ukážeme, jak ESP32 v MicroPythonu přepnout do obou režimů spánku a jak se bude modul chovat po probuzení. Abychom se zatím vyhnuli potřebě připojovat externí hardware, využijeme jako zdroj probuzení časovač. Program, který následuje, uspí ESP32 na 10 sekund (v obou režimech spánku), a poté jej probudí.

Kód, který zde představíme, je poměrně jednoduchý, ale měl by nám dobře ukázat, jak ESP32 reaguje na přechod do jednotlivých režimů spánku.

Ukázka lehkého spánku

Pro podporu lehkého spánku využijeme modul s příznačným názvem lightsleep. Samotný přechod modulu ESP32 do tohoto režimu provedeme pomocí příkazu lightsleep, jehož argumentem je doba v mikrosekundách, po kterou má být modul uspán. Pokud tento příkaz použijeme bez uvedení časového intervalu, modul zůstane v lehkém spánku na neurčito.

Nejdříve si ukážeme celý kód, který je poměrně krátký, a poté si jednotlivé části vysvětlíme podrobněji.

Kód programu:



  from machine import lightsleep, Pin

  from time import sleep


  led = Pin (2, Pin.OUT)

  led.on()


  print("Jsem vzhuru, ale za 5s usnu. Sleduj vestavenou LED")

  sleep(5)


  # lehke uspani na 10 sekund (10000 ms)

  lightsleep(10000)


  print("Ale, ale... Kdopak nas to probudil!")

Co by kód měl dělat?

Po úvodním importu potřebných modulů se rozsvítí vestavěná LED, což nám ukáže, že je ESP32 aktivní. Následně se na sériovém výstupu objeví výpis hlášky. Co je ale zajímavé, je čekací smyčka (v tomto případě na 5 sekund).

Tato smyčka má dva hlavní úkoly:

Vytvoření dostatečného času pro výpis hlášky: Smyslem této čekací smyčky je zajistit, že se před uspáním modulu na sériový výstup dostane celá hláška (výpis na sériový výstup není zrovna nejrychlejší). Pokud tuto smyčku vynecháte, uvidíte, že část dlouhé hlášky se nestihla vypsat před uspáním modulu (viz obrázek níže).

Poskytnutí času pro zastavení programu: Tato „ladící čekací smyčka“ dává možnost vývojáři program zastavit. Pokud spouštíme programy obsahující hluboký spánek pouze v REPL prostředí Thonny IDE, obvykle se nám nějak podaří program ukončit. Jakmile však program nahrajeme přímo do modulu ESP32, běží ve dvou fázích – v aktivní fázi, kdy můžeme program zastavit, a v režimu spánku, kdy je komunikace výrazně omezená. Pokud aktivní fáze programu trvá jen několik milisekund (nebo mikrosekund?), zatímco spánek může trvat několik sekund (nebo minut, hodin…), máme jen velmi malou šanci program zastavit. Proto je důležité při ladění programů v kódu vždy přidat nějakou „ladící čekačku“, do které se můžeme trefit při pokusu o zastavení programu.

Po uplynutí naší „ladící čekačky“ přepneme modul ESP32 do režimu lehkého spánku na 10 vteřin pomocí příkazu:


lightsleep(10000)

Všimněme si, jak se během lehkého spánku chová vestavěná LED! (zůstane svítit)

Po uplynutí 10 vteřin se ESP32 probudí. Jak jsme již zmínili, program pokračuje dál a na sériovém výstupu se objeví hláška: „Ale, ale... Kdopak nás to probudil!“. Jelikož však program není uzavřen v nekonečné smyčce, dojde k jeho ukončení. Výsledek programu můžeme vidět na následujícím obrázku.

Ukázka hlubokého spánku

Pro demonstraci režimu hlubokého spánku použijeme téměř stejný kód jako v předchozím případě. Jedinou změnou bude aktivace hlubokého spánku. Možná vás to překvapí, možná potěší, ale programový modul pro správu tohoto režimu se překvapivě jmenuje deepsleep – stejně tak se jmenuje i příkaz, kterým ESP32 přepneme do tohoto energeticky úsporného stavu.

V kódu bude tedy změna opravdu minimální:

Kód programu:



  from machine import deepsleep, Pin

  from time import sleep


  led = Pin (2, Pin.OUT)

  led.on()


  print("Jsem vzhuru, ale za 5s usnu. Sleduj vestavenou LED")

  sleep(5)


  # hluboke uspani na 10 sekund (10000 ms)

  deepsleep(10000)


  print("Ale, ale... Kdopak nas to probudil!")

Spustíme program a zaměříme se na dva hlavní body:

Chování vestavěné LED – Zatímco v předchozím programu LED svítila neustále, nyní se při přechodu do režimu hlubokého spánku zhasne. To odpovídá charakteristice tohoto energeticky úsporného režimu, kdy je většina činností modulu pozastavena, včetně pinu GPIO2 s připojenou LED.
Chování po probuzení – Jakmile se modul probudí z hlubokého spánku, dojde k resetu celého systému. To znamená, že veškeré informace uložené v paměti jsou ztraceny a program začíná běžet od začátku. Po příkazu deepsleep() se už nikdy neprovede žádný další příkaz v kódu, který byl za příkazem deepsleep(). Takže v našem případě nikdy neuvidíme zprávu „Ale, ale... Kdopak nas to probudil!“

Pokud bychom program spustili v prostředí REPL (například v Thonny IDE), výsledky by vypadaly takto:

Než se podíváme na konkrétní aplikace pro tento režim spánku, ještě ukážeme si, jak zjistit, že probuzení z hlubokého spánku není jen obyčejným resetem.

Tedy, jak to udělat, abychom se i v případě hlubokého spánku dočkali naší tolik očekávané hlášky. 😊

Detekce probuzení z hlubokého spánku

Modul machine v MicroPythonu nabízí metodu reset_cause(), která nám umožňuje zjistit, co způsobilo poslední reset modulu ESP32. K tomu existují také specifické konstanty, které odpovídají různým důvodům resetu. Pokud tedy chceme zjistit, zda byl modul probuzen právě z režimu hlubokého spánku, můžeme použít podmínku:


if machine.reset_cause() == machine.DEEPSLEEP_RESET:

Díky tomu dokážeme upravit náš program tak, aby po probuzení z hlubokého spánku vypsal naši očekávanou zprávu. Takto bude vypadat upravený kód:

Kód programu:



  import machine   # kvuli reset_cause a DEEPSLEEP_RESET
 
  from machine import deepsleep, Pin

  from time import sleep


  led = Pin(2, Pin.OUT)

  led.on()


  if machine.reset_cause() == machine.DEEPSLEEP_RESET:

      print("Ale, ale... Kdopak nas to probudil!")

  else:

      print("Jsem vzhuru, ale za 5s usnu. Sleduj vestavenou LED")

      sleep(5)


      # hluboke uspani na 10 sekund (10000 ms)

      deepsleep(10000)

V tomto kódu jsme použili podmínku pro detekci resetu. Program se tedy rozdělí na dvě větve:

První větev (else:) se aktivuje při prvním spuštění programu, kdy modul ESP32 nejprve zobrazí hlášku: „Jsem vzhuru, ale za 5s usnu. Sleduj vestavenou LED“, pak přejde do režimu hlubokého spánku na 10 sekund.
Druhá větev (aktivovaná po probuzení z hlubokého spánku) se postará o vypsání zprávy „Ale, ale... Kdopak nas to probudil!“. Tato větev nastává, jakmile modul ESP32 detekuje, že reset byl způsoben probuzením z deep sleep režimu.

Pokud program spustíme, uvidíme, že výstup je v něčem odlišný od režimu lehkého spánku. U hlubokého spánku je totiž po probuzení resetován celý systém a na výstupu je vypsána celá plejáda informací.

Poznámka:
: Když jsme zmínili machine.reset_cause(), neměli bychom opomenout i machine.wake_reason(), což je metoda, která vrací číselnou hodnotu příčiny probuzení.; Různým stavům probuzení odpovídají následující kostanty:; machine.TIMER_WAKE ……… (4) …… probuzení časovačem; machine.PIN_WAKE ………… (2) …… probuzení pinem; machine.EXT0_WAKE ……… (2) …… probuzení jedním pinem (ext0); machine.EXT1_WAKE ……… (3) …… proubzení více piny, nebo jedním z více pinů (ext1); machine.TOUCHPAD_WAKE … (5) …… probuzení dotykovým (kapacitním) pinem

UPOZORNĚNÍ:: V předchozích ukázkách jsme se setkali s režimem lehkého spánku (light sleep), který se chová v podstatě jako běžný příkaz sleep v Pythonu. Z hlediska struktury programu i jeho chování, zde není nic, co by pro nás mohlo být nové a inspirativní.; Proto se nyní dále zaměříme jen na režim hlubokého spánku, který je pro úsporu energie mnohem účinnější.

A teď už se konečně pustíme do nějakých praktických ukázek, které nám ukáží, jak tento režim využít v reálných aplikacích. 😊

Probuzení časovačem

Jedním z nejefektivnějších způsobů, jak prodloužit výdrž zařízení, je využití režimu hlubokého spánku (deep sleep). V tomto režimu spotřebovává ESP32 minimum energie a probouzí se pouze při definovaných událostech. Jednou z nejčastějších metod probuzení je v tomto případě použití interního časovače (RTC timer), který umožňuje nastavit přesný čas, po kterém se modul znovu aktivuje.

Jak jsme viděli, modul ESP32 podporuje více úsporných režimů, které umožňují výrazně snížit spotřebu energie podle potřeb konkrétní aplikace. Mezi nejpoužívanější patří hluboký spánek (deep sleep) a lehký spánek (light sleep). Oba režimy využívají interní RTC (Real-Time Clock) časovač jako jeden z možných zdrojů probuzení, a jejich nastavení v MicroPythonu je téměř totožné – liší se především chováním zařízení během spánku a po probuzení.

V MicroPythonu se RTC časovač používá v obou případech velmi podobně. Pro hluboký spánek se volá:


import machine

machine.deepsleep(10000)   # uspat na 10 sekund

Zatímco pro lehký spánek se použije:


import machine

machine.lightsleep(10000)   # uspat na 10 sekund

V obou případech parametr určuje dobu spánku v milisekundách. Rozdíl je v tom, jak systém se spánkem naloží – zda zcela vypne a restartuje se, nebo jen přeruší běh a později naváže.

V následujícím zapojení si ukážeme konkrétní praktické využití režimu spánku a následného probuzení modulu ESP32 pomocí RTC časovače.

Načítání dat z čidla DHT11 pomocí hlubokého spánku a buzení časovačem

V této části se zaměříme na načítání dat z čidla DHT11, které měří teplotu a relativní vlhkost vzduchu. Tento senzor jsme již podrobně probírali v samostatném článku na našem webu: ESP32 a čidlo DHT11/22 v MicroPythonu. V tomto článku najdete nejen podrobný popis, jak s tímto čidlem pracovat, ale i schéma zapojení, které si pro náš projekt opět použijeme. Jen připomínáme, že použití externího pull-up rezistoru (typicky 4,7–10 kΩ) se odvíjí od toho, zda je náš modul s čidlem DHT11 již tímto rezistorem osazen, či nikoliv – viz blokové schéma zapojení.

DHT11 je skvělé čidlo pro základní měření teploty a vlhkosti, a přitom jeho spotřeba je relativně nízká, což z něj činí ideální komponentu pro projekty, kde chceme šetřit energii – například při používání režimu hlubokého spánku na ESP32.

V následující tabulce naleznete přehled propojení jednotlivých pinů modulu ESP32 s čidlem DHT11:

Modul ESP32	Čidlo DHT11
3V3	+Vcc
D4	Signal
GND	GND

Možná si o čidle DHT11 pamatujeme, že to není žádný superrychlý senzor. Na druhou stranu, pro domácí meteorologickou stanici je naprosto ideální – nabízí dobrý poměr ceny a výkonu. Čidlo DHT11 může být použito jako součást systému, který sleduje podmínky v nějakém prostoru, přičemž data o teplotě a vlhkosti jsou periodicky odesílána do hlavní řídicí jednotky.

Takové řešení obvykle znamená, že čidlo DHT11 a připojený modul ESP32 budou běžet na baterii. A to je přesně ten případ, kdy musíme hodně šetřit energií. Když například chceme měřit teplotu a vlhkost každou hodinu, není vůbec nutné, aby procesor v modulu ESP32 běžel celý ten čas a stále jen setrvával v čekací smyčce. Náš cíl je tedy vytvořit program, který většinu času stráví v hlubokém spánku a probudí se pouze tehdy, když je potřeba načíst data z čidla DHT11.

Samozřejmě pro testování programu nastavíme kratší časový interval, abychom nemuseli čekat celou hodinu, než uvidíme výsledek probuzení modulu ESP32.

Tradičně začneme tím, že si ukážeme celý kód, a poté si vysvětlíme, jak funguje.

Kód programu:



  from machine import Pin, sleep, deepsleep

  from time import localtime, sleep

  import dht


  # Inicializace DHT čidla (pro DHT11)

  print("Stabilizace čidla...")

  sensor = dht.DHT11(Pin(4))   # pro DHT11, pro DHT22 použijte dht.DHT22(Pin(4))

  # Po inicializaci čidla přidáme krátkou pauzu pomocí light sleep, aby se čidlo stabilizovalo

  sleep(2)   # Čekání 2 sekundy


  # Výpis aktuálního času

  current_time = localtime()   # Vrátí aktuální čas jako tuple (rok, měsíc, den, hodina, minuta, sekunda, den v týdnu, den v roce)

  print(f"Aktuální čas: {current_time[3]:02}:{current_time[4]:02}:{current_time[5]:02}")


  # Měření teploty a vlhkosti

  try:

      sensor.measure()

      print(f"Teplota: {sensor.temperature():.1f} °C")

      print(f"Vlhkost: {sensor.humidity():.0f} %")

  except OSError as e:

      print('Problém s načtením čidla')


  # Interval mezi měřeními (v milisekundách)

  sleep_interval = 60000   # 60 sekund (1 minuta)


  # Přejít do light sleep režimu na daný interval (pro tento případ)

  print(f"Usinam na {sleep_interval / 1000:.0f} sekund...")

  deepsleep(sleep_interval)   # Přechod do light sleep režimu na daný interval

Pokud se podíváme na původní kód pro práci s čidlem DHT11 (publikováno v dřívějším článku), všimneme si, že se hned v několika ohledech změnil. Funkčně významnou změnou je odstranění hlavní nekonečné smyčky. Důvod je jednoduchý – při probuzení z hlubokého spánku bude následovat „probouzecí“ resetování, takže nemá cenu načítat hodnoty jakkoliv cyklicky.

Druhou změnou je přidání modulu localtime, který slouží pro práci s časem. Abychom mohli ve výstupu vidět, kdy přesně došlo k probuzení modulu ESP32 z hlubokého spánku, vypisujeme na výstup kromě naměřených hodnot teploty a vlhkosti i aktuální čas. Aktuální čas načítáme do proměnné current_time pomocí metody localtime(), která vrací seznam (tuple) časových údajů (rok, měsíc, den, hodina, minuta, sekunda, den v týdnu, den v roce).

Pokud chceme tento kód vyzkoušet tak, jak by měl fungovat v naší meteorologické stanici, je potřeba spustit program přímo na modulu ESP32, a ne pouze v REPLu prostředí Thonny IDE. To znamená, že program uložíme přímo do paměti ESP32 jako soubor main.py. Tento soubor můžeme v prostředí Thonny IDE uložit pomocí možnosti Uložit jako… nebo Uložit kopii… a pak zvolit volbu Micropython zařízení. Nahrajte kód do souboru main.py v zařízení ESP32, kupříkladu pomocí Uložit kopii… (viz obrázek)

Po uložení programu do modulu ESP32 stačí stisknout resetovací tlačítko na vývojovém kitu a program se spustí. Prostředí Thonny IDE nám bude nyní jen sloužit k zobrazení výstupu, který modul ESP32 generuje. Výsledný výstup vidíme na následujícím obrázku. Abychom viděli časové prodlevy mezi jednotlivými akcemi, je kromě teploty a vlhkosti vypisován i aktuální čas.

Externí probuzení

Některé piny modulu ESP32 (konkrétně piny 0, 2, 4, 12–15, 25–27, 32–39) jsou při režimu hlubokého spánku připojeny k modulu RTC (Real-Time Clock). To znamená, že tyto piny lze použít k probuzení zařízení z hlubokého spánku pomocí funkcí jako wake_on_… z modulu esp32. Důležitým poznatkem je, že výstupní piny RTC (všechny kromě pinů 34–39) si během hlubokého spánku uchovávají svou konfiguraci pull-up nebo pull-down rezistoru.

Pokud během režimu hlubokého spánku není potřeba aktivně používat pull-up nebo pull-down rezistory a hrozí, že by způsobily únik proudu (například když je pull-up rezistor připojen k zemi přes přepínač), je dobré je před vstupem do režimu hlubokého spánku vypnout. Tímto způsobem můžeme výrazně šetřit energii a prodloužit životnost baterie.


# Vypnutí pull-up a pull-down rezistorů na pinu

pin.init(pull=None)

Co je to RTC?

RTC v modulu ESP32 znamená Real-Time Clock – reálný časový hodinový obvod. Na rozdíl od běžného RTC čipu, který je samostatný a slouží výhradně k uchovávání času (například s použitím baterie), je v modulu ESP32 integrovaný RTC blok, který má širší funkcionalitu:

Počítání času – RTC může být použit k měření času, například k probuzení ESP32 po určitém čase v režimu hlubokého spánku.
RTC RAM – Speciální malá paměť (∼8 KB), která zůstává zachována i během režimu hlubokého spánku.
RTC GPIO – Některé piny GPIO jsou připojeny k RTC, což umožňuje jejich využití i v případě, že hlavní CPU je vypnuté.
Wake-up zdroje – RTC může probudit hlavní CPU pomocí časovače, externího pinu nebo dotykového senzoru.
Spolupráce s ULP koprocesorem – RTC koordinuje běh ULP (Ultra Low Power) koprocesoru během režimu hlubokého spánku, což výrazně šetří energii.

Použití RTC GPIO pro externí probuzení je skvělým způsobem, jak ušetřit energii, protože modul může strávit většinu času v hlubokém spánku a probudit se pouze v reakci na konkrétní vnější signál.

Modul ESP32 nabízí možnosti, jak probudit zařízení z režimu spánku pomocí změny stavu pinu. Existují dvě hlavní možnosti, jak toho dosáhnout: ext0 a ext1. Tyto režimy využívají RTC GPIO piny, což jsou speciální piny připojené k Real-Time Clock (RTC) modulu, které zůstávají aktivní i během režimu hlubokého spánku, a umožňují probuzení zařízení na základě vnějších signálů.

Režim ext0: Tento režim umožňuje použití jednoho GPIO pinu jako zdroj probuzení. V praxi to znamená, že můžete připojit externí zařízení, které změní stav tohoto pinu (např. tlačítko nebo PIR senzor), a tím probudit ESP32 z režimu spánku. Režim ext0 je vhodný pro jednodušší aplikace, kde není potřeba víc než jeden externí signál pro probuzení.
Režim ext1: Na rozdíl od režimu ext0 umožňuje ext1 použití více než jednoho GPIO pinu jako zdroj probuzení současně. Tento režim je užitečný, pokud chcete, aby více externích signálů mohlo probudit ESP32. Například můžete použít kombinaci senzorů, tlačítek nebo jiných zařízení k probuzení modulu, což zajišťuje flexibilitu při návrhu systému.

V obou případech lze jako zdroj probuzení použít pouze RTC GPIO piny. Tyto piny jsou speciálně navrženy pro práci v režimech nízké spotřeby, jako je deep sleep, a jsou schopny detekovat změnu stavu i při vypnutém hlavním procesoru. V následujícím diagramu rozložení pinů modulu ESP32 (námi používaný typ ESP32-WROOM32 DEVKITC) jsou RTC GPIO piny zvýrazněny.

Externí probuzení – `ext0`

Pro ilustraci použití externího buzení ext0 použijeme probuzení pomocí tlačítka. Abychom nemuseli připojovat externí tlačítko, využijeme jako zdroj buzení interní tlačítko použitého kitu s modulem ESP32 (na našem vývojovém kitu připojeno na pin GPIO0).

Následující skript ukazuje, jak ext0 funguje: používá jeden GPIO (zde GPIO0) jako externí zdroj probuzení.

Kód programu:



  import machine   # kvuli reset_cause a DEEPSLEEP_RESET
 
  import esp32

  from machine import Pin

  from time import sleep


  wake1 = Pin(0, mode = Pin.IN)

  led = Pin(2, Pin.OUT)


  if machine.reset_cause() == machine.DEEPSLEEP_RESET:

      print("Byl jsem vzbuzen!")


  #LED ON

  led.on()


  # parametr musi byt: esp32.WAKEUP_ANY_HIGH nebo esp32.WAKEUP_ALL_LOW

  esp32.wake_on_ext0(pin = wake1, level = esp32.WAKEUP_ALL_LOW)


  print("Jsem vzhuru. Za 10 sekund pujdu spat!")

  sleep(10)


  print("Usinam...")

  sleep(0.1)


  machine.deepsleep()   # Spí do dalšího probuzení

Jak kód funguje

Nejprve je potřeba importovat potřebné moduly. Oproti předchozím programům, nyní musíte importovat modul esp32, který obsahuje metody pro nastavení pinu jako zdroje probuzení. Po importu potřebných modulů především definujte probuzovací pin, zde jde o objekt wake1. V tomto případě používáme GPIO0, což odpovídá vestavenému tlačítku našeho vývojového kitu. Chceme-li použít jiný pin, je to možné, jen je třeba zkontrolovat zda je to pin z rodiny RTC. Budící GPIO pin by měl být nastaven jako vstup (Pin.IN) případně jako vstupní pin s interním pull-up (pull=Pin.PULL_UP) nebo pull-down (pull=Pin.PULL_DOWN) rezistorem.


wake1 = Pin(0, mode=Pin.IN)

Poté nastavujeme jako zdroj probuzení režim ext0, na to slouží metoda wake_on_ext0():


esp32.wake_on_ext0(pin=wake1, level=esp32.WAKEUP_ALL_LOW)

Metoda wake_on_ext0() má dva argumenty a to:

pin: objekt pinu GPIO, který slouží jako zdroj probuzení
level: definuje stav GPIO pinu, který probouzí ESP32. Úroveň může být jedna z následujících konstant:
- esp32.WAKEUP_ANY_HIGH (jakýkoliv z pinů – zde ten jediný – má hodnotu HIGH)
- esp32.WAKEUP_ALL_LOW (všechny piny – zde ten jediný – mají hodnotu LOW)

Poznánka:: Pokud Vám připadá pojmenování konstant podivné, tak je pravda, že pro použití jediného probouzecího pinu to působí zvláštně. Je třeba si ale uvědomit, že ještě existuje režim ext1, kde může být použito probouzecích pinů hned několik a pak název konstant přímo naznačuje logiku jejich vyhodnocení.

V našem případě má nezmáčknuté tlačítko na pinu GPIO0 hodnotu HIGH, takže probuzení musí vyvolat hodnota LOW. To odpovídá nastavení level = esp32.WAKEUP_ALL_LOW.

Hlavní kód po nastavení parametrů probuzení z režimu hlubokého spánku opět obsahuje naši tradiční „ladící čekací smyčku“ . Po takto nastavených 10 sekundách se modul ESP32 uvede do režimu hlubokého spánku. To, že uplynula „ladící čekací smyčka“ signalizuje modul ESP32 zhasnutím vestavené LED. Pozorný čtenář již jistě ví, že vestavěná LED sama zhasne, jakmile modul ESP32 upadne do hlubokého spánku.


machine.deepsleep()

Těsně před zapnutím hlubokého spánku je vypsána zpráva „Usínám…“ a je zde i 0,1 s prodleva, aby se tato zpráva stihla vypsat na sériový výstup, tedy zobrazit ve výstupu prostředí Thonny IDE.


print('Usinam...')

sleep(0.1)

Po probuzení modulu ESP32 z režimu spánku je testována příčina resetu. Pokud jde o reset po hlubokém spánku, je vypsána hláška: „Byl jsem vzbuzen!“


if machine.reset_cause() == machine.DEEPSLEEP_RESET:

    print("Byl jsem vzbuzen!")

Ukázka externího probuzení

Aby vše fungovalo, jak má, je třeba kód programu uložit přímo do modulu ESP32. Pokud bychom kód spouštěli jen v REPL prostředí Thonny IDE, nespustil by se znova po probuzení modulu ESP32 programový kód.

Upozornění:: Je třeba si dát pozor i na opačný efekt, kdy v prostředí Thonny IDE upravíme programový kód, ale neaktualizujeme jej v souboru main.py v pythonovském zařízení.; Spustíme program v REPL (tedy aktualizovaný kód), ale v okamžiku probuzení modulu ESP32 z hlubokého spánku se spouští soubor main.py v zařízení (tedy původní nezaktualizovaný kód).

Nahrajte kód do souboru main.py v zařízení ESP32, kupříkladu pomocí Uložit kopii… Poté stiskneme tlačítko EN/RESET, tím se spustí kódu na modulu ESP32. Po zhasnutí vestavěné LED (zastal hluboký spánek) můžeme stisknutím vestavěného tlačítka modul ESP32 probudit z hlubokého spánku. O průběhu celého procesu uspání a vzbuzení nás informuje výstupní okno prostředí Thonny IDE – viz následující obrázek.

Externí probuzení – `ext1`

Jelikož nás ještě čeká několik dalších ukázek, dovolíme si metodu externího probuzení s více piny (ext1) trochu ošidit. Asi je jasné, že externí probuzení ext1 funguje velmi podobně jako ext0, takže se mu nemusíme tolik věnovat. Ukážeme si tedy, jak by se změnil předešlý kód, kdybychom do něj chtěli přidat možnost probuzení modulu ESP32 pomocí dalšího tlačítka.

Upravený kód vypadá následujícím způsobem, dále si vysvětlíme, jak kód funguje a jaké změny jsme tedy provedli.

Kód programu:



  import machine   # kvuli reset_cause a DEEPSLEEP_RESET
 
  import esp32

  from machine import Pin

  from time import sleep


  wake1 = Pin(0, mode = Pin.IN)

  wake2 = Pin(4, mode = Pin.IN, pull=Pin.PULL_UP)


  led = Pin(2, Pin.OUT)


  if machine.reset_cause() == machine.DEEPSLEEP_RESET:

      print("Byl jsem vzbuzen!")


  #LED ON

  led.on()


  # parametr musi byt: esp32.WAKEUP_ANY_HIGH or esp32.WAKEUP_ALL_LOW

  esp32.wake_on_ext1(pins = (wake1, wake2), level = esp32.WAKEUP_ALL_LOW)


  print("Jsem vzhuru. Za 10 sekund pujdu spat!")

  sleep(10)


  print("Usinam...")

  sleep(0.1)


  machine.deepsleep()   # Spí do dalšího probuzení

Jak jsme řekli, kód je podobný příkladu ext0, ale používá wake_on_ext1() metodu. Pochopitelně musíme přidat zadání dalšího budícího pinu, zde pin GPIO4. Jelikož chceme připojit k modulu ESP32 co nejméně externích součástek, připojíme jen tlačítko, které bude připojovat pin proti zemi (viz schéma).

K tlačítku připojenému na pinu GPIO4 softwarově připojíme interní pull-up rezistor.


wake2 = Pin(4, mode=Pin.IN, pull=Pin.PULL_UP)

Z hlediska zadání seznamu „probouzecích“ pinů je pro nás důležité zadání seznamu těchto pinů přes parametr pins v metodě esp32.wake_on_ext1. V kódu vidíme, že do tohoto parametru lze předat všechny potřebné objekty pinů v podobě seznamu uzavřeného v závorkách.


esp32.wake_on_ext1(pins=(wake1, wake2), level=esp32.WAKEUP_ALL_LOW)

Názvy konstant pro parametr level zde oproti předchozí ukázce již dávají jasný význam: WAKEUP_ANY_HIGH – buď jakýkoliv pin je HIGH, nebo WAKEUP_ALL_LOW – všechny pinu jsou LOW.

Tyto možnosti a význam tohoto nastavení je třeba dobře zvažovat při elektronickém návrhu konstrukce. Pokud bychom se kupříkladu rozhodli, že chceme probudit modul ESP32 v případě, kdy pin GPIO4 bude mít hodnotu HIGH a zároveň bude stisknuté vestavěné tlačítko (GIPO0), tedy hodnota LOW, máme prostě smůlu – taková konfigurace zde není možná!

Funkčnost kódu je tedy následující. Modul ESP32 po zapnutí oznámí, že za deset sekund usne a po té době se přepne do úsporného režimu deep sleep. Pokud stiskneme jakékoliv z tlačítek samostatně, nic se neděje. Jakmile stiskneme obě tlačítka současně, modul se probere a oznámí „Byl jsem probuden!“. Stav bdělosti signalizuje i vestavěná LED – je-li modul probuzen, LED svítí, při hlubokém spánku LED nesvítí.

Probuzení tlesknutím

Jestliže jsme si probuzení časovačem ukázali na praktickém příkladu načítání čidla DHT11, zkusíme si i probuzení pomocí externího pinu (ext0) aplikovat na dříve již používané čidlo. Pro naši ukázku použijeme zvukové čidlo KY-037, které jsme v článku věnovanému dvojici principálně podobných čidel trochu ošidili, kdy jsme se spíše věnovali čidlu magnetickému.

V našem zapojení (viz následující obrázek) využijeme jen digitání výstup tohoto čidla. Pokud je v okolí čidla relativně ticho, je na výstupním digitálním pinu hodnota LOW. Překročí-li hladina hluku určitou úroveň, překlopí se výstup do úrovně HGH. A právě tento okamžik bude pro nás signál pro probuzení modulu ESP32. Takové zapojení je možné použít jako jednoduchý alarm tříštícího se skla, plačícího dítěte a nebo (jako v našem případě) detekci tlesknutí.

K následujícímu schématu zapojení připojíme jednu připomínku. Pokud bychom použili zapojení čidla KY037 z našeho předchozího článku (článek: ESP32: Magnetické nebo zvukové čidlo v MicroPythonu), zapojení by nefungovalo! Problém je v tom, že pro probuzení modulu ESP32 musíme použít RTC pin – v předchozím zapojení jsme měli pin DO připojený k GPIO19, který ale RTC není!

Takže musíme pin DO přepojit na některý z RTC pinů.

Použijeme kupříkladu pin GPIO4:


SENSOR_DIGITAL_PIN = 4   # diginal OUT pin

wake1 = Pin(SENSOR_DIGITAL_PIN, mode=Pin.IN)

Kód programu necháme téměř stejný, jako u ukázky probuzení s vestavěným tlačítkem (probuzení ext0). Jedinou úpravou ohledně probouzení je změna probouzecí úrovně pinu. V případě tlačítka jsme budili modul ESP32 úrovní LOW, zde se při hluku na výstupu DO objevuje úroveň HIGH. To musíme zohlednit v příkazu wake_on_ext0:


esp32.wake_on_ext0(pin=wake1, level=esp32.WAKEUP_ANY_HIGH)

Následující kód tedy snad už není třeba příliš vysvětlovat.

Kód programu:



  import machine   # kvuli reset_cause a DEEPSLEEP_RESET
 
  import esp32

  from machine import Pin

  from time import sleep


  SENSOR_DIGITAL_PIN = 4   # diginal OUT pin


  wake1 = Pin(SENSOR_DIGITAL_PIN, mode = Pin.IN)

  led = Pin(2, Pin.OUT)


  if machine.reset_cause() == machine.DEEPSLEEP_RESET:

      print("Byl jsem vzbuzen!")


  #LED ON

  led.on()


  # level parametr musi byt: esp32.WAKEUP_ANY_HIGH nebo esp32.WAKEUP_ALL_LOW

  esp32.wake_on_ext0(pin = wake1, level = esp32.WAKEUP_ANY_HIGH)


  print("Jsem vzhuru. Za 10 sekund pujdu spat!")

  sleep(10)


  # LED OFF

  led.value(0)

  print("Usinam...")

  sleep(0.1)


  machine.deepsleep()

Po uložení programu do souboru main.py v paměti modulu ESP32 stačí program restartovat tlačítkem RESET (EN) a pak si zatleskat. Výstupní okno prostředí Thonny IDE by mělo ukázat následující průběh událostí.

Pochopitelně před takto ukázkovým výstupem je třeba vhodně nastavit spouštěcí úroveň modulu KT-037 pomocí jeho nastavovacího trimru. Jak uvidíme, zvukový modul je v okolí rozhodovací oblasti poměrně nestabilní, takže se zpočátku budou objevovat buď falešná probuzení, nebo se naopak bude projevovat určitá necitlivost. Ale až se nám to po chvilce šroubování trimrem podaří přesně nastavit, budeme mít o to větší důvod k zatleskání. 😊

Probuzení dotykovým (kapacitním) pinem

Posledním ze způsobů, jak probudit ESP32 z hlubokého spánku, je využití jeho dotykových (kapacitních) pinů. Některé piny na ESP32 totiž podporují tzv. capacitive touch – tedy schopnost detekovat změnu kapacity, například při dotyku prstem nebo připojení dotykového senzoru. Ne všechny piny však tuto funkci mají – záleží na konkrétním rozložení RTC pinů. (viz pinout ESP32 – dotykové piny vyznačeny)

V této závěrečné část bychom si rádi ukázali nejen, jak v MicroPythonu nakonfigurovat dotykové probuzení, ale (ať se naučíme ještě něco navíc) i jak využít speciální RTC paměť pro uložení obsahu proměnné dvěma mezi probuzeními z hlubokého spánku. To se hodí například pro záznam počtu probuzení – jak v další ukázce uvidíme.

RTC paměť – víc než jen hodiny

Možná už víme, že RTC (Real-Time Clock) obvod na modulu ESP32 není jen o čase. Obsahuje i vlastní paměť, která „přežije“ hluboký spánek. Tato paměť (∼8kB) zůstává tedy zachována i po „probouzecím“ resetu. Skvělé místo pro uložení proměnných, které chceme zachovat mezi jednotlivými probuzeními! V naší ukázce budeme do této paměti ukládat počet probuzení. Vždy, když se ESP32 probudí, načte aktuální hodnotu, přičte k ní 1 a uloží ji zpět. Díky tomu si zařízení bude „pamatovat“, kolikrát bylo probuzeno.

Pro uložení proměnné do paměti RTC si vytvoříme následující funkci save_wake_count:


def save_wake_count(count):

    rtc = machine.RTC()

    rtc.memory(str(count).encode())   # Uložení počtu do RTC paměti

Tato funkce převede zadanou číselnou hodnotu do podoby řetězce a následně pomocí metody encode ji uloží v podobě binárního řetězce. Tím máme vyřešeno, že zde může být uložena jakákoliv číselná hodnota, bez ohledu na její velikost (nebo znaménko).

Pro načtení hodnoty z paměti RTC si definujeme následující funkci load_wake_count:


def load_wake_count():

    rtc = machine.RTC()

    try:

        # Zkuste načíst počet z RTC paměti

        wake_count = rtc.memory()

        if wake_count == b'':   # Pokud není hodnota v paměti, nastavíme na 0

            return 0

        else:

            return int(wake_count.decode())

    except Exception as e:

        return 0

Vidíme, že zápis i čtení z/do paměti RTC se provádí v obou případech metodou memory, rozdíl je jen zda má či nemá argument. V případě načítání hodnoty z RTC paměti jsme kód trochu rozšířili. Důležitá je podmínka, která otestuje načtený binárního řetězec. Pokud spustíme program poprvé, je RTC paměť prázdná. Načtená hodnota tedy bude prázdný binární řetězec. V takovém případě musíme vrátit hodnotu 0.

Pokud RTC paměť „něco“ obsahuje, převede se to na řetězec, který se funkce pokusí převést na celé číslo pomocí funkce int. Pokud by v paměti byla uložena struktura, kterou nelze převést na číslo (např. binární podoba textu „AHOJ“), došlo by k chybě. Vznik případné chyby je tedy podchycen tím, že celá tato část kódu je vložena do struktury try/except. Chyba je tím ošetřena a výstupní hodnota v takovém případě bude nastavena také na 0.

Jakmile máme funkce pro zápis a čtení RTC paměti, můžeme se vrátit k probouzení modulu ESP32 pomocí dotykového pinu.

Nastavení dotykového pinu

Trochu zavzpomínáme na náš dřívější článek: Kapacitní piny modulu ESP32 a MicroPython a připomene si, jak nastavit dotykový (kapacitní) pin.

Podobně jako u připojení interního ADC při načítání analogového signálu, zde musíme vstupnímu pinu připojit nadstavbovou obsluhu – zde dotykové načítání:


wake = Pin(4, mode = Pin.IN)

touch = machine.TouchPad(wake)

Objekt wake nám představuje „probouzecí“ pin, objekt touch pak tzv. Touch API, které měří kapacitní změny na konkrétním pinu. To nám umožní načítat jeho kapacitní odezvu pro zpracování v programovém kódu.

Jelikož se dotykový pin chová tak trochu jako analogový signál, tedy vrací určitý rozsah hodnot, je potřeba stanovit, při jaké hodnotě má vyvolat probuzení z režimu spánku. Tedy vlastně, která hodnota je z hlediska probouzení ze spánku LOW a která již HIGH. Lze se říci, že chceme nastavit, aby se tento „analogový“ pin tak trochu choval jako pin digitální. To nastavíme pomocí metody config(). Metoda config() nastavuje citlivost – tedy hodnotu, pod kterou má být pin považován za „aktivní“ (dotykový) pro probuzení.


touch.config(400)

Aby modul reagoval na dotyk během spánku, musíme aktivovat probouzení příkazem esp32.wake_on_touch(). Dokumentace platná pro MicroPythonu (pro modul ESP32!) uvádí, že se zde zadává booleanovský argument (True/False), který aktivuje/deaktivuje schopnost probouzet modul ESP32 dotykově. A booleanovského argumentu se budeme držet!*⁾ I když se tu a tam na internetu objeví informace o jiném typu argumentu.

*⁾ V tomto tvrzení se opíráme i o článek How to use ESP32’s sleep and wake-up modes in MicroPython od autora Nikhil Agnihotri.

Zároveň k tomu dodáme, že musíme počítat s tím, že se modul ESP32 bude probouzet dotykem na kterýkoliv dotykovým pin s připojeným Touch API. Nelze tedy v programu specifikovat, kdybychom tam měli definováno více dotykových pinů, který pin (jako jediný) může modul ESP32 probudit.

esp32.wake_on_touch(True)

Z hlediska nastavení dotykových (kapacitních) pinů máme snad již definitivně hotovo! Pojďme na ukázkový program:

Kód programu:



  import machine   # kvuli reset_cause a DEEPSLEEP_RESET
 
  from machine import Pin

  import time

  import esp32


  led = Pin(2, Pin.OUT)   #GPIO22 as output for LED

  led.on()     #LED is ON


  wake = Pin(4, mode = Pin.IN)

  touch = machine.TouchPad(wake)

  touch.config(400)

  esp32.wake_on_touch(True)


  def load_wake_count():

      rtc = machine.RTC()

      try:

          # Zkuste načíst počet z RTC paměti

          wake_count = rtc.memory()

          if wake_count == b'':   # Pokud není hodnota v paměti, nastavíme na 0

              return 0

          else:

              return int(wake_count.decode())

      except Exception as e:

              return 0


  def save_wake_count(count):

      rtc = machine.RTC()

      rtc.memory(str(count).encode())   # Uložení počtu do RTC paměti


  # Načtení aktuálního počtu probuzení

  wake_count = load_wake_count()


  if machine.reset_cause() == machine.DEEPSLEEP_RESET:

      print("Byl jsem vzbuzen!")

      # Inkrementace počtu probuzení

      wake_count += 1

      print(f'Počet probuzení: {wake_count}')

      # Uložení počtu probuzení

      save_wake_count(wake_count)


  print("Jsem vzhuru. Za 10 sekund pujdu spat!")

  print("Az zhasne LED, sahni na dotykovy pin.")


  time.sleep(10)


  # LED OFF

  led.off()


  machine.deepsleep()

Jelikož jsme si celý program trochu rozebrali již před samotným kódem, nyní spíše jen shrneme jeho základní funkci.

Po startu program definuje nastavení GPIO pinů a definuje funkce pro zápis a čtení RTC paměti.
Následně načte z paměti RTC hodnotu, která určuje počet probuzení.
Pokud byl program probuzen z hlubokého spánku je vypsána hláška o probuzení a vypsán počet probuzení.
Následuje zvýšení počtu probuzení a uložení této hodnoty do RTC paměti. Tím část spuštěná po probuzení končí a pokračuje kód, který se spouští vždy.
Program vyčká 10 sekund a pak se modul ESP32 přepne do režimu hlubokého spánku. To je signalizováno zhasnutím vestavěné LED. Od tohoto okamžiku je možné modul ESP32 probudit dotykem na nastavený dotykový pin.

Chování programu vidíme na následujících obrázcích – zejména ve výstupním okně prostředí Thonny IDE.

Na výpisu vidíme kromě jednotlivých probuzení i zvyšující se počet probuzení, který se ukládá do paměti RTC a díky tomu se nenuluje při probouzecím resetu.

Závěr

Naše putování světem ESP32 a MicroPythonu nás tentokrát zavedlo do zákoutí, kde se šetří každý mikroampér – k úsporným režimům spánku. Ukázali jsme si rozdíl mezi lehkým a hlubokým spánkem, kdy se který hodí a jak správně nastavit probuzení (káva nepomáhá – GPIO nebo časovač ano!). Přestože jejich použití není složité, správná volba režimu může mít zásadní dopad na výdrž celého zařízení – zejména pokud běží na baterii.

Uspání ESP32 není jen o tom „vypnout, co zrovna nepotřebujeme“. Jde o vyvážený kompromis mezi úsporou energie, dobou probuzení a možností reagovat na události. Dobře zvolený režim může znamenat, že zařízení vydrží v provozu týdny, možná i měsíce bez zásahu.

Autor článku: Miroslav Panoš

A co příště?

Možná už zase něco s nějakými čidly, možná jiný kousek magie… Záleží, jak se – nejen naše ESPčko – vyspí! 😊

Pokračování: ESP32: Barometrické čidlo BMP180 v MicroPythonu

Režimy spánku ESP32 v MicroPythonu

Režimy spánku modulu ESP32

1. Light sleep (lehký spánek)

2. Deep sleep (hluboký spánek)

Zdroje probuzení

Hluboký vs. Lehký spánek

Ukázka lehkého spánku

Ukázka hlubokého spánku

Detekce probuzení z hlubokého spánku

Probuzení časovačem

Načítání dat z čidla DHT11 pomocí hlubokého spánku a buzení časovačem

Externí probuzení

Externí probuzení – ext0

Ukázka externího probuzení

Externí probuzení – ext1

Probuzení tlesknutím

Probuzení dotykovým (kapacitním) pinem

RTC paměť – víc než jen hodiny

Nastavení dotykového pinu

Závěr

Externí probuzení – `ext0`

Externí probuzení – `ext1`