Tento článek nebude úplně ryze o Raspberry Pi, ale o tom, jak ho propojit s nějakým dalším zařízením. Komunikace bude realizovaná pomocí sériového portu emulovaného přes USB.

Krátce po zakoupení RPi jsem se začal zajímat, jak využít jeho GPIO piny k získávaní dat z různých čidel, senzorů a podobných udělátek. Brzy jsem zjistil, že situace není tak růžová, jak bych si přál. RPi postrádá A/D převodníky, PWM a navíc je drahé na to, abych si mohl dovolit ho nějakou svou neuvážeností spálit. Co se týče experimentování s elektronikou, na to je staré známé Arduino prostě vhodnější. Čínský klon z Ebay stojí pár dolarů (¼ ceny oproti originálu!), free shipping je samozřejmost, jen ta cesta domů mu trvala okolo měsíce.

Abych se přiznal, tak původní motivace nechat obsluhovat senzory Arduino byla ještě jiná, než výše zmíněné nevýhody Rpi. A to sice, že pokud chcete včas zareagovat na událost vyvolanou čidlem, musí synchronní polling provádět sám procesor, což je na multiprocesovém systému velmi nevhodné. Takový program by spotřebovával značnou část procesorového času naprosto zbytečně. Navíc nemůžete zaručit, že ve chvíli výskytu signálu bude mít tento program procesor vůbec přidělen (frekvence přepínání procesů bývá 100 Hz, tento případ je tedy spíše teorií). Mnohem lepší je přenechat obsluhu senzoru Arduinu, které navíc může zaručit reakci v reálném čase, a našemu RPi už jen bude posílat zprávu o výskytu této události. To bude data číst pomocí blokujícího systémového volání, výskyt události jednoduše obslouží a pak se do dalšího výskytu zablokuje. Pojďme tedy na to.

USB sběrnice může s pomocí hubů obsluhovat až 127 zařízení, s tím by si měl vystačit snad každý. Délka kabelu může být standardně 5 metrů, v případě použití optického kabelu i delší. Po připojení Arduina k PC se vytvoří emulovaná sériová linka. Tu lze identifikovat pomocí symbolického odkazu v /dev/serial.

pi@raspberrypi-test ~ $ ls -l /dev/serial/by-id/*
lrwxrwxrwx 1 root root 13 Jan 28 17:15 /dev/serial/by-id/usb-Arduino__www.arduino.cc__Arduino_Mega_2560_7523733353635140C190-if00 -> ../../ttyACM0

Naše sériové rozhraní má soubor umístěný v /dev/ttyACM0. Abychom s ním mohli komunikovat i bez práv roota, je nutné být ve skupině dialout.

pi@raspberrypi-test ~ $ sudo usermod -a -G dialout pi

Nezapomeňte, že změna se projeví, až když se znovu přihlásíte.

Do Arduina nahrajeme jednoduchý kód, který přečte znak ze sériového portu, malá písmena převede na velká a odešle zpět. Komunikace tedy bude probíhat oběma směry.

int character;

void setup() {
Serial.begin(9600);
}

void loop() {
if(Serial.available()) {
character = Serial.read();

if(character <= 'a' && character >= 'z') {
character += 'A' - 'a';
}

Serial.print(character);
}
}

Popisem kódu se zabývat nebudu, důležité je jen, že budeme používat baudrate 9600 bit/s.

Nyní napíšeme krátký skript, který poběží na RPi. Pochopitelně můžete použít jakákoli váš oblíbený programovací jazyk. Já dávám přednost Pythonu. Pro pohodlnou práci se sériovým portem nejdříve nainstalujeme modul PySerial.

pi@raspberrypi-test ~ $ wget http://pypi.python.org/packages/source/p/pyserial/pyserial-2.6.tar.gz
pi@raspberrypi-test ~ $ tar -zxf pyserial-2.6.tar.gz
pi@raspberrypi-test ~ $ cd pyserial-2.6/
pi@raspberrypi-test ~ $ python setup.py build && sudo python setup.py install

Instalace je opravdu primitivní. Ještě jednodušší je jeho použití. Vlastně jen vytvoříme vhodný objekt a potom už nás mohou zajímat jen jeho metody read() a write().

Pokud chceme současně číst a zapisovat data, jsou nasnadě tři možná řešení.

1. Přesně definovat pořadí komunikace – synchronní výměna dat. Jednoduše řečeno program dopředu ví, kdy se budou data odesílat a kdy přijímat. Jakákoli nekonzistentnost je špatně. Například při čtení dat se program zastaví a pokračuje až když data opravdu příjme. Arduino na druhou stranu ale může odeslat data, až když mu něco přiteče po sériové lince. Tomuto stavu se říká deadlock a je silně nežádoucí.
2. Pro čtení a zápis vytvořit samostatný proces/vlákno. Jedná se o velmi běžné řešení, vzniká ale problém jejich vzájemné synchronizace.
3. Využití techniky multiplexingu, neboli asynchronní programování. Jinak řečeno, program zpracovává ta data, která má k dispozici. Pokud má možnost něco přečíst, čte. Pokud potřebuje něco zapisovat, zapisuje. V jeden okamžik se ale vykonává pouze jedna činnost. Výhodou je, že si vystačíme pouze s jedním vláknem, odpadá tedy nutnost jakékoli synchronizace. Naopak nevýhodou je asi největší náročnost na kód. Velmi lehce se může stát, že jedním zapomenutým blokujícím volám zablokujeme úplně všechno. My využijeme tohoto principu, avšak v té nejjednodušší podobě.

Základem všeho je volání select. Jedná se o jediné povolené blokující volání, vše ostatní by mělo být neblokující. Pracuje velmi jednoduše, jako parametry se mu předají tři seznamy souborových descriptorů (ukazatelů na otevřené soubory). První seznam obsahuje ty descriptory, u kterých nás zajímá, jestli z nich můžeme něco přečíst, druhý seznam obsahuje descriptory kam bychom chtěli něco zapsat a třetí seznam descriptory, u kterých chceme ošetřovat výskyt nějaké chyby. Volání vrátí také tři seznamy, ovšem jen s těmi descriptory, které jsou připraveny na požadované operace. Jedná se tedy vlastně o takový filtr. Například pokud chceme číst data z deseti různých descriptorů a select nám vrátí jen tři, znamená to že pouze tři descriptory skutečně nějaká nová data obsahují. Ty potom obsloužíme a vše se opakuje. Pokud nic není připraveno na žádnou operaci, select zastaví program. Odblokuje ho až ve chvíli, kdy alespoň jeden descriptor bude obsloužitelný.

Celý zdrojový kód skriptu vypadá takto:

#!/usr/bin/env python

import serial

import sys

import select

import os

import time

 

def main():

ser = serial.Serial(‚/dev/ttyACM0‘, 9600)

 

time.sleep(1) # cekani nez se seriova linka inicializuje

 

ser.flushOutput() # vyprazdneni bufferu

ser.flushInput()

ser.nonblocking() # prepnuti seriove linky do neblokujiciho modu

 

while True:

r, w, x = select.select([ser.fileno(), sys.stdin], [], [])

 

for read in r:

if read is sys.stdin:

ser.write(os.read(sys.stdin.fileno(), 1))

if read == ser.fileno():

sys.stdout.write(os.read(ser.fileno(), 1))

 

if __name__ == ‚__main__‘:

try:

main()

except KeyboardInterrupt:

exit(0)

Pozn: prosím dodržte správné odsazování, Python je na něj citlivý.

Proces čeká na vstup z stdin a sériového portu. Pokud nějaká z nich má připravena data ke zpracování, přečte jeden byte, provede příslušnou akci a znovu zkontroluje jestli jsou k dispozici nějaká další data.

Skript není úplně ideální, správný asynchronní program by se měl chovat tak, že z jednoho descriptoru zpracuje všechna dostupná data naráz. Ne tedy, že po každém přečteném byte bude volat select. Bohužel, nepodařilo se mi vstup z stdin přepnout do neblokujícího módu, program tedy blokovaně čekal na další data nebo EOF signál (konec souboru, v případě stdin stisk ctrl + d). Při nespecifikované maximální délce čtení jeden byte, by deadlock vznikl velmi lehce. To samé platí o řádcích 22 a 24. Pokud by požadavek pro zápis nebyl vyřízen okamžitě, program by byl zbytečně blokován, místo toho aby dělal něco užitečného. Berte to jako příklad, jak je snadné jedním zapomenutým blokujícím voláním zbořit celý program.

Tímto způsobem je tedy efektivně možné RPi ulehčit od zátěže. Samozřejmě například teplotní čidlo není problém připojit na GPIO. Kontrola teploty, řekněme jednou za pět sekund, v pohodě stačí a procesor téměř nic nepozná. Pokud ale chcete obsluhovat cokoli charakteru tlačítka, jedná se o velmi vhodné řešení. V případě digitalizace analogového vstupu nebo PWM snad i jedné možné řešení za rozumné peníze. Navíc vyhrazený čip v Arduinu dokáže zaručit reakci v reálném čase.