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.

Bot erstellen 1
1. Suchfunktion öffnen

Bot erstellen 2
2. "BotFather" suchen und öffnen

Bot erstellen 3
3. Botfather neu starten

Bot erstellen 4
4. mit dem Befehl "/newbot"
einen eigenen Bot erzeugen

Bot erstellen 5
5. Bot-Namen vergeben


Bot erstellen 6
6. User-Namen vergeben


Bot erstellen 7
7. Token merken
und eigenen Bot öffnen

Bot erstellen 8
8. eigenen Bot starten



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)
Peripherie

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
Image herstellen 1
1. Raspberry Modell auswählen:
hier "Raspberry Pi 3"

Image herstellen 2
2. um an die Lite Version zu gelangen,
hier "Raspberry Pi OS (other)" wählen

Image herstellen 3
3. geeignete Version auswählen:
hier "Raspberry Pi OS Lite (32bit)"

Image herstellen 4
4. Speichermedium (micro SD-Karte) auswählen:


Image herstellen 5
5. Hostname vergeben

Image herstellen 6
6. lokale Einstellungen

Image herstellen 7
7. Benutzernamen und Passwort vergeben


Image herstellen 8
8. ggf. WLAN-Zugangsdaten eingeben
bei Verwendung der Ethernetbuchse frei lassen

Image herstellen 9
9. SSH aktivieren

Image herstellen 10
10. Raspberry Pi Connect deaktivieren

Image herstellen 11
11. Image schreiben

Image herstellen 12
12. nochmals bestätigen

Image herstellen 13
13. Schreibvorgang

Image herstellen 14
14. Prüfvorgang

Image herstellen 15
fertig :-)


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
Beim ersten Bootvorgang können mehrere automatische Neustarts erfolgen. Anschließend ist der Raspberry über SSH erreichbar (Alternativ zur SSH-Verbindung kann auch ein Montor und eine Tastatur angeschlossen werden.)

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-config
Es startet ein Konfigurationstool in dem Folgende Einstellungen zu tätigen sind.
  1.   8 Update this tool to the latest version
  2.   5 Localisation Options -> Locale -> de_DE.UTF-8 UTF-8 (zusätzlich auswählen (mit Space))
  3.   3 Interface Options -> Serial Port -> shell? No -> hardware enabled? Yes
  4.   6 Advanced Options -> Expand Filesystem
  5.   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.txt
Dann 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.py
Folgenden 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.py
Folgenden 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.service
Folgenden 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.target
 
Mit [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.service
Folgenden 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.py
Dies 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


Funktionstest