Schlagwort: Software

Waveshare Modbus Relais in Homeassistant

17. Juni 2023 / jjk1 / Keine Kommentare

In diesem Beitrag möchte ich dir zeigen, wie ich ein 8-fach Modbus Relais von Waveshare in Homeassistant eingebunden habe.

Material

Aufbau

Der Aufbau ist nicht kompliziert. Die Anschlüsse A+, B- und GND müssen mit den entsprechend gleichnamigen Anschlüssen am Relais verbunden werden. Dann ist nur noch eine Spannungsversorgung für das Relais notwendig und man kann loslegen.

Mitgelieferte Software

Im Waveshare Wiki findet man neben zahlreichen Beispielen auch einen Beispielcode in Python. Dieser sendet die Daten direkt über „serial“ an das Modbus Relais und zur Berechnung der Paritätsbytes wird ebenfalls ein eigenes Pythonmodul mitgeliefert. Das ist etwas umständlich, da es für Modbus bereits fertige Pythonmodule wie minimalmodbus gibt.

Steuerung mit Minimalmodbus

Nach der Installation mit

pip3 install minimalmodbus

1	pip3 install minimalmodbus

kann das Modul verwendet werden. Folgendes wäre ein Beispielcode:

import minimalmodbus

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)
modbusrelay_heizung.serial.timeout  = 0.1

def set_relais(relay, state):
    if state == "on":
        modbusrelay_heizung.write_bit(int(relay)-1, 1)
    if state == "off":
        modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():
    binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)
    print("Relais:" + str(binary_relais))

import minimalmodbus

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)

modbusrelay_heizung.serial.timeout = 0.1

def set_relais(relay, state):

if state == "on":

modbusrelay_heizung.write_bit(int(relay)-1, 1)

if state == "off":

modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():

binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)

print("Relais:" + str(binary_relais))

In Zeile 3 wird der Pfad zum USB -> Modbus Konverter und die ID des Relais angegeben. Die ID wird in den meisten Fällen 1 sein. Bei mir habe ich sie aber geändert, da am selben Modbus auch ein Stromzähler hängt, der die ID 1 bekommen hat. Mit den Funktionen get_relais() und set_relais(relais, on/off) kann man jetzt die Relais schalten und deren Status abfragen.

Einbindung in Homeassistant

Um das Modbus Relais in Homeassistant einzubinden, verwende ich MQTT. Dieses sollte bereits installiert und eingebunden sein. Mein Code sieht dann folgendermaßen aus:

#!/usr/bin/env python3

import paho.mqtt.client as mqtt
import requests
import time
import minimalmodbus

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)
modbusrelay_heizung.serial.timeout  = 0.1
print(modbusrelay_heizung)

def set_relais(relay, state):
    if state == "on":
        modbusrelay_heizung.write_bit(int(relay)-1, 1)
    if state == "off":
        modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():
    binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)
    print("Relais:" + str(binary_relais))
    for i in range(8):
        if binary_relais[i] == 1:
            client.publish("modbus/relais_heizung/get/" + str(i+1), "on")
        else:
            client.publish("modbus/relais_heizung/get/" + str(i+1), "off")

def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))
    client.subscribe("modbus/relais_heizung/set/#")

def on_message(client, userdata, msg):
    splitted_topic = msg.topic.split("/")
    relay = splitted_topic[3]
    print("Relay " + relay + " " + msg.payload.decode())
    ready = False
    while not(ready):
        set_relais(relay, msg.payload.decode())
        time.sleep(0.1)
        get_relais()
        ready = True
  
client = mqtt.Client()
client.connect("localhost",1883,60)
client.on_connect = on_connect
client.on_message = on_message
get_relais()
client.loop_forever()

#!/usr/bin/env python3

import paho.mqtt.client as mqtt

import requests

import time

import minimalmodbus

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)

modbusrelay_heizung.serial.timeout = 0.1

print(modbusrelay_heizung)

def set_relais(relay, state):

if state == "on":

modbusrelay_heizung.write_bit(int(relay)-1, 1)

if state == "off":

modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():

binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)

print("Relais:" + str(binary_relais))

for i in range(8):

if binary_relais[i] == 1:

client.publish("modbus/relais_heizung/get/" + str(i+1), "on")

else:

client.publish("modbus/relais_heizung/get/" + str(i+1), "off")

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

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

client.subscribe("modbus/relais_heizung/set/#")

def on_message(client, userdata, msg):

splitted_topic = msg.topic.split("/")

relay = splitted_topic[3]

print("Relay " + relay + " " + msg.payload.decode())

ready = False

while not(ready):

set_relais(relay, msg.payload.decode())

time.sleep(0.1)

get_relais()

ready = True

client = mqtt.Client()

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

client.on_connect = on_connect

client.on_message = on_message

get_relais()

client.loop_forever()

Hinzu kommt jetzt die Anbindung an MQTT. Wichtig ist dabei

Z. 8: Siehe oben
S. 23+25: Hier werden die Statuswerte der Relais an MQTT gesendet
Z. 29: Hier wird das MQTT Topic subscribed, an das nachher die Befehle zum setzen gesendet werden
Z. 43: Hier findet die Verbindung zum MQTT Broker statt

In Homeassistant verwende ich nun folgende Konfiguration:

switch:
  - unique_id: modbus_relais_heizung_1
    name: "Modbus Relais Heizung 1"
    state_topic: "modbus/relais_heizung/get/1"
    command_topic: "modbus/relais_heizung/set/1"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_2
    name: "Modbus Relais Heizung 2"
    state_topic: "modbus/relais_heizung/get/2"
    command_topic: "modbus/relais_heizung/set/2"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_3
    name: "Modbus Relais Heizung 3"
    state_topic: "modbus/relais_heizung/get/3"
    command_topic: "modbus/relais_heizung/set/3"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_4
    name: "Modbus Relais Heizung 4"
    state_topic: "modbus/relais_heizung/get/4"
    command_topic: "modbus/relais_heizung/set/4"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_5
    name: "Modbus Relais Heizung 5"
    state_topic: "modbus/relais_heizung/get/5"
    command_topic: "modbus/relais_heizung/set/5"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_6
    name: "Modbus Relais Heizung 6"
    state_topic: "modbus/relais_heizung/get/6"
    command_topic: "modbus/relais_heizung/set/6"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_7
    name: "Modbus Relais Heizung 7"
    state_topic: "modbus/relais_heizung/get/7"
    command_topic: "modbus/relais_heizung/set/7"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0
  - unique_id: modbus_relais_heizung_8
    name: "Modbus Relais Heizung 8"
    state_topic: "modbus/relais_heizung/get/8"
    command_topic: "modbus/relais_heizung/set/8"
    payload_on: "on"
    payload_off: "off"
    state_on: "on"
    state_off: "off"
    qos: 0

switch:

- unique_id: modbus_relais_heizung_1

state_topic: "modbus/relais_heizung/get/1"

command_topic: "modbus/relais_heizung/set/1"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_2

state_topic: "modbus/relais_heizung/get/2"

command_topic: "modbus/relais_heizung/set/2"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_3

state_topic: "modbus/relais_heizung/get/3"

command_topic: "modbus/relais_heizung/set/3"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_4

state_topic: "modbus/relais_heizung/get/4"

command_topic: "modbus/relais_heizung/set/4"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_5

state_topic: "modbus/relais_heizung/get/5"

command_topic: "modbus/relais_heizung/set/5"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_6

state_topic: "modbus/relais_heizung/get/6"

command_topic: "modbus/relais_heizung/set/6"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_7

state_topic: "modbus/relais_heizung/get/7"

command_topic: "modbus/relais_heizung/set/7"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

- unique_id: modbus_relais_heizung_8

state_topic: "modbus/relais_heizung/get/8"

command_topic: "modbus/relais_heizung/set/8"

payload_on: "on"

payload_off: "off"

state_on: "on"

state_off: "off"

qos: 0

Jetzt kann ich die Relais auch in Homeassistant schalten. Dabei muss das Pythonskript dauerhaft laufen, was man bspw. mit einer systemd Service Unit erreicht.

Gleichzeitig Modbus Relais und Stromzähler auslesen

Da ich, wie bereits erwähnt, einen Stromzähler und Relais an einem Modbus hängen habe und immer nur ein Programm auf den Modbus zugreifen kann, muss ich im selben Skript auch den Stromzähler auslesen. Das Skript dazu sieht so aus:

#!/usr/bin/env python3

import paho.mqtt.client as mqtt
import requests
import time
import minimalmodbus
import influxdb

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)
modbusrelay_heizung.serial.timeout  = 0.1
print(modbusrelay_heizung)
influxclient = influxdb.InfluxDBClient(host="serverpi", port=8086, database="energy")

relais_freigabe = True

def set_relais(relay, state):
    if state == "on":
        modbusrelay_heizung.write_bit(int(relay)-1, 1)
    if state == "off":
        modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():
    binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)
    print("Relais:" + str(binary_relais))
    for i in range(8):
        if binary_relais[i] == 1:
            client.publish("modbus/relais_heizung/get/" + str(i+1), "on")
        else:
            client.publish("modbus/relais_heizung/get/" + str(i+1), "off")

def on_connect(client, userdata, flags, rc):
    print("Connected with result code "+str(rc))
    client.subscribe("modbus/relais_heizung/set/#")

def on_message(client, userdata, msg):
    splitted_topic = msg.topic.split("/")
    relay = splitted_topic[3]
    print("Relay " + relay + " " + msg.payload.decode())
    ready = False
    while not(ready):
        if relais_freigabe:
            set_relais(relay, msg.payload.decode())
            time.sleep(0.1)
            get_relais()
            ready = True
        else:
            print("Warte 1 sek")
            time.sleep(1)
    

client = mqtt.Client()
client.connect("localhost",1883,60)
client.on_connect = on_connect
client.on_message = on_message
get_relais()
client.loop_start()
while True:
    try:
        time.sleep(0.1)
        time1 = time.perf_counter()
        # ------------------ Modbus Heizung ------------------
        modbus_instrument = "/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0"
        name = "heizung"
        # ------------------
        # try:
        modbuszaehler = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 1, debug = True)
        modbuszaehler.serial.timeout = 1.0
        print(modbuszaehler)
        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},
        }
        heizung_json_body = [
            {
                "measurement": name,
                "fields": {}
            },
        ]
        relais_freigabe = False
        for key in input_register:
            if input_register[key]["use"] == True:
                heizung_json_body[0]["fields"][key] = round(modbuszaehler.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"]), 2)
        relais_freigabe = True
        # ------------------ Tasmota Haus ------------------
        tasmota_url = "http://tasmota-1ae72e-1838.fritz.box"
        name = "tasmota_haus"
        # ------------------
        try:
            r = requests.get(tasmota_url + "/cm?cmnd=status%2010")
            json = r.json()
            tasmota_values = {}
            tasmota_haus_json_body = [
                {
                    "measurement": name,
                    "fields": {}
                },
            ]

            for key in json["StatusSNS"]["MT175"]:
                try:
                    tasmota_values[key] = float(json["StatusSNS"]["MT175"][key])
                except:
                    tasmota_values[key] = str(json["StatusSNS"]["MT175"][key])
                    
            tasmota_haus_json_body[0]['fields']['Leistung'] = tasmota_values['Power_curr']
            tasmota_haus_json_body[0]['fields']['Import_kWh'] = tasmota_values['Total']
            tasmota_haus_json_body[0]['fields']['Export_kWh'] = tasmota_values['Total_out']
            #print(tasmota_haus_json_body)
        except:
            print("Fehler beim Lesen von Tasmota Haus")

        # ------------------ Tasmota Heizung ------------------
        tasmota_url = "http://tasmota-1ae72e-1838.fritz.box"
        name = "tasmota_heizung"
        # ------------------
        try:
            r = requests.get(tasmota_url + "/cm?cmnd=status%2010")
            json = r.json()
            tasmota_values = {}
            tasmota_heizung_json_body = [
                {
                    "measurement": name,
                    "fields": {}
                },
            ]

            for key in json["StatusSNS"]["METER1"]:
                try:
                    tasmota_values[key] = float(json["StatusSNS"]["METER1"][key])
                except:
                    tasmota_values[key] = str(json["StatusSNS"]["METER1"][key])
            
            tasmota_heizung_json_body[0]['fields']['Leistung'] = tasmota_values['Power_curr']
            tasmota_heizung_json_body[0]['fields']['Import_kWh'] = tasmota_values['Total']
            tasmota_heizung_json_body[0]['fields']['Export_kWh'] = tasmota_values['Total_out']
            #print(tasmota_heizung_json_body)
        except:
            print("Fehler beim Lesen von Tasmota Haus")
        # ------------------ Heizungsleistung berechnen ------------------
        try:
            heizung_json_body[0]['fields']['Leistung'] = tasmota_heizung_json_body[0]['fields']['Leistung']-tasmota_haus_json_body[0]['fields']['Leistung'] + heizung_json_body[0]['fields']['aktuelle_Gesamtwirkleistung']
            if(tasmota_heizung_json_body[0]['fields']['Leistung']>=0 and tasmota_haus_json_body[0]['fields']['Leistung']>=0): # Voll Netzbetrieb
                heizung_json_body[0]['fields']['Leistung_Netz'] = heizung_json_body[0]['fields']['Leistung']
                heizung_json_body[0]['fields']['Leistung_PV'] = 0.0
                
            elif(tasmota_heizung_json_body[0]['fields']['Leistung']<=0 and tasmota_haus_json_body[0]['fields']['Leistung']<=0): # PV Betrieb
                heizung_json_body[0]['fields']['Leistung_Netz'] = 0.0
                heizung_json_body[0]['fields']['Leistung_PV'] = heizung_json_body[0]['fields']['Leistung']

            else: #Mischung
                heizung_json_body[0]['fields']['Leistung_Netz'] = tasmota_heizung_json_body[0]['fields']['Leistung']
                heizung_json_body[0]['fields']['Leistung_PV'] = tasmota_haus_json_body[0]['fields']['Leistung']*-1
                # Modbus Leistung dazurechnen
            heizung_json_body[0]['fields']['Leistung_Modbus'] = heizung_json_body[0]['fields']['aktuelle_Gesamtwirkleistung']
        except:
            print("Fehler beim Berechnen von Heizungsleistung")

        # ------------------ Zählerstand Heizung berechnen ------------------
        heizung_json_body[0]['fields']['Zaehlerstand_Einspeisung'] = tasmota_haus_json_body[0]['fields']['Export_kWh'] - tasmota_heizung_json_body[0]['fields']['Export_kWh']
        heizung_json_body[0]['fields']['Zaehlerstand_Bezug'] = tasmota_heizung_json_body[0]['fields']['Import_kWh'] - tasmota_haus_json_body[0]['fields']['Import_kWh']
        heizung_json_body[0]['fields']['Zaehlerstand_PV'] = heizung_json_body[0]["fields"]['Total_kwh']
        print(heizung_json_body)
        influxclient.write_points(heizung_json_body)
        # except:
        #     print("Fehler beim Lesen von Modbuszähler Heizung")
        time2 = time.perf_counter()
        timedifference = time2-time1
        if timedifference < 60:
            time.sleep(60-timedifference)
    except:
        print("Fehler beim Auslesen vom Modbuszähler")
        time.sleep(60)

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

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

#!/usr/bin/env python3

import paho.mqtt.client as mqtt

import requests

import time

import minimalmodbus

import influxdb

modbusrelay_heizung = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 2, debug = True)

modbusrelay_heizung.serial.timeout = 0.1

print(modbusrelay_heizung)

influxclient = influxdb.InfluxDBClient(host="serverpi", port=8086, database="energy")

relais_freigabe = True

def set_relais(relay, state):

if state == "on":

modbusrelay_heizung.write_bit(int(relay)-1, 1)

if state == "off":

modbusrelay_heizung.write_bit(int(relay)-1, 0)

def get_relais():

binary_relais = modbusrelay_heizung.read_bits(0, 8, 1)

print("Relais:" + str(binary_relais))

for i in range(8):

if binary_relais[i] == 1:

client.publish("modbus/relais_heizung/get/" + str(i+1), "on")

else:

client.publish("modbus/relais_heizung/get/" + str(i+1), "off")

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

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

client.subscribe("modbus/relais_heizung/set/#")

def on_message(client, userdata, msg):

splitted_topic = msg.topic.split("/")

relay = splitted_topic[3]

print("Relay " + relay + " " + msg.payload.decode())

ready = False

while not(ready):

if relais_freigabe:

set_relais(relay, msg.payload.decode())

time.sleep(0.1)

get_relais()

ready = True

else:

print("Warte 1 sek")

time.sleep(1)

client = mqtt.Client()

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

client.on_connect = on_connect

client.on_message = on_message

get_relais()

client.loop_start()

while True:

try:

time.sleep(0.1)

time1 = time.perf_counter()

# ------------------ Modbus Heizung ------------------

modbus_instrument = "/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0"

name = "heizung"

# ------------------

# try:

modbuszaehler = minimalmodbus.Instrument('/dev/serial/by-id/usb-1a86_USB_Serial-if00-port0', 1, debug = True)

modbuszaehler.serial.timeout = 1.0

print(modbuszaehler)

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},

}

heizung_json_body = [

{

"measurement": name,

"fields": {}

]

relais_freigabe = False

for key in input_register:

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

heizung_json_body[0]["fields"][key] = round(modbuszaehler.read_float(functioncode=4, registeraddress=input_register[key]["port"], number_of_registers=input_register[key]["digits"]), 2)

relais_freigabe = True

# ------------------ Tasmota Haus ------------------

tasmota_url = "http://tasmota-1ae72e-1838.fritz.box"

name = "tasmota_haus"

# ------------------

try:

r = requests.get(tasmota_url + "/cm?cmnd=status%2010")

json = r.json()

tasmota_values = {}

tasmota_haus_json_body = [

{

"measurement": name,

"fields": {}

]

for key in json["StatusSNS"]["MT175"]:

try:

tasmota_values[key] = float(json["StatusSNS"]["MT175"][key])

except:

tasmota_values[key] = str(json["StatusSNS"]["MT175"][key])

tasmota_haus_json_body[0]['fields']['Leistung'] = tasmota_values['Power_curr']

tasmota_haus_json_body[0]['fields']['Import_kWh'] = tasmota_values['Total']

tasmota_haus_json_body[0]['fields']['Export_kWh'] = tasmota_values['Total_out']

#print(tasmota_haus_json_body)

except:

print("Fehler beim Lesen von Tasmota Haus")

# ------------------ Tasmota Heizung ------------------

tasmota_url = "http://tasmota-1ae72e-1838.fritz.box"

name = "tasmota_heizung"

# ------------------

try:

r = requests.get(tasmota_url + "/cm?cmnd=status%2010")

json = r.json()

tasmota_values = {}

tasmota_heizung_json_body = [

{

"measurement": name,

"fields": {}

]

for key in json["StatusSNS"]["METER1"]:

try:

tasmota_values[key] = float(json["StatusSNS"]["METER1"][key])

except:

tasmota_values[key] = str(json["StatusSNS"]["METER1"][key])

tasmota_heizung_json_body[0]['fields']['Leistung'] = tasmota_values['Power_curr']

tasmota_heizung_json_body[0]['fields']['Import_kWh'] = tasmota_values['Total']

tasmota_heizung_json_body[0]['fields']['Export_kWh'] = tasmota_values['Total_out']

#print(tasmota_heizung_json_body)

except:

print("Fehler beim Lesen von Tasmota Haus")

# ------------------ Heizungsleistung berechnen ------------------

try:

heizung_json_body[0]['fields']['Leistung'] = tasmota_heizung_json_body[0]['fields']['Leistung']-tasmota_haus_json_body[0]['fields']['Leistung'] + heizung_json_body[0]['fields']['aktuelle_Gesamtwirkleistung']

if(tasmota_heizung_json_body[0]['fields']['Leistung']>=0 and tasmota_haus_json_body[0]['fields']['Leistung']>=0): # Voll Netzbetrieb

heizung_json_body[0]['fields']['Leistung_Netz'] = heizung_json_body[0]['fields']['Leistung']

heizung_json_body[0]['fields']['Leistung_PV'] = 0.0

elif(tasmota_heizung_json_body[0]['fields']['Leistung']<=0 and tasmota_haus_json_body[0]['fields']['Leistung']<=0): # PV Betrieb

heizung_json_body[0]['fields']['Leistung_Netz'] = 0.0

heizung_json_body[0]['fields']['Leistung_PV'] = heizung_json_body[0]['fields']['Leistung']

else: #Mischung

heizung_json_body[0]['fields']['Leistung_Netz'] = tasmota_heizung_json_body[0]['fields']['Leistung']

heizung_json_body[0]['fields']['Leistung_PV'] = tasmota_haus_json_body[0]['fields']['Leistung']*-1

# Modbus Leistung dazurechnen

heizung_json_body[0]['fields']['Leistung_Modbus'] = heizung_json_body[0]['fields']['aktuelle_Gesamtwirkleistung']

except:

print("Fehler beim Berechnen von Heizungsleistung")

# ------------------ Zählerstand Heizung berechnen ------------------

heizung_json_body[0]['fields']['Zaehlerstand_Einspeisung'] = tasmota_haus_json_body[0]['fields']['Export_kWh'] - tasmota_heizung_json_body[0]['fields']['Export_kWh']

heizung_json_body[0]['fields']['Zaehlerstand_Bezug'] = tasmota_heizung_json_body[0]['fields']['Import_kWh'] - tasmota_haus_json_body[0]['fields']['Import_kWh']

heizung_json_body[0]['fields']['Zaehlerstand_PV'] = heizung_json_body[0]["fields"]['Total_kwh']

print(heizung_json_body)

influxclient.write_points(heizung_json_body)

# except:

# print("Fehler beim Lesen von Modbuszähler Heizung")

time2 = time.perf_counter()

timedifference = time2-time1

if timedifference < 60:

time.sleep(60-timedifference)

except:

print("Fehler beim Auslesen vom Modbuszähler")

time.sleep(60)

Hinzu kommt hier die Verbindung zur Influx Datenbank (Z. 12) und das eigentliche Auslesen des Stromzählers ab Z. 57. Es werden auch noch andere Stromzähler, die über Tasmota angebunden sind, ausgelesen, um einige Werte zu berechnen. Wichtig hier ist auch die Variable relais_freigabe, die dafür sorgt, dass wenn gerade der Stromzähler ausgelesen wird, mit dem Setzen des Relais noch kurz gewartet wird, da dies nicht gleichzeitig passieren kann.

Bildquelle: waveshare.com, wikipedia.org

Spicetify – Addons für Spotify

31. Mai 2023 / jjk1 / Keine Kommentare

Spicetify bietet sowohl optische als auch funktionale Verbesserungen am Spotify Client für den PC. Dafür ist im Gegensatz zu vielen anderen Spotify Erweiterungen kein Spotify Premium erforderlich.

Installation

Nach der offiziellen Anleitung von Spicetify, installiert man das Programm mit folgendem Befehl:

curl -fsSL https://raw.githubusercontent.com/spicetify/spicetify-cli/master/install.sh | sh

1	curl -fsSL https://raw.githubusercontent.com/spicetify/spicetify-cli/master/install.sh \| sh

Der nächste Befehl hat bei mir nicht funktioniert. Ich musste vorher noch folgendes ausführen:

spicetify backup apply

1	spicetify backup apply

Anschließend lässt sich auch der Spicetify Marketplace installieren:

curl -fsSL https://raw.githubusercontent.com/spicetify/spicetify-marketplace/main/resources/install.sh | sh

1	curl -fsSL https://raw.githubusercontent.com/spicetify/spicetify-marketplace/main/resources/install.sh \| sh

Wenn Spotify als DEB-Paket von der Spotify Webseite installiert wurde, dann ist die Installation hiermit abgeschlossen. Da ich bei mir Spotify aber als Flatpak installiert habe, musste ich ein paar Dinge ändern. In der Config-Datei musste ich die Einstellungen für spotify_path und prefs_path anpassen:

nano .config/spicetify/config-xpui.ini

1	nano .config/spicetify/config-xpui.ini

spotify_path            = /var/lib/flatpak/app/com.spotify.Client/x86_64/stable/active/files/extra/share/spotify/
prefs_path              = /home/johannes/.var/app/com.spotify.Client/config/spotify/prefs

1 2	spotify_path = /var/lib/flatpak/app/com.spotify.Client/x86_64/stable/active/files/extra/share/spotify/ prefs_path = /home/johannes/.var/app/com.spotify.Client/config/spotify/prefs

Und dann noch Berechtigungen anpassen. 777 ist hier bestimmt zu viel. Ich lasse das aber erstmal so.

sudo chmod 777 -R /var/lib/flatpak/app/com.spotify.Client/x86_64/stable/active/files/extra/share/spotify

1	sudo chmod 777 -R /var/lib/flatpak/app/com.spotify.Client/x86_64/stable/active/files/extra/share/spotify

Dann war auch bei mir der Marketplace in Spotify sichtbar.

(Hinweis: nach einem Updaten mussten bei mir die Befehle sudo chmod 777 -R /var/lib/flatpak/app/com.spotify.Client/x86_64/stable/active/files/extra/share/spotify und spicetify backup apply nochmal ausgeführt werden.

Einige Spicetify Erweiterungen, die ich verwende:

Der Spicetify Marketplace teilt sich auf in Extensions, Themes, Snippets und Apps. Themes benutze ich keines, da ich keines der dort angebotenen Themes optisch ansprechender fand als das Standard-Theme.

Extensions

songstats

Diese Erweiterung zeigt Eigenschaften eines Songs an. Das sieht dann zum Beispiel so aus:

playlistIntersection

Mit dieser Erweiterung lassen sich Lieder finden, die in zwei Playlisten sind (oder nur in einer der beiden)

Display Full Album date

Diese Erweiterung zeigt statt nur dem Erscheinungsjahr das ganze Erscheinungsdatum bei der Albenansicht an:

Spotify Genres

Diese Erweiterung zeigt das Genre von dem Lied, das gerade läuft:

Power bar

Mit dieser Erweiterung bekommt man eine Suchleiste, wenn man Strg+Leertaste drückt:

Spicetify DJ Info

Diese Erweiterung gibt Informationen über das aktuelle Lied, die für DJs nützlich sind. das sind:

Tonart im Camelot System
Tempo in BPM
Energie
Beliebtheit

Snippets

Hide Upgrade Button

Diese Erweiterung tut genau das, was sie verspricht – sie lässt den Upgrade Button oben rechts verschwinden

Modern Scrollbar

Diese Erweiterung ändert die eckige Scrollbar in eine abgerundete.

Zeitrafferaufnahme mit Handy machen

21. April 2023 / jjk1 / Keine Kommentare

Jetzt mal ganz ehrlich: Wie viele von euch haben in der Schublade noch ein altes Handy rumliegen? Oder vielleicht auch zwei? Oder drei? Dabei kann man sie doch noch für sinnvolle Dinge verwenden. Wie wäre es mit einer Zeitrafferaufnahme?

Die Hardware

Ein Stativ ist bei Zeitrafferaufnahmen auf jeden Fall sinnvoll. Wer keines hat, kann sich notfalls auch mit ein paar Büchern helfen oder wenn man einen 3D-Drucker hat, selbst eines ausdrucken.

Da Akkus von älteren Geräten nicht mehr so lange halten und die Kamera recht viel Strom braucht, ist es auch vorteilhaft eine Steckdose und ein Ladegerät zur Hand zu haben.

Die Software

Als Kameraapp verwende ich OpenCamera (Playstore, F-Droid). Dort gibt es die Einstellung, automatisch Bilder in bestimmten Intervallen zu machen. Dafür stellt man die Einstellung „Serienbild“ auf unbegrenzt und „Serienbild-Intervall“ auf die gewünschte Dauer.

Einstellungen in Opencamera für Serienbild

Um ein gleichmäßiges Bild zu bekommen, sollte man den Fokus, den Weißabgleich und die Belichtung sperren. Dazu aktiviert man die Icons unter Einstellungen -> Benutzeroberfläche und kann die anschließend in der Kameraansicht aktivieren:

Einstellung für gesperrten Weißabgleich und Belichtung in OpenCamera

Deaktivieren des Automatischen Weißabgleichs, Fokus und Belichtung

Akkustand von Bluetooth-Kopfhörer in Ubuntu anzeigen

12. März 2023 / jjk1 / Keine Kommentare

Der Akkustand meiner Bluetooth-Kopfhörer wurde bei mir standardmäßig nicht angezeigt. Um das zu korrigieren, reicht eine einfache Änderung:

Konfigurationsdatei anpassen

In der Datei /etc/bluetooth/main.conf muss im Abschnitt „[General]“ ein

Experimental=true

1	Experimental=true

Eingefügt werden. Anschließend kann man entweder den ganzen Rechner oder nur den Bluetooth Service mit

sudo systemctl restart bluetooth

1	sudo systemctl restart bluetooth

neustarten und der Akkustand wird zum Beispiel in den Einstellungen unter „Energie“ angezeigt:

Ubuntu zeigt in den Einstellungen Akkustand an

Akkustand in der Leiste anzeigen

Damit ich nicht den Umweg über die Einstellungen gehen muss, zeige ich mir den Akkustand der Kopfhörer direkt in der oberen Leiste neben der Uhrzeit an. Dafür verwende ich folgende Gnome Extension: https://extensions.gnome.org/extension/5615/battery-indicator-upower/

Akkustand von Bluetooth Kopfhörer in Ubuntu

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

Mobile Alerts Sensoren mit Proxy lokal auslesen und an Homeassistant senden

28. Dezember 2022 / jjk1 / Keine Kommentare

Vor knapp zwei Jahren habe ich einen Beitrag darüber veröffentlicht, wie ich meine Mobile Alerts Temperatursensoren per Weboberfläche mit einem Pythonskript auslese. Diese Variante funktionierte bei mir und funktioniert immer noch ohne Probleme. Letztens bin ich aber auf eine andere Möglichkeit gestoßen, die mir deutlich besser gefällt, da sie zuverlässiger und unabhängig von der Cloud ist. Mit einem Proxy, der zwischen den Gateway und das Internet geschalten wird, können die Daten abgefangen und weiter verarbeitet werden.
Hierfür gibt es das Programm „maserver„. Es nimmt auch direkt die Einstellungen am Gateway vor. Dieses sendet die Daten anschließend an einen MQTT Broker. Bei mir läuft es auf einem RaspberryPi mit Ubuntu Server 22.04.

Vorbereitungen

Auf dem Server müssen zunächst nodejs und npm installiert werden:

sudo apt install nodejs npm

1	sudo apt install nodejs npm

Danach kann man den maserver herunterladen:

git clone https://github.com/sarnau/MMMMobileAlerts.git

1	git clone https://github.com/sarnau/MMMMobileAlerts.git

Im Ordner „MMMMobilealerts“ befindet sich jetzt der maserver.

Konfiguration

Darin befindet sich die Datei „config-example.json“. Benenne diese in „config.json“ um. Folgende Konfigurationsmöglichkeiten gibt es:

localIPv4Address: Die IP-Adresse des Geräts, auf dem der Proxy läuft. Wird nur benötigt, wenn es mehrere IP-Adressen hat, z. B. wenn es über mehrere Netzwerkschnittstellen angebunden ist oder Docker oder ein VPN Server darauf läuft.
mqtt: Die Adresse zum MQTT Broker.
mqtt_home: Das Topic, in dem die Daten auf dem MQTT Broker gesendet werden sollen.
mqtt_username, mqtt_password, logfile: Selbsterklärend.
logGatewayInfo: Ob Infos über gefundene Gateways angezeigt werden sollen.
proxyServerPort: Der Port, auf dem der Proxyserver laufen soll.
mobileAlertsCloudForward: Ob die Daten an die Mobilealerts Cloud gesendet werden sollen.
serverPost: Die Daten können zusätzlich auch per POST versendet werden.
serverPostUser, serverPostPassword, locale: Selbsterklärend.

Meine Konfiguration sieht dann so aus:

{
  "localIPv4Address": "192.168.178.142",
  "mqtt": "mqtt://127.0.0.1",
  "mqtt_home": "MobileAlerts/",
  "mqtt_username": "",
  "mqtt_password": "",
  "publish_type": "default",
  "sonoffPublish_prefix": null,
  "logfile": "./MobileAlerts.log",
  "logGatewayInfo": true,
  "proxyServerPort": 8095,
  "mobileAlertsCloudForward": true,
  "serverPost": null,
  "serverPostUser": null,
  "serverPostPassword": null,
  "locale": "de-DE"
}

{

"localIPv4Address": "192.168.178.142",

"mqtt": "mqtt://127.0.0.1",

"mqtt_home": "MobileAlerts/",

"mqtt_username": "",

"mqtt_password": "",

"publish_type": "default",

"sonoffPublish_prefix": null,

"logfile": "./MobileAlerts.log",

"logGatewayInfo": true,

"proxyServerPort": 8095,

"mobileAlertsCloudForward": true,

"serverPost": null,

"serverPostUser": null,

"serverPostPassword": null,

"locale": "de-DE"

}

Installation

Der Proxy wird mit

npm install

1	npm install

installiert, während man sich im „maserver“ Verzeichnis befindet.

Start

Gestartet werden kann das Programm mit:

node mobilealerts.js

1	node mobilealerts.js

Es findet automatisch den Gateway im Netzwerk und konfiguriert sich selbst im Gateway als Proxy. Nach spätestens 15 Minuten sollten die ersten Daten zu sehen sein.

Daten an Homeassistant senden

Im Homeassistant fügen wir zuerst die MQTT Integration unter „Einstellungen“->“Geräte und Dienste“->“Integration Hinzufügen“ hinzu.

Die Konfiguration der einzelnen Sensoren erfolgt dann über die configuration.yaml Datei und sieht beispielsweise so aus:

mqtt:
  sensor: 
    - name: "Bad Temperatur"
      device_class: temperature
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      unit_of_measurement: "°C"
      value_template: "{{value_json.temperature&#91;0]}}"
    - name: "Bad Luftfeuchtigkeit"
      device_class: humidity
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      unit_of_measurement: "%"
      value_template: "{{value_json.humidity&#91;0]}}"
    - name: "Draußen Temperatur"
      device_class: temperature
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      unit_of_measurement: "°C"
      value_template: "{{value_json.temperature&#91;0]}}"
    - name: "Draußen Luftfeuchtigkeit"
      device_class: humidity
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      unit_of_measurement: "%"
      value_template: "{{value_json.humidity&#91;0]}}"
 
  # Batterien

  binary_sensor:
    - name: "MA Bad Batterie"
      device_class: battery
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      payload_on: "low"
      payload_off: "ok"
      value_template: "{{value_json.battery}}"
    - name: "MA Draußen Batterie"
      device_class: battery
      state_topic: "MobileAlerts/XXXXXXXXXXXX/json"
      payload_on: "low"
      payload_off: "ok"
      value_template: "{{value_json.battery}}"

mqtt:

sensor:

- name: "Bad Temperatur"

device_class: temperature

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

unit_of_measurement: "°C"

value_template: "{{value_json.temperature[0]}}"

- name: "Bad Luftfeuchtigkeit"

device_class: humidity

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

unit_of_measurement: "%"

value_template: "{{value_json.humidity[0]}}"

- name: "Draußen Temperatur"

device_class: temperature

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

unit_of_measurement: "°C"

value_template: "{{value_json.temperature[0]}}"

- name: "Draußen Luftfeuchtigkeit"

device_class: humidity

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

unit_of_measurement: "%"

value_template: "{{value_json.humidity[0]}}"

# Batterien

binary_sensor:

- name: "MA Bad Batterie"

device_class: battery

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

payload_on: "low"

payload_off: "ok"

value_template: "{{value_json.battery}}"

- name: "MA Draußen Batterie"

device_class: battery

state_topic: "MobileAlerts/XXXXXXXXXXXX/json"

payload_on: "low"

payload_off: "ok"

value_template: "{{value_json.battery}}"

Dabei ist XXXXXXXXXXXX die 12-stellige Geräte-ID, die man in der Mobile Alerts App oder direkt auf der Rückseite der Sensoren findet.

Nach einem Neustart sollten die Daten in Homeassistant erscheinen:

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

Pool-Temperatursensor mit dem ESP

1. November 2022 / jjk1 / Keine Kommentare

Ich weiß nicht, wie ich auf die Idee gekommen bin, die Temperatur im Pool zu messen. War dann aber doch ein interessantes Projekt.

Hardware

Batteriebetrieben sollte er sein, da Netzspannung im Pool … Ihr wisst, was ich meine. Also fiel ein Raspberry schon mal weg – der braucht zu viel Strom. Etwas Kleineres musste her, ein Microcontroller, ein ESP, genauer gesagt ein Wemos D1 mini. Dazu noch ein Akku und ein Board, um den Akku aufzuladen und den ESP mit Strom zu versorgen.

D1 Mini
Batterie Shield
Akku
Wasserdichter Temperatursensor
Wasserdichtes Gehäuse
4,7KOhm Widerstand

Die Verkabelung des Sensors ist relativ einfach – Plus (rot) auf 5V, GND (Schwarz) auf GND und den Daten-Pin (Gelb) auf D4. Zwischen D4 und 5V muss dann noch der 4,7kOhm Widerstand geschalten werden.

Damit später der deepSleep funktioniert, müssen wir D0 mit RsT verbinden. Da jedoch dann die Verbindung über USB nicht mehr funktioniert, ist es nicht besonders sinnvoll, diese direkt zusammen zu löten. Ich mache das mit 2 kurzen Kabeln und einer Klemme.

Im Gehäuse sieht das ganze bei mir dann so aus:

Software

Eines vorweg: Mein Programm ist nicht schön und es gibt bestimmt viele Wege, es besser zu machen, aber es funktioniert. Ich sende meine Werte direkt in die Influx Datenbank (wäre – besonders bei mehreren Sensoren – über MQTT wohl sinnvoller).

#include <OneWire.h>
#include <ESP8266WiFi.h>
#include <InfluxDb.h>

#define INFLUXDB_HOST ""   //Enter IP of device running Influx Database
#define WIFI_SSID ""            //Enter SSID of your WIFI Access Point
#define WIFI_PASS ""          //Enter Password of your WIFI Access Point

Influxdb influx(INFLUXDB_HOST);
WiFiClient espClient;

OneWire  ds(D4);  // on pin D4 (a 4.7K resistor is necessary)
 
void setup(void) 
{
  Serial.begin(115200);
  setup_wifi();
  influx.setDb("esp8266_test");
  while (WiFi.status() != WL_CONNECTED) {
    setup_wifi();
  }
  // Sensor auslesen-------------------------------
  Serial.println("Reading Sensor");
  byte i;
  byte present = 0;
  byte type_s;
  byte data[12];
  byte addr[8];
  float celsius, fahrenheit;
 
  if ( !ds.search(addr)) 
  {
    ds.reset_search();
    delay(250);
    return;
  }
 
 
  if (OneWire::crc8(addr, 7) != addr[7]) 
  {
      Serial.println("CRC is not valid!");
      return;
  }
 
  // the first ROM byte indicates which chip
  switch (addr[0]) 
  {
    case 0x10:
      type_s = 1;
      break;
    case 0x28:
      type_s = 0;
      break;
    case 0x22:
      type_s = 0;
      break;
    default:
      Serial.println("Device is not a DS18x20 family device.");
      return;
  } 
 
  ds.reset();
  ds.select(addr);
  ds.write(0x44, 1);        // start conversion, with parasite power on at the end  
  delay(1000);
  present = ds.reset();
  ds.select(addr);    
  ds.write(0xBE);         // Read Scratchpad
 
  for ( i = 0; i < 9; i++) 
  {           
    data[i] = ds.read();
  }
 
  // Convert the data to actual temperature
  int16_t raw = (data[1] << 8) | data[0];
  if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) 
    {
      raw = (raw & 0xFFF0) + 12 - data[6];
    }
  } 
  else 
  {
    byte cfg = (data[4] & 0x60);
    if (cfg == 0x00) raw = raw & ~7;  // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
 
  }
  celsius = (float)raw / 16.0;

  // In Influx schreiben -------------------------------------------------
  Serial.println("Send data");
  InfluxData row("poolsensor");
  row.addValue("temperature", celsius);
  influx.write(row);
  Serial.println("Disconnecting Wifi");
  WiFi.disconnect();
  delay(1);
  
  ESP.deepSleep(900e6);
}
void setup_wifi() {
    delay(1);
    Serial.println();
    Serial.print("Connecting to ");
    Serial.println(WIFI_SSID);
 
    WiFi.begin(WIFI_SSID, WIFI_PASS);
 
    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.print(".");
    }
 
    Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
}
void loop(void) 
{
  
}

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

#include <OneWire.h>

#include <ESP8266WiFi.h>

#include <InfluxDb.h>

#define INFLUXDB_HOST "" //Enter IP of device running Influx Database

#define WIFI_SSID "" //Enter SSID of your WIFI Access Point

#define WIFI_PASS "" //Enter Password of your WIFI Access Point

Influxdb influx(INFLUXDB_HOST);

WiFiClient espClient;

OneWire ds(D4); // on pin D4 (a 4.7K resistor is necessary)

void setup(void)

{

Serial.begin(115200);

setup_wifi();

influx.setDb("esp8266_test");

while (WiFi.status() != WL_CONNECTED) {

setup_wifi();

}

// Sensor auslesen-------------------------------

Serial.println("Reading Sensor");

byte i;

byte present = 0;

byte type_s;

byte data[12];

byte addr[8];

float celsius, fahrenheit;

if ( !ds.search(addr))

{

ds.reset_search();

delay(250);

return;

}

if (OneWire::crc8(addr, 7) != addr[7])

{

Serial.println("CRC is not valid!");

return;

}

// the first ROM byte indicates which chip

switch (addr[0])

{

case 0x10:

type_s = 1;

break;

case 0x28:

type_s = 0;

break;

case 0x22:

type_s = 0;

break;

default:

Serial.println("Device is not a DS18x20 family device.");

return;

}

ds.reset();

ds.select(addr);

ds.write(0x44, 1); // start conversion, with parasite power on at the end

delay(1000);

present = ds.reset();

ds.select(addr);

ds.write(0xBE); // Read Scratchpad

for ( i = 0; i < 9; i++)

{

data[i] = ds.read();

}

// Convert the data to actual temperature

int16_t raw = (data[1] << 8) | data[0];

if (type_s) {

raw = raw << 3; // 9 bit resolution default

if (data[7] == 0x10)

{

raw = (raw & 0xFFF0) + 12 - data[6];

}

else

{

byte cfg = (data[4] & 0x60);

if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms

else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms

else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms

}

celsius = (float)raw / 16.0;

// In Influx schreiben -------------------------------------------------

Serial.println("Send data");

InfluxData row("poolsensor");

row.addValue("temperature", celsius);

influx.write(row);

Serial.println("Disconnecting Wifi");

WiFi.disconnect();

delay(1);

ESP.deepSleep(900e6);

}

void setup_wifi() {

delay(1);

Serial.println();

Serial.print("Connecting to ");

Serial.println(WIFI_SSID);

WiFi.begin(WIFI_SSID, WIFI_PASS);

while (WiFi.status() != WL_CONNECTED) {

delay(500);

Serial.print(".");

}

Serial.println("");

Serial.println("WiFi connected");

Serial.println("IP address: ");

Serial.println(WiFi.localIP());

}

void loop(void)

{

}

Der ESP sendet dann alle 30 Minuten die Temperatur. Die Daten landen auf meinem Homeserver, wo ich sie dann mit Grafana visualisieren kann.

Visualisierung

Hier noch ein paar Beispieldaten über 7 Tage. In grün die Pooltemperatur und in gelb die Außentemperatur:

Logitech G915 mit Linux verwenden (Piper/Ratbag/solaar)

9. Juni 2022 / jjk1 / Ein Kommentar

Vor einigen Wochen habe ich mir mal wieder eine neue Tastatur gekauft. Die Beleuchtung und Makros sind unter Linux ja immer so eine Sache – Bei manchen Herstellern funktioniert es problemlos, bei anderen gar nicht und bei wieder anderen funktionieren nur manche Geräte, andere wiederum nicht. Bei der G915 von Logitech ging es allerdings bis auf ein paar Kleinigkeiten recht gut.

Piper/Ratbag – für die Steuerung von Beleuchtung und Makros

Nach etwas Recherche stellte sich heraus, dass man die Tastatur wohl mit der Software „Piper“ ganz gut einstellen kann. Installiert war Piper schnell, danach gab es allerdings schon das erste Problem: Die Tastatur wurde nicht erkannt.

Piper zeigt an, dass kein Gerät gefunden wurde

Nach etwas Suchen im Internet kam ich dann auf die Lösung: Die USB-ID stimmte bei mir nicht mit der überein, die standardmäßig für diese Tastatur im Quellcode von Ratbag* festgelegt ist. Also schnell die ID mit lsusb im Terminal herausgesucht und anschließend die Konfiguration von Ratbag überarbeitet:

$ lsusb
&#91;...]
Bus 001 Device 004: ID 046d:c541 Logitech, Inc. USB Receiver

$ lsusb

[...]

Bus 001 Device 004: ID 046d:c541 Logitech, Inc. USB Receiver

Die ID ist hier „046d:c541“. Nun muss in folgender Datei:

$ sudo nano /usr/share/libratbag/logitech-g915.device

1	$ sudo nano /usr/share/libratbag/logitech-g915.device

die Zeile mit „DeviceMatch=“ folgendermaßen überarbeitet werden:

DeviceMatch=usb:046d:c33e;usb:046d:c541

1	DeviceMatch=usb:046d:c33e;usb:046d:c541

am Schluss ist die ID, die mit dem vorherigen Befehl ausgelesen wurde. Anschließend dann noch den Service neustarten:

$ sudo service ratbagd restart

1	$ sudo service ratbagd restart

Jetzt wird die Tastatur von Ratbag erkannt:

Oben links kann das Profil ausgewählt werden (Umschaltbar durch die Tasten M1-M3 auf der Tastatur).

Im ersten Tab „Tasten“ lassen sich die Makros einstellen. Ich habe meine Tasten G3-G5 auf die Makros „Strg+Shift+Alt+1-3“ gelegt und diese dann anschließend zum Öffnen von verschieden Programmen in den Systemeinstellungen eingestellt. Die Tasten G1 und G2 lassen sich leider nur auf rechte/linke Maustaste stellen. Dieser Bug wird hoffentlich auch bald gefixt – mich stört es aber eigentlich nicht.

Unter dem Tab „LEDs“ lässt sich – wer hätte es gedacht – die Beleuchtung einstellen. Für die Tasten und separat das G-Logo lassen sich verschiedene Beleuchtungsmodi einstellen oder auch die Beleuchtung ganz ausschalten.

Zum Schluss nicht vergessen, auf „Zuweisen“ zu klicken. Dann werden die Einstellungen direkt auf der Tastatur gespeichert und Piper wird eigentlich nicht mehr benötigt.

.* Piper ist die grafische Oberfläche für Ratbag

Solaar – Akkustand anzeigen

Der Akkustand der Tastatur lässt sich mit „solaar“ anzeigen.

Solaar war schnell installiert und der Akkustand lässt sich ohne weitere Einstellungen auslesen.

Bei früheren Versionen hatte ich das Problem, dass die Beleuchtung und die Makros der Tastatur sich abgeschaltet haben, sobald solaar gestartet wurde. Dieses Problem ist mittlerweile behoben.