Arduino UNO Q - LED - Clignotement sans Délai
Quand votre Arduino UNO Q doit faire deux choses à la fois — comme faire clignoter une LED et lire un bouton — la fonction delay() devient un problème. Elle bloque le MCU et provoque des événements manqués. Dans ce tutoriel, vous apprendrez à faire clignoter une LED sans delay() en utilisant millis(), afin que l'Arduino UNO Q puisse effectuer plusieurs tâches simultanément.
※ Note:
- Cette méthode fait bien plus que faire clignoter une LED et vérifier l'état d'un bouton. Elle permet à l'Arduino UNO Q d'effectuer plusieurs tâches simultanément sans interruption.
Dans ce tutoriel, vous apprendrez :
- Pourquoi delay() pose des problèmes dans les programmes multitâches
- Comment faire clignoter une LED sans delay() en utilisant millis() sur Arduino UNO Q
- Comment faire clignoter deux LEDs à des vitesses différentes simultanément
- Comment programmer côté Linux (Python) et côté MCU (C/C++ Arduino) pour contrôler la vitesse de clignotement depuis le côté Linux
- Comment utiliser Telegram pour contrôler la vitesse de clignotement LED à distance sur Arduino UNO Q
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 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 de la LED et du Bouton
Apprenez-en plus sur la LED et le bouton (brochage, fonctionnement, programmation) dans ces tutoriels :
Schéma de Câblage
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Code MCU — Avec delay() (Démonstration du Problème)
L'Arduino UNO Q dispose de deux processeurs : le MCU STM32 (gère le contrôle matériel en temps réel) et le MPU Qualcomm (exécute Debian Linux). Dans cette section, seul le MCU STM32 est programmé. Une section ultérieure montrera comment les deux processeurs fonctionnent ensemble.
Ce premier exemple utilise delay() pour faire clignoter la LED — et démontre pourquoi c'est un problème :
- La LED clignote toutes les secondes avec delay(1000)
- Pendant l'attente dans delay(), le MCU est complètement bloqué — il ne peut pas détecter les appuis sur le bouton
- Appuyez plusieurs fois sur le bouton et observez que de nombreux appuis sont manqués
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
#define LED_PIN 3 // The Arduino UNO Q pin connected to the LED
#define BUTTON_PIN 7 // The Arduino UNO Q pin connected to the button
#define BLINK_INTERVAL 1000 // interval at which to blink LED (milliseconds)
int led_state = LOW; // led_state used to set the LED
int prev_button_state = LOW; // will store last button state
void setup() {
pinMode(LED_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
// if the LED is off turn it on and vice-versa
led_state = (led_state == LOW) ? HIGH : LOW;
// set the LED with the led_state of the variable
digitalWrite(LED_PIN, led_state);
delay(BLINK_INTERVAL); // If button is pressed during this time, Arduino CANNOT detect
int button_state = digitalRead(BUTTON_PIN);
if (button_state != prev_button_state) {
// button state changed — but delay may have caused us to miss some presses
prev_button_state = button_state;
}
}
Étapes Rapides
- Première utilisation de l'Arduino UNO Q ? Suivez le tutoriel Démarrer avec Arduino UNO Q pour préparer votre environnement de développement avant de continuer.
- Câbler les composants : Connectez la LED (avec résistance 220Ω) à la broche 3 et le bouton à la broche 7 selon le schéma de câblage.
- Connecter : Branchez l'Arduino UNO Q sur votre ordinateur avec un câble USB-C.
- Ouvrir Arduino App Lab : Lancez Arduino App Lab et attendez qu'il détecte votre Arduino UNO Q — cela peut prendre plusieurs minutes au premier lancement.
- Créer une nouvelle application : Cliquez sur le bouton Créer une nouvelle application.
- Donnez un nom à l'application, par exemple : DIYables_BlinkDelay
- Cliquez sur Créer pour confirmer.
- Un ensemble de dossiers et de fichiers sera généré dans votre nouvelle application.
- Trouvez le fichier sketch/sketch.ino — c'est là que vous collerez le programme MCU.
Coller le programme : Copiez le code MCU ci-dessus et collez-le dans ce fichier. Laissez les autres fichiers par défaut.
- Install the library: Click the Add sketch library button (the open book icon with a + sign) in the left sidebar.
- Search for Arduino_RouterBridge created by Arduino and click the Install button.
Bricks
No bricks added...
Sketch Libraries
No sketch libra...
Files
python
sketch
.gitignore
README.md
app.yaml
sketch.ino
- Téléverser : Cliquez sur le bouton Exécuter dans Arduino App Lab pour compiler et téléverser sur le STM32.
- Tester : Appuyez plusieurs fois rapidement sur le bouton — remarquez que de nombreux appuis sont ignorés car delay() bloque le MCU.
- Conseil : C'est le problème que millis() résout — voir l'exemple suivant.
Code MCU — Sans delay() (Solution)
Cet exemple utilise millis() pour faire clignoter la LED sans blocage — le MCU vérifie le temps écoulé et agit seulement quand nécessaire, il peut donc toujours détecter chaque appui sur le bouton :
- Utilise millis() et prev_millis pour suivre quand basculer la LED
- N'appelle jamais delay() — le MCU est toujours libre d'effectuer d'autres tâches
- Appuyez sur le bouton et observez que chaque appui est détecté, même pendant que la LED clignote
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
#define LED_PIN 3 // The Arduino UNO Q pin connected to the LED
#define BUTTON_PIN 7 // The Arduino UNO Q pin connected to the button
#define BLINK_INTERVAL 1000 // interval at which to blink LED (milliseconds)
int led_state = LOW; // led_state used to set the LED
int prev_button_state = LOW; // will store last button state
unsigned long prev_millis = 0; // will store last time LED was updated
void setup() {
pinMode(LED_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
unsigned long current_millis = millis();
// check to see if it's time to blink the LED
if (current_millis - prev_millis >= BLINK_INTERVAL) {
// if the LED is off turn it on and vice-versa:
led_state = (led_state == LOW) ? HIGH : LOW;
// set the LED with the led_state of the variable:
digitalWrite(LED_PIN, led_state);
// save the last time you blinked the LED
prev_millis = current_millis;
}
// check button state's change — never missed because no blocking delay
int button_state = digitalRead(BUTTON_PIN);
if (button_state != prev_button_state) {
// save the last state of button
prev_button_state = button_state;
}
// DO OTHER WORKS HERE
}
Étapes Rapides
- Téléversez ce programme de la même façon que ci-dessus (créez une nouvelle application ou remplacez le programme dans l'existant).
- Appuyez plusieurs fois rapidement sur le bouton — chaque appui est détecté sans interruption.
- Conseil : Ajoutez d'autres tâches dans // DO OTHER WORKS HERE — la LED continuera à clignoter pendant l'exécution de ces tâches.
Ajout de Tâches Supplémentaires — Deux LEDs Clignotant à Différentes Vitesses
Cet exemple fait clignoter deux LEDs à des intervalles différents tout en continuant à détecter les appuis sur le bouton — le tout sans aucun delay() :
- LED 1 clignote toutes les 1000ms
- LED 2 clignote toutes les 500ms
- Les deux fonctionnent indépendamment avec des variables prev_millis séparées
- Les appuis sur le bouton ne sont jamais manqués
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
#define LED_PIN_1 3 // The Arduino UNO Q pin connected to LED 1
#define LED_PIN_2 4 // The Arduino UNO Q pin connected to LED 2
#define BUTTON_PIN 7 // The Arduino UNO Q pin connected to the button
#define BLINK_INTERVAL_1 1000 // interval at which to blink LED 1 (milliseconds)
#define BLINK_INTERVAL_2 500 // interval at which to blink LED 2 (milliseconds)
int led_state_1 = LOW; // led_state used to set LED 1
int led_state_2 = LOW; // led_state used to set LED 2
int prev_button_state = LOW; // will store last button state
unsigned long prev_millis_1 = 0; // will store last time LED 1 was updated
unsigned long prev_millis_2 = 0; // will store last time LED 2 was updated
void setup() {
pinMode(LED_PIN_1, OUTPUT);
pinMode(LED_PIN_2, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
}
void loop() {
unsigned long current_millis = millis();
// check to see if it's time to blink LED 1
if (current_millis - prev_millis_1 >= BLINK_INTERVAL_1) {
led_state_1 = (led_state_1 == LOW) ? HIGH : LOW;
digitalWrite(LED_PIN_1, led_state_1);
prev_millis_1 = current_millis;
}
// check to see if it's time to blink LED 2
if (current_millis - prev_millis_2 >= BLINK_INTERVAL_2) {
led_state_2 = (led_state_2 == LOW) ? HIGH : LOW;
digitalWrite(LED_PIN_2, led_state_2);
prev_millis_2 = current_millis;
}
// check button state's change
int button_state = digitalRead(BUTTON_PIN);
if (button_state != prev_button_state) {
prev_button_state = button_state;
}
// DO OTHER WORKS HERE
}
Étapes Rapides
- Ajoutez une deuxième LED (avec résistance 220Ω) à la broche 4.
- Téléversez ce programme — les deux LEDs clignoteront chacune à leur propre cadence indépendante.
- Conseil : Ajoutez d'autres LEDs avec leurs propres intervalles en ajoutant plus de variables prev_millis_N et de blocs if.
Programmation Bridge Linux + MCU
L'Arduino UNO Q dispose de deux processeurs fonctionnant ensemble : le MPU (Qualcomm, exécute Debian Linux) et le MCU (STM32, exécute Zephyr OS avec votre programme Arduino). Ils communiquent via RPC grâce à la bibliothèque Arduino_RouterBridge — jamais via des ports série bruts.
- La LED est connectée au MCU (STM32) — câblée à une broche numérique du STM32. Le MCU la fait clignoter en utilisant une boucle millis() non bloquante.
- Le MPU ne peut pas contrôler la LED directement — il envoie des commandes au MCU via Bridge.call(). Le MCU exécute la fonction Bridge.provide_safe() enregistrée et agit sur la LED.
- Le MPU dispose du Wi-Fi — il peut se connecter à Internet et recevoir des commandes Telegram, contrôler la vitesse de clignotement à distance, etc.
- Communication : Bridge.call() côté Linux invoque Bridge.provide_safe() côté MCU
- ⚠️ Réservé : /dev/ttyHS1 (Linux) et Serial1 (MCU) sont utilisés par le routeur Arduino — ne les ouvrez jamais directement
En résumé : Le MPU envoie la commande d'intervalle → le MCU la reçoit → le MCU ajuste la vitesse de clignotement LED en temps réel.
Programme MCU — clignotement LED non bloquant avec contrôle de vitesse à distance :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
#include "Arduino_RouterBridge.h"
#define LED_PIN 3
#define BLINK_INTERVAL_DEFAULT 1000
int led_state = LOW;
unsigned long prev_millis = 0;
unsigned long blink_interval = BLINK_INTERVAL_DEFAULT;
bool blinking = true;
void setup() {
Bridge.begin();
Monitor.begin();
pinMode(LED_PIN, OUTPUT);
Bridge.provide_safe("set_interval", set_interval);
Bridge.provide_safe("blink_start", blink_start);
Bridge.provide_safe("blink_stop", blink_stop);
Monitor.println("Blink Bridge ready");
}
void loop() {
if (!blinking) return;
unsigned long current_millis = millis();
if (current_millis - prev_millis >= blink_interval) {
led_state = (led_state == LOW) ? HIGH : LOW;
digitalWrite(LED_PIN, led_state);
prev_millis = current_millis;
}
}
void set_interval(int ms) {
blink_interval = ms;
}
void blink_start() {
blinking = true;
}
void blink_stop() {
blinking = false;
digitalWrite(LED_PIN, LOW);
}
Script Python (Arduino App Lab) — contrôle de la vitesse de clignotement depuis Linux :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
from arduino.app_utils import *
import time
def loop():
print("Setting blink interval to 200ms (fast)")
Bridge.call("set_interval", 200)
time.sleep(3)
print("Setting blink interval to 1000ms (slow)")
Bridge.call("set_interval", 1000)
time.sleep(3)
print("Stopping blink")
Bridge.call("blink_stop")
time.sleep(2)
print("Starting blink again")
Bridge.call("blink_start")
time.sleep(3)
App.run(user_loop=loop)
- Remarque : Assurez-vous que Bridge.begin() est appelé dans le programme MCU et que le programme est téléversé avant d'exécuter le script Python côté Linux.
- ⚠️ Avertissement : N'ouvrez jamais directement /dev/ttyHS1 (sous Linux) ou Serial1 (sur MCU) dans votre code — ces ports sont réservés par le routeur Arduino et y accéder brisera le Bridge.
Étapes Rapides
- Téléversez le programme MCU : Ouvrez Arduino App Lab, créez une nouvelle application, collez le programme MCU Bridge ci-dessus dans sketch/sketch.ino, puis cliquez sur Exécuter.
- Ajoutez le script Python : Collez le code Python ci-dessus dans l'onglet Python de la même application.
- Exécutez l'application : Cliquez sur Exécuter — la LED commence à clignoter. Le côté Python changera la vitesse automatiquement toutes les quelques secondes.
- Vérifiez la console : Ouvrez l'onglet Console → sous-onglet Console Python pour voir les messages de changement de vitesse.
- Conseil : Appelez Bridge.call("blink_stop") depuis Python pour arrêter la LED, puis Bridge.call("blink_start") pour reprendre — le MCU le gère instantanément.
Sortie de la Console App Lab
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
Setting blink interval to 200ms (fast)
Setting blink interval to 1000ms (slow)
Stopping blink
Starting blink again
Intégration Telegram
Vous pouvez contrôler la vitesse de clignotement LED à distance via Telegram — envoyez une commande depuis n'importe où et la LED répond instantanément.
Si vous n'avez pas encore de bot Telegram, consultez Arduino UNO Q - Bot Telegram pour obtenir votre token de bot avant de continuer.
Cette section couvre :
- Exécuter un script Python côté Linux de l'Arduino UNO Q pour écouter les messages Telegram
- Transférer la vitesse de clignotement ou les commandes de démarrage/arrêt côté MCU via Bridge.call()
- Envoyer une réponse de confirmation à Telegram
Programme MCU : Conservez le même programme MCU de la section Bridge précédente — aucune modification nécessaire. Assurez-vous qu'il est déjà téléversé et en cours d'exécution sur le STM32 avant de continuer.
Script Python (Arduino App Lab) — bot Telegram pour le contrôle du clignotement LED :
/*
* Ce code Arduino UNO Q a été développé par newbiely.fr
* Ce code Arduino UNO Q 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-uno-q/arduino-uno-q-blink-led-without-delay
*/
from arduino.app_utils import *
import requests
import time
BOT_TOKEN = "YOUR_BOT_TOKEN"
API_URL = f"https://api.telegram.org/bot{BOT_TOKEN}"
last_update_id = 0
def send_message(chat_id, text):
requests.post(f"{API_URL}/sendMessage", json={"chat_id": chat_id, "text": text})
def get_updates():
global last_update_id
resp = requests.get(f"{API_URL}/getUpdates", params={"offset": last_update_id + 1, "timeout": 5})
return resp.json().get("result", [])
def loop():
global last_update_id
updates = get_updates()
for update in updates:
last_update_id = update["update_id"]
msg = update.get("message", {})
chat_id = msg.get("chat", {}).get("id")
text = msg.get("text", "").strip()
if text.startswith("/blink "):
try:
ms = int(text.split()[1])
Bridge.call("set_interval", ms)
Bridge.call("blink_start")
send_message(chat_id, f"Blinking every {ms}ms")
except ValueError:
send_message(chat_id, "Usage: /blink <milliseconds>")
elif text == "/stop":
Bridge.call("blink_stop")
send_message(chat_id, "LED stopped")
elif text == "/start":
Bridge.call("blink_start")
send_message(chat_id, "LED blinking")
else:
send_message(chat_id, "Commands:\n/blink <ms> — set blink interval\n/stop — stop blinking\n/start — start blinking")
time.sleep(1)
App.run(user_loop=loop)
- Remarque : Remplacez YOUR_BOT_TOKEN par le token obtenu depuis @BotFather sur Telegram.
- Envoyez /blink 200 pour faire clignoter la LED rapidement. Envoyez /blink 2000 pour clignoter lentement.
- Envoyez /stop pour arrêter le clignotement. Envoyez /start pour reprendre.
Étapes Rapides
- Téléversez le programme MCU : Utilisez le programme MCU Bridge de la section précédente (téléversez-le d'abord s'il ne l'est pas déjà).
- Collez le script Telegram : Copiez le code Python ci-dessus dans l'onglet Python de votre application dans Arduino App Lab.
- Définissez votre token : Remplacez YOUR_BOT_TOKEN dans le script par votre vrai token de bot.
- Exécutez l'application : Cliquez sur Exécuter — le bot commence à écouter les messages Telegram immédiatement.
- Testez : Envoyez /blink 100 pour un clignotement très rapide, ou /stop pour figer la LED.
- Conseil : Essayez /blink 50 pour un clignotement très rapide qui ressemble à une lueur faible.