Autor: andre

  • DAKboard Display per Homekit / MQTT schalten

    Bei uns zuhause haben wir an zentraler Stelle einen digitalen Wandkalender zur Familienorganisation. Termine und Aufgaben die am Smartphone eingetragen werden, sind hier einsehbar. Auch das lesen von Kurznachrichten oder der Zugang zum Gäste WLAN sind möglich. Für den Betrieb gibt es im wesentlichen zwei Alternativen. Die OpenSource Lösung MagicMirror oder das kommerzielle Produkt DAKboard. Ich habe mich vor einiger Zeit aufgrund der einfacheren Einrichtung und der ansprechenderen Optik für DAKboard entschieden. Als Hardware kommt hier ein Rasperry Pi mit DAKboard OS sowie ein 32″ Samsung ‚The Frame‘ Fernseher zum Einsatz. So sieht das ganze dann aus.

    Um Strom zu sparen, soll das Display nur aktiv sein, wenn jemand davorsteht. Dies realisieren wir mit einem HomeKit-Bewegungsmelder und einer MQTT-basierten Automatisierung.

    Materialien

    • Raspberry Pi mit DAKboard OS
    • Display mit HDMI Verbindung zum Raspberry
    • HomeKit-Bewegungsmelder (z. B. Eve Motion)
    • MQTT-Broker (z. B. Mosquitto)
    • Homebridge mit mqtt-thing Plugin
    • Python-Umgebung auf dem Raspberry Pi

    Schritt-für-Schritt-Anleitung

    1. Einrichtung des HomeKit-Sensors
    • Integriere den Bewegungsmelder in dein HomeKit-System.
    • Stelle sicher, dass der Sensor in der Home-App sichtbar ist.
    2. Homebridge konfigurieren
    • Installiere Homebridge und das Plugin mqtt-thing.
    • Ergänze die config.json um den folgenden Eintrag für einen virtuellen Schalter:
    {
        "type": "lightbulb-OnOff",
        "name": "Dashboard",
        "url": "<BROKER_IP:PORT>",
        "username": "<USERNAME>",
        "password": "<PASSWORD>",
        "topics": {
            "getOn": "Dashboard/monitor",
            "setOn": "Dashboard/monitor"
        },
        "integerValue": true,
        "onValue": "1",
        "offValue": "0",
        "accessory": "mqttthing"
    },
    Code-Sprache: JSON / JSON mit Kommentaren (json)
    • Ersetze <BROKER_IP:PORT>, <USERNAME>, <PASSWORD> mit deinen MQTT-Broker-Daten.
    3. Automatisierung in HomeKit erstellen
    • Verknüpfe den Bewegungsmelder mit dem virtuellen Schalter.
    • Richte eine Regel ein, die den Schalter bei Bewegung einschaltet und ohne Bewegung wieder deaktiviert.

    Durch die Automation, wird bei jeder Änderung des Schalterzustands eine MQTT Nachricht an den Broker gesendet. Diese Nachrichten können wir im nächsten Schritt abonnieren und per Python Skript weiterverarbeiten.

    4. Python-Skript auf dem Raspberry Pi
    • Installiere die erforderliche Bibliothek:
    sudo pip3 install paho-mqtt
    • Speichere das folgende Python-Skript:
    #!/usr/bin/env python3
    
    # Dieses Skript steuert die HDMI-Ausgabe eines Raspberry Pi basierend auf MQTT-Nachrichten.
    
    import paho.mqtt.client as mqtt
    import subprocess
    
    # Funktion, um HDMI einzuschalten
    def hdmi_on():
        # Führt das Skript zum Aktivieren des HDMI-Ports aus
        result = subprocess.call("/home/pi/rpi-hdmi.sh on", shell=True)
        print(f"HDMI aktiviert: {result}")
    
    # Funktion, um HDMI auszuschalten
    def hdmi_off():
        # Führt das Skript zum Deaktivieren des HDMI-Ports aus
        result = subprocess.call("/home/pi/rpi-hdmi.sh off", shell=True)
        print(f"HDMI deaktiviert: {result}")
    
    # Callback-Funktion für eine erfolgreiche Verbindung zum MQTT-Broker
    def on_connect(client, userdata, flags, rc):
        print("Erfolgreich mit MQTT-Broker verbunden")
        # Abonniert den gewünschten MQTT-Topic
        client.subscribe("Dashboard/monitor", qos=0)
    
    # Callback-Funktion für empfangene MQTT-Nachrichten
    def on_message(client, userdata, msg):
        print(f"Nachricht erhalten: Thema={msg.topic}, QoS={msg.qos}, Payload={msg.payload.decode()}")
        # Steuerung basierend auf der Nachricht: "1" = HDMI ein, "0" = HDMI aus
        if msg.payload.decode() == "1":
            hdmi_on()
        elif msg.payload.decode() == "0":
            hdmi_off()
    
    # Callback-Funktion nach erfolgreichem Abonnement eines Topics
    def on_subscribe(client, userdata, mid, granted_qos):
        print(f"Abonniert: Topic-ID={mid}, QoS={granted_qos}")
    
    # MQTT-Client initialisieren
    client = mqtt.Client()
    
    # MQTT-Benutzername und Passwort setzen
    client.username_pw_set("<USERNAME>", "<PASSWORD>")
    
    # Verbindung zum MQTT-Broker herstellen
    client.connect("<BROKER_IP>", 1883)  # IP-Adresse, Port
    
    # Callback-Funktionen zuweisen
    client.on_connect = on_connect
    client.on_message = on_message
    
    # Startet die Endlosschleife, um auf Nachrichten zu warten
    client.loop_forever()
    
    Code-Sprache: Python (python)
    • Passe <BROKER_IP>, <USERNAME>, <PASSWORD> entsprechend an.
    5. Shell-Skript zur HDMI-Steuerung
    • Erstelle ein Shell-Skript (rpi-hdmi.sh), das den HDMI-Port steuert:
    #!/bin/sh
    case $1 in
        on) vcgencmd display_power 1 ;;
        off) vcgencmd display_power 0 ;;
    esac
    Code-Sprache: Bash (bash)
    • Speichere das Skript ausführbar:
    chmod +x /home/pi/rpi-hdmi.sh
    6. Autostart mit Systemd einrichten
    • Erstelle eine neue Systemd-Service-Datei:
    sudo nano /etc/systemd/system/dakboard.service
    • Füge den folgenden Inhalt ein:
    [Unit]
    Description=DAKboard MQTT Display Control
    After=network.target
    
    [Service]
    ExecStart=/usr/bin/python3 /path/to/your/script.py
    Restart=always
    User=pi
    WorkingDirectory=/home/pi
    StandardOutput=inherit
    StandardError=inherit
    
    [Install]
    WantedBy=multi-user.target
    Code-Sprache: JavaScript (javascript)

    Anpassungen: Ersetze /path/to/your/script.py durch den Pfad deines Python-Skripts.

    • Aktiviere und starte den Dienst:
    sudo systemctl enable dakboard.service
    sudo systemctl start dakboard.serviceCode-Sprache: CSS (css)

    Mit diesem Ansatz ist dein Skript sauber in den Bootprozess integriert, und Systemd sorgt für den Neustart bei Fehlern.

  • Gewürzeinsatz für Küchenschublade

    In unserer Küche bestand die dringende Notwendigkeit, eine praktikable Lösung für die Aufbewahrung unserer Gewürze zu finden. Diese werden bei uns vorzugsweise in kleinen Gläsern mit Korkenverschluss von Ankerkraut aufbewahrt. Unser Wunsch war es, diese Gläser sichtbar und griffbereit in einer freien Schublade zu lagern. Bei meiner Suche stieß ich jedoch auf ein Problem: Ich fand keine geeigneten Einsätze, die zu den Abmessungen unserer Gewürzgläser passten. Daher entschied ich mich, selbst etwas für den 3D Drucker zu bauen..

    Fusion360 Maße

    Die Einsätze wurden als separate Module konzipiert, wobei jedes Modul Platz für vier Gläser bietet. Jedes dieser Module misst 150mm in der Breite und 236,5mm in der Höhe. Diese Maße wurden so gewählt, dass genau zwei Module übereinander in unsere Küchenschubladen passen. Die Höhe inkl. Glas beträgt 63,3mm.

    Fusion 360 Höhe

    Das Endergebnis kann sich in meinen Augen durchaus sehen lassen. Nun haben wir eine maßgeschneiderte, übersichtliche und ästhetische Lösung für die Aufbewahrung unserer Gewürzgläser.

    Das fertige Produkt

    Für all diejenigen, die sich von diesem Projekt inspiriert fühlen und es nachbauen möchten, habe ich das STL-Modell für den 3D-Drucker zur Verfügung gestellt.

    STL Modell für den Ausdruck

  • Aquascaping

    Mal ein bisschen was fürs Auge auf meiner Seite. Während des Corona Lockdowns hat mich das Thema Aquascaping gepackt und nachdem ich die ersten Bilder im Internet gesehen hatte, war klar das ich sowas auch haben möchte. Mittlerweile habe ich ein eigenes 60f von ADA im Wohnzimmer stehen. Als Besatz schwimmen dort eine wachsende Anzahl Zwerggarnelen, ein paar Schnecken sowie zwei Zwergfadenfische herum.

    ADA 60f Aquascape

    Und auch wer weniger Platz zur Verfügung hat, kann sich schöne Pflanzenaquarien in die Wohnung stellen. Hier mein erstes Wabikusa mit Moosball

    DOOA Neo Glas Air Wabikusa

    Da die Lust auf Pflanzenaquarien damit noch immer nicht befriedigt ist, ist im Laufe des nächsten Jahres noch die Anschaffung eines ~250l Beckens geplant.

  • New Frontend for Opensource Smartmeter

    I never really liked the structure of my piMeter software. The combination of websockets for live data and a database for historical data was cluttered and buggy. On top of that, I was never happy with the javascript frontend where all the graphs for visualisation were hardcoded.

    Time to streamline the software and leave the visualisation to people who know about it. Grafana and InfluxDB were the right candidates.

    Installation of InfluxDB and Grafana

    Add the Package Source:

    curl -sL https://repos.influxdata.com/influxdb.key | sudo apt-key add - source 
    /etc/lsb-release echo "deb https://repos.influxdata.com/${DISTRIB_ID,,} 
    ${DISTRIB_CODENAME} stable" | sudo tee /etc/apt/sources.list.d/influxdb.listCode-Sprache: PHP (php)

    Install the database with apt-get and start the service:

    sudo apt-get update && sudo apt-get install influxdb
    sudo service influxdb startCode-Sprache: JavaScript (javascript)

    With the command:

    influx

    you can start the InfluxDB console and add a database for your piMeter

    CREATE DATABASE piMeter

    Thats it.

    Installing Grafana works the same way.

    Add Package Source:

    echo "deb https://packagecloud.io/grafana/stable/debian/ wheezy main" | 
    sudo tee /etc/apt/sources.list.d/grafana.list curl https://packagecloud.io/gpg.key | 
    sudo apt-key add -Code-Sprache: PHP (php)

    Install Grafana with apt-get and start the service:

    sudo apt-get update && sudo apt-get install grafana
    sudo service grafana-server startCode-Sprache: JavaScript (javascript)

    You can now Log-In to your installation at www.yourDomain:3000 and build your Dashboard.

    Ressources

    Github

    The old repository will be cleaned up and renamed to piMeter_hardware.
    I would like to thank  orca-zhang for the really easy to use InfluxDB-Cpp Lib!

  • Opensource Raspberry Pi Smartmeter

    I was missing the ability to measure and visualise the energy consumption in my smarthome. For this reason I developed a smartmeter / energymonitor as an extension for the Raspberry Pi, which I would like to share for rebuild / improvement / expansion. The piMeter.

    The Smartmeter can record the following data in 3 phases:

    Current RMS
    Voltage RMS
    Active power
    Apparent power
    Reactive power
    Accumulated active power
    Accumulated apparent power
    Accumulated reactive power

    All smartmeter data is visualised on a web front-end. It shows consumption data for a given day, month or year. It can also display real-time data of actual consumption. The real-time data is stored in the RAM. It keeps 10 minutes of data in a buffer and sends it to the browser when needed. The long-term data is stored in a mariaDB on my NAS. Storing this data directly on the Pi is not recommended due to the high read/write cycles on the sd card.

    The smartmeter is based on the ADE9000 chip from Analog Devices, which communicates with the Raspberry Pi via SPI. For the current measurement I use SCT-013-000 current transformers from YHDC. They are cheap and can measure currents up to 100A.

    Web Frontend

    Dashboard
    Realtime Data

    Smartmeter Board

    piMeter Board

    Case

    Ressources

    Github
    Schematics
    SCT-013-000 Datasheet
    ADE9000 Datasheet
    BCM2835 SPI Lib

    Disclaimer

    Working with 230V is dangerous. The board has no protection against accidental contact. I accept no liability for damage to persons or property resulting from the reproduction of the meter.