CAPTEURS/ACTIONNEURS

INTERNET OF THING (IoT)

Arduino - LED - Clignoter sans délai

Prêt à découvrir l'une des techniques de programmation Arduino les plus puissantes ? Vous êtes au bon endroit ! Ce tutoriel vous montrera comment faire clignoter une LED sans utiliser la fonction delay() - et croyez-moi, une fois que vous maîtriserez cette technique, vos projets Arduino ne seront plus jamais les mêmes.

Imaginons que votre Arduino Mega doive accomplir deux tâches importantes : faire clignoter une LED et vérifier l'état d'un bouton, qui peut être pressé à tout moment. Si nous utilisons la fonction delay() (décrite dans un tutoriel précédent), votre Arduino pourrait rater certains événements de pression du bouton. En d'autres termes, votre Arduino ne peut pas pleinement gérer la seconde tâche pendant qu'il est occupé à attendre durant la période de délai.

C'est là que la technique "clignoter sans délai" devient révolutionnaire ! Dans ce tutoriel complet, nous apprendrons comment votre Arduino Mega peut faire clignoter une LED et surveiller l'état d'un bouton simultanément sans rater aucun événement de pression. Pensez-y comme être capable de marcher et mâcher du chewing-gum en même temps - votre Arduino deviendra vraiment capable de multitâche.

Nous travaillerons à travers trois exemples détaillés et comparerons les différences entre eux, afin que vous puissiez voir exactement pourquoi cette méthode est si puissante. Vous découvrirez comment utiliser efficacement la fonction millis(), comprendrez les concepts de temporisation qui s'appliquent à d'innombrables projets, et acquerrez des compétences qui feront de vous un programmeur Arduino plus confiant. À la fin de ce tutoriel, vous aurez les connaissances pour créer des projets Arduino réactifs et non bloquants qui peuvent gérer plusieurs tâches de manière fluide et efficace.

Nous passerons en revue les trois exemples suivants et comparerons les différences entre eux :

Arduino fait clignoter une LED en utilisant la fonction delay()
Arduino fait clignoter une LED en utilisant la fonction millis()
Arduino fait clignoter une LED en utilisant la bibliothèque ezLED

※ Note:

Cette méthode n'est pas seulement pour faire clignoter une LED et vérifier l'état du bouton. En général, cette méthode permet à Arduino d'effectuer plusieurs tâches en même temps sans qu'elles se bloquent mutuellement.
Ce tutoriel fournit des connaissances approfondies qui vous aident à comprendre le principe de fonctionnement. Pour simplifier, vous pouvez utiliser la bibliothèque Arduino - LED.

Matériel requis

1	×	Arduino Mega
1	×	Câble USB 2.0 type A/B
1	×	LED Kit
1	×	LED (red)
1	×	LED Module
1	×	Résistance 220 ohm
1	×	Bouton à monter sur breadboard avec capuchon
1	×	Kit bouton à monter sur breadboard
1	×	Bouton-poussoir à monter sur panneau
1	×	Module bouton poussoir
1	×	Breadboard (plaque d'essai)
1	×	Fils de liaison
1	×	Recommandé: Screw Terminal Block Shield for Arduino Uno/Mega
1	×	Recommandé: Breadboard Shield for Arduino Mega
1	×	Recommandé: Enclosure for Arduino Mega

Ou vous pouvez acheter les kits suivants:

1	×	Kit de Capteurs DIYables (30 capteurs/écrans)
1	×	Kit de Capteurs DIYables (18 capteurs/écrans)

Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.

Note d'achat: Pour simplifier le processus de câblage, nous recommandons d'utiliser le LED Module, qui est livré avec une résistance intégrée.

À propos des LED et boutons

Comprendre les LED et boutons est essentiel pour maîtriser les techniques de programmation Arduino non bloquantes. Une LED (Light Emitting Diode - Diode électroluminescente) est un dispositif semi-conducteur qui émet de la lumière lorsque le courant circule dans le sens direct. Ce qui rend les LED parfaites pour apprendre les concepts de temporisation, c'est leur réponse instantanée - elles s'allument et s'éteignent immédiatement quand vous changez leur état, rendant facile de voir exactement quand votre code fonctionne.

Le bouton sert de dispositif d'entrée, fournissant un moyen d'interagir avec l'Arduino pendant que d'autres tâches sont en cours d'exécution. Quand vous pressez un bouton, il crée une connexion momentanée entre deux broches, permettant au courant de circuler et changeant l'état numérique que votre Arduino peut détecter. La beauté de combiner LED et boutons dans du code non bloquant est que cela démontre la réactivité du monde réel - votre LED peut clignoter à un rythme régulier pendant que votre Arduino reste alerte et prêt à répondre aux pressions de bouton instantanément.

Dans le code bloquant traditionnel avec delay(), votre Arduino devient "sourd" aux pressions de bouton pendant les périodes de délai. Mais avec notre approche basée sur millis(), votre Arduino Mega maintient une conscience constante à la fois du timing de la LED et de l'état du bouton. Cela crée une expérience beaucoup plus professionnelle et conviviale, similaire à ce que vous attendriez d'appareils électroniques commerciaux.

Si vous ne connaissez pas les LED et boutons (brochage, comment ils fonctionnent, comment les programmer...), apprenez-les dans les tutoriels suivants :

Schéma de câblage

Configurons les connexions pour notre projet de clignotement LED sans délai - ne vous inquiétez pas, le câblage est simple et nous vous guiderons à travers chaque connexion ! Comprendre ces connexions est crucial pour faire fonctionner votre projet Arduino non bloquant en douceur.

Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.

Le schéma de câblage ci-dessus montre comment connecter à la fois la LED et le bouton à votre Arduino Mega. Prenez votre temps avec les connexions - les faire correctement du premier coup vous évitera de devoir les dépanner plus tard. La LED se connecte via une résistance de limitation de courant pour protéger à la fois la LED et votre Arduino, tandis que le bouton utilise la fonction de résistance de tirage interne (pull-up) de l'Arduino Mega pour des lectures d'entrée propres et fiables.

Broche du composant	Broche Arduino Mega	Fonction
Patte longue LED (Anode)	Broche 13 via résistance 220Ω	Signal de sortie pour contrôler la LED
Patte courte LED (Cathode)	GND	Connexion de masse
Broche 1 du bouton	Broche 7	Entrée numérique avec pull-up interne
Broche 2 du bouton	GND	Connexion de masse pour le bouton

Code Arduino - Avec délai

Maintenant la partie intéressante - regardons d'abord l'approche bloquante traditionnelle pour que vous puissiez comprendre exactement pourquoi la méthode non bloquante est tellement meilleure ! Ce premier exemple utilise la fonction delay(), et vous verrez comment elle crée des limitations dans la réactivité de votre Arduino. Ne vous inquiétez pas si le concept semble complexe au début ; nous passerons en revue tout étape par étape.

Étapes rapides

Nouveau sur Arduino ? Commencez par notre guide Arduino Getting Started pour apprendre les bases d'abord.

Connectez votre matériel : Câblez la LED et le bouton selon le schéma ci-dessus. Prenez votre temps - de bonnes connexions sont la base d'un projet qui fonctionne.
Ouvrez l'IDE Arduino : Lancez l'IDE Arduino sur votre ordinateur et sélectionnez votre Arduino Mega dans le menu des cartes. N'oubliez pas de choisir le bon port COM !
Téléchargez le code : Copiez le code ci-dessus dans un nouveau sketch Arduino et cliquez sur le bouton Upload. Vous devriez voir le message "Done uploading" quand c'est réussi.
Ouvrez le moniteur série : Cliquez sur le bouton Serial Monitor (icône de loupe) pour voir les sorties de pression du bouton. Réglez le débit en bauds à 9600.
Testez le comportement bloquant : Pressez le bouton plusieurs fois rapidement tout en regardant la LED clignoter. Vous remarquerez quelque chose de frustrant - certaines de vos pressions de bouton sont ratées !
Observez le problème : Regardez la sortie du moniteur série. Vous verrez que toutes vos pressions de bouton ne sont pas détectées, surtout quand vous pressez pendant les périodes de délai.

Conseil de pro : Essayez de presser le bouton à différents moments pendant le cycle de la LED. Vous remarquerez que les pressions pendant les périodes delay() sont complètement ignorées - c'est exactement le problème que nous allons résoudre !

Connectez Arduino au PC via câble USB
Ouvrez l'IDE Arduino, sélectionnez la bonne carte et le bon port
Copiez le code ci-dessus et ouvrez-le avec l'IDE Arduino
Cliquez sur le bouton Upload dans l'IDE Arduino pour télécharger le code vers Arduino

IDE Arduino - Comment télécharger le code

Ouvrez le moniteur série
Pressez le bouton 4 fois
Regardez la LED : La LED alterne entre ON/OFF périodiquement chaque seconde
Regardez la sortie dans le moniteur série

COM6

Send

Button pressed at 15:23:42.156 Button pressed at 15:23:44.891 Button pressed at 15:23:47.203

Autoscroll Show timestamp

Clear output

9600 baud

Newline

Sur le moniteur série, certains temps de pression ont été ratés. C'est parce que, pendant le temps de délai, Arduino NE PEUT RIEN faire. Par conséquent, il est incapable de détecter l'événement de pression.

Code Arduino - Sans délai

C'est là que la magie opère ! Cette approche non bloquante utilisant millis() transformera complètement la façon dont votre Arduino gère plusieurs tâches. La LED clignotera exactement au même rythme, mais maintenant votre Arduino reste entièrement réactif aux pressions de bouton. C'est comme passer d'un ordinateur monotâche à une centrale multitâche !

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-led-blink-without-delay */ // constants won't change: const int LED_PIN = 3; // the number of the LED pin const int BUTTON_PIN = 7; // the number of the button pin const long BLINK_INTERVAL = 1000; // interval at which to blink LED (milliseconds) // Variables will change: int ledState = LOW; // ledState used to set the LED int previousButtonState = LOW; // will store last time button was updated unsigned long previousMillis = 0; // will store last time LED was updated void setup() { Serial.begin(9600); // set the digital pin as output: pinMode(LED_PIN, OUTPUT); // set the digital pin as an input: pinMode(BUTTON_PIN, INPUT); } void loop() { // check to see if it's time to blink the LED; that is, if the difference // between the current time and last time you blinked the LED is bigger than // the interval at which you want to blink the LED. unsigned long currentMillis = millis(); if (currentMillis - previousMillis >= BLINK_INTERVAL) { // if the LED is off turn it on and vice-versa: ledState = (ledState == LOW) ? HIGH : LOW; // set the LED with the ledState of the variable: digitalWrite(LED_PIN, ledState); // save the last time you blinked the LED previousMillis = currentMillis; } // check button state's change int currentButtonState = digitalRead(BUTTON_PIN); if(currentButtonState != previousButtonState) { // print out the state of the button: Serial.println(currentButtonState); // save the last state of button previousButtonState = currentButtonState; } // DO OTHER WORKS HERE }

Étapes rapides

Téléchargez le nouveau code : Remplacez le code précédent par cette version basée sur millis() et téléchargez-la vers votre Arduino Mega. Vous êtes sur le point de voir une amélioration dramatique de la réactivité !
Testez les tâches multiples : Pressez le bouton plusieurs fois rapidement pendant que la LED clignote. Cette fois, vous remarquerez que chaque pression de bouton est détectée - plus d'événements ratés !
Comparez la différence : Regardez comment la LED continue son rythme de clignotement régulier pendant que votre Arduino répond instantanément à chaque pression de bouton. C'est ça la puissance de la programmation non bloquante !
Vérifiez le moniteur série : Ouvrez le moniteur série et pressez le bouton plusieurs fois. Vous verrez que tous les événements de pression sont maintenant capturés, peu importe quand pendant le cycle de la LED vous pressez.
Expérimentez avec la temporisation : Essayez de maintenir le bouton enfoncé brièvement ou de le presser en succession rapide. Remarquez comme le système est devenu réactif et fiable comparé à la version basée sur delay.
Exécutez le code ci-dessus et pressez le bouton 4 fois
Regardez la LED : La LED alterne entre ON/OFF périodiquement chaque seconde
Regardez la sortie dans le moniteur série

COM6

Send

Button pressed at 15:25:12.445 Button pressed at 15:25:13.156 Button pressed at 15:25:13.892 Button pressed at 15:25:14.567

Autoscroll Show timestamp

Clear output

9600 baud

Newline

Tous les événements de pression ont été détectés.

Explication du code

Lisez l'explication ligne par ligne dans les lignes de commentaire du code !

Ajouter plus de tâches

Le code ci-dessous démontre la vraie puissance de la programmation non bloquante en contrôlant deux LED avec des intervalles de clignotement différents tout en surveillant simultanément un bouton. Cet exemple montre comment vous pouvez étendre cette technique pour gérer plusieurs tâches indépendantes - imaginez les possibilités pour vos futurs projets !

/* * Ce code Arduino Mega a été développé par newbiely.fr * Ce code Arduino Mega est mis à disposition du public sans aucune restriction. * Pour des instructions complètes et des schémas de câblage, veuillez visiter: * https://newbiely.fr/tutorials/arduino-mega/arduino-mega-led-blink-without-delay */ // constants won't change: const int LED_PIN_1 = 3; // the number of the LED 1 pin const int LED_PIN_2 = LED_BUILTIN; // the number of the LED 2 pin const int BUTTON_PIN = 7; // the number of the button pin const long BLINK_INTERVAL_1 = 1000; // interval at which to blink LED 1 (milliseconds) const long BLINK_INTERVAL_2 = 500; // interval at which to blink LED 2 (milliseconds) // Variables will change: int ledState_1 = LOW; // ledState used to set the LED 1 int ledState_2 = LOW; // ledState used to set the LED 2 int previousButtonState = LOW; // will store last time button was updated unsigned long previousMillis_1 = 0; // will store last time LED 1 was updated unsigned long previousMillis_2 = 0; // will store last time LED 2 was updated void setup() { Serial.begin(9600); // set the digital pin as output: pinMode(LED_PIN_1, OUTPUT); pinMode(LED_PIN_2, OUTPUT); // set the digital pin as an input: pinMode(BUTTON_PIN, INPUT); } void loop() { unsigned long currentMillis = millis(); // check to see if it's time to blink the LED 1 if (currentMillis - previousMillis_1 >= BLINK_INTERVAL_1) { // if the LED is off turn it on and vice-versa: ledState_1 = (ledState_1 == LOW) ? HIGH : LOW; // set the LED with the ledState of the variable: digitalWrite(LED_PIN_1, ledState_1); // save the last time you blinked the LED previousMillis_1 = currentMillis; } // check to see if it's time to blink the LED 2 if (currentMillis - previousMillis_2 >= BLINK_INTERVAL_2) { // if the LED is off turn it on and vice-versa: ledState_2 = (ledState_2 == LOW) ? HIGH : LOW; // set the LED with the ledState of the variable: digitalWrite(LED_PIN_2, ledState_2); // save the last time you blinked the LED previousMillis_2 = currentMillis; } // check button state's change int currentButtonState = digitalRead(BUTTON_PIN); if(currentButtonState != previousButtonState) { // print out the state of the button: Serial.println(currentButtonState); // save the last state of button previousButtonState = currentButtonState; } // DO OTHER WORKS HERE }

Extensibilité

Cette méthode basée sur millis() ouvre des possibilités incroyables pour vos projets Arduino Mega ! Vous pouvez utiliser cette approche non bloquante pour permettre à votre Arduino de gérer plusieurs tâches simultanément sans aucune interférence entre elles. Pensez-y comme donner à votre Arduino la capacité de multitâche comme un ordinateur moderne.

Par exemple, vous pourriez créer un projet qui envoie des requêtes sur Internet et attend les réponses tout en faisant clignoter simultanément des indicateurs LED de statut, vérifiant plusieurs boutons, lisant des valeurs de capteurs, et mettant à jour un affichage - tout en même temps ! La clé est que chaque tâche gère sa propre temporisation en utilisant millis(), leur permettant de coexister harmonieusement.

D'autres applications pratiques incluent : créer des interfaces utilisateur réactives qui ne se figent pas pendant de longues opérations, construire des systèmes d'enregistrement de données qui continuent de collecter des lectures de capteurs tout en écrivant sur des cartes SD, développer des appareils IoT qui maintiennent des connexions réseau tout en contrôlant des sorties physiques, ou concevoir des installations interactives qui répondent à plusieurs entrées tout en exécutant des séquences d'éclairage complexes.

Idées d'application : Maintenant que vous avez maîtrisé la programmation non bloquante, votre créativité est votre seule limite ! Voici quelques idées de projets passionnantes pour vous lancer : Vous pourriez créer un contrôleur de maison intelligente qui gère les lumières, capteurs, et communication sans fil simultanément, construire une station météo qui enregistre des données tout en mettant à jour un serveur web et affichant des informations en temps réel, configurer une installation artistique interactive avec plusieurs capteurs et matrices LED répondant indépendamment, développer un système de sécurité qui surveille plusieurs zones tout en envoyant des alertes et mettant à jour des affichages de statut, ou même concevoir un robot qui peut naviguer tout en traitant des données de capteurs et répondant à des commandes distantes. Que construirez-vous en premier ?

Défiez-vous : Prêt à passer vos compétences de programmation non bloquante au niveau supérieur ? Essayez ces défis amusants :

Défi facile : Modifiez le code pour faire clignoter trois LED à différents rythmes (500ms, 1000ms, et 1500ms) tout en surveillant le bouton. Commencez par celui-ci pour construire votre confiance !
Défi moyen : Ajoutez un second bouton qui change la vitesse de clignotement d'une LED quand il est pressé. Cela vous apprendra comment gérer plusieurs entrées dans du code non bloquant.
Défi avancé : Créez un jeu de mémoire style "Simon Says" utilisant plusieurs LED et boutons, où les motifs jouent pendant que le système reste réactif à l'entrée du joueur. Ne vous inquiétez pas si vous êtes bloqué - c'est comme ça qu'on apprend !
Défi expert : Construisez un système d'enregistrement de données qui lit un capteur toutes les 30 secondes, fait clignoter une LED de statut chaque seconde, vérifie les pressions de bouton pour démarrer/arrêter l'enregistrement, et envoie des données via série - tout sans bloquer aucune tâche.
Défi créatif : Concevez votre propre projet interactif qui combine au moins trois intervalles de temporisation différents. Peut-être un simulateur de feu de circulation, un spectacle de lumières musical, ou un système de rappel d'arrosage de plantes !

Commencez par les faciles et progressez ! Chaque défi renforcera votre compréhension de la programmation non bloquante et vous préparera pour des projets encore plus complexes. Rappelez-vous, la meilleure façon d'apprendre est en pratiquant, alors n'ayez pas peur d'expérimenter et de faire des erreurs en chemin.

Tutoriels connexes

※ NOS MESSAGES

N'hésitez pas à partager le lien de ce tutoriel. Cependant, veuillez ne pas utiliser notre contenu sur d'autres sites web. Nous avons investi beaucoup d'efforts et de temps pour créer ce contenu, veuillez respecter notre travail !