Jak si čipy mezi sebou posílají zprávy (s analogiemi na reálný svět)
⏱ Čas na studium: přibližně 1 hodina
Představ si mikrokontrolér (MCU, viz L16) jako malý mozek. Mozek sám o sobě nic neudělá — musí komunikovat s ostatními částmi těla: očima, ušima, rukama. U elektroniky je to stejné. MCU musí:
Všechny tyhle zprávy se přenášejí po drátech (vodičích). A tady začíná otázka: kolik drátů a jak rychle?
To jsou dva základní způsoby, jak po drátech poslat třeba jeden bajt (8 bitů = 8 nul a jedniček).
Analogie: paralelně je jako 8-proudová dálnice (všechno najednou), sériově je úzká cestička (auta jedou za sebou, ale velmi rychle).
Než se podíváme na konkrétní protokoly, je dobré vědět, že komunikaci dělíme do tří typů podle kdo kdy může mluvit:
Jeden mluví, druhý jen poslouchá. Nikdy to neotočíš.
Oba mohou mluvit, ale musí se střídat. Když mluví jeden, druhý poslouchá.
Oba mohou mluvit i poslouchat současně. Má to vždy dva zvláštní dráty: jeden pro směr A→B, druhý pro směr B→A.
UART je nejstarší a nejjednodušší sériový protokol — ze 70. let. Když z Arduina posíláš zprávu na Serial Monitor v počítači, uvnitř to jede přes UART. Když připojíš Bluetooth nebo GPS modul, taky UART.
Jak to vypadá fyzicky? Dva dráty + zem:
Propojení dvou zařízení: TX jednoho → RX druhého. A naopak. Překřížené jako hadice u dvou zahradních kohoutků.
Baud je rychlost — kolik bitů za sekundu se posílá. Vyslovuje se „bód". Typické hodnoty: 9600, 38400, 115200, 921600.
Jeden bajt (8 bitů) se nepošle „nahý" — má kolem sebe obálku, abychom věděli, kde začíná a kde končí. Tahle obálka se jmenuje rámec.
Nejčastější nastavení je 8N1:
Celkem 10 bitů na 1 bajt. Proto při 115200 baudu pošleš 11 520 bajtů/s (baud ÷ 10).
UART je asynchronní — nikdo neposílá metronom. Každá strana má svůj vlastní oscilátor (zdroj hodin uvnitř čipu). Pokud jeden oscilátor běží o 2 % jinak, zprávy se rozpadnou.
Levný interní RC oscilátor v AVR má přesnost ±1,5 % při pokojové teplotě, ale při −20 °C nebo +80 °C klidne posune o 10 %. Pro UART vyšší než 9600 baud proto použij krystal (přesnost 20 ppm, tedy 0,002 %).
ppm = parts per million, „dílů v milionu" — 1 ppm = 0,0001 %. 20 ppm krystal se zpožďuje max 1 sekundu za 14 hodin.
I²C (čti „I kvadrát C", anglicky „I squared C" nebo „I two C") je chytrý protokol, který umí na pouhých 2 drátech připojit až 127 zařízení. Jak to je možné? Má to systém.
Dva dráty:
Na rozdíl od UART (který se musí dohodnout předem), I²C má vyhrazený drát pro metronom. Po drátu SCL jede obdélníkový signál 0-1-0-1-0-1… a oba účastníci ho slyší.
Na I²C sběrnici je jeden šéf (master) a mnoho podřízených (slaves). Master tahle za nitky — rozhoduje, kdy někdo mluví.
Pozn.: I²C teoreticky umí i „multi-master", kdy jsou šéfové dva, ale pro hobby 99 % případů = jeden MCU a mnoho senzorů.
Každý slave má svou adresu — něco jako jméno nebo PSČ. Při 7 bitech máš rozsah 0 až 127, tedy 128 možných adres. Několik je rezervovaných, takže reálně cca 112.
0x76 (hex) = 118 (decimálně). OLED displej SSD1306 má 0x3C = 60.I²C má zvláštní elektrický trik. Drát SDA (a stejně tak SCL) je open-drain. Každý účastník ho umí stáhnout k zemi (logická 0), ale nikdo ho neumí zvednout do napájení (logická 1). Proto musíš přidat pull-up rezistory — většinou 4,7 kΩ mezi drát a +3,3 V (nebo +5 V).
ACK = „acknowledge", kývnutí „rozumím, slyším". Když master pošle adresu, slave se ozve stažením SDA k zemi na 1 takt — to je jeho „tady jsem". Pokud žádný slave tu adresu nemá, nikdo neodpoví (NACK) a master ví, že tam nic není.
Analogie: volání jmen ve škole. „Honza Novák?" — „Tady!" (ACK). „Petr Novák?" — ticho (NACK, není ve třídě).
Než zkusíš komunikovat s konkrétním čipem, ověř, že vůbec odpovídá. Napiš krátký program, který projde všechny adresy 1–126 a pošle dotaz. Čipy, co ACKnou, vypíšeš. Za 10 sekund víš, co na desce máš.
#include <Wire.h> void setup() { Wire.begin(); Serial.begin(115200); Serial.println("Hledam I2C zarizeni..."); for (byte addr = 1; addr < 127; addr++) { Wire.beginTransmission(addr); if (Wire.endTransmission() == 0) { Serial.print("Nalezen: 0x"); Serial.println(addr, HEX); } } } void loop() {}
Typické adresy, které potkáš:
0x3C (60) — OLED displej SSD13060x68 (104) — akcelerometr MPU6050, hodiny DS32310x76 (118) — meteo senzor BME280SPI (čti „es pé í") je nejrychlejší běžný sériový protokol. Používá se pro věci, kde je potřeba vysoká rychlost: SD karty (gigabajty dat), LCD displeje (hodně pixelů), externí Flash paměti, rádia (LoRa, nRF24).
Potřebuje 4 dráty (trochu víc než I²C, ale za to máš rychlost):
Tady se vracíme k pojmu z 19.2. Všimni si: SPI má samostatný drát pro každý směr (MOSI a MISO). To znamená, že šéf může mluvit a zároveň poslouchat.
I²C používá adresy (jména). SPI jde na to jinak — má fyzicky oddělený drát pro každého slave. Jeden drát = jeden slave. Master vyvolá „teď ty" tím, že stáhne jeho CS pin do logické 0.
Tohle je možná trochu technické, ale stačí základní představa. SPI módy se liší v tom, kdy přesně přečíst data vůči hodinovému signálu. Dvě volby × dvě volby = 4 módy (0, 1, 2, 3).
Praxe: v datasheetu senzoru najdeš „SPI mode 0" nebo „mode 3" a v kódu nastavíš SPI.setDataMode(SPI_MODE0). Když se to nekope, uvidíš krakatice. Nastavuj to podle datasheetu a přestaň se tím trápit.
Nebraň se: každý protokol má své typické použití. Nauč se vzory a nebudeš muset dlouho rozhodovat.
| UART | I²C | SPI | |
|---|---|---|---|
| Počet drátů | 2 + GND | 2 + GND | 4 + GND |
| Rychlost | 9,6k – 1 Mbps | 100k – 1 Mbps | 1 – 100 Mbps ⚡ |
| Směr | Full-duplex | Half-duplex | Full-duplex |
| Počet zařízení | 1:1 | až 127 na adresách | 1 master + N slaves (každý 1 CS pin) |
| Typické použití | Serial Monitor, Bluetooth, GPS, GSM | Senzory, OLED displej, EEPROM, RTC | SD karta, LCD, rádio LoRa, externí Flash |
Od teorie k blinkajícím LED a displeji, který něco vypíše
⏱ Čas na studium: přibližně 1 hodina
Co uděláme: Arduino každou sekundu pošle na Serial Monitor zprávu „Hello #1", „Hello #2", … Když do Monitoru napíšeš znak a stiskneš Send, Arduino ti odpoví „got: X". Obousměrná komunikace přes jediný USB kabel.
Hardware: žádný extra. Arduino má uvnitř čip USB-UART převodníku (CH340 nebo FT232). Ten převádí napětí TX/RX na USB protokol. Ty tam jen zapojíš USB kabel.
void setup() { Serial.begin(115200); // zapne UART, 115200 baud, 8N1 default Serial.println("UART je up!"); }
unsigned long lastMs = 0; uint16_t counter = 0; void loop() { // Každou sekundu pošli Hello #N if (millis() - lastMs >= 1000) { lastMs = millis(); Serial.print("Hello #"); Serial.println(++counter); } // Když PC něco pošle, vrať to zpět while (Serial.available()) { char c = Serial.read(); Serial.print("got: "); Serial.println(c); } }
Serial.print() nahází bajty do interního bufferu (64 B u AVR, 256 B u ESP32). Samotné vysílání bit-po-bitu dělá UART modul uvnitř čipu — je to hardware, CPU o něm nemusí vědět. Proto Serial.print neblokuje program — vrátí hned kontrolu, a vysílání doběhne na pozadí.sprintf do lokálního bufferu a pak Serial.write naráz.Co uděláme: Připojíme malý OLED displej (128×64 pixelů, modrý nebo bílý text) přes I²C na Arduino. Vypíšeme „Hello OLED!" a rostoucí číslo. Za 2 € z AliExpressu, 4 dráty. Perfektní první I²C projekt.
Hardware — jen 4 dráty:
Poznámka k pull-upům: pamatuj na 4,7 kΩ pull-up rezistory z 19.4. Většina OLED modulů z AliExpressu je má už na desce (malé odpory vedle SDA/SCL konektoru). Pokud ne, přidej je externě.
#include <Adafruit_SSD1306.h> // Vytvoříme objekt displeje: 128 pixelů široký, 64 vysoký, I²C, bez reset pinu Adafruit_SSD1306 display(128, 64, &Wire, -1); uint16_t counter = 0; void setup() { Wire.begin(); // zapne I²C na SDA=A4, SCL=A5 display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // inicializace displeje, adresa 0x3C display.setTextSize(2); // velký text (default je 1) display.setTextColor(WHITE); // text „svítí" (inverze černé) } void loop() { display.clearDisplay(); // smaž dřívější obsah display.setCursor(0, 0); // pozice kurzoru: roh vlevo nahoře display.println("Hello"); display.println("OLED!"); display.print("n="); display.println(++counter); display.display(); // pošli framebuffer do displeje delay(1000); }
display.println("Hello"), knihovna jen nastaví pixely v bufferu. Teprve display.display() pošle celý buffer přes I²C do displeje (trvá to ~30 ms při 400 kHz I²C). Tak ušetří I²C provoz — posíláš jen 1× za frame, ne při každém změně písmenka.0x3C na 0x3D.Wire.begin() na Wire.begin(21, 22) (SDA=GPIO21, SCL=GPIO22).Klíčové pojmy, pravidla a kvíz pro ověření
Shrnutí lekce 19
Test z lekce 19
Opakovací test — lekce 1–19