Arduino Millis vs Delay
Quoi est la fonction Millis () dans Arduino?
Cette fonction donne le temps total à partir de l'exécution du code Arduino et continuera d'exécuter jusqu'à ce que le programme fonctionne. De même, cette fonction donne le temps écoulé en millisecondes et a la capacité de fonctionner pendant 50 jours après cela, cette fonction réinitialise sa valeur à zéro et recommencer à partir de.
La signification de cette fonction est qu'elle peut être utilisée dans le programme Arduino si une instruction doit fonctionner uniquement à un moment précis seulement. Pour plus d'illustration, nous avons expliqué le fonctionnement de la fonction Millis par l'exemple.
Supposons que nous devons exécuter une instruction après toutes les 5 secondes, donc nous avons d'abord défini l'heure en millisecondes, après quoi l'instruction spécifique s'exécutera.
UNSIGNED Long ExecutionTime = 5000;
Donc, nous définissons la variable constante nommée temps d'exécution Ayant une valeur de 5000 millisecondes puis pour vérifier l'heure actuelle du programme, nous utiliserons la fonction Millis et stockerons sa valeur dans le Temps présent variable.
un long temps présent non signé;
PresentTime = Millis ();
Ensuite, nous devons faire la condition du temps dans lequel l'instruction sera exécutée. Ainsi, nous créons une condition IF qui sera vraie lorsque la différence de présent et de temps passé atteint 5000 millisecondes et que l'instruction à l'intérieur de la condition IF exécutera. Pour de telles conditions, nous devons également déclarer une autre variable qui sauvera le temps précédent ou le temps passé.
Nous pouvons concevoir cette condition de telle manière que lorsque la différence du courant et du temps précédent est supérieure à l'égal au temps d'exécution, puis exécutez l'instruction suivante. Une fois l'instruction respective exécutée, enregistrez cette heure actuelle dans la variable de passe-temps.
Pastime long non signé = 0;
if (présentTime STastTime> = ExecutionTime)
// exécute l'instruction
PASTTIME = CurrentTime;
Ici, une chose est à rappeler que nous avons utilisé le long type de données en raison de la fonction Millis () car il a des valeurs considérablement importantes.
Code Arduino pour le fonctionnement de la fonction Millis ()
Le code complet pour comprendre le fonctionnement de la fonction Millis est donné comme:
const non signé à long terme = 5000; / * heure à laquelle l'instruction exécutera * /
non signé depuis longtemps = 0; // variable pour Strong le passé
Variable longue unsigned à longue date = 0; // pour stocker le temps actuel
void setup()
En série.commencer (9600); // initialisation de la communication série
VOID LOOP ()
PresentTime = Millis (); // Mise à jour de la valeur de l'heure actuelle
/ * C'est l'événement * /
if (actualtime - Pasttime> = ExecutionTime) / * condition du temps sur lequel l'instruction sera exécutée * /
En série.print ("L'heure actuelle est:");
En série.println (présent temps); // affichant le temps présent
En série.imprimer (""); // y compris l'espace
En série.print ("Instruction à exécuter:");
En série.println ("Bienvenue à Linuxhint"); // Instruction à exécuter
pastime = temps actuel; // mise à jour de la valeur du temps passé
Le code Arduino fonctionnera de telle manière que, par exemple, à première vue, la valeur du passe-temps est nul et disons que l'heure actuelle est de 400 millisecondes. Selon la condition IF, la réponse sera de 400, ce qui est inférieur à 5000 millisecondes, donc la condition IF sera fausse.
De même, dans la troisième ou la quatrième itération, le «temps actuel» est de 5000 millisecondes, alors la différence sera de 5000 millisecondes car la valeur du «pastime» est toujours nulle. Ainsi, l'instruction sera exécutée et la valeur du passe-temps sera mise à jour.
De cette façon, nous pouvons utiliser la fonction Millis pour exécuter une instruction spécifique à un moment précis.
Sortie du code Arduino pour Millis ()
Dans le moniteur en série, on peut clairement constater que lorsqu'il y a une différence de «temps actuel» et de «pastime» est 5000, alors la condition sera vraie. L'image publiée ci-dessous montre les valeurs du «temps actuel» auquel la condition IF est vraie et l'instruction qui doit être exécutée.
Si nous imprimons simplement la valeur de la fonction Millis () qui est stockée dans le nom de la variable «Presenttime» ressemblera à ceci comme dans l'image ci-dessous:
Qu'est-ce qu'une fonction de retard () dans Arduino
La fonction de retard () est principalement utilisée pour faire une pause du code Arduino pendant un certain temps. En d'autres termes, cette fonction crée un retard de quelque temps spécifié par l'utilisateur dans le fonctionnement du code Arduino.
Cette fonction peut être utilisée sur le programme où la valeur de toute variable doit être mise à jour fréquemment. Ainsi, en donnant la pause au programme Arduino, il donnera le temps au capteur de mettre à jour sa valeur.
De même, nous pouvons utiliser la fonction de retard pour donner une pause entre l'exécution de plusieurs instructions. La fonction de retard prend le temps en millisecondes car son entrée et la syntaxe de la fonction de retard sont données ci-dessous:
retard (temps en millisecondes);
Code arduino pour l'utilisation de la fonction de retard
Pour démontrer les fonctionnalités de la fonction de retard (), nous avons compilé un code Arduino qui est donné comme:
void setup()
En série.commencer (9600); // initialisation de la communication série
VOID LOOP ()
En série.imprimer ("bonjour et bienvenue"); // instruction avant le retard
retard (5000); // Création d'une pause de 5000 millisecondes
En série.println ("\ n à Linuxhint.com "); // instruction après retard
Dans le code Arduino, nous avons donné deux instructions qui imprimeront les données sur le moniteur en série. Les deux instructions sont exécutées avec un retard de 5000 millisecondes. En d'autres termes, après l'exécution de la première instruction, nous avons utilisé une fonction de retard qui suscitera le code Arduino pour 5000 millisecondes. Après 5000 millisecondes, le programme sera démarré à partir de l'endroit où il a été arrêté et la deuxième instruction sera exécutée.
Sortie du code Arduino pour l'utilisation de la fonction de retard ()
L'image publiée ci-dessous est la première instruction donnée avant l'utilisation de la fonction de retard ().
Après cette instruction, le programme est interrompu pendant 5000 millisecondes, puis l'exécution de la deuxième instruction a lieu. La figure ci-dessous montre que le programme a exécuté la deuxième instruction.
Comparaison de la fonction Millis () et Delay ()
Les différences entre le millis () et la fonction de retard sont données dans le tableau ci-dessous:
| Fonction Millis () | Fonction de retard () |
|---|---|
| Il peut être utilisé pour exécuter une instruction spécifique à un moment précis | Cette fonction crée simplement une pause dans le flux du code Arduino |
| Cette fonction donne le temps en millisecondes à partir du démarrage du code Arduino et peut augmenter pendant 50 jours | Cette fonction prend du temps en millisecondes en tant qu'entrée utilisateur et s'exécute pour cette période spécifique |
| Cette fonction ne fait pas en pause ou n'arrête pas le code | Cette fonction arrête l'ensemble du code pendant un certain temps |
Comment puis-je utiliser milis () au lieu de retard ()
Nous utilisons la fonction Millis au lieu de retard en utilisant simplement la condition IF pour le moment précis auquel nous voulons exécuter chaque instruction. Cela donnera automatiquement un retard entre l'exécution de deux instructions ou plus et le but du retard peut être servi. Le principal avantage pour utiliser le millis au lieu de retard est que l'ensemble du programme Arduino ne s'arrête pas; Seule l'exécution d'une certaine instruction est mise à l'arrêt. Cependant, la fonction de retard arrête l'ensemble du programme et l'utilisation de la fonction de retard peut manquer quelque peu les entrées externes du programme car l'ensemble du programme est arrêté.
Pour illustrer davantage, nous avons fourni un code Arduino sur la façon dont nous pouvons utiliser la fonction Millis au lieu de la fonction de retard:
const non signé à long terme = 6000; / * heure à laquelle la première instruction exécutera * /
Const non signé Long ExecutionTime1 = 2000; / * heure à laquelle la deuxième instruction exécutera * /
non signé longtemps pastime = 0; // variable pour fort le temps passé de la première instruction
Variable longue unsigned à longue durée = 0; // pour stocker le temps présent
non signé longtemps pasttime1 = 0; // variable pour fort le temps passé de la deuxième instruction
void setup()
En série.commencer (9600); // initialisation de la communication série
VOID LOOP ()
PresentTime = Millis (); // Mise à jour de la valeur de l'heure actuelle
/ * C'est l'événement * /
if (actualtime - Pasttime> = ExecutionTime) / * condition du temps sur lequel l'instruction sera exécutée * /
En série.print ("L'heure actuelle est:");
En série.println (présent temps); // affichant le temps présent
En série.imprimer (""); // y compris l'espace
En série.print ("Instruction à exécuter:");
En série.println ("Gardez les lumières éteintes"); // Instruction à exécuter
pastime = temps actuel; // mise à jour de la valeur du temps passé
if (actuel-temps - pasttime1> = exécutiontime1) / * condition du temps sur lequel l'instruction sera exécutée * /
En série.print ("L'heure actuelle");
En série.println (présent temps); // affichant le temps présent
En série.imprimer (""); // y compris l'espace
En série.print ("Instruction à exécuter:");
En série.println ("allumez les lumières"); // instruction à exécuter
pasttime1 = actuel; // Mise à jour du temps présent de l'instruction SCODN
Ici, dans le code, nous avons utilisé la fonction Millis pour exécuter les deux instructions avec un retard de près de 4 secondes. Nous avons publié une image de la sortie du code Arduino compilé pour expliquer comment la fonction Millis peut être utilisée en la remplaçant par la fonction de retard.
Dans la sortie, nous pouvons voir que lorsque le temps est de 2 secondes, la deuxième instruction est exécutée jusqu'à ce que le temps atteigne 6 secondes. Lorsque le temps atteint 6 secondes, la première instruction est exécutée.
Conclusion
Pour créer une logique de toute tâche qui doit être effectuée à l'aide d'Arduino, il existe plusieurs fonctions qui peuvent être utilisées. Ces fonctions rendent la fonctionnalité du code Arduino efficace et facile à implémenter la logique créée.Il y a deux fonctions dont nous avons discuté en détail, l'une est la fonction Millis et l'autre est la fonction de retard. La fonction Millis exécute une instruction spécifique à un moment précis alors que la fonction de retard arrête le code Arduino pendant un certain temps.