Pojďme programovat elektroniku

Český Maker Badge: Zapomeňte na papírové visačky. Teď si je můžete naprogramovat pro každou akci

  • Maker Badge seženete za 799 korun
  • Je vyzbrojený e-inkem a Wi-Fi čipem ESP32-S2
  • Naprogramujete jej v Pythonu i Arduinu

Pokud jste v životě byli alespoň jednou nějaké konferenci, festivalu nebo větším koncertu, dostali jste u vstupu buď papírový proužek na zápěstí, anebo badge – visačku na krk se šňůrkou. Za ty roky jsem jich posbíral nejspíše stovky a tajně snil o tom, že jednou konečně dostanu elektronickou, na které si zobrazím prakticky cokoliv.

Maker Badge za osm stovek

Mé přání nakonec splnil Miroslav Zuzelka aka @dronecz, který vyrobil (nejen) pro návštěvníky tuzemských festivalů Maker Faire stejnojmenný a plně programovatelný Maker Badge s rozměry 100×60 mm.

Maker Badge v akci:

Elektronická jmenovka pro geeky přijde zájemce na baťovských 799 korun, veškerou dokumentaci najdete na GitHubu a za tuto částku dostanete kapesní prototypovací mikropočítač, který obsahuje:

  • 2,13“ monochromatický e-inkový displej (250×122 pixelů)
  • Modul řídícího počítače s Wi-Fi ESP32-S2-WROOM
  • Čtyři adresovatelné RGB LED WS2812B
  • Pět dotykových plošek pro snadné ovládání
  • Vyvedené všechny piny pro snadné rozšiřování a napojení shieldů
  • Lithiový akumulátor
  • USB-C pro programování a nabíjení

K čemu je to dobré? Maker Badge má na horním okraji otvory pro připojení šňůrky, takže si ho můžete dát právě jako každý jiný konferenční badge přes krk a vyrazit na akci. To, co se zobrazí na displeji, už záleží na vás. Budete si to muset totiž sami naprogramovat.

Maker Badge se může díky snadné rozšiřitelnosti proměnit i v kompletní meteostanici a šperk, který bude slušet každé dívce:

Programuje se v CircuitPythonu i v Arduinu

Ničeho se ale nebojte, Maker Badge je totiž navržený pro snadné bastlení v Pythonu pro mikrokontrolery – CircuitPython, jehož firmware je předinstalovaný už od výroby.

Jelikož se ale o veškerou práci stará mikropočítač z rodiny ESP32, který se těší velké oblibě mezi kutily, samozřejmě si budete moci desku přeprogramovat i v C/C++ a prostředí Arduino, nebo ESP-IDF přímo od výrobce čipu.

Stačí připojit desku k PC a upravit jeden texťák

Na GitHubu najdete základní příklady jak pro Python, tak Arduino a hotový ukázkový skript v CircuitPythonu na vás bude ostatně čekat přímo na čipu.

74f33e36-e99c-4194-9698-f477e4b0e1d1
Maker Badge s firmwarem CircuitPython se po připojení k PC ohlásí jako externí úložiště

Stačí desku připojit skrze USB-C k počítači, načež se ohlásí jako běžné externí úložiště se souborem skriptu hlavního programu code.py. Naprostý začátečník jej může otevřít v libovolném textovém editoru a podle návodu v něm upravit obsah tří řádků, které se mají zobrazit na displeji.

Badge na konferenci i do baru

Zkušení kodéři si pak mohou code.py (nebo main.py) přepsat dle vlastního gusta a spouštět na Maker Badge své unikátní programy.

2f5b686e-26f4-4e62-bc2e-3ea2f5d33eb180213061-c803-49bc-a698-920c5561924c667bcb84-f98a-4218-bf99-f05b90f272e769a2a40b-bedc-4a1d-9463-b0856662de55
Úvodní jmenovku doplní další obrazovky pro večerní návštěvu baru i společenskou únavu třeba v sobotu ve tři ráno

A přesně to si dnes vyzkoušíme, kód základního příkladu z GitHubu, si totiž vylepšíme a Maker Badge proměníme v zobrazovadlo pěti různých digitálních vizitek pro různé situace.

Extrémně rychlé bastlení

Pokud jste nikdy nepracovali v CircuitPythonu pro mikrokontrolery, vězte, že vše funguje úplně jinak než při programování v Arduinu. Zatímco v Arduinu bastlíme kompletní firmware čipu, v CircuitPythonu píšeme pouze skript, který po spuštění zpracuje běhové prostředí Pythonu předinstalované na čipu. Takže žádné zdlouhavé kompilování a naopak velmi rychlé opravy při vývoji.

c4590fec-fd6e-4e03-a210-dc1d5f7d3a3b
Visual Studio Code s pluginem CircuitPython nabídne doplňování kódu i spojení s terminálem na čipu, ve kterém se právě vypisují informace o stavu programu

Oficiálním textovým editorem pro CirucitPython je multiplatformní a velmi jednoduchý Mu, který připomíná Arduino IDE. Docela dobře nicméně poslouží i doplněk CircuitPython pro oblíbený Visual Studio Code.

Díky tomu, že se Maker Badge s firmwarem CircuitPythonu chová po připojení k PC jako disková jednotka, stačí pro okamžitou editaci programu jen otevřít textový soubor zmíněného hlavního skriptu code.py (nebo main.py), provést libovolnou úpravu, soubor uložit, načež se CircuitPython automaticky resetuje a vše spustí znovu.

Dotyková tlačítka překreslí displej

Náš dnešní skript bude vlastně naprosto primitivní. Využijeme pětice dotykových plošek, pomocí kterých budeme přepínat mezi pěti obrazovkami. Tlačítka jsou připojená na piny GPIO1-GPIO5.

c474fe05-b489-4164-b4df-93eb395161e0
K přepínání obrazovek použijeme pětici dotykových tlačítek

U druhé, třetí a čtvrté obrazovky zároveň pro demonstraci rozsvítíme čtveřici adresovatelných RGB LED červenou, zelenou, nebo modrou barvou. LED jsou připojené k pinu GPIO18.

Vizitky jako obrázky ve formátu BMP

Aby byly vizitky na Maker Badge co nejhezčí, první tři budou mít podobu hotových bitmap ve formátu BMP, které si připravíme v libovolném grafickém editoru na počítači. Já použil redakční Zoner Photo Studio, stejně dobře ale poslouží i GIMP.

a0d240fd-586c-4ab3-859a-3d71f62bf12f
Příprava první vizitky v Zoner Photo Studio v plných barvách a uložení v indexovaných barvách, kdy se odstíny šedi pokusíme simulovat ditheringem

Jelikož je Maker Badge vyzbrojený monochromatickým displejem, BMP by mělo být pro rychlé dekódování v CircuitPythonu uložené taktéž v monochromatických – indexovaných barvách.

Díky tomu pak zároveň zabere jeden obrázek s rozměry 250×122 pixelů pouze pár kilobajtů a nebudeme flashovou paměť čipu zbytečně zaplňovat o řád většími soubory

5a45caa3-aee8-4aa6-ab11-5339878caa3d
Originál v plných barvách
bc3a1c34-7d90-4323-8993-a35d82d4b471
Po převodu ditheringem na monochromatickou bitmapu jen se dvěma odstíny

Trojici obrázků ve formátu BMP uložíme podobně jako hlavní skript na USB  uložiště a poté je načteme na začátku programu přímo ze souborového systému.

Na poslední obrazovce ukážeme stav baterie

Na čtvrté obrazovce si vyzkoušíme generování vlastních tvarů za běhu programu. Vytvoříme tři (byť statické) textové řádky generickým pixelovým fontem. Mohli bychom ale použít i rastrové fonty na míru, jak to známe z kreslení textu na displeje třeba zrovna v Arduinu.

b8b871dd-4cb0-41f1-b6ae-940bc6fb7753
Za běhu generovaná obrazovka se stavem akumulátoru. Základní font je možné nahradit rastrovým, my si ale vystačíme s primitivním vytvořením textu

A konečně na poslední páté obrazovce vytvoříme text opět za běhu, přičemž tentokrát jej za běhu i upravíme, na poslední obrazovce se totiž vypíše aktuální elektrické napětí v akumulátoru.

Na četbu stavu akumulátoru autoři naštěstí mysleli a připojili jej k pinu GPIO6 pomocí obvodu děliče napětí se dvěma 10 kΩ rezistory, které nám sníží vysoké napětí akumulátoru na přijatelnou polovinu. Čip ESP32 totiž pracuje pod napětím 3,3 V a A/D převodník zpracuje rozsah 0-3,3 V.

91f3cef2-15bb-492b-80ff-b2b9ccf54cfc
Princip děliče napětí se dvěma rezistory, které nám vstupní napětí 4,2 V plně nabitého akumulátoru sníží na poloviční napětí 2,1 V

Takže pokud bude akumulátor nabitý na maximum 4,2 V, napětí mezi děličem napětí a systémovou zemí čipu ESP32 bude činit v ideálním případě 2,1 V. My tuto hodnotu díky A/D převodníku převedeme nejprve na celé číslo, poté přepočítáme zpět na elektrické napětí a znásobíme dvěma.

Autoři mysleli na co nejnižší spotřebu, takže můžeme ovládat napájení e-inku i děliče napětí

Protože Maker Badge běží na baterii, je třeba zajistit, aby z ní odebíral za běhu co nejméně elektrické energie. Napájení e-inkového displeje i obvodu dělič napětí proto řídí tranzistory připojené k pinům GPIO16 (e-ink) a GPIO14 (dělič). Změnou stavu na těchto pinech jejich obvody zapneme, nebo vypneme.

0957be4a-1c19-48b5-ae59-663b89800c84
Obvod děliče napětí pro čtení stavu baterie s tranzistorem, který pomocí pinu GPIO14 obvod spíná, nebo rozpíná. Podobné zapojení najdeme u napájení e-inku. Koukněte na celé schéma

E-ink samotný je totiž sice úsporný – spaluje elektřinu jen při překreslování –, nicméně čip jeho ovladače může stále odebírat nějaké ty mikrowatty. U děliče napětí to bude dle hodnoty odporu obou rezistorů ještě mohem více!

Napájení obvodu děliče napětí tedy můžeme aktivovat jen krátce před měřením stavu akumulátoru, no a pak jej zase odpojit. Stejně tak musíme na začátku programu aktivovat napájení e-inku, abychom se s ním mohli vůbec spojit.

Zapnout, zvolit obrázek a vypnout

Na stranu druhou, díky tomu, že autoři zvolili displej s elektromechanický inkoust, displej udrží obraz i při kompletním odpojení zdroje elelktřiny. Pokud by tedy v klidové fázi Badge vůbec nemusel běžet, stačí ho jen přepínačem spustit, když potřebujeme překreslit obrazec do jiné podoby, a pak jej zcela vypnout.

afa372ba-8d5f-434a-9c9b-d29a39e9c0d1
Pro jednoduchost příkladu předpokládáme, že po překreslení obrazovky prostě celý Maker Badge vypneme hlavním spínačem, a tak po překreslení ani nepřepínáme procesor do úsporného režimu

V kódu tedy sice proto budeme pro demonstraci spínat a vypínat obvod děliče napětí při měření stavu baterie, u e-inku to ale řešit nebudeme (jen ho na začátku zapneme) a stejně tak nebudeme pro jednoduchost kódu řešit ani žádné přepínání hlavního čipu do úsporného stavu.

Jakmile tedy Maker Badge spustíme, procesor ESP32-S2 poběží na plný plyn a náš program bude v nekonečné smyčce kontrolovat stav pětice dotykových tlačítek, protože předpokládáme, že po nastavení kýženého stavu jednoduše zase vše vypneme hlavním přepínačem napájení.

Laciné e-inky nemají rády časté překreslování

Laciné e-inky jsou poměrně citlivé a použitý displej není výjimkou. Výrobce doporučuje jeho překreslování nejvýše jednou za 180 sekund (je vhodný hlavně pro cenovky v obchodech apod.) a pamatuje na to i zobrazovací knihovna pro CircuitPython. Kdybychom chtěli překreslovat displej v kratším intervalu, vyskočí chyba a náš program skončí, což nechceme.

fb99d585-6b4a-47bd-920b-2108799234a9
Displej je k desce připojený konektorem na zadní straně Maker Badge, jeho případná výměna je tedy poměrně snadná

Minimální prodlevu mezi dvěma překresleními lze naštěstí při vytváření objektu displeje explicitně upravit, což jsme provedli i v našem kódu. I tak je ale dobré nesnažit se o nějaké animace apod. Plné překreslení obrazovky totiž tak jako tak zabere zhruba 1-2 sekund a opravdu byste si koledovali o to, že za pár měsíců displej prostě selže.

Pokud by se to opravdu stalo, na Maker Badge jej naštěstí můžete velmi jednoduše vyměnit.

Zdrojový kód celého programu

Tak, to by pro základní představení naší ukázky mohlo stačit. V úvodu článku se určitě podívejte na video, jak to celé dopadlo, no a níže už na vás čeká kompletní programový kód, který stačí uložit do kořenového adresáře Maker Badge pod názvem code.py nebo main.py.

Obrázky v monochromatickém BMP pak stačí vložit do adresáře obrazovky opět v kořenovém adresáři Maker Badge.

# Kod nize vznikl upravou oficialni ukazky z GitHubu pro revizi D desky Maker Badge:
# https://github.com/makerfaireczech/maker_badge/blob/main/SW/CircuitPython/examples/MF%20basic%20rev.D/code.py

# Vsechny pouzite knihovny jsou soucasti firmwaru CircuitPython pro Maker Badge
import board # Knihovna pro praci s deskou (popis dostupnych pinu apod.)
import digitalio # Knihovna pro praci s digitalnimi signaly 
import analogio # Knihovna por praci s analogovymi signaly
import touchio # Knihovna pro praci s dotykovymi tlacitky
import neopixel # Knihovna pro praci s adresovatelnymi RGB LED
import gc # Knihovna pro praci se spravou pameti
import terminalio # Knihovna pro praci s terminalem
import time # Knihovna pro praci s casem
import displayio # Knihovny pro praci s displejem
import adafruit_ssd1680
from adafruit_display_text import label

# Funkce pro zapis textu do konzole/terminalu
# vylepsena o vypis stavu volne RAM (Kod v CircuitPython muze byt hladovy)
def printm(text):
    print(f"RAM {gc.mem_free()} B:\t{text}")

# Funkce pro nastaveni vditelnosti vrstvy/objektu na displeji
# Graficke prvky na obrazovce jsou adresovatelne v jednoduchem „DOM“ principu
# Objekt zviditlenime tak, ze jej pridame, nebo odstranime do rodicovskeho objektu
def nastav_viditelnost_vrstvy(viditelna, rodic, vrstva):
    try:
        if viditelna:
            rodic.append(vrstva)
        else:
            rodic.remove(vrstva)
    except ValueError:
        pass

# Funkce pro aktivaci vrstvy/objektu
# Pomoci vyse vytvorene funkce projdeme vsechny potomky rodice a zneviditelnime je
# Pote zviditelnime jen toho potomka/vrstvu, ktereho zrovna potrebujeme
def aktivuj_gui_vrstvu(rodic, vrstva):
    for _vrstva in rodic:
        nastav_viditelnost_vrstvy(False, rodic, _vrstva)
    nastav_viditelnost_vrstvy(True, rodic, vrstva)

# Funkce pro vytvoreni textu na obrazovce, ktery bude zapouzdreny v objektu Group (vice pozdeji v kodu)
# V objektu Group by tak mohlo byt vicero textu se spolecnymi rodicovskymi parametery
# jako velikost, souradnice atp. My ale pracujeme jen s jednim textem
def vytvor_textovy_objekt(text, velikost, barva, x, y):
    objekt = displayio.Group(scale=velikost, x=x, y=y)
    text_obj = label.Label(terminalio.FONT, text=text, color=barva)
    objekt.append(text_obj)
    return objekt

# Funkce pro zjisteni stavu akumulatoru
# Akumulator je pripojeny skrze A/D prevodnik na pin GPIO6
# Pro snizeni napeti se pouziva delic napeti se dvema 10 kOhm rezistory
# Napeti je tedy bezpecne snizeno na polovinu (koeficient 2)
# Obvod delice by v klidu zbytecne spaloval elektrickou energii,
# a tak jej aktivujeme pomoci tranzistoru pripojeneho na GPIO14
def ziskej_stav_baterie():
    koeficient_delice = 2 # Delic napeti snizuje napeti na polovinu
    baterie_en.value = False # # Tranzistor sepne obvod delice napeti nastavenim pinu GPIO14 na nizky stav
    raw = baterie_adc.value # Ziskame hodnotu  /A/D
    baterie_en.value = True # Obvod odpojime nastavenim vysokeho stavu
    # Udaj z A/D CircuitPython vraci v rozsahu 0-65535 nehlede na skutecne rozliseni A/D na cipu
    # Surovou hodnotu prepocteme zpet na napeti s predpokladem, ze hodnota 65535 odpovida napeti 3,3V (rozsah prevodniku)
    napeti = raw * (3.3 / 65536)
    return napeti * koeficient_delice, napeti, raw

printm("Fakticky zacatek programu")

# ********** NASTAVENI EINK DISPLEJE **********
# Konfigurace komunikacnich a napajecich pinu
displej_spi = board.SPI() 
displej_cs = board.D41
displej_dc = board.D40
displej_reset = board.D39
displej_busy = board.D42
displej_en = digitalio.DigitalInOut(board.D16)
displej_en.direction = digitalio.Direction.OUTPUT

# Aktivace napajeni einku a konfigurace jeho sbernice SPI
displej_en.value = False # Tranzistor sepne napajeni einku nastavenim pinu GPIO16 na nizky stav
displayio.release_displays()
display_bus = displayio.FourWire(
    displej_spi,
    command=displej_dc,
    chip_select=displej_cs,
    reset=displej_reset,
    baudrate=1000000,
)
time.sleep(1)

# Konfigurace zakladnich parametru einku a vytvoreni prazdne pomocne bitmapy pro dve psoledni obrazovky
displej_sirka = 250
displej_vyska = 122
displej_cerna = 0x000000
displej_bila = 0xFFFFFF
displej_paleta = displayio.Palette(1)
displej_paleta[0] = displej_bila
displej_pozadi = displayio.Bitmap(displej_sirka, displej_vyska, 1)

# Konfigurace obvladace einku a vytvoreni objektu eink displeje
displej = adafruit_ssd1680.SSD1680(
    display_bus,
    width=displej_sirka,
    height=displej_vyska,
    rotation=270,
    busy_pin=displej_busy,
    # Ve vychozim stavu ovladac umozni prekresleni displeje cca jen jednou za 180 sekund
    # Je to doporucena hodnota od vyrobce, ktera ma zajistit vysokou trvanlivost
    # Pro rychlou praci s badgem by to ale bylo neergonomicke
    # Timto prikazem si vynutime snizeni prodlevy na 100 ms
    # za cenu potencialniho snizeni trvanlivosti displeje
    seconds_per_frame=0.1,
)

# ********** KONFIGURACE PINU PRO CTENI STAVU AKUMULATORU **********
baterie_en = digitalio.DigitalInOut(board.D14)
baterie_en.direction = digitalio.Direction.OUTPUT
baterie_adc = analogio.AnalogIn(board.D6)
ziskej_stav_baterie() # Uvodni cteni z A/D „na prazdno“ pro stabilizaci


# ********** KONFIGURACE PETI DOTYKOVYCH TLACITEK **********
tlacitka_citlivost = 20000
tlacitko1 = touchio.TouchIn(board.D5)
tlacitko1.threshold = tlacitka_citlivost
tlacitko2 = touchio.TouchIn(board.D4)
tlacitko2.threshold = tlacitka_citlivost
tlacitko3 = touchio.TouchIn(board.D3)
tlacitko3.threshold = tlacitka_citlivost
tlacitko4 = touchio.TouchIn(board.D2)
tlacitko4.threshold = tlacitka_citlivost
tlacitko5 = touchio.TouchIn(board.D1)
tlacitko5.threshold = tlacitka_citlivost

# ********** KONFIGURACE MATICE CTYR MODULU ADRESOVATELNYCH RGB LED **********
led_pin = board.D18
led_matrix = neopixel.NeoPixel(led_pin, 4, brightness=0.1, auto_write=False)

# RGB barvy pro LED
led_vypnuto = (0, 0, 0)
led_cervena = (255, 0, 0)
led_zelena = (0, 255, 0)
led_modra = (0, 0, 255)

# ********** VYTVORENI PETI HLAVNICH OBRAZOVEK/VRSTEV MEZI KTERYMI BUDEME PREPINAT **********
# Mezi obrazovkami budeme prepinat pomoci dotykovych plosek na spodnim okraji Maker Badge
# Knihovna Displayio umoznuje zakladni logickou organizaci objektu na obrazovce. Souvisejici casti na
# obrazovce proto zapouzdrime do skupinoveho objektu Group a TileGrid, ktere pak budeme moci
# snadno zapinat a vypinat, menit jejich obsah atp.Zakladnim rodicem vsech techto objektu
# na obrazovce bude kontejner 
kontejner = displayio.Group()
printm("Hlavni kontejner vytvoreny")

# Ted vytvorime objekt prvni obrazovky ze souboru obrazovka1.bmp
# Je to obrazek nasi formalni vizitky
obrazovka1_bmp = displayio.OnDiskBitmap("/obrazovky/obrazovka1.bmp")
obrazovka1 = displayio.TileGrid(obrazovka1_bmp, pixel_shader=obrazovka1_bmp.pixel_shader)
printm("Prvni obrazovka vytvorena")

# Ted vytvorime objekt druhe obrazovky ze souboru obrazovka2.bmp
# Je to obrazek nasi seznamkove vizitky vecer do baru
obrazovka2_bmp = displayio.OnDiskBitmap("/obrazovky/obrazovka2.bmp")
obrazovka2 = displayio.TileGrid(obrazovka2_bmp, pixel_shader=obrazovka2_bmp.pixel_shader)
printm("Druha obrazovka vytvorena")

# Ted vytvorime objekt treti obrazovky ze souboru obrazovka3.bmp
# Je to obrazek nocni vizitky, kdy uz jsme spolecensky unaveni a chceme, aby nam nekdo zavolal taxik
obrazovka3_bmp = displayio.OnDiskBitmap("/obrazovky/obrazovka3.bmp")
obrazovka3 = displayio.TileGrid(obrazovka3_bmp, pixel_shader=obrazovka3_bmp.pixel_shader)
printm("Treti obrazovka vytvorena")

# Ctvrtou obrazovku vytvorime dynamicky za behu
# Je to jen ukazka. Kazdy element je zpetne adresovatelny a upravitelny
# Dodatecne tedy muzeme menit i text aj.
obrazovka4 = displayio.Group()
obrazovka4.append(displayio.TileGrid(displej_pozadi, pixel_shader=displej_paleta))
obrazovka4.append(vytvor_textovy_objekt("TOTO JE", 3, displej_cerna, 5, 20))
obrazovka4.append(vytvor_textovy_objekt("CTVRTA", 3, displej_cerna, 5, 60))
obrazovka4.append(vytvor_textovy_objekt("OBRAZOVKA", 3, displej_cerna, 5, 100))
printm("Ctvrta obrazovka vytvorena")

# Patou obrazovku vytvorime take dynamicky
# Bude se na ni po stisku na 5. tlacitko zobrazovat aktualni stav akumulatoru 
obrazovka5 = displayio.Group()
obrazovka5.append(displayio.TileGrid(displej_pozadi, pixel_shader=displej_paleta))
obrazovka5.append(vytvor_textovy_objekt("Stav baterie", 2, displej_cerna, 5, 20))
obrazovka5.append(vytvor_textovy_objekt("0.000 V", 3, displej_cerna, 5, 60))
printm("Pata obrazovka vytvorena")

# Ve vychozim stavu zobrazime 1. obrazovku
# Nastavime tedy tuto vrstvu na viditelnou, ostatni skryjeme
# a dame povel ovladaci, at ji vykresli na eink
# Vsimnete si stromove architektury kontejner->obrazovka
# Obrazovky aktivaci vlastne pridavame, nebo odstranujeme
# z hlavniho kontejneru, ktery posilame do einku 
aktivuj_gui_vrstvu(kontejner, obrazovka1)
displej.show(kontejner)
displej.refresh()
printm("Prvni obrazovka zobrazena")

# ********** NEKONECNA SMYCKA PROGRAMU **********
# Analogie loop() z Arduina
# Ze smycky vyskocime leda pri chybe programu,
# anebo vypnutim napajeni pomoci prepinace
# Prave rucni vypnuti predpokladame,
# pro jednoduchost kodu totiz neprechazime do usporneho rezimu
# a cip ESP32 tedy bezi naplno a splauje elektrinu
while True:
    # Pri stisku 1. tlacitka vypneme RGB LED a zobrazime 1. obrazovku
    if tlacitko1.value:
        printm("Stisk tlacitka 1")
        led_matrix.fill(led_vypnuto)
        led_matrix.show()
        aktivuj_gui_vrstvu(kontejner, obrazovka1) 
        displej.show(kontejner)
        displej.refresh()
        printm("Prvni obrazovka zobrazena")   
    # Pri stisku 2. tlacitka nastavime na RGB LED cervenou a zobrazime 2. obrazovku
    if tlacitko2.value:
        printm("Stisk tlacitka 2")
        led_matrix.fill(led_cervena)
        led_matrix.show()
        aktivuj_gui_vrstvu(kontejner, obrazovka2)
        displej.show(kontejner)
        displej.refresh()
        printm("Druha obrazovka zobrazena")
    # Pri stisku 3. tlacitka nastavime na RGB LED zelenou a zobrazime 3. obrazovku
    if tlacitko3.value:
        printm("Stisk tlacitka 3")
        led_matrix.fill(led_zelena)
        led_matrix.show()
        aktivuj_gui_vrstvu(kontejner, obrazovka3)
        displej.show(kontejner)
        displej.refresh()
        printm("Treti obrazovka zobrazena")
    # Pri stisku 4. tlacitka nastavime na RGB LED modrou a zobrazime 4. obrazovku
    if tlacitko4.value:
        printm("Stisk tlacitka 4")
        led_matrix.fill(led_modra)
        led_matrix.show()
        aktivuj_gui_vrstvu(kontejner, obrazovka4)
        displej.show(kontejner)
        displej.refresh()
        printm("Ctvrta obrazovka zobrazena")
    # Pri stisku 5. tlacitka vypneme RGB LED, zmerime napeti akumulatoru,
    # dynamicky upravime 5. obrazovku a zobrazime ji
    if tlacitko5.value:
        printm("Stisk tlacitka 5")
        led_matrix.fill(led_vypnuto)
        led_matrix.show()
        # Zmerime napeti v akumulatoru pomoci A/D prevodniku
        # Deska pouziva delic napeti se dvema 10 kOhm rezistory
        # A/D prevodnik proto cte napeti snizene na polovinu
        # Funkce pro prehlednost vraci vsechny hodnoty
        napeti, napeti_delic, raw = ziskej_stav_baterie()
        printm(f"Stav akumulatoru: " +
            f"RAW hodnota z A/D prevodniku: {raw}\t" +
            f"Napeti za delicem: {napeti_delic} V\t" +
            f"Napeti akumulatoru: {napeti} V"
        )
        # Priklad dodatecne upravy objektu na obrazovce za behu:
        # Obrazovka 5 se sklada ze tri objektu (bile pozadi, prvni radek, druhy radek)
        # Prejdeme tedy na treti objekt (index 2), coz je dalsi objekt,
        # ktery obsahuje konecne jeden GUI element label (index 0)
        # u ktereho adekvatne zmenime parametr text
        obrazovka5[2][0].text = str(f"{napeti:.3f} V")        
        aktivuj_gui_vrstvu(kontejner, obrazovka5)
        displej.show(kontejner)
        displej.refresh()
        printm("Pata obrazovka zobrazena")
Diskuze (21) Další článek: Betaverze Windows 11 23H2 podporuje archivy 7Z a RAR. Ikony už nemusí být seskupené

Témata článku: , ,