Arduino is een elektronisch platform dat instructies van gebruikers opneemt in de vorm van code die bekend staat als sketch en dienovereenkomstig output genereert. Om de instructies te verzamelen en één voor één te verwerken, gebruikt de Arduino een seriële buffer. De seriële buffer van Arduino houdt de binnenkomende gegevens vast totdat het apparaat klaar is om ze te verwerken. Soms moeten we de seriële buffer van de Arduino wissen om interferentie met inkomende gegevens te voorkomen. Laten we dit in meer detail bekijken.
Arduino Seriële Buffer
We weten dus allemaal dat Arduino communiceert via het seriële communicatieprotocol dat bekend staat als USART. Ja, Arduino heeft een aantal andere protocollen zoals SPI, I2C, maar USART is het meest voorkomende en meest gebruikte protocol. Als je interesse hebt om alle drie de protocollen Arduino te lezen, klik dan op hier .
Arduino seriële buffers verzamelen de binnenkomende seriële karakters en houden ze vast totdat de microcontroller ze kan verwerken. Seriële communicatie is de methode om gegevens van het ene apparaat naar het andere over te dragen. Arduino met behulp van USART-hardware op zijn borden assembleert elke 8 bits in een byte. Sla deze bytes vervolgens op in de seriële buffer, maximaal 64 bytes kunnen worden opgeslagen in de seriële buffer van Arduino.
Arduino seriële buffer wissen
Arduino seriële buffers hebben een beperkt geheugen om gegevens op te slaan in het geval dat als het geheugen overloopt of als er een grote hoeveelheid gegevens aanwezig is op de seriële pin, we eerst de seriële buffer moeten wissen om binnenkomende gegevens op te slaan. Laten we eens kijken naar mogelijke manieren om de seriële buffer van Arduino te wissen.
Manieren om de seriële buffer van Arduino te wissen
Om seriële bufferruimte vrij te maken zodat deze kan worden bijgewerkt met nieuwe gegevens, kan het volgende van de twee manieren nuttig zijn:
-
- Seriële buffer wissen met de functie Serial.flush()
- Seriële buffer wissen met de functie Serial.begin()
1: Wis de seriële buffer met de functie Serial.flush()
De eerste methode die een seriële buffer van Arduino kan wissen, is dus het gebruik van een Serial.flush()-functie. Deze functie behoort tot de Arduino seriële bibliotheekfunctie.
Seriële.flush()
Arduino Serial.flush()-functie wacht tot de gegevens volledig zijn verzonden. In plaats van de binnenkomende gegevens weg te gooien, kan het wachten, dus zodra de gegevens in de buffer volledig zijn verzonden, kan de seriële buffer de nieuwe gegevens ontvangen.
Opmerking : Na gebruik van Serial.flush() kan het langer duren voordat programma's zijn uitgevoerd en afgedrukt op de seriële monitor. Vanaf nu wacht de Arduino-code zodra alle gegevens zijn verzonden, zodat deze nieuwe gegevens in het geheugen kan opslaan.
Syntaxis
Seriële.flush ( )
Parameters:
Er is slechts één parameter nodig.
Serieel: Seriële poortobject
Geeft terug
Deze functie retourneert niets.
Voorbeeldcode:
Hier is de code die is geschreven zonder de functie Serial.flush() te gebruiken:
ongeldige setup ( ) {Serieel.begin ( 9600 ) ;
unsigned lang millis_FlushStart = millis ( ) ; /* Start code door de huidige Arduino-klok op te slaan tijd */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/zelfstudie' ) ) ;
unsigned lang millis_FlushStop = millis ( ) ; /* huidig tijd op dit punt */
Serieafdruk ( F ( 'Zonder spoelfunctie duurt het' ) ) ;
Serieafdruk ( millis_FlushStop - millis_FlushStart ) ; /* Afdrukken tijd genomen door seriële buffer om gegevens af te drukken */
Serial.println ( F ( 'milliseconden.' ) ) ;
}
lege lus ( ) {
}
In de bovenstaande code hebben we drie verschillende strings geïnitialiseerd en de code gestart door de huidige tijd van de millis()-functie te nemen en deze op te slaan in een nieuwe variabele. Zodra de gegevens opnieuw zijn afgedrukt met de functie millis() geven we de huidige tijd door aan een nieuwe variabele.
Zodra beide tijd binnen twee variabelen is ontvangen, geeft het verschil ons de tijd die Arduino nodig heeft om de drie gedefinieerde strings in milliseconden af te drukken.
In de uitgangsterminal is te zien dat het 9 ms duurt om de gedefinieerde string af te drukken.
Nu zullen we in de onderstaande code de functie Serial.flush() gebruiken waarmee alle strings kunnen passeren en daar wachten totdat de seriële buffer vrij wordt om de volgende gegevens te ontvangen. Daarom kost het extra tijd in vergelijking met het afdrukken van gegevens zonder Serial.flush().
Serieel.begin ( 9600 ) ;
unsigned lang millis_FlushStart = millis ( ) ; /* Start code door de huidige Arduino-klok op te slaan tijd */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/zelfstudie' ) ) ;
Seriële.flush ( ) ; /* wacht voor gegevens die moeten worden verzonden na dat geheugen leegmaken */
unsigned lang millis_FlushStop = millis ( ) ; /* huidig tijd op dit punt */
Serieafdruk ( F ( 'Met spoelfunctie duurt het ' ) ) ;
Serieafdruk ( millis_FlushStop - millis_FlushStart ) ; /* Afdrukken tijd genomen door seriële buffer om gegevens af te drukken */
Serial.println ( F ( 'milliseconden.' ) ) ;
}
lege lus ( ) {
}
Deze code is vergelijkbaar met een code die we eerder hebben uitgelegd. Het verschil hier is de functie Serial.flush() waarmee het programma wat extra tijd kan wachten totdat het seriële buffergeheugen vrij wordt voor het ontvangen van de volgende gegevens.
In de uitvoer kunnen we duidelijk zien dat het deze keer 76 ms kost om de drie strings af te drukken in vergelijking met de vorige die slechts 9 ms duurt.
2: Wis de seriële buffer met de functie Serial.begin()
Tot nu toe hebben we de functie Serial.flush() uitgelegd om de seriële buffer te wissen, maar deze functie moet wachten tot de gegevens volledig zijn verzonden, nu komen de vragen bij me op wat als we de binnenkomende gegevens in de seriële buffer willen wissen. Het antwoord op de vraag is simpel: we kunnen dit doen met a terwijl loop met de seriële bibliotheekfunctie.
Syntaxis
terwijl ( Serieel.beschikbaar ( ) )
Serieel.lezen ( ) ;
Serieel.einde ( ) ;
Serieel.begin ( 9600 ) ;
Code
String waarde;
ongeldige setup ( ) {
}
lege lus ( ) {
als ( Serieel.beschikbaar ( ) ) { /* controleren voor seriële gegevens */
val = '' ;
terwijl ( Serieel.beschikbaar ( ) ) { /* lezen seriële gegevens als verkrijgbaar */
char Seriële_gegevens = Serieel.lezen ( ) ;
val =val+Seriële_Data; /* gegevens opslaan in nieuwe tekenreeks */
}
Serial.println ( val ) ; /* print de lezen gegevens */
Serieel.einde ( ) ; /* seriële communicatie beëindigen */
Serieel.begin ( 9600 ) ; /* Doorzichtig seriële buffer */
}
}
Arduino gebruikt Serial.begin()-functies om seriële communicatie te initialiseren door de baudrate te definiëren. Zodra deze functie is geïnitialiseerd, worden de gegevens die eerder in het Arduino-geheugen waren opgeslagen, duidelijk. Hier zullen we de seriële gegevens controleren met behulp van de functie Serial.available() zodra de gegevens zijn gelezen, worden deze opgeslagen in een nieuwe reeks en ten slotte zullen we met Serial.begin (9600) de seriële buffer van Arduino wissen.
Opmerking: We moeten de seriële buffer leegmaken omdat deze ervoor zorgt dat gegevens naar het apparaat zijn verzonden en niet wachten of in de wacht staan om te worden verzonden.
Conclusie
Om de seriële buffer van de Arduino te wissen, zodat deze nieuwe gegevens in het buffergeheugen kan opslaan, kunnen Serial.flush() en Serial begin worden gebruikt. Het kan worden gebruikt om de seriële buffer van Arduino te wissen, maar we moeten wachten zodra alle gegevens zijn verzonden om dit te voorkomen. We kunnen een while-lus gebruiken met de functie Serial.begin() die ook inkomende gegevens uit de seriële buffer kan wissen.