Comment la fonction temporelle fonctionne-t-elle dans Arduino?

Arduino prend en charge de nombreuses fonctions intégrées, parmi lesquelles, certaines sont liées au temps également connu sous le nom de fonctions temporelles. Ces fonctions sont utilisées pour générer un retard de temps dans le code Arduino. Par exemple, si nous voulons que la LED affiche la sortie à plusieurs reprises toutes les deux ou trois secondes, nous pouvons mettre un retard en utilisant les fonctions temporelles.

Dans cet article, nous discuterons de certaines des fonctions temporelles qui sont fréquemment utilisées dans le code Arduino à l'aide de quelques exemples.

Quelle est la fonction temporelle à Arduino

Les fonctions de temps dans Arduino sont utilisées pour créer des pauses dans la sortie en fonction de l'exigence, les fonctions temporelles importantes d'Arduino sont expliquées en détail.

retard(): C'est la fonction la plus couramment utilisée dans la programmation Arduino, il prend la valeur entière et génère le retard du délai de code de millisecondes en fonction de la valeur entière d'entrée. Pour comprendre l'application de la fonction de retard (), considérez cet exemple:

int count = 2;
void setup()
En série.commencer (9600);

VOID LOOP ()
En série.print ("La valeur est imprimée après");
En série.imprimer (count);
En série.println ("secondes");
count = count + 2;
Retard (2000);

Dans ce code, nous imprimons «la valeur est imprimée après (temps) secondes». La logique derrière le code est très simple, nous avons déclaré une variable globale «count = 2», puis nous nous sommes connectés à Arduino en utilisant la communication en série à un taux de boude de 9600. Ensuite, dans la boucle vide (), nous avons imprimé la sortie après le retard de 2000 millisecondes, ce qui est égal à 2 secondes (1 seconde = 1000 millisecondes). Et augmentent également la valeur du nombre de 2.

DelayMicRosecondes (): Cette fonction fonctionne de manière similaire à la fonction de retard (), mais au lieu de millisecondes, elle génère le retard en microsecondes. Considérons le code ci-dessus et remplaçons la fonction de retard () par deltMicRoseconds ():

int count = 100;
void setup()
En série.commencer (9600);

VOID LOOP ()
En série.print ("La valeur est imprimée après");
En série.imprimer (count);
En série.println ("microsecondes");
Count = Count + 100;
DelayMicrosecondes (100);

Dans la sortie ci-dessus, nous avons imprimé l'instruction en utilisant la fonction de retardmicroseconds () et spécifié le retard de 100 microsecondes. Pour afficher la sortie sur la sortie du moniteur série, nous avons utilisé la communication série à un taux de 9600 en bauds. Le nombre de variables est déclaré globalement avec une valeur de 100 et dans Void Loop (), nous avons augmenté sa valeur de 100 après chaque itération.

milli(): La fonction Milli () est utilisée pour découvrir le temps d'exécution en millisecondes jusqu'à l'instruction Milli (). Pour comprendre cela, nous considérerons un exemple simple du code suivant:

int timr;
void setup()
En série.commencer (9600);

VOID LOOP ()
Retard (2000);
En série.print ("La valeur du temps est");
Timr = Millis ();
En série.println (timr);

Sur l'exécution réussie du code, nous obtenons le temps d'exécution de chaque itération dans la sortie. Nous avons mis un retard de 2000 millisecondes en utilisant la fonction de retard () et extrait le temps d'exécution en millisecondes en utilisant la fonction Millis (). La valeur renvoyée par la fonction Millis () est stockée dans la variable TIMR et affichée sur la sortie du moniteur en série.

Note: Il y a une différence dans la sortie car quelques millisecondes sont prises par la «série.Println () ”Fonction et un certain temps est pris par le matériel.

micro (): Cette fonction est utilisée pour calculer et extraire le temps d'exécution du code jusqu'à l'exécution de cette fonction. Par exemple, nous écrivons un code simple, dans lequel nous mettons le retard de 2000 millisecondes en utilisant la fonction de retard (), et calculons l'heure en microsecondes à l'aide du code:

int timr;
void setup()
En série.commencer (9600);

VOID LOOP ()
Retard (2000);
En série.print ("La valeur du temps est");
Timr = micros ();
En série.println (timr);

Le script ci-dessus est simple à comprendre. Nous avons connecté Arduino à l'ordinateur en utilisant la communication série à un taux en bauds de 9600. Dans la boucle vide (), nous avons généré un retard de 2000 millisecondes à l'aide de la fonction de retard (), extraire le temps d'exécution en microsecondes à l'aide de la fonction micros (), stocker les résultats dans la variable «TIMR» et l'a imprimée en série surveiller la sortie.

Conclusion

Dans Arduino, les fonctions temporelles sont utilisées pour générer les retards et les pauses dans le code ou la sortie. Nous pouvons utiliser ces fonctions temporelles pour générer ou faire une pause dans le clignotement des LED. Nous pouvons également trouver le temps d'exécution du code en utilisant les fonctions temporelles. Dans cet article, nous avons expliqué les fonctions temporelles les plus couramment utilisées à Arduino et les avons expliquées avec quelques exemples simples.