Komunikace modulu Arduino s USB deskou Velleman K8055

Aneb „Vdechněme nový život staré desce Velleman K8055“

V letech 2003 až 2015 byla deska Velleman K8055 ikonou mezi nadšenci do elektroniky a automatizace. Umožňovala snadno ovládat fyzický svět z prostředí Windows/Linux pomocí několika řádků kódu v C#, VB nebo Delphi, a to bez nutnosti programovat samotné mikročipy. S masivním nástupem platformy Arduino však tato koncepce zdánlivě ztratila smysl. Samotné Arduino (např. verze Uno) nabídlo vyšší rychlost, více I/O pinů a zlomkovou cenu. A to nemluvě o tom, že deska K8055 narážela na limity USB HID protokolu s latencí okolo 10–20 ms.

Obrázek č. 1 – Funkční propojení modulu Arduino UNO s USB deskou Velleman K8055N

Autonomní řízení pomocí Arduina a USB Host Shieldu

Má propojení Arduina s K8055 pomocí tohoto USB Host Shieldu v dnešní době ještě nějaký význam? Možná ne, možná ano – to již záleží na konkrétním bastlíři.

Každopádně lze řící, že v mnoha ohledech jde o velmi zajímavý bastlířský počin:

• Zaskočení za staré PC: Arduino vybavené USB Host Shieldem dokáže zcela nahradit energeticky náročné PC (s Windows či Linuxem) v již vybudovaném a odladěném HW řešení. Starý projekt tak může fungovat dál jako úsporný embedded systém bez nutnosti předělávat stávající koncepci, desky plošných spojů a příslušnou kabeláž.
• Hardware, který něco snese: Karta K8055 má na rozdíl od citlivých pinů Arduina ošetřené a odolné vstupy i výstupy, které lze bezpečně používat v náročnějším prostředí nebo pro spínání vyšších proudů. Deska K8055 se tak může stát pro náš mikrokontrolér určitým „elektrickým firewallem“.
• Dva reálné D/A převodníky: Deska K8055 disponuje dvěma 8bitovými analogovými výstupy (DAC). Běžné desky Arduino napěťový D/A převodník nemají a spoléhají pouze na simulaci pomocí PWM regulace. Potřebujeme-li někde modul Arduino jednoduše doplnit o dvojici DA převodníků, může karta K8055 alespoň dočasně zaskočit.

Spojení historické karty a mikrokontroléru tak najednou může představovat docela rychlou a elegantní cestu, jak vdechnout nový život funkčnímu hardwaru a ušetřit si práci s návrhem nových obvodů.

Princip komunikace

Dále používaný způsob komunikace modulu Arduino a USB karty Velleman K8055 bude postaven na rozšíření modulu Arduino pomocí USB Host Shield. Karta Velleman K8055 se chová jako standardní USB HID zařízení (podobně jako klávesnice, joystick nebo myš). Aby s ní bylo možné komunikovat, musí k ní být připojen tzv. USB Host (řídicí jednotka).

Běžné desky jako Arduino Uno (čip ATmega328P) však mají vestavěné USB pouze v roli USB Client/Device, což slouží jen pro nahrávání kódu a sériovou komunikaci s PC. Ani mikrokontroléry s přímou podporou USB (jako ATmega32u4 v Arduinu Leonardo) nativně USB Host nezvládají.

Proto musíme Arduinu dodat tuto USB schopnost pomocí již zmíněného rozšiřujícího modulu USB Host Shield (nejčastěji osazeného čipem MAX3421E). Pro K8055 se tak Arduino stane k nerozeznání od klasického počítače s USB portem.

Obrázek č. 2 – Modulu Arduino UNO s nasazeným rozšířením USB Host Shield

Variabilita hardwaru:

• Arduino UNO & Mega 2560 & Leonardo: Standardní USB Host Shield padne rozměrově na UNO. Díky vyvedení komunikace přes ICSP konektor funguje rovnou i na deskách Mega a Leonardo.
• Arduino Pro Mini: Pro kompaktní vestavné aplikace existují i malé moduly Mini USB Host Shield, které lze přímo použít na miniaturní desky Arduino – např. Arduino Pro Mini.

Jak USB Host Shield funguje a které piny zabírá

USB Host Shield komunikuje s mikrokontrolérem přes rychlou sériovou sběrnici SPI (Serial Peripheral Interface).

Přehled zapojení pinů (příklad pro Arduino UNO):

• MOSI: Pin 11 (nebo z ICSP konektoru) – datový výstup z Arduina
• MISO: Pin 12 (nebo z ICSP konektoru) – datový vstup do Arduina
• SCK: Pin 13 (nebo z ICSP konektoru) – hodinový signál
• CS/SS (Chip Select): Pin 10 – výběr čipu MAX3421E
• INT (Interrupt): Pin 9 – přerušení pro detekci událostí na USB
• RESET: Pin 7

Technická poznámka z praxe

Karta K8055 si bere napájení (5 V) přímo z USB portu. Karta K8055 má vlastní odběr cca 100–200 mA (podle počtu sepnutých LED a zatížení DAC). USB Host Shield spoléhá na napájení z modulu Arduina. Pokud budeme Arduino napájet jen přes připojený USB kabel z PC, může se stát, že napětí pro K8055 může klesnout a karta bude nestabilní. Vždy při připojené desce K8055 napájejte Arduino z externího zdroje (7–12 V), aby napájecí kaskáda dokázala udržet stabilních 5 V pro USB zařízení.

Jak ovládat Velleman K8055 přes USB Host Shield

Propojení karty K8055 s Arduinem přes USB Host Shield staví na tom, že karta funguje jako standardní zařízení třídy USB HID (Human Interface Device). Karta nepotřebuje žádné složité ovladače – komunikace probíhá posíláním a přijímáním 8bajtových paketů (HID Data Reports).

Identifikace karty na USB sběrnici (VID & PID)

Jakmile zapojíte K8055 do USB Host Shieldu, jeho obslužná knihovna musí kartu identifikovat. K tomu slouží dvě konstanty:

• Vendor ID (VID): Karta K8055 vrací hodnotu 0x10CF, která udává výrobce – společnost Velleman.
• Product ID (PID): Tato hodnota záleží na nastavení jumperů SK5 a SK6 (určující adresu karty) na připojené desce K8055 (adresování karty je 0 až 3):
  • 0x5500 – Adresa 0 (oba jumpery nasazeny)
  • 0x5501 – Adresa 1
  • 0x5502 – Adresa 2
  • 0x5503 – Adresa 3 (oba jumpery odstraněny)

Anatomie HID paketů:

Komunikace mezi modulem Arduino a rozhraním Velleman K8055 (nebo novější revizí K8055N) probíhá ve formě standardních 8bajtových USB HID reportů. Při odesílání příkazů z Arduina do karty (OUT paket) určuje Bajt 0 kód příkazu, zatímco zbývající bajty (Bajt 1–7) obsahují požadovaná data pro výstupy nebo parametry nastavení. Při čtení vrací karta stav svých modulů v 8bajtové odpovědi (IN paket).

A) Směr Arduino → K8055 (OUT Paket/Příkazy a Výstupy)

V následující tabulce je uveden přehled základních příkazů, jejich kódy pro Bajt 0 a struktura odesílané osmice bajtů [Bajt 0, Bajt 1, ..., Bajt 7].

Zdroj: https://github.com/rm-hull/k8055/blob/master/MANUAL.md

B) Směr K8055 → Arduino (IN Paket/Čtení vstupů)

Karta K8055 vrací odpověď v 8bajtové struktuře buf[0..7]:

Zdroj: https://github.com/rm-hull/k8055/blob/master/MANUAL.md

Praktická realizace v kódovém prostředí Arduina

Zápis na kartu:

S využitím knihovny USB Host Shield 2.0 a její třídy HIDUniversal lze komunikaci nízkoúrovňově obsloužit následujícím způsobem:

#include <Usb.h>
#include <hiduniversal.h>

// Deklarace USB a HID rozhraní
USB Usb;
HIDUniversal Hid(&Usb);

// Vyrovnávací paměť pro odesílání dat do K8055 (8 bytů)
uint8_t outBuffer[8] = { 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

void setup() {
    Serial.begin(115200);
    Serial.println(F("Inicializace USB Host Shieldu..."));
    if (Usb.Init() == -1) {
        Serial.println(F("OSCOK selhal - USB Host Shield nenalezen!"));
        while (1); // Zástavka při chybě HW
    }

    delay(200);
    Serial.println(F("USB Host pripraven. Pripojte desku K8055..."));
}

void loop() {
    Usb.Task(); // Obsluha USB sběrnice

    // Ověření, zda je HID zařízení připojeno a nalezeno
    if (Hid.isReady()) {
        // Příklad: Rozsvítíme výstupy DO1 a DO3 (bit 0 a bit 2 -> 1 + 4 = 5 = 0x05)
        // a nastavíme analogový výstup DAC1 na polovinu (128 ~ 2.5V)
        outBuffer[0] = 0x05; // Příkaz zápisu
        outBuffer[1] = 0x05; // Digitální výstupy: DO1 a DO3 ON
        outBuffer[2] = 128;  // DAC1: ~2.5 V
        outBuffer[3] = 0;    // DAC2: 0 V

        // Odeslání paketu přímo na OUT endpoint rozhraní K8055
        uint8_t rcode = Usb.setReport(Hid.GetAddress(), 0, 8, 0x02, 0x00, outBuffer);

        if (rcode != 0) {
            Serial.print(F("Chyba odeslani USB reportu: "));
            Serial.println(rcode, HEX);
        }

        delay(100); // Rychlá smyčka pro aktualizaci výstupů
    }
}

Čtení z karty

Čtení dat probíhá přes přerušení (Interrupt IN Endpoint). Pro plynulé čtení vstupů z K8055 je v knihovně nutné vytvořit potomka třídy HIDReportParser. Ten automaticky zachytí každý paket zaslaný kartou při změně vstupů nebo v rámci periodického dotazování.

Třída HIDReportParser z knihovny USB Host Shield 2.0 slouží k automatickému zpracování příchozích dat z USB zařízení v momentě, kdy je na vraceném rozhraní (Interrupt IN endpoint) k dispozici nový paket.

Vytvořením vlastního potomka této třídy přeneseme dekódování bajtů přímo do samostatné metody, čímž udržíme hlavní smyčku loop() čistou.

#include <Usb.h>
#include <hiduniversal.h>

// 1. Definice vlastní třídy odvozené od HIDReportParser
class K8055ReportParser : public HIDReportParser {
public:
    // Metoda Parse se zavolá automaticky s příchodem nového 8bajtového paketu
    virtual void Parse(USBHID *hid, bool is_ep_comp, uint8_t len, uint8_t *buf) override {
        // Ověření správné délky paketu (K8055 posílá 8 bytů)
        if (len < 8) return;

        // --- DEKÓDOVÁNÍ DATOVÉHO PAKETU ---
        // Bajt 0: Digitální vstupy DI1 až DI5 (bitová maska)
        uint8_t digitalInputs = buf[0];

        bool di1 = (digitalInputs & 0x01); // Bit 0 -> DI1
        bool di2 = (digitalInputs & 0x02); // Bit 1 -> DI2
        bool di3 = (digitalInputs & 0x04); // Bit 2 -> DI3
        bool di4 = (digitalInputs & 0x08); // Bit 3 -> DI4
        bool di5 = (digitalInputs & 0x10); // Bit 4 -> DI5

        // Bajt 1 a 2: Analogové vstupy ADC1 a ADC2 (0 až 255 -> 0V až 5V)
        uint8_t adc1 = buf[1];
        uint8_t adc2 = buf[2];

        // Bajt 3+4 a 5+6: 16bitové čítače pulzů (Little-Endian: LSB + MSB)
        uint16_t counter1 = buf[3] | (buf[4] << 8);
        uint16_t counter2 = buf[5] | (buf[6] << 8);

        // --- VÝSTUP DAT (Příklad zpracování) ---
        Serial.println(F("--- Data z K8055 ---"));
        Serial.print(F("Digitální vstupy (DI1-DI5): "));
        Serial.print(di1);
        Serial.print(di2);
        Serial.print(di3);
        Serial.print(di4);
        Serial.println(di5);

        Serial.print(F("ADC1: "));
        Serial.print(adc1);
        Serial.print(F(" | ADC2: "));
        Serial.println(adc2);

        Serial.print(F("Čítač 1: "));
        Serial.print(counter1);
        Serial.print(F(" | Čítač 2: "));
        Serial.println(counter2);
        Serial.println();
    }
};

// 2. Instanciace objektů
USB Usb;
HIDUniversal Hid(&Usb);
K8055ReportParser K8055Parser; // Instance našeho parseru

void setup() {
    Serial.begin(115200);
    Serial.println(F("Startuji USB Host Shield..."));

    if (Usb.Init() == -1) {
        Serial.println(F("Chyba: USB Host Shield neodpovídá!"));
        while (1);
    }

    // 3. Propojení HID rozhraní s naším parserem
    if (!Hid.SetReportParser(0, &K8055Parser)) {
        Serial.println(F("Nepodařilo se zaregistrovat Report Parser!"));
    }

    Serial.println(F("Připojte kartu Velleman K8055..."));
}

void loop() {
    // Spuštění obsluhy USB sběrnice.
    // Jakmile K8055 pošle nová data, Usb.Task() interně zavolá K8055Parser.Parse()

    Usb.Task();
}

V ukázkovém kódu vidíme tři zásadní úkoly, které musíme pro čtení dat z karty zvládnout:

1. Registrace přes SetReportParser(0, &K8055Parser): Sdělíte knihovně, že příchozí HID zprávy (Report ID 0) má předávat vámi vytvořenému objektu K8055Parser.
2. Asynchronní spouštění: V hlavní smyčce loop() stačí pouze volat Usb.Task(). Jakmile karta K8055 zaznamená změnu stisku tlačítka (vstupu) nebo pootočení potenciometru na analogovém vstupu, pošle zprávu po USB sběrnici.
3. Virtuální metoda Parse(): Poté, co data dorazí do čipu MAX3421E, knihovna vyvolá metodu Parse(), kde ukazatel buf přímo směřuje k nově přijatému poli 8 bajtů, které je třeba následně zpracovat.

Knihovna K8055.h

Pochopení principu nízkoúrovňových 8bajtových HID reportů a přímého předávání bajtů po USB sběrnici je jistě skvělý základ. Ukazuje, jak hardwarová komunikace funguje na té nejnižší úrovni. Psát ale kompletní projekt ručním skládáním bajtových polí a řešením časování přerušení by bylo zbytečně prkenné a poměrně frustrující. Proto jsme celou tuto nízkoúrovňovou komunikaci zabalili do přehledné a abstrahované knihovny K8055.h pro modul Arduino.

V referenční příručce knihovny naleznete:

1. Kompletní API katalog všech metod knihovny K8055.h s datovými typy a popisy parametrů jednotlivých metod.
2. Plně funkční diagnostický skript K8055_Demo.ino, který s využitím knihovny K8055.h krok za krokem otestuje všechny analogové i digitální obvody připojené karty K8055.

Po nainstalování knihovny K8055 do prostředí Arduino IDE (Projekt → Zahrnout knihovnu → Přidat .ZIP knihovnu…) můžeme začít knihovnu K8055 používat ve svých projektech. Pojďme si ukázat, jak práce s touto knihovnou zjednodušuje kód pro práci s deskou K8055 a jaké možnosti vývojáři přináší.

Jedna knihovna, dvě generace K8055

Během let společnost Velleman vydala dvě verze této populární USB karty – původní K8055 a její modernizovanou revizi K8055N. Knihovna rozlišuje mezi původním režimem karty K8055 (Legacy Mode) a novější revizí K8055N (New Mode), automaticky odesílá správné USB příkazy, přičemž respektuje, že některé pokročilé příkazy jsou dostupné pouze pro K8055N.

Knihovna dokáže při inicializaci automaticky rozeznat, s jakým hardwarem má tu čest, a podle toho přizpůsobí své chování:

• K8055 (Legacy Mode): Pracuje v režimu kompatibility se staršími kartami. Používá 16bitové čítače pulzů a bezpečný odstup mezi příkazy 20 ms, aby nedošlo k zahlcení pomalejšího mikrokontroléru na kartě.

Obrázek č. 3 – Základní verze USB desky Velleman K8055 (ovladatelná přes Legacy Mode)

• K8055N (New Mode): Detekuje novou revizi a okamžitě zpřístupní rozšířené funkce. Zrychluje komunikaci (odstup příkazů zkrátí na 10 ms) a zpřístupní:
  • 32bitové čítače pulzů na vstupech.
  • Hardwarové PWM výstupy s nastavitelnou frekvencí (setPWM()).
  • Přímé zpětné čtení stavu výstupů z hardwaru desky (readBackDigitalOut()).

Obrázek č. 4 – Základní verze USB desky Velleman K8055N (ovladatelná přes New Mode)

Tip:

Přestože nastavení podle jednotlivých typů desek probíhá v knihovně automaticky, lze se v kódu na režim připojené desky snadno dotázat metodou k8055.isNewMode() nebo si zkontrolovat přesné číslo revize přes k8055.cardVersion().

Porovnání nízkoúrovňový skript vs. elegantní knihovna K8055.h

Místo složitého nastavování třídy HIDReportParser a bitového posunu bajtů v poli stačí knihovnu inicializovat a volat srozumitelné metody, které se snaží kopírovat původní příkazovou sadu stanovenou původní DLL knihovnou společnosti Velleman. Následujcí kód nám ukazuje použití při zápisu i načtení vstupů a výstupů karty K8055

Příklad: Zapnutí výstupu a přečtení analogového vstupu

Nyní s knihovnou K8055.h:

#include <Usb.h>
#include <K8055.h>

USB Usb;
K8055 k8055(&Usb);

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

    // Jednoduchá registrace knihovny
    if (k8055.begin()) {
        Serial.println(F("K8055 knihovna pripravena."));
    }
}

void loop() {
    k8055.task(); // Automatická obsluha USB a rekonexe

    if (k8055.connected()) {
        // 1. Ovládání výstupů lidskou řečí
        k8055.setDigitalChannel(3);        // Zapne výstup OUT3
        k8055.outputAnalogChannel(1, 128); // DAC1 na 50 % (cca 2.5 V)

        // 2. Přímé čtení hodnot bez bitových operací
        uint8_t ad1 = k8055.readAnalogChannel(1);
        bool in1 = k8055.readDigitalChannel(1);

        if (in1) {
            Serial.print(F("Tlačítko stisknuto, napětí AD1: "));
            Serial.println(ad1);
        }
   }
}

Pokud potřebujeme monitorovat více vstupů současně, nemusíte posílat několik dotazů za sebou. Knihovna obsahuje vysoce efektivní metodu readAll(), která v jediném příkazu USB sběrnice načte kompletní stav karty:

uint8_t digInputs, analog1, analog2;
uint32_t counter1, counter2;

// Načte komplet digitální vstupy, oba analogové převodníky i oba impulzní čítače
k8055.readAll(digInputs, analog1, analog2, counter1, counter2);

Důležité doporučení pro praxi: Používejte Hardware Watchdog (WDT)

Protože komunikace probíhá přes poměrně složitý USB HID protokol na mikrokontroléru bez operačního systému, může v reálném prostředí (např. při silném elektromagnetickém rušení nebo kolísání napájecího napětí) dojít k náhodnému zaseknutí USB Host čipu MAX3421E nebo karty K8055. Knihovna sice obsahuje mechanismy pro automatické zotavení, přesto důrazně doporučujeme v produkčních projektech aktivovat hardwarový watchdog modulu Arduino:

#include <avr/wdt.h>

void setup() {

    // ... inicializace ...

    wdt_enable(WDTO_2S); // Aktivuje HW watchdog na 2 sekundy
}
 
void loop() {
    k8055.task();

    if (k8055.connected()) {

        // ... vaše logika ...

    }

    wdt_reset(); // Pravidelný reset watchdogu - pokud systém zamrzne, WDT Arduino restartuje
}

Přehled příkazů a rozhraní knihovny K8055.h

Pro přehlednost je níže připraven ucelený přehled hlavních metod a funkcí knihovny K8055.h. Knihovna převádí nízkoúrovňové USB HID reporty na přehledné C++ metody. Všechny příkazy jsou rozděleny do logických skupin:

Správa připojení

• begin() – Registruje HID parser v USB Host Shieldu.
• task() – Cyklická obsluha USB sběrnice a autodetekce (volá se v loop()).
• connected() – Vrací true, pokud je karta připojena a komunikuje.
• cardVersion() – Vrací revizi karty na základě dotazu (1 = K8055, 2 = K8055N).
• isNewMode() – Vrací revizi karty na základě uložené proměnné (false = K8055, true = K8055N).
• setCommandInterval – Mění minimální pauzu mezi odesílanými USB příkazy.
• resetConnection – Vynutí opětovnou detekci a inicializaci karty na USB sběrnici.

Digitální výstupy (OUT1–OUT8)

• setDigitalChannel(ch)/clearDigitalChannel(ch) – Zapne nebo vypne konkrétní výstup 1 až 8.
• writeAllDigital(maska) – Nastaví všech 8 výstupů najednou bitovou maskou.
• setAllDigital()/clearAllDigital() – Zapne nebo vypne všechny výstupy.
• readBackDigitalOut() – Přečte aktuální stav digitálních výstupů.

Analogové a PWM výstupy

• outputAnalogChannel(ch, val) – Nastaví hodnotu 0–255 (0–5 V) na DAC1 nebo DAC2 (nebo odpovídající střídy na PWM výstupu).
• outputAllAnalog(val1, val2) – Nastaví oba DAC výstupy naráz (nebo odpovídající PWM výstupy)
• clearAnalogChannel(ch) – Vynuluje zvolený analogový kanál.
• clearAllAnalog() – Vynuluje oba analogové výstupy
• setAnalogChannel(ch) – Nastaví zvolený analogový výstup na maximální hodnotu 255.
• setAllAnalog() – Nastaví oba analogové výstupy na maximální hodnotu 255.
• readBackAnalogOut(dt1, dt2) – Přečte aktuálně nastavené hodnoty analogových výstupů.
• setPWM(ch, střída, freq) – (Pouze K8055N) Nastaví na zvolený PWM výstup HW střídu a frekvenci PWM.

Vstupy a pulzní čítače

• readDigitalChannel(ch)/readAllDigital() – Přečte stav vstupů IN1 až IN5, buď jednotlivě, nebo najednou.
• readAnalogChannel(ch)/readAllAnalog(val1, val2) – Přečte hodnoty napětí na AD1 a AD2 (buď jednotlivě, nebo najednou).
• readCounter(cnt)/resetCounter(cnt) – Načte nebo vynuluje impulzní čítač na IN1/IN2.
• readCounter16 – Přečte spodních 16 bitů hodnoty čítače 1 nebo 2
• setCounterDebounceTime(cnt, ms) – Nastaví filtr zákmitů pro čítače v milisekundách.

Hromadné čtení

• readAll(digIn, an1, an2, cnt1, cnt2) – Okamžitě načte v jediném USB přístupu kompletní stav všech vstupů, analogů i čítačů karty.

Praktické rady a bastlířské zákeřnosti

Než se pustíte do řešení propojení desku K8055 a modulu Arduino, dejte si pozor na následující HW „špeky“:

1. Čínské klony USB Host Shieldu: Levné desky z e-shopů (AliExpress, eBay, Banggood) často nemají propájené napájecí můstky. Na desce shieldu zkontrolujte malé pájecí plošky označené 3.3V a 5V. Čip MAX3421E běží na 3,3 V, zatímco USB sběrnice a Arduino UNO potřebují 5 V. Pokud nejsou tyto napájecí propojky spojené cínem, shield nebude fungovat nebo neposkytne napájení pro USB kartu K8055.

Obrázek č. 5 – Pájecí plošky napájení na USB Host Shield

2. Zapojení výstupů OUT1–OUT8: Výstupy karty neposkytují napětí +5 V, jak by si někdo mohl myslet. Jsou realizovány přes výkonový budič ULN2803 s otevřeným kolektorem, což znamená, že výstupy při sepnutí spínají vůči zemi (GND). Zátěž (relé, LED apod.) připojujete tedy mezi externí kladné napětí (až do 50 V!) a svorku OUT, která při sepnutí zátěž uzemní.
3. Odrušení (EMI) a indukční zátěže: Spínání relé nebo motorů přes K8055 vytváří špičky v napájení, které mohou shodit čip MAX3421E na USB Shieldu. K cívkám relé vždy zapojujte antiparalelní ochranné diodu a Arduino napájejte ze samostatného kvalitního zdroje.
4. Kalibrace analogů: Pokud naměříte metodou readAnalogChannel() jiné hodnoty, než čekáte, zkontrolujte trimry ATT1/ATT2 a jumpery SK2/SK3 přímo na desce K8055. Tuto součástky nastavují útlum a napěťový rozsah analogových vstupů (viz návod desky K8055).

Souběžné použití USB Host a Ethernet Shieldu

Při stavbě pokročilejších projektů nás dost možná napadne myšlenka: Co kdybychom kartu K8055 připojili přes Arduino do místní počítačové sítě Ethernet a ovládali ji přes webové rozhraní či protokol MQTT?

Obrázek č. 6 – Arduino a Ethernet Shield

Zde však narazíme na dvě zásadní překážky – hardwarový konflikt a paměťové limity modulu Arduino.

Fyzická kolize na sběrnici SPI

Přímým zasunutím Ethernet Shieldu (s čipem W5100/W5500) a USB Host Shieldu na sebe tato sestava NEFUNGUJE! Oba shieldy sice sdílejí rozhraní SPI (Ethernet Shield si navíc rezervuje Pin 4 pro SD kartu), ale trvají na stejném adresovacím pinu Chip Select (CS/SS) – Pinu 10. Pokud shieldy zapojíte bez úprav, Arduino při komunikaci aktivuje obě periferie současně. Data na sběrnici se překryjí a komunikace okamžitě selže.

Bastlířské řešení kolize:

1. Přerušte pin 10: Na USB Host Shieldu nechme pin 10 nepropojený do spodní patice (např. jeho jemným ohnutím).
2. Přemostění na jiný pin: Připájíme drátovou spojku z pinu CS (ohnutý pin 10) USB Host Shieldu na jiný volný digitální pin Arduina (např. Pin 8).
3. Úprava v kódu: Při inicializaci knihovny pro USB Host Shield předáte nový CS pin (viz následující kód):
   
   // Definice USB Host Shieldu s přesměrovaným CS pinem na Pin 8
USB UsbH(8);

Paměť modulu Arduino UNO?

Na desce Arduino UNO (ATmega328P) se souběžné spuštění obou shieldů (Ethernet a USB Host) dostává na hranici technických možností:

• Flash paměť (Kód): USB Host Shield Library 2.0 si vezme cca 12–15 KB a Ethernet knihovna dalších 10–14 KB. Z celkových 31,5 KB Flash vám pro vlastní řídicí logiku zůstane doslova pár stovek bytů.
• SRAM paměť (Proměnné): USB knihovna alokuje pro buffery a USB deskriptory cca 500–700 B. Ethernet knihovna pro sockety a vyrovnávací paměti vyžaduje dalších cca 500–600 B. Samotné načtení knihoven si vezme přes 1,2–1,5 KB z dostupných 2 KB SRAM! Jakmile volná paměť klesne pod ∼300 bytů, hrozí přetečení zásobníku (stack overflow), což způsobuje náhodné zamrzání či restarty Arduina.

Jak z toho ven?

Pokud musíte zůstat u Arduina UNO, musíte jít cestou drastických úspor. Takže balit všechny textové řetězce do makra F(), ořezat knihovnu USB Host Shieldu v settings.h pouze na HID core a namísto HTTP webserveru zvolit pro síť lehký protokol UDP. Což je poněkud „strašidelné“ řešení.

Asi nejlepším řešením je přechod na Arduino Mega 2560, které nabízí 256 KB Flash (8× více než UNO) a 8 KB SRAM (4× více než UNO). Oba shieldy na desku Mega fyzicky pasují a tak získáváme dostatek výkonové rezervy i pro složitější síťové aplikace. Pochopitelně i zde je potřeba pamatovat na úpravu CS pinu jednoho ze shieldů.

Závěr: Druhá míza pro legendární hardware?

Starý hardware zkrátka nemusí vždy končit v kontejneru na elektroodpad – a dokonce ani v bastlířském šuplíku s označením: „Tohle ještě určitě k něčemu bude“. Propojení karty Velleman K8055 s Arduinem přes USB Host Shield sice ukazuje pravý nefalšovaný bastlířský přístup, ale někdy se zkrátka vyplatí vzít odladěný, odolný hardware, vyhodit náročné PC a vdechnout staré technice nový život v podobě autonomní a úsporné řídicí jednotky. A pochopitelně to vše bez nutnosti předělávat stávající silové rozvody, pájet nové svorkovnice nebo měnit metry kabeláže.

Pokud vám K8055 leží na stole (nebo ji právě vytahujete ze dna krabice v garáži), stačí stáhnout přiloženou knihovnu s hotovým ukázkovým skriptem a začít studovat přiloženou PDF příručku.

Až se vás doma někdo zeptá, proč už druhý víkend v kuse sedíte v dílně nad dvacet let starou deskou a spletí drátů, můžete s klidným svědomím tvrdit, že se nezabýváte zbytečností, ale provádíte vysoce odbornou ekologickou recyklaci a aktivně zachraňujete planetu před elektronickým odpadem. 😊

Přejeme hodně zdaru při bastlení s K8055 a modulem Arduino!