Raspberry Pi als Logging-Modul mit journald für Mikrocontroller

Raspberry Pi als Logging-Modul für Mikrocontroller

Beim Logging von Sensorwerten mit einem Mikrocontroller muss man mit verschiedenen Einschränkungen leben:

fehlende Echtzeituhr
begrenzter Speicher
umständlichen Zugriff auf die Daten
keine Auswertung der Daten möglich

Natürlich könnte man sich ein Programm schreiben oder schreiben lassen, dass über diese Leistungsmerkmale verfügt. Aber warum so umständlich, wenn es das schon gibt: Logging mit journald unter Linux.

Eine mögliche Lösung wäre, einen Raspberry Pi als externes Logging-Modul zu betreiben. Der Mikrocontroller übernimmt nur die Datenerfassung, während der Raspberry Pi die Speicherung, Zeitstempelung und Weiterverarbeitung übernimmt. Dadurch bleibt das Gesamtsystem einfach und flexibler.

Mehr Informationen

Anleitung: Raspberry Pi als Logging-Modul einrichten

Betriebssystem aktualisieren und vorbereiten
Systemkonfiguration
Virtuelle Python-Umgebung einrichten
Programmcode auf dem Raspberry Pi
Verkabelung mit dem Mikrocontroller
Programm für den Raspberry Pi Pico (Beispiel)
Raspberry Pi: Logs auf der Kommandozeile anzeigen
Raspberry Pi: Autostart-Service für das Logging einrichten (optional)
Raspberry Pi: Logging persistent machen (optional)

Betriebssystem aktualisieren und vorbereiten

Nach dem Erzeugen einer frischen MicroSD-Karte mit Raspberry Pi OS, sollte man das Betriebssystem und die Software aktualisieren. Danach wird man das System vermutlich nie wieder aktualisieren.

sudo apt update
sudo apt upgrade

Vorab installieren wir folgende Software:

sudo apt install libsystemd-dev python3-serial python3-systemd python3-pip

Systemkonfiguration

Im Konfigurationstool für den Raspberry Pi müssen wir noch ein paar Einstellungen vornehmen.

sudo raspi-config

Die serielle Schnittstelle muss eingeschaltet werden.

Im Menü hangelt man sich durch folgende Optionen: Interface Options / Serial Port

Login shell over serial? NO
Enable serial port hardware? YES

Hinweis: Der Login über die serielle Schnittstelle MUSS abgeschaltet (NO) sein, weil diese Schnittstelle sonst nicht genutzt werden kann.

Wenn man das Konfigurationstool beendet, dann wird normalerweise ein Reboot angeboten. Das ist sinnvoll.

Virtuelle Python-Umgebung einrichten

Für Python erstellen wir eine virtuelle Umgebung mit „venv“ (Virtual Environment), in die zusätzliche Python-Pakete installiert werden.

Mehr Informationen zu Virtual Environment mit Python

Zuerst legen wir in unserem Home-Verzeichnis „/home/pi“ ein Projektverzeichnis mit dem Namen „log“ an und wechseln dorthin.

mkdir /home/pi/log
cd /home/pi/log

In diesem Verzeichnis erstellen wir eine virtuelle Python-Umgebung, in die wir anschließend alles installieren, ohne das System zu verändern.

python3 -m venv venv

Die Umgebung aktivieren:

source venv/bin/activate

Ab jetzt steht vor der Eingabeaufforderung „(venv)“.

Im nächsten Schritt installieren wir zusätzliche Pakete in die virtuelle Umgebung. Dafür verwenden wir pip (Package Installer for Python).

pip install pyserial systemd-python

Danach können wir die virtuelle Umgebung wieder deaktivieren.

deactivate

Programmcode auf dem Raspberry Pi

Das folgende Python-Programm macht 3 Dinge:

Text-Empfang auf der seriellen Schnittstelle
Speichern der Daten im journald-Log

Dazu öffnen wir eine neue Datei:

nano uart_log.py

In dem sich öffnenden Editor fügen wir folgenden Programmcode ein:

# Bibliotheken laden
import serial
from systemd import journal

# Serielle Schnittstelle initialisieren
ser = serial.Serial("/dev/serial0", 115200, timeout=1)

# Hauptprogramm
try:
    while True:
        line = ser.readline().decode("utf-8").strip()
        if line:
            print('Daten empfangen:', line)
            journal.send(line, SYSLOG_IDENTIFIER='uart_log', PRIORITY=6)
except KeyboardInterrupt:
    pass
except Exception as e:
    print('Fehler:', e)

Mit Strg + O, Return und Strg + X die Datei speichern und schließen.

Dann kannst du das Programm testweise starten:

venv/bin/python3 uart_log.py

Mit Strg + C kann man das Programm beenden.

Hinweis: Wenn das Programm „uart_log.py“ bei einem Neustart automatisch gestartet werden soll, dann muss man einen systemd-Service einrichten.

Verkabelung mit dem Mikrocontroller

Die Darstellung sieht die Verkabelung von einen Raspberry Pi 3 und einem Raspberry Pi Pico vor. Das soll aber nur ein Beispiel sein. Es kann im Prinzip jeder Raspberry Pi und jeder Mikrocontroller sein.

In diesem Beispiel wird der Raspberry Pi Pico über die GPIO-Pinleiste des Raspberry Pi mit Strom versorgt.
Der ganze Aufbau funktioniert nur dann zuverlässig, wenn beide über eine gemeinsame Masse-Verbindung (GND) verbunden sind.
Als einzige wirkliche Datenverbindung dient die Verbindung vom GPIO15 (Raspberry Pi UART-RX) nach GPIO0 (Raspberry Pi Pico UART-TX). Die Verbindung für den Rückweg brauchen wir nicht.
Bei Mikrocontrollern, die 5-Volt-Pegel haben, muss man einen Pegelwandler (Logic Level Shifter) dazwischenschalten. Der Raspberry Pi verträgt nur einen 3,3-Volt-Pegel.
Die Geschwindigkeit der Schnittstelle ist beim Raspberry Pi auf 115200 Baud eingestellt.

Programm für den Raspberry Pi Pico (Beispiel)

Der folgende Programmcode initialisiert die serielle Schnittstelle (UART) des Raspberry Pi Pico und sendet anschließend in einer Endlosschleife jede Minute die Temperatur des integrierten Temperaturfühlers über diese Schnittstelle.

# Bibliotheken laden
from machine import Pin, UART, ADC
import time

# Initialisierung des ADC4 (integrierter Temperatursensor)
sensor = ADC(4)
time.sleep(1)

# UART initialisieren
LOG = UART(0, baudrate=115200, tx=Pin(0), rx=Pin(1))

# Funktion: Text über UART senden
def logging(text):
    print(text)
    LOG.write(text)

# Hauptprogramm
while True:
    # Sensor lesen
    value = sensor.read_u16()
    spannung = value * 3.3 / (65536)
    temperatur = 27 - (spannung - 0.706) / 0.001721
    logging(f"temp={temperatur}")
    time.sleep(60)

Wenn man diesen Programmcode mit dem Dateinamen „main.py“ speichert, dann wird die Datei automatisch beim Neustart ausgeführt.

Raspberry Pi: Logs auf der Kommandozeile anzeigen

journalctl -t uart_log

oder live:

journalctl -t uart_log -f

Raspberry Pi: Autostart-Service für das Logging einrichten (optional)

Das Programm „uart_log.py“ auf dem Raspberry Pi startet nicht automatisch bei einem Neustart. Dazu muss man einen systemd-Service einrichten.

Hinweis: Den Service sollte man nur dann einrichten, wenn das Programm fehlerfrei funktioniert.

Dazu erstellen wir eine neue Datei:

sudo nano /etc/systemd/system/uart_log.service

Und tragen in diese Datei folgende Zeilen ein:

[Unit]
Description=UART Logging Service (/dev/serial0)
Requires=dev-serial0.device
After=dev-serial0.device

[Service]
Type=simple
User=pi
ExecStart=/home/pi/log/venv/bin/python3 /home/pi/log/uart_log.py
Restart=on-failure
RestartSec=5
StartLimitBurst=5

[Install]
WantedBy=multi-user.target

Mit Strg + O, Return und Strg + X die Datei speichern und schließen.

Den neu eingerichteten Service einlesen:

sudo systemctl daemon-reload

Danach kann man das Python-Programm als Service manuell starten und stoppen. Außerdem kann man den automatischen Start bei einem System-Neustart aktivieren.

Wichtige Kommandos zum Steuern

Service-Status anzeigen:

sudo systemctl status uart_log.service

Service starten:

sudo systemctl start uart_log.service

Service stoppen:

sudo systemctl stop uart_log.service

Service bei einem Neustart automatisch starten:

sudo systemctl enable uart_log.service

Automatischer Start abschalten:

sudo systemctl disable uart_log.service

Mit einem Reboot kann man testen, ob der automatische Start funktioniert.

sudo systemctl enable uart_log.service
sudo reboot

Hinweis: Bevor man den Programmcode ändert, sollte man den Service immer stoppen und deaktivieren. Wenn man im Programmcode Mist baut und es deshalb zum Neustart kommt, dann kann das zu einer Reboot-Schleife führen, die sich nicht unterbrechen lässt.

Raspberry Pi: Logging dauerhaft machen (optional)

Standardmäßig ist das dauerhafte Speichern von Logs in Raspberry Pi OS deaktiviert, um die Speicherkarte zu schonen. Da Speicherkarte nur eine begrenzte Anzahl an Schreibzyklen aushalten, können ständige Log-Schreibvorgänge die Lebensdauer der Speicherkarten verkürzen. Wenn man die Logs auch nach einem Neustart lesen können will, muss man das Logging mit „journald“ dauerhaft machen.

Im Raspberry-Pi-Konfigurationstool kann man das ganz bequem ein- und ausschalten.

sudo raspi-config

Hier findet man unter „Advanced Options / Logging“ den entsprechenden Eintrag. Mit „Yes“ kann man das dauerhafte Logging aktivieren. Anschließen das Programm beenden und den Raspberry Pi neu starten.

Nach einen Neustart kann man mit folgendem Programm prüfen, ob das Logging dauerhaft ist:

journalctl -u systemd-journald

Wenn man dort einen Eintrag mit „System Journal (/var/log/journal/...“ findet, dann ist das Logging dauerhaft.

Hinweis: Verschleiß der Speicherkarte vermeiden

Dauerhaftes Logging auf einer Speicherkarte kann dazu führen, dass die Speicherkarte irgendwann mal Aussetzer hat und kaputt geht. Um das zu vermeiden sollte man zumindest die Größe der Logs begrenzen.

Öffne dazu folgende Datei:

sudo nano /etc/systemd/journald.conf

Trage dort folgende Zeilen ein:

SystemMaxUse=100M

100M steht für 100 Megabyte. Es handelt sich um eine Speicherplatzbegrenzung für das systemd-Journal. Dadurch werden alte Log-Daten automatisch gelöscht, sobald alle Logs auf der Speicherkarte insgesamt mehr als 100 Megabyte belegen.
Du kannst dieses Limit natürlich ganz flexibel an deine Bedürfnisse anpassen. Aber Achtung, wenn der Wert zu groß ist und der Speicherplatz auf der Speicherkarte ausgeht, dann wird das System instabil und fällt aus.

Die Datei speichern und schließen: Strg + O, Return, Strg + X

Danach muss der Dienst neu gestartet werden:

sudo systemctl restart systemd-journald

Mit folgendem Kommando kann man prüfen, wie viel Speicher das Logging in Anspruch nimmt.

journalctl --disk-usage

Weitere verwandte Themen:

Elektronik-Set Raspberry Pi Edition

Elektronik erleben mit dem Raspberry Pi mit Python und GPIO Zero

Leichter Einstieg ins Hardware-nahe Programmieren mit Python und GPIO Zero
Experimentieren und Programmieren ohne Vorkenntnisse
Sofort Loslegen mit All-in-one-Set

Elektronik-Set jetzt bestellen

Hardware-nahes Programmieren mit dem Raspberry Pi, Python und GPIO Zero

Das "Elektronik-Set Raspberry Pi Edition" ist ein Bauteile-Sortiment mit Anleitung zum Experimentieren und Programmieren mit Python und GPIO Zero.

LED: Einschalten, ausschalten, blinken und Helligkeit steuern
Taster: Verschiedene Zustände auswerten und anzeigen lassen
LED mit Taster einschalten und ausschalten
Relais-Board steuern
LED, Relais-Board und Motor über ULN2003A steuern
Ampel- und Lauflicht-Steuerung
Herunterfahren per Taster
Reaktionsspiel mit Tastern und LEDs
Eigene Steuerungen programmieren