Send numeriske data fra en Arduino til en annen: 16 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:21

Introduksjon

av David Palmer, CDIO Tech. ved Aston University.

Måtte du noen gang sende noen numre fra en Arduino til en annen? Denne instruksen viser hvordan.

Du kan enkelt teste det fungerer ved ganske enkelt å skrive inn en streng med tall som skal sendes på Serial Monitor -terminalen, og se tallene komme ut igjen på en andre seriell monitor som er koblet til den andre Arduino. Du kan til og med bruke en Bluetooth -lenke.

Hva det gjør

To Arduino -programmer (skisser i Arduino -tale) må utvikles, ett et Master -program for å koble til vertsmaskinen som kjører Arduino Serial Monitor, ett for å fungere som slave for å motta den serielle meldingen fra Master, dekode den og sende den tilbake. Slaven er eventuelt i stand til å vise tallene den har å gjøre med på en andre IDEs serielle monitor - bare hvis du vil bruke denne. Det kan hjelpe å få ting til å fungere i utgangspunktet, og hjelpe deg hvis du bestemmer deg for å gjøre noen endringer i programmene for å passe dine egne krav.

Utstyr

• 2 Arduinoer
• 2 USB -ledninger
• patch ledninger (etter behov)
• 1 PC/bærbar datamaskin lastet med Arduino IDE (tilgjengelig som gratis nedlasting fra nettstedet Arduino.cc)

Trinn 1: Konfigurere - Sett opp maskinvaren først

Koble de 2 Arduinos til 2 USB -porter på datamaskinen.

Tips, det er en god idé å merke dem som M og S (master og slave), slik at du ikke kommer inn i en rot senere (som vist på de to bildene her.)

Trinn 2: Konfigurere - Still inn skjermen

Det beste er å sette opp skjermen slik at du har

• IDE lastet med masterprogrammet til venstre og
• det med slaven til høyre.

Behold seriemonitorene for Maser og Slave til venstre og høyre også som vist på skjermbildet her.

Trinn 3: Sett opp Master End, Koble deretter sammen - Del 1

Når du konfigurerer Master End Serial Monitor til å sende to tall, må du alltid bruke start- og slutten, skilletegn og komma -skilletegnet som du ser her.

Du må nå koble de 2 Arduino -ene sammen over seriell. Dette gjøres med to lappetråder.

Jeg brukte grønt og gult

• Ta den gule først, denne må plugges inn i D6 i en Arduino og D7 i den andre
• Deretter motsatt for den grønne ledningen, D7 på den første og D6 på den andre Arduino.

Alternativt, hvis du har noe tilgjengelig som et par Bluetooth -moduler - som HC -05 - vil disse også fungere for å gi deg nøyaktig samme effekt som ledningene ovenfor.

Trinn 4: Sett opp Master End, Koble deretter sammen - Del 2

Vi bruker Software Serial -biblioteket. Ytterligere informasjon er tilgjengelig med denne lenken

Du kan se det kalt ut på linje 7 i et av programmene. Den konfigurerer pins digital 7 og 6 som TX og RX (sende og motta). Slik vil dataene bevege seg ut av Master Arduino gjennom den grønne ledningen inn i Slave, og når Slave -programmet i den andre Arduinoen er ferdig med arbeidet, tilbake gjennom den gule ledningen. Nederst i den samme illustrasjonen (i Serial Monitor -vinduet) kan du se dataene vi overførte nå har lykkes med å gå rundt løkken som er beskrevet her, og komme tilbake til PC -en som paret av heltall som er pent skilt ut.

Trinn 5: Oversikt over skissene / programmene - struktur av programmet

Layout Som i alle Arduino -skisser er det 3 grunnleggende deler:

• Erklæringene
• Oppsettet
• Hovedløkken

Som det ofte skjer, har vi her benyttet oss av en fjerde seksjon som er tillegg av 'Funksjoner'. Hvis du ikke er kjent med å bruke Functions, kan du Google for "Arduino -funksjoner", og du vil finne forklaringssteder som eksempelet i denne lenken: www.tutorialspoint.com/arduino/arduino_functions…..

Vi har også gjort bruk av faner for å dele programmet i mer håndterbare blokker.

De tre blokkene vi har brukt kan ses øverst på hver illustrasjon av IDE -vinduene ovenfor:

• simpleRxTx0330Master
• felles
• notater

Dette er faktisk separate filer i programmets mappe, som du kan se i denne Windows Utforsker -visningen av Slave -programmets filer.

Det er en veldig god grunn til at vi har gjort dette.

• Da vi bygde opp programmet, innså vi at det meste av programmet for Mesteren var det samme som for slaven.
• Vi endte med å trekke alle de vanlige delene inn i en fane, som vi derfor kalte "vanlig", og hver gang vi hadde feilsøkt en del (testet den og var fornøyd med at den fungerte OK) kopierte og limte vi hele fanen overfor Master til Slave, eller omvendt.
• Notatfanene er også tilfeldigvis identiske, ettersom designet er generisk.

Ingen av funksjonene kalles fra oppsett, de kalles alle fra loop, så vi har opprettet dem etter oppsett, men før loop.

Trinn 6: Top Down Design

Det er en god idé å designe skissen din med en definisjon av hva du vil gjøre.

Når du har dette kan du begynne å få skissen til å gjøre disse tingene. Vanligvis hvis det er en detalj du ikke vet hvordan du gjør ennå, bare gjør den til en funksjon, og la opprettelsen av funksjonen stå til senere.

Dette følger den gode designfilosofien, undervist i mange universiteter, kalt CDIO (Hvis du ikke allerede vet denne, kan du Google den og finne nettsteder for å forklare den som: https://www.cdio.org/s.) Dette sier i utgangspunktet: Ikke start designet før du har klart konseptet. Ikke start implementeringen før du har klart designet. Ikke forvent at den skal fungere før du har klart implementeringen. C først, deretter D, I og O. I hvert påfølgende trinn gjentar du det (gå tilbake rundt sløyfen (e)), så når du er fornøyd med den første Design -løkken tilbake, og sjekk at den fortsatt oppfyller konseptet, og oppdater C hvis du trenger det. Og så videre, så selv når du har kommet til å operere, gå helt tilbake til toppen, og se hvordan C ser ut nå, deretter D og I, og gjør og sjekk alt endres etter behov. Med programmeringsskisser fungerer dette akkurat det samme hvis du designer ovenfra og ned.

Trinn 7: Konsept og design - Del 1

Konseptet her ser ut som oversiktskravene som er angitt i kategorien 'notater'. '

Designet kan se ut som en tidlig versjon av løkken, som matcher notatfanen og kan se ut som du ser i denne figuren

Se hvordan jeg liker å starte med å faktisk CTRL-C kopiere kommentarene inn i sløyfehodet først, og deretter begynne å fylle ut emnene med kommandoer som gjør disse tingene.

Dette kompilerer faktisk OK som du kan se nederst på skjermen i figuren. Det strekker seg fra CDIO-trinn D til I, og når vi utvikler koden, er det en god idé å fortsette rundt denne D-I-løkken.

Nå er det på tide å gå ned til neste trinn, det er en kommentar der som sier at vi skal: // motta noe fra maskinvaren USB, så skal vi overføre det til programvarens serielle kanal. Vi skriver denne koden for å få det til - linje 133 til 138 vist her i gul markering

Trinn 8: Konsept og design - Del 2

De to første to funksjonene vi introduserer her er (recv () og tran () for å motta fra maskinvareporten og overføre til programvareporten - og dermed kalle dem med 'hw' eller 'sw' parametrene som vises.

I tillegg til dem har vi lagt til en test på en global variabel som heter newData. Dette er et flagg vi vil sette inne i "void recv ();" - funksjonen. Når en melding er mottatt, blir denne variabelen flagget fra usann til sann. Vi gjør dette slik at vi bare sender en melding hvis en har blitt mottatt (flag == true) på linje 134. Og når vi har overført meldingen vår, er jobben gjort, slik at vi fjerner flagget til falskt igjen på linje 137.

Igjen kan vi sjekke kompilering (D til I), og denne gangen har vi en "ikke deklarert" feilmelding (vist). Dette forteller oss at vi ikke har erklært recv (); funksjon. Vi planlegger å gjøre dette senere, så nå for å la oss få en ren kompilering trenger vi å lage en dummy- eller plassholderfunksjon, som vist nedenfor.

Igjen kan vi sjekke kompilering (D til I), og denne gangen har vi en annen "ikke deklarert" feilmelding for tran (); funksjon. Dette trenger en lignende stubbe som oppretter. Igjen kan vi sjekke kompilering (D til I), og denne gangen vil vi finne at dette fungerer perfekt; så langt så bra.

Trinn 9: Fullfør hovedsløyfen: A) Motta fra USB, B) Motta fra slave Arduino

Det er et siste stykke vi har lagt til for å fullføre denne delen, som er å legge til noen feilsøkingskode.

Det er en annen instruks om feilsøkingsskisser som kan refereres til for å forstå hva vi har gjort her og hvorfor. Se instruksjonsboken "Hvordan bygge og teste Arduino -skisser til de fungerer"

Så disse feilsøkingslinjene [136-139 vist] legges til neste i hovedsløyfen, og se og se, du kan teste dem i Master-enden ved å gjøre feilsøkingsvariabelen sann og Compiling (I), så hvis du kobler til en Arduino, du kan laste opp, åpne serieovervåking og se om det som kommer tilbake til seriell skjerm er som vist her (ser du meldingen "DEBUG MODE" er lagt til?)

Trinn 10: Motta og håndtere dataene i Slave Arduino

Mottar fra Slave Arduino

Legg den nødvendige koden for den andre kanalen til hovedsløyfen, programvarens serielle mottaker som vist - linje 149 til 155.

Kan du se at strukturen er løst basert på det vi skrev ovenfor for Master -saken?

Du vil også se at vi får en kompilatorfeil, en annen ikke -deklarert funksjon - denne gangen parseData (); - så vi må lage en stubbe for dette også, før vi kan kjøre en feilfri testkompilering.

Håndtering av dataene i Slave Arduino

Legg til hovedløyfekoden som kreves for Arduino hvis den er konfigurert som en slaveenhet som vist - linje 163 til 174. Kan du se at strukturen til den er veldig lik den på den første kanalen?

Og du bør finne denne gangen det kompilerer helt fint.

Trinn 11: Skriv mottaksfunksjonen

Mottaksfunksjonen - void recv (char fra) {} - har to hovedjobber.

1 for å motta en rekke tegn fra USB -kanalen, og

2 for å motta en fra Arduino til Arduino -kanalen.

For det første må vi bruke det fordi det bruker Arduino's innebygde maskinvare UART, og for det andre ved hjelp av standard Arduino Library: programvare UART.

Når vi begynner å legge til kode i en funksjon - for å lage en funksjon som gjør noe, i stedet for bare en stubbe - må vi huske å fjerne eller kommentere stubben den erstatter. Ellers får vi en kompileringsfeil: refefintion of 'void lrec (char)'.

Prøv å få feilen, og prøv deretter en av metodene ovenfor for å bli kvitt den.

Start med en funksjon som ser ut som den vi viser her av linjene 75 til 88 i gult.

Nå vet du at du må prøve kompileringsoperasjonen når du har kode. Det gir deg en feil, som de vi hadde tidligere, av typen: funksjonsnavn som ikke er deklarert i dette omfanget. Vi trenger først en ny stubbe for å la oss kompilere forbi denne feilen, så legg til en slik som før, og sørg for at du nå kan få en kompilering uten feil.

La oss nå se på koden vi har skrevet for recv () -funksjonen.

Det er ganske rent, du kan se bruken av "hvis" -tilstanden for å produsere de to delene av funksjonen referert til ovenfor.

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

Den første av linjeparet i hvert tilfelle er starten på en stund -sløyfe. Hvis du ikke er kjent med mens du er, kan du slå det opp på Arduino.cc/Reference -siden for forklaring og eksempler. Her venter vi 'mens' den innebygde 'Serielle' funksjonen ikke har mottatt noen tegn (er) og fordi variabelen newData er slått av (dvs. newData == false condition er sann). Så snart et tegn - eller mer enn ett tegn - er mottatt, vil tiden "falle gjennom" til den andre linjen i dette paret. Det vil da ringe recAstringChar (char); funksjon for å håndtere gjeldende karakter. Dette paret av linjer vil deretter skifte mens (eller så lenge som) det er tegn som fortsatt må mottas. Når de er ferdig, slutter mens -tilstanden, slik at neste nivå kan slutte, og igjen tillate rec (char); funksjonen avsluttes. Dermed har en full melding nå blitt mottatt.

Trinn 12: Skriv mottaksundervisningen - del 1

Vi må nå skrive funksjonen recAstringChar (char);. Du ser fra kommentaren til linje 50 her på toppen, at jobben er å oppdatere to buffere med kopier av den innkommende seriemeldingen. [Det viste seg at mens jeg prøvde å få alt til å fungere, var det en ting jeg lærte at jeg trengte to forskjellige buffere - eller i det minste var det den enkleste måten å komme meg rundt noen problemer, derfor utviklet det seg til å trenge 2 buffere, så Jeg har nettopp laget dem.] Jeg har kalt den ene bufferen: receivedData, og den andre: receivedChars.

Bufferne er globale variabler, så de deklareres på modulnivå, se linje 9 og 10 i den vanlige fanen. Det er andre variabler deklarert inne i denne funksjonen som derfor har lokalt omfang- vist i linje 51-54 her. Dette er ikke stedet å forklare forskjellene mellom globaler og lokalbefolkningen, men det er mer informasjon om dette på https://www.arduino.cc/glossary/en/ under Local and Global.

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

Hovedprogramflyten i denne funksjonen styres av hvis på linje 56 her, og dens tilsvarende annet på linje 74. Dette omhandler to scenarier

a) [fra linje 74 på] når den mottatte meldingen begynner. Dette skjer når startMarker blir oppdaget - dette har blitt definert som '<' - tegnet, og derfor begynner vi alltid strengen vår med det tegnet når vi tester skissen. Hvis vi ikke gjør det, vil ingenting bli behandlet som mottatt, det vil bli ignorert, akkurat som om vi skriver tull på tastaturet "Serial Monitor".

b) [linje 56 til 73] som mottar alle de andre tegnene, uansett hva de er, men de behandler bare tegn etter at en gyldig start har skjedd (a '>' er mottatt som i a) ovenfor.)

I disse linjene (fra 74 til 78) legger vi det mottatte <i en av bufferne (mottattData [0]), men ikke i den andre. Vi justerer bufferpekeren (variabel: char ndx) for å peke til neste reservebufferposisjon (mottattData [1]) ved hjelp av kommandoen post-increment (++) i linjen ndx ++;, og vi setter det pågående flagget til true.

Programflyten i denne delen av funksjonen styres av hvis på linje 57 her, og dens tilsvarende annet på linje 65. Dette omhandler to scenarier

a) [fra linje 65 på] når den mottatte meldingen er avsluttet. Dette skjer når endMarker blir oppdaget - definert som>, og derfor avslutter vi alltid strengen vår med den karakteren hver gang vi tester skissen vår. En av tingene som skjer når slutttegnet mottas er at det globale flagget (teknisk variabel) newData er satt sant akkurat som funksjonen avsluttes, slik at funksjonen som kalte vår underfunksjon (kallingsfunksjonen: recv (char);) kan "vite" at gyldige nye data er mottatt fullført.

b) [linje 57 til 64] som mottar alle de andre tegnene, uansett hva de er. Det parkerer dem bare travelt i rader i begge bufferne.

Trinn 13: Skriv mottaksundervisningen - del 2

Det kan hjelpe å gi et eksempel på hvordan de to bufferne ser ut når de har blitt befolket. Hvis vi skulle skrive inn enter, ville bufferne ha tegnene vist i dem:

Så nå kan du se at vi har en buffer som er nøyaktig alle de samme tegnene som vi først skrev inn, og en buffer som bare har de to verdiene og et separerende komma. Nå har vi en kode som kan motta tegnene vi skriver inn på Serial Monitor-tastaturet, vi kan gå fra CDIO fase I til O, skrive inn noen strenger og se hva som skjer. Last opp koden til Master Arduino, åpne Serial Monitor og prøv å skrive inn noe gyldig, for eksempel enter. Mottar du et ekko på skjermen Serial Monitor som det som vises her?

Trinn 14: Skriv overførings- og analysefunksjonene

Først for overføringen

Så nå har vi mottatt en streng, vi kan skrive overføringsfunksjonen: tran (char); for å bytte ut stubben. Dette vil tillate oss å sende en streng fra Master til Slave Arduino, så sørg for at begge enhetene er koblet til og koblet sammen for å teste denne nye funksjonaliteten.

Skriv inn denne funksjonen som vist her på linje 117 til 133. Som du kjenner igjen, har den to deler, en som skal overføres til USB -kanalen (maskinvare UART) og en som skal overføres til den andre Arduino (programvare UART.) Dette bør kompilere feil -gratis, og du kan umiddelbart laste opp skissen og se hva som skjer. Denne gangen sender jeg. Får du resultatet vist?

Skjermbildet er interessant fordi den mottatte strengen … skal se riktig ut som før, og den sendte strengen … skal nå se riktig ut. Vær imidlertid oppmerksom på at heltallskonverteringen ikke har fungert. Det er fortsatt litt mer kode å legge til for at det skal fungere.

Trinn 15: Skriv overførings- og analysefunksjonene

Deretter for analysen

Dette er et stykke kode som analyserer strengen som er mottatt for å hente ut de numeriske delstrengene og konverterer dem til heltallsverdier. Det er det ugyldige parseData (); funksjonen til hovedsløyfen

Erstatt analysestubben med koden vist på linje 98 - 113. Last den opp, og la oss se om problemet vi hadde med de to heltallsverdiene nå er løst. La oss prøve.

Ja, det fungerer, som vist, heltallene som er funnet er 49 og 98.

Trinn 16: Finale

Disse dataene har gått rett rundt løkken fra PC -en gjennom Master gjennom slaven og tilbake via Master igjen til PC -en igjen. Med den ferdige versjonen av felles lastet opp til både Master- og slaveenden, og med feilsøkingsmodus slått av nå, får vi se data som er korrekt mottatt i begge ender som vist her.