Send numeriske data fra en Arduino til en anden: 16 trin

2024 Forfatter: John Day | [email protected]. Sidst ændret: 2024-01-30 08:26

Introduktion

af David Palmer, CDIO Tech. ved Aston University.

Har du nogensinde haft brug for at sende nogle numre på tværs fra den ene Arduino til den anden? Denne instruks viser hvordan.

Du kan nemt teste det virker ved blot at skrive en række numre, der skal sendes på Serial Monitor -terminalen, og se tallene komme ud igen på en anden seriel skærm, der er forbundet til den anden Arduino. Du kan endda bruge et Bluetooth -link.

Hvad det gør

To Arduino -programmer (skitser i Arduino -tale) skal udvikles, et et masterprogram til at oprette forbindelse til værtscomputeren, der kører Arduino Serial Monitor, et til at fungere som slave for at modtage den serielle besked fra mesteren, afkode den og sende den tilbage. Slaven er valgfri i stand til at vise de numre, den beskæftiger sig med, på en anden IDE's serielle skærm - bare hvis du vil bruge dette. Det kan hjælpe med at få tingene til at fungere i første omgang og hjælpe dig, hvis du beslutter dig for at foretage ændringer i programmerne, så de passer til dine egne krav.

Udstyr

• 2 Arduinoer
• 2 USB -ledninger
• patch ledninger (efter behov)
• 1 pc/bærbar computer med Arduino IDE (tilgængelig som gratis download fra Arduino.cc -webstedet)

Trin 1: Opsætning - Indstil din hardware først

Slut de 2 Arduinos til 2 USB -porte på din computer.

Tip, det er en god idé at mærke dem som M og S (master og slave), så du ikke kommer ind i en rod senere (som vist på de 2 fotos her.)

Trin 2: Opsætning - Indstil din skærm

Det bedste er at opsætte din skærm, så du har

• IDE indlæst med masterprogrammet til venstre og
• det med slaven til højre.

Hold også seriemonitorerne til Maser og Slave til venstre og højre som vist på skærmbilledet her.

Trin 3: Konfigurer masterenden, og forbind derefter sammen - del 1

Når du konfigurerer din Master End Serial Monitor til at sende to numre, skal du altid bruge start- og slutafgrænsningstegnene og kommaseparatortegnet, som du ser her.

Du skal nu forbinde de 2 Arduino'er sammen over seriel. Dette gøres med to patchtråde.

Jeg brugte grønt og gult

• Tag den gule først, denne skal tilsluttes D6 i en Arduino og D7 i den anden
• Derefter modsat for den grønne ledning, D7 på den første og D6 på den anden Arduino.

Alternativt, hvis du har noget tilgængeligt som et par Bluetooth -moduler - som HC -05'er - vil disse også fungere for at give dig nøjagtig den samme effekt som ledningerne ovenfor.

Trin 4: Konfigurer masterenden, og forbind derefter sammen - del 2

Vi gør brug af softwarens serielle bibliotek. Yderligere oplysninger er tilgængelige med dette link

Du kan se den kaldes ud på linje 7 i et af programmerne. Det konfigurerer pins digital 7 og 6 som TX og RX (transmitter og modtag). Sådan vil dataene rejse ud af Master Arduino gennem den grønne ledning ind i Slave, og når Slave -programmet i den anden Arduino har afsluttet sit arbejde, tilbage gennem den gule ledning. I bunden af den samme illustration (i vinduet Serial Monitor) kan du se, at de data, vi transmitterede, nu med succes er gået rundt i den løkke, der er beskrevet her, og kommer tilbage til pc'en, da parret af heltal pænt adskilt.

Trin 5: Oversigt over skitserne / programmerne - programmets struktur

Layout Som i alle Arduino -skitser er der 3 grundlæggende dele:

• Erklæringerne
• Opsætningen
• Den vigtigste sløjfe

Som det ofte forekommer, har vi her gjort brug af et fjerde afsnit, der er tilføjelsen af 'Funktioner'. Hvis du ikke er bekendt med at bruge funktioner, kan du Google efter "Arduino -funktioner", og du finder forklaringssteder som eksemplet i dette link: www.tutorialspoint.com/arduino/arduino_functions…..

Vi har også gjort brug af faner til at adskille programmet til mere håndterbare blokke.

De tre blokke, vi har brugt, kan ses øverst i hver illustration af IDE -vinduerne ovenfor:

• simpleRxTx0330Master
• almindelige
• noter

Disse er faktisk separate filer inde i programmets mappe, som du kan se i denne Windows Stifinder -visning af Slave -programmets filer.

Der er en meget god grund til, at vi har gjort dette.

• Da vi byggede programmet op, indså vi, at det meste af programmet for Mesteren var det samme som for Slave.
• Vi endte med at trække alle de fælles dele ind i en fane, som vi derfor kaldte "fælles", og hver gang vi havde fejlsøgt en del (testet den og var tilfredse med, at den fungerede ok) kopierede og indsatte vi hele den fane overfor Master til Slave eller omvendt.
• Fanerne i noter er tilfældigvis identiske, da designet er generisk.

Ingen af funktionerne kaldes fra setup, de kaldes alle fra loop, så vi har oprettet dem efter setup men før loop.

Trin 6: Top -down design

Det er en god idé at designe din skitse startende med en definition af, hvad du vil gøre.

Når du har dette, kan du begynde at få skitsen til at gøre disse ting. Generelt hvis der er en detalje, du ikke ved, hvordan du gør endnu, skal du bare gøre det til en funktion og lade oprettelsen af funktionen stå til senere.

Dette følger den gode designfilosofi, der undervises på mange universiteter, kaldet CDIO (Hvis du ikke allerede kender denne, kan du google den og finde websteder til at forklare den som: https://www.cdio.org/s.) Dette siger dybest set: Start ikke designet, før du har klart konceptet. Start ikke implementeringen, før du har designet klart. Forvent ikke, at den fungerer, før du har klaret implementeringen. C først, derefter D, I og O. I hvert efterfølgende trin gentages du (gå tilbage rundt om sløjferne), så når du er tilfreds med din oprindelige Design -loop tilbage, og kontroller, at den stadig opfylder konceptet, og opdater C, hvis du har brug for det. Og så videre, så selvom du er kommet til Operation, skal du gå helt tilbage til toppen og se, hvordan C ser ud nu, derefter D og I, og lave og kontrollere alle ændres efter behov. Med programmeringsskitser fungerer dette på samme måde, hvis du designer ovenfra og ned.

Trin 7: Koncept og design - Del 1

Konceptet her ligner skitseringskravene i fanen 'noter'. '

Designet kunne ligne en tidlig version af sløjfen, der matcher fanen noter og kunne se sådan ud, som du ser i denne figur

Se, hvordan jeg kan lide at starte med faktisk CTRL-C først at kopiere kommentarerne til loopens hoved og derefter begynde at udfylde emnerne med kommandoer, der vil gøre disse ting.

Dette kompilerer faktisk OK, som du kan se nederst på skærmen i figuren. Det rækker fra CDIO-fase D til I, og da vi udvikler koden, er det en god idé at fortsætte rundt om denne D-I-loop.

Nu er det tid til at gå ned til næste trin, der er en kommentar der, der siger, at vi skal: // modtage noget fra hardware -USB, så sender vi det til softwarens serielle kanal. Vi skriver denne kode for at få det til at ske - linjer 133 til 138 vist her i gul highlighter

Trin 8: Koncept og design - Del 2

De to første to funktioner, vi introducerer her, er (recv () og tran () til at modtage fra hardware -porten og overføre til software -porten - derfor kalde dem med de viste 'hw' eller 'sw' parametre.

Ud over dem har vi tilføjet en test på en global variabel kaldet newData. Dette er et flag, vi sætter inde i funktionen "void recv ();". Når en meddelelse er modtaget, markeres denne variabel fra falsk til sand. Vi gør dette, så vi kun sender en besked, hvis en er modtaget (flag == true) i linje 134. Og når vi har sendt vores besked, er det 'job done', så vi sletter flaget tilbage til falsk igen i linje 137.

Igen kan vi kontrollere kompilering (D til I), og denne gang har vi en 'ikke deklareret' fejlmeddelelse (vist). Dette fortæller os, at vi ikke har erklæret recv (); fungere. Vi planlægger at gøre dette senere, så lige nu for at give os mulighed for at få en ren kompilering skal vi oprette en dummy eller pladsholderfunktion, som vist nedenfor.

Igen kan vi kontrollere kompilering (D til I), og denne gang har vi endnu en 'ikke deklareret' fejlmeddelelse for tran (); fungere. Dette har brug for en lignende stub oprettelse. Igen kan vi kontrollere kompilering (D til I), og denne gang finder vi dette fungerer perfekt; så langt så godt.

Trin 9: Afslut hovedsløjfen: A) Modtagelse fra USB, B) Modtagelse fra slave Arduino

Der er et sidste stykke, vi har tilføjet for at afslutte denne del, som er at tilføje nogle fejlfindingskoder.

Der er en anden instruks om fejlfindingsskitser, som der kan henvises til for at forstå, hvad vi har gjort her, og hvorfor. Se instruktionsbogen "Sådan bygger og tester du Arduino -skitser, indtil de virker"

Så disse fejlfindingslinjer [vist 136-139] tilføjes næste i hovedsløjfen, og se og se, du kan teste dem i Master-enden ved at gøre fejlfindingsvariablen sand og Kompilering (I), så hvis du tilslutter en Arduino, du kan uploade, åbne den serielle skærm og se, om det, der kommer tilbage til den serielle skærm, er som vist her (ser du meddelelsen "DEBUG MODE" tilføjes?)

Trin 10: Modtagelse og håndtering af data i Slave Arduino

Modtager fra Slave Arduino

Tilføj den nødvendige kode for den anden kanal til hovedsløjfen, softwarens serielle modtager som vist - linje 149 til 155.

Kan du se, at strukturen er løst baseret på det, vi skrev ovenfor for Master -sagen?

Du vil også se, at vi får en compiler -fejl, en anden ikke -erklæret funktion - denne gang parseData (); - så vi skal også lave en stubbe til dette, før vi kan køre en fejlfri testkompil.

Håndtering af data i Slave Arduino

Tilføj hovedsløjfe -koden, der kræves for Arduino, hvis den er konfigureret som en slave -enhed som vist - linje 163 til 174. Kan du se, at strukturen på den ligner den på den første kanal?

Og du skulle finde ud af, at denne gang kompileres helt fint.

Trin 11: Skriv modtagefunktionen

Modtagefunktionen - void recv (char fra) {} - har to hovedjobs.

1 for at modtage en række tegn fra USB -kanalen og

2 for at modtage en fra Arduino til Arduino kanalen.

For det første skal vi bruge det, fordi det bruger Arduino's indbyggede hardware UART, og for det andet ved hjælp af standard Arduino Library: software UART.

Når vi begynder at tilføje kode til en funktion - for at oprette en funktion, der gør noget, i stedet for bare en stub - skal vi huske at fjerne eller kommentere den stub, den erstatter. Ellers får vi en kompileringsfejl: refefintion af 'void lrec (char)'.

Prøv at få fejlen, og prøv derefter en af de ovenfor foreslåede måder at slippe af med den.

Start med en funktion, der ligner den, vi viser her med linjer 75 til 88 i gult.

På nuværende tidspunkt ved du, at du har kode for at prøve kompilering. Det giver dig en fejl, som dem vi havde tidligere, af typen: funktionsnavn, der ikke er angivet i dette omfang. Vi får i første omgang brug for endnu en stub for at lade os kompilere forbi denne fejl, så tilføj en som før, og sørg for, at du nu kan få en kompilering uden fejl.

Lad os nu se på den kode, vi har skrevet til recv () -funktionen.

Det er ganske rent, du kan se brugen af 'if' -tilstanden til at producere de to dele af funktionen, der er nævnt ovenfor.

Koden inde i 'sw' -delen og' hw' -delen er af samme form, og jeg vil beskrive den her.

Den første af linjeparet i hvert tilfælde er starten på et stykke loop. Hvis du ikke er bekendt med while's, kan du slå det op på Arduino.cc/Reference -webstedet for at få forklaringen og eksemplerne. Her venter vi 'mens' den indbyggede 'Seriel' funktion ikke har modtaget nogen karakter (er), og fordi variablen newData er blevet deaktiveret (dvs. newData == false condition er sand). Så snart et tegn - eller mere end ét tegn - er modtaget, vil stunden 'falde igennem' til den anden linje i dette par. Det vil derefter kalde recAstringChar (char); funktion til at håndtere det aktuelle tegn. Dette par linjer skifter derefter, mens (eller så længe) der stadig er tegn, der skal modtages. Når de alle er færdige, mens tilstanden ender, tillader if eller ellers næste niveau at ende, og igen tillader rec (char); funktion til at afslutte. Således er der nu modtaget en fuld besked.

Trin 12: Skriv modtage sub -funktion - del 1

Vi skal nu skrive funktionen kaldet recAstringChar (char);. Du ser fra kommentaren til linje 50 her øverst, at dens opgave er at opdatere to buffere med kopier af den indgående serielle meddelelse. [Det viste sig, mens jeg forsøgte at få det hele til at fungere, at en ting jeg lærte var, at jeg havde brug for to forskellige buffere - eller i det mindste var det den nemmeste måde at komme rundt på nogle problemer på, derfor udviklede det sig til at have brug for 2 buffere, så Jeg har lige lavet dem.] Jeg har kaldt den ene buffer: receivedData og den anden: receivedChars.

Bufferne er globale variabler, så de deklareres på modulniveau, se linje 9 og 10 i den fælles fane. Der er andre variabler, der er erklæret inde i denne funktion, som derfor har lokalt omfang- vist i linje 51-54 her. Dette er ikke stedet at forklare forskellene mellem globaler og lokale, men der er mere information om dette i https://www.arduino.cc/glossary/en/ under Local og Global.

Du kan også finde ud af alt om datatyper og typemodifikatorer: statisk, boolsk, byte, const, char i https://www.arduino.cc/reference/en/#variables, vist her.

Hovedprogrammets flow i denne funktion styres af if på linje 56 her og dens tilsvarende andet på linje 74. Dette omhandler to scenarier

a) [fra linje 74 på], når den modtagne besked begynder. Dette sker, når startMarker opdages - dette er blevet defineret som '<' -tegnet, og derfor starter vi altid vores streng med det tegn, hver gang vi tester skitsen. Hvis vi ikke gør det, vil intet blive behandlet som modtaget, det vil alle blive ignoreret, ligesom om vi skriver nonsens ved tastaturprompten 'Serial Monitor'.

b) [linje 56 til 73], som modtager alle de andre tegn, uanset hvad de er, men de behandler kun tegn efter en gyldig start er sket (a '>' er modtaget som i a) ovenfor.)

I disse linjer (fra 74 til 78) lagde vi det modtagne <i en af bufferne (modtagetData [0]), men ikke i den anden. Vi justerer buffermarkøren (variabel: char ndx) for at pege på den næste reservebufferposition (ontvangenData [1]) ved hjælp af kommandoen post-increment (++) i linjen ndx ++;, og vi sætter det igangværende flag til sandt.

Programforløbet i denne del af funktionen styres af hvis på linje 57 her og dens tilsvarende andet på linje 65. Dette omhandler to scenarier

a) [fra linje 65 til], når den modtagne besked er afsluttet. Dette sker, når endMarker er opdaget - defineret som>, og derfor slutter vi altid vores streng med den karakter, hver gang vi tester vores skitse. En af de ting, der sker, når sluttegnet modtages, er, at det globale flag (teknisk variabel) newData er sat sandt, når funktionen slutter, så funktionen, der kaldte vores underfunktion (den kaldende funktion: recv (char);) kan 'vide', at gyldige nye data er modtaget komplet.

b) [linje 57 til 64], der modtager alle de andre tegn, uanset hvad de er. Det parkerer bare travlt dem pænt i rækker i begge buffere.

Trin 13: Skriv modtage sub -funktion - del 2

Det kan hjælpe at give et eksempel på, hvordan de 2 buffere ser ud, når de er blevet befolket. Hvis vi skulle indtaste enter, ville bufferne have tegnene vist i dem:

Så nu kan du se, at vi har en buffer, der er nøjagtigt alle de samme tegn, som vi først indtastede, og en buffer, der bare har de to værdier og et adskillelses komma. Nu har vi en kode, der kan modtage de tegn, vi indtaster på Serial Monitor-tastaturet, vi kan flytte fra CDIO fase I til O, indtaste nogle strenge og se, hvad der sker. Upload koden til Master Arduino, åbn Serial Monitor og prøv at indtaste noget gyldigt, f.eks. Enter. Modtager du et ekko på skærmen Serial Monitor som det, der vises her?

Trin 14: Skriv overførsels- og analysefunktionerne

Først til transmissionen

Så nu har vi modtaget en streng, vi kan skrive sendefunktionen: tran (char); at udskifte sin stubbe. Dette vil give os mulighed for at sende en streng fra Master til Slave Arduino, så sørg for, at begge enheder er tilsluttet og forbundet til at teste denne nye funktionalitet.

Indtast denne funktion som vist her i linje 117 til 133. Som du vil genkende, har den to dele, en til at sende til USB -kanalen (hardware UART) og en til at overføre til den anden Arduino (software UART.) Dette skulle kompilere fejl -gratis, og du kan straks uploade skitsen og se, hvad der sker. Denne gang sender jeg. Får du vist resultatet?

Skærmbilledet er interessant, fordi den modtagne streng … skal se korrekt ud som før, og den transmitterede streng … nu skal se korrekt ud. Bemærk dog, at heltalskonverteringen ikke har fungeret. Der er stadig lidt mere kode at tilføje for at få det til at fungere.

Trin 15: Skriv overførsels- og analysefunktionerne

Derefter til parse

Dette er et stykke kode, der analyserer den modtagne streng for at hente de numeriske delstrenge og konverterer dem til heltalsværdier. Det er det ugyldige parseData (); funktion af hovedsløjfen

Erstat parsestubben med koden vist i linje 98 - 113. Upload den, og lad os se, om det problem, vi havde med de 2 heltalsværdier, nu er løst. Lad os prøve.

Ja, det virker, som vist, de heltal, der findes, er 49 og 98.

Trin 16: Finale

Disse data er gået lige rundt om sløjfen fra pc'en gennem Master gennem slaven og tilbage via Master igen til pc'en igen. Med den færdige version af fælles uploadet til både Master- og slaveender, og med fejlfindingstilstand deaktiveret nu, får vi se data korrekt modtaget i begge ender som vist her.