Arduino är en elektronisk plattform som tar instruktioner från användare i form av kod känd som sketch och genererar utdata därefter. För att samla in instruktionerna och bearbeta dem en efter en använder Arduino en seriell buffert. Arduinos seriella buffert lagrar inkommande data tills enheten är redo att behandla dem. Ibland måste vi rensa Arduinos seriella buffert för att undvika störningar med inkommande data. Låt oss se detta mer i detalj.
Arduino seriell buffert
Så vi vet alla att Arduino kommunicerar med ett seriellt kommunikationsprotokoll känt som USART. Ja, Arduino har några andra protokoll som SPI, I2C men USART är det vanligaste och mest använda protokollet. Om du är intresserad av att läsa Arduino alla tre protokollen, klicka här .
Arduinos seriella buffertar samlar in de inkommande seriella tecknen och håller dem tills mikrokontrollern kan bearbeta dem. Seriell kommunikation är metoden för att överföra data från en enhet till en annan. Arduino som använder USART-hårdvara på sina kort samlar var 8 bitar till en byte. Lagra sedan dessa byte i den seriella bufferten, maximalt 64 byte kan lagras inuti Arduinos seriella buffert.
Rensa Arduino seriell buffert
Arduinos seriella buffertar har begränsat minne för att lagra data i det fall om minnet svämmar över eller stora mängder data finns vid seriestiftet, måste vi rensa den seriella bufferten först för att lagra inkommande data. Låt oss ta reda på möjliga sätt att rensa Arduinos seriella buffert.
Sätt att rensa Arduino Serial Buffer
För att frigöra seriellt buffertutrymme så att det kan uppdateras med ny data kan följande av två sätt vara till hjälp:
-
- Rensa seriell buffert med Serial.flush()-funktionen
- Rensa seriell buffert med Serial.begin()-funktionen
1: Rensa seriell buffert med Serial.flush()-funktionen
Så, den första metoden som kan rensa en Arduino seriell buffert är att använda en Serial.flush() funktion. Denna funktion tillhör Arduinos seriella biblioteksfunktion.
Serial.flush()
Arduino Serial.flush()-funktionen väntar på att data överförs fullständigt. Istället för att kassera inkommande data låter den den vänta så när data inuti bufferten har överförts fullständigt kan den seriella bufferten ta emot den nya datan.
Notera : Efter att ha använt Serial.flush()-program kan det ta längre tid att köra och skriva ut utdata på seriell monitor. Från och med nu väntar Arduino-koden när all data har överförts så att den kan lagra ny data i sitt minne.
Syntax
Serial.flush ( )
Parametrar
Det tar bara en parameter.
Serie: Serieportobjekt
Returnerar
Denna funktion returnerar ingenting.
Exempelkod
Här är koden som är skriven utan att använda Serial.flush()-funktionen:
ogiltig installation ( ) {Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Starta koden genom att spara aktuell Arduino-klocka tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
unsigned long millis_FlushStop = millis ( ) ; /* nuvarande tid vid denna tidpunkt */
Serial.print ( F ( 'Utan spolningsfunktion krävs' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Grafik tid tas av seriell buffert för att skriva ut data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
tom slinga ( ) {
}
I ovanstående kod initierade vi tre olika strängar och startade koden genom att ta den aktuella tiden från funktionen millis() och spara den i en ny variabel. När data skrivs ut igen med funktionen millis() skickar vi den nuvarande tiden till en ny variabel.
När båda tiderna väl har tagits emot i två variabler kommer skillnaden att ge oss den tid det tar för Arduino att skriva ut de tre definierade strängarna i millisekunder.
I utgångsterminalen kan det ses att det tar 9ms att skriva ut den definierade strängen.
Nu i koden nedan kommer vi att använda funktionen Serial.flush() som låter alla strängar passera och väntar där tills den seriella bufferten blir klar för att ta emot nästa data. Därför kommer det att ta extra tid jämfört med att skriva ut data utan att använda Serial.flush().
Serial.begin ( 9600 ) ;
unsigned long millis_FlushStart = millis ( ) ; /* Starta koden genom att spara aktuell Arduino-klocka tid */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutorial' ) ) ;
Serial.flush ( ) ; /* Väntar för data som ska överföras efter det tömningsminnet */
unsigned long millis_FlushStop = millis ( ) ; /* nuvarande tid vid denna tidpunkt */
Serial.print ( F ( 'Med spolningsfunktion krävs det' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Grafik tid tas av seriell buffert för att skriva ut data */
Serial.println ( F ( 'millisekunder.' ) ) ;
}
tom slinga ( ) {
}
Den här koden liknar en vi förklarade tidigare. Skillnaden här är Serial.flush()-funktionen som låter programmet vänta en extra tid tills det seriella buffertminnet blir klart för att ta emot nästa data.
I output kan vi tydligt se att den här gången tar det 76ms att skriva ut de tre strängarna jämfört med den föregående som bara tar 9ms.
2: Rensa seriell buffert med Serial.begin()-funktionen
Hittills har vi förklarat funktionen Serial.flush() för att rensa den seriella bufferten men den här funktionen måste vänta på att data ska överföras helt nu kommer frågorna att tänka på vad händer om vi vill rensa inkommande data i den seriella bufferten. Svaret på frågan är enkelt: vi kan göra detta med hjälp av en medan loop med funktionen Serial library.
Syntax
medan ( Serial.available ( ) )
Serial.read ( ) ;
Serial.end ( ) ;
Serial.begin ( 9600 ) ;
Koda
String val;
ogiltig installation ( ) {
}
tom slinga ( ) {
om ( Serial.available ( ) ) { /* kolla upp för seriella data */
val = '' ;
medan ( Serial.available ( ) ) { /* läsa seriella data om tillgängligt */
röding Serial_Data = Serial.read ( ) ;
val =val+Serial_Data; /* lagra data i en ny sträng */
}
Serial.println ( val ) ; /* skriv ut läsa data */
Serial.end ( ) ; /* avsluta seriell kommunikation */
Serial.begin ( 9600 ) ; /* klar seriell buffert */
}
}
Arduino använder Serial.begin()-funktioner för att initiera seriell kommunikation genom att definiera överföringshastigheten, när denna funktion har initierats blir data som tidigare lagrats i Arduino-minnet tydliga. Här kommer vi att leta efter seriella data med hjälp av Serial.available()-funktionen när informationen är läst kommer den att lagras i en ny sträng och slutligen med Serial.begin(9600) rensar vi Arduinos seriella buffert.
Notera: Vi måste spola den seriella bufferten eftersom den säkerställer att data har skickats till enheten och bara inte väntar eller väntar på att skickas.
Slutsats
För att rensa Arduinos seriella buffert så att den kan lagra ny data i buffertminnet kan Serial.flush() och Serial begin användas. Den kan användas för att rensa Arduinos seriella buffert, men vi måste vänta när all data har sänts för att undvika detta, vi kan använda en while-loop med Serial.begin()-funktionen som också kan rensa inkommande data från den seriella bufferten.