Si vous souhaitez "suspendre" le microcontrôleur, saisissez simplement l'instruction de délai à la bonne place du programme. Mais cela devient un véritable obstacle lorsque vous essayez d’autres choses, par exemple, de suivre le clic d’un bouton. Dans ce cas, il est nécessaire de mettre en place une sorte de multitâche.
Oui, cela va ajouter quelques lignes de code à vos programmes, mais cela fera de vous un programmeur plus expérimenté et augmentera le potentiel de votre Arduino. Pour ce faire, vous devez juste apprendre à utiliser la fonction millis.
Il faut comprendre que la fonction delay met en pause l'exécution de votre programme Arduino, le rendant incapable de faire autre chose pendant cette période. Au lieu de suspendre l'intégralité de votre programme pendant un certain temps, nous allons apprendre à calculer le temps qui s'est écoulé avant la fin de l'action. Ceci, bien sûr, est fait en utilisant la fonction millis () et quelques variables par des amis pour stocker nos données. Pour que tout soit facile à comprendre, nous commencerons par le premier croquis de formation intitulé «Blink», mais dans ce cas, nous ferons clignoter la DEL sans délai.
Le début de ce programme est identique à tout autre programme standard pour Arduino. Vient d’abord l’annonce de toutes les variables et de toutes les lignes d’entrée / sortie nécessaires (par exemple, la ligne 13 pour la LED). Ici, nous avons également besoin d’une variable entière pour stocker l’état actuel de la LED. Il sera réglé sur LOW car l'état initial du voyant est éteint. Puis déclarez la variable "previousMillis" de type "unsigned long". Contrairement aux entiers, les variables non signées longues ont 32 bits, ce qui est nécessaire pour les variables dont la valeur peut devenir très grande - comme le temps potentiel que nous pouvons attendre jusqu'à ce qu'une action soit entreprise. La variable previousMillis sera utilisée pour stocker l'heure à laquelle le dernier voyant a clignoté. Il existe également un type de «const long», il est également 32 bits, mais il ne modifie pas la valeur, c’est-à-dire qu’il s’agit de constantes (dans ce cas, pour la constante d’intervalle). Nous le fixons à 1000 et l’utilisons comme temps de pause, mesuré en millisecondes.
const int ledPin \u003d 13; // définit la sortie de la LED // Les variables vont changer: int ledState \u003d LOW; // ledState est utilisé pour déterminer l'état de la LED unsigned long previousMillis \u003d 0; // sauvegarde l'heure à la dernière mise à jour de la DEL // constantes ne changent pas: const intervalle long \u003d 1000; // intervalle clignotant en millisecondes void setup () (// définition de la ligne de sortie 13 de pinMode (ledPin, OUTPUT);)
Ensuite, nous entrons dans un cycle sans fin. Rappelez-vous qu'au lieu du retard, nous voulons calculer le temps écoulé depuis notre dernier clignotement, dans notre cas 1000 ms. Si le temps indiqué est écoulé, il est temps de changer le statut de notre voyant.
Tout d'abord, nous définissons le «longMillis» long non signé sur «millis ()», qui détermine l'heure actuelle en millisecondes. Cela nous aidera à déterminer si la différence entre l'heure actuelle et l'heure précédente a dépassé 1000 ms. Pour ce faire, nous disons: "Si l'heure actuelle moins l'heure précédente lorsque notre voyant clignote est supérieure ou égale à notre valeur assignée de 1000 ms, enregistrez l'heure du dernier clignotement comme le précédent." Cela nous aidera à nous rappeler combien de temps s’est écoulé depuis le dernier clignotement de la boucle suivante. Ensuite, si l’état de la LED est BAS, augmentez-le, sinon laissez-le BAS. Utilisez ensuite la commande digitalWrite pour afficher l’état actuel sur le voyant.
void loop () (unsigned long currentMillis \u003d millis (); if (currentMillis - previousMillis\u003e \u003d intervalle) (// sauvegarde l'heure du dernier changement d'état de la LED previousMillis \u003d currentMillis; // si la LED est éteinte, allumez-la et inversement si (ledState \u003d\u003d LOW) (ledState \u003d HIGH;) else (ledState \u003d LOW;) // sortie vers la DEL digitalWrite (ledPin, ledState);))
La fonction millis () vous permet de lire le temps écoulé depuis le début du programme en cours. La fonction renvoie une valeur au format «unsigned long» et vous permet de lire les valeurs jusqu'à 50 jours à compter du démarrage du programme. Passé ce délai, le compte à rebours recommencera. Voici un exemple d'utilisation de la fonction millis ():
Non signé depuis longtemps; void setup () (Serial.begin (9600);) void loop () (Serial.print («On time:»); time \u003d millis (); // mémorise la valeur de l'heure Serial.println (time); // envoi informations via le port série de retard (1000);)
Dans l'exemple ci-dessus, une information sur une seconde sur le temps écoulé depuis le lancement du programme sera envoyée au moniteur de port. Le temps étant mesuré en millisecondes, chaque valeur ultérieure différera de 1 000. La précision de lecture dépend de la stabilité du résonateur à quartz Arduino.
Fonction Micros ()
La fonction micros () est analogue à la fonction millis (), la différence réside dans la précision de la mesure. En utilisant la fonction micros (), nous obtenons le temps écoulé depuis le début du programme en cours en microsecondes. Le compteur de microsecondes compté sera réinitialisé après 70 minutes. Voici un exemple d'utilisation de la fonction micros ():
Non signé depuis longtemps; void setup () (Serial.begin (9600);) void loop () (Serial.print («Heure depuis le lancement:«); time \u003d micros (); Serial.print (heure); Serial.println (”ms "); Retard (1000);)
Comme dans l'exemple de la fonction millis (), une information sur le temps mesuré est transmise au moniteur de port toutes les deux secondes. La seule différence est que, dans ce cas, le temps est mesuré en microsecondes.
Fonction Delay ()
La fonction delay () vous permet de suspendre l'exécution du programme en cours pendant la durée spécifiée dans le paramètre. La syntaxe de la commande est la suivante:
// commande de retard (500); // delay pour 0.5 sec // commandes delay (1000); // retard pour 1s
Le temps est indiqué en millisecondes (1 seconde \u003d 1000 ms). Ce paramètre peut être du type "unsigned long", compris entre 0 et 4294967295. Voici un exemple d'utilisation de la commande delay ():
#define ledPin 13 void setup () (pinMode (ledPin, 13);) void loop () (digitalWrite (ledPin, HIGH); // allume le retard de la DEL (500); // attend 500ms (0.5 sec) digitalWrite ( ledPin, LOW); // éteint le retard du voyant (1000); // attend 1000 ms (1 sec))
Dans l'exemple ci-dessus, le voyant s'allume pendant 0,5 seconde, puis s'éteint pendant 1 seconde, et ainsi de suite, jusqu'à ce que l'Arduino soit mis hors tension.
Fonction DelayMicroseconds ()
La fonction delayMicroseconds () est une variation de la fonction delay (). La différence réside dans la quantité et la précision du timing. La fonction delay () vous permet de compter le temps avec une précision de 1 milliseconde, tandis que delayMicroseconds () avec une précision de 1 microseconde.
La valeur pouvant être spécifiée dans le paramètre est comprise entre 0 et 16383. Pour des intervalles de temps plus longs, utilisez la fonction delay () ou utilisez delayMicroseconds () plusieurs fois.
#define outPin 8 void setup () (pinMode (outPin, OUTPUT); // broche 8 en sortie) void loop () (digitalWrite (outPin, HIGH); // broche 8 high state delayMicroseconds (50); // pause 50 microsecondes digitalWrite (outPin, LOW); // broche 8 délai d'état faibleMicrosecondes (50); // pause de 50 microsecondes)
Cet exemple génère un méandre avec une période de 100 microsecondes et un remplissage de 50%.
Bonjour, Andreï. Votre approche pour transférer le bagage de connaissances et d’expérience que vous avez acquis est très intéressante. Cela aide beaucoup dans les entreprises. Eh bien, moi qui commence à maîtriser l’arduino, j’ai envie de progresser. De plus, avec l'aide des autres, je comprends plus vite. Donc: tout d’abord, ma tâche était de faire voyager un robot le long de la ligne. Fait - tout va bien. Mais alors, en lui fournissant des options supplémentaires, je ne comprenais pas pourquoi il avait cessé de répondre correctement à la ligne. Je suis tombé sur cet article et j'ai compris la raison.
J'ai maintenant une question pour vous: dans l'esquisse ci-dessous et prête, étant donné les problèmes de retard, dois-je passer en millis où que soit cette fonction? Si oui, alors je comprends que le croquis devra être refait presque entièrement? Et comment utiliser les millis dans la mesure de distance n’est pas tout à fait clair? Merci
// Robot avec la fonction suivante à bandes blanches
// ************************ Installation des sorties moteur ************************ *
int MotorLeftSpeed \u200b\u200b\u003d 5; // moteur gauche (A) SPEED - ENA
int MotorLeftForward \u003d 4; // Moteur gauche (A) AVANT - IN1
int MotorLeftBack \u003d 3; // moteur gauche (A) BACK - IN2
int MotorRightForward \u003d 8; // Moteur droit (B) FORWARD - IN3
int MotorRightBack \u003d 7; // moteur de droite (B) BACK - IN4
int MotorRightSpeed \u200b\u200b\u003d 9; // droite (B) moteur SPEED - ENB
// ************************ Installation des conclusions des capteurs à ultrasons *********************** *
int trigPinL \u003d 14; // définit le numéro de sortie du capteur à ultrasons trig gauche
int echoPinL \u003d 15; // définit le numéro de sortie du capteur à ultrasons à écho gauche
int trigPinC \u003d 10; // définit le numéro de sortie du capteur à ultrasons central trig
int echoPinC \u003d 11; // réglage du numéro de sortie du capteur à ultrasons à écho central
int trigPinR \u003d 12; // définit le numéro de sortie du capteur à ultrasons trig de droite
int echoPinR \u003d 13; // réglage du numéro de sortie du capteur à ultrasons à écho droit
// *********************** Installation des sorties des capteurs de ligne *******************
const int LineSensorLeft \u003d 19; // entrée du capteur de ligne gauche
const int LineSensorRight \u003d 18; // entrée du capteur de droite
int SL; // statut du capteur gauche
int SR; // bon état du capteur
// *********************** Réglage de la sortie d'alarme sonore et sonore **************
int Light \u003d 2; // définit le numéro de la sortie de l'alarme lumineuse
int Zumm \u003d 6; // définir le numéro de sortie du buzzer
int ledState \u003d LOW; // définit le statut du voyant sur cette variable
long précédentMillis \u003d 0; // stocke l'heure de la dernière commutation de LED
intervalle long \u003d 300; // intervalle entre l'allumage et l'extinction de la LED (0,3 seconde)
// *********************** Mesure de distance variable par capteurs *************
unsigned int impulseTimeL \u003d 0;
unsigned int impulseTimeC \u003d 0;
unsigned int impulseTimeR \u003d 0;
distL long \u003d 0; // distance mesurée par le capteur à ultrasons gauche
distC long \u003d 0; // distance mesurée par le capteur à ultrasons central
distR long \u003d 0; // distance mesurée par le capteur droit Uz
// ************************************** CONFIGURATION ************* **********************
Serial.begin (9600); // démarre le port série (vitesse 9600)
// **************** Nous définissons les contacts des moteurs *****************
pinMode (MotorRightBack, OUTPUT); // moteur droit (B) ARRIÈRE
pinMode (MotorRightForward, OUTPUT); // Moteur droit (B) AVANT
pinMode (MotorLeftBack, OUTPUT); // moteur gauche (A) ARRIÈRE
pinMode (MotorLeftForward, OUTPUT); // Moteur gauche (A) AVANT
délai (durée);
// **************** Nous définissons les contacts des détecteurs de bande **************
pinMode (LineSensorLeft, INPUT); // définition de la broche du capteur de ligne gauche
pinMode (LineSensorRight, INPUT); // définition de la broche du capteur de droite
// *************** Réglage des modes de sortie des capteurs à ultrasons **********************
pinMode (trigPinL, OUTPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons gauche trig
pinMode (echoPinL, INPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons à écho gauche
pinMode (trigPinC, OUTPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons central trig
pinMode (echoPinC, INPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons à écho central
pinMode (trigPinR, OUTPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons trig droite
pinMode (echoPinR, INPUT); // réglage du mode de fonctionnement de la sortie du capteur à ultrasons à écho droit
// **************** Nous établissons les contacts de l'alarme lumineuse et sonore *************************** *****
pinMode (Zumm, OUTPUT); // réglage du mode de fonctionnement de la sortie buzzer
pinMode (Light, OUTPUT); // réglage du mode de fonctionnement de la sortie du signal lumineux
// ******************* Commandes de mouvement de base *******************
void forward (int a, int sa) // GO
analogWrite (MotorRightSpeed, sa);
analogWrite (MotorLeftSpeed, sa);
void right (int b, int sb) // DROITE DROITE (un côté)
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorLeftBack, LOW);
digitalWrite (MotorLeftForward, HIGH);
analogWrite (MotorLeftSpeed, sb);
void left (int k, int sk) // TOUR DE GAUCHE (un côté)
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorRightForward, HIGH);
analogWrite (MotorRightSpeed, sk);
digitalWrite (MotorLeftBack, LOW);
void stopp (int f) // STOP
digitalWrite (MotorRightBack, LOW);
digitalWrite (MotorRightForward, LOW);
digitalWrite (MotorLeftBack, LOW);
digitalWrite (MotorLeftForward, LOW);
// **************************** Mesure de distance ********************* *
void izmdistL () // mesure de distance avec le capteur à ultrasons de gauche
digitalWrite (trigPinL, HIGH);
digitalWrite (trigPinL, LOW); // 10 mS d'impulsion à la sortie trig du capteur à ultrasons pour mesurer la distance
impulseTimeL \u003d pulseIn (echoPinL, HIGH); // lit la distance du capteur à ultrasons
distL \u003d impulseTimeL / 58; // Convertir en centimètres
void izmdistC () // mesure de distance par un capteur à ultrasons central
digitalWrite (trigPinC, HIGH);
digitalWrite (trigPinC, LOW); // 10 mS d'impulsion à la sortie trig du capteur à ultrasons pour mesurer la distance
impulseTimeC \u003d pulseIn (echoPinC, HIGH); // lit la distance du capteur à ultrasons
distC \u003d impulseTimeC / 58; // Convertir en centimètres
void izmdistR () // mesure de distance par un capteur à ultrasons central
digitalWrite (trigPinR, HIGH);
digitalWrite (trigPinR, LOW); // 10 mS d'impulsion à la sortie trig du capteur à ultrasons pour mesurer la distance
impulseTimeR \u003d pulseIn (échoPinR, HIGH); // lit la distance du capteur à ultrasons
distR \u003d impulseTimeR / 58; // Convertir en centimètres
// ************************************** LOOP ************* ***********************
// ************************ LIGNE suivant le mode *********************** ***
// ********************* alarme lumineuse et sonore **************
ton (Zumm, 900); // allume le son à 900 Hz
ton (Zumm, 900); // allume le son à 800 Hz
non signé long currentMillis \u003d millis ();
if (currentMillis - previousMillis\u003e intervalle) // vérifie si l'intervalle souhaité est passé, s'il a passé
previousMillis \u003d currentMillis; // sauve l'heure du dernier changement
if (ledState \u003d\u003d LOW) // si le voyant est éteint, allumez-le et inversement
ledState \u003d HIGH;
digitalWrite (Light, ledState); // définit le statut de sortie pour allumer ou éteindre la LED
// ************************* Mesure de distance *********************** **
Serial.println (distL);
Serial.println (distC);
Serial.println (distR);
if (distL\u003e 50 && distC\u003e 50 && distR\u003e 50) // si la distance mesurée est supérieure à 50 centimètres - aller
SL \u003d digitalRead (LineSensorLeft); // lit le signal du capteur de bande gauche
SR \u003d digitalRead (LineSensorRight); // lit le signal du capteur de bande de droite
// *************************** Suivez la ligne noire ******************* ****
// ROBOT sur la voie - allez tout droit
if (SL \u003d\u003d BASSE & SR \u003d\u003d BASSE) // BLANC - BLANC - continuer tout droit
forward (10, 100); // DIRECT (heure, vitesse)
// ROBOT commence à sortir du strip - nous roulons en taxi
else if (SL \u003d\u003d BAS & SR \u003d\u003d HAUT) // NOIR - BLANC - GAUCHE
left (10, 100); // tourne à GAUCHE (temps, vitesse)
else if (SL \u003d\u003d HAUT & SR \u003d\u003d BAS] // BLANC - NOIR - DROIT DROIT
right (10, 100); // DROITE DROITE (heure, vitesse)
// FINISH - ROBOT voit avec les deux capteurs une bande
sinon si (SL \u003d\u003d HAUT & SR \u003d\u003d HAUT) // NOIR - NOIR - STOP
stopp (50); // STOP
else // si la distance mesurée est inférieure ou égale au minimum - stand
La première chose qu'un débutant maitrisant les rencontres Arduino est la propriété désagréable de la fonction delay () - bloquant l'exécution du programme. De nombreux exemples sur Internet utilisent cette fonction, mais l'application pratique laisse à penser qu'il vaut mieux s'en passer.
Comme il convenait à un débutant, j’ai inventé une bicyclette qui permettait sa mise en œuvre de délai sans blocage. La tâche était la suivante:
- Assurez le pseudo-multitâche afin que différents événements se produisent en temps voulu, à leurs propres intervalles et ne se bloquent pas.
- C'était pratique de l'utiliser.
- Il pourrait être conçu comme une bibliothèque et facilement incorporé dans d'autres projets sans copier-coller.
Le résultat est la suivante.
#include
La méthode Now () renvoie true si l'intervalle est passé. Dans ce cas, le compte à rebours reprend à la même fréquence. C'est-à-dire que Now () chaque fois "se recharge" automatiquement.
Le clignotement classique des LED peut être compliqué jusqu'à deux clignotements. Par exemple, les ampoules reliées aux jambes 12 et 11 doivent clignoter à des intervalles de 1s et 777ms, respectivement.
#include
Dans la boucle, vous pouvez faire autre chose, des LED clignotantes ne bloqueront pas l'exécution de ce code.
Il est clair qu'il ne s'agit pas d'un remplacement complet de delay (), qui interrompt le flux pour un temps donné; vous devez toujours écrire le programme en tant que MCA (mécanisme de la machine à états). En d’autres termes, stockez l’État et, en fonction de celui-ci, accédez au bon endroit dans le code.
Ancienne version:
Action1 (); délai (1000); action2 (); retard (500); action3 (); ...
Nouvelle option:
État d'octet \u003d 0; SmartDelay d (); ... switch (état) (cas 0: action1 (); d.Set (1000000UL); état \u003d 1; pause; cas 1: si (d.Now ()) (action2 (); d.Set (500000UL) ; état \u003d 2;) pause; cas 2: si (d.Now ()) (action3 (); d.Stop (); état \u003d 0;) pause;) ...
La méthode Set (intervalle) définit un nouvel intervalle et renvoie l'ancien. Vous pouvez simplement regarder l'intervalle en utilisant la méthode Get ();
Stop () arrête le traitement et Now () renvoie toujours false.
Start () reprend son travail et Now () commence à fonctionner normalement.
Si vous devez ralentir le compte, mais ne vous arrêtez pas du tout, c'est la méthode Wait (). Par exemple, si le voyant 12 clignote, mais ne clignote pas lorsque vous appuyez sur le bouton, ajoutez simplement ce code à loop () dans l'exemple avec deux diodes ci-dessus:
Si (digitalRead (9)) led12.Wait (); ...
Ainsi, avec un niveau de signal élevé à 9 branches, la diode 12 ne clignotera pas et continuera lorsque 0 apparaît à cet endroit.
Lorsqu'un écran est dessiné à l'aide d'une telle «minuterie», par exemple, et que les boutons sont traités en parallèle, il peut être nécessaire de redessiner l'écran ou une partie immédiatement après avoir cliqué sur le bouton, sans attendre la fin de l'intervalle. Pour ce faire, utilisez la méthode Reset (), après quoi le prochain appel à Now () retournera true. Par exemple:
Affichage SmartDelay (1000000UL); void loop () (if (btClick ()) display.Reset (); // a poussé un bouton, vous devez dessiner un écran. if (display.Now ()) screenRedraw (); // dessinez un écran.)
D'après les bogues, je vois seulement que le débordement du compteur de microsecondes n'est pas pris en compte, mais sinon, oui, vous devez nettoyer le code. Je n'aime pas la façon dont Reset () est fait pendant que je réfléchis.
Les retards dans Arduino jouent un très grand rôle. Sans eux, même le plus simple exemple Blink, qui fait clignoter une LED après une période donnée, ne fonctionnera pas. Mais la plupart des programmeurs débutants connaissent peu les délais et utilisent uniquement le délai Arduino, sans connaître les effets secondaires de cette commande. Dans cet article, je parlerai en détail des fonctions temporaires et de leurs fonctionnalités dans l'environnement de développement Arduino IDE.
Arduino a plusieurs équipes différentes chargées de travailler avec le temps et les pauses:
- delay ()
- delayMicroseconds ()
- millis ()
- micros ()
Ils diffèrent par leur précision et ont leurs propres caractéristiques qui doivent être prises en compte lors de la rédaction du code.
Utilisation de la fonction de délai arduino
La syntaxe
Le délai Arduino est la commande la plus simple et il est le plus souvent utilisé par les débutants. En fait, c'est un délai qui met le programme en pause du nombre de millisecondes indiqué entre parenthèses. (Dans une seconde, 1000 millisecondes.) La valeur maximale peut être 4294967295 ms, ce qui correspond approximativement à 50 jours. Regardons un exemple simple qui illustre le fonctionnement de cette commande.
Void setup () (pinMode (13, OUTPUT);) void loop () (digitalWrite (13, HIGH); // donne un retard de signal à 13 broches élevé (10000); // met en pause 10000ms ou 10 secondes digitalWrite13, LOW); // donne un signal faible de 13 pins delay (10000); // pause 10000ms ou 10 secondes)
En méthode mise en place nous prescrivons que la broche 13 sera utilisée comme sortie. Dans la partie principale du programme, un signal haut est d'abord envoyé à la broche, puis nous faisons un délai de 10 secondes. À ce moment, le programme semble être suspendu. Vient ensuite un signal bas et à nouveau un délai et tout recommence. En conséquence, nous obtenons que la broche est alimentée en alternance, puis 5 V, puis 0.
Vous devez clairement comprendre que pendant un certain temps, avec l’aide d’un délai, le programme s’arrête, l’application ne recevra aucune donnée des capteurs. C'est le principal inconvénient de l'utilisation de la fonction de délai dans Arduino. Vous pouvez contourner cette limitation à l'aide d'interruptions, mais nous en parlerons dans un article séparé.
Exemple de retard avec LED clignotante
Un exemple de circuit pour illustrer le fonctionnement de la fonction de délai.
Vous pouvez construire un circuit avec une LED et une résistance. Ensuite, nous obtenons un exemple standard - LED clignotante. Pour ce faire, vous devez connecter la LED avec un contact positif à la broche, que nous avons désignée comme sortie. Nous connectons la jambe libre de la LED via une résistance d’environ 220 ohms (peut-être un peu plus) au sol. Vous pouvez déterminer la polarité si vous regardez ses entrailles. Une grande tasse à l'intérieur est liée à un moins et une petite jambe à un plus. Si votre LED est neuve, vous pouvez déterminer la polarité en fonction de la longueur des bornes: longue jambe - plus, courte - moins.
Fonction DelayMicroseconds
Cette fonction est un analogue complet du délai, sauf que l'unité de mesure n'est pas les millisecondes, mais les microsecondes (en 1 seconde - 1 000 000 microsecondes). La valeur maximale sera 16383, ce qui correspond à 16 millisecondes. La résolution est de 4, c'est-à-dire que le nombre sera toujours un multiple de quatre. Un morceau de l'exemple ressemblerait à ceci:
DigitalWrite (2, HAUT); // donne un signal fort pour 2 pins delayMicroseconds (16383); // pause 16383mks digitalWrite (2, BAS); // donne un signal faible pour 2 pins delayMicroseconds (16383); // pause 16383mks
Le problème avec delayMicroseconds est exactement le même que celui de delay - ces fonctions «bloquent» complètement le programme et le bloque littéralement pendant un certain temps. À l'heure actuelle, il est impossible de travailler avec des ports, de lire des informations provenant de capteurs et d'effectuer des opérations mathématiques. Cette option convient aux feux clignotants, mais les utilisateurs expérimentés ne l'utilisent pas pour les grands projets, car de tels échecs n'y sont pas nécessaires. Par conséquent, il est préférable d’utiliser les fonctions décrites ci-dessous.
Millis fonction au lieu de délai
La fonction millis () vous permettra d’effectuer un délai immédiat sur l’arduino, contournant ainsi les inconvénients des méthodes précédentes. La valeur maximale du paramètre millis est identique à celle de la fonction de délai (4294967295ms ou 50 jours).
Avec des millis, nous n'arrêtons pas l'esquisse dans son intégralité, nous indiquons simplement combien de temps l'arduino doit simplement «contourner» exactement le bloc de code que nous voulons mettre en pause. Contrairement à delay millis, rien ne s’arrête. Cette commande nous renvoie simplement, à partir de la minuterie intégrée du microcontrôleur, le nombre de millisecondes écoulées depuis le début. À chaque appel de boucle, nous mesurons nous-mêmes le temps écoulé depuis le dernier appel de notre code et, si la différence de temps est inférieure à la pause souhaitée, nous ignorons le code. Dès que la différence devient supérieure à la pause requise, nous exécutons le code, obtenons l'heure actuelle en utilisant les mêmes millis et nous nous en souvenons - cette heure sera un nouveau point de référence. Au prochain cycle, le compte à rebours se fera déjà à partir d'un nouveau point et nous ignorerons à nouveau le code jusqu'à ce que la nouvelle différence entre millis et notre valeur précédemment enregistrée atteigne à nouveau la pause souhaitée.
Retarder sans délai en millis nécessite un code plus volumineux, ce qui vous permet de faire clignoter une LED et de suspendre une esquisse sans arrêter le système.
Voici un exemple illustrant le travail de l'équipe:
Unsigned long timing; // Variable de stockage du point de référence void setup () (Serial.begin (9600);) void loop () (/ * À ce stade, l’analogique commence à retarder ()) Calculez la différence entre le moment actuel et le point de référence précédemment enregistré. Si la différence est plus grande Si vous ne disposez pas de la valeur souhaitée, exécutez le code. Sinon, ne faites rien * / if (millis () - timing\u003e 10000) (// Au lieu de 10000, remplacez la valeur de pause dont vous avez besoin pour timing \u003d millis (); Serial.println ("10 secondes") ;))
D'abord, nous entrons la variable de synchronisation, le nombre de millisecondes y sera stocké. Par défaut, la valeur de la variable est 0. Dans la partie principale du programme, nous vérifions la condition: si le nombre de millisecondes écoulé depuis le démarrage du microcontrôleur moins le nombre enregistré dans la variable de minutage est supérieur à 10 000, une action est effectuée pour afficher un message dans le moniteur de port et la valeur de temps actuelle est écrite dans la variable. À la suite du programme, toutes les 10 secondes, 10 secondes seront affichées sur le moniteur de port. Cette méthode vous permet de faire clignoter une LED sans délai.
Fonction Micros au lieu de délai
Cette fonction peut également effectuer un délai sans utiliser la commande delay. Il fonctionne exactement de la même manière que les millis, mais il ne compte pas en millisecondes, mais en microsecondes avec une résolution de 4 μs. Sa valeur maximale est 4294967295 microsecondes ou 70 minutes. En cas de débordement, la valeur est simplement réinitialisée à 0, ne l'oubliez pas.
Résumé
La plate-forme Arduino nous fournit plusieurs façons d’effectuer des retards dans votre projet. Avec un délai, vous pouvez mettre rapidement une esquisse en pause, tout en bloquant le fonctionnement du microcontrôleur. L'utilisation de la commande millis vous permet de vous passer d'arduino sans délai, mais cela nécessitera un peu plus de programmation. Choisissez la meilleure façon en fonction de la complexité de votre projet. En règle générale, dans les esquisses simples et avec un délai inférieur à 10 secondes, le délai est utilisé. Si la logique de travail est plus compliquée et qu'un délai important est nécessaire, il est préférable d'utiliser millis plutôt que le délai.
