Arduino est une plate-forme électronique qui prend les instructions des utilisateurs sous la forme d'un code connu sous le nom de croquis et génère une sortie en conséquence. Pour collecter les instructions et les traiter une par une, l'Arduino utilise un tampon série. Le tampon série Arduino conserve les données entrantes jusqu'à ce que l'appareil soit prêt à les traiter. Parfois, nous devons effacer le tampon série Arduino pour éviter les interférences avec les données entrantes. Voyons cela plus en détail.
Tampon série Arduino
Ainsi, nous savons tous qu'Arduino communique en utilisant le protocole de communication série connu sous le nom d'USART. Oui, Arduino a d'autres protocoles comme SPI, I2C mais USART est le protocole le plus courant et le plus fréquemment utilisé. Si vous souhaitez lire les trois protocoles Arduino, cliquez sur ici .
Les tampons série Arduino collectent les caractères série entrants et les conservent jusqu'à ce que le microcontrôleur puisse les traiter. La communication série est la méthode de transfert de données d'un appareil à un autre. Arduino utilisant du matériel USART sur ses cartes assemble chaque 8 bits en un octet. Ensuite, stockez ces octets dans le tampon série, un maximum de 64 octets peut être stocké dans le tampon série Arduino.
Effacer le tampon série Arduino
Les tampons série Arduino ont une mémoire limitée pour stocker les données au cas où la mémoire déborde ou si une grande quantité de données se trouve sur la broche série, nous devons d'abord effacer le tampon série pour stocker les données entrantes. Découvrons les moyens possibles d'effacer le tampon série Arduino.
Façons d'effacer le tampon série Arduino
Pour libérer de l'espace tampon série afin qu'il puisse être mis à jour avec de nouvelles données, l'une des deux méthodes suivantes peut être utile :
-
- Effacer le tampon série à l'aide de la fonction Serial.flush()
- Effacer le tampon série à l'aide de la fonction Serial.begin()
1 : Effacer le tampon série à l'aide de la fonction Serial.flush()
Ainsi, la première méthode qui peut effacer un tampon série Arduino utilise une fonction Serial.flush(). Cette fonction appartient à la fonction de bibliothèque série Arduino.
Serial.flush()
La fonction Arduino Serial.flush() attend que les données soient complètement transmises. Plutôt que de rejeter les données entrantes, il lui permet d'attendre afin qu'une fois que les données à l'intérieur du tampon soient complètement transmises, le tampon série puisse recevoir les nouvelles données.
Noter : Après avoir utilisé Serial.flush(), les programmes peuvent prendre plus de temps pour s'exécuter et imprimer la sortie sur le moniteur série. À partir de maintenant, le code Arduino attend une fois que toutes les données sont transmises afin de pouvoir stocker de nouvelles données dans sa mémoire.
Syntaxe
Serial.flush ( )
Paramètres
Il ne prend qu'un seul paramètre.
En série: Objet port série
Retour
Cette fonction ne renvoie rien.
Exemple de code
Voici le code qui est écrit sans utiliser la fonction Serial.flush() :
void setup ( ) {Serial.begin ( 9600 ) ;
long non signé millis_FlushStart = millis ( ) ; /* Démarrer le code en enregistrant l'horloge Arduino actuelle temps */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutoriel' ) ) ;
long non signé millis_FlushStop = millis ( ) ; /* courant temps À ce point */
Serial.print ( F ( 'Sans Flush Function il faut' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Impressions temps pris par le tampon série pour imprimer les données */
Serial.println ( F ( « millisecondes ». ) ) ;
}
boucle vide ( ) {
}
Dans le code ci-dessus, nous avons initialisé trois chaînes différentes et démarré le code en prenant l'heure actuelle de la fonction millis() et en l'enregistrant dans une nouvelle variable. Une fois que les données sont imprimées à nouveau à l'aide de la fonction millis(), nous passons l'heure actuelle à une nouvelle variable.
Une fois que les deux temps sont reçus à l'intérieur de deux variables, la différence nous donnera le temps pris par Arduino pour imprimer les trois chaînes définies en millisecondes.
Dans le terminal de sortie, on peut voir qu'il faut 9 ms pour imprimer la chaîne définie.
Maintenant, dans le code ci-dessous, nous allons utiliser la fonction Serial.flush() qui permettra à toutes les chaînes de passer et d'attendre jusqu'à ce que le tampon série devienne clair pour recevoir les données suivantes. Par conséquent, cela prendra plus de temps que d'imprimer des données sans utiliser Serial.flush().
Serial.begin ( 9600 ) ;
long non signé millis_FlushStart = millis ( ) ; /* Démarrer le code en enregistrant l'horloge Arduino actuelle temps */
Serial.println ( F ( 'Linuxhint.com/Arduino' ) ) ;
Serial.println ( F ( 'Linuxhint.com/RaspberryPi' ) ) ;
Serial.println ( F ( 'Linuxhint.com/Tutoriel' ) ) ;
Serial.flush ( ) ; /* Attend pour données à transmettre après ce vidage de la mémoire */
long non signé millis_FlushStop = millis ( ) ; /* courant temps À ce point */
Serial.print ( F ( 'Avec la fonction Flush, il faut' ) ) ;
Serial.print ( millis_FlushStop - millis_FlushStart ) ; /* Impressions temps pris par le tampon série pour imprimer les données */
Serial.println ( F ( « millisecondes ». ) ) ;
}
boucle vide ( ) {
}
Ce code est similaire à celui que nous avons expliqué précédemment. La différence ici est la fonction Serial.flush() qui permet au programme d'attendre un peu plus de temps jusqu'à ce que la mémoire tampon série devienne libre pour recevoir les données suivantes.
En sortie, nous pouvons clairement voir que cette fois, il faut 76 ms pour imprimer les trois chaînes par rapport à la précédente qui ne prenait que 9 ms.
2 : Effacer le tampon série à l'aide de la fonction Serial.begin()
Jusqu'à présent, nous avons expliqué la fonction Serial.flush () pour effacer le tampon série, mais cette fonction doit attendre que les données soient complètement transmises, maintenant les questions viennent à l'esprit et si nous voulons effacer les données entrantes dans le tampon série. La réponse à la question est simple : nous pouvons le faire en utilisant un tandis que boucle avec la fonction de bibliothèque série.
Syntaxe
tandis que ( Série.disponible ( ) )
Serial.read ( ) ;
Serial.end ( ) ;
Serial.begin ( 9600 ) ;
Code
chaîne val;
void setup ( ) {
}
boucle vide ( ) {
si ( Série.disponible ( ) ) { /* Chèque pour données série */
val = '' ;
tandis que ( Série.disponible ( ) ) { /* lis données série si disponible */
carboniser Serial_Data = Serial.read ( ) ;
val =val+Serial_Data ; /* stocker des données dans une nouvelle chaîne */
}
Serial.println ( val ) ; /* imprimer le lis Les données */
Serial.end ( ) ; /* mettre fin à la communication série */
Serial.begin ( 9600 ) ; /* dégager tampon série */
}
}
Arduino utilise les fonctions Serial.begin() pour initialiser la communication série en définissant le débit en bauds, une fois cette fonction initialisée, les données précédemment stockées dans la mémoire Arduino deviennent claires. Ici, nous vérifierons les données série à l'aide de la fonction Serial.available () une fois les données lues, elles seront stockées dans une nouvelle chaîne et enfin, en utilisant Serial.begin (9600), nous effacerons le tampon série Arduino.
Noter: Nous devons vider le tampon série car il garantit que les données ont été envoyées à l'appareil et qu'elles n'attendent pas ou ne sont pas en attente d'être envoyées.
Conclusion
Pour effacer le tampon série Arduino afin qu'il puisse stocker de nouvelles données dans la mémoire tampon, Serial.flush() et Serial begin peuvent être utilisés. Il peut être utilisé pour effacer le tampon série Arduino, mais nous devons attendre une fois que toutes les données sont transmises pour éviter cela, nous pouvons utiliser une boucle while avec la fonction Serial.begin() qui peut également effacer les données entrantes du tampon série.