Schlagwort: visualisierung

Ein Upgrade für den Homeserver Teil 10 – InfluxDB und Grafana

31. Dezember 2023 / jjk1 / Keine Kommentare

Seit gut drei Jahren betreibe ich einen RaspberryPi als Homeserver. Zunächst reichte dieser noch gut aus. Mit der Zeit wurde aber nicht nur die Zahl der Anwendungen, die auf dem Raspberry laufen, mehr, sondern auch die Leistungsanforderungen der Anwendungen selbst. Besonders meine ich damit die Influx Datenbank, die seit über drei Jahren jede Minuten um einen Datensatz der PV-Anlage größer wird. Die Datenbank braucht mittlerweile über 10 Minuten zum Starten. Auch diese Webseite braucht zum Laden deutlich länger, als sie sollte. Wenn ich den Raspberry komplett neu starte, braucht es ca. eine Stunde, bis alle Anwendungen wieder laufen. Das ist definitiv zu viel. Es sollte also ein neuer Rechner her. In dieser Artikelserie möchte ich davon berichten.

Übersicht aller Artikel dieser Serie

Was ist InfluxDB, was ist Grafana?

InfluxDB ist eine Datenbank, die darauf spezialisiert ist, zeitbasierte Daten, z.B. Messwerte zu speichern.

Grafana ist eine Software, um diese Daten in Form von verschiedenen Diagrammen zu visualisieren.

Installation von InfluxDB

Die Installation von InfluxDB ist in deren Dokumentation sehr gut erklärt. Die Befehle von dort können wir einfach so ins Terminal übertragen.

# influxdata-archive_compat.key GPG Fingerprint: 9D539D90D3328DC7D6C8D3B9D8FF8E1F7DF8B07E
wget -q https://repos.influxdata.com/influxdata-archive_compat.key
echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null
echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list


sudo apt-get update && sudo apt-get install influxdb
sudo service influxdb start

# influxdata-archive_compat.key GPG Fingerprint: 9D539D90D3328DC7D6C8D3B9D8FF8E1F7DF8B07E

wget -q https://repos.influxdata.com/influxdata-archive_compat.key

echo '393e8779c89ac8d958f81f942f9ad7fb82a25e133faddaf92e15b16e6ac9ce4c influxdata-archive_compat.key' | sha256sum -c && cat influxdata-archive_compat.key | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg > /dev/null

echo 'deb [signed-by=/etc/apt/trusted.gpg.d/influxdata-archive_compat.gpg] https://repos.influxdata.com/debian stable main' | sudo tee /etc/apt/sources.list.d/influxdata.list

sudo apt-get update && sudo apt-get install influxdb

sudo service influxdb start

Installation von Grafana

Grafana installiere ich als Docker-Container. Dazu lege ich in Portainer einen neuen Container an und wähle das Image „grafana/grafana-enterprise:latest“. Dann gebe ich noch den Port 3000 frei und lege ein Volume an.

Installation von Grafana in Portainer: Volumes

Nachdem man den Container erstellt hat, gelangt man mit http://IP_ADRESSE:3000 auf die Weboberfläche von Grafana. Dort muss man noch ein Passwort festlegen, dann ist Grafana einsatzbereit.

InfluxDB in Grafana konfigurieren

Ich gehe davon aus, dass in InfluxDB bereits eine Datenbank angelegt ist. Diese wollen wir nun in Grafana einbinden.

Dazu wähle ich im ausklappbaren Menü links den Punkt „Connections“

Erstellen einer Verbindung von InfluxDB in Grafana

Anschließend wähle ich unter „Add new Connection“ die InfluxDB.

Dort klicke ich noch auf „Add new data source“.

Anschließend lässt sich die Verbindung zur Datenbank konfigurieren. Als URL muss die IP-Adresse des Servers eingetragen werden. Standard-Port ist 8086. „localhost“ funktioniert hier nicht, weil „localhost“ auf die IP-Adresse des Docker-Containers zeigt, da wir Grafana ja über Docker installiert haben.

Im unteren Abschnitt muss noch der Name der Datenbank und falls vorhanden der Benutzername und das Passwort eingetragen werden.

Nach einem Klick auf „Save & test“ erhält man ein „datasource is working“ wenn alles funktioniert hat.

Fazit

Auf das Erstellen eines Dashboards gehe ich hier nicht weiter ein, da das abhängig von der Art der Daten sehr unterschiedlich sein kann. Als Inspiration zeige ich hier noch zwei meiner Dashboards.

Einmal ein Systemmonitor meines alten Servers:

Und hier die Visualisierung einer PV-Anlage:

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:

Sprache wählen:

Neuste Beiträge

Neuste YouTube Videos

Über diese Website

Schlagwort: visualisierung

Ein Upgrade für den Homeserver Teil 10 – InfluxDB und Grafana

Übersicht aller Artikel dieser Serie

Was ist InfluxDB, was ist Grafana?

Installation von InfluxDB

Installation von Grafana

InfluxDB in Grafana konfigurieren

Fazit

Shelly Plug S in Grafana visualisieren

Material

Installation von MQTT

Konfiguration der Shelly

Test

Python Skript

Beispiel Visualisierung mit Grafana

Pool-Temperatursensor mit dem ESP

Hardware

Software

Visualisierung