Category Archives: Počítače, vývoj HW a SW

Záchrana neřiditelného RC modelu skrzevá Arduino

Dítko během posledních dvou let v modelářském klubu postavilo maketu říčního remorkéru ČSPLO „Bečva„. Bezmála metrový model pro soutěže v kategorii F2B (Naviga) vypadá moc hezky….

Jpeg Celý příspěvek

Reklamy

komentáře 3

Filed under Mikrokontroléry - Arduino, ESP8266, Picaxe, ..., Počítače, vývoj HW a SW

Hodiny z pekla

Tchýně přijela na návštěvu a vypadá to, že neplánuje odjet? Zlobivý mladší sourozenec? Zbytečně dobré pracovní prostředí? Problém dokážeme snadno vyřešit s Arduinem!

Spousta lidí si stěžuje, že nemůže spát, když v místnosti tikají hodiny. Ale časem si stejně zvyknou. Co takhle to trochu vylepšit a udělat hodiny, které tikají nestandardně? Deset minut jdou běžným způsobem, pak se na půl minuty zastaví a následně zpoždění doženou… a pak zase čtvrt hodiny běží normálně. Tohle je daleko více obtěžující, než běžné tikání! A přitom ty hodiny jdou přesně – v každou chvíli je odchylka od aktuálního času menší než dvě minuty.

Tedy postavte si takovéhle super hodiny, nainstalujte je do místnosti, kde spí nechtěná návštěva, a pak už se jen kochejte výsledkem.

Celý příspěvek

Napsat komentář

Filed under Mikrokontroléry - Arduino, ESP8266, Picaxe, ..., Počítače, vývoj HW a SW

blynk.cc – rapid prototyping pro IoT (ESP8266, NodeMCU) s podporou mobilek

Blynk.cc je zajímavá platforma pro rychlé prototypování IoT řešení s vizualizací v mobilním telefonu. Pokud potřebujete vyzkoušet senzor a nechce se vám k němu psát serverovou stranu a mobilní front-end, Blynk může být správné řešení.

Podporuje Arduino (s ethernet/wifi shieldy), Particle … a napřímo podporuje i ESP-8266 (NodeMCU). A ta poslední varianta mne zaujala.

První aplikace je hotová za pět minut.

Nainstalujte si mobilkovou aplikaci a podle popisu zde založte první projekt. Získáte autorizační token.

Stáhněte si Arduino knihovnu z http://www.blynk.cc/getting-started/ . Je to ZIP soubor se čtyřmi podadresáři, které nakopírujete do adresáře libraries/ v adresáři s Arduino skeči. Restartujte Arduino IDE.

Udělejte jednoduchý skeč:

#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "autentizační token";
void setup()
{
 Serial.begin(115200);
 Blynk.begin(auth, "ssid wifi sítě", "heslo wifi sítě");
}

void loop()
{
  Blynk.run();
}

No a teď už je možné do projektu v mobilce přidat načítání a zobrazení hodnoty libovolného digitálního či analogového pinu. To se udělá prostým vložením objektu Value display (prosté zobrazení), Gauge („budík“) či Graph (graf – hodinový, denní, měsíční). Jen vložíte na stránku v mobilce ovládací prvek a řeknete mu, jaký pin mikrokontroléru (Dxx, Axx) má obsluhovat. Stejně snadno je možno nastavovat hodnoty výstupních pinů. Na straně kontroléru nic neprogramujete. Neřešíte spojení, ukládání dat na server, vizualizaci – nic.

  

Ale co když chci připojit ke kontroléru něco, co se musí ovládat složitěji než prostým načtením hodnoty z pinu?

Za tímto účelem má Blynk virtuální piny V1 až Vxx. jejich hodnota není vázána přímo na pin kontroléru, ale je obsluhována v aplikaci.

Třeba si takhle připojíme k NodeMCU teploměr DS18B20. Nejjednodušší možné zapojení – napájení na 3.3 V, zem na zem, datový pin teploměru na pin D4 kontroléru a přes odpor 4k7 na napájení.

DSC_4226

Podporu pro OneWire sběrnici má NodeMCU v sobě, knihovna DallasTemperature pro čtení teploty se instaluje v manažerovi knihoven Arduino IDE automaticky.

Sketch vypadá takto:

Hlavička:

#define BLYNK_PRINT Serial // Comment this out to disable prints and save space
#include <ESP8266WiFi.h>
#include <BlynkSimpleEsp8266.h>
#include <SimpleTimer.h>
#include <OneWire.h> 
#include <DallasTemperature.h>

#define ONE_WIRE_BUS D4
#define TEMPERATURE_PRECISION 10 

OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
DeviceAddress thermometer;

SimpleTimer timer;

// You should get Auth Token in the Blynk App.
// Go to the Project Settings (nut icon).
char auth[] = "16a...........305032d";

Setup – enumerace zařízení na OneWire sběrnici, nalezení adresy teploměru a konfigurace Blynku:

void setup()
{
 Serial.begin(115200);

 sensors.begin();
 Serial.println("***************************************************");
 Serial.print("Pocet teplomeru: ");
 Serial.println(sensors.getDeviceCount(), DEC);
 //zjisti adresy
 oneWire.reset_search();
 if (!oneWire.search(thermometer)) Serial.println("teplomer nenalezen!");

 Blynk.begin(auth, "jméno wifi", "heslo k wifi");
  // jednou za tři sekundy chceme poslat teplotu
 timer.setInterval(3000L, sendUptime);   
 
}

A vlastní výkonná smyčka:

void loop()
{
 Blynk.run();
 timer.run();
}

Aha. Tady vlastně nic neděláme s tím teploměrem, že? Teploměr se načítá jednou za 3 sekundy – ve funkci sendUptime, která je volaná z timeru:

void sendUptime()
{
 //nastav rozlišení
 sensors.setResolution(thermometer, TEMPERATURE_PRECISION);
//načti všechny teploměry
 sensors.requestTemperatures();
 float tempC = sensors.getTempC(thermometer);
 
 Blynk.virtualWrite(10, tempC); // virtual pin 
 Blynk.virtualWrite(11, tempC); // virtual pin
if( tempC>26 )
 {
 Blynk.notify("Teplota moc velka!");
 }
  
}

Je tady vidět, že načtu teplotu z teploměru a pošlu jí do dvou virtuálních pinů – V10 a V11. Proč? Protože každý virtuální pin může na mobilce končit jen v jednom zobrazovači. Takže V10 bude zobrazovat aktuální hodnotu a V11 pošlu do grafu.

Jo a ještě pozor na červený text. Pokud na mobilce do projektu vložíte objekt „Push Notifications“, tak pomocí Blynk.notify můžete poslat push notifikaci. A fakt to funguje. Tj. nejen vlastní zobrazení stavu zařízení, ale i upozornění kdykoli.

Na mobilce jsem si udělal jednoduchý projekt: jednou display value z pinu V10, jednou graf z pinu V11. A tlačítko pro ovládání pinu D0 (tam má moje NodeMCU ledku). A prvek pro push notification. No a pak stačí kliknout na „spustit“ (trojúhelníček) a žije to. Na mobilce je vidět graf teplot i aktuální teplota; po kliknutí na tlačítko „led“ se rozsvítí nebo zhasne ledka:

Screenshot_2016-03-17-18-41-36

No a pokud teplota stoupne nad 26 stupňů (zub na grafu) … na mobilce vyskočí push notifikace. I když je mobilka suspendnutá a aplikace neběží.

Screenshot_2016-03-17-14-25-56

Výhody: Skvělé pro jednoduché testování. Nemusíte programovat front-end. Podpora push-notifikací.

Nevýhody: Není webový front-end, jen mobilkový. Nepřekvapilo by mne, kdyby to časem zpoplatnili.

Na okraj: Není nutné využívat jejich cloud. Blynk server si můžete nainstalovat i lokálně u sebe.

 

Napsat komentář

Filed under Mikrokontroléry - Arduino, ESP8266, Picaxe, ..., Počítače, vývoj HW a SW

Zkuste to bez drátů, pane Marconi!

(Prvotně publikováno 7.3.2014 na raspi.cz.)

Kterak k Raspberry Pi připojit bezdrátový senzor něčeho, třeba teploty.

Pro plánované zařízení jsem potřeboval, aby dva mikrokontroléry byly schopny si mezi sebou na vzdálenost pár metrů vyměňovat data bezdrátově. Po chvíli hledání jsem našel zajímavý komunikační čip od Nordic Semiconductors – nFR24L01+.

nFR24L01+ není jen tak obyčejné ASK-OOK pípátko, přes které se dá prodloužit sériový port. Tenhle čip funguje až na vrstvě 4 modelu ISO/OSI, tedy udělá za vás spoustu práce.  Vysílá na frekvenci 2.4 GHz (volné pásmo ISM – industrial, science, magic). Umí zpracovávat pakety o délce až 32 byte, které chrání pomocí šestnáctibitového CRC. Každý čip má nastavenou svou adresu (pětibajtovou) a je schopen přijímat data až od dalších pěti čipů. A automaticky obsluhuje potvrzení příjmu od protistrany. Tedy funguje to tak, že dáte čipu data a řeknete „odešli na stanici s adresou 1-2-3-4-5“. Čip autonomně odešle data a počká na potvrzení od protistrany. Když potvrzení nedojde, opakuje vysílání ještě několikrát. A na závěr vám řekne, zda se podařilo či nepodařilo data dodat na druhou stranu. Komunikace je přes SPI. No a to nejlepší na závěr: [tady] ho mají zabalený v hezkém hotovém modulu za 1.72 USD včetně dopravy do ČR! Tedy za tuhle cenu je jeden, potřebujete dva. Ale necelé 4 USD = 80 Kč za bezdrátový spolehlivý link mi přijde jako dobrá cena.

DSC_4913

Aby se mi neznámé zařízení lépe ladilo, rozhodl jsem se, že odesílat budu z mikrokontroléru, ale přijímat budu do Raspberry Pi, protože by se to mohlo časem taky hodit. Jako mikrokontrolér pro podobné hračky používám čipy Picaxe. Konkrétně v tomhle případě Picaxe 20M2. Stejně jako u populárních Atmelů (Arduino) je to kompletní mikrokontrolér, který má na čipu vše potřebné – analogové i digitální vstupy i výstupy, podporu I2C, sériového portu a spousty dalších věcí. Programuje se to v „basicu“ – syntaxí je to basic, ale sémantikou spíše assembler (pracujete přímo s registry/pamětí). Vývojové prostředí je zdarma. Největší rozdíly proti Atmelu/Arduinu jsou tyto:

  1. Pro programování nepotřebujete programátor ani jiné specifické USB hračky. K obvodu stačí dát dva rezistory a je možné ho připojit k běžnému sériovému portu, přes který se programuje a přes který umí posílat debugovací hlášení. Podpora pro sériový port může být i v hotovém zařízení. Je možné ho tedy přeprogramovávat kdykoli.
  2. Podporuje napájení 5 V i 3.3 V.
  3. Přímo na úrovni jazyka obsahuje spoustu knihoven, které pokrývají většinu úkolů. Potřebujete změřit délku impulzu? Načíst teplotu z 1-wire teploměru? Poslat data přes I2C? Na všechno jsou tam jednořádkové příkazy, které to umí samy.

Zapojení – vysílač – Picaxe

Na straně vysílače je to jednoduché. Všechny datové nohy bezdrátového modulu připojíme napřímo na nohy mikrokontroléru.

  • C.0  -> Nordic CE
  • C.1  -> Nordic CSN
  • C.2  -> Nordic SCK
  • C.3  -> Nordic MOSI
  • C.4  -> Nordic MISO
  • C.5  -> Nordic IRQ

Na další piny připojíme 1-wire teploměr DS18B20 (do standardního zapojení popsaného na webu Picaxe) a dvě LED diody pro signalizaci (komunikace OK, chyba). Zbývá už jen napojit napájení bezdrátového modulu. A tady pozor! I když jsou datové nohy modulu tolerantní k 5 V, napájení musí být 3.3 V! A ještě jedno upozornění: k napájení modulu je nutné připojit kondenzátor 10 uF. Dokud tam nebyl, chovalo se to divně.

DSC_4919

Schema zapojení:

DSC_4920

Zapojení – přijímač – Raspberry Pi

Tady P.T. čtenáře přesměruji [na tento článek]. Tam je to všechno step-by-step popsáno, včetně zapnutí SPI na straně Raspberry Pi.

DSC_4915

Zapojení je extrémně jednoduché – jen se propojí odpovídající piny RPi s odpovídajícími piny modulu.

RPi GPIO9 /MISO    (Pin 21)    – modul  pin 7 ( MISO )
RPi GPIO10/MOSI   (Pin 19)   – modul  pin 6 ( MOSI )
RPi GPIO11/CLK   (Pin 23)    – modul  pin 5 ( SCK )
RPi GPIO8/CE0     (Pin 24)    – modul pin 4 ( CSN )
RPi GPIO25  (Pin 22)    – modul pin 3  ( CE ) – tohle je jediná věc mimo standardní SPI zapojení, tímhle pinem se ovládá, kdy je modul rádiově aktivní
RPI 3.3V        (Pin 1)    – modul  pin 2 ( VCC/3.3V )
RPi Gnd         (Pin 6)    – modul  pin 1 (GND)

Software

Vhodný startovní kód pro Picaxe jsem [našel zde].

Kód pro Raspberry Pi je na již dříve [zmíněném odkazu].

Samozřejmě, že si spolu navzájem nerozuměly. Musel jsem postupně procházet datasheet obvodu a pochopit, co je potřeba změnit:

  • Obě strany samozřejmě musí mít stejně nastavenu linkovou vrstvu – frekvenci, rychlost, režim potvrzování.
  • Na straně přijímače musí být nastavená stejná délka paketu, jakou vysílač opravdu pošle.
  • Vysílající strana si nastaví odesílací i přijímací adresu na stejnou adresu, jakou má přijímač (!!!).
  • Odesilatel by si neměl vymaskovat stavové informace o odeslání paketu, přijímač by neměl nechat maskovat stavové informace o příjmu paketu.
  • No a pak nastane magie a začne to fungovat.

Finální kód pro obě strany najdete [zde].

Raspberry Pi tedy dostává každou chvíli paket o délce 1 byte, který obsahuje teplotu naměřenou na straně vysílače, přímo ve stupních celsia.

Finální řešení bude mít i na straně přijímače také mikrokontrolér Picaxe. Ale až někdy budete potřebovat něco měřit bezdrátově, vzpomeňte si na moduly nFR24L01+, možná budou váš problém řešit.

Jo a ještě zbývá doplnit dosah: na volném prostranství jsem měl data cca 25 metrů od vysílače. Přes dvě tlusté zdi to funguje na cca 8 metrů bez problémů.

Napsat komentář

Filed under Mikrokontroléry - Arduino, ESP8266, Picaxe, ..., Počítače, vývoj HW a SW

Levný LCD displej připojený přes I2C

Prvotně publikováno na raspi.cz 27.5.2013.

Pro účely zobrazení provozních dat jsem potřeboval připojit nějaký levný LCD displej. Vzhledem k tomu, že se mi nechce obsazovat hejno I/O pinů běžným displejem s paralelním rozhraním, hledal jsem něco s I2C … a našel jsem: podsvícený displej 2×16 znaků s I2C sběrnicí za USD 8.69 (poštovné do ČR zdarma).

Technicky je to standardní paralelní displej 2×16 s nejběžnějším řadičem HD44780. Ten je připojen na I2C osmibitový I/O port expandér PCF8574 sedící na adrese 0×20 (adresa se dá změnit propojkami na desce). Tento expandér je výrazně jednodušší než mnou dříve použitý MCP23009 – není potřeba jej nijak nastavovat. Data zaslaná na I2C adresu expandéru se rovnou pošlou na výstupy.

Vzhledem k tomu, že displej je na 5 V, připojil jsem k němu I2C bus přes převodník úrovníza USD 2.60 (poštovné zdarma). Zapojení je jednoduché: na 5V straně jsem připojil +5V a zem; na 3.3V straně jsem napájení nezapojoval. A pak jsem na dva z pinů na 3.3V straně přivedl SDA a SCL z RasPi a na druhé straně tyto piny zapojil do displeje.

Mapování skutečných nožiček displeje na porty expandéru je toto:

bit 7 = backlight, 0=rozsviceno
bit 6 = RS; 0=command, 1=data
bit 5 = RW; 0=write, 1=read — takže vždy 0
bit 4 = E; 0=klid, 1=strobe
bit 3 = D7
bit 2 = D6
bit 1 = D5
bit 0 = D4

Řízení těchto displejů je poměrně jednoduché. Teorie je hezky popsána na tomto odkazu, ale pro praxi je možná jednodušší vyjít z pythoního samplu tady (pozor, předpokládá jiné zapojení nožiček).

Takže za další hodinku jsem napsal ovládací program v Javě… a zcela překvapivě to fungovalo.

Poslední, co je potřeba otestovat, je znaková sada displeje.  Každý z těchto kontrolérů má jinou sadu znaků podle toho, pro jakého zákazníka byl stavěn. Já našel tohle:

Výsledek je uspokojivý.

Ukázkovou aplikaci najdete ke stažení zde. Vyžaduje nainstalovanou knihovnu pi4j.

NA ZÁVĚR ODKAZY

1) Teorie LCD řadičů HD44780 – http://joshuagalloway.com/lcd.html

2) Praktický sampl v Pythonu: http://www.raspberrypi-spy.co.uk/2012/07/16×2-lcd-module-control-using-python/

3) Stránky zdejšího diskutujícího MiKa, který řešil podobný problém. Připojoval displeje s paralelním připojením: http://www.astromik.org/raspi/16.htm a posléze i přes I2C, kde si ale expandér zapojil sám: http://www.astromik.org/raspi/32.htm

Napsat komentář

Filed under Počítače, vývoj HW a SW

I/O v Javě, rychlé I/O, PWM modulace a tak dále

Prvotně publikováno na raspi.cz 29.3.2013.

V nedávném článku „Propojujeme Raspberry Pi a Arduino“ si Buben postěžoval, že

  • RPi postrádá PWM
  • Nelze rozumně spolehlivě reagovat na změny na vstupních pinech, protože synchronní polling by bral moc času procesoru a byl by z důvodu multiprocesingu v linuxu nespolehlivý

… a že tedy je lepší předat obsluhu I/O Arduinu.

S výsledkem této úvahy souhlasím. Složitější I/O nemá obtěžovat CPU, mají ho dělat kanálové procesory – tak nás IBM učí už více než 50 let. A volba Arduina není špatná. Nicméně předpoklady, na základě kterých Buben toto tvrzení postavil, jsou nepravdivé.

Pro spoustu aplikací stačí počet I/O portů, které má RPi – a pro spoustu aplikací stačí ihardwarová podpora, kterou má RPi pro řešení obou výše uvedených problémů.

Hardwarové PWM výstupy

Přímo na expanzním portu snadno najdete pin GPIO1 (18), což je zároveň výstup hardwarového PWM, které má RPi v sobě. Ale uznávám, že jedno PWM je nanic. Každý smysluplný kus železa potřebuje alespoň tři serva = tři PWM kanály. Co s tím?

Samozřejmě je blbost aplikačně simulovat PWM tím, že budeme na GPIO pin sypat jedničky a nuly. To by skutečně stálo všechen procesorový výkon a navíc by to nebylo spolehlivé  – přepínání tasků v linuxu by způsobilo nahodilé a nepříjemné výpadky v modulaci.

Ale co kdyby ty jedničky a nuly na výstup za nás sypal někdo jiný? Někdo, kdo to umí bez zátěže procesoru?

Ano, to je správná cesta. V paměti připravíme „obraz“ jednoho PWM pulzu (tj. třeba 500 nul a pak 500 jedniček = máme pulz s plněním 50%) a pak stačí říct řadiči DMA, ať tento kus paměti fixním tempem neustále dokola posílá na daný pin. A ejhle, funguje to.

Hotovou implementaci pro základní PWM najdete zde: https://github.com/sarfata/pi-blaster/

Detailnější popis je na stránce autora.

Aplikaci stačí nainstalovat a spustit (nebo nechat spouštět automaticky při bootu). Ovládání je pak jednoduché: Příkazem

echo "1=0.3" > /dev/pi-blaster

nastavíme pin 1 na PWM plnění 30%,

echo "1=1" > /dev/pi-blaster

dá plnění 100% atd. Zatížení procesoru je nulové a signál je hezky pravidelný, bez výpadků. Takto může být obsluhováno více GPIO pinů, defaultně jich pi-blaster řídí 8.

Pokud nechcete pomocí PWM řídit úroveň jasu LEDky, ale chcete ovládat serva, nepotřebujete „standardní“ PWM, ale trochu jiné. U serv je to tak, že frekvence pulzů by měla být 100 Hz; impulz o délce 1 msec je 0% výkonu, impulz o délce 2 msec je 100% výkonu. Kratší pulzy jsou chyba, delší taky.  Chce se vám s tím ladit? Jistě ne. Takže potřebujeme hotové řešení.

Najdeme ho tady: https://github.com/richardghirst/PiBits/tree/master/ServoBlaster

Výše popsaný projekt pi-blaster vznikl jako rozšíření myšlenky ServoBlasteru. Pi-blaster má hezčí implementaci (ovládání přes soubor).

Hardwarová detekce změny stavu GPIO pinu – jak nepollovat I/O procesorem

Procesor, na kterém je RPi postaveno, samozřejmě umí na změnu stavu vstupního GPIO pinu navázat přerušení.

Tedy zbývá jen zjistit, zda je tato služba podporována v linuxu a dá se používat?

Ano, je tam a funguje.

Tedy ve své aplikaci můžete snadno říct „až se změní stav GPIO0, zavolej mojí funkci X()“.

Test jsem provedl v Javě, což je pro real-time programování výrazně nevhodný jazyk. Nicméně Javu mám jako svůj denní nástroj a přemýšlím v ní; navíc jsem už líný používat pointery a podobné věci, ze kterých se v céčku dá postavit operační systém, a rád se od nich nechám odstínit.

Pro integraci Javy s GPIO na RPi existuje hezká knihovna pi4j. Více o ní napíšu za chvíli, ale ten důležitý výsledek testu je: interrupt-driven obsluha GPIO na RPi funguje. Za klidového stavu (tj. když se nic neděje, na GPIO nejsou žádné změny) to nežere žádný strojový čas. A v té ošklivé pomalé Javě to zvládá obsloužit až zhruba 2000 změn stavu za sekundu. A když přijde osamocený milisekundový impulz, neztratí se, Java ho dostane.

Podpora pro RPi GPIO v Javě – pi4j

Knihovna pi4j je přesně to, co potřebujete, pokud si chcete hrát s I/O na RPi ve vyšším jazyce.

Co umí?

  • Pro začátek samozřejmě obsluhu jednotlivých GPIO pinů. Nastavení směru, nastavení hodnoty.  A eventy o změnách stavu.
  • Taky je tam podpora pro I2C. Snadno můžete mluvit s I2C zařízeními.
  • Nezapomnělo se ani na sériové porty (UART).
  • SPI? No jasně.

Už tohle vše by bylo dobrým důvodem knihovnu používat, ale zde funkce teprve začínají. Autoři si totiž uvědomili, že když už mají dobře navržené abstraktní rozhraní pro GPIO, tak by s ním šlo obsluhovat víc věcí.

  • Máte na I2C připojený I/O expandér MCP23008 / MCP23009, o kterém jsem dříve psal? Tak si prostě místo standardního objektu „pin“ vyžádáte tento objekt od providera MCP23008GpioProvider. Toť vše. Veškerá další obsluha tohoto „drátu“ je stejná – je jedno, jestli pracujete s pinem přímo na expanzním portu, nebo s pinem za expandérem MCP23009. Wow!
  • Totéž samozřejmě platí i pro I2C I/O expandéry MCP23017 a PCF8574. A taky pro expandér MCP23S017 připojený přes SPI.
  • Koupili jste si expanzní desku PiFace? Kód je připraven.
  • Přímá podpora pro řízení krokových motorků. Stačí namapovat řídící vodiče a pak už jen můžete říkat „100 kroků plnou rychlostí doprava“.
  • Komunikace se senzorem Wii Motion Plus (modul s gyroskopem rozšiřující standardní ovladač pro Nintendo Wii, připojuje se přes I2C).
  • Obsluha LCD displejů.

Knihovna je hezky navržená a pro jednotlivé funkční bloky jsou tam hotové samply.

Jak rychle vlastně Java na RPi s I/O pracuje?

Udělal jsem takový jednoduchý test. Na jeden GPIO pin (výstupní) jsem připojil LED diodu, a zároveň jsem ho spojil na druhý pin – vstupní.

O změnách na vstupu jsem si nechal posílat eventy.

A pak jsem v jednoduché smyčce posílal na výstup jedničky a nuly.

Co jsem zjistil?

Maximální frekvence na výstupním drátu dosažitelná z mé aplikace byla zhruba 2 kHz. Nicméně kdybych si dal práci s nastavení JVM, mělo by to být výrazně lepší.

Pro délku jedničky/nuly 1 msec se už začaly některé eventy o změnách ztrácet. V průměru jsem dostal 986 eventů na 1000 změn. Vytížení CPU bylo tvrdých 100%. První eventy přišly až po cca 100 msec od zahájení vysílání – ale to je dáno přepínáním threadů v Javě; smyčka posílající 1/0 prostě nepustila procesor. Ale eventy se frontují, takže se povětšinou neztrácejí.  (U osamoceného milisekundového pulzu se eventa neztratila nikdy; ztrácení je skutečně funkcí objemu změn.)

Pro impulzy o délce 5 msec už vytížení procesoru spadlo na 50% a eventů dorazilo 998 z tisíce.

10 msec pulzy už vytěžovaly procesor jen na 30% a eventy se neztratily žádné.

Pro delší pulzy vytížení procesoru klesalo k neměřitelnosti.

A samozřejmě: když jsem takhle posílal na výstup třeba 100 Hz signál, na svitu LED byly jasně vidět nepravidelnosti . Linux prostě není real-time systém a občas vám procesor sebere na tak dlouhou dobu, že je to vidět jako zřetelné mrknutí LEDky.

Napsat komentář

Filed under Počítače, vývoj HW a SW

1-wire snímače na I2C, přesnější měření teploty

Prvotně publikováno na raspi.cz 21.11.2012.

V komentářích u článku o měření teploty přes čidla na I2C komentoval „DFZ“ nepoužití Dallasovských 1-wire čidel s tím, že připojit je přes GPIO4 a kernelový patch je snadné. Tak tedy zamyšlení a ukázka na téma 1-wire.


Něco málo teorie – co to je 1-wire?

„1-wire“ je patentní systém komunikace s čidly a obecně zdroji krátkých informací (teploměry, vlhkoměry, identifikační čipy, hodiny, malé paměti, …) od Dallas Semiconductors (nyní Maxim). Jedno z obchodních jmen této technologie je „iButton“ a rutinně se používá v docházkových systémech.

V jednodušší verzi stačí pro připojení zařízení dva vodiče – zem a obousměrný signálový drát. Jednotlivá koncová zařízení se v tomto případě napájejí parazitně ze signálového vodiče.

Pokud chcete mít maximální spolehlivost, můžete použít třívodičové zapojení – zem, napájení a signál.

Základním kouzlem 1-wire je rozumně navržený komunikační protokol a to, jak se obsluhuje sběrnice – a z obou těchto bodů vyplývající spolehlivost a maximální dosah. Na jednu sběrnici je možno připojit hodně čidel – až stovky zařízení. Dobře nastavený 1-wire bus s dobrým bus driverem (s aktivním napájením datového vodiče atd.) na kvalitním krouceném kabelu UTP-5 může fungovat až na vzdálenost v řádu 500 metrů a nenechá se rozhodit poměrně silným rušením. V amatérských podmínkách není problém připojovat zařízení vzdálená několik desítek metrů.

Jak připojit 1-wire zařízení k RPi?

Jsou v podstatě tři základní metody připojování 1-wire zařízení:

1) Použití hotového bus driveru na RS-232 nebo USB.

Existují moduly od Dallasu i od jiných výrobců (např. zde), které se připojí na USB nebo RS-232 a na druhém konci z nich kouká 1-wire. Jednoduché. Jeden problém je ale cena – mluvíme o řádově 30 USD. Druhý problém je, že to není elegantní – přece k RPi nebudeme připojovat ošklivý adaptér, který je stejně velký jako celá malina? A v neposlední řadě nemáme USB portů nazbyt, že?

2) Připojení čidel přímo na GPIO4 

Součástí distribuce Occidentalis je přímá podpora 1-wire čidel na GPIO4 pomocí bit-bangingu (tj. někdo v assembleru nakódoval správné sekvence nul a jedniček; pro časování se nepoužívá žádný hardware, je to čistě softwarové řešení). Stejná funkce se pomocí kernelového patchu „w1“ dá docpat i do běžného Raspbianu.

Jenže se mi to nelíbí.

Nelíbí se mi realizace. Distribuce Occidentalis mi nefungovala dobře. A řešení s kernelovým patchem znamená, že už nepoužíváte standardní kernel – a tedy při každém update systému musíte řešit, zda to bude fungovat i nadále. Kdyby se to dostalo do jádra Raspbianu, bylo by to něco jiného.

Nelíbí se mi ale ani samotná myšlenka, že se to bude řešit přímo na GPIO portu. Smysl to určitě má – pro jednotky čidel na drátu dlouhém max. desítky centimetrů. Ale představa, že by 1-wire bus byl delší a na jednom konci končil přímo procesorem RPi … brrr. Odolnost takového řešení proti indukci neočekávaných napětí je mizivá. Takže jednoho dne zjistíte, že vaše RPi shořelo.

Takže co nám zbývá?

3) Použití bus driveru pro I2C

Ano, to je správná cesta. Na I2C si připojíme bus driver – čip, který má na jedné straně I2C a na druhé jeden či více 1-wire busů. Když se něco semele, vyměníme jen spálený bus driver – a ten je navíc výrazně odolnější než procesor RPi. Takže tohle je určitě správná cesta.

Připojení 1-wire čidla teploty přes bus driver DS2482

DS2482-100 (25 Kč u TME) je to, co hledáme. (Maximalisté mohou použít DS2482-800 – to je stejný čip, ale má 8 1-wire busů.)

Datasheet.

Tenhle čip má jen jednu malinkou chybičku. Skoro přehlédnutelnou. Největší pouzdro, ve kterém se vyrábí, je SO-8. Tj. rozměry čipu jsou cca 4×6 mm a rozteč nožiček je poloviční proti běžným DIL pouzdrům – 1/20″ (pro evropany 1,27 mm). Do nepájivého kontaktního pole to nedostanete.

Takže nezbývá než vyndat pájku. SO-8 je asi nejmenší velikost pouzdra, co se ještě dá amatérsky pájet.

Pokud se vám, stejně jako mně, nechce si leptat vlastní plošný spoj, je možné ho koupit zde. Ideální není – tomu, kdo vymyslel vývody pod čipem bych utrhnul něco důležitého – ale použít se dá.

Zapojení je jednoduché:

  • 1 – napájení +3.3V
  • 2 – datový vodič pro 1-wire, je nutné připojit přes odpor 4k7 na +3.3V
  • 3 – GND
  • 4 – SCL
  • 5 – SDA
  • 6 – pomocí této nohy se řídí „aktivní napájení datového vodiče 1-wire“, což neřešíme = nezapojit
  • 7+8 – výběr adresy, spojíme na GND
Dsc_34751

Takto zapojený 1-wire bus je nejjednodušší možný – pro malé počty čidel a krátké přívody. Pokud bychom chtěli připojit hodně čidel a/nebo mít bus velmi dlouhý (desítky metrů), je potřeba tam přidat jeden MOSFET transistor pro aktivní pullup řízený nožičkou číslo 6. Jo a taky by se hodilo napájení sběrnice +5V. Viz datasheet.

Jako experimentální čidlo použijeme čidlo teploty DS18B20 (24 Kč u TME). Datasheet. DS18B20 umožňuje až 12-bitovou konverzi dat a v rozsahu -10 až +85 stupňů slibuje přesnost +-0.5 stupně. A je v pěkně použitelném třínožičkovém pouzdru.

Zapojení je jednoduché – prostřední nožičku na 1-wire data, levou na GND a pravou na +3.3V. Pokud bychom chtěli připojit více čidel, všechny se zapojí paralelně.

Ds2482-1_bb1

Software

Nejprve se koukneme, zda vidíme bus driver na I2C sběrnici.

pi@raspberrypi ~ $ i2cdetect -y 0
0 1 2 3 4 5 6 7 8 9 a b c d e f
00: — — — — — — — — — — — — —
10: — — — — — — — — 18 — — — — — — —
20: 20 — — — — — — — — — — — — — — —
30: — — — — — — — — — — — — — — — —
40: — — — — — — — — 48 — — — — 4d — —
50: — — — — — — — — — — — — — — — —
60: — — — — — — — — — — — — — — — —
70: — — — — — — — —

Je tam nové zařízení na adrese 18, takže je to v pořádku.

No a teď jak to vlastně použít – jak načíst hodnoty z čidel?

Kouzlo linuxu a open-source světa je, že hodně problémů už někdo promýšlel a vyřešil je lépe, než bych dokázal sám. Takže i pro 1-wire čidla existuje řešení – OWFS (one-wire file system). A existuje přímo v balíčku pro Raspbian!

Tak do toho:

sudo mkdir /mnt/1wire
sudo apt-get install owfs
sudo apt-get install owfs-doc
sudo apt-get install ow-shell

Nyní je potřeba editovat /etc/owfs.conf :

Zakomentujte (přidejte před ní #) řádku:

server: FAKE = DS18S20,DS2405

a přidejte následující řádky:

device = /dev/i2c-0
mountpoint = /mnt/1wire
Celsius
allow_other
error_print = 0
error_level = 0

Dále editujte /etc/fuse.conf – odkomentujte řádku

user_allow_other

Teď by bylo dobré restartovat. Chvilku počkáme, než RPi naběhne… a pak zkusíme vypsat obsah owfs:

pi@raspberrypi ~ $ owdir
/28.9614C2030000
/bus.0
/uncached
/settings
/system
/statistics
/structure
/simultaneous
/alarm

Výpis „owdir“ ukazuje strukturu objektů v owfs. Objekt „/28.9614C2030000“ reprezentuje teplotní čidlo; kdyby bylo připojeno více čidel, měly by obdobná jména. Objekt „/bus.0“ je 1-wire sběrnice; kdyby bylo více sběrnic (např. při použití čipu DS2482-800), bylo by zde více záznamů „/bus.#“ .

Objekty jsou uloženy stromově – je možné se dívat i na další úrovně. Třeba na detaily čidla:

pi@raspberrypi ~ $ owdir /28.9614C2030000
/28.9614C2030000/address
/28.9614C2030000/alias
/28.9614C2030000/crc8
/28.9614C2030000/errata
/28.9614C2030000/family
/28.9614C2030000/fasttemp
/28.9614C2030000/id
/28.9614C2030000/locator
/28.9614C2030000/power
/28.9614C2030000/r_address
/28.9614C2030000/r_id
/28.9614C2030000/r_locator
/28.9614C2030000/temperature
/28.9614C2030000/temperature10
/28.9614C2030000/temperature11
/28.9614C2030000/temperature12
/28.9614C2030000/temperature9
/28.9614C2030000/temphigh
/28.9614C2030000/templow
/28.9614C2030000/type

Pro čtení dat z jednotlivých souborů je k dispozici příkaz owread. Můžeme se tedy zeptat třeba na typ připojeného čidla:

pi@raspberrypi ~ $ owread /28.9614C2030000/type
DS18B20

A jakou nám měří teplotu?

pi@raspberrypi ~ $ owread /28.9614C2030000/temperature
20.4375

(Jaké hodnoty jsou v dalších souborech a co s nimi? Nastudujte si za domácí úkol dokumentaci OWFS a datasheet čidla DS18B20.)

Stejným způsobem jako k čidlu se můžeme chovat i k ostatním položkám stromu OWFS. Třeba můžeme zjisti, jaký bus master je použit pro bus.0:

pi@raspberrypi ~ $ owread /bus.0/interface/settings/name
DS2482-100

Jak zde je vidět, OWFS řeší spoustu věcí, ne jen vlastní zjištění teploty. Pro většinu 1-wire zařízení OWFS umožňuje plnohodnotné použití. Například u teplotních čidel je tak možno zjišťovat maxima a minima nebo nastavovat limity pro automatické alerty. Vygenerované alerty pak najdete v cestě /alarm.
Dá se to ještě vylepšit? No jistě!

Copak asi značí to „FS“ v názvu OWFS? Filesystém.

Zkusíme ho spustit:

sudo owfs

No a teď zkusíme použít ne „owdir“, ale prostý výpis adresáře:

pi@raspberrypi ~ $ ls -l /mnt/1wire
total 0
drwxrwxrwx 1 root root 8 Nov 17 23:49 28.9614C2030000
drwxr-xr-x 1 root root 8 Nov 17 23:49 alarm
drwxr-xr-x 1 root root 8 Nov 17 23:49 bus.0
drwxr-xr-x 1 root root 8 Nov 17 23:49 settings
drwxrwxrwx 1 root root 8 Nov 17 23:49 simultaneous
drwxr-xr-x 1 root root 8 Nov 17 23:49 statistics
drwxr-xr-x 1 root root 32 Nov 17 23:49 structure
drwxr-xr-x 1 root root 8 Nov 17 23:49 system
drwxr-xr-x 1 root root 8 Nov 17 23:49 uncached

A hele? Je tu totéž, co vypisovalo owdir!
A data se z toho čtou jak? No jako z normálních souborů:

pi@raspberrypi ~ $ cat /mnt/1wire/28.9614C2030000/temperature
20.6875

Šlo by z toho dostat ještě víc?

Pomocí služby owhttpd je možné stejná data zpřístupnit jako webové stránky.

Aplikace owserver a owhttpd jsou systémové služby, takže se spouští při startu systému a je možno je ovládat pomocí

sudo service owserver start
sudo service owserver stop

resp.

sudo service owhttpd start
sudo service owhttpd stop

Další odkazy

A design guide for the layman: understanding, designing and building MicroLan™ (1-Wire) networks:
http://www.1wire.org/Files/Articles/1-Wire-Design%20Guide%20v1.0.pdf

Guidelines for Reliable Long Line 1-Wire® Networks:
http://www.maximintegrated.com/app-notes/index.mvp/id/148
Zde najdete informace, jak počítat délky 1-wire sítě a jaké jsou limity 

Quickstart quide pro ubuntu:
http://owfs.org/index.php?page=quickstart-guide

Kterak zajistit, aby se „owfs“ (ne owserver) spustilo samo po startu systému:
http://wiki.temperatur.nu/…

Jak připojit čidla teploty přes GPIO4 a kernelový patch (česky – zdejší diskutující MiK):
http://www.astromik.org/raspi/15.htm

Dsc_34731

1 – I2C teploměry
2+3 – I2C GPIO expandér a jím řízená LED
4 – budič 1-wire sběrnice DS2482-100
5 – teplotní čidlo DS18B20

Napsat komentář

Filed under Počítače, vývoj HW a SW