Stuur numeriese data van een Arduino na 'n ander: 16 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:24

Inleiding

deur David Palmer, CDIO Tech. aan die Universiteit van Aston.

Moes u ooit 'n paar nommers van die een Arduino na die ander stuur? Hierdie instruksie wys hoe.

U kan maklik toets of dit werk deur eenvoudig 'n string getalle in te tik wat u by die Serial Monitor -terminale moet stuur, en sien hoe die nommers terugkom by 'n tweede seriële monitor wat gekoppel is aan die tweede Arduino. U kan selfs 'n Bluetooth -skakel gebruik.

Wat dit doen

Twee Arduino -programme (sketse in Arduino praat) moet ontwikkel word, een 'n Master -program om aan te sluit op die gasheerrekenaar met die Arduino Serial Monitor, een om op te tree as 'n slaaf om die reeksboodskap van die meester te ontvang, dit te dekodeer en terug te stuur. Die slaaf kan ook die getalle waarmee hy te doen het, op 'n tweede IDE se seriële monitor vertoon - ingeval u dit wil gebruik. Dit kan in die eerste plek help om dinge aan die gang te kry, en dit kan u help as u besluit om die programme aan u eie vereistes te verander.

Toerusting

• 2 Arduino's
• 2 USB -kabels
• lasdrade (soos benodig)
• 1 rekenaar/skootrekenaar gelaai met Arduino IDE (beskikbaar as gratis aflaai vanaf die Arduino.cc -webwerf)

Stap 1: Opstel - Stel eers u hardeware op

Koppel die 2 Arduinos aan op 2 USB -poorte op u rekenaar.

Wenk, dit is 'n goeie idee om hulle as M en S (meester en slaaf) te benoem, sodat u nie later in 'n warboel beland nie (soos op die 2 foto's hier getoon.)

Stap 2: Opstel - Stel u skerm in

Die beste ding is om u skerm so op te stel dat u dit het

• die IDE gelaai met die Master -program aan die linkerkant en
• dit met die Slaaf aan die regterkant.

Hou die seriemonitors vir Maser en Slave ook links en regs, soos aangedui op die skermkiekie hier.

Stap 3: Stel die Master End op, en skakel dan saam - Deel 1

As u u Master End Serial Monitor opstel om twee nommers te stuur, moet u altyd die begin- en einde -skeidingstekens en die komma -skeidingskarakter gebruik soos u hier sien.

U moet nou die 2 Arduino's met mekaar verbind. Dit word gedoen met twee lasdrade.

Ek het groen en geel gebruik

• Neem die geel eerste, dit moet in D6 in een Arduino en D7 in die tweede een aansluit
• Dan die teenoorgestelde vir die groen draad, D7 op die eerste en D6 op die tweede Arduino.

Alternatiewelik, as u iets beskikbaar het, soos 'n paar Bluetooth -modules - soos HC -05's - sal dit ook werk om presies dieselfde effek as die drade hierbo te gee.

Stap 4: Stel die Master End op, en skakel dan saam - Deel 2

Ons maak gebruik van die Software Serial -biblioteek. Verdere inligting is beskikbaar met hierdie skakel

U kan die uitroep op reël 7 van enige van die programme sien. Dit stel penne 7 en 6 in as TX en RX (stuur en ontvang). Dit is hoe die data uit die Master Arduino deur die groen draad na die Slave sal beweeg, en as die Slave -program in die tweede Arduino sy werk voltooi het, terug deur die geel draad. Onderaan dieselfde illustrasie (in die Serial Monitor -venster) kan u sien dat die data wat ons oorgedra het, suksesvol om die lus gegaan het wat hier beskryf word, en terugkom na die rekenaar toe die heelgetalle mooi uitmekaar was.

Stap 5: Oorsig van die sketse / programme - struktuur van die program

Uitleg Soos in alle Arduino -sketse is daar drie basiese dele:

• Die verklarings
• Die opstelling
• Die belangrikste lus

Soos gereeld voorkom, het ons hier gebruik gemaak van 'n 4de afdeling wat die toevoeging van 'Funksies' is. As u nie vertroud is met die gebruik van funksies nie, kan u 'Arduino -funksies' na Google soek, en u vind verduidelikingswebwerwe soos die voorbeeld in hierdie skakel: www.tutorialspoint.com/arduino/arduino_functions ….

Ons het ook van oortjies gebruik gemaak om die program in meer hanteerbare blokke te skei.

Die drie blokke wat ons gebruik het, kan bo -aan elke illustrasie van die IDE -vensters hierbo gesien word:

• simpleRxTx0330Master
• algemene
• notas

Dit is eintlik aparte lêers in die gids van die program, soos u kan sien in hierdie Windows Explorer -aansig van die lêers van die Slave -program.

Daar is 'n baie goeie rede waarom ons dit gedoen het.

• Toe ons die program opbou, het ons besef dat die meeste programme vir die Meester dieselfde was as vir die Slaaf.
• Uiteindelik trek ons die algemene dele in 'n oortjie, wat ons dus 'algemeen' noem, en elke keer as ons 'n deel ontfout het (dit getoets en tevrede was dat dit goed werk) het ons die hele oortjie net gekopieer en geplak oorkant Meester tot Slaaf, of andersom.
• Die note -oortjies is ook toevallig identies, aangesien die ontwerp algemeen is.

Nie een van die funksies word vanaf die opstelling genoem nie, hulle word almal uit die lus genoem, daarom het ons dit na die opstelling, maar voor die lus, geskep.

Stap 6: Ontwerp van bo na onder

Dit is 'n goeie idee om u skets te ontwerp, begin met 'n definisie van wat u wil doen.

Sodra u dit het, kan u die skets begin doen met die dinge. Oor die algemeen, as daar 'n detail is wat u nog nie weet hoe u dit moet doen nie, maak dit net 'n funksie en laat die funksie tot later gebeur.

Dit volg op die goeie ontwerpfilosofie, wat in baie universiteite onderrig word, CDIO genoem (as u hierdie een nog nie ken nie, kan u dit Google, en webwerwe vind om dit te verduidelik soos: https://www.cdio.org/s.) Dit sê basies: Moenie die ontwerp begin voordat die konsep duidelik is nie. Begin nie met die implementering voordat u die ontwerp duidelik het nie. Moenie verwag dat dit sal werk voordat u die implementering duidelik het nie. C eers, dan D, I en O. In elke daaropvolgende fase herhaal u dit (gaan terug om die lus), dus sodra u tevrede is met u aanvanklike ontwerplus, kyk of dit steeds aan die konsep voldoen en werk op die C as dit nodig is. En so aan, selfs as u by die operasie is, gaan u heeltemal terug na die top, en kyk weer hoe die C nou lyk, dan die D en ek, en maak en kyk alles Met programmeringssketse werk dit presies dieselfde as u van bo af ontwerp.

Stap 7: Konsep en ontwerp - Deel 1

Die konsep lyk hier soos die uiteensettingvereistes wat op die blad 'notas' vermeld word. '

Die ontwerp kan lyk soos 'n vroeë weergawe van die lus, wat pas by die notablad en kan lyk soos u in hierdie figuur sien

Kyk hoe ek daarvan hou om eers te begin met die CTRL-C om die opmerkings eers in die kop van die lus te kopieer, en dan die spasies in te vul met opdragte wat die dinge kan doen.

Dit stel eintlik OK saam, soos u onderaan die skerm in die figuur kan sien. Dit strek van CDIO-stadium D tot ek, en terwyl ons die kode ontwikkel, is dit 'n goeie idee om deur te gaan met hierdie D-I-lus.

Dit is nou tyd om na die volgende fase te gaan; daar is 'n opmerking daar wat sê dat ons: // iets van die hardeware -USB sal ontvang, dan stuur ons dit na die sagtewarekanaal. Ons skryf hierdie kode om dit te laat gebeur - reëls 133 tot 138 word hier in geel markeerstift getoon

Stap 8: Konsep en ontwerp - Deel 2

Die twee eerste twee funksies wat ons hier bekendstel, is (recv () en tran () om die ontvangs van die hardeware -poort en die oordrag na die sagteware -poort te ontvang - daarom noem ons dit met die 'hw' of 'sw' parameters wat getoon word.

Benewens hulle, het ons ook 'n toets bygevoeg oor 'n globale veranderlike genaamd newData. Dit is 'n vlag wat ons binne die "void recv ();" - funksie sal plaas. As 'n boodskap ontvang is, word hierdie veranderlike van onwaar na waar gemerk. Ons doen dit sodat ons slegs 'n boodskap kan oordra as dit in reël 134 ontvang is (vlag == waar). En sodra ons ons boodskap oorgedra het, is dit 'klaar', sodat ons die vlag weer in reël 137 weer vals maak.

Weereens kan ons die kompilering (D tot I) nagaan, en hierdie keer het ons 'n 'nie -verklaarde' foutboodskap (getoon). Dit vertel ons dat ons nie die recv () verklaar het nie; funksie. Ons is van plan om dit later te doen, sodat ons nou eers 'n skoon kompilasie moet kry om 'n dummy- of plekhouerfunksie te skep, soos hieronder aangedui.

Weereens kan ons die kompilering (D tot I) nagaan, en hierdie keer het ons nog 'n 'nie -verklaarde' foutboodskap vir die tran (); funksie. Dit benodig 'n soortgelyke stomp skep. Weereens kan ons die kompilering (D tot I) nagaan, en hierdie keer sal ons vind dat dit perfek werk; so ver so goed.

Stap 9: Voltooi die hooflus: A) Ontvang vanaf USB, B) Ontvang van slaaf Arduino

Daar is 'n laaste stuk wat ons bygevoeg het om hierdie deel af te handel, naamlik om 'n foutopsporingskode by te voeg.

Daar is nog 'n instruksie oor ontfoutingsketse waarna verwys kan word om te verstaan wat ons hier gedoen het en waarom. Verwys na die instruksies "Hoe om Arduino -sketse te bou en te toets totdat dit werk"

Hierdie ontfoutingsreëls [getoon 136-139] word vervolgens in die hooflus bygevoeg, en kyk, u kan dit in die Master-einde toets deur die ontfoutingsveranderlike waar te maak en (I) saam te stel, en as as u 'n Arduino aansluit, kan u dit oplaai, die seriële monitor oopmaak en kyk of dit wat in die seriële monitor terugkom, is soos hier getoon (sien u dat die boodskap "DEBUG MODE" bygevoeg is?)

Stap 10: Ontvang en hanteer die data in die Slave Arduino

Ontvangs van slaaf Arduino

Voeg die nodige kode vir die tweede kanaal by die hooflus, die seriële ontvanger van die sagteware, soos getoon - reëls 149 tot 155.

Kan u sien dat die struktuur losweg gebaseer is op wat ons hierbo vir die Master -saak geskryf het?

U sal ook sien dat ons 'n samestellerfout kry, 'n ander onverklaarde funksie - hierdie keer parseData (); - daarom moet ons ook hiervoor 'n stomp maak voordat ons 'n foutvrye toetsopstel kan uitvoer.

Die hantering van die data in die Slave Arduino

Voeg die hoofluskode wat nodig is vir die Arduino by as dit as 'n slawe -toestel opgestel is, soos getoon - reëls 163 tot 174. Kan u sien dat die struktuur daarvan baie ooreenstem met die van die eerste kanaal?

En u moet hierdie keer vind dat dit absoluut goed is.

Stap 11: Skryf die Ontvangsfunksie

Die Ontvangsfunksie - leegte recv (char van) {} - het twee hooftake.

1 om 'n string karakters van die USB -kanaal te ontvang, en

2 om een van die Arduino- tot Arduino -kanaal te ontvang.

Vir die eerste moet ons dit gebruik, want dit gebruik die ingeboude hardeware UART van die Arduino, en die tweede met die standaard Arduino -biblioteek: sagteware UART.

As ons kode begin byvoeg by 'n funksie - om 'n funksie te skep wat iets doen, in plaas van net 'n stomp - moet ons onthou om die stomp wat dit vervang, te verwyder of kommentaar te lewer. Anders kry ons 'n opstelfout: herdefinisie van 'void lrec (char)'.

Probeer om die fout op te spoor, en probeer dan een van die bogenoemde maniere om daarvan ontslae te raak.

Begin met 'n funksie wat lyk soos die van reëls 75 tot 88 in geel.

U weet nou dat u die kompilasiebewerking moet probeer met kode. Dit gee u 'n fout, soos dié wat ons vroeër gehad het, van die tipe: funksienaam wat nie in hierdie omvang verklaar word nie. Ons sal aanvanklik nog 'n stomp nodig hê om ons by hierdie fout te laat saamstel, so voeg een in soos voorheen, en maak seker dat u nou 'n samestelling sonder foute kan kry.

Kyk nou na die kode wat ons vir die recv () -funksie geskryf het.

Dit is redelik skoon; u kan die 'as' -voorwaarde gebruik om die twee dele van die funksie waarna hierbo verwys word, te vervaardig.

Die kode in die 'sw' -gedeelte en die' hw' -deel is van dieselfde vorm, en ek sal dit hier beskryf.

Die eerste van die paar reëls is telkens die begin van 'n tyd -lus. As u nie die tyd ken nie, kan u dit op die Arduino.cc/Reference -webwerf opsoek vir die verduideliking en voorbeelde. Hier wag ons 'terwyl' die ingeboude 'Serial' -funksie geen karakter (s) ontvang het nie en omdat die veranderlike newData afgeskakel is (dws die newData == vals toestand is waar). Sodra 'n karakter - of meer as een karakter - ontvang word, sal die rukkie 'deurdring' na die tweede reël in hierdie paar. Dit sal dan die recAstringChar (char) oproep; funksie om die huidige karakter te hanteer. Hierdie paar reëls sal dan afwissel terwyl daar (of solank as wat) nog karakters moet ontvang word. Sodra hulle klaar is, eindig die toestand terwyl die volgende vlak tot 'n einde kom, en dan die herhaling (char) moontlik maak; funksie tot 'n einde kom. 'N Volledige boodskap is dus nou ontvang.

Stap 12: Skryf die Ontvang subfunksie - Deel 1

Ons moet nou die funksie genaamd recAstringChar (char) skryf;. U sien uit die kommentaar op reël 50 hier bo, dat dit die taak is om twee buffers op te dateer met afskrifte van die inkomende reeksboodskap. [Dit blyk toe ek probeer om dit alles te laat werk, dat een ding wat ek geleer het, was dat ek twee verskillende buffers nodig gehad het - of dit was ten minste die maklikste manier om probleme op te los, daarom het dit ontwikkel tot 2 buffers, dus Ek het dit pas gemaak.] Ek het die een buffer: ontvangenData, en die ander: ontvangenChars.

Die buffers is globale veranderlikes, dus word dit op modulevlak verklaar, sien reëls 9 en 10 van die algemene oortjie. Daar is ander veranderlikes wat binne hierdie funksie verklaar word, wat dus 'n plaaslike omvang het, soos getoon in reëls 51-54 hier. Dit is nie die plek om die verskille tussen wêreldwye en plaaslike inwoners te verduidelik nie, maar daar is meer inligting hieroor in https://www.arduino.cc/glossary/en/ onder Local and Global.

U kan ook alles vind oor die datatipes en tipe-wysigers: staties, booleaans, byte, const, char in https://www.arduino.cc/reference/en/#variables, wat hier gewys word.

Die hoofprogramvloei in hierdie funksie word beheer deur die as op reël 56 hier, en die ooreenstemmende ander op reël 74. Dit handel oor twee scenario's

a) [vanaf reël 74] wanneer die ontvangde boodskap begin. Dit gebeur wanneer die startMarker opgemerk word - dit is gedefinieer as die '<' karakter, en daarom begin ons altyd ons string met die karakter wanneer ons die skets toets. As ons dit nie doen nie, sal niks verwerk word soos dit ontvang word nie, dit word alles geïgnoreer asof ons nonsens tik by die 'Serial Monitor' -sleutelbordaanwysing.

b) [reëls 56 tot 73] wat al die ander karakters ontvang, wat hulle ook al is, maar hulle handel slegs met karakters nadat 'n geldige begin plaasgevind het (a '>' is ontvang soos in a) hierbo.)

In hierdie reëls (van 74 tot 78) plaas ons die ontvangde <in een van die buffers (ontvangenData [0]), maar nie in die ander nie. Ons pas die bufferwyser (veranderlike: char ndx) aan om na die volgende ekstra bufferposisie (ontvangenData [1]) te wys deur die opdrag na-inkrement (++) in die reël ndx ++ te wys;, en ons stel die vlag wat aan die gang is op waar.

Die programvloei in hierdie deel van die funksie word beheer deur die as op reël 57 hier, en die ooreenstemmende ander op reël 65. Dit handel oor twee scenario's

a) [vanaf reël 65] wanneer die ontvangde boodskap beëindig is. Dit gebeur wanneer die endMarker opgemerk word - gedefinieer as>, en daarom eindig ons string altyd met die karakter wanneer ons ons skets toets. Een van die dinge wat gebeur wanneer die eindkarakter ontvang word, is dat die globale vlag (tegnies veranderlike) newData waar gestel word net soos die funksie eindig, sodat die funksie wat ons subfunksie genoem het (die roepfunksie: recv (char);) kan 'weet' dat geldige nuwe data volledig ontvang is.

b) [reëls 57 tot 64] wat al die ander karakters ontvang, wat hulle ook al is. Dit parkeer hulle netjies netjies in rye in albei buffers.

Stap 13: Skryf die Ontvang subfunksie - Deel 2

Dit kan help om 'n voorbeeld te gee van hoe die twee buffers lyk wanneer hulle bevolk is. As ons enter invoer, sal die buffers die karakters bevat:

U kan dus sien dat ons een buffer het wat presies dieselfde karakters is as wat ons eers ingevoer het, en een buffer wat net die twee waardes en 'n skeidende komma het. Nou het ons 'n kode wat die karakters wat ons by die Serial Monitor-sleutelbord invoer, kan ontvang; ons kan van CDIO fase I na O gaan, 'n paar snare tik en sien wat gebeur. Laai die kode op na die Master Arduino, maak die Serial Monitor oop en probeer iets geldig invoer, soos enter. Ontvang u 'n eggo op die Serial Monitor -skerm soos die hier gewys?

Stap 14: Skryf die stuur- en ontledingsfunksies neer

Eerstens vir die oordrag

So nou het ons 'n string ontvang, ons kan die stuurfunksie skryf: tran (char); sy stomp te vervang. Dit sal ons toelaat om 'n string van die meester na die Slave Arduino te stuur, Maak dus seker dat albei toestelle ingeprop en gekoppel is om hierdie nuwe funksie te toets.

Voer hierdie funksie in soos getoon in reëls 117 tot 133. Soos u sal herken, het dit twee dele, een om na die USB -kanaal (hardeware UART) te stuur en een om na die ander Arduino (sagteware UART.) Oor te dra. -vry, en u kan die skets onmiddellik oplaai en kyk wat gebeur. Hierdie keer sal ek stuur. Word die resultaat getoon?

Die skermkiekie is interessant, want die ontvangen string … moet soos voorheen korrek lyk, en die gestuurde string … moet nou korrek lyk. Let egter daarop dat die heelgetal -omskakeling nie gewerk het nie. Daar is nog 'n bietjie kode om by te voeg om dit te laat werk.

Stap 15: Skryf die stuur- en ontledingsfunksies neer

Dan vir die Parse

Dit is 'n stuk kode wat die string wat ontleed is, ontleed om die numeriese gedeeltelike snare uit te haal en dit om te skakel in heelgetalwaardes. Dit is die leemte parseData (); funksie van die hooflus

Vervang die ontledingsstomp met die kode in reëls 98 - 113. Laai dit op, en laat ons kyk of die probleem met die 2 heelgetalwaardes nou opgelos is. Kom ons probeer.

Ja, dit werk wel, soos getoon, die heelgetalle wat gevind word, is 49 en 98.

Stap 16: Finale

Hierdie data het reg rondom die lus gegaan vanaf die rekenaar deur die meester deur die slaaf en weer via die meester weer na die rekenaar. Met die voltooide weergawe van die algemene oplaai na beide Master- en slave -eindes, en met die ontfoutingsmodus nou afgeskakel, sien ons data wat aan beide kante korrek ontvang is, soos hier getoon.