Bedienung der Rollladensteuerung über einen Telegram-Bot mit Raspberry Pi 3B+
Vorwort
Auch wenn die erste Version des Telegram-Bots auf dem Raspberry Pi recht stabil lief, haben sich im Laufe der Zeit doch einige Änderungswünsche ergeben. So war die erste Version nicht wirklich multiinstanzfähig. Auch das Timeout für inaktive Nutzer hatte ich nie so richtig zufriedenstellend zum Laufen gebracht. Deshalb beschloss ich, den Telegram-Bot komplett neu aufzusetzen. Dieses Mal mit einem Raspberry Pi 3B+ und dem Betriebssystem Trixie 32-Bit Lite (ohne grafische Oberfläche).Vorbereitungen auf dem Smartphone
Wie bei der ersten Version muss natürlich auch dieses Mal zunächst die Messenger-App Telegram installiert werden. Dazu einfach im jeweiligen App-Store nach „Telegram“ suchen und die App installieren. Anschließend wird der Bot erstellt. Dabei stehen inzwischen deutlich mehr Funktionen und Einstellungsmöglichkeiten zur Verfügung als bei der ersten Version.Ab jetzt ist der eigene Bot im Prinzip betriebsbereit. Wichtig hierbei ist, das vergebene Token (Bild7). Dieses wird später im Script des Raspberrys benötigt. Sollte das Token einmal vergessen worden sein - keine Panik. Man kann es sich über den "Botfather" immer wieder anzeigen lassen. Dazu einfach den Befehl "/mybots" an den Botfather senden. Nach der Auswahl des eigenen Bots ist das Token abrufbar. In diesem Menü sind auch diverse andere Einstellungen für den eigenen Bot möglich.
z.B.
- Profilbild hochladen
- Bot-Beschreibung eingeben
- Bot-Namen ändern
- diverse Privacy Einstellungen
- usw.
Vorbereitung der Hardware
An den Raspberry Pi ist folgende Peripherie angeschlossen:- Spannungsversorgung
- Rote LED über Vorwiderstand (Heartbeat-Kontrolle)
- Gelbe LED über Vorwiderstand (Zustandsanzeige SSH)
- Schwarzer Taster über Schutzwiderstand gegen Masse sowie Pull-up-Widerstand
- Gelber Taster über Schutzwiderstand gegen Masse sowie Pull-up-Widerstand
- TTL-UART-zu-RS232-Adapter an Pin 8 (TX) und Pin 10 (RX) - (GPIO15 und GPIO16)
|
Dieses Mal erfolgt die Spannungsversorgung ganz regulär über den Micro-USB-Anschluss. Der TTL-UART-zu-RS232-Adapter ist identisch mit dem in der Rollladensteuerung beschriebenen Adapter. Das bedeutet allerdings auch, dass für die Verbindung zwischen Raspberry Pi und der Rollladensteuerung ein Nullmodemkabel benötigt wird. Bei der alten Version hatte ich die LED über den Vorwiderstand an Masse angeschlossen. Das hatte einen unerwünschten Effekt zur Folge. Da die GPIO-Pins im unbenutzten Zustand 3,3 V führen (vermutlich über einen internen Pull-up), glimmte die LED bereits während des Bootvorgangs. Erst wenn der Dienst zur Steuerung der LED geladen wurde, hatte sie einen definierten Zustand. Um das von vornherein zu verhindern, sind die LEDs dieses Mal zum 3,3V Anschluss hin verdrahtet. Das erfordert lediglich eine Umkehr der Logik im Script: Pin LOW = LED an; Pin HIGH = LED aus.
| Bild des neuen Gehäuses wird noch ergänzt. |
Vorbereitung des Raspberry Pi
1. Image erstellen
Die folgende Anleitung beschreibt die Installation und Konfiguration des Betriebssystems Trixie 32Bit Lite auf dem Raspberry 3B+. (Zum Zeitpunkt der Erstellung dieser Seite war das die aktuelle Version.)Dazu nutze ich im Moment gerne das Tool "Raspberry Pi Imager" hier in der Version v2.0.12
Das hat den Vorteil, dass bereits beim Erzeugen des Images diverse Einstellungen für den Raspberry gemacht werden können.
z.B.:
- Hostname
- Zeitzone
- Tastaturlayout
- Benutzername und Passwort
- Wenn nötig WLAN Zugangsdaten (hier nicht verwendet)
- Interfaceeinstellungen
2. Erster Bootvorgang
- die so vorbereitete SD-Karte in den Raspberry legen
- Internetverbindung üner Ehternetbuchse herstellen (wenn kein WLAN konfiguriert wurde)
- Raspberry mit Spannung versorgen
3. Setup
Eine SSH-Verbindung herstellen – z.B. mit dem Programm Kitty.Nun sind einige Einstellungen vorzunehmen, dazu folgende Befehle in der Konsole ausführen:
sudo raspi-configEs startet ein Konfigurationstool in dem Folgende Einstellungen zu tätigen sind.
- 8 Update this tool to the latest version
- 5 Localisation Options -> Locale -> de_DE.UTF-8 UTF-8 (zusätzlich auswählen (mit Space))
- 3 Interface Options -> Serial Port -> shell? No -> hardware enabled? Yes
- 6 Advanced Options -> Expand Filesystem
- Finish -> reboot now? Yes
Nach dem Neustart wird der Raspberry mit folgenden Befehlen auf den neuesten Stand gebracht:
sudo apt-get update #Paketlisten aktualisieren sudo apt-get -d upgrade #neue Pakete (nur) herunterladen sudo apt-get -y upgrade #neue Pakete installieren sudo reboot #Neustart
ggf. fehlende Programme/Bibliotheken nachistallieren
sudo apt-get install python3-serial #Modul fuer serielle Schnittstelle sudo apt-get install python3-dev #Entwicklungstools sudo apt-get install python3-rpi.gpio #GPIO Lib sudo apt-get install python3-python-telegram-bot #Telegram API Lib sudo apt-get install python3-apscheduler #fuer das Timeout sudo reboot #Neustart
nur beim (ab?) Raspberry Pi 3
Der Raspberry Pi 3 Model B+ verfügt über ein Bluetooth-Modul, welches an die Hardware-UART-Schnittstelle (ttyAMA0) des Prozessors angeschlossen ist. (Bei den älteren Modellen war die Hardware-UART-Schnittstelle direkt mit der Stiftleiste verbunden.) Standardmäig ist beim Raspberry 3 Model B jetzt eine Software-UART-Schnittstelle (ttyS0) mit der Stiftleiste verbunden. Die Baudraten werden damit nicht befriedigend eingehalten. Bei Trixie genügt für das Remapping eine Änderung in der Datei/boot/firmware/config.txt
Datei in einem Editor öffnen z.B.:
sudo nano /boot/firmware/config.txtDann die Zeile "enable_uart=1" suchen und oberhalb davon folgenden text ergänzen:
dtoverlay=disable-bt
Mit [STRG]+[X] den Editor beenden und die Änderungen mit [j] [ENTER]speichern.
Dabei wird die ttyAMA0 automatisch wieder auf die Stiftleiste gemappt.
Ab jetzt ist der Raspberry auf dem neuesten Stand und die Hardware-UART-Schnittstelle (ttyAMA0) für unsere Bedürfnisse angepasst.
Jetzt kommen die Python-Scripte ins Spiel. Als erstes wird das Script für die LEDs und die Taster beschrieben. Die rote LED dient zur Betriebsanzeige und der schwarze Taster zum definierten Herunterfahren des Raspberrys. Wird der schwarze Taster länger als 3 Sekunden betätigt, führt dies zum Shutdown. Im Normalbetrieb blitzt die LED zyklisch kurz auf. Dazu eine Datei "gpoi.py" erzeugen, diese ausführbar machen und anschließend im Editor öffnen:
mkdir /home/stefan/gpio touch /home/stefan/gpio/gpio.py chmod +x /home/stefan/gpio/gpio.py nano /home/stefan/gpio/gpio.pyFolgenden Inhalt in die Datei schreiben (hier noch ohne die Anteile für SSH):
#!/usr/bin/python # -*- coding: utf-8 -*- import sys import os import RPi.GPIO as GPIO import time import threading GPIO.setmode(GPIO.BOARD) #Pinheadernummern als Referenz benutzen red_led_pin = 5 #rote LED an Pin5 über 330R Vorwiederstand mit VCC verbunden yellow_led_pin = 7 #gelbe LED an Pin7 über 330R Vorwiederstand mit VCC verbunden black_button_pin = 11 #schwarzer Taster an Pin11 über 330R mit GND verbunden + 10k Pullup an VCC yellow_button_pin = 13 #gelber Taster an Pin13 über 330R mit GND verbunden + 10k Pullup an VCC GPIO.setup(red_led_pin, GPIO.OUT, initial=GPIO.HIGH) #Pin5 als Ausgang deklarieren und auf High setzen (LED=aus) GPIO.setup(yellow_led_pin, GPIO.OUT, initial=GPIO.HIGH) #Pin7 als Ausgang deklarieren und auf High setzen (LED=aus) GPIO.setup(black_button_pin, GPIO.IN) #Pin11 als Eingang deklarieren GPIO.setup(yellow_button_pin, GPIO.IN) #Pin13 als Eingang deklarieren def subroutine_black_button(): print ("Subroutine für schwarzen Taster aufgerufen. Raspberry wird heruntergefahren.") for i in range(11): GPIO.output(red_led_pin, GPIO.LOW) time.sleep(0.1) GPIO.output(red_led_pin, GPIO.HIGH) time.sleep(0.1) os.system("sudo halt") def subroutine_yellow_button(): print ("Subroutine für gelben Taster aufgerufen. SSH wird aktiviert/deaktiviert.") for i in range(11): GPIO.output(yellow_led_pin, GPIO.LOW) time.sleep(0.1) GPIO.output(yellow_led_pin, GPIO.HIGH) time.sleep(0.1) if os.path.exists("/var/run/sshd.pid"): #Wenn sshd.pid existiert (ssh aktiv ist -> abschalten) os.system("sudo systemctl stop ssh") os.system("sudo systemctl disable ssh") else: #sonst (ssh nicht aktiv -> einschalten) os.system("sudo systemctl enable ssh") os.system("sudo systemctl start ssh") def check_button_pressed(button_pin, subroutine, led_pin): button_pressed_time = 0 try: while True: if GPIO.input(button_pin) == GPIO.LOW: if button_pressed_time == 0: GPIO.output(led_pin, GPIO.LOW) button_pressed_time = time.time() elapsed_time = time.time() - button_pressed_time if elapsed_time >= 3: subroutine() button_pressed_time = 0 else: button_pressed_time = 0 time.sleep(0.1) except KeyboardInterrupt: pass #Threads für die Ãberwachung der Taster definieren black_button_thread = threading.Thread(target=check_button_pressed, args=(black_button_pin, subroutine_black_button, red_led_pin)) yellow_button_thread = threading.Thread(target=check_button_pressed, args=(yellow_button_pin, subroutine_yellow_button, yellow_led_pin)) #Threads Starten black_button_thread.start() yellow_button_thread.start() try: while True: if GPIO.input(black_button_pin) == GPIO.HIGH: GPIO.output(red_led_pin, GPIO.LOW) #rote LED an time.sleep(0.1) #für 0,1 Sekunden GPIO.output(red_led_pin, GPIO.HIGH) #rote LED aus if GPIO.input(yellow_button_pin) == GPIO.HIGH: if os.path.exists("/var/run/sshd.pid"): #Wenn sshd.pid existiert (ssh aktiv ist) GPIO.output(yellow_led_pin, GPIO.LOW) #gelbe LED an else: #sonst GPIO.output(yellow_led_pin, GPIO.HIGH) #gelbe LED aus time.sleep(1) #1 Sekunde warten except KeyboardInterrupt: print("Programm wurde manuell beendet!\n") finally: # black_button_thread.join() # yellow_button_thread.join() GPIO.cleanup()Mit [STRG]+[X] den Editor beenden und die Änderungen mit [j] [ENTER]speichern.
Für Das Script des Telegram-Bots ist wieder eine Datei zu erzeugen, ausführbar zu machen und im Editor zu öffnen:
mkdir /home/stefan/rollladensteuerung touch /home/stefan/rollladensteuerung/telegram_bot.py chmod +x /home/stefan/rollladensteuerung/telegram_bot.py nano /home/stefan/rollladensteuerung/telegram_bot.pyFolgenden Inhalt in die Datei schreiben:
(Die richtigen IDs der berechtigten Nutzer werden später ergänzt)
#!/usr/bin/env python3 # -*- coding: utf-8 -*- import asyncio import logging import os import sys import time import serial from telegram import ReplyKeyboardMarkup, ReplyKeyboardRemove from telegram.constants import ParseMode from telegram.ext import ( Application, CommandHandler, ContextTypes, MessageHandler, filters, ) DEBUG = True BOT_TOKEN = "Das Telegram-Bot Token hier eintragen" LIST_OF_ADMINS = [123456789, 445566778] SERIAL_PORT = "/dev/ttyAMA0" SERIAL_BAUDRATE = 9600 SERIAL_TIMEOUT = 2.0 INACTIVITY_TIMEOUT = 120 STATE_WINDOW = "window" STATE_POSITION = "position" STATE_BUSY = "busy" WINDOWS = { "Wohnen": ["M8"], "Erker": ["M9", "M10", "M11"], "Terrasse": ["M1"], "Paula": ["M3"], "Lars": ["M6"], "Schlafen": ["M7"], "Kochen": ["M2"], "Dusche": ["M4"], "Bad": ["M5"], "NORD": ["G1"], "OST": ["G2"], "SUED": ["G3"], "WEST": ["G4"], "ALLE": ["S"], } VALID_POSITIONS = { "100%": "100", "90%": "90", "80%": "80", "70%": "70", "60%": "60", "50%": "50", "40%": "40", "30%": "30", "20%": "20", "10%": "10", "0%": "0", } KEYBOARD_WINDOW = [ ["Wohnen", "Erker", "Terrasse"], ["Lars", "Paula", "Schlafen"], ["Kochen", "Dusche", "Bad"], ["NORD", "OST", "SUED", "WEST", "ALLE"], ["Positionsabfrage", "Abbrechen"], ] KEYBOARD_POSITION = [ ["100%", "90%", "80%"], ["70%", "60%", "50%"], ["40%", "30%", "20%"], ["10%", "0%", "Abbrechen"], ] MARKUP_WINDOW = ReplyKeyboardMarkup(KEYBOARD_WINDOW, resize_keyboard=True) MARKUP_POSITION = ReplyKeyboardMarkup(KEYBOARD_POSITION, resize_keyboard=True) # Sitzungen werden je Chat und Telegram-Benutzer getrennt gehalten. # Key: (chat_id, user_id), Value: {"state": ..., "fenster": ...} sessions = {} def debug(message): if DEBUG: print("[DEBUG] " + str(message), flush=True) def inactivity_job_name(key): return "inactivity-{}-{}".format(key[0], key[1]) def cancel_inactivity_job(application, key): job_queue = application.job_queue if job_queue is None: return for job in job_queue.get_jobs_by_name(inactivity_job_name(key)): job.schedule_removal() def schedule_inactivity_job(application, key): job_queue = application.job_queue if job_queue is None: raise RuntimeError( "JobQueue ist nicht verfügbar. Installiere python3-apscheduler." ) cancel_inactivity_job(application, key) job_queue.run_once( inactivity_timeout, INACTIVITY_TIMEOUT, data=key, name=inactivity_job_name(key), ) async def inactivity_timeout(context: ContextTypes.DEFAULT_TYPE): key = context.job.data if sessions.pop(key, None) is None: return debug("Inaktivitäts-Timeout für Chat {}, Benutzer {}".format(*key)) await context.bot.send_message( chat_id=key[0], text="Timeout - bis bald mit /start", reply_markup=ReplyKeyboardRemove(), ) def init_serial(): try: debug("Initialisiere serielle Schnittstelle {}".format(SERIAL_PORT)) tty = serial.Serial( port=SERIAL_PORT, baudrate=SERIAL_BAUDRATE, parity=serial.PARITY_NONE, stopbits=serial.STOPBITS_ONE, bytesize=serial.EIGHTBITS, timeout=SERIAL_TIMEOUT, write_timeout=SERIAL_TIMEOUT, ) tty.reset_input_buffer() tty.reset_output_buffer() debug("{} geöffnet".format(tty.portstr)) return tty except Exception as exc: debug("Fehler beim Initialisieren der seriellen Schnittstelle: {}".format(exc)) return None class SerialManager: """Eine FIFO-Warteschlange für alle Telegram-Benutzer.""" def __init__(self, tty): self.tty = tty self.queue = asyncio.Queue() self.worker_task = None def start(self): self.worker_task = asyncio.create_task(self._worker()) async def close(self): if self.worker_task is not None: self.worker_task.cancel() try: await self.worker_task except asyncio.CancelledError: pass await asyncio.to_thread(self.tty.close) async def submit(self, job_type, payload=None): loop = asyncio.get_running_loop() future = loop.create_future() await self.queue.put((job_type, payload, future)) return await future async def _worker(self): while True: job_type, payload, future = await self.queue.get() try: result = await asyncio.to_thread( self._execute_sync, job_type, payload ) if not future.cancelled(): future.set_result(result) except Exception as exc: debug("Interner Fehler im seriellen Worker: {}".format(exc)) if not future.cancelled(): future.set_result({"ok": False, "response": "", "error": str(exc)}) finally: self.queue.task_done() def _send_and_read(self, command): """Sendet genau einen Befehl und liest genau eine Antwortzeile.""" debug("Sende seriell: {!r}".format(command)) self.tty.write(command.encode("ascii") + b"\n") self.tty.flush() raw = self.tty.readline() if not raw or not raw.endswith(b"\n"): debug("Serieller Timeout/keine vollständige Antwort auf {!r}".format(command)) self.tty.reset_input_buffer() return None response = raw.decode("ascii", errors="replace").strip() debug("Antwort auf {!r}: {!r}".format(command, response)) return response def _execute_sync(self, job_type, payload): try: if job_type == "move": commands = payload for index, command in enumerate(commands): response = self._send_and_read(command) if response is None: return {"ok": False, "response": "", "error": "timeout"} if response.lower() != "ok": # Error 1 bis Error 6 und unerwartete Antworten bleiben intern. debug("Steuerung meldet Fehler/unerwartete Antwort: {!r}".format(response)) return {"ok": False, "response": response, "error": "controller"} if index < len(commands) - 1: # Die bisherigen Erker-Pausen bleiben erhalten. time.sleep(0.2) return {"ok": True, "response": "ok", "error": None} if job_type == "positions": response = self._send_and_read("P,0") if response is None: return {"ok": False, "response": "", "error": "timeout"} if response.startswith("Error "): debug("Steuerung meldet Fehler bei Positionsabfrage: {!r}".format(response)) return {"ok": False, "response": response, "error": "controller"} return {"ok": True, "response": response, "error": None} return {"ok": False, "response": "", "error": "unknown job"} except Exception as exc: debug("Fehler bei serieller Kommunikation: {}".format(exc)) try: self.tty.reset_input_buffer() except Exception: pass return {"ok": False, "response": "", "error": str(exc)} def session_key(update): return (update.effective_chat.id, update.effective_user.id) async def start(update: "Update", context: ContextTypes.DEFAULT_TYPE): user = update.effective_user message = update.effective_message key = session_key(update) if user.id not in LIST_OF_ADMINS: first_name = user.first_name or "" last_name = user.last_name or "" await message.reply_text( 'Hello {} {}. This is a private Bot. Your ChatID: "{}" has been blocked.'.format( first_name, last_name, update.effective_chat.id ) ) return sessions[key] = {"state": STATE_WINDOW, "fenster": None} schedule_inactivity_job(context.application, key) debug("Start von Chat {}, Benutzer {}".format(*key)) await message.reply_text("Fensterauswahl:", reply_markup=MARKUP_WINDOW) async def stop(update: "Update", context: ContextTypes.DEFAULT_TYPE): key = session_key(update) sessions.pop(key, None) cancel_inactivity_job(context.application, key) debug("Stop von Chat {}, Benutzer {}".format(*key)) await update.effective_message.reply_text( "Bis bald mit /start", reply_markup=ReplyKeyboardRemove(), ) async def handle_text(update: "Update", context: ContextTypes.DEFAULT_TYPE): message = update.effective_message user = update.effective_user key = session_key(update) text = (message.text or "").strip() if user.id not in LIST_OF_ADMINS: return session = sessions.get(key) if session is None: return # Abbrechen ist in beiden Menüs verfügbar. if text == "Abbrechen": await stop(update, context) return # Während eines seriellen Auftrags keine weiteren Eingaben derselben # Unterhaltung annehmen, andere Nutzer können weiterarbeiten. if session["state"] == STATE_BUSY: return if session["state"] == STATE_WINDOW: if text == "Positionsabfrage": session["state"] = STATE_BUSY cancel_inactivity_job(context.application, key) await message.reply_text( "Positionen werden abgefragt...", reply_markup=ReplyKeyboardRemove(), ) result = await context.application.bot_data["serial_manager"].submit( "positions" ) if result["ok"]: values = result["response"].strip().split(",") if len(values) < 11 or any( not value.strip().isdigit() for value in values[:11] ): debug("Ungültige Positionsantwort: {!r}".format(result["response"])) await message.reply_text( "Fehler: Positionsdaten unvollständig oder ungültig. Bitte erneut versuchen." ) else: my_text = ( "<code>Wohnen : " + values[7].strip().rjust(3) + "%\n" "Erker1 : " + values[8].strip().rjust(3) + "%\n" "Erker2 : " + values[9].strip().rjust(3) + "%\n" "Erker3 : " + values[10].strip().rjust(3) + "%\n" "Terrasse: " + values[0].strip().rjust(3) + "%\n" "Paula : " + values[2].strip().rjust(3) + "%\n" "Lars : " + values[5].strip().rjust(3) + "%\n" "Schlafen: " + values[6].strip().rjust(3) + "%\n" "Kochen : " + values[1].strip().rjust(3) + "%\n" "Dusche : " + values[3].strip().rjust(3) + "%\n" "Bad : " + values[4].strip().rjust(3) + "%</code>" ) await message.reply_text(my_text, parse_mode=ParseMode.HTML) else: debug("Positionsabfrage fehlgeschlagen: {}".format(result["error"])) await message.reply_text( "Fehler: Positionsdaten unvollständig oder ungültig. Bitte erneut versuchen." ) # /stop oder ein neues /start kann während der Abfrage eingetroffen sein. if sessions.get(key) is session: session["state"] = STATE_WINDOW schedule_inactivity_job(context.application, key) await message.reply_text("Fensterauswahl:", reply_markup=MARKUP_WINDOW) return if text not in WINDOWS: return session["fenster"] = text session["state"] = STATE_POSITION schedule_inactivity_job(context.application, key) debug("Benutzer {} hat Fenster ausgewählt: {}".format(user.id, text)) await message.reply_text("Position:", reply_markup=MARKUP_POSITION) return if session["state"] == STATE_POSITION: if text not in VALID_POSITIONS: return fenster = session.get("fenster") if fenster not in WINDOWS: session["state"] = STATE_WINDOW await message.reply_text("Fensterauswahl:", reply_markup=MARKUP_WINDOW) return position_value = VALID_POSITIONS[text] commands = [ "{} ,{}".format(prefix, position_value).replace(" ", "") for prefix in WINDOWS[fenster] ] session["state"] = STATE_BUSY cancel_inactivity_job(context.application, key) debug("Benutzer {}: Fenster {!r} soll auf {} fahren".format( user.id, fenster, text )) # Der Auftrag bleibt als Einheit in der FIFO, einschlieÃlich der Erker-Sequenz. result = await context.application.bot_data["serial_manager"].submit( "move", commands ) if not result["ok"]: # Keine technischen Steuerungsfehler an den Telegram-Nutzer ausgeben. debug("Fahrbefehl fehlgeschlagen: {}".format(result["error"])) if sessions.get(key) is session: session["state"] = STATE_WINDOW session["fenster"] = None schedule_inactivity_job(context.application, key) await message.reply_text("Fensterauswahl:", reply_markup=MARKUP_WINDOW) async def post_init(application: Application): manager = application.bot_data["serial_manager"] manager.start() for admin_id in LIST_OF_ADMINS: try: await application.bot.send_message( chat_id=admin_id, text=( "Rollladen-Dienst gestartet\n\n" "Mit /start kann es los gehen." ), reply_markup=ReplyKeyboardRemove(), ) except Exception as exc: debug( "Startmeldung an Admin {} nicht gesendet: {}".format( admin_id, exc ) ) async def post_shutdown(application: Application): manager = application.bot_data.get("serial_manager") if manager is not None: await manager.close() def main(): if not DEBUG: logging.disable(logging.CRITICAL) else: logging.basicConfig(level=logging.INFO) tty = init_serial() if tty is None: sys.exit(1) application = ( Application.builder() .token(BOT_TOKEN) .concurrent_updates(16) .post_init(post_init) .post_shutdown(post_shutdown) .build() ) if application.job_queue is None: tty.close() sys.exit( "JobQueue fehlt. Installiere sie mit: sudo apt-get install python3-apscheduler" ) application.bot_data["serial_manager"] = SerialManager(tty) application.add_handler(CommandHandler("start", start)) application.add_handler(CommandHandler("stop", stop)) application.add_handler(MessageHandler(filters.TEXT & ~filters.COMMAND, handle_text)) debug("Bot wird gestartet") application.run_polling() if __name__ == "__main__": try: main() except KeyboardInterrupt: debug("Programm wird beendet")Mit [STRG]+[X] den Editor beenden und die Änderungen mit [j] [ENTER]speichern.
Jetzt müssen die Scripte noch als Dienste beschrieben und gestartet werden.
Datei für den Shutdown-Dienst erzeugen und im Editor öffnen:
sudo nano /etc/systemd/system/gpio_daemon.serviceFolgenden Inhalt in die Datei schreiben:
[Unit] Description=Shutdown über Taster After=multi-user.target [Service] Type=idle ExecStart=/usr/bin/python3 /home/stefan/gpio/gpio.py Restart=on-failure RestartSec=1m [Install] WantedBy=multi-user.targetMit [STRG]+[X] den Editor beenden und die Änderungen mit [j] [ENTER]speichern.
Das Gleiche für den Telegram-Bot-Dienst:
sudo nano /etc/systemd/system/rollladen_daemon.serviceFolgenden Inhalt in die Datei schreiben:
[Unit] Description=Rollladensteuerung mit Telegram Wants=network-online.target After=network-online.target [Service] Type=idle ExecStart=/usr/bin/python3 /home/stefan/rollladensteuerung/telegram_bot.py Restart=on-failure RestartSec=1min [Install] WantedBy=multi-user.target
Beide Dienste aktivieren und den Raspberry Pi neu starten:
sudo systemctl daemon-reload sudo systemctl enable gpio_daemon.service sudo systemctl enable rollladen_daemon.service sudo reboot
Prüfen ob die Dienste laufen:
sudo systemctl status gpio_daemon.service sudo systemctl status rollladen_daemon.service
Wenn die Dienste ordungsgemäß laufen, kann auf dem Smartphone der erste Befehl an den eigenen Bot gesendet werden:
Auf den Befehl "/start" wird die API mit großer Warscheinlichkeit etwa so antworten:
Hello [Dein Telegram-Nickname]. This is a private Bot. Your ChatID: "12345678" has been blocked.
Aus dieser Nachricht ist die ChatID des eigenen Telegram-Accounts zu entnehmen, und in die Datei "telegram_bot.py" an entsprechender Stelle einzutragen.
Bei "LIST_OF_ADMINS = [123456789, 445566778]" - es können mehrere Nutzer IDs (durch Kommata getrennt) angegeben werden.
nano /home/stefan/rollladensteuerung/telegram_bot.pyDies dient einfach dazu, dass nicht jeder Mensch der Welt den Bot nutzen kann/darf. Damit die Änderungen in der Datei wirksam werden, muss der Dienst neu gestartet werden.
sudo systemctl restart rollladen_daemon.service























