Sådan rydder du Arduino Serial Buffer

Sadan Rydder Du Arduino Serial Buffer



Arduino er en elektronisk platform, der tager instruktioner fra brugere i form af kode kendt som sketch og genererer output i overensstemmelse hermed. For at indsamle instruktionerne og behandle dem én efter én, bruger Arduino en seriel buffer. Arduino-seriebufferen gemmer de indgående data, indtil enheden er klar til at behandle dem. Nogle gange er vi nødt til at rydde Arduinos serielle buffer for at undgå interferens med indgående data. Lad os se dette mere detaljeret.

Arduino seriel buffer

Så vi ved alle, at Arduino kommunikerer ved hjælp af seriel kommunikationsprotokol kendt som USART. Ja, Arduino har nogle andre protokoller som SPI, I2C, men USART er den mest almindelige og hyppigt brugte protokol. Hvis du har interesse i at læse Arduino alle tre protokoller, skal du klikke her .







Arduino serielle buffere samler de indkommende serielle tegn og holder dem, indtil mikrocontrolleren kan behandle dem. Seriel kommunikation er metoden til at overføre data fra en enhed til en anden. Arduino, der bruger USART-hardware på sine boards, samler hver 8 bit til en byte. Gem derefter disse bytes i den serielle buffer, maksimalt 64 bytes kan gemmes inde i den serielle Arduino-buffer.



Klar Arduino seriel buffer

Arduino serielle buffere har begrænset hukommelse til at gemme data i tilfælde af, at hvis hukommelsen løber over eller store mængder data er der ved den serielle pin, skal vi først rydde den serielle buffer for at gemme indgående data. Lad os finde ud af mulige måder at rydde Arduino-seriebufferen på.



Måder at rydde Arduino Serial Buffer

For at frigøre seriel bufferplads, så den kan opdateres med nye data, kan følgende af de to måder være nyttigt:





    • Ryd seriel buffer ved hjælp af Serial.flush()-funktionen
    • Ryd seriel buffer ved hjælp af Serial.begin() funktionen

1: Ryd seriel buffer ved hjælp af Serial.flush()-funktionen

Så den første metode, der kan rydde en Arduino seriel buffer, er at bruge en Serial.flush() funktion. Denne funktion hører til Arduinos serielle biblioteksfunktion.

Serial.flush()

Funktionen Arduino Serial.flush() venter på, at dataene bliver transmitteret fuldstændigt. I stedet for at kassere de indgående data, tillader den den at vente, så når først dataene inde i bufferen er transmitteret fuldstændigt, kan den serielle buffer modtage de nye data.



Bemærk : Efter brug af Serial.flush()-programmer kan det tage længere tid at udføre og udskrive output på seriel monitor. Fra nu af venter Arduino-koden, når alle data er transmitteret, så den kan gemme nye data i sin hukommelse.

Syntaks

Serial.flush ( )

Parametre

Det kræver kun én parameter.

Serie: Seriel port objekt

Vender tilbage

Denne funktion returnerer intet.

Eksempel kode

Her er koden, som er skrevet uden at bruge Serial.flush()-funktionen:

ugyldig opsætning ( ) {
Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Start koden ved at gemme det aktuelle Arduino-ur tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
unsigned long millis_FlushStop = millis ( ) ; /* nuværende tid på dette tidspunkt */
Seriel.print ( F ( 'Uden skyllefunktion tager det' ) ) ;
Seriel.print ( millis_FlushStop - millis_FlushStart ) ; /* Udskrifter tid taget af seriel buffer for at udskrive data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
ugyldig løkke ( ) {
}


I ovenstående kode initialiserede vi tre forskellige strenge og startede koden ved at tage den aktuelle tid fra funktionen millis() og gemme den i en ny variabel. Når dataene er udskrevet igen ved hjælp af funktionen millis() overfører vi den nuværende tid til en ny variabel.

Når begge tider er modtaget inde i to variable, vil forskellen give os den tid, det tager Arduino at udskrive de tre definerede strenge i millisekunder.


I udgangsterminalen kan det ses, at det tager 9ms at udskrive den definerede streng.


Nu i koden nedenfor vil vi bruge Serial.flush()-funktionen, som vil tillade alle strengene at passere og vente der, indtil den serielle buffer bliver klar for at modtage de næste data. Derfor vil det tage ekstra tid sammenlignet med at udskrive data uden at bruge Serial.flush().

ugyldig opsætning ( ) {
Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Start koden ved at gemme det aktuelle Arduino-ur tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
Serial.flush ( ) ; /* Venter til data, der skal transmitteres efter den skyllede hukommelse */
unsigned long millis_FlushStop = millis ( ) ; /* nuværende tid på dette tidspunkt */
Seriel.print ( F ( 'Med skyllefunktion tager det' ) ) ;
Seriel.print ( millis_FlushStop - millis_FlushStart ) ; /* Udskrifter tid taget af seriel buffer for at udskrive data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
ugyldig løkke ( ) {
}


Denne kode ligner en, vi forklarede tidligere. Forskellen her er Serial.flush()-funktionen, som tillader programmet at vente noget ekstra tid, indtil seriel bufferhukommelse bliver fri til modtagelse af næste data.


I output kan vi tydeligt se, at denne gang tager det 76 ms at udskrive de tre strenge sammenlignet med den forrige, som kun tager 9 ms.

2: Ryd seriel buffer ved hjælp af Serial.begin()-funktionen

Indtil nu har vi forklaret funktionen Serial.flush() for at rydde den serielle buffer, men denne funktion skal vente på, at dataene bliver transmitteret fuldstændigt, nu kommer spørgsmålene til at tænke på, hvad hvis vi vil rydde de indkommende data inde i den serielle buffer. Svaret på spørgsmålet er enkelt: vi kan gøre dette ved at bruge en mens loop med seriel biblioteksfunktion.

Syntaks

mens ( Seriel.tilgængelig ( ) )
Serial.read ( ) ;
Serial.end ( ) ;
Serial.begin ( 9600 ) ;

Kode

streng val;
ugyldig opsætning ( ) {
}
ugyldig løkke ( ) {
hvis ( Seriel.tilgængelig ( ) ) { /* kontrollere til serielle data */
val = '' ;
mens ( Seriel.tilgængelig ( ) ) { /* Læs serielle data hvis ledig */
char Serial_Data = Serial.read ( ) ;
val =val+Serial_Data; /* gemme data i ny streng */
}
Serial.println ( val ) ; /* udskrive Læs data */
Serial.end ( ) ; /* afslutte seriel kommunikation */
Serial.begin ( 9600 ) ; /* klar seriel buffer */
}
}


Arduino bruger Serial.begin()-funktioner til at initialisere seriel kommunikation ved at definere baudhastigheden, når denne funktion er initialiseret, bliver dataene, der tidligere er gemt i Arduino-hukommelsen, klare. Her vil vi tjekke for de serielle data ved hjælp af Serial.available()-funktionen, når dataene er læst, vil de gemme i en ny streng, og til sidst vil vi ved hjælp af Serial.begin(9600) rydde Arduinos serielle buffer.

Bemærk: Vi er nødt til at tømme den serielle buffer, fordi den sikrer, at data er blevet sendt til enheden og bare ikke venter eller venter på at blive sendt.

Konklusion

For at rydde den serielle Arduino-buffer, så den kan gemme nye data i bufferhukommelsen, kan Serial.flush() og Serial begin bruges. Den kan bruges til at rydde den serielle Arduino-buffer, men vi er nødt til at vente, når alle data er transmitteret for at undgå dette, vi kan bruge en while-løkke med Serial.begin()-funktionen, som også kan slette indgående data fra den serielle buffer.