Schlagwort: RaspberryPi

Putzfunktion für Raspberry Display

5. Februar 2023 / jjk1 / Keine Kommentare

Wenn mein Display (hier kannst du dir anschauen, wie ich es eingebaut habe) schmutzig ist, ist es ganz praktisch, wenn es eine „Putzfunktion“ gibt, die für eine kurze Zeit alle Eingaben deaktiviert, sodass beim Putzen nichts verstellt wird. Hier möchte ich dir zeigen, wie ich das umgesetzt habe.

Installation des Webservers

Für diese Funktion verwende ich einen Webserver, der ein Request entgegennimmt. Dieser führt dann ein Shell Skript aus, das die Eingaben vom Touchscreen abschaltet.

sudo apt install apache2 php

1	sudo apt install apache2 php

PHP Skript

Dann verwende ich ein einfaches PHP Skript, welches ein Shell-Skript als User „pi“ startet:

<?php
        exec('sudo su -c "/home/pi/cleanmode.sh" pi');

1 2	<?php exec('sudo su -c "/home/pi/cleanmode.sh" pi');

Dieses habe ich in /var/www/html/cleanmode.sh gespeichert.

Shell-Skript

Für das Shell-Skript muss man zuerst die ID des Touchscreens herausfinden. Mit folgendem Befehl lassen sich alle IDs anzeigen:

pi@raspberrypi:~ $ DISPLAY=:0 xinput list
⎡ Virtual core pointer                    	id=2	&#91;master pointer  (3)]
⎜   ↳ Virtual core XTEST pointer              	id=4	&#91;slave  pointer  (2)]
⎜   ↳ ILITEK ILITEK-TP Mouse                  	id=8	&#91;slave  pointer  (2)]
⎜   ↳ ILITEK ILITEK-TP                        	id=7	&#91;slave  pointer  (2)]
⎜   ↳ vc4                                     	id=6	&#91;slave  pointer  (2)]
⎣ Virtual core keyboard                   	id=3	&#91;master keyboard (2)]
    ↳ Virtual core XTEST keyboard             	id=5	&#91;slave  keyboard (3)]
    ↳ vc4                                     	id=9	&#91;slave  keyboard (3)]

pi@raspberrypi:~ $ DISPLAY=:0 xinput list

⎡ Virtual core pointer id=2 [master pointer (3)]

⎜ ↳ Virtual core XTEST pointer id=4 [slave pointer (2)]

⎜ ↳ ILITEK ILITEK-TP Mouse id=8 [slave pointer (2)]

⎜ ↳ ILITEK ILITEK-TP id=7 [slave pointer (2)]

⎜ ↳ vc4 id=6 [slave pointer (2)]

⎣ Virtual core keyboard id=3 [master keyboard (2)]

↳ Virtual core XTEST keyboard id=5 [slave keyboard (3)]

↳ vc4 id=9 [slave keyboard (3)]

Anschließend probiert man mit

DISPLAY=:0 xinput disable [ID]

1	DISPLAY=:0 xinput disable [ID]

alle IDs durch, bis der Touchscreen nicht mehr funktioniert. In meinem Fall war es die ID 7.

Folgendes Shell-Skript muss dann angepasst werden:

DISPLAY=:0 xinput disable 7
sleep 60
DISPLAY=:0 xinput enable 7

DISPLAY=:0 xinput disable 7

sleep 60

DISPLAY=:0 xinput enable 7

Die Zeit in Zeile 2 kann man ebenfalls nach Belieben anpassen. Mein Skript liegt in /home/pi/cleanmode.sh. Sollte das bei dir anders sein, musst du den Pfad im PHP Skript entsprechend ändern.

Den Benutzer www-data mit Root-Rechten ausstatten

Damit der User www-data (Dieser wird vom Webserver verwendet) das Shell-Skript als User pi ausführen kann, braucht er Root-Rechte.

ACHTUNG: Den Benutzer www-data mit Rootrechten auszustatten, ist ein großes Sicherheitsrisiko. Dies sollte man unter keinen Umständen auf einem vom Internet erreichbaren Webserver tun!

Wir öffnen dazu mit dem Befehl

sudo visudo

1	sudo visudo

Die Datei /etc/sudoers und tragen dort unter „User privilege specification“ folgende Zeile ein:

www-data ALL=NOPASSWD: ALL

1	www-data ALL=NOPASSWD: ALL

Nach dem Speichern mit Strg+O, dem Beenden mit Strg+X und einem Neustart hat der User www-data nun Root-Rechte. Öffnet man nun im Browser folgende URL:

http://[IP_DEINES_RPi]/cleanmode.sh

sollte sich der Touchscreen abschalten und nach 60 Sekunden wieder anschalten.

Putzfunktion in Homeassistant

Auf meinem Display läuft zur Zeit Homeassistant. Dort möchte ich die Putzfunktion gerne als Button haben. Außerdem möchte ich einen Timer, der mir anzeigt, wie viel Zeit ich noch habe, bis der Touchscreen wieder aktiviert wird.

In der config.yaml habe ich folgende Konfiguration hinterlegt:

rest_command:
  cleanmode:
    url: "http://[IP_MEINES_RPi]/cleanmode.php"

timer:
  putztimer:
    duration: "00:00:60"

rest_command:

cleanmode:

url: "http://[IP_MEINES_RPi]/cleanmode.php"

timer:

putztimer:

duration: "00:00:60"

Ersteres ist der Aufruf der URL, Zweiteres der Timer.

Anschließend habe ich im Homeassistant UI einen Button unter „Helfer“ erstellt.
Eine Automatisierung steuert dann das ganze, startet also den Timer und ruft dann die URL auf:

Homeassistant Automatisierung Putzfunktion

Und hier noch in Textform:

alias: Putzbutton
description: ""
trigger:
  - platform: state
    entity_id:
      - input_button.putzbutton
condition: []
action:
  - service: timer.start
    data:
      duration: "60"
    target:
      entity_id: timer.putztimer
  - service: rest_command.cleanmode
    data: {}
mode: single

alias: Putzbutton

description: ""

trigger:

- platform: state

entity_id:

- input_button.putzbutton

condition: []

action:

- service: timer.start

data:

duration: "60"

target:

entity_id: timer.putztimer

- service: rest_command.cleanmode

data: {}

mode: single

Solaranzeige Daten in Homeassistant

6. Januar 2023 / jjk1 / 2 Kommentare

Heute Morgen habe ich mich an ein Problem gesetzt, das ich schon länger habe: Wie bekomme ich die Daten meiner Solaranzeige in Homeassistant? Oder ist es vielleicht sinnvoller, die Homeassistant SolarEdge Modbus Integration zu verwenden und die Daten dann von Homeassistant in die InfluxDB zu schicken?
Ich habe mich für die erste Variante entschieden. Dabei ist ein kleines PHP Programm entstanden. Dort gibt man einen MQTT „Block“ ein und heraus kommt dabei eine fertige Homeassistant Konfiguration, die man nur noch kopieren muss. Eine ausführlichere Anleitung wie’s funktioniert ist auch dabei.

Link: https://jojokorpi.ddns.net/solaranzeigetohomeassistant
Quellcode: https://github.com/jjk4/solaranzeigetohomeassistant

Shelly Plug S in Grafana visualisieren

26. November 2022 / jjk1 / Keine Kommentare

Wenn man Strom sparen möchte, ist es vorteilhaft zu wissen, welche Geräte wann wie viel Strom verbrauchen. Um das herauszufinden, gibt es Messsteckdosen, die man zwischen Steckdose und Stecker stecken kann, um den Stromverbrauch zu messen. Eine Möglichkeit dafür ist die Shelly Plug S. Diese Steckdose lässt sich per App bedienen. Dort kann man neben der aktuellen Leistung auch den Stromverbrauch sehen. Ein Diagramm, welches die Leistung über einen Zeitraum angibt, gibt es hier aber leider nicht. Und außerdem ist die Steckdose in dieser Form von der Cloud abhängig – das möchte auch nicht jeder.

Was ich an Shellys gut finde, ist, dass man sie auch völlig Lokal per Webinterface oder MQTT bedienen kann. Theoretisch kann man auf den meisten von ihnen sogar eine eigene Firmware flashen (Info dazu hier: https://templates.blakadder.com/index.html ), aber das wäre mir an dieser Stelle zu viel.

Material

Shelly Plug S
beliebigen Linux Server, z.B. RaspberryPi

Installation von MQTT

Auf dem Server müssen wir einen MQTT Server installieren, an den die Shelly die Daten senden kann:

sudo apt install mosquitto mosquitto-clients

1	sudo apt install mosquitto mosquitto-clients

Konfiguration der Shelly

Die Shelly macht bei ersten Start einen Hotspot auf, mit dem man sich beispielsweise mit dem Handy verbinden kann. Im Browser gibt man dann die Adresse http://192.168.33.1 ein, wo man dann die Zugangsdaten zum WLAN eingeben kann. Danach startet die Shelly neu und man kann nun das Webinterface aus dem Heimnetz öffnen und dort sämtliche Einstellungen vornehmen.

Unter „Internet & Security“, „Advanced Developer Settings“ gibt es hier den Punkt „Enable action execution via MQTT“. Diesen aktivieren wir und geben dann unter „Server“ die IP-Adresse des Servers und den Port (Standard ist 1883) an. Danach das Speichern nicht vergessen!

Eine andere wichtige Einstellung wäre noch unter dem Punkt „Settings“ „POWER ON DEFAULT MODE“, also was passieren soll, wenn die Shelly mal keinen Strom mehr bekommt (z.B. bei einem Stromausfall). Das hängt davon ab, was an der Shelly hängt. Bei einer Lampe macht es Sinn, sie nach einem Stromausfall auszuschalten, während ein Kühlschrank immer an bleiben sollte.

Test

Mit dem Befehl

mosquitto_sub -v -h localhost -t "#"

1	mosquitto_sub -v -h localhost -t "#"

werden alle Nachrichten im Terminal angezeigt, die per MQTT verschickt werden. Nach spätestens 30 Sekunden (Die Shelly sendet alle 30 Sekunden Daten) sollte es eine Ausgabe geben, die ungefähr so aussieht:

shellies/shellyplug-s-5B3FE7/relay/0/power 6.20
shellies/shellyplug-s-5B3FE7/relay/0/energy 1193685
shellies/shellyplug-s-5B3FE7/relay/0 on
shellies/shellyplug-s-5B3FE7/temperature 31.88
shellies/shellyplug-s-5B3FE7/overtemperature 0

shellies/shellyplug-s-5B3FE7/relay/0/power 6.20

shellies/shellyplug-s-5B3FE7/relay/0/energy 1193685

shellies/shellyplug-s-5B3FE7/relay/0 on

shellies/shellyplug-s-5B3FE7/temperature 31.88

shellies/shellyplug-s-5B3FE7/overtemperature 0

Interessant sind hier die Punkte „Power“ (aktuelle Leistung in Watt) und „Energy“ (Gesamtverbrauch in Wattminuten)

Python Skript

Zuerst müssen folgende Python Module installiert werden:

sudo pip3 install influxdb paho-mqtt

1	sudo pip3 install influxdb paho-mqtt

Mein Code dafür ist folgender:

#!/usr/bin/env python3

import paho.mqtt.client as mqtt
import json
from influxdb import InfluxDBClient

influxclient = InfluxDBClient(host='localhost', port=8086)
influxclient.switch_database('solaranzeige')
try:
    # This is the Subscriber

    def on_connect(client, userdata, flags, rc):
        print("Connected with result code "+str(rc))
        client.subscribe("shellies/shellyplug-s-5B3FE7/relay/0/power")
        client.subscribe("shellies/shellyplug-s-5B3FE7/relay/0/energy")


    def on_message(client, userdata, msg):
        if(msg.topic == "shellies/shellyplug-s-5B3FE7/relay/0/power"):
            leistung = float(msg.payload.decode())
            print(leistung)
            json_body = [
                {
                    "measurement": "shellyplugs1",
                    "fields": {
                        "leistung": leistung,
                    }
                },
            ]
            influxclient.write_points(json_body)
        if(msg.topic == "shellies/shellyplug-s-5B3FE7/relay/0/energy"):
            energie = float(msg.payload.decode())
            print(energie)
            json_body = [
                {
                    "measurement": "shellyplugs1",
                    "fields": {
                        "energie": energie,
                    }
                },
            ]
            influxclient.write_points(json_body)
    client = mqtt.Client()
    client.connect("localhost",1883,60)

    client.on_connect = on_connect
    client.on_message = on_message

    client.loop_forever()
except Exception as e:
    print("Fehler: " + str(e))

#!/usr/bin/env python3

import paho.mqtt.client as mqtt

import json

from influxdb import InfluxDBClient

influxclient = InfluxDBClient(host='localhost', port=8086)

influxclient.switch_database('solaranzeige')

try:

# This is the Subscriber

def on_connect(client, userdata, flags, rc):

print("Connected with result code "+str(rc))

client.subscribe("shellies/shellyplug-s-5B3FE7/relay/0/power")

client.subscribe("shellies/shellyplug-s-5B3FE7/relay/0/energy")

def on_message(client, userdata, msg):

if(msg.topic == "shellies/shellyplug-s-5B3FE7/relay/0/power"):

leistung = float(msg.payload.decode())

print(leistung)

json_body = [

{

"measurement": "shellyplugs1",

"fields": {

"leistung": leistung,

}

]

influxclient.write_points(json_body)

if(msg.topic == "shellies/shellyplug-s-5B3FE7/relay/0/energy"):

energie = float(msg.payload.decode())

print(energie)

json_body = [

{

"measurement": "shellyplugs1",

"fields": {

"energie": energie,

}

]

influxclient.write_points(json_body)

client = mqtt.Client()

client.connect("localhost",1883,60)

client.on_connect = on_connect

client.on_message = on_message

client.loop_forever()

except Exception as e:

print("Fehler: " + str(e))

Kurze Erklärung: (Diese stellen müssen angepasst werden!)

Z. 7-8: Es wird eine Verbindung zur Datenbank hergestellt
Z. 14-15: Die topics von power und energy der Shelly werden subscribed. Hier können auch noch zusätzliche topics hinzukommen, z.B. für die Betriebstemperatur oder weitere Shellys, siehe Abschnitt „Test“)
Z. 19-30: Auch hier muss das topic angepasst werden. In diesem Abschnitt wird dann der Wert in der Konsole ausgegeben und anschließend in die Datenbank in das measurement „shellyplugs1“ in das Feld „leistung“ eingetragen. Dieser Abschnitt muss auch wiederholt werden, falls weitere topics nach Z. 15 hinzugefügt wurden.
Z. 44: Es wird eine Verbindung zum MQTT Broker hergestellt.

Dieses Skript kann nun laufen, zum Beispiel als Systemd Service Unit und schreibt die Daten dann in die Influx Datenbank, von wo sie beispielsweise mit Grafana visualisiert werden können.

Beispiel Visualisierung mit Grafana

Die Shelly hängt bei mir am Kühlschrank. Im folgenden Diagramm sieht man gut, dass die Ausschläge in der Nacht im Gesamtstromverbrauch (gelb) vom Kühlschrank kommen (grün):

Lokale Hostnames in Pi-hole korrekt auflösen

19. September 2021 / jjk1 / Keine Kommentare

Seit einigen Jahren suchte ich schon nach einer Lösung, Hostnames im lokalen Netzwerk mit Pi-Hole korrekt aufzulösen. Nun bin ich selbst auf eine Lösung gekommen.

1. Möglichkeit: Conditional Forwarding

Diese Möglichkeit hatte ich einige Zeit, ich war damit aber nie so wirklich zufrieden, da immer hinter den Hostnames ein .fritz.box ergänzt werden musste, also z.B. raspberrypi.fritz.box.

Bei „Settings“ > „DNS“ > „Advanced settings“ muss man dazu folgende Punkte einstellen:

Unter „Never forward non-FQDNs“ und „Never forward reverse lookups for private IP ranges“ keinen Haken setzen.
Unter „Use Conditional Forwarding“ einen Haken setzen.
Den Bereich des lokalen Netzwerkes eingeben, zum Beispiel 192.168.178.0/24. /24 steht für x.x.x.1 bis x.x.x.255.
Die IP Adresse des DHCP Servers, meist der Router, eingeben, z.B. 192.168.178.1.
Als Local Domain Name verwende ich fritz.box

2. Möglichkeit: Der Router als einziger DNS Server

Diese Möglichkeit funktionierte bei mir schon besser. Bei „Settings“ > „DNS“ > „Advanced settings“ muss man dazu folgende Punkte einstellen:

In dem linken Kasten „Upstream DNS Servers“ alle Haken rausnehmen.
Im rechten Kasten „Upstream DNS Servers“ Als Custom 1 und Custom 3 die IP Adressen (IPV4 und IPV6) der Fritzbox bzw. des Routers eintragen.

Nun funktionieren die Hostnames wie gewohnt.

13″ Touchscreen Wandeinbau

17. August 2021 / jjk1 / 2 Kommentare

Ich habe jetzt seit Längerem einen 7″ Touchscreen bei mir in der Wand hängen. Der lief bis jetzt auch gut, aber er wurde mir zu klein. Deshalb hab ich mich auf die Suche nach einem Neuen gemacht und schließlich diesen 13″ Touchscreen von Waveshare gefunden und bestellt.

Materialliste

Display
HDMI Kabel mit Winkelstecker
Raspberry
Kühlkörper
3D Drucker und Filament für’s Gehäuse
ein paar Kleinigkeiten (Schrauben, Kabel, Lüsterklemme, …)
Werkzeug

Testaufbau

Nach deutlich verspäteter Lieferung Konnte ich den Touchscreen ausprobieren. Ein Netzteil hatte ich noch da, aber keinen passenden Stecker. Da musste dann eben der Lötkolben zum Einsatz kommen:

Im Wiki stand zwar, dass man die Auflösung einstellen muss, das war aber bei mir nicht der Fall. Das Display lief Plug and Play.

Software

Beim 7″ Touchscreen habe ich rpi-backlight genutzt, um den Bildschirm bzw. die Hintergrundbeleuchtung an- und auszuschalten. Hier verwende ich jetzt vcgencmd display_power 0 und vcgencmd display_power 1.

Als Oberfläche verwende ich, wie beim alten Display auch, eine selbst gebaute HTML Seite. Da ich jetzt deutlich mehr Platz habe, konnte ich hier auch mehr auf einmal darstellen. Die Seite gibts auf Github zum Download. Sie ist noch nicht fertig.

https://github.com/jjk4/displayoberflaeche

Das Gehäuse

Ein Problem, dass mich länger beschäftigt hat, was ein passendes Gehäuse. Bei dem alten 7″ Touchscreen passte ja dieses Gehäuse sehr gut, aber dieser Zufall war schon so zufällig, den gibts nicht zweimal. Also wollte ich das Gehäuse drucken.

Dieses Gehäuse ist dabei raus gekommen:

Gehäuse zum Download: https://www.thingiverse.com/thing:4934655

An den Ecken kann man eine Mutter einschmelzen und an der Rückseite gibt es eine Befestigungsmöglichkeit für den Raspberry (In meinem Fall ein Pi 3). Gedruckt sieht das Ganze dann so aus:

Da bei einem Teil das dünne Stück zerbrochen ist, hab ich noch schnell ein weiteres Teil gedruckt, dass nicht nur das abgebrochene wieder fixiert, sondern auch die beiden Teile zusammenhält:

Bilder vom Einbau

RaspberryPi als Überwachungskamera

12. August 2021 / jjk1 / Keine Kommentare

Hier möchte ich dir gerne zeigen, wie ich mit einem Raspberry Pi eine Überwachungskamera gebaut habe und wie auch du das machen kannst.

Hardware

Materialliste

Raspberry: Ein Raspberry Pi Zero ist klein, günstig und verbraucht nur wenig Strom. Er ist aber auch in der Leistung stark beschränkt. Bei HD Auflösung (1280×720) hat er bei mir bei Bewegungserkennung und beim Speichern der Bilder ca. 1FPS erreicht. Das reicht mir aus. Wer mehr braucht, sollte lieber zu einem Raspberry Pi 4 greifen.

Netzteil: Ich verwende hier ein Hutschienennetzteil (Für den Pi4 hier). Wer lieber eines mit Stecker (Für den Pi4 hier) mag, kann das auch verwenden.

Kühlung: Da bei einer Videoübertragung und Bewegungserkennung der RPi ganz schön viel zu tun hat, ist eine Kühlung auf jeden Fall sinnvoll. Ich verwende diese Kühlkörper (Für den Pi4 hier). Da auch der USB Stick ziemlich heiß wurde und ich vom RPi Zero noch den kleinen Kühlkörper übrig hatte, habe ich diesen zum Kühlen des USB Sticks genutzt. In eine normale USB-Buchse passt er dann aber nicht mehr.

SD Karte: Ich verwende diese hier. 16 GB sind für das Projekt völlig ausreichend. Theoretisch würden auch weniger reichen, kleinere SD Karten kosten aber fast genau so wenig.

Kameramodul: Hier hat man eine große Auswahl. Ob mit Weitwinkel, Infrarot, gleich beidem, in extrem klein oder in High Quality (nicht für den Pi Zero zu empfehlen). Es gibt aber auch sehr günstige Kameras wie diese hier, die absolut ausreichend sind.

Flachbandkabel: Die meisten Kameras kommen bereits mit einem Kabel. Da Raspberry Pi Zero aber einen kleineren CSI Anschluss hat, braucht man dafür ein Adapterkabel.

USB Stick: Wenn Aufnahmen gespeichert werden sollen, macht man das wegen der begrenzten Haltbarkeit am besten nicht auf der SD Karte. Stattdessen kann man einen USB Stick verwenden oder die Aufnahmen auf einem NAS speichern. Ich verwende diesen Stick.

Adapter für USB-Stick: Da der Raspberry Pi Zero nur einen Micro USB Anschluss hat, braucht man für den USB Stick einen Adapter. Ich verwende diesen hier.

Gehäuse: Hier gibt es auch sehr viel Auswahl. Es gibt das offizielle Raspberry Pi Zero Gehäuse, welches schon eine Aussparung für eine Kamera hat, aber ich verwende gerne Kamera Dummys. Diese sehen dann nicht nur aus wie echte Kameras, sondern lassen sich auch gut einstellen.

Zusammengerechnet komme ich dann nach aktuellem Stand auf ca. 60€.

Zusammenbau

Zum Zusammenbau braucht man nicht viel sagen. Alles kommt in den Stecker, wo es reinpasst ;). Zusammengebaut sieht die Kamera (ohne Gehäuse) so aus:

Einbau in das Gehäuse

Meine Kamera soll in einen Kameradummy. Ich habe diese hier verwendet. Vermutlich sind aber die meisten Kamera Dummys auf eBay sehr ähnlich, wenn nicht sogar gleich. Er lies sich sehr gut zerlegen. Das sieht dann so aus:

Das Schutzglas lässt sich ebenfalls noch ausbauen. So kann man es reinigen. Die Kameralinse und die LED werden nicht benötigt. Zwischen den beiden Hälften des Gehäuses lässt sich sehr gut eine Kunststoffplatte befestigen. Auf dieser habe ich dann den Raspberry festgeschraubt.

Hinter der Platte mit den IR LED Attrappen kann man mit Heißkleber die Kamera befestigen. Das sieht dann so aus:

Jetzt muss nur noch alles wieder zusammengebaut werden. Der Raspberry hängt bei mir in der unteren Kamerahälfte, da es wegen dem Batteriefach oben sehr eng wird.

Von vorne sieht die Kamera dann so aus:

Software

Installation des Images

Als Software für die Überwachungskamera verwende ich Motioneye OS. Das ist eine für verschiedene Einplatinencomputer optimierte Linuxdistribution, mit der man sehr einfach und benutzerfreundlich Überwachungskameras bauen kann.

Nachdem das Image heruntergeladen und mit z. B. dem Raspberry Pi Imager auf die SD Karte gespielt wurde, muss noch das WLAN, falls vorhanden eingestellt werden. Erstelle dazu auf der kleineren der beiden Partitionen auf der SD Karte (boot Partition) eine Datei mit dem Namen „wpa_supplicant.conf“. Diese Datei braucht folgenden Inhalt:

country=DE
update_config=1
ctrl_interface=/var/run/wpa_supplicant

network={
    scan_ssid=1
    ssid="WLAN NAME"
    psk="MEINTOLLESSUPERSICHERESPASSWORT"
}

country=DE

update_config=1

ctrl_interface=/var/run/wpa_supplicant

network={

scan_ssid=1

ssid="WLAN NAME"

psk="MEINTOLLESSUPERSICHERESPASSWORT"

}

Die SSID und das Passwort müssen natürlich angepasst werden.

Konfiguration von Motioneye

Nach dem Booten und aufrufen der IP im Browser sieht man direkt das Bild der Kamera:

Um weitere Einstellungen vorzunehmen, muss man sich aber anmelden. Das geht über den „switch user“ Button oben links. Der Benutzername ist „admin“ und das Passwort muss leer gelassen werden.

Jetzt kann man im seitlichen Menü alle möglichen Einstellungen vornehmen. Diese sind meist selbsterklärend, trotzdem gibt es noch neben jeder Einstellung ein ?, welches die Einstellung noch mal erklärt. Meine Einstellungen sehen so aus:

Wenn man auf den Livestream und anschließend auf das „Foto“ Icon klickt, kann man sich Kameraaufnahmen anschauen:

Homeserver mit dem RaspberryPi

24. Juli 2021 / jjk1 / Ein Kommentar

Hier möchte ich dir meinen kleinen Homeserver vorstellen.

Hardware

Materialliste

RaspberryPi 4 4GB
Netzteil
SSD
Gehäuse/Adapter für SSD
SD Karte
„Serverschrank“
Breakout Board
8 Kanal Relais Karte
Kühler
Kabel für GPIO (in meinem Fall ein altes IDE Kabel)
Modbus USB Adapter
Display mit I2C Platine
Überspannungsschutz
Stromzähler Shellcount 2
Alte externe HDD
Mehrfachstecker
Kabel, Klemmen, Hutschiene, Kabelkanäle

Zusammenbau

Achtung: Arbeiten an 230V darf nur von Elektrofachpersonal durchgeführt werden!

Klemmen und Relaiskarte — Bilder vom Zusammenbau

Versorgt wird der ganze Homeserver mit 230V. Diese gehen zuerst durch den Zähler, dann an eine Steckdose, an der der Überspannungsschutz und dann ein Mehrfachstecker angeschlossen ist. An dieser hängt das Netzteil für den Pi und das Netzteil für die HDD. Das 5V Netzteil hat zwei Ausgänge, einen verwende ich nur für den Pi, den anderen für alles andere.

Das Display ist mit 3,3V und I2C (Pin 3 und 5) angeschlossen. Onewire Sensoren, die die Temperatur der Wärmepumpe kontrollieren sind ebenfalls mit 3,3V und Onewire (Standard Pin 7) angeschlossen. Die Relais laufen mit 5V und beliebigen GPIOs. Die S0 Schnittstelle des Stromzählers ist an einen freien GPIO angeschlossen. Die HDD, SSD und der Modbus Adapter, der Stromzähler überwacht sind per USB angeschlossen (HDD und SSD an USB3, Modbus an USB2).

Ganzer Server Tür zu — Bilder vom fertigen Homeserver (mangels Tageslicht etwas unscharf)

Ganzer Server — Bilder vom fertigen Homeserver (mangels Tageslicht etwas unscharf)

Software

Zur Software möchte ich gar nicht so viel sagen. Auf dem Raspberry läuft Raspbian 10 und:

Nextcloud
InfluxDB
Pihole
Wireguard
Webserver, u.A. für diese Webseite
Grafana
Minetest
Samba Server
Webmin
kleinere Skripte von mir, die verschiedene Werte (Modbus, Netzwerk, 1Wire) auslesen, verarbeiten, speichern und je nach Wert Relais schalten)
Und bestimmt noch ein paar weitere, die ich jetzt vergessen hab

LCD Display

Zu einem Punkt möchte ich doch noch weiter ins Detail gehen. Für das Display verwende ich folgendes Skript: klick. Ein Video dazu gibt es hier:

Statusdisplay für meinen Homeserver

Dieses Video auf YouTube ansehen

SDM630 Modbus Zähler auslesen

1. Juni 2021 / jjk1 / 6 Kommentare

In diesem Tutorial zeige ich dir, wie du mit einem RaspberryPi (oder auch jedem anderen Linux Rechner) einen SDM630 Modbus Zähler auslesen kannst. Das Tutorial soll eher eine Grundlage für ein eigenes Projekt sein. Fertige Software gibt es genug, wie zum Beispiel Smartmeter.

Hardware

SDM630 Stromzähler (z.B. diesen hier)
Modbus USB Adapter (z.B. diesen hier)
Kabel
2x 150 Ohm Widerstand

An der oberen Klappe des Zählers gibt es u.A. die Anschlüsse A+ und B-. Diese werden mit den Klemmen A und B am Adapter verbunden. Ein Abschlusswiderstand von 150 Ohm kommt an die Endes des Bus bzw. an das letzte und erste Gerät. Da ich nur 2 Geräte habe, ist das der Zähler und der USB Adapter.

Am Bus können theoretisch mehrere Zähler parallel angeschlossen werden.

Software

Einstellungen am Zähler

Am Zähler müssen für den Modbus verschiedene Einstellungen vorgenommen werden. Das geht bei meinem Zähler so:

Lange die Taste E drücken
Passwort eingeben (Standard: 1000)
Lange die Taste E drücken
Es erscheint „Set Addr“
Durch langes Drücken der Taste E die Einstellung wählen und mit den Pfeilen die Adresse ändern. Durch langes Drücken der Taste E die Einstellung Verlassen
Mit den Pfeilen die Einstellungen „Set baud“, „Set Pari“ und „Set Stop“ wählen und ebenfalls einstellen

Die Adresse ist dazu das, das Gerät im Bus zu identifizieren. Wenn du nur ein Gerät hast, kannst du die Adresse bei 1 lassen, wenn du mehrere hast, den Geräten entsprechend unterschiedliche Adressen geben.

Die Baudrate ist einfach gesagt die Übertragungsgeschwindigkeit. Bei höherer Baudrate ist aber nur eine kürzere Kabellänge möglich.

Parität benutze ich keine, also „none“

Der Stop-Bit kann auf 1 gelassen werden

Mit Skript Werte auslesen

Neben den Einstellungen die du vorher vorgenommen hast, brauchst du noch einen weiteren Wert: Den USB Port. Durch ausprobieren ist man hier ziemlich erfolgreich. Mit ls /dev/ttyUSB* kannst du dir alle Ports anzeigen lassen. In meinem Fall gab es nur einen einzigen.

Mein Code sieht folgendermaßen aus:

import minimalmodbus

instrument = minimalmodbus.Instrument('/dev/ttyUSB0', 1)  # port name, slave address (in decimal)
input_register = {
    "Spannung_L1": {
        "port": 0, "digits": 2, "Unit": "V", "use": True},
    "Spannung_L2": {
        "port": 2, "digits": 2, "Unit": "V", "use": True},
    "Spannung_L3": {
        "port": 4, "digits": 2, "Unit": "V", "use": True},
    "Strom_L1": {
        "port": 6, "digits": 2, "Unit": "A", "use": True},
    "Strom_L2": {
        "port": 8, "digits": 2, "Unit": "A", "use": True},
    "Strom_L3": {
        "port": 10, "digits": 2, "Unit": "A", "use": True},
    "Wirkleistung_L1": {
        "port": 12, "digits": 2, "Unit": "W", "use": True},
    "Wirkleistung_L2": {
        "port": 14, "digits": 2, "Unit": "W", "use": True},
    "Wirkleistung_L3": {
        "port": 16, "digits": 2, "Unit": "W", "use": True},
    "Scheinleistung_L1": {
        "port": 18, "digits": 2, "Unit": "VA", "use": True},
    "Scheinleistung_L2": {
        "port": 20, "digits": 2, "Unit": "VA", "use": True},
    "Scheinleistung_L3": {
        "port": 22, "digits": 2, "Unit": "VA", "use": True},
    "Blindleistung_L1": {
        "port": 24, "digits": 2, "Unit": "VAr", "use": True},
    "Blindleistung_L2": {
        "port": 26, "digits": 2, "Unit": "VAr", "use": True},
    "Blindleistung_L3": {
        "port": 28, "digits": 2, "Unit": "VAr", "use": True},
    "Leistungsfaktor_L1": {
        "port": 30, "digits": 2, "Unit": "", "use": True},
    "Leistungsfaktor_L2": {
        "port": 32, "digits": 2, "Unit": "", "use": True},
    "Leistungsfaktor_L3": {
        "port": 34, "digits": 2, "Unit": "", "use": True},
    "Phasenwinkel_L1": {
        "port": 36, "digits": 2, "Unit": "Grad", "use": True},
    "Phasenwinkel_L2": {
        "port": 38, "digits": 2, "Unit": "Grad", "use": True},
    "Phasenwinkel_L3": {
        "port": 40, "digits": 2, "Unit": "Grad", "use": True},
    "Durchschnittliche_Spannung_zu_N": {
        "port": 42, "digits": 2, "Unit": "V", "use": True},
    "Durchschnittlicher_Strom_zu_N": {
        "port": 46, "digits": 2, "Unit": "A", "use": True},
    "aktueller_Gesamtstrom": {
        "port": 48, "digits": 2, "Unit": "A", "use": True},
    "aktuelle_Gesamtwirkleistung": {
        "port": 52, "digits": 2, "Unit": "W", "use": True},
    "aktuelle_Gesamtscheinleistung": {
        "port": 56, "digits": 2, "Unit": "VA", "use": True},
    "aktuelle_Gesamtblindleistung": {
        "port": 60, "digits": 2, "Unit": "VAr", "use": True},
    "aktueller_Gesamtleistungsfaktor": {
        "port": 62, "digits": 2, "Unit": "", "use": True},
    "aktueller_Gesamtphasenwinkel": {
        "port": 66, "digits": 2, "Unit": "A", "use": True},
    "Frequenz": {
        "port": 70, "digits": 2, "Unit": "Hz", "use": True},
    "Import_Wh_seit_reset": {
        "port": 72, "digits": 2, "Unit": "kWh", "use": True},
    "Export_Wh_seit_reset": {
        "port": 74, "digits": 2, "Unit": "kWH", "use": True},
    "Import_VArh_seit_reset": {
        "port": 76, "digits": 2, "Unit": "kVArh", "use": True},
    "Export_VArh_seit_reset": {
        "port": 78, "digits": 2, "Unit": "kVArh", "use": True},
    "VAh_seit_reset": {
        "port": 80, "digits": 2, "Unit": "kVAh", "use": True},
    "Ah_seit_reset": {
        "port": 82, "digits": 2, "Unit": "Ah", "use": True},
    "Gesamtwirkleistung": {
        "port": 84, "digits": 2, "Unit": "W", "use": True},
    "Max_Gesamtwirkleistung": {
        "port": 86, "digits": 2, "Unit": "W", "use": True},
    "Gesamtscheinleistung": {
        "port": 100, "digits": 2, "Unit": "VA", "use": True},
    "Max_Gesamtscheinleistung": {
        "port": 102, "digits": 2, "Unit": "VA", "use": True},
    "Gesamtstrom_Neutralleiter": {
        "port": 104, "digits": 2, "Unit": "A", "use": True},
    "Max_Strom_Neutralleiter": {
        "port": 106, "digits": 2, "Unit": "A", "use": True},
    "Spannung_L1_L2": {
        "port": 200, "digits": 2, "Unit": "V", "use": True},
    "Spannung_L2_L3": {
        "port": 202, "digits": 2, "Unit": "V", "use": True},
    "Spannung_L3_L1": {
        "port": 204, "digits": 2, "Unit": "V", "use": True},
    "Durchschnittsspannung_L_L": {
        "port": 206, "digits": 2, "Unit": "V", "use": True},
    "Strom_Neutralleiter": {
        "port": 224, "digits": 2, "Unit": "A", "use": True},
    "THD_Spannung_L1": {
        "port": 234, "digits": 2, "Unit": "%", "use": True},
    "THD_Spannung_L2": {
        "port": 236, "digits": 2, "Unit": "%", "use": True},
    "THD_Spannung_L3": {
        "port": 238, "digits": 2, "Unit": "%", "use": True},
    "THD_Strom_L1": {
        "port": 240, "digits": 2, "Unit": "%", "use": True},
    "THD_Strom_L2": {
        "port": 242, "digits": 2, "Unit": "%", "use": True},
    "THD_Strom_L3": {
        "port": 244, "digits": 2, "Unit": "%", "use": True},
    "THD_Durchschnittliche_Spannung_zu_N": {
        "port": 248, "digits": 2, "Unit": "%", "use": True},
    "THD_Durchschnittlicher_Strom_zu_N": {
        "port": 250, "digits": 2, "Unit": "%", "use": True},
    "Strom_L1_demand": {
        "port": 258, "digits": 2, "Unit": "A", "use": True},
    "Strom_L2_demand": {
        "port": 260, "digits": 2, "Unit": "A", "use": True},
    "Strom_L3_demand": {
        "port": 262, "digits": 2, "Unit": "A", "use": True},
    "Max_Strom_L1_demand": {
        "port": 264, "digits": 2, "Unit": "A", "use": True},
    "Max_Strom_L2_demand": {
        "port": 266, "digits": 2, "Unit": "A", "use": True},
    "Max_Strom_L3_demand": {
        "port": 268, "digits": 2, "Unit": "A", "use": True},
    "THD_Spannung_L1_L2": {
        "port": 334, "digits": 2, "Unit": "%", "use": True},
    "THD_Spannung_L2_L3": {
        "port": 336, "digits": 2, "Unit": "%", "use": True},
    "THD_Spannung_L3_L1": {
        "port": 338, "digits": 2, "Unit": "%", "use": True},
    "THD_Durchschnittliche_Spannung_zu_L_L": {
        "port": 340, "digits": 2, "Unit": "%", "use": True},
    "Total_kwh": {
        "port": 342, "digits": 2, "Unit": "kwh", "use": True},
    "Total_kvarh": {
        "port": 344, "digits": 2, "Unit": "kvarh", "use": True},
    "Import_L1_kwh": {
        "port": 346, "digits": 2, "Unit": "kwh", "use": True},
    "Import_L2_kwh": {
        "port": 348, "digits": 2, "Unit": "kwh", "use": True},
    "Import_L3_kwh": {
        "port": 350, "digits": 2, "Unit": "kwh", "use": True},
    "Export_L1_kwh": {
        "port": 352, "digits": 2, "Unit": "kwh", "use": True},
    "Export_L2_kwh": {
        "port": 354, "digits": 2, "Unit": "kwh", "use": True},
    "Export_L3_kwh": {
        "port": 356, "digits": 2, "Unit": "kwh", "use": True},
    "Gesamtstrom_L1_kwh": {
        "port": 358, "digits": 2, "Unit": "kwh", "use": True},
    "Gesamtstrom_L2_kwh": {
        "port": 360, "digits": 2, "Unit": "kwh", "use": True},
    "Gesamtstrom_L3_kwh": {
        "port": 362, "digits": 2, "Unit": "kwh", "use": True},
    "Import_L1_kvarh": {
        "port": 364, "digits": 2, "Unit": "kvarh", "use": True},
    "Import_L2_kvarh": {
        "port": 366, "digits": 2, "Unit": "kvarh", "use": True},
    "Import_L3_kvarh": {
        "port": 368, "digits": 2, "Unit": "kvarh", "use": True},
    "Export_L1_kvarh": {
        "port": 370, "digits": 2, "Unit": "kvarh", "use": True},
    "Export_L2_kvarh": {
        "port": 372, "digits": 2, "Unit": "kvarh", "use": True},
    "Export_L3_kvarh": {
        "port": 374, "digits": 2, "Unit": "kvarh", "use": True},
    "Total_L1_kvarh": {
        "port": 376, "digits": 2, "Unit": "kvarh", "use": True},
    "Total_L2_kvarh": {
        "port": 378, "digits": 2, "Unit": "kvarh", "use": True},
    "Total_L3_kvarh": {
        "port": 380, "digits": 2, "Unit": "kvarh", "use": True},
}

for key in input_register:
	if input_register[key]["use"] == True:
		print(key + ": " + str(round(instrument.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"]), 2)) + input_register[key]["Unit"])

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

import minimalmodbus

instrument = minimalmodbus.Instrument('/dev/ttyUSB0', 1) # port name, slave address (in decimal)

input_register = {

"Spannung_L1": {

"port": 0, "digits": 2, "Unit": "V", "use": True},

"Spannung_L2": {

"port": 2, "digits": 2, "Unit": "V", "use": True},

"Spannung_L3": {

"port": 4, "digits": 2, "Unit": "V", "use": True},

"Strom_L1": {

"port": 6, "digits": 2, "Unit": "A", "use": True},

"Strom_L2": {

"port": 8, "digits": 2, "Unit": "A", "use": True},

"Strom_L3": {

"port": 10, "digits": 2, "Unit": "A", "use": True},

"Wirkleistung_L1": {

"port": 12, "digits": 2, "Unit": "W", "use": True},

"Wirkleistung_L2": {

"port": 14, "digits": 2, "Unit": "W", "use": True},

"Wirkleistung_L3": {

"port": 16, "digits": 2, "Unit": "W", "use": True},

"Scheinleistung_L1": {

"port": 18, "digits": 2, "Unit": "VA", "use": True},

"Scheinleistung_L2": {

"port": 20, "digits": 2, "Unit": "VA", "use": True},

"Scheinleistung_L3": {

"port": 22, "digits": 2, "Unit": "VA", "use": True},

"Blindleistung_L1": {

"port": 24, "digits": 2, "Unit": "VAr", "use": True},

"Blindleistung_L2": {

"port": 26, "digits": 2, "Unit": "VAr", "use": True},

"Blindleistung_L3": {

"port": 28, "digits": 2, "Unit": "VAr", "use": True},

"Leistungsfaktor_L1": {

"port": 30, "digits": 2, "Unit": "", "use": True},

"Leistungsfaktor_L2": {

"port": 32, "digits": 2, "Unit": "", "use": True},

"Leistungsfaktor_L3": {

"port": 34, "digits": 2, "Unit": "", "use": True},

"Phasenwinkel_L1": {

"port": 36, "digits": 2, "Unit": "Grad", "use": True},

"Phasenwinkel_L2": {

"port": 38, "digits": 2, "Unit": "Grad", "use": True},

"Phasenwinkel_L3": {

"port": 40, "digits": 2, "Unit": "Grad", "use": True},

"Durchschnittliche_Spannung_zu_N": {

"port": 42, "digits": 2, "Unit": "V", "use": True},

"Durchschnittlicher_Strom_zu_N": {

"port": 46, "digits": 2, "Unit": "A", "use": True},

"aktueller_Gesamtstrom": {

"port": 48, "digits": 2, "Unit": "A", "use": True},

"aktuelle_Gesamtwirkleistung": {

"port": 52, "digits": 2, "Unit": "W", "use": True},

"aktuelle_Gesamtscheinleistung": {

"port": 56, "digits": 2, "Unit": "VA", "use": True},

"aktuelle_Gesamtblindleistung": {

"port": 60, "digits": 2, "Unit": "VAr", "use": True},

"aktueller_Gesamtleistungsfaktor": {

"port": 62, "digits": 2, "Unit": "", "use": True},

"aktueller_Gesamtphasenwinkel": {

"port": 66, "digits": 2, "Unit": "A", "use": True},

"Frequenz": {

"port": 70, "digits": 2, "Unit": "Hz", "use": True},

"Import_Wh_seit_reset": {

"port": 72, "digits": 2, "Unit": "kWh", "use": True},

"Export_Wh_seit_reset": {

"port": 74, "digits": 2, "Unit": "kWH", "use": True},

"Import_VArh_seit_reset": {

"port": 76, "digits": 2, "Unit": "kVArh", "use": True},

"Export_VArh_seit_reset": {

"port": 78, "digits": 2, "Unit": "kVArh", "use": True},

"VAh_seit_reset": {

"port": 80, "digits": 2, "Unit": "kVAh", "use": True},

"Ah_seit_reset": {

"port": 82, "digits": 2, "Unit": "Ah", "use": True},

"Gesamtwirkleistung": {

"port": 84, "digits": 2, "Unit": "W", "use": True},

"Max_Gesamtwirkleistung": {

"port": 86, "digits": 2, "Unit": "W", "use": True},

"Gesamtscheinleistung": {

"port": 100, "digits": 2, "Unit": "VA", "use": True},

"Max_Gesamtscheinleistung": {

"port": 102, "digits": 2, "Unit": "VA", "use": True},

"Gesamtstrom_Neutralleiter": {

"port": 104, "digits": 2, "Unit": "A", "use": True},

"Max_Strom_Neutralleiter": {

"port": 106, "digits": 2, "Unit": "A", "use": True},

"Spannung_L1_L2": {

"port": 200, "digits": 2, "Unit": "V", "use": True},

"Spannung_L2_L3": {

"port": 202, "digits": 2, "Unit": "V", "use": True},

"Spannung_L3_L1": {

"port": 204, "digits": 2, "Unit": "V", "use": True},

"Durchschnittsspannung_L_L": {

"port": 206, "digits": 2, "Unit": "V", "use": True},

"Strom_Neutralleiter": {

"port": 224, "digits": 2, "Unit": "A", "use": True},

"THD_Spannung_L1": {

"port": 234, "digits": 2, "Unit": "%", "use": True},

"THD_Spannung_L2": {

"port": 236, "digits": 2, "Unit": "%", "use": True},

"THD_Spannung_L3": {

"port": 238, "digits": 2, "Unit": "%", "use": True},

"THD_Strom_L1": {

"port": 240, "digits": 2, "Unit": "%", "use": True},

"THD_Strom_L2": {

"port": 242, "digits": 2, "Unit": "%", "use": True},

"THD_Strom_L3": {

"port": 244, "digits": 2, "Unit": "%", "use": True},

"THD_Durchschnittliche_Spannung_zu_N": {

"port": 248, "digits": 2, "Unit": "%", "use": True},

"THD_Durchschnittlicher_Strom_zu_N": {

"port": 250, "digits": 2, "Unit": "%", "use": True},

"Strom_L1_demand": {

"port": 258, "digits": 2, "Unit": "A", "use": True},

"Strom_L2_demand": {

"port": 260, "digits": 2, "Unit": "A", "use": True},

"Strom_L3_demand": {

"port": 262, "digits": 2, "Unit": "A", "use": True},

"Max_Strom_L1_demand": {

"port": 264, "digits": 2, "Unit": "A", "use": True},

"Max_Strom_L2_demand": {

"port": 266, "digits": 2, "Unit": "A", "use": True},

"Max_Strom_L3_demand": {

"port": 268, "digits": 2, "Unit": "A", "use": True},

"THD_Spannung_L1_L2": {

"port": 334, "digits": 2, "Unit": "%", "use": True},

"THD_Spannung_L2_L3": {

"port": 336, "digits": 2, "Unit": "%", "use": True},

"THD_Spannung_L3_L1": {

"port": 338, "digits": 2, "Unit": "%", "use": True},

"THD_Durchschnittliche_Spannung_zu_L_L": {

"port": 340, "digits": 2, "Unit": "%", "use": True},

"Total_kwh": {

"port": 342, "digits": 2, "Unit": "kwh", "use": True},

"Total_kvarh": {

"port": 344, "digits": 2, "Unit": "kvarh", "use": True},

"Import_L1_kwh": {

"port": 346, "digits": 2, "Unit": "kwh", "use": True},

"Import_L2_kwh": {

"port": 348, "digits": 2, "Unit": "kwh", "use": True},

"Import_L3_kwh": {

"port": 350, "digits": 2, "Unit": "kwh", "use": True},

"Export_L1_kwh": {

"port": 352, "digits": 2, "Unit": "kwh", "use": True},

"Export_L2_kwh": {

"port": 354, "digits": 2, "Unit": "kwh", "use": True},

"Export_L3_kwh": {

"port": 356, "digits": 2, "Unit": "kwh", "use": True},

"Gesamtstrom_L1_kwh": {

"port": 358, "digits": 2, "Unit": "kwh", "use": True},

"Gesamtstrom_L2_kwh": {

"port": 360, "digits": 2, "Unit": "kwh", "use": True},

"Gesamtstrom_L3_kwh": {

"port": 362, "digits": 2, "Unit": "kwh", "use": True},

"Import_L1_kvarh": {

"port": 364, "digits": 2, "Unit": "kvarh", "use": True},

"Import_L2_kvarh": {

"port": 366, "digits": 2, "Unit": "kvarh", "use": True},

"Import_L3_kvarh": {

"port": 368, "digits": 2, "Unit": "kvarh", "use": True},

"Export_L1_kvarh": {

"port": 370, "digits": 2, "Unit": "kvarh", "use": True},

"Export_L2_kvarh": {

"port": 372, "digits": 2, "Unit": "kvarh", "use": True},

"Export_L3_kvarh": {

"port": 374, "digits": 2, "Unit": "kvarh", "use": True},

"Total_L1_kvarh": {

"port": 376, "digits": 2, "Unit": "kvarh", "use": True},

"Total_L2_kvarh": {

"port": 378, "digits": 2, "Unit": "kvarh", "use": True},

"Total_L3_kvarh": {

"port": 380, "digits": 2, "Unit": "kvarh", "use": True},

}

for key in input_register:

if input_register[key]["use"] == True:

print(key + ": " + str(round(instrument.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"]), 2)) + input_register[key]["Unit"])

In Zeile 1 wird das Modbus Modul von Python importiert. Dieses musst du vielleicht noch installieren:

$ pip3 install minimalmodbus

1	$ pip3 install minimalmodbus

In der nächsten Zeile wird das Gerät initialisiert. Hier musst du evtl. noch den USB Port und die Modbus Adresse ändern. Danach gibt es einen sehr langen Part, durch den das Skript später weiß, welcher Wert welche Nummer und welche Einheit hat. Durch das „use“ kann festgelegt werden, ob der Wert verwendet werden soll oder nicht. Dazu einfach den Wert auf True bzw. False setzen. In Zeile 177 befindet sich eine for Schleife, die einmal für jeden Wert ausgeführt wird. Zeile 178 prüft, ob der Wert verwendet werden soll. Alles danach (Einrückungen nicht vergessen) kannst du jetzt frei programmieren. In meinem Beispiel werden alles Daten einfach nur per print ausgegeben. Die Zeile

instrument.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"])

1	instrument.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"])

gibt den Wert zurück (der, bei der die for Schleife gerade ist). Mit

input_register[key]["Unit"]

1	input_register[key]["Unit"]

bekommst du die Einheit.

Dieses Codebeispiel schreib zum Beispiel die Daten in eine Influx Datenbank.

Und jetzt viel Spaß beim Programmieren!

Mit Webmin den Server überwachen und steuern

18. Februar 2021 / jjk1 / Keine Kommentare

Webmin ist ein Tool, mit dem man einen Linux Server überwachen (CPU Last, RAM Nutzung, etc.) und auch einige Dinge grafisch einstellen (Updates, cronjobs, apache2, mysql, etc.) kann. Weil mit dieser Software sehr viel grafisch geht, ist das Tool gerade für Anfänger in der Linuxserverwelt interessant, die noch nicht mit dem Terminal vertraut sind. In diesem Tutorial möchte ich dir Webmin vorstellen und zeigen, wie du es installieren kannst. Die Grundlage für dieses Tutorial ist ein auf debian basierender Linuxserver wie zum Beispiel ein RaspberryPi.

Achtung: Webmin kann auch einiges an Leistung verbrauchen. Wenn man Leistungsprobleme hat und deshalb das Gerät überwachen will, ist Webmin nicht die richtige Wahl. Dazu würde ich eine Überwachung über telegraf, influxdb und grafana oder einfach im Terminal mit „top“ empfehlen.

Die Installation

Theoretisch könnte man sich auf der Webseite von Webmin eine aktuelle deb Datei herunterladen und diese installieren. Um Webmin einfach aktualisieren zu können (mit sudo apt-get upgrade) verwende ich hier einen anderen Weg:

Als erstes wird in der Datei sudo nano /etc/apt/sources.list folgende Zeile eingetragen:

deb http://download.webmin.com/download/repository sarge contrib

1	deb http://download.webmin.com/download/repository sarge contrib

und der PGP Schlüssel heruntergeladen

wget http://www.webmin.com/jcameron-key.asc

1	wget http://www.webmin.com/jcameron-key.asc

und installiert:

sudo apt-key add jcameron-key.asc

1	sudo apt-key add jcameron-key.asc

Nach einem

sudo apt-get update

1	sudo apt-get update

Kann jetzt Webmin mit

sudo apt-get install webmin

1	sudo apt-get install webmin

installiert werden

Verwendung

Ab jetzt ist Webmin unter https://IP_DES_RPI:10000 erreichbar.

Eine Sicherheitswarnung, dass die Webseite nicht sicher wäre kann man wegklicken. Webmin benutzt ein selbst signiertes SSL Zertifikat, welches von den meisten Browsern als unsicher erkannt wird.

Man kann sich jetzt mit einem Benutzer und Passwort anmelden, dass auch auf dem Server existiert und root oder sudo Rechte hat, zum Beispiel als „root“ oder „pi“. Mir persönlich gefällt der „dark mode“ besser, den man über das Mond-Symbol unten Links aktivieren kann.

Hier sieht man jetzt einige Informationen über den Server wie zum Beispiel CPU Auslastung, RAM Auslastung oder den belegten Speicherplatz. Außerdem erhält man vielleicht eine Meldung, dass Update verfügbar sind. Diese kann man direkt über das Webinterface installieren. Links unter „System“ kann man zum Beispiel cronjobs verwalten, Updates machen oder Benutzer und Gruppe verwalten. Unter „Servers“ kann je nach dem, welche Server (Webserver…) installiert sind, diese Konfiguriert werden. In meinem Fall sind das zum Beispiel Apache, MySQL (was eine alternative zu phpmyadmin wäre), Samba und SSH Server. Unter „Tools“ kann man zum sich u.A. ein Terminal anzeigen lassen. Mit Webmin kann man natürlich auch noch deutlich mehr machen, als ich hier aufgelistet habe. Einfach mal im Webinterface stöbern 🙂

7″ RaspberryPi Touchscreen Wandeinbau

14. Februar 2021 / jjk1 / 2 Kommentare

Dieser Blogeintrag hat mich dazu gebracht, auch so einen Touchscreen in die Wand einzubauen. Hier zeige ich dir, wie ich das Hardware- und Softwaretechnisch gelöst habe.

(Kleiner Tipp am Rande: Ich habe auch schon ein 13″ Display eingebaut: https://jojokorpi.ddns.net/wordpress/index.php/2021/08/17/13-touchscreen-wandeinbau/)

Mit dem Display kann ich das Bild der Überwachungskamera ansehen, die Lüftungsanlage steuern, die Produktion der Solaranlage überwachen, Meine Mobile Alerts Sensoren auslesen und den Wetterbericht lesen.

Hardware

Einkaufsliste:

Ein Netzteil, ich verwende dieses hier
Ein Gehäuse
Neodym Magnete
Ein RaspberryPi (Da das Projekt schon etwas älter ist, habe ich einen RaspberryPi 3 benutzt, aber ein RaspberryPi 4 wäre besser.)
Eine SD Karte
Der Touchscreen
Wenn der Touchscreen bei Bewegung an gehen soll, ein Bewegungsmelder
Ein paar Kabel

Einbau

Zum Einbau des Gehäuses gibt es nicht viel spannendes zu sagen. Ein Loch in die Wand machen, Gehäuse rein schieben und fixieren. Im Gehäuse habe ich dann noch Schrauben eingebaut, die später zur Befestigung mit den Magneten wichtig sind.

Im Keller direkt unter dem Display ist das Netzteil und eine LAN Buchse untergebracht. Von dem geht ein Kabel zu Stromversorgung und ein LAN Kabel nach oben. Zur Verkabelung habe ich im Gehäuse noch eine Lüsterklemme befestigt, um die Kabel, welche vom Bewegungsmelder und dem Netzteil kommen mit Jumperkabeln zu verbinden, die dann später auf die GPIO des Raspberry gesteckt werden können.

Um das Display mit Raspberry im Gehäuse zu befestigen, kann man dann einfach 4 Magnete auf den Schrauben platzieren, alle Kabel am Raspberry anstecken und das Display ins Gehäuse einsetzen. Es wird von den Magneten so fest gehalten, dass es nicht von selbst herausfällt, aber, dass man es mit etwas Kraft heraus holen kann.

Ich habe zusätzlich noch einen Bewegungsmelder eingebaut. Dieser ist in einer Blindabdeckung unter dem Display. Er ebenfalls mit einem Kabel mit dem Raspberry am Pin 10 angeschlossen.

Software

Skript für Bewegungsmelder

Folgendes Python Skript nutze ich, damit ich mit dem Bewegungsmelder das Display an- und ausschalten kann:

import sys
from RPi import GPIO
import os
from time import *
GPIO.setmode(GPIO.BOARD)
GPIO.setup(10, GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
print("Starte Bildschirm.py...")
def motion(pin):
	print(asctime(),)
	os.system('echo 0 &gt; /sys/class/backlight/rpi_backlight/bl_power')
	sleep(30)
	os.system('echo 1 &gt; /sys/class/backlight/rpi_backlight/bl_power')
	return


GPIO.add_event_detect(10, GPIO.RISING)
GPIO.add_event_callback(10, motion)
try:
	while True:
		sleep(0.5)
except KeyboardInterrupt:
	GPIO.cleanup()
	sys.exit()