Arduino UNO Q - Ampelmodul
In diesem Tutorial erfahren Sie, wie Sie ein Ampelmodul mit Arduino UNO Q steuern. Wir werden mehrere Programmieransätze behandeln — von einer einfachen delay()-basierten Sequenz bis zu einer nicht-blockierenden millis()-Version — und dann das Projekt erweitern, um die Fernsteuerung der Lichtzeitdauern über Telegram zu ermöglichen.
In diesem Tutorial erfahren Sie:
- Wie Sie ein Ampelmodul mit Arduino UNO Q verdrahten
- Wie Sie den Arduino UNO Q MCU programmieren, um durch rotes, gelbes und grünes Licht zu wechseln
- Wie Sie einen millis()-basierten Ansatz für nicht-blockierende Ampelsteuerung verwenden
- Wie Sie die Lichtzeitdauern remote über Telegram anpassen
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.
Über das Ampelmodul
Pinbelegung
Ein Ampelmodul hat 4 Pins:
- GND-Pin: Mit GND auf Arduino UNO Q verbinden
- R-Pin: Steuert das rote Licht — mit einem digitalen Ausgang verbinden
- Y-Pin: Steuert das gelbe Licht — mit einem digitalen Ausgang verbinden
- G-Pin: Steuert das grüne Licht — mit einem digitalen Ausgang verbinden
Schaltplan
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Wie man ein Ampelmodul programmiert
Legen Sie die Signalpins als digitale Ausgänge fest:
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
Aktivieren Sie das rote Licht:
digitalWrite(PIN_RED, HIGH); // rotes Licht einschalten
digitalWrite(PIN_YELLOW, LOW); // gelbes Licht ausschalten
digitalWrite(PIN_GREEN, LOW); // grünes Licht ausschalten
delay(RED_TIME); // rotes Licht für die festgelegte Dauer halten
MCU-Code — Ampelmodul (einfach)
Der Arduino UNO Q hat zwei Prozessoren: den STM32 MCU (verwaltet die Echtzeitkontrolle der Hardware) und die Qualcomm MPU (führt Debian Linux aus). In diesem Abschnitt wird nur der STM32 MCU programmiert — die Linux-Seite bleibt untätig. Ein späterer Abschnitt zeigt, wie beide Prozessoren zusammenarbeiten.
Dieses Beispiel wechselt mit delay() zwischen rot, gelb und grün:
/*
* 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-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin connected to G pin of traffic light module
#define RED_TIME 4000 // RED time in millisecond
#define YELLOW_TIME 4000 // YELLOW time in millisecond
#define GREEN_TIME 4000 // GREEN time in millisecond
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
// red light on
digitalWrite(PIN_RED, HIGH); // turn on
digitalWrite(PIN_YELLOW, LOW); // turn off
digitalWrite(PIN_GREEN, LOW); // turn off
delay(RED_TIME); // keep red light on during a period of time
// yellow light on
digitalWrite(PIN_RED, LOW); // turn off
digitalWrite(PIN_YELLOW, HIGH); // turn on
digitalWrite(PIN_GREEN, LOW); // turn off
delay(YELLOW_TIME); // keep yellow light on during a period of time
// green light on
digitalWrite(PIN_RED, LOW); // turn off
digitalWrite(PIN_YELLOW, LOW); // turn off
digitalWrite(PIN_GREEN, HIGH); // turn on
delay(GREEN_TIME); // keep green light on during a period of time
}
Schnellschritte
- Erste Schritte mit Arduino UNO Q? Folgen Sie dem Leitfaden "Erste Schritte mit Arduino UNO Q", um Ihre Entwicklungsumgebung vorzubereiten, bevor Sie fortfahren.
- Verdrahten Sie das Modul: Verbinden Sie das Ampelmodul gemäß dem Schaltplan mit den Pins 2, 3 und 4.
- Verbinden Sie: 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.
- Erstellen Sie eine neue App: Klicken Sie auf die Schaltfläche Neue App erstellen.
- Geben Sie der App einen Namen, z. B.: DIYables_TrafficLight
- Klicken Sie auf Erstellen, um zu bestätigen.
- Sie sehen eine Reihe von Ordnern und Dateien, die in Ihrer neuen App generiert werden.
- Suchen Sie die Datei sketch/sketch.ino — hier werden Sie den MCU-Sketch einfügen.
Sketch einfügen: Kopieren Sie den MCU-Code oben und fügen Sie ihn in die Sketchdatei ein. Behalten Sie andere Dateien im Standardzustand.
- 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 in Arduino App Lab auf die Schaltfläche "Ausführen", um den Code zu kompilieren und auf den STM32 hochzuladen.
- Überprüfen Sie das Modul: Das Ampelmodul sollte folgende Abfolge zeigen: rot → gelb → grün → rot, sich wiederholend.
- Profi-Tipp: Die Timing-Werte der Ampel unterscheiden sich je nach Standort und Kreuzungsdesign. Passen Sie die Werte RED_TIME, YELLOW_TIME und GREEN_TIME an, um das gewünschte Verhalten zu erzielen.
MCU-Code — Reinere Version mit einer Funktion
Die Verwendung einer Hilfsfunktion macht den Code kürzer und leichter zu verwalten:
/*
* 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-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin connected to G pin of traffic light module
#define RED_TIME 2000 // RED time in millisecond
#define YELLOW_TIME 1000 // YELLOW time in millisecond
#define GREEN_TIME 2000 // GREEN time in millisecond
#define RED 0 // Index in array
#define YELLOW 1 // Index in array
#define GREEN 2 // Index in array
const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN };
const int times[] = { RED_TIME, YELLOW_TIME, GREEN_TIME };
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
}
// the loop function runs over and over again forever
void loop() {
trafic_light_on(RED);
delay(times[RED]); // keep red light on during a period of time
trafic_light_on(YELLOW);
delay(times[YELLOW]); // keep yellow light on during a period of time
trafic_light_on(GREEN);
delay(times[GREEN]); // keep green light on during a period of time
}
void trafic_light_on(int light) {
for (int i = RED; i <= GREEN; i++) {
if (i == light)
digitalWrite(pins[i], HIGH); // turn on
else
digitalWrite(pins[i], LOW); // turn off
}
}
- Profi-Tipp: Die Funktion trafic_light_on(int light) schaltet genau ein Licht ein und schaltet die anderen aus — sauber und wiederverwendbar.
MCU-Code — Nicht-blockierende Version mit millis()
Die Funktion delay() blockiert den gesamten anderen Code während des Wartens. Für responsive Programme (z. B. Knöpfe oder Sensoren lesen, während die Ampel läuft), verwenden Sie stattdessen millis():
/*
* 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-traffic-light
*/
#define PIN_RED 2 // The Arduino UNO Q pin connected to R pin of traffic light module
#define PIN_YELLOW 3 // The Arduino UNO Q pin connected to Y pin of traffic light module
#define PIN_GREEN 4 // The Arduino UNO Q pin connected to G pin of traffic light module
#define RED 0 // Index in array
#define YELLOW 1 // Index in array
#define GREEN 2 // Index in array
const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN };
int times[] = { 2000, 1000, 2000 }; // RED, YELLOW, GREEN durations in ms
unsigned long last_time = 0;
int light = RED; // start with RED light
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
trafic_light_on(light);
last_time = millis();
}
void loop() {
if ((millis() - last_time) > (unsigned long)times[light]) {
light++;
if (light >= 3)
light = RED; // new cycle
trafic_light_on(light);
last_time = millis();
}
// TO DO: your other code here
}
void trafic_light_on(int light) {
for (int i = RED; i <= GREEN; i++) {
if (i == light)
digitalWrite(pins[i], HIGH); // turn on
else
digitalWrite(pins[i], LOW); // turn off
}
}
- Profi-Tipp: Mit millis() können Sie Button- oder Sensor-Code in loop() neben der Ampellogik einfügen — sie laufen gleichzeitig, ohne sich gegenseitig zu blockieren.
Linux + MCU Bridge-Programmierung
Der Arduino UNO Q hat zwei Prozessoren, die zusammenarbeiten: die MPU (Qualcomm, führt Debian Linux aus) und der MCU (STM32, führt Zephyr OS mit Ihrem Arduino-Sketch aus). Sie kommunizieren über RPC via der Arduino_RouterBridge-Bibliothek — niemals über rohe serielle Ports.
- Das Ampelmodul ist mit dem MCU (STM32) verbunden — verdrahtet mit digitalen Ausgangspins auf dem STM32. Der MCU wechselt die Lichter mit nicht-blockierendem millis()-Timing.
- Die MPU kann die Lichter nicht direkt steuern — sie muss Befehle an den MCU über Bridge.call() senden. Der MCU führt die registrierten Bridge.provide()-Funktionen aus.
- Die MPU hat Wi-Fi — da die MPU vollständiges Debian Linux mit Wi-Fi ausführt, kann sie Telegram-Befehle empfangen und die Lichtzeitdauern remote aktualisieren.
- Kommunikation: Bridge.call() auf der Linux-Seite ruft Bridge.provide()-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 Timing-Befehle → MCU empfängt sie → MCU aktualisiert Lichtzeitdauern in Echtzeit.
MCU-Sketch — Ampelmodul mit Bridge-Timing-Steuerung:
/*
* 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-traffic-light
*/
#include "Arduino_RouterBridge.h"
#define PIN_RED 2
#define PIN_YELLOW 3
#define PIN_GREEN 4
#define RED 0
#define YELLOW 1
#define GREEN 2
const int pins[] = { PIN_RED, PIN_YELLOW, PIN_GREEN };
int times[] = { 2000, 1000, 2000 }; // RED, YELLOW, GREEN durations in ms
unsigned long last_time = 0;
int current_light = RED;
const char* light_names[] = { "RED", "YELLOW", "GREEN" };
void trafic_light_on(int light) {
for (int i = RED; i <= GREEN; i++) {
if (i == light)
digitalWrite(pins[i], HIGH);
else
digitalWrite(pins[i], LOW);
}
Monitor.println("Light changed to: " + String(light_names[light]));
}
void set_timing(int red_ms, int yellow_ms, int green_ms) {
times[RED] = red_ms;
times[YELLOW] = yellow_ms;
times[GREEN] = green_ms;
Monitor.println("Timings updated: RED=" + String(red_ms) + "ms, YELLOW=" + String(yellow_ms) + "ms, GREEN=" + String(green_ms) + "ms");
}
void get_status() {
Monitor.println("Current light: " + String(light_names[current_light]));
}
void setup() {
pinMode(PIN_RED, OUTPUT);
pinMode(PIN_YELLOW, OUTPUT);
pinMode(PIN_GREEN, OUTPUT);
Bridge.begin();
Monitor.begin();
Bridge.provide("set_timing", set_timing);
Bridge.provide("get_status", get_status);
trafic_light_on(current_light);
last_time = millis();
Monitor.println("Traffic Light Bridge ready");
}
void loop() {
if ((millis() - last_time) > (unsigned long)times[current_light]) {
current_light++;
if (current_light >= 3)
current_light = RED;
trafic_light_on(current_light);
last_time = millis();
}
}
Python-Skript (Arduino App Lab) — Lichtzeitdauer 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-traffic-light
*/
from arduino.app_utils import *
import time
def loop():
print("Setting normal timing: RED=3s, YELLOW=1s, GREEN=3s")
Bridge.call("set_timing", 3000, 1000, 3000)
time.sleep(10)
print("Setting fast timing: RED=1s, YELLOW=0.5s, GREEN=1s")
Bridge.call("set_timing", 1000, 500, 1000)
time.sleep(8)
print("Restoring default timing: RED=2s, YELLOW=1s, GREEN=2s")
Bridge.call("set_timing", 2000, 1000, 2000)
App.run(user_loop=loop)
- Hinweis: Stellen Sie sicher, dass Bridge.begin() im MCU-Sketch aufgerufen wird und der Sketch hochgeladen ist, bevor Sie das Python-Skript auf der Linux-Seite ausführen.
- ⚠️ Warnung: Öffnen Sie niemals direkt /dev/ttyHS1 (auf Linux) oder verwenden Sie Serial1 (auf MCU) in Ihrem Code — diese sind vom Arduino Router reserviert und der Zugriff darauf unterbricht die Bridge.
Schnellschritte
- Laden Sie den MCU-Sketch hoch: Öffnen Sie Arduino App Lab, erstellen Sie eine neue App, fügen Sie den obigen Bridge MCU-Sketch in sketch/sketch.ino ein, behalten Sie die Standardbibliotheken bei (keine zusätzliche Bibliothek erforderlich), und klicken Sie auf "Ausführen".
- Fügen Sie das Python-Skript hinzu: Fügen Sie den obigen Python-Code auf der Python-Registerkarte derselben App ein.
- Führen Sie die App aus: Klicken Sie auf "Ausführen" — die Python-Seite passt die Ampeltiming automatisch an.
- Überprüfen Sie die Konsole: Öffnen Sie die Registerkarte "Konsole" → Unterregisterkarte "Python-Konsole", um die Timing-Updates anzuzeigen.
- Profi-Tipp: Ändern Sie das Python-Skript, um Timings basierend auf einem Zeitplan zu ändern (z. B. kürzerer Zyklus in der Nacht).
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
Setting normal timing: RED=3s, YELLOW=1s, GREEN=3s
Setting fast timing: RED=1s, YELLOW=0.5s, GREEN=1s
Restoring default timing: RED=2s, YELLOW=1s, GREEN=2s
Telegram-Integration
Sie können die Ampeltiming remote über Telegram anpassen — ändern Sie, wie lange jedes Licht von überall aus eingeschaltet bleibt.
Wenn Sie noch keinen Telegram-Bot haben, lesen Sie Wie man einen Telegram-Bot erstellt, um Ihr Bot-Token zu erhalten, bevor Sie fortfahren.
Dieser Abschnitt behandelt:
- Ausführung eines Python-Skripts auf der Linux-Seite des Arduino UNO Q, um auf Telegram-Nachrichten zu warten
- Weiterleitung von Timing-Befehlen an den MCU über Bridge.call()
- Senden einer Bestätigungsantwort zurück zu Telegram
MCU-Sketch: Verwenden Sie denselben MCU-Sketch aus dem vorherigen Bridge-Abschnitt — keine Änderungen erforderlich. Stellen Sie sicher, dass er bereits hochgeladen und auf dem STM32 ausgeführt wird, bevor Sie fortfahren.
Python-Skript (Arduino App Lab) — Telegram-Bot für Ampelsteuerung:
/*
* 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-traffic-light
*/
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("/timing "):
parts = text.split()
try:
red_ms = int(parts[1])
yellow_ms = int(parts[2])
green_ms = int(parts[3])
Bridge.call("set_timing", red_ms, yellow_ms, green_ms)
send_message(chat_id, f"Timings set: RED={red_ms}ms, YELLOW={yellow_ms}ms, GREEN={green_ms}ms")
except (ValueError, IndexError):
send_message(chat_id, "Usage: /timing <red_ms> <yellow_ms> <green_ms>\nExample: /timing 3000 1000 3000")
elif text == "/status":
Bridge.call("get_status")
send_message(chat_id, "Status requested — check the MCU monitor console")
else:
send_message(chat_id, "Commands:\n/timing <red_ms> <yellow_ms> <green_ms> — set light durations\n/status — check current light\n\nExample: /timing 3000 1000 3000")
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 /timing 3000 1000 3000, um ROT=3s, GELB=1s, GRÜN=3s einzustellen.
- Senden Sie /status, um zu überprüfen, welches Licht derzeit eingeschaltet ist (Status wird auf MCU-Monitor protokolliert).
Schnellschritte
- Laden Sie den MCU-Sketch hoch: Verwenden Sie den Bridge MCU-Sketch aus dem vorherigen Abschnitt (laden Sie ihn zuerst hoch, falls noch nicht geschehen).
- Fügen Sie das Telegram-Skript ein: Kopieren Sie den obigen Python-Code auf die Python-Registerkarte Ihrer App in Arduino App Lab.
- Legen Sie Ihr Token fest: 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, auf Telegram-Nachrichten zu warten.
- Testen Sie es: Senden Sie /timing 1000 500 1000 für einen schnellen Zyklus oder /timing 5000 2000 5000 für einen langsamen.
- Profi-Tipp: Fügen Sie einen Nachtzustand-Befehl hinzu, der ein langsam blinkendes gelbes Licht anwendet — großartig für Stunden mit wenig Verkehr.
App Lab Konsolenausgabe
sketch.ino
1#include "Arduino_RouterBridge.h"
Serial Monitor
Python
[2026-04-29 12:00:01] Telegram: /timing 3000 1000 3000
[2026-04-29 12:00:01] Timings set: RED=3000ms, YELLOW=1000ms, GREEN=3000ms
[2026-04-29 12:05:20] Telegram: /timing 1000 500 1000
[2026-04-29 12:05:20] Timings set: RED=1000ms, YELLOW=500ms, GREEN=1000ms
Telegram
12:45
Welcome to Telegram!
ArduinoBot
10:19
Chatting with Arduino...
BotFather
Yesterday
Your bot has been created.
ArduinoBot
bot
OpenClaw-Integration
Sie können die OpenClaw an dieses Tutorial anpassen, indem Sie die Anweisungen im Arduino UNO Q - OpenClaw Tutorial beachten
Anwendungs-/Projektideen
Hier sind einige Projektideen, die Sie mit einem Ampelmodul und Arduino UNO Q umsetzen können:
- Fußgängerüberweg-Simulation: Fügen Sie einen Knopf hinzu — das Drücken löst ein Fußgänger-Signal nach der grünen Phase aus
- Telegram-gesteuerte Kreuzung: Stellen Sie das Timing remote ein, um unterschiedliche Verkehrsdichten zu simulieren
- Zeitgesteuerter Zeitplan: Verwenden Sie die Linux-Uhr der MPU, um zwischen Tages-Timing (kurzer Zyklus) und Nacht-Timing (längeres Rot/Grün) zu wechseln
- Modelleisenbahn-Übergang: Verwenden Sie die Ampel, um einen Modelleisenbahn-Übergang zu steuern — grün, wenn der Zug weg ist, rot während er vorbeifährt
- Labstatus-Anzeige: Verwenden Sie rot/gelb/grün, um die Verfügbarkeitsstatus eines Laborraums anzuzeigen
Fordere dich selbst heraus
Versuchen Sie diese Herausforderungen mit dem Ampelmodul und Arduino UNO Q:
- Einfach: Ändern Sie das Timing so, dass die gelbe Phase nur 500 ms lang und die grüne Phase 4 Sekunden ist
- Mittel: Erweitern Sie den Bridge-Sketch, um eine force_light(int light)-Funktion bereitzustellen, die sofort zu einem bestimmten Licht wechselt (0=rot, 1=gelb, 2=grün) von Python aus
- Fortgeschritten: Erstellen Sie einen Telegram-Bot, der die Befehle /schedule day und /schedule night unterstützt, die jeweils automatisch einen anderen Satz von Timings anwenden