From 88b9757fb50867d3212e33f608898b768f37989e Mon Sep 17 00:00:00 2001 From: BigTire Date: Fri, 6 Jan 2023 21:45:17 +0100 Subject: [PATCH] =?UTF-8?q?P=C5=99id=C3=A1n=C3=AD=20pozn=C3=A1mek=20ke=20z?= =?UTF-8?q?kou=C5=A1ce=20ze=20ZPI?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- KIV ZPI/Readme.md | 392 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 392 insertions(+) create mode 100644 KIV ZPI/Readme.md diff --git a/KIV ZPI/Readme.md b/KIV ZPI/Readme.md new file mode 100644 index 0000000..1fdc969 --- /dev/null +++ b/KIV ZPI/Readme.md @@ -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 ``` +- ```// 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()``` \ No newline at end of file