Numerikus adatok küldése egyik Arduino -ból a másikba: 16 lépés

2024 Szerző: John Day | [email protected]. Utoljára módosítva: 2024-01-30 09:40

Bevezetés

David Palmer, CDIO Tech. az Aston Egyetemen.

Szüksége volt valaha néhány szám átküldésére az egyik Arduino -ról a másikra? Ez az utasítás megmutatja, hogyan.

Könnyedén tesztelheti működését, ha egyszerűen beír egy számsort, amelyet el kell küldeni a Serial Monitor terminálra, és láthatja, hogy a számok visszatérnek a második Arduino -hoz csatlakoztatott soros monitoron. Akár Bluetooth -kapcsolatot is használhat.

Mit csinál

Két Arduino program (vázlatok az Arduino nyelven beszélve) fejlesztésre szorulnak, az egyik egy mesterprogram az Arduino soros monitort futtató gazdagéphez való csatlakozáshoz, az egyik pedig szolgaként működik, hogy megkapja a soros üzenetet a Mestertől, dekódolja és visszaküldi. A rabszolga opcionálisan képes megjeleníteni a számokat, amelyekkel foglalkozik, egy második IDE soros monitorán - ha használni szeretné ezt. Ez elősegítheti a dolgok működését, és segít abban, ha úgy dönt, hogy a saját igényeinek megfelelően módosítja a programokat.

Felszerelés

• 2 Arduino
• 2 USB kábel
• patch vezetékek (szükség szerint)
• 1 számítógép/laptop Arduino IDE -vel (ingyenesen letölthető az Arduino.cc webhelyről)

1. lépés: Beállítás - Először állítsa be a hardvert

Csatlakoztassa a 2 Arduinot a számítógép 2 USB -portjához.

Tipp: érdemes M és S (mester és rabszolga) címkével ellátni őket, hogy később ne keveredjenek zűrzavarba (ahogy az itt látható 2 fotó is mutatja).

2. lépés: Beállítás - Állítsa be a képernyőt

A legjobb az, ha úgy állítja be a képernyőt, hogy megvan

• az IDE betöltve a Master programmal a bal oldalon és
• hogy a jobboldali Rabszolgával.

Tartsa a Maser és Slave soros monitorokat bal és jobb oldalon is, ahogy az itt látható képernyőképen látható.

3. lépés: A fővég beállítása, majd csatlakozás - 1. rész

Amikor beállítja a Master End soros monitort két szám küldésére, akkor mindig a kezdő és a vég, elválasztó karaktereket és a vessző elválasztó karaktert kell használnia.

Most össze kell kapcsolnia a 2 Arduino -t soros kapcsolaton keresztül. Ez két patch vezetékkel történik.

Én zöldet és sárgát használtam

• Vegyük először a sárgát, ennek az egyik Arduino D6 -hoz, a másodikhoz pedig a D7 -hez kell csatlakoznia
• Aztán a zöld vezetéknél az ellenkezője: D7 az első és D6 a második Arduino.

Alternatív megoldásként, ha rendelkezésre áll valami, például egy pár Bluetooth -modul, például a HC -05, akkor ezek ugyanolyan hatást fognak kifejteni, mint a fenti vezetékek.

4. lépés: Állítsa be a fővégét, majd csatlakozzon egymáshoz - 2. rész

A Software Serial könyvtárat használjuk. További információk ezen a linken érhetők el:

Ezt bármelyik program 7. sorában láthatja. A digitális 7 -es és 6 -os csapokat TX -re és RX -re (küldés és fogadás) konfigurálja. Így jutnak el az adatok az Arduino mestertől a zöld vezetéken keresztül a Slave -be, és amikor a Slave program a második Arduino -ban befejezte munkáját, vissza a sárga vezetéken. Ugyanezen ábra alján (a Soros monitor ablakban) láthatja, hogy az általunk továbbított adatok sikeresen megkerülik az itt leírt ciklust, és visszatérnek a PC -hez, miközben az egész számok szépen elkülönülnek.

5. lépés: A vázlatok / programok áttekintése - A program felépítése

Elrendezés Mint minden Arduino vázlat esetében, három alapvető részből áll:

• A Nyilatkozatok
• A beállítás
• A fő hurok

Mint gyakran előfordul, itt egy 4. szakaszt használtunk, amely a „Funkciók” kiegészítés. Ha nem ismeri a funkciók használatát, akkor keresse meg az "Arduino -funkciók" Google -t, és olyan linkeket talál, mint a példa ezen a linken: www.tutorialspoint.com/arduino/arduino_functions…..

A füleket is használtuk a program kezelhetőbb blokkokra történő szétválasztására.

Az általunk használt három blokk az IDE ablakok fenti illusztrációinak tetején látható:

• simpleRxTx0330Master
• gyakori
• megjegyzi

Ezek valójában külön fájlok a program mappájában, amint ezt a Slave program fájljainak Windows Explorer nézetében láthatja.

Ennek nagyon jó oka van.

• A program felépítése közben rájöttünk, hogy a mester programjainak nagy része ugyanaz, mint a rabszolga számára.
• Végül minden közös részt behúztunk egy lapra, amelyet ezért "közösnek" neveztünk, majd minden alkalommal, amikor hibát hibáztunk (teszteltünk, és elégedettek voltunk vele, hogy működik), csak lemásoltuk és beillesztettük az egész lapot szemben a Mestertől a Slave -ig, vagy fordítva.
• A jegyzetek lapok szintén azonosak, mivel a kialakítás általános.

A függvények egyike sem hívható meg a setup -ból, mindegyik ciklusból, tehát a beállítás után, de a ciklus előtt hoztuk létre őket.

6. lépés: Tervezés felülről lefelé

Jó ötlet a vázlat megtervezése, kezdve annak meghatározásával, hogy mit szeretne csinálni.

Ha ez megvan, elkezdheti a vázlat elkészítését. Általában, ha van olyan részlet, amelyet még nem tudsz, hogyan kell megtenni, csak tedd függvénnyé, és hagyd későbbre a függvény létrehozását.

Ez követi a jó tervezési filozófiát, amelyet sok egyetemen tanítanak, CDIO -nak (ha még nem ismeri ezt, akkor google -olhat, és olyan webhelyeket találhat, amelyek magyarázzák ezt: https://www.cdio.org/s.) Ez alapvetően azt mondja: Ne kezdje el a tervezést, amíg nem világos a koncepció. Ne kezdje el a megvalósítást, amíg nem világos a tervezés. Ne várja el, hogy működésbe lép, amíg nem világos a megvalósítás. Először C, majd D, I és O. Minden későbbi szakaszban iterál (menjen vissza a ciklus (ok) körébe, tehát ha elégedett a kezdeti tervezési ciklusával, és ellenőrizze, hogy továbbra is megfelel -e a koncepciónak, és frissítse) a C -t, ha szükséges. És így tovább, így még akkor is, ha már a Működésbe került, menjen vissza a csúcsra, és nézze meg, hogyan néz ki most a C, majd a D és én, és készítsen és ellenőrizze az összeset A programozási vázlatoknál ez ugyanúgy működik, ha felülről lefelé tervez.

7. lépés: Koncepció és tervezés - 1. rész

A koncepció itt úgy néz ki, mint a „megjegyzések” lapon megadott vázlatos követelmények.”

A Design úgy nézhet ki, mint a ciklus korai változata, amely megegyezik a Jegyzetek lappal, és hasonlíthat az ábrán láthatóhoz

Nézze meg, hogyan szeretem kezdeni azzal, hogy a CTRL-C először másolja a megjegyzéseket a ciklus fejébe, majd kezdje el kitölteni az üres helyeket olyan parancsokkal, amelyek elvégzik ezeket a dolgokat.

Ez valójában lefordítja az OK -t, amint az a képernyő alján látható. Ez eléri a CDIO D szakaszától az I-ig, és ahogy fejlesztjük a kódot, jó ötlet folytatni ezt a D-I ciklust.

Most itt az ideje, hogy lemenjünk a következő szakaszba, ott van egy megjegyzés, amely azt mondja, hogy: // kapunk valamit a hardver USB -ről, majd továbbítjuk a szoftver soros csatornájára. Ezt a kódot azért írjuk, hogy ez megtörténjen - a 133-138. Sor itt sárga kiemelővel látható

8. lépés: Koncepció és tervezés - 2. rész

Az itt bemutatott két első két funkció a (recv () és a tran (), amelyek a hardverportról történő fogadást és a szoftverportra történő továbbítást végzik - ezért hívják őket a „hw” vagy „sw” paraméterekkel.

Rajtuk kívül hozzáadtunk egy tesztet egy newData nevű globális változóhoz. Ezt a zászlót a "void recv ();" függvényben fogjuk beállítani. Amikor üzenet érkezett, ez a változó hamisról igazra van megjelölve. Ezt úgy tesszük, hogy csak akkor továbbítunk üzenetet, ha a 134 -es sorban megkaptuk (flag == true). És miután továbbítottuk az üzenetünket, akkor ez a "munka kész", így a 137 -es sorban ismét töröljük a hamis értéket.

Ismét ellenőrizhetjük a fordítást (D -től I -ig), és ezúttal egy "nem deklarált" hibaüzenetet kapunk (látható). Ez azt jelenti, hogy nem deklaráltuk a recv (); funkció. Ezt később tervezzük megtenni, így egyelőre ahhoz, hogy tiszta fordítást kaphassunk, létre kell hoznunk egy próbabábu vagy helyőrző függvényt, ahogy az alább látható.

Ismét ellenőrizhetjük a fordítást (D -től I -ig), és ezúttal egy másik "nincs bejelentve" hibaüzenetet kapunk a tran () -ra; funkció. Ehhez hasonló csonk létrehozására van szükség. Ismét ellenőrizhetjük a fordítást (D -től I -ig), és ezúttal tökéletesen fogunk működni; eddig jó.

9. lépés: Fejezze be a fő hurkot: A) Fogadás USB -ről, B) Fogadás Slave Arduino -tól

Van egy utolsó rész, amelyet hozzáadtunk ennek a résznek a befejezéséhez, azaz néhány hibakeresési kódot.

Van egy másik utasítás a vázlatok hibakeresésében, amelyre hivatkozva megérthetjük, hogy mit tettünk itt és miért. Olvassa el az utasításokat "Az Arduino vázlatok építése és tesztelése, amíg működnek"

Tehát ezeket a hibakeresési sorokat [az ábrán látható 136-139] a fő ciklusban adjuk hozzá, és íme, tesztelheti őket a mester végén a hibakeresési változó igazításával és a fordítással (I), majd ha ha csatlakoztat egy Arduino -t, akkor feltöltheti, megnyithatja a soros monitort, és megnézheti, hogy az, ami visszajön a soros monitorba, az itt látható (látja a "DEBUG MODE" üzenetet?)

10. lépés: Az adatok fogadása és kezelése a Slave Arduino -ban

Slave Arduino fogadása

Adja hozzá a második csatorna szükséges kódját a fő hurokhoz, a szoftveres soros vevőhöz az ábrán látható módon - 149-155.

Látja, hogy a szerkezet lazán épül fel arra, amit fentebb írtunk a Mester esetre?

Azt is látni fogja, hogy fordító hibát kapunk, egy másik be nem jelentett függvényt - ezúttal parseData (); - tehát ehhez is csonkot kell készítenünk, mielőtt hibamentes tesztfordítást futtathatunk.

Az adatok kezelése a Slave Arduino -ban

Adja hozzá az Arduino számára szükséges fő hurokkódot, ha az Slave eszközként van konfigurálva az ábrán látható módon - 163–174. Sor. Látja, hogy szerkezete nagyon hasonlít az első csatorna szerkezetéhez?

És meg kell találnia, hogy ezúttal teljesen rendben van.

11. lépés: Írja be a Fogadás függvényt

A Fogadás funkciónak - void recv (char from) {} - két fő feladata van.

1 karakterlánc fogadásához az USB -csatornáról, és

2, hogy egyet kapjon az Arduino -Arduino csatornától.

Az elsőt azért kell használnunk, mert az Arduino beépített hardveres UART -ját használja, a másodikhoz pedig a szabványos Arduino Library -t: az UART szoftvert.

Amikor elkezdünk kódot hozzáadni egy függvényhez - hogy létrehozzunk egy funkciót, amely valamit csinál, nem csak csonkot -, akkor emlékeznünk kell arra, hogy el kell távolítanunk vagy megjegyzést kell fűznünk a helyettesített csonkhoz. Ellenkező esetben fordítási hibát kapunk: a 'void lrec (char)' újraértelmezése.

Próbálja meg elhárítani a hibát, majd próbálja meg megszüntetni a fenti módszerek bármelyikét.

Kezdje egy olyan funkcióval, amely hasonlít a 75-88.

Mostanra már tudja, hogy a kód birtokában ki kell próbálnia a fordítási műveletet. Olyan hibát kap, mint a korábban, a következő típusnál: függvénynév nincs megadva ebben a hatókörben. Kezdetben szükségünk lesz egy újabb csonkra, hogy le tudjuk fordítani ezt a hibát, ezért adjon hozzá egyet, mint korábban, és győződjön meg róla, hogy most hibátlanul kaphat fordítást.

Most nézzük meg a recv () függvényhez írt kódot.

Elég tiszta, láthatja az "if" feltétel használatát a fent említett függvény két részének előállításához.

Az „sw” és a „hw” részen belüli kód azonos alakú, és itt leírom.

A sorpárok közül az első minden esetben a while ciklus kezdete. Ha nem ismeri az időtartamokat, akkor az Arduino.cc/Reference oldalon kereshet magyarázatot és példákat. Itt várunk, amíg 'a' beépített 'Serial' függvény nem kapott karaktert, és mivel az newData változó ki van kapcsolva (azaz a newData == false feltétel igaz). Amint egy karakter - vagy több karakter - megérkezik, a „páros” átmegy a második sorba ebben a párban. Ekkor a recAstringChar (char); funkció az aktuális karakter kezelésére. Ez a sorpár akkor váltakozik, amíg (vagy addig), amíg a karakterek még beérkeznek. Ha mindezek befejeződtek, a közben az állapot véget ér, lehetővé téve az if vagy a következő szint végét, és lehetővé teszi a rec (char); funkció befejeződik. Így a teljes üzenet megérkezett.

12. lépés: Írja be a Fogadás alfunkciót - 1. rész

Most meg kell írnunk a recAstringChar (char) nevű függvényt;. Láthatja a megjegyzésből az 50. sorhoz itt a tetején, hogy a feladata két puffer frissítése a bejövő soros üzenet másolataival. [Kiderült, hogy mindezt működés közben próbáltam, hogy egy dolgot megtanultam, hogy két különböző pufferre van szükségem - vagy legalábbis ez volt a legegyszerűbb módja néhány probléma kiküszöbölésének, így ez egyfajta 2 pufferre volt szükség, így Most készítettem el őket.] Az egyik puffert hívtam: ReceiveData, a másikat pedig: ReceiveChars.

A pufferek globális változók, ezért modul szinten vannak deklarálva, lásd a közös lap 9. és 10. sorát. A függvényen belül más változók is szerepelnek, amelyek ezért helyi hatókörrel rendelkeznek- itt az 51-54. Ez nem az a hely, ahol megmagyarázzuk a globális és a helyiek közötti különbségeket, de erről bővebb információ található a https://www.arduino.cc/glossary/en/ címen, a Local and Global alatt.

Az itt látható https://www.arduino.cc/reference/en/#variables címen mindent megtudhat az adattípusokról és a típusmódosítókról: static, boolean, byte, const, char.

A fő programfolyamatot ebben a függvényben az if az 56 -os sorban és a megfelelő 74 -es sor szabályozza. Ez két forgatókönyvet foglal magában

a) [a 74. sortól kezdve], amikor a fogadott üzenet elkezdődik. Ez a startMarker észlelésekor történik - ezt a „<” karakterként határozták meg, ezért a vázlat tesztelésekor mindig a karakterrel kezdjük a karakterláncot. Ha ezt nem tesszük meg, akkor semmit sem fogunk feldolgozni fogadásként, mindezt figyelmen kívül hagyjuk, mintha hülyeségeket írnánk a "Soros monitor" billentyűzetre.

b) [56–73. sor], amely az összes többi karaktert fogadja, legyenek azok bármilyenek is, de csak az érvényes kezdés után foglalkoznak a karakterekkel (a „>” jelzés a fenti a) pont szerint érkezett.)

Ezekbe a sorokba (74 -től 78 -ig) azt a <kapott értéket helyezzük az egyik pufferbe (ReceiveData [0]), de a másikba nem. A puffermutatót (változó: char ndx) úgy állítjuk be, hogy a következő tartalék pufferhelyre mutasson (ReceiveData [1]) az ndx ++ sorban lévő növekmény utáni paranccsal (++);, és a folyamatban lévő zászlót igazra állítjuk.

A programfolyamatot a függvény ezen részében az if az 57. sorban, a másik pedig a 65. sorban szabályozza. Ez két forgatókönyvvel foglalkozik

a) [a 65. sortól kezdve], amikor a fogadott üzenet véget ért. Ez akkor fordul elő, amikor az endMarker -t észreveszik -> -ként definiálva, ezért amikor vázlatunkat teszteljük, mindig ezzel a karakterrel fejezzük be a karakterláncunkat. Az egyik dolog, ami akkor történik, amikor a végső karakter megérkezik, az, hogy a newData globális zászló (műszakilag változó) a függvény befejezésekor igaz lesz, így az alfunkciónkat hívó függvény (a hívó függvény: recv (char);) "tudja", hogy az érvényes új adatok hiánytalanul érkeztek.

b) [57–64. sor], amely az összes többi karaktert fogadja, legyenek azok bármilyenek. Csak szorgosan parkolja őket szépen sorban mindkét pufferben.

13. lépés: Írja be a Fogadás alfunkciót - 2. rész

Segíthet, ha példát mondhat arra, hogyan néz ki a két puffer, amikor betöltötték őket. Ha begépelnénk az enter billentyűt, akkor a pufferekben megjelennek a karakterek:

Tehát most láthatja, hogy van egy pufferünk, amely pontosan ugyanazok a karakterek, mint amit először beírtunk, és egy puffer, amely csak a két értéket és egy elválasztó vesszőt tartalmazza. Most már rendelkezünk néhány kóddal, amely képes fogadni a soros monitor billentyűzetén beírt karaktereket, áttérhetünk a CDIO I. fázisáról az O pontra, beírva néhány karakterláncot, és meglátva, mi történik. Töltse fel a kódot a Master Arduino -ba, nyissa meg a Soros monitort, és próbáljon meg beírni valami érvényeset, például az Enter billentyűt. Kap egy olyan visszhangot a Soros monitor képernyőn, mint az itt látható?

14. lépés: Írja be az átviteli és elemzési függvényeket

Először az átvitelért

Tehát most egy karakterláncot kaptunk, írhatjuk az átviteli függvényt: tran (char); csonkjának cseréjéhez. Ez lehetővé teszi számunkra, hogy egy karakterláncot küldjünk a Mestertől a Slave Arduino -nak, ezért győződjön meg arról, hogy mindkét eszköz csatlakoztatva van és csatlakoztatva van az új funkció teszteléséhez.

Adja meg ezt a funkciót a 117-133. Sorban látható módon. Amint felismeri, két részből áll, az egyiket az USB -csatornára (hardveres UART), a másikat pedig a másik Arduino -hoz (szoftveres UART.). -ingyenes, és azonnal feltöltheti a vázlatot, és megnézheti, mi történik. Ezúttal elküldöm. Megkapja a megjelenített eredményt?

A képernyőkép azért érdekes, mert a Fogadott karakterláncnak… úgy kell kinéznie, mint korábban, az Átvitt karakterláncnak pedig most. Ne feledje azonban, hogy az Integer konverzió nem működött. Még egy kicsit több kódot kell hozzáadni ahhoz, hogy ez működjön.

15. lépés: Írja le az átviteli és elemzési függvényeket

Aztán a Parse -nek

Ez egy kódrészlet, amely elemzi a kapott karakterláncot a numerikus parciális karakterláncok lekéréséhez, és egész számokká alakítja át azokat. Ez a void parseData (); a főhurok funkciója

Cserélje ki az elemzési csonkot a 98 - 113. sorokban látható kódra. Töltse fel, és nézzük meg, hogy a 2 egész értékkel kapcsolatos probléma megoldódott -e. Próbáljuk meg.

Igen, működik, amint az látható, a talált egész számok 49 és 98.

16. lépés: Befejezés

Ezek az adatok a PC -n keresztül a Master -en keresztül a slave -n és vissza a Master -en keresztül ismét a PC -hez mentek. Miután a közös verzió elkészült a Master és a slave végeken, és ha a hibakeresési mód most ki van kapcsolva, mindkét oldalon megfelelően láthatjuk az adatokat, amint az itt látható.