Slik fjerner du Arduino Serial Buffer

Slik Fjerner Du Arduino Serial Buffer



Arduino er en elektronisk plattform som tar instruksjoner fra brukere i form av kode kjent som skisse og genererer utdata deretter. For å samle instruksjonene og behandle dem én etter én, bruker Arduino en seriell buffer. Arduino-seriebufferen holder innkommende data til enheten er klar til å behandle dem. Noen ganger må vi tømme Arduino-seriebufferen for å unngå forstyrrelser med innkommende data. La oss se dette mer detaljert.

Arduino seriell buffer

Så vi vet alle at Arduino kommuniserer ved hjelp av seriell kommunikasjonsprotokoll kjent som USART. Ja, Arduino har noen andre protokoller som SPI, I2C, men USART er den vanligste og mest brukte protokollen. Hvis du er interessert i å lese Arduino alle tre protokollene, klikk her .







Arduino seriebuffere samler inn de innkommende serietegnene og holder dem til mikrokontrolleren kan behandle dem. Seriell kommunikasjon er metoden for å overføre data fra en enhet til en annen. Arduino som bruker USART-maskinvare på brettene setter sammen hver 8 bits til en byte. Lagre deretter disse bytene i seriebufferen, maksimalt 64 byte kan lagres inne i Arduino seriebufferen.



Tøm Arduino seriell buffer

Arduino serielle buffere har begrenset minne for å lagre data i tilfelle hvis minnet renner over eller store mengder data er der ved seriepinnen, må vi tømme den serielle bufferen først for å lagre innkommende data. La oss finne ut mulige måter å tømme Arduino-seriebufferen på.



Måter å fjerne Arduino Serial Buffer

For å frigjøre seriell bufferplass slik at den kan oppdateres med nye data kan følgende av de to måtene være nyttig:





    • Fjern seriell buffer ved å bruke Serial.flush()-funksjonen
    • Tøm seriell buffer ved å bruke Serial.begin()-funksjonen

1: Fjern seriell buffer ved å bruke Serial.flush()-funksjonen

Så, den første metoden som kan tømme en Arduino seriell buffer er å bruke en Serial.flush() funksjon. Denne funksjonen tilhører Arduinos seriebiblioteksfunksjon.

Serial.flush()

Arduino Serial.flush()-funksjonen venter på at dataene skal overføres fullstendig. I stedet for å forkaste de innkommende dataene, lar den den vente, så når dataene inne i bufferen er overført fullstendig, kan seriebufferen motta de nye dataene.



Merk : Etter bruk av Serial.flush() kan programmer ta lengre tid å kjøre og skrive ut på seriell monitor. Per nå venter Arduino-koden når alle data er overført, slik at den kan lagre nye data i minnet.

Syntaks

Serial.flush ( )

Parametere

Det tar bare én parameter.

Serie: Seriell portobjekt

Returnerer

Denne funksjonen returnerer ingenting.

Eksempelkode

Her er koden som er skrevet uten å bruke Serial.flush()-funksjonen:

ugyldig oppsett ( ) {
Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Start koden ved å lagre gjeldende Arduino-klokke tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
unsigned long millis_FlushStop = millis ( ) ; /* strøm tid På dette punktet */
Serial.print ( F ( 'Uten spylefunksjon tar det' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Utskrifter tid tatt av seriell buffer for å skrive ut data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
ugyldig sløyfe ( ) {
}


I koden ovenfor initialiserte vi tre forskjellige strenger og startet koden ved å ta gjeldende tid fra millis()-funksjonen og lagre den i en ny variabel. Når dataene er skrevet ut igjen ved hjelp av millis()-funksjonen overfører vi den nåværende tiden til en ny variabel.

Når begge tidene er mottatt i to variabler, vil forskjellen gi oss tiden det tar Arduino å skrive ut de tre definerte strengene i millisekunder.


I utgangsterminalen kan det sees at det tar 9ms å skrive ut den definerte strengen.


Nå i koden gitt nedenfor vil vi bruke Serial.flush()-funksjonen som lar alle strengene passere og vente der til den serielle bufferen blir klar for å motta neste data. Derfor vil det ta ekstra tid sammenlignet med å skrive ut data uten å bruke Serial.flush().

ugyldig oppsett ( ) {
Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Start koden ved å lagre gjeldende Arduino-klokke tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
Serial.flush ( ) ; /* Venter til data som skal overføres etter tømmeminnet */
unsigned long millis_FlushStop = millis ( ) ; /* strøm tid På dette punktet */
Serial.print ( F ( 'Med spylefunksjon tar det' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Utskrifter tid tatt av seriell buffer for å skrive ut data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
ugyldig sløyfe ( ) {
}


Denne koden ligner på en vi forklarte tidligere. Forskjellen her er Serial.flush()-funksjonen som lar programmet vente litt ekstra tid til det serielle bufferminnet blir klart for mottak av neste data.


I utdata kan vi tydelig se at denne gangen tar det 76 ms å skrive ut de tre strengene sammenlignet med den forrige som bare tar 9 ms.

2: Fjern seriell buffer ved å bruke Serial.begin()-funksjonen

Inntil nå har vi forklart funksjonen Serial.flush() for å tømme den serielle bufferen, men denne funksjonen må vente på at dataene skal overføres fullstendig. Svaret på spørsmålet er enkelt: vi kan gjøre dette ved å bruke en samtidig som sløyfe med funksjonen Serial Library.

Syntaks

samtidig som ( Seriell.tilgjengelig ( ) )
Serial.read ( ) ;
Serial.end ( ) ;
Serial.begin ( 9600 ) ;

Kode

streng val;
ugyldig oppsett ( ) {
}
ugyldig sløyfe ( ) {
hvis ( Seriell.tilgjengelig ( ) ) { /* kryss av til seriedata */
val = '' ;
samtidig som ( Seriell.tilgjengelig ( ) ) { /* lese seriedata hvis tilgjengelig */
røye Serial_Data = Serial.read ( ) ;
val =val+Serial_Data; /* lagre data i ny streng */
}
Serial.println ( val ) ; /* skrive ut lese data */
Serial.end ( ) ; /* avslutte seriell kommunikasjon */
Serial.begin ( 9600 ) ; /* klar seriell buffer */
}
}


Arduino bruker Serial.begin()-funksjoner for å initialisere seriell kommunikasjon ved å definere overføringshastighet, når denne funksjonen er initialisert, blir dataene som tidligere er lagret i Arduino-minnet klare. Her vil vi se etter seriedata ved å bruke Serial.available()-funksjonen når dataene er lest, vil de lagre i en ny streng og til slutt ved å bruke Serial.begin(9600) vil vi tømme Arduino seriebuffer.

Merk: Vi må tømme den serielle bufferen fordi den sikrer at data er sendt til enheten og bare ikke venter eller er på vent for å bli sendt.

Konklusjon

For å tømme Arduino-seriebufferen slik at den kan lagre nye data i bufferminnet, kan Serial.flush() og Serial begin brukes. Den kan brukes til å tømme Arduino-seriebufferen, men vi må vente når alle data er overført for å unngå dette, vi kan bruke en while-løkke med Serial.begin()-funksjonen som også kan slette innkommende data fra den serielle bufferen.