|
|
|
|
@ -0,0 +1,392 @@
|
|
|
|
|
# Poznámky ke zkoušce ze ZPI
|
|
|
|
|
- 3 základní prvky IoT architektury
|
|
|
|
|
- **zařízení**
|
|
|
|
|
- **síť**
|
|
|
|
|
- **Cloud**
|
|
|
|
|
- komunikační technologie vhodné pro IoT:
|
|
|
|
|
- Wifi, Bluetooth, BLE (Bluetooth Low Energy), LoRa
|
|
|
|
|
- LPWAN (Low Energy Wide Area Network): LoraWAN, Sigfox, Zigbee apod.
|
|
|
|
|
- Klíčové faktory komunikačních technologií:
|
|
|
|
|
- **přenosová rychlost**
|
|
|
|
|
- **spotřeba energie**
|
|
|
|
|
- **dosah**
|
|
|
|
|
- **frekvence**
|
|
|
|
|
|
|
|
|
|
## Věc
|
|
|
|
|
- obvykle se skládá z:
|
|
|
|
|
- senzorů
|
|
|
|
|
- mikropočítače / mikrokontroléru
|
|
|
|
|
- komunikačního modulu
|
|
|
|
|
- **senzor**
|
|
|
|
|
- **zdroj informací** pro měřicí nebo řídicí systém
|
|
|
|
|
- je určen ke **sledování stavu prostředí**
|
|
|
|
|
- **snímá fyzikální veličinu** ve svém okolí (= vždy má fyzikální princip)
|
|
|
|
|
- druhy senzorů:
|
|
|
|
|
- pasivní / aktivní
|
|
|
|
|
- dotykové a bezdotykové senzory
|
|
|
|
|
|
|
|
|
|
## Mikrokontrolér
|
|
|
|
|
- získává data ze senzorů
|
|
|
|
|
- zpracovává data
|
|
|
|
|
- odesílá data do cloudu
|
|
|
|
|
- Základní architektury
|
|
|
|
|
- mikroprocesor doplněný o další obvody k řízení elektroniky
|
|
|
|
|
- **Harvardská** architektura
|
|
|
|
|
- použití => **účelové počítače**
|
|
|
|
|
- oddělený paměťový prostor pro data a program – umožňuje vyšší rychlost zpracování
|
|
|
|
|
- **Von Neumannova** architektura
|
|
|
|
|
- použití => **univerzální počítače**
|
|
|
|
|
- společný prostor pro data i program
|
|
|
|
|
- Podle šířky datové sběrnice se µC dělí na:
|
|
|
|
|
- 8 – bitové
|
|
|
|
|
- 16 – bitové
|
|
|
|
|
- 32 – bitové
|
|
|
|
|
|
|
|
|
|
### Piny mikrokontroléru
|
|
|
|
|
- GPIO, ADC, DAC, SPI, I2C, UART, PWM
|
|
|
|
|
|
|
|
|
|
### Programování mikrokontrolerů
|
|
|
|
|
- **jazyky nízké úrovně** – strojový kód, assembler
|
|
|
|
|
- **vyšší programovací jazyky** - základní příkazy jsou nezávislé na µC, vyžadují překladač nebo interpretr
|
|
|
|
|
- základní jazyk pro programování mikrokontrolerů C/C++, popř. jazyky z nich odvozené (Wiring – Arduino)
|
|
|
|
|
- Mbed platforma
|
|
|
|
|
- výkonnější µC mohou využívat micro-Python
|
|
|
|
|
- 2 typy překladačů:
|
|
|
|
|
- **interpretační**
|
|
|
|
|
- **kompilační**
|
|
|
|
|
|
|
|
|
|
### Vývojová prostředí pro µC
|
|
|
|
|
- Arduino, ESP32, Nucleo, Micro:bit
|
|
|
|
|
- univerzální vývojové IDE
|
|
|
|
|
- VisualStudio Code, Platforma Mbed
|
|
|
|
|
|
|
|
|
|
### Struktura programu pro mikrokontrolér
|
|
|
|
|
- inicializační část
|
|
|
|
|
- Nastavení pinů µC, komunikační rychlosti, definice proměnných programu, definice podprogramů pro obsluhu přerušení, inicializace časovačů apod.
|
|
|
|
|
- výkonná část
|
|
|
|
|
- Hlavní program µC – test vstupních pinů, čtení dat ze senzorů, nastavení výstupních pinů, komunikace s okolím apod.
|
|
|
|
|
|
|
|
|
|
### Jednoduchý program pro M5Stack
|
|
|
|
|
- Zobrazení textu na obrazovce
|
|
|
|
|
- ```from m5stack import lcd```
|
|
|
|
|
- ```lcd.clear()```
|
|
|
|
|
- ```lcd.print('Hello World',100,100, lcd.WHITE)```
|
|
|
|
|
|
|
|
|
|
## Typový systém
|
|
|
|
|
- **Dynamický**
|
|
|
|
|
- datový typ proměnné nemusíme definovat => datový typ se automatický mění
|
|
|
|
|
- **Statický**
|
|
|
|
|
- musíme definovat typ proměnné a tento typ je dále neměnný
|
|
|
|
|
|
|
|
|
|
## Proměnná, identifikátor, typy proměnných
|
|
|
|
|
- **Proměnná** – objekt ve kterém jsou uložena data
|
|
|
|
|
- **identifikátor** - název proměnné
|
|
|
|
|
- **základní datové typy**:
|
|
|
|
|
- int, float, str, bool
|
|
|
|
|
|
|
|
|
|
## Přiřazovací příkaz
|
|
|
|
|
- **identifikátor = výraz**
|
|
|
|
|
- výraz může obsahovat:
|
|
|
|
|
- matematické operátory
|
|
|
|
|
- logické operátory
|
|
|
|
|
- relační operátory
|
|
|
|
|
- výraz se vyhodnocuje zleva do prava podle priority
|
|
|
|
|
- prioritu operací lze měnit závorkami ()
|
|
|
|
|
|
|
|
|
|
## Výpis hodnoty proměnné
|
|
|
|
|
- print(object(s), sep=separator, end=end)
|
|
|
|
|
|
|
|
|
|
## Větvení
|
|
|
|
|
- if podmínka:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- další příkaz
|
|
|
|
|
- if podmínka:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- else:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- další příkaz
|
|
|
|
|
- if podmínka:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- elif podmínka:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- else:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- další příkaz
|
|
|
|
|
|
|
|
|
|
## Cykly
|
|
|
|
|
- S pevným počtem opakování:
|
|
|
|
|
- for proměnná in posloupnost:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- další příkaz
|
|
|
|
|
- ```for i in range(5):```
|
|
|
|
|
- S ukončovací podmínkou:
|
|
|
|
|
- while logická_podmínka:
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- další příkaz
|
|
|
|
|
|
|
|
|
|
## Funkce v Pythonu
|
|
|
|
|
- procedura - funkce, která nic nevrací
|
|
|
|
|
- definice funkce:
|
|
|
|
|
- def jméno_funkce(a,b,c):
|
|
|
|
|
- blok příkazů
|
|
|
|
|
- return res
|
|
|
|
|
- volání funkce:
|
|
|
|
|
- příkazy
|
|
|
|
|
- p=jméno_funkce(3,7,10)
|
|
|
|
|
- příkazy
|
|
|
|
|
|
|
|
|
|
## Balíčky, moduly, import
|
|
|
|
|
- **balíček** = knihovna funkcí, které spolu nějakým způsobem souvisí, může být členěn do modulů
|
|
|
|
|
- Balíček může obsahovat konstanty, funkce, datové typy
|
|
|
|
|
- **Modul** – soubor funkcí
|
|
|
|
|
|
|
|
|
|
### Import balíčku a jeho částí
|
|
|
|
|
- ```import jméno_balíčku```
|
|
|
|
|
- Přístup k funkcím přes tečkovou notaci
|
|
|
|
|
- ```import jméno_balíčku as xx```
|
|
|
|
|
- ```from jméno_balíčku import jméno```
|
|
|
|
|
- Z balíčku se importuje pouze modul (nebo funkce) jméno
|
|
|
|
|
- ```from jméno_balíčku import *```
|
|
|
|
|
- Z balíčku se importují všechny moduly
|
|
|
|
|
|
|
|
|
|
### Výpis obsahu balíčku
|
|
|
|
|
- ```import jméno_balíčku```
|
|
|
|
|
- ```dir(jméno_balíčku)```
|
|
|
|
|
|
|
|
|
|
## GPIO – (General Purpose Input Output)
|
|
|
|
|
- mohou být nastaveny jako **vstupní** nebo jako **výstupní**
|
|
|
|
|
- Nastavení pinů se provádí před hlavním cyklem mikrokontroleru ( while True: ) (např. u arduina ve funkci void setup() )
|
|
|
|
|
- Ovládání pinů je obsaženo v modulu ```machine```, který je u M5Stack součástí balíčku ```m5stack```
|
|
|
|
|
- nastavení Pinu pro výstup:
|
|
|
|
|
- ```import m5stack```
|
|
|
|
|
- ```pin26= machine.Pin(26,machine.Pin.OUT)```
|
|
|
|
|
- ```pin26.on() # výstup v úrovni 1```
|
|
|
|
|
- ```Pin26.off() # výstup v úrovni 0```
|
|
|
|
|
- U výstupního pinu musíme dát pozor, aby pinem netekl větší proud
|
|
|
|
|
- nastavení Pinu pro vstup:
|
|
|
|
|
- ```import m5stack```
|
|
|
|
|
- ```pin26= machine.Pin(26,machine.Pin.IN,machine.Pin.PULL_UP)```
|
|
|
|
|
- ```print(pin26.value())```
|
|
|
|
|
|
|
|
|
|
## Obsluha tlačítek u M5Stack Fire
|
|
|
|
|
- 3 tlačítka , která mají v API přiřazena jména ```btnA```, ```btnB```, ```btnC```
|
|
|
|
|
- funkce pro práci s tlačítky:
|
|
|
|
|
- ```isPressed()```, ```wasPressed()```, ```isReleased()```, ```wasReleased()```, ```pressFor(delay)```, ```wasDoublePress()```
|
|
|
|
|
|
|
|
|
|
## Přerušení vs pooling
|
|
|
|
|
- **pooling**
|
|
|
|
|
- mikrokontrolér cyklicky testuje zda mají senzory připravená data
|
|
|
|
|
- **přerušení**
|
|
|
|
|
- reakce mikrokontroléru na asynchronní událost
|
|
|
|
|
- pokud má senzor připravená data „vyzve procesor“ k jejich zpracování
|
|
|
|
|
- procesor může mezi událostmi zpracovávat jinou část programu nebo může „spát“
|
|
|
|
|
|
|
|
|
|
## MicroPython vs. Python
|
|
|
|
|
- Micropython je redukovaná implementovaná verze interpreteru jazyka Python 3
|
|
|
|
|
- od klasického Pythonu se liší pouze množstvím knihoven (modulů) – některé chybí, některé jsou naopak přidány
|
|
|
|
|
|
|
|
|
|
## LCD - API
|
|
|
|
|
- Soubor funkcí, které pracují s obrazovkou
|
|
|
|
|
- ``` from m5stack import lcd ```
|
|
|
|
|
- barvy => ```lcd.BLACK```, ```WHITE```, ...
|
|
|
|
|
- fonty => ```lcd.FONT_Default```, , ```FONT_Ubuntu```
|
|
|
|
|
- ```lcd.clear([color])```
|
|
|
|
|
- ```lcd.print(text [,x,y, color, …])```
|
|
|
|
|
- ```lcd.fontSize()```
|
|
|
|
|
|
|
|
|
|
## Seznamy v micropythonu
|
|
|
|
|
- seznam je heterogenní datová struktura => lze do ní ukládat proměnné různých datových typů
|
|
|
|
|
- prázdný seznam: ```seznam = []```
|
|
|
|
|
- vytvoření proměnné x typu seznam, obsahující prvky: ```x=[1.5, 3, ‘text’]```
|
|
|
|
|
- délka seznamu: ````delka = len(x)```
|
|
|
|
|
- procházení seznamu: ```for i in x:```
|
|
|
|
|
- vložení prvku na konec: ```x.append(val)```
|
|
|
|
|
- vložení prvku na index: ```x.insert(index, val)```
|
|
|
|
|
- smazání prvku podle hodnoty: ```x.remove(val)```
|
|
|
|
|
- smazání prvku podle indexu: ```x.pop(index)```
|
|
|
|
|
|
|
|
|
|
## IMU (Inertial Measurement Unit)
|
|
|
|
|
- měří **polohu** a **orientaci** objektu obvykle je složený z **akcelerometru** a **gyroskopu**, někdy s magnetometrem
|
|
|
|
|
|
|
|
|
|
## Časovače
|
|
|
|
|
- **čítač**, který používá **taktovací signál**
|
|
|
|
|
- použití (např.):
|
|
|
|
|
- generování periodických impulsů
|
|
|
|
|
- PWM (pulsně šířková modulace)
|
|
|
|
|
- U ESP32 jsou k dispozici 4 hardwarové časovače
|
|
|
|
|
- Micropython:
|
|
|
|
|
- Pro práci s časovači se používá třída ```machine.Timer```
|
|
|
|
|
- Nastavení parametrů časovače:
|
|
|
|
|
- ```from machine import Timer```
|
|
|
|
|
- ```tim0=Timer(0)```
|
|
|
|
|
- ```tim0.init(period=2000,mode=Timer.PERIODIC,callback=tim_callback)```
|
|
|
|
|
- ```Timer.ONE_SHOT``` / ```Timer.PERIODIC```
|
|
|
|
|
- obslužná rutina přerušení časovače:
|
|
|
|
|
- ```def tim_callback(timer):```
|
|
|
|
|
- ```global i```
|
|
|
|
|
- ```lcd.clear()```
|
|
|
|
|
- ```lcd.print(i,100,100,lcd.RED)```
|
|
|
|
|
- ```i=i+1```
|
|
|
|
|
- ukončení časovače: ```tim0.deinit()```
|
|
|
|
|
|
|
|
|
|
## A/D (analog/digital) převodníky
|
|
|
|
|
- Převádí spojitou hodnotu napětí na číslicovou reprezentaci
|
|
|
|
|
- Základní charakteristiky:
|
|
|
|
|
- **Počet kvantizačních úrovní**
|
|
|
|
|
- **Kvantizační krok**
|
|
|
|
|
- Souměrnost
|
|
|
|
|
- Typ převodníku
|
|
|
|
|
- **Rozsah vstupního napětí**
|
|
|
|
|
|
|
|
|
|
### Typy převodníků
|
|
|
|
|
- **Paralelní** (flash) **převodník**
|
|
|
|
|
- Princip: Vstupní napětí Vin se porovnává komparátory s referenčním napětím na napěťovém děliči. Výstup komparátorů je kódován do binární podoby.
|
|
|
|
|
- +: rychlý převod (převod se provádí paralelně) -: vyšší spotřeba, drahé
|
|
|
|
|
- **Převodník s následnou aproximací** (SAR)
|
|
|
|
|
- tři bloky:
|
|
|
|
|
- SAR (successive aproximation register) – registr postupné aproximace
|
|
|
|
|
- komparátor
|
|
|
|
|
- D/A převodník
|
|
|
|
|
- **Tento typ převodníku se používá u většiny mikrokontrolerů**
|
|
|
|
|
- **Sigma-delta převodní**
|
|
|
|
|
- moderní typ převodníku, dosahuje vysokého rozlišení (16-24 bit) za relativně nízkou cenu
|
|
|
|
|
- jednoduchý hardware
|
|
|
|
|
- složitý software
|
|
|
|
|
- jádrem převodníku je integrátor a komparátor
|
|
|
|
|
|
|
|
|
|
## Použití ADC převodníku na ESP32
|
|
|
|
|
- obecně 2 dostupné ADC převodníky
|
|
|
|
|
- V micropythonu na ESP32 je modul ```ADC``` pro převod součástí knihovny ```machine```
|
|
|
|
|
- import modulu a vytvoření objektu adc s nastavením pinu na kterém je převodník:
|
|
|
|
|
- ```from machine import ADC, Pin```
|
|
|
|
|
- ```adc=ADC(Pin(36))```
|
|
|
|
|
- Čtení hodnoty převodníku do proměnné ```xx```:
|
|
|
|
|
```xx=adc.read()```
|
|
|
|
|
- Změna parametrů převodu:
|
|
|
|
|
- ```ADC.atten(attenuation)```
|
|
|
|
|
- ```ADC.width(width)```
|
|
|
|
|
|
|
|
|
|
## D/A – (digital/analog) převodníky
|
|
|
|
|
- Převádí číslicovou reprezentaci na analogový signál
|
|
|
|
|
- Charakteristiky:
|
|
|
|
|
- Rozsah výstupního napětí (u ESP32 - 0-3.3V)
|
|
|
|
|
- Počet kvantizačních úrovní (počet bitů) (u ESP32 je 8 bitový DAC – tj. lze zadat číslo v rozsahu 0-255)
|
|
|
|
|
- Typy převodníků:
|
|
|
|
|
- přímé
|
|
|
|
|
- vstupní datové slovo je přímo převedeno na výstupní napětí (proud)
|
|
|
|
|
- nepřímé
|
|
|
|
|
|
|
|
|
|
## D/A nepřímý převodník
|
|
|
|
|
- U nepřímých převodníků – pomocná veličina je impulz
|
|
|
|
|
- převodníky s pulzně šířkovou modulací (PWM)
|
|
|
|
|
|
|
|
|
|
### Použití DAC převodníku na ESP32
|
|
|
|
|
- Obecně jsou na ESP32 dostupné 2 převodníky
|
|
|
|
|
- Převodník je 8 bit (255 úrovní) a vstupní rozsah napětí je 0-3.3V
|
|
|
|
|
- Použití:
|
|
|
|
|
- generátor funkcí
|
|
|
|
|
- v kombinaci s ADC jako digitální signálový procesor
|
|
|
|
|
- V micropythonu na ESP32 je modul ```DAC``` pro převod součástí knihovny ```machine```
|
|
|
|
|
- Aktivace modulu a vytvoření objektu dac s nastavením pinu na kterém je převodník
|
|
|
|
|
- ```from machine import DAC, Pin```
|
|
|
|
|
- ```dac=DAC(Pin(26))```
|
|
|
|
|
- Převod číslicové hodnoty xxx na analogové napětí
|
|
|
|
|
- ```dac.write(xxx)```
|
|
|
|
|
|
|
|
|
|
## PWM – Pulse Width Modulation
|
|
|
|
|
- Jedná se o způsob, jak uměle získat analogové napětí na digitálním pinu
|
|
|
|
|
- rychlým přepínáním digitálního pinu z úrovně H do úrovně L a naopak
|
|
|
|
|
- PWM je charakterizováno základní frekvencí změny úrovně a tzv. střídou (duty cycle) což je poměr mezi tím, jak dlouho je signál v úrovni H oproti úrovni L v rámci jedné periody (střída 50% značí že doba v úrovni H je stejná jako v úrovni L)
|
|
|
|
|
- U ESP32 => lze použít PWM na všech pinech, které lze nastavit jako výstupní
|
|
|
|
|
- Použití:
|
|
|
|
|
- Řízení rychlosti motorů
|
|
|
|
|
- Stmívání LED
|
|
|
|
|
- Řízení servomotorů apod.
|
|
|
|
|
- V micropythonu na ESP32 je modul ```PWM``` součástí knihovny ```machine```
|
|
|
|
|
- Aktivace modulu a vytvoření objektu pwm0 s nastavením pinu na kterém bude PWM použito
|
|
|
|
|
- ```from machine import PWM, Pin```
|
|
|
|
|
- ```pwm0=PWM(Pin(26))```
|
|
|
|
|
- ```Pwm0=PWM(Pin(26),freq=1000,duty=200) ```
|
|
|
|
|
- Zjištění základní frekvence, nastavení základní frekvence PWM na 1000 Hz
|
|
|
|
|
- ```print(pwm0.freq())```
|
|
|
|
|
- ```pwm0.freq(1000)```
|
|
|
|
|
- Zjištění duty-cycle a nastavení duty-cycle
|
|
|
|
|
- ```print(pwm0.duty())```
|
|
|
|
|
- ```pwm0.duty(200)```
|
|
|
|
|
- Ukončení práce s PWM
|
|
|
|
|
- ```pwm0.deinit()```
|
|
|
|
|
|
|
|
|
|
## Co je Mbed
|
|
|
|
|
- Mbed OS je operační systém s otevřeným zdrojovým kódem a vývojový nástroj pro platformy využívající mikrokontroléry
|
|
|
|
|
- Platforma Mbed je postavena na jazyku C/C++
|
|
|
|
|
- Mbed OS obsahuje ovladače pro mnoho různých hardware:
|
|
|
|
|
- moduly, desky, komponenty
|
|
|
|
|
|
|
|
|
|
### Mikrokontrolery ARM
|
|
|
|
|
- 32 bitová architektura typu RISC
|
|
|
|
|
- velmi často využíván v mobilních odvětvích
|
|
|
|
|
- ARM1 (1984), aktuální ARM11
|
|
|
|
|
|
|
|
|
|
### Vývoj aplikací v Mbed
|
|
|
|
|
- 3 možnosti vývoje aplikace:
|
|
|
|
|
- 1. Online překladač
|
|
|
|
|
- 2. Mbed Studio
|
|
|
|
|
- 3. PlatformIO
|
|
|
|
|
|
|
|
|
|
### Struktura programu v Mbed
|
|
|
|
|
- ```#include <mbed.h>```
|
|
|
|
|
- ```// deklarace globálních proměnných```
|
|
|
|
|
- ```void main() {```
|
|
|
|
|
- ```// deklarace lokálních proměnných```
|
|
|
|
|
- ```while (1) {```
|
|
|
|
|
- ```…```
|
|
|
|
|
- ```}```
|
|
|
|
|
- ```}```
|
|
|
|
|
|
|
|
|
|
## UART/USART
|
|
|
|
|
- jednoduchá komunikační linka mezi dvěma zařízeními
|
|
|
|
|
- asynchronní plně duplexní komunikace
|
|
|
|
|
- někdy se používá USART => podporuje i synchronní verzi
|
|
|
|
|
- typické parametry - 8/N/1 - bity se přenáší od LSB k MSB
|
|
|
|
|
- Propojení modulů vždy „křížem“
|
|
|
|
|
|
|
|
|
|
### UART – konfigurace a použití
|
|
|
|
|
- Micropython:
|
|
|
|
|
- Pro práci s UART se používá třída ```machine.UART```
|
|
|
|
|
- Práce s UART:
|
|
|
|
|
- Vytvoření objektu ```uart2``` typu UART
|
|
|
|
|
- ```from machine import UART```
|
|
|
|
|
- ```uart2=UART(2)```
|
|
|
|
|
- ```Uartx=UART(id, tx=číslo_pinu,rx=číslo_pinu)```
|
|
|
|
|
- Nastavení parametrů komunikace
|
|
|
|
|
- ```uart2.init(baudrate=9600,bits=8,parity=None,stop=1)```
|
|
|
|
|
- Komunikace (u ESP32 lze použít pouze metodu „pooling“)
|
|
|
|
|
- ```uart.any()```
|
|
|
|
|
- ```xxx=uart.read()```
|
|
|
|
|
- ```xxx=uart.read(n)```
|
|
|
|
|
- ```xxx=uart.readln()```
|
|
|
|
|
- ```uart.write(txt)```
|
|
|
|
|
- Ukončení činnosti sériového rozhraní
|
|
|
|
|
- ```uart2.deinit()```
|
|
|
|
|
|
|
|
|
|
## Bluetooth komunikace M5stack
|
|
|
|
|
- M5stack micropython API nepodporuje bluetooth komunikaci
|
|
|
|
|
- Lze to vyřešit použitím BT-UART modulů
|
|
|
|
|
- POZOR!!!! Moduly jsou sice napájeny 3-6V, ale RX a TX piny nejsou 5V tolerant
|
|
|
|
|
- BT modul se konfiguruje AT příkazy
|
|
|
|
|
|
|
|
|
|
## I²C – (Inter- Integrated Circuit)
|
|
|
|
|
- synchronní poloduplexní komunikace (= jeden vodič pro data a jeden vodič pro taktovací signál)
|
|
|
|
|
- používá se pro připojení nízkorychlostních zařízení
|
|
|
|
|
- Zařízení typu master zahajuje a ukončuje komunikaci, adresuje zařízení slave se kterým chce komunikovat a generuje hodinový signál SCL
|
|
|
|
|
- Zařízení slave je adresované masterem, obvykle poskytuje data
|
|
|
|
|
|
|
|
|
|
### I²C – konfigurace a použití
|
|
|
|
|
- Micropython:
|
|
|
|
|
- Pro práci s I²C se používá třída machine.I2C
|
|
|
|
|
- Práce s UART:
|
|
|
|
|
- Vytvoření objektu i2c typu I2C
|
|
|
|
|
- ```from machine import I2C```
|
|
|
|
|
- ```i2c=I2C(1,sda=21, scl=22[,freq=400000])```
|
|
|
|
|
- hledání adres zařízení
|
|
|
|
|
- ```lst=i2c.scan()```
|
