ESP
DIYer
32
LAB

Moderní mikrokontrolér v rukou „bastlíře“

Pozvání do MicroPythonu

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

Vítejte u „nultého“ dílu seriálu věnovaného praktickému programování mikrokontroléru ESP32 v prostředí MicroPython. Pokud přicházíte ze světa tradičního Arduina s jazykem C++, nebo s programováním hardwaru teprve začínáte, tento článek by vám měl posloužit jako takový „startovní můstek“.

Rádi bychom zde představili základní vlastnosti MicroPythonu, jako jsou některá jeho syntaktická pravidla, datové struktury a architekturu programů tak, abychom se v následujících dílech seriálu již nemuseli zdržovat základními pojmy a mohli se naplno věnovat pokročilejšímu řízení senzorů, displejů a bezdrátové komunikaci.

Co je MicroPython a jak funguje

Tradiční vývoj pro mikrokontroléry (například na deskách Arduino) staví na kompilovaném jazyce C++. Zdrojový kód se v počítači nejprve celý přeloží do strojových instrukcí a v podobě binárního obrazu nahraje do paměti flash.

kompilace vs REPL

MicroPython na to jde úplně jinak – přináší interpretovaný přístup přímo na čipu modulu ESP32. MicroPython představuje plnohodnotnou, ale paměťově úspornou reimplementaci standardu Python 3. Zajišťuje převod lidsky čitelného zápisu programu do instrukcí procesoru ve třech navazujících fázích:

  1. Zdrojový kód: Text programu zapsaný v syntaxi Pythonu v souboru s příponou .py.
  2. Kompilace do Bytecode: Překladač MicroPythonu přímo v zařízení přeloží zdrojový kód do úsporného mezipaměťového objektového kódu (bytecode).
  3. Virtuální stroj (PVM): Virtuální stroj MicroPythonu čte v operační paměti RAM bytecode řádek po řádku a v reálném čase (runtime) jej vykonává na procesoru.

Výkon moderních mikrokontrolérů, jako je ESP32 nebo Raspberry Pi Pico, je dnes natolik vysoký, že i přes režii virtuálního stroje je vykonávání kódu pro drtivou většinu řídicích a měřicích úloh více než dostatečně rychlé.

Dva režimy práce

Při vývoji v MicroPythonu využíváme dva odlišné režimy práce, které poskytují značnou flexibilitu při testování i finálním nasazení.

Interaktivní režim REPL

Režim REPL (Read-Evaluate-Print Loop) funguje jako interaktivní konzole. Vývojové prostředí (například Thonny IDE) zobrazí po připojení desky výzvu zadanou třemi znaky >>>.

Tento režim pracuje v cyklu čtyř kroků:

  • Read: Interpret přečte zadaný příkaz z konzole.
  • Evaluate: Příkaz vyhodnotí a ihned vykoná v paměti mikrokontroléru.
  • Print: Vytiskne výsledek zpět do konzole.
  • Loop: Čeká na zadání dalšího příkazu.

REPL je neocenitelný nástroj pro rychlé testování hardwaru, zkoušení výpočtů nebo přímou kontrolu stavu pinů bez nutnosti cokoliv ukládat do souborů. V konzoli REPL navíc stačí zadat název proměnné a stisknout Enter pro zobrazení její aktuální hodnoty, a mezi dříve zadanými příkazy lze procházet šipkami nahoru a dolů.

Skriptový režim – soubory main.py a boot.py

Pro trvalé aplikace se kód ukládá do souborové paměti flash mikrokontroléru. Aby deska věděla, co má dělat po připojení napájení nebo po resetu, využívá souborový systém dva speciální vyhrazené skripty.

Funkce souboru main.py:

Když je program nahrán na ESP32, uloží se do paměti desky. Kód se však po resetu desky nebo po odpojení od napájení automaticky nespustí, pokud je uložen pod běžným uživatelským názvem. Aby se MicroPython skript spustil automaticky ihned po přivedení napájení, musí být pojmenován main.py.

Funkce souboru boot.py:

Soubor boot.py se spouští jako první při startu mikrokontroléru, tedy ještě před souborem main.py. Soubor se zpravidla používá pro inicializaci hardwarových sběrnic, připojení k Wi-Fi, nastavení souborového systému apod.

Následující tabulka přehledně srovnává úlohu těchto dvou základních souborů:

Název souboru Okamžik a pořadí spuštění Hlavní účel a typické využití
boot.py Spouští se jako první ihned při startu mikrokontroléru. Inicializace hardwarových sběrnic, připojení k Wi-Fi síti, nastavení souborového systému.
main.py Spouští se automaticky ihned po dokončení boot.py. Hlavní aplikační kód, nekonečné smyčky pro čtení senzorů a řízení akčních členů.
Důležité upozornění pro vývojáře:
Pokud váš hlavní skript v main.py obsahuje nekonečnou smyčku bez jakékoliv pauzy nebo přerušení, může zablokovat sériovou komunikaci s vývojovým prostředím. V prostředí Thonny lze běžící skript zablokovaný v REPL přerušit klávesovou zkratkou Ctrl+C. Nebo provedením klávesové zkratky Ctrl+D vyvoláte tzv. Soft-Reset, který restartuje MicroPython bez odpojení napájení.

Základní syntaktická pravidla MicroPythonu

Přechod z jazyků rodiny C/C++ vyžaduje adaptaci na několik zásadních syntaktických pravidel Pythonu. Python klade důraz na čistotu, stručnost a čitelnost kódu.

Bez středníků:

Řádky se neukončují středníkem ;. Konec příkazu je definován koncem řádku.

Dynamické typování:

V MicroPythonu se proměnné nedeklarují uvedením datového typu (jako int x = 5;). Proměnná vzniká prvním přiřazením hodnoty a typ je určen dynamicky podle vložené hodnoty. Zápis a = 42 vytvoří proměnnou typu int. Pokud do ní později přiřadíme a = a * 1.0, změní se její typ na float.

typovani

Automatické mezerování v print():

Příkaz print("a =", a) při předání více parametrů oddělených čárkou automaticky vloží mezi hodnoty mezeru. Pokud je žádoucí zabránit automatickému odřádkování na konci výstupu, předává se parametr end="" (např. print("a =", a, end="")).

Odsazování kódu (Indentation) namísto složených závorek

Největší změnou pro vývojáře přicházející z Arduino IDE je vymezování bloků kódu. Zatímco v C++ uvozují bloky kódu složené závorky {} a odsazení slouží pouze pro přehlednost, MicroPythonu se závorky za tímto účelem nepoužívají a rozsah bloků kódu definuje odsazení (vnoření podmínek, smyček a funkcí). Nesprávné odsazení vede k chybě syntaxe.

V běžném Pythonu je standardem odsazovat o 4 mezery. V prostředí MicroPythonu na mikrokontrolérech se z důvodu úspory paměti RAM a šířky řádků na menších displejích často využívá odsazování o 2 mezery. Klíčové je zachovat stejnou úroveň odsazení pro všechny řádky v rámci jednoho bloku.

bloky

Dvojtečka na začátku bloku:

Řádek uvozující podmínku, cyklus nebo funkci vždy musíme zakončit dvojtečkou :.

Pravidlo odsazení a ukončení začátku bloku vypadá kupříkladu takto:

teplota = 28.0

if teplota > 25.0:
  # V MicroPythonu lze odsazovat i jen o 2 mezery
  print("Varování: Vysoká teplota!")

Komentáře v kódu

Pro dokumentaci kódu interpret nabízí dva způsoby zápisu:

  • Jednořádkový komentář: Začíná symbolem #. Vše od tohoto znaku do konce řádku interpret ignoruje.
  • Víceřádkový komentář: Lze zapsat buď umístěním symbolu # na začátek každého jednotlivého řádku, nebo využitím víceřádkového řetězcového literálu. Komentář jako dlouhý string (docstring) Používá trojité uvozovky """ nebo '''. Pokud tento dlouhý řetězec není přiřazen do žádné proměnné, interpret jej načte a přeskočí, čímž funguje jako přehledný víceřádkový komentář.
# Jednořádkový komentář: Konfigurace snímače
jas = 85  # Hodnota v procentech

"""
Toto je víceřádkový komentář zapsaný jako dlouhý string.
Může zabírat několik řádků a slouží k podrobnému popisu
funkce nebo celého modulu.
"""

Operátory a číselné soustavy

MicroPython rozšiřuje standardní aritmetiku o užitečné operátory a formáty zápisu čísel:

  • Aritmetické operátory: Součet +, odčítání -, násobení *, běžné dělení /, modulo %.
  • Celočíselné dělení: Operátor // provádí dělení se zaokrouhlením dolů.
  • Umocňování: Operátor ** slouží k mocninám (např. 2**4 spočítá 24 = 16)
  • Číselné soustavy: Zápis čísel podporuje binární soustavu s předponou 0b (např. 0b1010), osmičkovou s 0o (např. 0o52) a šestnáctkovou s 0x (např. 0x2A). Pro převod čísel do řetězce slouží funkce bin(), oct() a hex().

Datové typy, kolekce a paměťový model

MicroPython přizpůsobuje typový systém potřebám vestavěných zařízení.

Základní datové typy

Na rozdíl od C++, kde existují typy jako byte, short, int, long, unsigned long, float či double, rozlišuje MicroPython tyto hlavní typy:

int (Celá čísla):
MicroPython nemá stanoven pevný bitový limit pro celé číslo. Dokáže zpracovávat extrémně velká celá čísla (desítky až stovky cifer) bez přetečení paměti.
float (Desetinná čísla):
Nepodporuje typ double s dvojitou přesností. Typ float má omezenou přesnost přibližně na 7 platných číslic, takže při výpočtech může docházet k drobným odchylkám na posledním místě.
str (Řetězce):
Text uzavřený v uvozovkách nebo apostrofách používá kódování UTF-8. Základní ASCII znaky zabírají 1 bajt, české znaky s diakritikou (např. č, š, ž) zabírají 2 bajty.
bool (Logické hodnoty):
Nabývá výhradně hodnot True nebo False.

Datové kolekce a paměťový model

MicroPython nabízí bohatou škálu datových kolekcí, které se liší podle toho, zda jsou měnitelné (mutable) či neměnitelné (immutable) – viz dále. Nebo zda zachovávají pořadí prvků (indexování).

Lists (Seznamy)
Seznamy jsou velmi flexibilní, měnitelné kolekce definované v hranatých závorkách. Mohou obsahovat prvky různých datových typů. Prvky seznamu lze upravovat, přidávat i mazat. Seznamy mohou jako své prvky obsahovat další seznamy.
l = [42, True, "abc", 66.6]
print(len(l)) # Vrací počet prvků v seznamu
Arrays (Pole)
Pole jsou na rozdíl od seznamů omezená pouze na jeden datový typ, díky čemuž jsou paměťově efektivnější a vhodná pro velké objemy dat.
import array as arr
a = arr.array("i", [3, 7, 9, 25]) # "i" značí datový typ Integer ("f" pro float)
Tuples (N-tice)
Tuples představují neměnitelné (immutable) seznamy. Definují se v kulatých závorkách (). Po vytvoření n-tice již nelze měnit její hodnoty ani upravovat délku.
t = (1, 2, "test")
# t[0] = 5 -> Vyvolá chybu (tuple je neměnný)
Dictionaries (Slovníky)
Slovníky jsou měnitelné (mutable) kolekce definované ve složených závorkách {}, které ukládají data ve formě dvojic klíč–hodnota (key–value). Místo číselných indexů se k hodnotám přistupuje pomocí unikátních a neměnitelných klíčů (například řetězců či čísel), což umožňuje velmi rychlé vyhledávání. Nové dvojice lze do slovníku snadno přidávat a stávající upravovat či mazat.
d = {"teplota": 22.5, "stav": "OK", "pin": 4}
print(d["teplota"]) # Vypíše hodnotu 22.5
d["stav"] = "CHYBA" # Upraví hodnotu pod klíčem "stav"
Sets (Množiny)
Množiny jsou měnitelné (mutable), neuspořádané kolekce unikátních prvků definované ve složených závorkách {} nebo pomocí funkce set(). Neumožňují duplicitní hodnoty a nepodporují indexování, protože nezachovávají pořadí prvků. Hodí se především k rychlému ověření, zda se prvek v kolekci nachází, k odstranění duplicit nebo k provádění matematických množinových operací, jako je sjednocení a průnik.
s = {1, 2, 2, 3, "a"}
print(s) # Vypíše {1, 2, 3, 'a'} (duplicitní dvojka se odstraní)
s.add(4) # Přidá nový prvek do množiny

Bajtová pole (Bytearrays & Bytestrings)

  • Bytearray: Měnitelné pole obsahující pouze bajty (hodnoty 0–255), vytvořené funkcí bytearray().
  • Bytes (Bytestring): Neměnitelná varianta bajtového pole vytvořená funkcí bytes().

Měnitelné vs. neměnitelné objekty a funkce id()

V MicroPythonu je vše objekt. Proměnné jsou názvy, které odkazují na tyto objekty v paměti. Jinými slovy: proměnná v Pythonu není krabička s hodnotou, ale jen jmenovka (štítek), která ukazuje na konkrétní místo v paměti, kde je uložený samotný objekt. Pomocí funkce id() si můžeme zjistit přesnou „adresu“ tohoto objektu v paměti.

Neměnitelné objekty (Immutable)

Patří sem například celá čísla (int), textové řetězce (str) nebo n-tice (tuple). Jakmile takový objekt v paměti vznikne, jeho obsah už nikdy nelze přepsat.

  • Co se stane při změně: Když napíšete x = 10 a pak x = 20, Python nepřepíše desítku na dvacítku. Vytvoří v paměti úplně nový objekt s hodnotou 20 a jmenovku x přesune na něj.
  • Důsledek pro id(): Protože se jmenovka přesunula na nový objekt, funkce id(x) vrátí jiné číslo než předtím.

Měnitelné objekty (Mutable)

Patří sem například seznamy (list), slovníky (dict) nebo pole (array). Tyto objekty fungují jako kontejnery, jejichž vnitřní obsah můžete libovolně upravovat.

  • Co se stane při změně: Když máte seznam seznam = [1, 2, 3] a změníte první prvek pomocí seznam[0] = 99, objekt zůstává na stejném místě v paměti. Změnil se jen jeho vnitřek.
  • Důsledek pro id(): Jmenovka seznam ukazuje stále na ten samý objekt, takže hodnota id(seznam) zůstane naprosto stejná.

Rozdíl nejlépe uvidíte na tomto krátkém příkladu:

# Neměnitelný objekt (int)
a = 5
print(id(a)) # Vypíše např. 1073742000
a = 6 # Vytvoří se NOVÝ objekt
print(id(a)) # Vypíše JINÉ číslo, např. 1073742032
# Měnitelný objekt (list)
muj_list = [1, 2]
print(id(muj_list)) # Vypíše např. 1073801120
muj_list.append(3) # Upraví se STÁVAJÍCÍ objekt
print(id(muj_list)) # Vypíše STEJNÉ číslo: 1073801120

Toto chování je zásadní, když posíláme proměnné jako parametry do vlastní funkce. Do funkce se totiž nikdy nekopírují samotná data, ale pouze ten odkaz (jmenovka) na objekt v paměti.

  • Pošleme-li neměnitelný objekt (např. číslo) – Funkce si uvnitř sebe vytvoří nový objekt a původní proměnná mimo funkci zůstane nedotčená.
  • Pošleme-li měnitelný objekt (např. seznam) – Funkce pracuje přímo s tím samým objektem v paměti. Pokud uvnitř funkce ze seznamu něco smažeme nebo do něj přidáte, změní se nám seznam i v hlavním programu mimo funkci.
def pridej_prvek(data):
    data.append("nový") # Mění přímo původní objekt v paměti

cisla = ["starý"]
pridej_prvek(cisla)
print(cisla)  # Vypíše ['starý', 'nový'] – původní seznam se změnil!

Řídicí struktury a funkce

Větvení if - elif - else

Větvení if - elif - else umožňuje programu v MicroPythonu rozhodovat se na základě splnění určitých podmínek. Kód se vyhodnocuje shora dolů a provede se vždy jen první větev, jejíž podmínka je pravdivá. U mikrokontrolérů jsou podmínky klíčovým nástrojem pro reakce na stavy vstupních pinů, tlačítka a naměřené hodnoty ze senzorů.

Program vyhodnocuje podmínky shora dolů a vykoná pouze první větev, která je pravdivá (True). Bloky kódu musí být správně odsazené.

  • if – Základní podmínka.
  • elif (zkratka z else if) – Nepovinná další podmínka. Testuje se pouze tehdy, pokud předchozí podmínky neplatily. Můžete jich použít libovolný počet.
  • else – Nepovinná záchytná větev na konci. Provede se, pokud nebyla splněna žádná z předchozích podmínek.

Namísto C++ operátorů &&, || a ! se v MicroPythonu používají doslovná anglická slova and, or a not. Také je třeba si všimnout, že v MicroPythonu se podmínka nepíše do závorek.

teplota = 26

if teplota > 30:
    print("Je horko, zapínám klimatizaci.")
elif teplota >= 20:
    print("Teplota je ideální.")
else:
    print("Je chladno, zapínám topení.")

Logické operátory

V jazyce MicroPython fungují logické operátory stejně jako v jiných programovacích jazycích k vyhodnocování pravdivostních hodnot (True a False). Nejčastěji je využijeme v podmínkách if nebo v cyklech while při čtení senzorů a tlačítek.

Operátor Význam Příklad
== Rovná se (pozor, dvě rovnítka) pin.value() == 1
!= Nerovná se stav != "chyba"
> Větší než teplota > 25
< Menší než napeti < 3.3
>= Větší nebo rovno rychlost >= 50
<= Menší nebo rovno baterie <= 10
Praktické tipy
Python umožňuje zapisovat rozsahy velmi přehledně podobně jako v matematice, například if 18 <= teplota <= 24:.
V podmínkách se prázdný seznam [], prázdný řetězec "", číslo 0 nebo hodnota None automaticky vyhodnocují jako False.

Smyčky

V MicroPythonu se používají dva základní typy smyček, for a while. U mikrokontrolérů (např. ESP32, Raspberry Pi Pico, micro:bit) jsou navíc zásadní nekonečné smyčky pro nepřetržitý běh programu a čtení senzorů.

Smyčka while a nekonečná smyčka

Smyčka while opakuje blok kódu tak dlouho, dokud platí zadaná podmínka.

  • Podmíněné čekání. Smyčku while lze použít k čekání na určitý stav, například na stisk tlačítka nebo připojení k Wi-Fi.
  • Zamezení zamrznutí. Uvnitř nekonečných nebo čekacích smyček je vhodné zařadit krátké zpoždění (např. time.sleep_ms(10)), aby se procesor zbytečně nepřetěžoval.

V hardwarových projektech se nejčastěji využívá její nekonečná varianta while True:, která nahrazuje funkci loop() známou z Arduina.

hlavni program

Smyčka for

Smyčka for slouží k procházení sekvencí (seznamů, textových řetězců) nebo k opakování kódu v přesně daném počtu kroků pomocí funkce range().

Funkce range()

Funkce range(start, stop, step) v MicroPythonu slouží k rychlému generování posloupnosti celých čísel, nejčastěji pro řízení smyčky for:

for i in range(1, 4):
  print(i) # Vytiskne 1, 2, 3 (horní mez 4 je neprotnutá)

Funkce range() přijímá jeden až tři celočíselné argumenty:

  • start (volitelný) – První číslo vygenerované posloupnosti. Pokud jej neuvedete, MicroPython automaticky začne od 0.
  • stop (povinný) – Horní (nebo dolní) limit posloupnosti. Toto číslo již není součástí výsledné řady (generování se zastaví těsně před ním).
  • step (volitelný) – Krok, o který se hodnota v každém dalším průchodu změní. Výchozí hodnota je 1, ale lze použít i záporné číslo pro odpočítávání.

Jeden parametr: range(stop)

Generuje čísla od 0 do stop-1. Vhodné pro prosté opakování akce.

# Vypíše čísla 0, 1, 2, 3, 4
for i in range(5):
    print(i)

Dva parametry: range(start, stop)

Generuje čísla od start do stop-1. Hodí se například při nastavování řady GPIO pinů.

# Vypíše čísla 2, 3, 4, 5 (pin 6 už se nezahrne)
for pin_cislo in range(2, 6):
    print("Inicializuji pin:", pin_cislo)

Tři parametry: range(start, stop, step)

Umožňuje přeskakovat hodnoty nebo odpočítávat pozpátku, což je ideální například pro plynulé stmívání LED pomocí PWM.

# Plynulé rozsvícení (krok po 100)
for strida in range(0, 1024, 100):
  &nsbp; print("Jas:", strida)

# Odpočítávání pozpátku (záporný krok)
for odpocet in range(5, 0, -1):
    print("Start za:", odpocet)
Na co si dát v MicroPythonu pozor?
  • Funkce range() nepodporuje desetinná čísla (např. range(0, 1, 0.1) skončí chybou TypeError). Pokud potřebujete desetinný krok, vynásobte rozsah deseti a hodnotu uvnitř smyčky vydělte (i/10).
  • Pokud zadáte nelogické hranice (např. range(10, 5) bez záporného kroku), smyčka se ani jednou neprovede a program nevyhodí chybu.

Řízení běhu smyčky

Běh obou typů smyček lze za chodu upravovat pomocí speciálních klíčových slov:

  • break – Okamžitě ukončí celou smyčku a program pokračuje kódem pod ní.
  • continue – Přeskočí zbytek aktuálního průchodu a rovnou spustí další iteraci smyčky.
  • pass – Prázdný příkaz, který nedělá nic, ale je nutný v prázdných čekacích smyčkách, aby MicroPython nevyhlásil syntaktickou chybu.

Asynchronní smyčky (uasyncio)

Pokud potřebujete vykonávat více smyček zdánlivě najednou (např. blikat LED diodou a zároveň obsluhovat webový server bez blokování příkazem time.sleep()), využívá se v MicroPythonu knihovna uasyncio (v novějších verzích také pod názvem asyncio). Využívá smyčku událostí (event loop) a neblokující čekání await asyncio.sleep(). Ale to už je vychytávka z „vyšší pilotáže“.

Definice funkcí

Definice funkcí MicroPythonu se provádí pomocí klíčového slova def, za kterým následuje název funkce, kulaté závorky a dvojtečka. Parametry ani návratové hodnoty se neuvádějí s datovými typy:

def double_it(i):
  return i * 2 # Stejná funkce zpracuje int, float i str

print(double_it(5))
print(double_it("Hello")) # vytiskne "HelloHello"

Funkce mohou přijímat vstupní data (parametry v závorkách) a vracet výsledek své práce zpět do programu pomocí klíčového slova return.

  • Proměnné uvedené v definici funkce, do kterých se při volání dosadí konkrétní hodnoty (argumenty).
  • Parametru lze nastavit výchozí hodnotu, která se použije, pokud ji při volání nezadáte.
  • Příkaz return okamžitě ukončí běh funkce a předá zadanou hodnotu zpět. Pokud funkce return neobsahuje, vrací automaticky hodnotu None.
# Funkce s parametry, výchozí hodnotou a návratovou hodnotou
def vypocitej_vykon(napeti, proud=0.5):
    vykon = napeti * proud
    return vykon

# Volání funkce s oběma parametry
vysledek1 = vypocitej_vykon(5, 2)
print("Výkon 1:", vysledek1, "W")  # Vypíše: Výkon 1: 10 W

# Volání s využitím výchozího proudu (0.5 A)
vysledek2 = vypocitej_vykon(3.3)
print("Výkon 2:", vysledek2, "W")  # Vypíše: Výkon 2: 1.65 W

Důležitá pravidla pro práci s funkcemi:

  • Funkci musíte v souboru nejprve definovat (pomocí def) a teprve na řádcích pod ní ji můžete zavolat.
  • Proměnné vytvořené uvnitř funkce jsou lokální – existují pouze po dobu běhu funkce a mimo ni nejsou vidět.
  • Rozlišování velikosti písmen (Case-sensitive) – MicroPython rozlišuje malá a velká písmena, takže blikni() a Blikni() jsou pro něj dvě úplně odlišné funkce.
  • V názvu nesmí být mezera (místo ní použijte podtržítko – např. nacti_teplotu()).
  • Bez speciálních znaků. Používejte pouze písmena (ideálně bez diakritiky), číslice a podtržítko _ (žádné pomlčky, vykřičníky ani tečky).
  • Název funkce nesmí začínat číslicí. Název 1_bliknuti() je chyba, ale bliknuti_1() je v pořádku.
  • Žádná klíčová slova. Funkce se nesmí jmenovat stejně jako příkazy jazyka (např. def, if, while, for, return).

Formátování textu

Metoda .format()

Pro pokročilé formátování řetězců se používá metoda .format() nebo formátovací výrazy se složenými závorkami. Tato metoda nahradí složené závorky {} v textu hodnotami zadanými  závorce. Je plně podporovaná ve všech verzích MicroPythonu.

  • Základní vložení více hodnot – Hodnoty se dosazují v přesném pořadí, v jakém jsou uvedeny.
  • Pojmenované zástupné znaky – Pro lepší přehlednost můžete do závorek napsat názvy proměnných.
# Dosazení podle pořadí
print("Teplota: {:.1f} °C, Vlhkost: {} %".format(teplota, vlhkost))

# Pojmenované dosazení
print("Stav: {t:.1f} °C / {v} %".format(t=teplota, v=vlhkost))

Moderní f-řetězce (f-strings)

Od verze MicroPython 1.17 lze před uvozovky napsat písmeno f a proměnné i formátovací pravidla psát přímo do složených závorek. Tento zápis je čitelnější a v MicroPythonu o něco rychlejší.

napeti = 3.284
pin = 2

# Proměnná se píše přímo dovnitř složených závorek
print(f"Pin {pin} má napětí {napeti:.2f} V")
# Výstup: Pin 2 má napětí 3.28 V

Formátovací značky

Uvnitř složených závorek za dvojtečkou : můžete definovat přesný vzhled čísel, což se hodí pro výpis na OLED/LCD displeje nebo do konzole:

Formátovací značka Význam Příklad vstupu Výsledek
:.2f Desetinné číslo na 2 místa 3.14159 3.14
:02d Celé číslo doplněné nulami (ideální pro hodiny/datum) 5 05
:b Převod na dvojkovou (binární) soustavu 10 1010
:08b Binární zápis na 8 bitů (např. stav registru) 10 00001010
:X Převod na šestnáctkovou (hexadecimální) soustavu 255 FF
:>6 Zarovnání doprava na šířku 6 znaků (pro tabulky) 42     42

První kroky s hardwarem

Pro ovládání fyzického hardwaru v MicroPythonu jsou nejdůležitější dva vestavěné moduly: machine (pro přístup ke komponentám čipu) a time (pro práci s časem a zpožděním). Tyto moduly tvoří základ téměř každého projektu na deskách jako ESP32 nebo Raspberry Pi Pico.

Modul machine (ovládání hardwaru)

Modul machine umožňuje MicroPythonu komunikovat přímo s fyzickými vývody (piny) a periferiemi mikrokontroléru. Nejčastěji se z něj importuje třída Pin, která ovládá digitální vstupy a výstupy (GPIO).

  • Výstupní pin (Pin.OUT) – Slouží k odesílání napětí (typicky 3,3 V nebo 0 V) pro rozsvícení LED diody nebo sepnutí relé.
  • Vstupní pin (Pin.IN) – Slouží ke čtení stavu tlačítka nebo digitálního senzoru (vrací 1 nebo 0).
  • Interní rezistory (Pin.PULL_UP/Pin.PULL_DOWN) – Udržují vstupní pin v definovaném stavu, aby na něm neplavalo náhodné rušení při nezapojeném tlačítku.
from machine import Pin

# Nastavení pinu č. 2 jako výstup (často vestavěná LED na ESP32)
led = Pin(2, Pin.OUT)
led.value(1)  # Zapne napětí (logická 1)
led.value(0)  # Vypne napětí (logická 0)

# Nastavení pinu č. 14 jako vstup s interním pull-up rezistorem
tlacitko = Pin(14, Pin.IN, Pin.PULL_UP)
stav = tlacitko.value()  # Přečte stav (1 = nestisknuto, 0 = stisknuto)
Poznámka:
Kromě třídy Pin obsahuje modul machine také třídy ADC pro čtení analogového napětí, PWM pro plynulou regulaci jasu/motorů a sběrnice I2C , SPI či UART.
prace s hardwarem

Modul time (práce s časem)

Modul time slouží k pozastavení běhu programu nebo k měření uplynulého času. V MicroPythonu obsahuje oproti klasickému Pythonu navíc funkce pro práci s milisekundami a mikrosekundami, které jsou u hardwaru nezbytné.

Funkce Popis a použití
time.sleep(s) Pozastaví program na zadaný počet sekund (přijímá i desetinná čísla, např. 0.5).
time.sleep_ms(ms) Pozastaví program na zadaný počet milisekund (1000 ms = 1 s).
time.sleep_us(us) Pozastaví program na zadaný počet mikrosekund (pro velmi rychlé signály).
time.ticks_ms() Vrátí počet milisekund od spuštění desky (ideální pro neblokující časování).
time.ticks_diff(t1, t2) Bezpečně vypočítá rozdíl mezi dvěma časy z ticks_ms().

Ovládání LED tlačítkem

Následující program spojuje oba moduly dohromady. Dokud držíte tlačítko, LED dioda bliká.

from machine import Pin
import time

# Inicializace hardwaru
led = Pin(2, Pin.OUT)
tlacitko = Pin(14, Pin.IN, Pin.PULL_UP)

# Hlavní nekonečná smyčka
while True:
    # Pokud je tlačítko stisknuté (u PULL_UP to znamená hodnotu 0)
    if tlacitko.value() == 0:
        led.value(1)
        time.sleep_ms(200)  # Svítí 200 ms
        led.value(0)
        time.sleep_ms(200)  # Zhasnuto 200 ms
    else:
        led.value(0)
        time.sleep_ms(50)   # Krátká pauza pro úsporu procesoru

Diagnostika a ladění chyb (Debugging)

Vývoj pro mikrokontroléry přináší specifické situace, kdy chyba v kódu vede k zastavení programu nebo k neočekávanému chování hardwaru. Hledání a odstraňování chyb se nazývá ladění (debugging).

Rozlišujeme tři hlavní typy chyb:

  1. SyntaxError (Skladebné chyby): Vznikají porušením pravopisu nebo gramatiky MicroPythonu (např. chybějící dvojtečka na konci řádku if nebo překlep v příkazu). Interpret je odhalí ještě před spuštěním skriptu a v konzoli zobrazí hlášení SyntaxError: invalid syntax.
  2. Runtime errors (Běhové chyby a výjimky): Nastávají během vykonávání programu při pokusu o neproveditelnou operaci:
    • NameError: Odkaz na proměnnou nebo objekt, který dosud neexistuje.
    • ZeroDivisionError: Pokus o dělení nulou.
    • ImportError: Pokus o načtení modulu, který není nainstalován v paměti flash.
    • OSError: Chyba při komunikaci s hardwarovou periferií (např. senzor neodpovídá na I2C sběrnici).
  3. Semantic errors (Významové chyby): Program běží bez chybových hlášení, ale chování neodpovídá záměru vývojáře (např. obrácená podmínka if teplota < 0: místo if teplota > 0:).

ZÁVĚR:

Abyste měli při čtení dalších částí našeho seriálu všechny důležité principy po ruce, připravili jsme rozšířené shrnutí stavebních kamenů jazyka MicroPython.

Rychlý tahák základních pravidel

1. Čistá syntaxe a povinné odsazování

Zapomeňte na středníky ; na konci řádků a složené závorky {} z jazyka C/Arduino. Nový blok kódu (podmínku, cyklus, funkci) se uvozuje dvojtečka : a vše, co do něj patří, musí být odsazeno o 2 nebo 4 mezery (standard v Pythonu).

Pozor:
Nikdy nekombinujte v jednom souboru mezery a tabulátory, MicroPython vám jinak vyhodí chybu odsazení (IndentationError).

2. Dynamické proměnné a práce s pamětí

Proměnným předem neurčujete datový typ, hodnotu jim přiřadíte rovnou (teplota = 24.5 nebo stav = True). MicroPython typ pozná sám a dokáže ho za běhu i změnit.

Tip pro mikrokontroléry:
Desky mají omezenou operační paměť (RAM). Názvy proměnných pište čitelně, ale vyhněte se zbytečnému vytváření obřích seznamů nebo nekonečnému spojování dlouhých textových řetězců uvnitř hlavní smyčky.

3. Kouzelné soubory boot.py a main.py

Aby váš kód běžel samostatně i po odpojení od počítače (např. při napájení z baterie), musíte ho uložit přímo do paměti desky pod názvem main.py.

Při startu deska nejdříve vykoná systémový soubor boot.py (slouží pro základní nastavení hardwaru nebo Wi-Fi) a hned poté automaticky spustí váš main.py.

4. Ovládání pinů a přesné časování

Pro komunikaci s fyzickým světem (LEDky, tlačítka, senzory) importujte třídu Pin z vestavěného modulu machine (from machine import Pin).

Pro pozastavení programu použijte modul time. Kromě klasického time.sleep(1) (čekání v sekundách) v elektronice budete mnohem častěji používat přesnější time.sleep_ms(500) (milisekundy) nebo time.sleep_us(10) (mikrosekundy).

5. Čitelné podmínky a logika

Místo složitých symbolů (&&, ||, !) používá MicroPython srozumitelná anglická slova: and (a zároveň), or (nebo) a not (negace).

Pro větvení více podmínek za sebou slouží zkrácené klíčové slovo elif (zkratka z else if). Pamatujte také na rozdíl mezi přiřazením hodnoty (a = 5) a porovnáním (if a == 5:).

6. Hlavní smyčka programu (while True:)

Na rozdíl od Arduina nemá MicroPython předpřipravené funkce setup() a loop(). Počáteční nastavení napíšete jednoduše na začátek souboru a nekonečnou smyčku, ve které deska neustále dokola čte senzory a ovládá výstupy, vytvoříte pomocí while True:.

7. Záchranná brzda v konzoli (Ctrl+C a Ctrl+D)

Pokud se vám program zacyklí a deska neodpovídá v konzoli (REPL), nezmatkujte a nemusíte hned vytahovat USB kabel:

  • Ctrl+C okamžitě přeruší běžící program a vrátí vás do příkazového řádku.
  • Ctrl+D provede měkký restart (soft reboot) desky a znovu spustí váš kód od začátku.

8. Ladění pomocí print() a čtení chybových hlášek

Nejjednodušším nástrojem pro hledání chyb je funkce print(). Vypisujte si do konzole hodnoty ze senzorů nebo zprávy, do které části kódu program právě dorazil. Když nastane chyba, MicroPython vypíše tzv. Traceback – vždy se dívejte na poslední řádek (typ chyby) a číslo řádku, na kterém k ní došlo.


Zní to na první pohled složitě? Přechod z Arduino IDE na MicroPython sice vyžaduje trochu jiný způsob přemýšlení, ale ve skutečnosti to není žádný obří skok. Nemusíte mít obavy – všechno si projdeme pěkně krok za krokem a ve správný čas si klíčové věci znovu připomeneme.

Tak… a nyní již opravdu začínáme: Instalujeme MicroPython na ESP32
Pošli signál autorovi: