Calliope Mini 3 als Datenlogger: CSV schreiben mit ACK-Bestätigung

Posted on by Stefan Draeger

Der Calliope Mini 3 eignet sich hervorragend, um erste Experimente mit Sensoren durchzuführen und beispielsweise Temperaturwerte zu erfassen. Zwar bietet der Calliope selbst die Möglichkeit, Daten lokal auf dem internen Speicher abzulegen – das anschließende Herunterladen und Auslesen dieser Daten ist jedoch umständlich und wenig flexibel.

In diesem Beitrag zeige ich eine alternative Lösung, bei der die erfassten Sensordaten direkt vom Calliope Mini 3 über die serielle USB-Verbindung an den PC übertragen und dort in eine CSV-Datei geschrieben werden. Die Daten werden dabei nicht fortlaufend automatisch gespeichert, sondern erst dann abgerufen, wenn eine Verbindung zum PC besteht. Das ermöglicht eine saubere Trennung zwischen Messung und Datenauswertung.

Calliope Mini 3 als Datenlogger – Sensordaten per USB übertragen, in Excel auswerten
Dieses Video auf YouTube ansehen.

Ein weiterer Vorteil: Jede empfangene Datenzeile wird vom PC mit einer ACK-Bestätigung quittiert. So erhält der Calliope Mini sofort eine Rückmeldung, ob die Übertragung erfolgreich war. Dieses Verfahren erhöht die Sicherheit und Qualität der Datenübertragung – fehlerhafte oder verlorene Messwerte können so direkt erkannt und bei Bedarf erneut gesendet werden.

💡 Hinweis:
Dieser Beitrag dient als einfacher Einstieg in das Thema Datenlogging mit Quittierung und zeigt die grundlegende Funktionsweise am Beispiel des Calliope Mini 3. Die hier vorgestellte Lösung bildet die Basis für das eigentliche Projekt, das später auf den ESP32 übertragen und dort weiterentwickelt wird.

Inhaltsverzeichnis

Aufbau der Schaltung – DHT11 Sensor am Calliope Mini über Groove-Schnittstelle

Der Calliope Mini 3 bietet zwei praktische Groove-Anschlüsse, über die sich externe Module einfach und ohne zusätzliche Lötarbeiten verbinden lassen. Für dieses Projekt verwende ich einen DHT11 Sensor, der sowohl die Temperatur als auch die relative Luftfeuchtigkeit misst.

Grove DHT11 Shield
Grove DHT11 Shield
DIY DHT11 Shield mit Grove Connector Schnittstelle
DIY DHT11 Shield mit Grove Connector Schnittstelle

Den Anschluss eines DHT11 am Calliope Mini habe ich bereits in einem früheren Beitrag für das Vorgängermodell, den Calliope Mini 1.3, beschrieben. Dort kam zusätzlich ein kleines LCD-Display zum Einsatz: ➡️ Calliope Mini mit DHT11 & LCD-Display

In diesem Beitrag liegt der Fokus jedoch – wie eingangs erwähnt – auf der Datenübertragung zum PC und der Speicherung der Messwerte als CSV-Datei. Der Aufbau der Hardware bleibt bewusst einfach: Der DHT11 Sensor wird mit einem passenden Groove-Kabel direkt an den Sockel A1 des Calliope Mini angeschlossen. Weitere Verdrahtung oder Zusatzbauteile sind nicht erforderlich.

Diese Lösung ist besonders einsteigerfreundlich und ermöglicht einen schnellen Start ohne aufwendige Schaltungsarbeiten.

Aufbau des Code am Calliope Mini 3

Schritt 1 – Neues Projekt anlegen

Zu Beginn öffnest du den MakeCode-Editor unter ➡️ https://makecode.calliope.cc/#editor.

Klicke dort auf „Neues Projekt“ und vergebe einen passenden Namen, z. B. „Datenlogger DHT11“.
Bevor du mit dem Programmieren startest, achte darauf, dass du den richtigen Mikrocontroller auswählst. Im oberen Bereich des Editors findest du die Auswahl zwischen:

  • Calliope Mini 1
  • Calliope Mini 2
  • Calliope Mini 3

In diesem Projekt arbeiten wir mit dem Calliope Mini 3. Stelle also sicher, dass oben das Symbol für die Version 3 angezeigt wird.
Nur dann stehen dir alle Funktionen und Erweiterungen, die wir in diesem Projekt benötigen, zur Verfügung.

Damit ist dein Projekt korrekt vorbereitet und du kannst mit dem nächsten Schritt – dem Import der DHT11-Bibliothek – fortfahren.

Schritt 2 – Bibliothek für den Groove DHT11 Sensor importieren

Damit der Calliope Mini die Werte des DHT11 Sensors auslesen kann, müssen wir die passende Bibliothek (Erweiterung) hinzufügen.
Klicke dazu im MakeCode-Editor auf „Erweiterungen“ und suche nach 👉 „dht11“.
Wähle die Erweiterung aus, die den DHT11 Sensor unterstützt.

Nach dem Import findest du im Blockmenü einen neuen Bereich mit den Sensorblöcken, über die du Temperatur und Luftfeuchtigkeit abfragen kannst.

Schritt 3 – Sensordaten auf der LED-Matrix anzeigen

Bevor wir die Daten an den PC senden, testen wir die Messwerte direkt auf dem Calliope Mini.
Nutze dafür die Blöcke aus der DHT11-Erweiterung und lasse die Temperatur und Luftfeuchtigkeit auf der LED-Matrix anzeigen.
Das hilft dabei, sicherzustellen, dass der Sensor korrekt angeschlossen ist und die Messwerte stimmen.

Programm zum anzeigen der Temperatur vom DHT11 Sensor auf der LED Matrix des Calliope Mini 3Herunterladen

Das ist ein einfacher, aber wichtiger Zwischenschritt, um die Funktion des Sensors zu überprüfen.

Schritt 4 – Serielle Verbindung einrichten und auf USB-Port umleiten

Für die Datenübertragung an den PC richten wir eine serielle Schnittstelle ein.
Im MakeCode-Blockmenü findest du unter „Serielle“ die passenden Blöcke dafür. Stelle sicher, dass die Daten über den USB-Port gesendet werden, damit dein Python-Skript am PC die Werte empfangen kann.

Dieser Schritt verbindet die Sensorwerte mit der Datenleitung zum Computer – die Grundlage für das Logging.

Schritt 5 – Temperaturwert an den PC senden

Im nächsten Schritt übertragen wir nur den reinen Temperaturwert vom Calliope Mini an den PC. Der Wert wird dabei als einfache Zahl, z. B. 24, über die serielle USB-Verbindung gesendet – ohne zusätzliche Texte oder Kennzeichnungen.

Das macht die Datenübertragung besonders einfach und effizient, da der PC beim Empfangen direkt mit dem Wert weiterarbeiten kann.

Verwende dafür im MakeCode-Editor den Block
➡️ „seriell schreibe Zahl“
oder
➡️ „seriell schreibe Zeile“, wenn du den Wert vorher als Text formatierst.

Wichtig ist, dass jede Messung als eigene Zeile gesendet wird, damit der PC die einzelnen Werte korrekt auseinanderhalten kann. Der Zeilenumbruch (\n) am Ende wird automatisch durch den Block „seriell schreibe Zeile“ hinzugefügt.

Schritt 6 – Antwort vom PC auswerten (ACK empfangen)

Nach dem Senden der Daten wartet der Calliope Mini auf eine Antwort vom PC.
Unser Python-Skript quittiert jede empfangene Datenzeile mit einem „ACK_<Daten>“.
In MakeCode kannst du die serielle Lese-Events nutzen, um diese Antwort zu empfangen und auszuwerten.

So stellst du sicher, dass der Calliope Mini weiß, ob die Daten korrekt angekommen sind – das erhöht die Datensicherheit und ermöglicht Wiederholungen bei Bedarf.

Serielle Datenübertragung testen mit PuTTY – COM-Port ermitteln

Um die vom Calliope Mini gesendeten Daten direkt am PC auszulesen und zu testen, eignet sich das kostenfreie Tool PuTTY hervorragend. Mit PuTTY kannst du über eine serielle Verbindung einfach die ankommenden Daten anzeigen lassen.

Bevor du PuTTY einrichtest, musst du herausfinden, an welchem COM-Port der Calliope Mini angeschlossen ist. Je nach Betriebssystem gehst du dabei unterschiedlich vor:

🖥️ Windows: COM-Port im Gerätemanager ermitteln

  • Öffne den Gerätemanager (Rechtsklick auf das Windows-Startsymbol → Geräte-Manager).
  • Unter dem Bereich „Anschlüsse (COM & LPT)“ findest du den Eintrag für den Calliope Mini, z. B.:
    „Serielles USB-Gerät (COM7)”
  • Diese COM-Nummer (hier z. B. COM7) trägst du später in PuTTY ein.

🐧 Linux: USB-Geräte auflisten mit lsusb

  • Verbinde den Calliope Mini per USB mit deinem Linux-System.
  • Öffne ein Terminal und gib folgenden Befehl ein: nginxKopierenBearbeitenlsusb
  • Alternativ kannst du auch nach den seriellen Geräten suchen: bashKopierenBearbeitendmesg | grep tty oder: bashKopierenBearbeitenls /dev/ttyACM*
  • Der Mikrocontroller wird meist als /dev/ttyACM0 oder /dev/ttyUSB0 erkannt.

PuTTY einrichten

  • Starte PuTTY.
  • Wähle „serial“ als Verbindungsart.
  • Trage den ermittelten COM-Port
    (z. B. COM7 oder /dev/ttyACM0) ein.
  • Setze die Baudrate auf 9600.
  • Klicke auf „Open“, um die serielle Konsole zu öffnen und die Daten zu sehen.

Wichtig: WebUSB-Verbindung zum Browser trennen

Beachte, dass der Calliope Mini immer nur eine serielle Verbindung gleichzeitig unterstützt. Wenn der Mikrocontroller bereits über WebUSB im Browser (z. B. über den MakeCode-Editor) verbunden ist, blockiert diese Verbindung den COM-Port – andere Programme wie PuTTY oder dein Python-Skript können in diesem Fall nicht auf die serielle Schnittstelle zugreifen.

👉 Lösung:
Bevor du PuTTY oder dein Python-Logging-Skript startest, trenne unbedingt die Verbindung zum Browser:

  • Klicke im MakeCode-Editor auf „Trennen“ (bzw. „Disconnect“).
  • Schließe ggf. den Browser-Tab, wenn die Verbindung nicht sauber getrennt wird.

Erst wenn die WebUSB-Verbindung getrennt ist, kann dein PC die serielle Schnittstelle wieder für PuTTY oder dein eigenes Auslese-Tool öffnen.

💡 Hintergrund:
Die serielle Schnittstelle des Calliope Mini wird exklusiv belegt – Mehrfachverbindungen (z. B. Browser und PuTTY gleichzeitig) sind nicht möglich.

Datenlogging am PC – Python-Skript zur Auswertung

Die vom Calliope Mini per USB übertragenen Sensordaten werden auf dem PC von einem kleinen Python3-Skript empfangen und direkt in eine CSV-Datei geschrieben.
Das Skript prüft dabei zusätzlich, ob jede empfangene Datenzeile korrekt angekommen ist, und sendet als Rückmeldung eine ACK-Bestätigung zurück an den Mikrocontroller.

Python-Umgebung einrichten mit PyCharm

Für das Projekt verwende ich die kostenfreie PyCharm Community Edition als Entwicklungsumgebung (IDE).
PyCharm bietet eine komfortable Möglichkeit, Pakete wie pySerial direkt über die IDE zu installieren – mit nur wenigen Klicks über den eingebauten Paketmanager.

Die Bibliothek pySerial ist notwendig, um die serielle Verbindung in Python zu nutzen. Die Installation über PyCharm oder alternativ per Konsole:

pip install pyserial

Python-Skript ausführen

Das Python-Skript startest du ganz einfach über die Kommandozeile oder direkt aus PyCharm heraus.
Beispiel für den Aufruf über die Konsole:

python read_serial_to_csv_ack.py Sensor1

Dabei wird Sensor1 als Gerätename übergeben und zusammen mit dem Zeitstempel und dem Sensorwert in die CSV-Datei geschrieben.

Python3 Code zum abrufen der Daten vom PC 
"""
----------------------------------------------------------
Datenlogging mit dem Calliope Mini 3:
CSV schreiben mit ACK-Bestätigung
----------------------------------------------------------
Autor: Stefan Draeger
Blogbeitrag: https://draeger-it.blog/calliope-mini-3-als-datenlogger-csv-schreiben-mit-ack-bestaetigung/

Beschreibung:
Dieses Python3-Skript empfängt Sensordaten vom Calliope Mini 3 über die serielle USB-Schnittstelle
und schreibt die empfangenen Daten direkt in eine CSV-Datei auf dem PC. Die CSV-Datei enthält
einen Zeitstempel, den Gerätenamen (als Startparameter übergeben) und den empfangenen Sensorwert.

Jede empfangene Datenzeile wird vom PC mit einer ACK-Bestätigung (ACK_<WERT>) quittiert.
Dadurch erhält der Calliope Mini eine Rückmeldung, ob die Daten korrekt empfangen wurden.
Fehlübertragungen lassen sich so zuverlässig erkennen und vermeiden.

Das Skript wartet auf eine aktive Verbindung und liest die Daten nur, wenn der Calliope Mini angeschlossen ist.
----------------------------------------------------------
"""

# ------------------------------
# Importieren der benötigten Module
# ------------------------------
import serial                # Für die serielle Kommunikation über USB
import time                  # Für kurze Pausen im Programmablauf (sleep)
import csv                   # Für das Schreiben der CSV-Datei
import sys                   # Für den Zugriff auf die übergebenen Kommandozeilenargumente
from datetime import datetime  # Für die Erstellung von Zeitstempeln

# ------------------------------
# Gerätename als Kommandozeilenparameter übergeben
# Aufruf-Beispiel: python read_serial_to_csv_ack.py Sensor1
# ------------------------------
if len(sys.argv) < 2:
    print("Bitte Gerätenamen als Parameter übergeben!")
    print("Beispiel: python read_serial_to_csv_ack.py Sensor1")
    sys.exit(1)  # Programm beenden, wenn kein Gerätename übergeben wurde

DEVICE_NAME = sys.argv[1]  # Gerätename aus den übergebenen Parametern lesen

# ------------------------------
# Serielle Schnittstelle und Baudrate festlegen
# ------------------------------
SERIAL_PORT = 'COM5'        # COM-Port, an dem der Calliope Mini angeschlossen ist
BAUD_RATE = 9600            # Baudrate für die serielle Kommunikation
CSV_FILENAME = 'sensordaten.csv'  # Name der CSV-Datei, in die geschrieben wird

# ------------------------------
# Serielle Verbindung zum Calliope Mini öffnen
# ------------------------------
try:
    ser = serial.Serial(SERIAL_PORT, BAUD_RATE, timeout=1)
    print(f"Verbunden mit {SERIAL_PORT} @ {BAUD_RATE} Baud")
except serial.SerialException as e:
    print(f"Fehler beim Öffnen des Ports: {e}")
    sys.exit(1)  # Bei Verbindungsfehler Programm beenden

# ------------------------------
# Funktion zum Vorbereiten der CSV-Datei
# (Header wird nur geschrieben, wenn die Datei noch nicht existiert)
# ------------------------------
def prepare_csv(filename):
    try:
        # 'x' bedeutet: Datei neu anlegen, wenn sie noch nicht existiert
        with open(filename, 'x', newline='') as file:
            writer = csv.writer(file)
            writer.writerow(['Timestamp', 'Device', 'Value'])  # CSV-Header schreiben
            print(f"CSV-Datei '{filename}' erstellt.")
    except FileExistsError:
        # Wenn Datei schon existiert, weiterschreiben ohne Header
        print(f"CSV-Datei '{filename}' existiert bereits, schreibe Daten ans Ende.")

prepare_csv(CSV_FILENAME)  # CSV-Datei vorbereiten

# ------------------------------
# Hauptprogramm: Serielle Daten empfangen, in CSV schreiben, ACK senden
# ------------------------------
try:
    # CSV-Datei im Anhängemodus öffnen ('a' für append)
    with open(CSV_FILENAME, 'a', newline='') as csvfile:
        writer = csv.writer(csvfile)

        while True:
            # Prüfen, ob Daten vom Calliope Mini im Buffer liegen
            if ser.in_waiting > 0:
                # Empfangene Datenzeile lesen und dekodieren
                line = ser.readline().decode('utf-8', errors='ignore').strip()

                # Wenn eine Zeile empfangen wurde (nicht leer)
                if line:
                    # Aktuellen Zeitstempel erzeugen (Format: YYYY-MM-DD HH:MM:SS)
                    timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S')

                    # Ausgabe der empfangenen Daten zur Kontrolle in der Konsole
                    print(f"{timestamp} | {DEVICE_NAME} | {line}")

                    # Empfangenes Datenpaket in die CSV-Datei schreiben
                    writer.writerow([timestamp, DEVICE_NAME, line])
                    csvfile.flush()  # Daten sofort auf die Festplatte schreiben

                    # ACK-Nachricht vorbereiten und zurück an den Calliope senden
                    ack_message = f"ACK_{line}\n"
                    ser.write(ack_message.encode('utf-8'))  # ACK senden
                    print(f"ACK gesendet: {ack_message.strip()}")

            time.sleep(0.1)  # Kurze Pause, um die CPU-Auslastung zu verringern

# ------------------------------
# Programm beenden über Strg+C (KeyboardInterrupt)
# ------------------------------
except KeyboardInterrupt:
    print("\nBeende das Programm.")

# ------------------------------
# Serielle Verbindung sauber schließen, wenn das Programm endet
# ------------------------------
finally:
    ser.close()
    print("Serielle Verbindung geschlossen.")

Im nächsten Schritt möchte ich dir zeigen wie du diese Daten visualisieren kannst.

Visualisieren der gesammelten Daten

Die gesammelten Daten können wir nun mit dem Power Query Editor von Microsoft Excel transformieren und aufbereiten. Das klingt erstmal sehr kompliziert aber ist es nicht wie du gleich sehen wirst.

Im oben verlinkten Video erläutere ich dir, wie du dieses machst und jede Station in eine eigene Tabelle darstellen kannst.

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert