Arduino UNO Q - LED - Blinken ohne Verzögerung
Wenn Ihr Arduino UNO Q zwei Dinge gleichzeitig tun muss – wie das Blinken einer LED und das Auslesen einer Taste – wird die delay()-Funktion zum Problem. Sie friert das MCU ein und führt zu verpassten Ereignissen. In diesem Tutorial erfahren Sie, wie Sie eine LED ohne delay() mit Hilfe von millis() blinken lassen, damit der Arduino UNO Q reibungslos mehrere Aufgaben gleichzeitig ausführen kann.
※ Notiz:
- Diese Methode tut mehr als nur eine LED zum Blinken bringen und den Tastenstatus prüfen. Sie ermöglicht es dem Arduino UNO Q, mehrere Aufgaben gleichzeitig ohne Unterbrechung auszuführen.
In diesem Tutorial erfahren Sie:
- Warum delay() Probleme in Multitasking-Programmen verursacht
- Wie Sie eine LED ohne delay() mit Hilfe von millis() auf Arduino UNO Q blinken lassen
- Wie Sie zwei LEDs mit unterschiedlichen Geschwindigkeiten gleichzeitig zum Blinken bringen
- Wie Sie sowohl die Linux-Seite (Python) als auch die MCU-Seite (C/C++ Arduino-Code) programmieren, um die Blinkgeschwindigkeit von der Linux-Seite zu steuern
- Wie Sie Telegram verwenden, um die LED-Blinkgeschwindigkeit auf Arduino UNO Q aus der Ferne zu steuern
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Kaufhinweis: Um den Verdrahtungsprozess zu vereinfachen, empfehlen wir die Verwendung des LED Module, das mit einem eingebauten Widerstand geliefert wird.
Über LED und Taste
Informationen zu LED und Taste (Pinbelegung, Funktionsweise, Programmierung) finden Sie in diesen Tutorials:
Schaltplan
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
MCU-Code — Mit delay() (Problembeschreibung)
Der Arduino UNO Q hat zwei Prozessoren: das STM32-MCU (handhabt Echtzeitsteuerung von Hardware) und das Qualcomm MPU (führt Debian Linux aus). In diesem Abschnitt wird nur das STM32-MCU programmiert. Ein späterer Abschnitt zeigt, wie beide Prozessoren zusammenarbeiten.
Dieses erste Beispiel verwendet delay() zum Blinken der LED – und zeigt warum dies ein Problem ist:
- Die LED blinkt jede 1 Sekunde mit delay(1000)
- Während delay() wartet, ist das MCU vollständig gefroren – es kann Tastendrücke nicht erkennen
- Drücken Sie die Taste mehrmals und beobachten Sie, dass viele Drücke übersehen werden
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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;
}
}
Schnelle Schritte
- Erste Schritte mit Arduino UNO Q? Folgen Sie dem Erste Schritte mit Arduino UNO Q-Tutorial, um Ihre Entwicklungsumgebung vorzubereiten, bevor Sie fortfahren.
- Komponenten verdrahten: Verbinden Sie die LED (mit 220Ω-Widerstand) mit Pin 3 und die Taste mit Pin 7 gemäß Schaltplan.
- Verbinden: Schließen Sie den Arduino UNO Q mit einem USB-C-Kabel an Ihren Computer an.
- Öffnen Sie Arduino App Lab: Starten Sie Arduino App Lab und warten Sie, bis es Ihren Arduino UNO Q erkennt – dies kann beim ersten Start mehrere Minuten dauern.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Neue App erstellen.
- Geben Sie der App einen Namen, z. B.: DIYables_BlinkDelay
- Klicken Sie auf Erstellen, um zu bestätigen.
- Sie werden eine Reihe von Ordnern und Dateien in Ihrer neuen App sehen.
- Finden Sie die Datei sketch/sketch.ino – hier werden Sie die MCU-Skizze einfügen.
Skizze einfügen: Kopieren Sie den MCU-Code oben und fügen Sie ihn in die Skizzendatei ein. Behalten Sie andere Dateien im Standardzustand bei.
- 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
- Hochladen: Klicken Sie auf die Schaltfläche "Ausführen" in Arduino App Lab, um den Code zu kompilieren und auf den STM32 hochzuladen.
- Test: Drücken Sie die Taste mehrmals schnell hintereinander – beachten Sie, dass viele Drücke ignoriert werden, da delay() das MCU blockiert.
- Pro-Tipp: Dies ist das Problem, das millis() löst – siehe das nächste Beispiel.
MCU-Code — Ohne delay() (Lösung)
Dieses Beispiel verwendet millis(), um die LED ohne Blockierung zum Blinken zu bringen – das MCU prüft die verstrichene Zeit und handelt nur wenn nötig, sodass es weiterhin jeden Tastendruck erkennen kann:
- Verwendet millis() und prev_millis, um nachzuverfolgen, wann die LED umgeschaltet werden soll
- Ruft niemals delay() auf – das MCU ist immer frei für andere Aufgaben
- Drücken Sie die Taste und beobachten Sie, dass jeder Druck erkannt wird, auch während die LED blinkt
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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
}
Schnelle Schritte
- Laden Sie diese Skizze genauso wie oben hoch (erstellen Sie eine neue App oder ersetzen Sie die Skizze in der vorhandenen).
- Drücken Sie die Taste mehrmals schnell hintereinander – jeder Druck wird ohne Unterbrechung erkannt.
- Pro-Tipp: Fügen Sie mehr Aufgaben in // DO OTHER WORKS HERE ein – die LED wird weiter blinken, während diese Aufgaben ausgeführt werden.
Weitere Aufgaben hinzufügen — Zwei LEDs blinken mit unterschiedlichen Geschwindigkeiten
Dieses Beispiel lässt zwei LEDs mit unterschiedlichen Intervallen blinken und erkennt weiterhin Tastendrücke – alles ohne delay():
- LED 1 blinkt alle 1000 ms
- LED 2 blinkt alle 500 ms
- Beide laufen unabhängig voneinander mit separaten prev_millis-Variablen
- Tastendrücke werden niemals übersehen
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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
}
Schnelle Schritte
- Fügen Sie eine zweite LED (mit 220Ω-Widerstand) zu Pin 4 hinzu.
- Laden Sie diese Skizze hoch – beide LEDs blinken mit ihren eigenen unabhängigen Raten.
- Pro-Tipp: Fügen Sie weitere LEDs mit ihren eigenen Intervallen hinzu, indem Sie mehr prev_millis_N-Variablen und if-Blöcke hinzufügen.
Linux + MCU-Brückenprogrammierung
Der Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten: das MPU (Qualcomm, führt Debian Linux aus) und das MCU (STM32, führt Zephyr OS mit Ihrem Arduino-Sketch aus). Sie kommunizieren über RPC über die Arduino_RouterBridge-Bibliothek – niemals über rohe serielle Anschlüsse.
- Die LED ist mit dem MCU (STM32) verbunden – verdrahtet mit einem digitalen Pin am STM32. Das MCU lässt sie mit einer nicht blockierenden millis()-Schleife blinken.
- Das MPU kann die LED nicht direkt steuern – es sendet Befehle an das MCU über Bridge.call(). Das MCU führt die registrierte Bridge.provide_safe()-Funktion aus und handhabt die LED.
- Das MPU hat Wi-Fi – es kann sich mit dem Internet verbinden und Dinge tun, die das MCU nicht kann: Telegram-Befehle empfangen, Blinkgeschwindigkeit aus der Ferne steuern und vieles mehr.
- Kommunikation: Bridge.call() auf der Linux-Seite ruft Bridge.provide_safe()-Funktionen auf der MCU-Seite auf
- ⚠️ Reserviert: /dev/ttyHS1 (Linux) und Serial1 (MCU) werden vom Arduino Router verwendet – öffnen Sie sie niemals direkt
Kurz gesagt: MPU sendet den Intervallbefehl → MCU empfängt ihn → MCU passt die LED-Blinkgeschwindigkeit in Echtzeit an.
MCU-Skizze – LED-Blinken ohne Blockierung mit Remote-Geschwindigkeitssteuerung:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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);
}
Python-Skript (Arduino App Lab) – Blinkgeschwindigkeit von Linux aus steuern:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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)
- Hinweis: Stellen Sie sicher, dass Bridge.begin() in der MCU-Skizze aufgerufen wird und die Skizze hochgeladen wurde, bevor Sie das Python-Skript auf der Linux-Seite ausführen.
- ⚠️ Warnung: Öffnen Sie niemals direkt /dev/ttyHS1 (unter Linux) oder verwenden Sie Serial1 (auf MCU) in Ihrem Code – diese sind vom Arduino Router reserviert und der Zugriff darauf unterbricht die Bridge.
Schnelle Schritte
- MCU-Skizze hochladen: Öffnen Sie Arduino App Lab, erstellen Sie eine neue App, fügen Sie die oben angegebene Bridge-MCU-Skizze in sketch/sketch.ino ein, und klicken Sie auf "Ausführen".
- Python-Skript hinzufügen: Fügen Sie den obigen Python-Code in die Python-Registerkarte derselben App ein.
- Führen Sie die App aus: Klicken Sie auf "Ausführen" – die LED beginnt zu blinken. Die Python-Seite ändert automatisch alle paar Sekunden die Geschwindigkeit.
- Überprüfen Sie die Konsole: Öffnen Sie die Registerkarte "Konsole" → Unterregisterkarte "Python-Konsole", um Meldungen zur Geschwindigkeitsänderung anzuzeigen.
- Pro-Tipp: Rufen Sie Bridge.call("blink_stop") von Python aus auf, um die LED zu stoppen, dann Bridge.call("blink_start"), um fortzufahren – das MCU handhabt es sofort.
App Lab-Konsolenausgabe
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
Telegram-Integration
Sie können die LED-Blinkgeschwindigkeit aus der Ferne über Telegram steuern – senden Sie einen Befehl von überall, und die LED antwortet sofort.
Wenn Sie noch keinen Telegram-Bot haben, lesen Sie Wie man einen Telegram-Bot erstellt, um Ihr Bot-Token vor dem Fortfahren zu erhalten.
Dieser Abschnitt behandelt:
- Ausführung eines Python-Skripts auf der Linux-Seite von Arduino UNO Q zum Abhören von Telegram-Nachrichten
- Weiterleitung von Blinkgeschwindigkeit oder Start-/Stoppbefehlen an die MCU-Seite über Bridge.call()
- Rücksennung einer Bestätigungsantwort an Telegram
MCU-Skizze: Behalten Sie die gleiche MCU-Skizze aus dem vorherigen Bridge-Abschnitt – keine Änderungen erforderlich. Stellen Sie sicher, dass sie bereits auf den STM32 hochgeladen und ausgeführt wird, bevor Sie fortfahren.
Python-Skript (Arduino App Lab) – Telegram-Bot zur LED-Blinksteuerung:
/*
* Dieser Arduino UNO Q Code wurde von newbiely.de entwickelt
* Dieser Arduino UNO Q Code wird der Öffentlichkeit ohne jegliche Einschränkung zur Verfügung gestellt.
* Für vollständige Anleitungen und Schaltpläne besuchen Sie bitte:
* https://newbiely.de/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)
- Hinweis: Ersetzen Sie YOUR_BOT_TOKEN durch das Token, das Sie von @BotFather auf Telegram erhalten haben.
- Senden Sie /blink 200, um die LED schnell blinken zu lassen. Senden Sie /blink 2000, um langsam zu blinken.
- Senden Sie /stop, um das Blinken zu beenden. Senden Sie /start, um fortzufahren.
Schnelle Schritte
- MCU-Skizze hochladen: Verwenden Sie die Bridge-MCU-Skizze aus dem vorherigen Abschnitt (laden Sie sie zuerst hoch, wenn nicht bereits geschehen).
- Telegram-Skript einfügen: Kopieren Sie den obigen Python-Code in die Python-Registerkarte Ihrer App in Arduino App Lab.
- Token festlegen: Ersetzen Sie YOUR_BOT_TOKEN im Skript durch Ihr tatsächliches Bot-Token.
- Führen Sie die App aus: Klicken Sie auf "Ausführen" – der Bot beginnt sofort mit dem Abhören von Telegram-Nachrichten.
- Test: Senden Sie /blink 100 für sehr schnelles Blinken oder /stop, um die LED einzufrieren.
- Pro-Tipp: Versuchen Sie /blink 50 für ein sehr schnelles Blinken, das wie ein schwaches Leuchten aussieht.