Aplikace B15 Radio III

Při programování her s dvěma micro:bity budeme potřebovat některé algoritmy, které nám pomohou při psaní programového kódu. Tato lekce je jedna z nich a popisuje způsob, jak u programů typu Peer to Peer (viz lekce A15) přece jenom stanovit, který micro:bit bude například zahajovat hru, který bude mít bílé a který černé figury a pod.

název: B15 Radio III
kategorie: B mírně pokročilí
ref.číslo: B15
projekt: kurz micro:bit
verze: 01, 2017-09-22
autor: Ivo Obr, Lanškroun


Lekce je spíše výuková a naučíme se :

  1. Práce s obrázky hodin, například čekání na nějakou událost
  2. Jak u stejného programu nahraného do dvou micro:bitů se mikropočítače domluví na pořadí
  3. Jak si budou micro:bity kontrolovat rádiové spojení a reagovat na výpadek

Program začneme jako vždy, ale přidáme k němu import modulu “radio”, a modulu generátoru náhodných čísel.

from microbit import *
import radio
import random

Programy nahrané ve dvou micro:bitech jsou stejné a proto budou reagovat stejně. Přesto se mohou v něčem lišit, a to ve vygenerovaných náhodných číslech. Abychom mohli popisovat naše postupy, jeden micro:bit si nazveme “miA” a druhý “miB”.

Jestliže bychom oba micro:bity zapnuli v jeden okamžik (například z jednoho napájení), pak by oba začaly vysílat ve stejný čas, nebo přijímat ve stejný čas a asi by se špatně domlouvaly. Zařídíme to proto tak, že si na začátku programy vygenerují náhodné číslo. Toto číslo pak bude časovou prodlevou před prvním vysíláním. Kdo z nich začne vysílat první, když budou oba na příjmu, ten si zvolí pořadí číslo 1, druhý už bude mít pořadí číslo 2.

Jak to bude vypadat prakticky v programu :

1)  miA a miB si vygenerují náhodná čísla. Micro:bit miA např. 56, miB třeba 21.
2) oba stále opakovaně naslouchají a čekají, zdali partner nevyšle zprávu
3) miB už spotřeboval čekací dobu 21 a tak vyšle zprávu “SLAVE”, což znamená, že dává pokyn druhému micro:bitu být podřízený.
4) miA zprávu “SLAVE” příjme, poznamená si že bude “dvojkou” a odešle zprávu “MASTER” kterou dává najevo miB, že bude “jedničkou”
5) miB přijme zprávu “MASTER” a zapíše si, že bude “jedničkou”
6) tím si rozdělily micro:bity role, ukončí algoritmus spojování a vypíšou svá pořadí na displeji

Při čekání na spojení budeme vykreslovat otáčející se ručičku hodin na displeji. K tomu si vytvoříme seznam se jménem “hodiny” složený z dvanácti obrázků :

hodiny = [Image.CLOCK1, Image.CLOCK2, Image.CLOCK3, Image.CLOCK4,
                 Image.CLOCK5, Image.CLOCK6, Image.CLOCK7, Image.CLOCK8,
                 Image.CLOCK9, Image.CLOCK10, Image.CLOCK11, Image.CLOCK12]

Nastavíme parametry přenosu a zapneme vysílání:

radio.config(length=10, group=15, power=7)
radio.on()

Vykreslíme úvodní obrázek a vygenerujeme si náhodné číslo. Rozsah 1 až 200 jsem zvolil jako kompromis, můžete si vyzkoušet jiné hodnoty. Více jak 500 znamená, že se prodlužuje průměrný čas na zahájení spojení. Pokud je menší než 10, je velká pravděpodobnost, že si miA a miB vygenerují shodná čísla. (Prakticky si nezapnete oba micro:bity současně, takže by kolize hrozila zcela výjimečně. Pro některé postupy by to ale mohlo být hrozbou.) To číslo 200 jsem zvolil pro tento příklad, aby lidskými měřítky jsme mohli sledovat, jak se miA a miB připojují.

Další úvodní nastavení proměnných :

i = 0                      celkový počet cyklů while, použití v hodinách
citac = 0               počitadlo, kolik je třeba udělat cyklů, než se začne vysílat
poradi = 0            na začátku nula, pak dle domluvy miA a miB (jedna a dvě)
 

Cyklus, který trvá tak dlouho, dokud se micro:bity nespojí (“poradi” různé od nuly)

while poradi == 0:

Vykreslíme ručičku hodin – obrázek s indexem 0 až 11. Index získáme operací “zbytek po dělení”, kde je operátorem znak “procento”. Obsah proměnné “i” dělíme dvanácti a zbytek po dělení je indexem do seznamu “hodiny”.

display.show(hodiny[i % 12])

Čitač každým průchodem cyklu se zvětší o hodnotu jedna. Až dosáhne hodnoty vygenerovaného náhodného čísla, tak se odešle zpráva “SLAVE”. Čitač se vynuluje, aby se mohlo pokračovat znovu, pokud například druhý micro:bit ještě není zapnutý.

if citac == cas:
    radio.send(“SLAVE”)
    citac = 0   

Do proměnné se jménem “prijem” přesuneme z přijímače zprávu. Pokud není v proměnné nic, tak zpráva žádná nedošla. Pokud tam ale zpráva je, musíme si zjistit, jaká.
Pokud jsme přijali zprávu “SLAVE”, pak budeme “dvojkou”. Odpovíme “jedničce” zprávou “MASTER”, a zapíšeme si do svého pořadí dvojku. Tím také ukončíme cyklus while.
Pokud jsme přijaly zprávu “MASTER”, je to zpráva od “dvojky” a my si do pořadí zapíšeme jedničku, a tím ukončíme cyklus while.
prijem = radio.receive()
    if not(prijem is None):
        if prijem == “SLAVE”:
            radio.send(“MASTER”)
            poradi = 2
        if prijem == “MASTER”:
            poradi = 1

Zbývá už jenom zvýšit hodnoty proměnných “i” a “citac”.
    i += 1
    citac += 1

Na konci těla cyklu while musíme trochu přibrzdit micro:bit, aby se hodiny točily přiměřeně a časy byly přijatelné pro lidskou rychlost.
sleep(40)

Jakmile si miA a miB rozdělily role, tak každý micro:bit si své pořadí vypíše na displeji. Pokud si budete opakovat zapnutí micro:bitů, můžete sledovat, že si role vyměňují zcela náhodně.

Pokud zapnete jen jeden micro:bit, bude se ručička na displeji otáčet stále dokola a on bude stále čekat na zapnutí druhého.

Tím jsme vyřešili spojení micro:bitů a rozdělení rolí. Dále bude třeba kontrolovat, zdali micro:bity jsou stále spojené. Může se stát, že s jedním micro:bitem odejdete na vzdálenost, kdy už se spojení ztratí, dojde bateriové napájení nebo někdo naše vysílání bude rušit.

Celý systém kontroly bude jednoduchý. Každou vteřinu necháme micro:bit vysílat zprávu “HEART”. V praxi se to obvykle uvádí jako “heart_beat” – tlukot srdce. Jestliže budeme přijímat takovou zprávu z druhého micro:bitu, víme že žije a že s námi komunikuje. Pokud dojde ke ztrátě takové zprávy, a to v námi stanovené délce časového intervalu, pak budeme považovat tuto situaci za ztrátu rádiového spojení. V našem případě na to budeme reagovat obrázkem “Image.NO” na displeji a po dvou vteřinách resetujeme micro:bit. Reset nám nastartuje znovu program od začátku (začne se hledat spojení).

Nejdříve si poznamenáme čas, kdy začneme. Jsou to časy, kdy začínáme s algoritmem “heart_beat”.
cas_vys = running_time()
cas_pri = running_time()

Celý náš další program budeme opakovat
While True:

První částí bude pravidelné odesílání zprávy “HEART” a to v intervalu 1sec :
if running_time() > (cas_vys + 1000):
        radio.send(“HEART”)
        cas_vys = running_time()

Pak se podíváme, jestli přišla nějaká zpráva od protějšku.
prijem = radio.receive()

Pokud zpráva došla, výraz “not(prijem is None)” je pravdivý, pak nás bude zajímat obsah této zprávy, protože protějšek může posílat i jiná data, než nás nyní zajímají. Pokud je obsah “HEART”, poznamenáme si čas, kdy zpráva došla.

    if not(prijem is None):
        if prijem == “HEART”:
            cas_pri = running_time()

Na konci našeho kódu se zeptáme, zdali aktuální čas není příliš velký proti času poslední zprávy. Já jsem si zvolil 3sec, ale můžete si zde nastavit časový interval jiný podle složitosti vašeho kódu. Pokud čas překročil tento limit, znamená to, že už delší dobu náš protějšek nic neodvysílal. V tom případě vykreslíme na displeji “Image.NO”, počkáme dvě vteřiny a resetujem micro:bit. Poslední sleep(10) je od cyklu “while True”.

    if running_time() > (cas_pri + 3000):
        display.show(Image.NO)
        sleep(2000)
        reset()
    sleep(10)

Samozřejmě si program můžete upravovat dle svého, vyzkoušet si jiná časování a pod. Na konec ještě celý program :

# Writen by Ivo Obr
# zari 2017
from microbit import *
import radio
import random

hodiny = [Image.CLOCK1, Image.CLOCK2, Image.CLOCK3, Image.CLOCK4,
          Image.CLOCK5, Image.CLOCK6, Image.CLOCK7, Image.CLOCK8,
          Image.CLOCK9, Image.CLOCK10, Image.CLOCK11, Image.CLOCK12]
radio.config(length=10, group=15, power=7)
radio.on()
display.show(Image.HEART)
sleep(300)
cas = random.randint(0, 200)
i = 0
citac = 0
poradi = 0
while poradi == 0:
    display.show(hodiny[i % 12])
    if citac == cas:
        radio.send("SLAVE")
        citac = 0    
    prijem = radio.receive()
    if not(prijem is None):
        if prijem == "SLAVE":
            radio.send("MASTER")
            poradi = 2
        if prijem == "MASTER":
            poradi = 1
    i += 1
    citac += 1
    sleep(40)
display.show(str(poradi))
# kontrola spojeni pomoci HEART_BEAT
cas_vys = running_time()
cas_pri = running_time()
while True:
    if running_time() > (cas_vys + 1000):
        radio.send("HEART")
        cas_vys = running_time()
    prijem = radio.receive()
    if not(prijem is None):
        if prijem == "HEART":
            cas_pri = running_time()
# TADY MUZE BYT PROGRAMOVY KOD HRY A POD.
    if running_time() > (cas_pri + 3000):
        display.show(Image.NO)
        sleep(2000)
        reset()
    sleep(10)

 

Aplikace C4 Hra Asteroidy objektově

Lekce C4 opakuje programování stejné hry jako v lekci C3, ale tentokrát použijeme při programování struktury dat, které se nazývají objekty. Obsah je jen lehkým úvodem k objektovému programování.

název: C4 Hra Asteroidy objektově
kategorie: C středně pokročilí
ref.číslo: C4
projekt:
verze: 01, 2017-08-22
autor: Ivo Obr, Lanškroun


V lekci C3 jsme měli pouze jednoduché proměnné, co proměnná, to její jiný název. Takže jsme měli například jednu proměnnou pro souřadnici “x” asteroidu1, další proměnná byla souřadnice “y” asteroidu1 atd. Na tuto situaci se můžeme nyní podívat i z druhé strany a říci, že máme asteroid1 (pro nás to bude objekt se jménem “asteroid1”), který bude mít dvě vlastnosti, a to souřadnici “x” a souřadnici “y”.

Jak budeme přistupovat k hodnotám u souřadnic asteroidu1? Postaru to bude takto:

asteroid1_x = 0
asteroid1_y = 0

Objektově to bude následovně. Vytvoříme si objekt (bude v dalším) se jménem asteriod1. Objekt bude mít po vytvoření dvě vlastnosti a to vlastnost x (x-ová souřadnice) a y (y-ová souřadnice). Obecně se k vlastnostem dostaneme tak, že uvedeme název objektu, následuje oddělovač tečka a pak název vlastnosti. Takže zápis bude takto :

asteriod1.x = 0
asteroid1.y = 0

Zatím žádné výhody nevidíme, náš příklad je příliš jednoduchý. Objekt může mít ještě ve svém obsahu další prvky, a těm se říká metody. Jsou to části programového kódu – příkazy, které obvykle pracují s vlastnostmi objektu.

Příkladem je například okno na monitoru. To je objekt, jehož vlastnosti jsou výška okna, šířka okna, pozice okna, zobrazení (minimální, maximální, ….), barva rámu okna, aktivita a spousta dalších vlastností. Metody jsou pojmenované skupiny příkazů, které například okno otevírají, zavírají, posouvají, aktivují a mnoho dalších. V programu pak můžeme vytvářet různá okna, ale jejich soubor vlastností je stejný i metody jsou stejné.

Bylo by velmi nepraktické každé okno znovu popisovat (když jejich struktura je stejná). Proto si na začátku programu nadefinujeme strukturu objektu (nikoliv skutečný objekt) a této struktuře (vzoru) dáme jméno. Říkáme tomu třída objektu a začátek definice vypadá takto :

(dva prázdné řádky)
class Asteroid():

Tato definice třídy objektu musí být na začátku programu. Slovo “class” je začátek popisu struktury (třídy objektu), slovo “Asteroid” je název třídy. Dvě vlastnosti této třídy (vzoru) popíšeme takto :

def __init__(self, sx, sy):
        self.x = sx
        self.y = sy

Zápis funkce “__init__” umožní při vytvoření objektu vložit hodnoty do vlastností nového objektu. Vysvětlení v následujícím popisu vytvoření objektu. Další zápisy popisují metodu třídy Asteroid:

def krok(self):
        self.y = self.y + 1
        if self.y == 5:
            self.y = 0
            self.x = random.randint(0, 4)
(dva prázdné řádky)

 Slovo “def” je začátkem definice (popisu) metody se jménem “krok”. Slovo “self” popisuje sebe sama  a při vytvoření konkrétního objektu se slovo “self” nahradí jménem konkrétního objektu.

Definice třídy objektu musí být na začátku programu.

Toto je zápis vytvoření konkrétního objektu se jménem asteroid1:

asteroid1 = Asteroid(random.randint(0, 4), 0)

Název našeho prvního objektu je “asteroid1”. Vytvoří se z třídy objektu (ze struktury) se jménem Asteroid (v programu můžeme mít více tříd objektů). V kulaté závorce jsou při vytváření objektu dodány dvě numerické hodnoty. Prvá hodnota je pozice souřadnice “x” (sloupec), druhá hodnota je pozice souřadnice “y” (řádek). Pozice sloupce je určena vygenerováním náhodného čísla v rozsahu 0 až 4, řádek je vždy ten horní s indexem 0. Druhý asteroid vytvoříme takto :

asteroid2 = Asteroid(random.randint(0, 4), 2)

Změna je pouze v souřadnici “y”, to je třetí řádek (počítáno od prvého). Vlastnost asteroidu1 – jeho x-ová souřadnice je asteroid1.x a podobně je to s dalšími vlastnostmi.
Aby se asteroid1 nebo asteroid2 pohyboval, stačí použít (volat) jeho metodu se jménem “krok” a to takto:

asteroid1.krok()
asteroid2.krok()

Tady už začínáte vidět výhodu objektového programování, a to v jednoduchosti příkazu. Pokud bychom měli asteroidů více, pak by se výhoda začala stále více projevovat. Vlastní fungování programu je vysvětleno v lekci C3, takže zde je jen ukázka posunu programování ze základního do objektového.

Pokud jste pozorní, můžete nyní vidět, že většina příkazů v MicroPython je vlastně volání metod nebo vlastností jednotlivých objektů. Například “display” je objekt matice 5×5 LED diod. Jedna z metod tohoto objektu má název “show”. Takže náš příkaz na začátku programu

display.show(Image.ARROW_W)

je volání metody “show” v objektu “display” s parametrem předem definovaného obrázku. Obrázek je objekt pojmenovaný “Image” a jedna z vlastností tohoto objektu má název   “ARROW_W”. Objekt “Image” má mnoho vlastností pojmenovaných jako ARROW_W, ARROW_N, ARROW_E .. atd.

Tato lekce by měla sloužit jako nahlédnutí do objektového programování. Nakonec ještě celý program, jak vypadá v objektovém provedení.

 

Aplikace C3 Hra Asteroidy

Lekce C3 je ukázkou jednoduché hry, kdy prolétáme kosmickou lodí skupinu asteroidů a vyhýbáme se jim. Po strážce hra končí a nám se ukáže skóre, kolik bodů jsme během hry nasbírali.

název: C3 Hra Asteroidy
kategorie: C středně pokročilí
ref.číslo: C3
projekt:
verze: 01, 2017-07-30
autor: Ivo Obr, Lanškroun


V programu si zopakujeme většinu postupů z lekcí B1 až B10. Nejdříve si definujeme, jak bude hra vypadat na našem displeji 5×5 LED diod. Protože se jedná o jednoduchou hru, kterou můžete pak dále rozvíjet, naprogramujeme jednu loď na čtvrtém řádku (spodním).

Tato loď bude reprezentována blikající diodou, která může nabýt jednu z poloh v ose X od 0  do 4. Pohyb lodi budeme řídit tlačítkem “A” (pohyb vlevo) a tlačítkem “B” (pohyb vpravo).

Asteroidy budou  dva, jeden začíná padat od nultého řádku (úplně nahoře), druhý začíná padat už od druhého řádku (prostřední řádek). Ve kterém sloupci začnou padat bude učeno vygenerovaným náhodným číslem v rozsahu 0 až 4. Vzhledem k jednoduchosti programu mohou oba asteroidy padat ve  stejném sloupci.

Jakmile bude na dolním řádku pozice asteroidu a lodi stejná (srážka), hra končí a na displeji se vypíše skóre hry (počet kroků hry).

A nyní k vlastnímu programu. Ten začneme příkazy :

from microbit import *
import random

Druhý řádek je nutný, neboť budeme používat generátor náhodných čísel. Celý další program je opakování příkazů.

while True:
            display.show(Image.ARROW_W)

Příkaz “display.show” vykreslí šipku směrem západním, tedy k tlačítku “A”. Ukazuje nám, kde máme začít hru. Ve stejném sloupci jako displej je dotaz na stisk tlačítka “A”. Pokud je tlačítko “A” stisknuto, hra se otevře a nastavíme úvodní hodnoty do proměnných.

if button_a.was_pressed():
              display.clear()
              score = 0
              lod_x = 2
              asteroid1_x = random.randint(0, 4)
              asteroid2_x = random.randint(0, 4)
              asteroid1_y = 0
              asteroid2_y = 2
              i = 0
              rychlost = 300
              hra = True
              sleep(600)

lod_x  je souřadnice naší lodě ve vodorovném směru, svisle je vždy na 4
asteroid1_x a asteroid1_y jsou souřadnice prvního asteroidu (stejně tak asteroid2)
i je pomocná proměnná pro blikání lodě
rychlost je počet milisekund prodlení v  jednom kroku hry
hra je logická proměnná nastavená na True, pokud je srážka s asteroidem je nastavena na False

sleep(600)
while hra:
            if button_a.was_pressed() and lod_x != 0:
            lod_x -= 1
            elif button_b.was_pressed() and lod_x != 4:
            lod_x += 1
            img = Image(‘00000:’*5)
            img.set_pixel(lod_x, 4, i*5+4)
            img.set_pixel(asteroid1_x, asteroid1_y, 9)
            img.set_pixel(asteroid2_x, asteroid2_y, 9)
 

Příkaz “while” je ve stejné pozici (sloupci) jako příkazu “sleep”. Příkaz “while” se opakuje tak dlouho, pokud nedojde ke srážce lodi s asteroidem. Pak je proměnná “hra” nastavena na False a hra končí. Testujeme tlačítka “A” a “B”. Pokud není loď v krajních polohách, tak posuneme souřadnici vlevo nebo vpravo o jeden sloupec. Příkaz lod_x += 1 je stejný jako lod_x = lod_x +1 . Jde o zkrácený zápis.

Dále si připravíme objekt obrázku s názvem “img”. V kulaté závorce je použit zápis, kde se ‘00000:’ (řádek na displeji) opakuje 5krát.

S tímto obrázkem můžeme dále pracovat a to tak, že upravíme svícení jednotlivé diody příkazem : [název_obrázku].set_pixel(x-souřadnice, y-souřadnice, jas)

Tímto příkazem si  nastavíme svícení diody lodě. Loď je vždy na  řádku 4. Poslední hodnota i*5+4 je jas diody. Hodnota proměnné “i” se střídá mezi nulou a jedničkou v jednotlivých krocích. Takže jas diody se mění střídavě mezi 5 a 9. Další dva příkazy nastavují svítící diody pro oba asteroidy, jas je nastaven trvale na hodnotu 9 (maximum).

Další příkazy upravují hodnotu proměnné “i” tak, aby se střídaly hodnoty 0 a 1. V prvém průchodu  je hodnota “i” nula a prvým příkazem se zvětší na 1. Příkaz “if” vyhodnotí, že další příkazy se již provádět nebudou. Ve druhém průchodu se hodnota proměnné “i” zvětší o jedna na hodnotu dvě. Příkaz “if” povolí vykonání dalších odsazených příkazů a hned prvý z nich vrátí hodnotu proměnné “i” na nulu.

i += 1
if i == 2:
    i = 0
    asteroid1_y += 1
    if asteroid1_y == 5:
        asteroid1_y = 0
        asteroid1_x = random.randint(0, 4)
     asteroid2_y += 1
     if asteroid2_y == 5:
        asteroid2_y = 0
        asteroid2_x = random.randint(0, 4)
     score += 1

Pokud je hodnota proměnné “i” rovna dvěma (jen na malou chvilku), pak se zvětší hodnota souřadnice “y” asteroidů  o jedničku. Pokud byl už asteroid na řádku 4 a zvětšením dostal hodnotu 5, (což je už mimo rozsah displeje), vrátíme asteroid nahoru na souřadnici “y” s hodnotou nula, ale vypočítáme mu nový náhodný sloupec, ve kterém se bude pohybovat.

Nakonec přičteme jedničku do celkového skóre.

Nyní nám zbývá zjistit, zdali se naše loď nesrazila s nějakým asteroidem. Pokud je asteroid na čtvrtém řádku, porovnáme souřadnice sloupců lodě a asteroidu. pokud je hodnota stejná, došlo ke srážce a hru ukončíme tím, že nastavíme proměnnou “hra” na hodnotu False. Tím se už předchozí příkaz “while hra” již nebude opakovat.

if asteroid1_y == 4:
    if lod_x == asteroid1_x:
        hra = False
if asteroid2_y == 4:
    if lod_x == asteroid2_x:
        hra = False

Blížíme se ke konci, kde nejdříve vykreslíme obrázek “img” na displeji.  Na začátku jsme si nastavili délku trvání prodlevy mezi jednotlivými průchody na 300msec. Aby nebyla hra tak jednoduchá, budeme zrychlovat hru zmenšováním prodlevy až na 101msec.

display.show(img)
rychlost -= 1
if rychlost == 100:
    rychlost = 101
sleep(rychlost)

Pokud hra skončila, vypíšeme skóre příkazem :

display.scroll(str(score))
sleep(2000)

Počkáme dvě vteřiny, abychom výsledek přečetli. Proměnná “score” je numerická, je v ní numerická hodnota. Výraz str(score) nám převede hodnotu na řetězec číslic. Tento řetězec už můžeme vypsat příkazem display.scroll().

Na konci této lekce pak najdete celý program. S programem lze experimentovat, upravovat rychlost, aby asteroidy nebyly ve stejném sloupci a pod.

Aplikace B14 Radio II

V lekci A17 jsme nahlédli do světa radiového (bezdrátového) přenosu dat.  Abychom se naučili více, opustíme Block Editory a pustíme se do programování v jazyku MicroPython, který nám otevře další možnosti bezdrátového spojení micro:bitů.

název: B14 Radio II
kategorie: B mírně pokročilí
ref.číslo: B14
projekt: kurz micro:bit
verze: 01, 2017-07-24
autor: Ivo Obr, Lanškroun


Naprogramuje si opět stejný program jako v lekci A17, ale tentokrát si vysvětlíme další možnosti bezdrátového přenosu.

Program začneme jako vždy, ale přidáme k němu import modulu “radio”, který nám umožňuje pracovat s dalšími příkazy pro nastavení a práci s vysíláním a příjmem  dat.

from microbit import *
import radio

Nyní musí následovat příkazy, které se provedou na začátku programu jen jednou a to bude nastavení parametrů pro bezdrátové spojení.  Nastavení se provede příkazem :

radio.config(seznam parametrů)

kde parametr je vždy dvojice “název_parametru=hodnota”  (oddělovačem parametrů je čárka)

parametry jsou (uváděné hodnoty jsou standardní, pokud je nechcete měnit, není třeba parametr uvádět):

length=32

– nastaví maximální délku zprávy v bytech, kterou lze jedním příkazem poslat. Maximální hodnota je 251 bytů.

queue=3

– nastaví počet zpráv, které mohou čekat ve frontě přijatých zpráv. Maximální hodnota je omezena aktuální velikostí paměti.

channel=7

– nastavení vysílacího a přijímacího kanálu. Hodnoty jsou od 0 do 100 včetně. Vysílací kmitočet 2400Mhz má 101 samostatných kanálů. Pokud pracujeme v místě, kde se používá větší množství micro:bitů, je vhodné si zvolit jiný vysílací a příjmový kanál, aby se micro:bity navzájem nerušily. Micro:bity, které mají spolu komunikovat musí být nastaveny na stejném kanále.

power=6

– s tímto parametrem jsme se už seznámili v lekci A17 a to v bloku “radio set transmit power”. Nastaví se výkon vysílání. Hodnoty jsou 0 až 7. Nula znamená, že vysílač nevysílá žádný signál.

group=0

– s tímto parametrem jsme se již také setkali v lekci A17, povolené hodnoty jsou 0 až 255. Byl to blok “radio set group”, který nastavuje číslo skupiny micro:bitů, které chtějí spolu komunikovat.  Pokud mají micro:bity nastaveny stejné číslo, mohou spolu komunikovat. Je to vhodné například na výstavách nebo soutěžích, aby mezi sebou komunikovali micro:bity jen ty co mají, a ne všechny v sále. (poznámka : neplést s parametrem channel, ten nastaví vysílací frekvenci, group nastavuje číslo skupiny, které je součástí vysílané zprávy.)

address=0x75626974

– adresa příjemce zprávy. Je to 32bitová adresa, která slouží k filtrování příchozích zpráv na úrovni hardwaru, přičemž se zachovávají pouze ty, které odpovídají zadané adrese. Výchozí nastavení, které se zde používá, je standardně používané jinými platformami souvisejícími s mikrosystémy. Doporučuji neměnit.

data_rate= radio.RATE_1MBIT

– nastavení datové rychlosti v bitech. Doporučuji neměnit. Používá se při komunikaci s jinými zařízeními. Další možné hodnoty jsou : radio.RATE_250KBIT  a  radio.RATE_2MBIT

Pokud neuvedeme příkaz radio.config(parametry), pak zůstávají nastaveny standardní hodnoty viz výše.

 

Příklad:

Maximální délka zprávy bude 64 bytů, skupinu nastavíme na 24 a požadujeme maximální vysílací výkon (co největší vzdálenost přenosu):

radio.config(length=64, group=24, power=7)

Než začneme používat příkazy, musíme ještě zapnou vysílač a přijímač příkazem:

radio.on()

Případné vypnutí (abychom šetřili baterii) je :

radio.off()

Abychom mohli používat další příkazy pro vysílání a příjem dat, musíme mít rádio zapnuté.

Nyní už můžeme psát další kód. Budeme opakovat následující příkazy :

– když bylo tlačítko “A” stisknuté, odešleme zprávu “FUNGUJE TO!”

 

Test na stisk tlačítka “A” naprogramujeme příkazem:

if button_a.was_pressed():

a odeslání textu naprogramujeme příkazem :

radio.send(“FUNGUJE TO!”)

Výše uvedený příkaz vyšle řetězec znaků. Před odesláním ještě připojí na začátek tři speciální znaky, které budou při příjmu zase odpojeny, tím se ale nemusíme dále zabývat

Text, který chceme odeslat píšeme do apostrofů nebo uvozovek. Protože v dalších složitějších programech můžeme posílat různě složité zprávy, které si musíme nejdříve složit do nějaké proměnné, použil jsem způsob, kdy se do kulaté závorky za “radio.send” nezapíše přímo text, ale název proměnné “zprava” (jméno jsem si zvolil, můžete použít jiné jméno proměnné). Na začátku programu jsem do této proměnné přiřazovacím příkazem vložil text.

zprava = “FUNGUJE TO!”
.
.
radio.send(zprava)

Pokud tlačítko “A” nestiskneme, žádná zpráva se neodesílá.

Takže dále budeme sledovat, jestli nějaká zpráva nebyla přijímačem od jiného micro:bitu zachycena. Náš micro:bit bude zachycovat zprávy, které jsou vysílány na kanále 7. (standardní nastavení). Pokud je nějaká zpráva zachycena, musím mít skupinu 24, jinak je zahozena. (to jsme si nastavili v parametrech pomocí “group=24”)

Musíme si vytvořit nějaké místo na přijatou zprávu, v programu jsem zvolil proměnnou se jménem “prijem” a vložil jsem do ní nic, to znamená, že je prázdná (viz program na konci). Zkusíme zjistit, zda byla nějaká zpráva přijatá a to příkazem :

prijem = radio.receive()

Příkaz “radio.receive()” nám do proměnné na levé straně přiřazovacího příkazu vloží přijatou zprávu. Pokud ale žádná zpráva přijatá nebyla, vloží tam micro:bit speciální hodnotu “None”.

Takže, pokud je v obsahu proměnné nějaký text, vypíšeme ho na displej micro:bitu, pokud je tam hodnota “None”, neděláme nic dalšího. Test, zda proměnná “prijem” má v sobě nějaký text uděláme tak, že se ptáme příkazem “if” :

Pokud není obsah “prijem” prázdný (None), pak obsah “prijem” vypíšeme na displej

if not(prijem is None):

display.scroll(prijem)

Výraz (prijem is None) je pravdivý pokud nebyla přijata zpráva. Protože otočíme logickým operátorem “not” logickou hodnotu z “True” na “False”, pak se příkaz “display” nevykoná   (a naopak).

Celý program můžete vidět na následujícím obrázku :

Nyní už stačí nahrát program do dvou nebo více micro:bitů a můžeme zkusit, jak to funguje.

 

Náměty pro tuto lekci :

  • Vyzkoušejte si, do jaké vzdálenosti mezi sebou micro:bity komunikují.
  • Do programu si vložte poznámkové řádky a okomentujte si jednotlivé příkazy
  • Program si uložte pod jménem B14, aby jste se k němu mohli kdykoliv vrátit nebo ho poslat emailem kamarádovi.

 

 

Aplikace C2 jednoduchá pokladnička

Návod na jednoduchou pokladničku nám poslal Michal Jurák z gymnázia Elgartova Brno. O jejich microbitím příběhu na Elgartce jsme psali zde. Paní učitelka Havířová dětem koupila micro:bit ze svého a M.Jurák byl autorem pokladničky řízené micro:bitem, do které pak studenti házeli peníze aby se složily na zaplacení micro:bit paní učitelce. Kromě micro:bitu budete potřebovat trochu zručnosti a můžete s pustit do stavby. Dne 27.6. aktualizováno o program v blokovém editoru.Continue reading