Bitek mindenhol, avagy okos tárgyak

A DIY közösség programozni tudó része az Arduino, a programozni kevésbé tudó része leginkább az ESP8266 és az újabb ESP32 WiFis fejlesztői lapokra alapozza okoskütyüit - legalábbis azok biztosan, akik olcsón és könnyen akarnak valami működőt építeni. Az ESP-használók rengeteg kész projektből meríthetnek ötleteket és rengeteg kész firmware segíthet működőképessé tenni elgondolásukat, mint például az ESPEasy, a Tasmota, ESPurna.

De mi a helyzet azokkal, akik valami okból ódzkodnak az egész vezeték nélküli témától?

Nos ők vehetnek kész megoldásokat, mint például a LAN controller 3.0 vagy a már korábban általam említett ArduinoEasy firmware és egy Arduino Mega segítségével építhetnek maguknak egy eszközt. Azt már itt tisztáznám, hogy ezzel a leírással nem a keményvonalas programozókat célzom meg, akik megírják az összes eszközükre külön a működtető programokat, hanem azoknak, akik hozzám hasonlóan az univerzális dolgokat preferálnák, egyszer feltöltik a programot, majd webes felületen keresztül beállítják, mi hogyan működjön benne.
Ahogy már az ArduinoEasy-ről szóló cikkben kitértem rá, az Arduino-k korlátozott sebessége és minimális erőforrásai (8kB memória) nem igazán teszik alkalmassá egy bonyolultabb sketch (program) stabil futtatására, ezért is kezdtem keresni alternatívát. Első és egyben legolcsóbb használhatónak tűnő jelöltem a "Maple Mini" néven futó STM32F103CBT6 hangzatos nevű központi vezérlővel szerelt fejlesztői lapka. Erről azt érdemes tudni, hogy igazság szerint már pár éve nem gyártja a LeafLabs, ellenben az azonos tervek alapján készült, azonos funkcionalitást biztosító klónjait ontják magukból a kínai gyárak. [Forrás]

Maple Mini

Ez talán az egyik legnépszerűbb STM32 lapka, az F103-as család közepes tagja, 128kB tárhellyel (ekkora program fér rá maximum) és 20kB memóriával. Tesztjeim alapján ez a memóriamennyiség már elégséges az ArduinoEasy stabil futtatásához, a tárhely viszont éppen csak sikítva elegendő, fordítás előtt több lehetőséget ki kell kapcsolnunk a kódban, sajnos többek között az MQTT támogatást is, ami önmagában 50kB körüli kódméretet igényelne, az egész végeredmény pedig 180kB körüli.. látható tehát, hogy a 128kB eléréshez kicsit ügyeskednünk kell. (Aki ennek ellenére mégis a kisebb testvér C8T6-ot vásárolja be magának 64kB tárhellyel, az ArduinoEasy nem fog rámenni, már kezdheti is izzítani a klaviatúrát, hogy megírja magának a működtető programot.)
Azt sem árt tudni, hogy a miniUSB csatlakozón keresztül fel tudjuk tölteni rá a programunkat, viszont ennek kezelését egy, a flash tárhely elején levő, úgynevezett "bootloader" intézi, ami gyárilag vele érkezik és 20kB a mérete, ezzel számunkra 108kB-ot hagyva.. ezt lehetőségünk van lecserélni egy újabb és kisebb bootloader 2.0-ra, ami már csak 8kB méretű, és így 120kB tárhely marad a teljes programunknak. A harmadik lehetőség, hogy az RX-TX lábaira egy külső USB-s programozót kötünk, és a teljes 128kB-ot használjuk a saját programunk tárolására, a bootloadert ezzel törölve, és természetesen az USB csatlakozót ettől kezdve nem tudjuk használni programfeltöltésre.
Megjegyzés: a dedikált USB csatlakozás közvetlenül az STM32-ről van kivezetve, ezért nincs benne külön UART chip, mint az ESP fejlesztői lapokon.

A Maple Mini-hez 1000 Ft / 3 dollár körüli áron lehet hozzájutni, ami nem áll messze az ESP8266 árkategóriájától, viszont külön kell megvásárolni hozzá a LAN csatlakozást biztosító W5500-at, amiért még egyszer ennyit (1000 Ft / 3 dollár) le kell szurkolnunk.

W5500 lap

Tehát cirka 2000 Ft-ból tudunk hasonló célt ellátó vezetékes eszközt gyártani, mint amire a 800Ft-os vezeték nélküli ESP8266 D1 Mini önmagában alapból alkalmas.

A lábkiosztás az alábbi:

Ha visszapillantunk az előző képre, a lapra szitázva a lábak sorszámai láthatóak, ezen pedig a lábak valódi megnevezései. Pl a MOSI1/PA7 az első képen a 4-es számú láb, az SPISEL1/PA4 pedig a 7-es számú stb..
A chip alapvetően 3.3V-os logikával dolgozik, ám bizonyos lábai boldogulnak az 5V-os bemeneti jelszintekkel is - a rajzon tömör fekete pöttyökkel jelzik, melyek ezek. A PWM kimeneti (16bites) funkcióra és az Analóg bemeneteket (12bites) fogadni képes lábakat is megjelölték - ezekből jóval több van, mint az ESP8266 esetében volt. Tápellátása történhet normál miniUSB kábelen (5V DC) keresztül, vagy a VIN lábat használva, ez utóbbi esetben 3-12V DC tápellátás szükséges.

A program lefordítása és feltöltése

A fordításhoz és feltöltéshez az Arduino IDE-re lesz szükség, egyúttal az STM32-höz szükséges könyvtárakat is fel kell telepítenünk. Több, egymástól eltérő Arduino hardvertámogató-réteg (Core) is létezik STM32-höz:

• az eredeti "régi", ami kiforrottabb, viszont nem nagyon frissül mostanában az a Roger Clark féle:
  https://github.com/rogerclarkmelbourne/arduino_stm32
• az új "hivatalos", ami gyakran frissül, viszont az F103 családon belül a nagyobb tárhellyel szerelt változatokat nem támogatja alapból:
  https://github.com/stm32duino/Arduino_Core_STM32

Mivel szereztem be RCT6 és RET6 modulokat is, amelyeket a hivatalos Core még nem támogat, ezért egyelőre a Roger Clark féle használatára írtam át az ArduinoEasy szükséges részeit a beüzemeléshez. Előre bocsájtom, hogy nem használok Windowst, és bár az alábbiakhoz hasonlóan meg lehet oldani azon is, minden alábbi lépés Ubuntu Linux alatt tesztelve.

1. Töltsük le innen az Arduino IDE-t a gépünkre, csomagoljuk ki:
   https://www.arduino.cc/en/Main/Software
2. Indítsuk el az Arduino IDE-t
3. Az Eszközök->Alaplap->Alaplap-kezelőben válasszuk ki és telepítsük az "Arduino SAM boards (Cortex-M3)" nevű alaplapot
4. Töltsük le a https://github.com/rogerclarkmelbourne/Arduino_STM32/archive/master.zip címről az STM32 alaplapot
5. Tömörítsük ki a letöltött ZIP állományt a ~/Arduino/hardware/Arduino_STM32 mappába (hozzuk létre, ha nincs hardware mappa itt)
6. Futtassuk root joggal vagy sudo-val az ebben található tools/linux64/install.sh parancsfájlt, ami beállítja az udev szabályokat (ha esetleg nem futtatható az állomány, akkor a chmod a+x install.sh segít ezen, sőt ha már itt vagyunk a tools/linux és a tools/linux64 mappában levő fájlok többségének érdemes futtatható jogot beállítani)
7. Az Arduino IDE újraindítását követően már látni fogja ezt az új alaplapot is, az Eszközök->Alaplap alatt:

Miután sikerült az Arduino IDE-t és az STM32 Core fájlokat letöltenünk, lépjünk be egy szimpatikus könyvtárba,  és töltsük le a patchelt ArduinoEasy forrását git-el:

vagy szimplán töltsük le ZIP-ként:

és tömörítsük ki.

A parancs nyomán létrejött ArduinoEasy mappán belül található lib mappából a Base64-et másoljuk át kompletten a ~/Arduino/libraries/ alá, hogy az Arduino IDE megtalálja fordításkor, kivéve ha nem akarjuk használni a Domoticz HTTP protokoll jelszóval hitelesítő részét, mert akkor nemes egyszerűséggel inkább módosítsuk az "ArduinoEasy-Globals.h" állomány tartalmát, és az ott levő #define FEATURE_BASE64 után levő true feltételt írjuk át false -ra, és ekkor nem fogja keresni a Base64 könyvtárat. (de erről még lesz pár szó egy bekezdés múlva)

Az Arduino IDE-nek van egy - számomra - érdekes tulajdonsága, miszerint olyan nevű mappában kell lennie a (fő) .INO fájlnak, mint maga a fájlnév. Mi a teendő? Az ArduinoEasy-n belül található src mappa tartalmát átmásoljuk pl az ~/Arduino/projects alá, hogy kéznél legyen, és ilyen formában a ~/Arduino/projects/ArduinoEasy mappa alá kerül közvetlenül minden .ino állomány, az ArduinoEasy.ino is, amit most már meg tudunk nyitni az Arduino IDE-n belül, és elvileg nem fog sopánkodni...
(Nyilván mindenki rájött eddigre, aki nem tudta volna, hogy az INO kiterjesztésű fájlok tartalmazzák az Arduino számára lefordítható C forráskódot, mellette a .h fájlokban láthatóak pedig a definíciók)

FORDÍTÁS ÉS KÖZVETLEN ELŐKÉSZÜLETEI

Ha sikerült megnyitnunk a fentiek után az ArduinoEasy.ino -t, akkor keressük ki a fülek közül az Arduino-Globals.h-t:

Ezen a ponton komolyan el kell gondolkoznunk, hogy mire akarjuk majd használni a kütyünket, hány eszközt akarunk implementálni benne és milyen típusúakat, mivel ki kell választanunk és csak azokat és annyit belefordítani, amire szükség lesz - mivel nem vagyunk bővében a helynek.

Első és legfontosabb döntésünk, hogy mennyi tárhellyel tudunk gazdálkodni. A gyárilag érkező bootloader-t használva igazából nem hiszem, hogy le lehet csontozni az ArduinoEasy-t hogy 108k-ba minden beleférjen.. ha nem használunk bootloader-t, akkor az egész 128k-val (131072 byte) gazdálkodhatunk, de most tételezzük fel, hogy hozzám hasonlóan a bootloader 2.0 használata mellett döntünk, ami lehetővé teszi a későbbi USB kábelen keresztüli könnyű feltöltést és 120kB tárhely használatát teszi lehetővé. (128220 byte)

A következő eldöntendő dolog, hogy megelégszünk 4 TASK használatával, vagy 8 TASK-ra is szükségünk lehet? TASK minden felvett eszköz az ESPEasy terminológiában, ami egyébként a webes felületen egy kattintással felvehető eszközt jelent. (ESPEasy ismerete előny...) 4 TASK esetén 4kB méretű lesz a szükséges adatpartíció, 8 TASK esetén 6kB, vagyis a programkód számára felhasználható hely 118784 byte vagy 116736 byte ezekben az esetekben, tőlünk függően. Ezt a döntésünket a #define TASKS_MAX segítségével állíthatjuk be.

A #define sorokról annyit kell tudni első körben, hogy két főbb fajtája van, az egyik esetben az a lényeg, hogy egy adott változó definiálva van-e vagy nincs, ebben az esetben úgy állíthatjuk a beállítást, hogy két darab per jelet írva elé kikommenteljük // ez esetben ez a feltétel megszűnik létezni, vagy töröljük a komment jeleket, és a fordító figyelembe veszi, hogy ezt a definíciót szeretnénk használni.
A másik fajtája, ami után van egy logikai/szám/szöveges érték, amit a fordító kiértékel fordítás soron, és attól függően illeszt be bizonyos kódrészeket.

Amennyiben a DEFAULT_USE_STATIC_IP értéke true, akkor az alatta levő DEFAULT_IP-t fogja használni az eszköz a hálózaton, ha false az értéke vagy 0-val írjuk tele az IP cím helyét, akkor DHCP-n fog magának IP címet kérni.

Az alábbi beállításokkal sikerült 115960 byte méretű kódot fordítanom a Maple Mini alaplapra, boatloader 2.0 beállítással, 8 TASK-ra. (de több jó megoldás lehet, mindenki olyat legóz magának össze, amire szüksége van)

A pluginek egyébként szinte azonosak, mint az ESPEasy-ben használtak, így ott szerzett gyakorlatunkat kamatoztathatjuk ennél a fordításnál. :)
A fenti konfig egy W5500 használatát feltételezi, engedélyezi az UDP-t használó részek - DHCP, NTP, ESPEasy P2P - használatát, a Domoticz HTTP kontrollert a gpio, pwm, tone, rtttl parancsokat, az analóg plugint, a DHT22-t a SysInfo és Dummy pluginokat fordítja még bele a kész binárisba.

Hogy mekkora méretet sikerült elérnünk azt a Vázlat menü-> Ellenőriz/Fordít pontjával deríthető ki, amit mindenféle kockázat nélkül bármikor elvégezhetünk, ekkor még nem kell az eszközt csatlakoztatnunk, nem történik feltöltés, csak lefordítja a kódot és kiírja a méretét.

FIGYELEM!
Amennyiben a kódméret nagyobb, mint az általam fentebb írtak és mégis feltöltjük az eszközre, akkor a program vége felül lesz írva a beállításokkal, ami nem kívánt mellékhatásokkal, lefagyással, stb fog járni, amiért semmilyen formában felelősséget vállalni nem tudok! Ha szűk a rendelkezésre álló kapacitás, nagyobb flash tárhellyel rendelkező chipbe kell beruházni.. (erről is készül majd cikk a későbbiekben)

FELTÖLTÉS

Amennyiben sikerült megfelelő méretű kódot generálnunk, lépjünk is tovább, a feltöltés témakörére.

Ha frissen érkezett MapleMini lapunkat miniUSB kábellel a Linuxos PC-nkre csatlakoztatjuk a dmesg | tail parancs az alábbihoz hasonlót fog mutatni jó esetben:

Ez azt mutatja, hogy a gyári 20kB méretű bootloader a helyén van, válaszol és már akár tölthetnénk is fel az Arduino IDE Upload gombjára kattintva bármi olyan kódot, ami 108k vagy kisebb... de mivel ez nekem pl kevéske, és szerintem másnak is annak bizonyul, térjünk át arra a kérdésre, hogyan fogunk ezen javítani. Megjegyzés: ha erre a sima bootloader-rel rendelkező chipre próbáljuk feltölteni a bootloader2.0 módban a programunkat, a nélkül, hogy feltöltenénk magát a bootloader2.0-t előbb, csúnya meglepetésben lesz részünk!

A megoldás, egy külső soros-USB csatoló, például a már ESP8266-oknál sikerrel használt CP2102 is lehet, amit az alábbi módon kell a Maple Mini-re kötni:

Mit is látunk?

Az RX-TX lábak keresztbekötésén túl a tápellátást kell bekötnünk, valamint a BOOT0 lábat HIGH, a BOOT1-et pedig LOW szintre kell húzni, ezzel jelezve, hogy most soros programfeltöltő módba léptünk.

Ha az STM32 Core-t a fentebb írt helyre csomagoltuk ki, akkor az alábbi mappában megtalálhatjuk az st32flash alkalmazást, aminek segítségével a soros feltöltés elvégezhető:

A fenti bekötés után a Linuxos PC USB-jére történő csatlakoztatását követően az alábbihoz hasonlót kell látnunk a dmesg | tail parancsra:

Ami azt jelenti, hogy a /dev/ttyUSB0 címen tudunk kommunikálni az eszközzel, az alábbi paranccsal lekérhetjük a Maple paramétereit:

Ha a bekötés helyes volt, a válasznak ilyesminek kell lennie:

Ebből két fontos dolgot tudtunk meg: 1-helyesen végeztük el a bekötést, 2-az eszközön 128KiB flash tárhely áll rendelkezésre, ahogy vártuk. Ha nem kaptunk választ, nyomozhatjuk az okát, ha igen, akkor folytassuk, töltsük le a bootloader2.0-át:

Ha letöltöttük és meggyőződtünk róla, hogy nem egy HTML oldalt vagy hibaüzenetet sikerült letöltenünk, hanem egy 7124 bájt méretű bináris állományt, akkor azt az alábbi paranccsal tölthetjük fel:

És ezzel sikerült bootloader2.0-val ellátnunk MapleMini-nket. Ezt az eljárást pontosan egyszer kell elvégeznünk, a továbbiakban az alábbiak szerint USB kábelen direktben tudunk majd programkódot feltölteni! (a továbbiakban az USB-soros átalakítóra nincs szükség, leköthetjük és eltehetjük)
Ez után 120KB helyet használhatunk USB csatlakozáson keresztül történő feltöltéssel DFU-UTIL vagy az Arduino IDE-vel, kiválasztjuk a megfelelő Bootloader version-t, majd a Port-nál a Maple Mini-t:

Majd a Feltöltés gombra kattintva (jobbra mutató nyíl) az Arduino IDE megkísérli a kiválasztott portra a lefordított binárist átküldeni:

Ilyenkor általában újrafordít mindent, és ha közben a MapleMini nem válaszolna sokáig, nyomjuk meg a rajta levő RESET gombot, ekkor elkezd villogni, és a fentihez hasonló üzenetek mellett az Arduino feltölti rá a kódot. Ha elsőre nem megy, ne legyünk restek újrapróbálni, nem mindig sikerül nekem sem elsőre, jól kell időzíteni a Reset gomb megnyomását..

A soros csatlakozásra ugyebár már nem lesz szükség, ezért azt már régen lekötöttük, hiszen ezentúl USB-n keresztül tudjuk frissíteni a programot, a W5500 LAN modult pedig az alábbi bekötés szerint tudjuk illeszteni:

Ha mindent jól csináltunk, akkor a fenti kódfeltöltés és a LAN csatlakozás bekötése után az eszközünket elérhetjük a DEFAULT_IP részben megadott, alapértelmezetten 192.168.0.50 IP címen egy böngészőből.

Elsőre talán nehéznek tűnik a folyamat, de ha belegondolunk közel sem annyira, mintha az egész programot nekünk kellene megírnunk, és még ezeket a lépéseket is megcsinálni... Másodjára könnyebb lesz.