Comment effacer le tampon de série Arduino
Arduino est une plate-forme électronique qui prend les instructions des utilisateurs sous forme de code connu sous le nom de Sketch et génère la sortie en conséquence. Pour collecter les instructions et les traiter un par un, l'Arduino utilise un tampon série. Le tampon de série Arduino contient 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 que Arduino communique à l'aide d'un protocole de communication série connue sous le nom de USART. Oui, Arduino a d'autres protocoles comme SPI, I2C mais Usart est le protocole le plus courant et le plus utilisé. Si vous avez un intérêt à lire Arduino les trois protocoles, cliquez ici.
Les tampons de série Arduino collectent les caractères en série entrants et les maintiennent 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 planches se rassemble chaque 8 bits dans un octet. Ensuite, stockez ces octets dans le tampon série, le maximum de 64 octets peut être stocké à l'intérieur du tampon série Arduino.
Tampon de série Arduino clair
Les tampons de série Arduino ont une mémoire limitée pour stocker des données dans le cas où la mémoire déborde ou une grande quantité de données est là à la broche série, nous devons d'abord effacer le tampon de série pour stocker des données entrantes. Découvrons les moyens possibles de nettoyer le tampon série Arduino.
Façons de nettoyer le tampon de série Arduino
Pour libérer de l'espace de tampon série afin qu'il puisse être mis à jour avec de nouvelles données après les deux façons peut être utile:
-
- Effacer le tampon de série à l'aide de la série.Fonction Flush ()
- Effacer le tampon de série à l'aide de la série.Fonction Begin ()
1: Effacer le tampon série à l'aide de série.Fonction Flush ()
Ainsi, la première méthode qui peut effacer un tampon de série Arduino utilise une série.Fonction Flush (). Cette fonction appartient à la fonction de bibliothèque série Arduino.
En série.affleurer()
Arduino Serial.La fonction flush () attend que les données soient complètement transmises. Plutôt que de jeter les données entrantes, elle lui permet d'attendre donc une fois que les données à l'intérieur du tampon sont complètement transmises, le tampon série peut recevoir les nouvelles données.
Note: Après avoir utilisé de la série.Les programmes Flush () peuvent prendre plus de temps pour exécuter et imprimer la sortie sur le moniteur en série. À partir de maintenant, le code Arduino attend une fois que toutes les données sont transmises afin qu'elles puissent stocker de nouvelles données dans sa mémoire.
Syntaxe
En série.affleurer()
Paramètres
Il ne prend qu'un seul paramètre.
En série: Objet de port série
Retour
Cette fonction ne renvoie rien.
Exemple de code
Voici le code qui est écrit sans utiliser de série.Fonction Flush ():
void setup()
En série.commencer (9600);
Long Millis_flushStart non signé = unsignet (); / * Démarrer le code en enregistrant le temps de l'horloge Arduino actuel * /
En série.println (f ("Linuxhint.com / arduino "));
En série.println (f ("Linuxhint.com / raspberrypi "));
En série.println (f ("Linuxhint.com / tutoriel "));
Long Millis_flushStop = Millis (); / * Heure actuelle à ce stade * /
En série.print (f ("Sans Flush Fonction il prend"));
En série.print (Millis_FlushStop - Millis_FlushStart); / * Imprime le temps pris par tampon série pour imprimer les données * /
En série.println (f ("millisecondes."));
VOID LOOP ()
Dans le code ci-dessus, nous avons initialisé trois chaînes différentes et commencé le code en prenant le temps actuel de la fonction Millis () et en l'enregistrant dans une nouvelle variable. Une fois les données à nouveau imprimées à l'aide de la fonction Millis (), nous passons le temps actuel à une nouvelle variable.
Une fois que les deux temps 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 la borne de sortie, il peut être vu qu'il faut 9 ms pour imprimer la chaîne définie.
Maintenant, dans le code ci-dessous, nous utiliserons la série.Fonction flush () qui permettra à toutes les chaînes de passer et d'attendre là que le tampon série devient clair pour recevoir les données suivantes. Par conséquent, cela prendra plus de temps par rapport aux données d'impression sans utiliser de série.affleurer().
void setup()
En série.commencer (9600);
Long Millis_flushStart non signé = unsignet (); / * Démarrer le code en enregistrant le temps de l'horloge Arduino actuel * /
En série.println (f ("Linuxhint.com / arduino "));
En série.println (f ("Linuxhint.com / raspberrypi "));
En série.println (f ("Linuxhint.com / tutoriel "));
En série.affleurer(); / * Attend que les données soient transmises après cette mémoire rinçante * /
Long Millis_flushStop = Millis (); / * Heure actuelle à ce stade * /
En série.print (f ("avec la fonction de rinçage qu'il prend"));
En série.print (Millis_FlushStop - Millis_FlushStart); / * Imprime le temps pris par tampon série pour imprimer les données * /
En série.println (f ("millisecondes."));
VOID LOOP ()
Ce code est similaire à celui que nous avons expliqué plus tôt. La différence ici est la série.Fonction Flush () qui permet au programme d'attendre un peu de temps supplémentaire jusqu'à ce que la mémoire de tampon série devienne claire pour recevoir des 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 prend que 9 ms seulement.
2: Effacer le tampon série à l'aide de série.Fonction Begin ()
Jusqu'à présent, nous expliquons la série de fonction.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 que 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 alors que boucle avec la fonction de bibliothèque série.
Syntaxe
Pendant que (série.disponible())
En série.lire();
En série.fin();
En série.commencer (9600);
Code
String Val;
void setup()
VOID LOOP ()
si (série.Disponible ()) / * Vérifiez les données série * /
val = "";
Pendant que (série.Disponible ()) / * Lire les données série si disponibles * /
char série_data = série.lire();
val = val + serial_data; / * stocker des données à l'intérieur de la nouvelle chaîne * /
En série.println (val); / * Imprimez les données de lecture * /
En série.fin(); / * terminer la communication série * /
En série.commencer (9600); / * Effacer le tampon série * /
Arduino utilise la série.Begin () Fonctions pour initialiser la communication série en définissant le taux de 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 série.Fonction disponible () Une fois les données lues, elle se stockera à l'intérieur d'une nouvelle chaîne et enfin à l'aide de série.Begin (9600) Nous effacerons le tampon série Arduino.
Note: Nous devons rincer le tampon série car il garantit que les données ont été envoyées à l'appareil et n'attend tout simplement pas ou en attente pour être envoyée.
Conclusion
Pour effacer le tampon série Arduino afin qu'il puisse stocker de nouvelles données dans la série de mémoire tampon.Flush () et Serial Begin peuvent être utilisés. Il peut être utilisé pour effacer le tampon de 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 série.Fonction begin () qui peut également effacer les données entrantes du tampon série.