Daten grafisch aufbereiten

[Avenger84]

Hallo,
ich habe ein kleines Programm auf meinem Raspberry umgesetzt:
https://github.com/datenschuft/SMA-EM

[IMG]https://pics.computerbase.de/forum/attachments/801/801319-4b0c00dfe74abbcf3a45cf05825b3dc1.jpg[/IMG]





Das liest jede Sekunde Multicast Daten aus und zeigt diese im Shell an.
Es waren einige Fehler enthalten die ich verbessert habe, dazu auf deutsch übersetzt.

Ist schon ganz gut aber es geht noch hübscher.

Nun habe ich gehört dass man mit "influxdb" und "Grafana" beides auch auf dem Raspberry, diese Werte als Webseite virtualisieren kann.

Ziel ist es nachher den Raspberry per IP aufzurufen mit Port oder IP/SMA und dann etwas grafisches zu haben was so ähnlich (zumindest die Richtung) ausschaut:
https://www.computerbase.de/forum/attachments/1588267179714-png.911236/
Das würde ich gern selber gestalten wenn ich weiß was ich tun muss.

Unter https://github.com/datenschuft/SMA-EM/tree/master/features
gibt es sowohl influxdb.py als auch sma_grafana.json

Also bereits eine Vorbereitung.

Vielleicht kann mir Jemand "Starthilfe" geben.

 

[Tokukarin]

Interessant, würde mich echt interessieren ob Grafana, Kibana oder Prometheus auch auf nem Raspberry laufen🤣

 

[spcqike]

da du bereits fast alles hast was du brauchst (dir fehlt ja nur die Datenbank, also InfluxDB, und die Visualisierung, also Grafana), empfehle ich dir Docker.
Installiere dir Docker auf dem Pi, starte 2 Container trage die Daten von Influx in deiner influxdb.py ein.

Zur Installation von Docker und der Container gibt es bereits hunderte Anleitungen.
das influxdb.py sollte deine Daten in der Datenbank protokollieren. Ob das Skript dann von selbst dauerhaft läuft, oder ob du per Crontab periodisch starten musst, kann ich nicht sagen. da es aber ein "min_update" hat gehe ich von ersterem aus.

den Inhalt der Grafana_json kannst du wohl direkt kopieren und in Grafana einfügen. einige Sachen wie den Datenbanknamen musst du aber anpassen. Alternativ kannst du natürlich ein Dashboard basteln, wie du es möchtest.

Interessant, würde mich echt interessieren ob Grafana, Kibana oder Prometheus auch auf nem Raspberry laufen🤣

Zumindest Grafana und InfluxDB laufen wunderbar auf einem Raspberry. Dafür gibt es wie gesagt fertige Container. Wer will, hat seine Datenbank/Visualisierung in 5 Minuten aufgesetzt.

 

[Tokukarin]

Zumindest Grafana und InfluxDB laufen wunderbar auf einem Raspberry. Dafür gibt es wie gesagt fertige Container. Wer will, hat seine Datenbank/Visualisierung in 5 Minuten aufgesetzt.

Dann noch Openshift und ich werde neidisch

 

[Bagbag]

@Tokukarin
Meine Grafana Instanz verbraucht 30MB RAM, Prometheus 95MB. Das ist nun wahrlich nichts besonderes, was nicht Problemlos auf nem Raspberry Pi läuft. Nur durch die SD-Karte könnten die Ladezeiten etwas länger sein.

 

[Tokukarin]

@Bagbag
Interessant, ich kenne Grafana leider nur in Enterprise Umgebungen. Und da reichen 30MB leider nicht 😅

 

[G-Red]

@Avenger84
Handelt es sich um Daten die gespeichert werden müssen, oder sind das einfach nur laufende Werte die zur Laufzeit angezeigt werden müssen?

Wenn es sich um das Zweite handelt, würde ich mir vielleicht einfach das NodeRed anschauen.

 

[Raijin]

NodeRed wäre in der Tat eine Alternative. Ich arbeite in der Firma derzeit an einem Messsystem basierend auf einem RevPI, das Daten aus verschiedenen Quellen sammelt. Sensoren, digitale/analoge IOs, aber zB auch Daten von mehreren SPS. Diese Daten zeige ich zum einen Live über das Dashboard von NodeRed an, speichere sie aber zudem auch in einer (externen) Datenbank ab. Von dort hole ich mir in einer Unterseite des Dashboards auch Daten ab, die ich dann als Historie darstelle.

 

[spcqike]

man könnte es auch mit FHEM auswerten, protokollieren und darstellen

FHEM nutze ich sowohl privat, als auch in der Firma zum Abfragen kleinerer Daten wie Sensoren (Temperatur, Feuchte und Anlagen mittels ESP/Arduino, Spritpreise und Druckerstatus (Füllstand der Tinten, Anzahl der gedruckten Seiten) mittels HTTP-Abfragen, Fritzbox Traffic und Anrufinfos, Anwesenheit mittels WLAN, ...)

Ist zwar weniger "schick", dafür sehr flexibel und vielseitig einsetzbar. Und kann auch zu InfluxDB oder zu MySQL schreiben und auslesen, bzw. auch Grafana abfragen und die Graphen darstellen.

 

[Avenger84]

Es sollen nur live Werte angezeigt werden, im Sekundentakt wäre ganz nett (so wie das Python3 jetzt).

NodeRed habe ich auch schon von gehört und was gesehen.

Was ist am besten für live Werte ohne Logging/Aufzeichnung ?

 

[G-Red]

Ich hatte mal mit NodeRed daten von einem CAN-Bus eines Fahrzeugs abgegriffen und diese dann grafisch dargestellt. Die daten wurden in 100ms Takt übertragen.

 

[Raijin]

"Am besten" gibt es nicht. Probier NodeRed einfach aus, gibt's ebenfalls als Docker-Container. Intern arbeitet NodeRed mit JavaScript, aber es lassen sich auf Nodes nachladen, mit denen man Skripte in python aufrufen kann. Sicherlich musst du dann den Output entsprechend parsen und aufbereiten, aber das ist halb so wild.

Für dein Szenario eignen sich eben IoT-Anwendungen im weitesten Sinne, weil sie per Definition darauf ausgelegt sind, mit verschiedenen Datenquellen zu arbeiten und die Daten dann entsprechend darzustellen. Programmierkenntnisse sind dazu meistens nicht wirklich notwendig bzw. halten sich in Grenzen. Bei NodeRed beschränkt sich das in der Regel darauf, dass man in einem Function-Node Werte umwandelt. So liefert einer meiner Sensoren beispielsweise nur einen Integer als 1000stel und ich muss den Wert dann entsprechend durch 1000 teilen, um den realen Messwert zu erhalten.

In deinem Falle müsstest du den Output des Skripts als String parsen. Das wirst du aber so oder so tun müssen, egal welche Visualisierung du einsetzt.

 

[Avenger84]

In deinem Falle müsstest du den Output des Skripts als String parsen. Das wirst du aber so oder so tun müssen, egal welche Visualisierung du einsetzt.

Da hörts bei mir schon auf, schade.
Nodered sieht so aus, als würde ich damit klar kommen, aber wie ich die Werte da rüber kriege ->

Falls mir da Jemand helfen möchte, der weiß wie das geht, kann er sich gerne per pn melden.

 

[Raijin]

Wie hattest du dir das denn sonst vorgestellt? Mit "Starthilfe" dachte ich, dass du dich da eben reinfuchsen und eben selbst eine Visualisierung bauen wolltest, weil kaum zu erwarten ist, dass hier jemand eine fertige Visu für deinen Anwendungsfall aus dem Hut zaubert.

Ich sehe gerade, dass es für NodeRed sogar direkt einen Function-Node mit python gibt. Das ist noch viel besser, weil du nicht den Umweg über einen Shellaufruf mit Output, parsen, etc nehmen musst. So kannst du den Source des Skripts direkt in den Node kopieren. Statt im Skript dann den Output-String zusammenzubauen (die ganzen print-Anweisungen im Skript) ersetzt du diesen Teil einfach mit sowas hier:

payload.gesamt.verbrauch=emparts['pconsume']
payload.gesamt.frequenz=emparts['frequency']
payload.l1.verbrauch=emparts['p1consume']
...

Das Payload-Objekt ist im Prinzip das was bei NodeRed auf den "Drähten" zwischen den Nodes hin- und herläuft. Der besagte python-Function-Node wird also getriggert (zB alle 5 Sekunden), der Node baut das payload-Objekt zusammen und dann wird selbiges an die Dashboard-Nodes weitergegeben. Fertig ist die Visu mit NodeRed.

*edit
Obiges Beispiel ist kein python, sondern nur exemplarisch.

 

[Avenger84]

Danke, werde ich ausprobieren

 

[Avenger84]

@Raijin kannst du mir noch einen kleinen Tritt in die richtige Richtung geben bitte.

Nodered läuft.

Install
Python 2.7 and Python 3.x compatible

npm install -g node-red-contrib-python3-function

hat auch geklappt

Das sagt mir nichts:

Define a function with Python instead of Javascript

npm install node-red-contrib-python3-function

Und wie ich die Werte in Nodered kriege ist mir auch ein Rätsel.

python3 function gibt es schon mal.

Ein digitales Ausgabefeld finde ich nicht.

Sry hab 0 Plan davon, bin aber lernfähig.

 

[Raijin]

Ein function node enthält direkt ein Skript. Standardmäßig ist das javascript, mit dem python-node ist es dann eben python. Zumindest in der Theorie solltest du da direkt dein Skript reinkopieren können. Da ich mir das Skript aber nicht im Detail angeschaut habe, kann ich natürlich nicht beurteilen ob es aus dem Stand lauffähig ist oder ob man noch Änderungen vornehmen muss. Was man auf jeden Fall ändern sollte ist die Ausgabe des Skripts. Auf der Konsole wird ja lediglich ein String zusammengebaut, der die Variablen im Skript abfragt, formatiert und mit den Überschriften versieht. Genau hier musst du ansetzen und so wie oben exemplarisch dargestellt die Werte in das Ausgabe-Objekt packen.


Vielleicht dazu noch etwas Grundsätzliches zu NodeRed: Bei NodeRed laufen von Node zu Node Nachrichten durch die Verbindungen. Diese Nachrichtenobjekte heißen sinnvollerweise "msg" und bestehen standardmäßig aus 3 Properties:

msgid = ID
topic = Titel
payload = Daten

Die payload ist dabei das am häufigsten verwendete Property, weil dort die Daten enthalten sind. Da stecken also String, Zahlen, aber eben auch komplexe Objekte drin. Man kann am function node auch Ausgänge hinzufügen und so mehrere Dinge parallel ausgeben. So ist es möglich, jedem Wert einen Ausgang zu spendieren oder aber die Gruppen in ein gemeinsames Objekt zu packen.


Exemplarisch habe ich mal einen flow aus dem Ärmel geschüttelt:

Spoiler: Flow

Spoiler: Exportierter Flow

[
{
"id": "c23b1d22.66fe28",
"type": "ui_text",
"z": "bd518007.f95a18",
"group": "5fffb328.30271c",
"order": 5,
"width": 0,
"height": 0,
"name": "Verbrauch L2",
"label": "Verbrauch",
"format": "{{msg.payload.verbrauch}}",
"layout": "row-spread",
"x": 980,
"y": 260,
"wires": []
},
{
"id": "5fffb328.30271c",
"type": "ui_group",
"z": "",
"name": "Cameras",
"tab": "237eeb23.9c2b34",
"order": 1,
"disp": true,
"width": "6",
"collapse": false
},
{
"id": "237eeb23.9c2b34",
"type": "ui_tab",
"z": "",
"name": "Cameras",
"icon": "dashboard",
"disabled": false,
"hidden": false
}
]

Der Flow wird so erstmal nicht funktionieren, weil ihn ihn kurzerhand auf einem Demo-Portal gebastelt habe (habe gerade kein NodeRed greifbar). Interessant ist hier zunächst einmal der function node. Dort habe ich beispielhaft Werte bzw. Objekte generiert und an die drei Ausgänge verteilt. Von dort geht es dann weiter an 3 UI-Nodes, die du ggfs noch in der Palette nachinstallieren musst (Stichwort: Dashboard, siehe unten).

Spoiler: Function Node SkriptMessung

Spoiler: UI Node Gauge

Spoiler: UI Node Text

In deinem Fall heißt das dann also konkret, dass du dein Skript in den Node kopierst und die Ausgabe von einem String auf Variablen-Ausgabe umbaust bzw. die Gesamt/L1/L2-Objekte erzeugst und in der Funktion zurückgibst. Diese Objekte greifst du dann im UI-Node ab, wählst aus welchen Wert du haben willst (zB aus dem 3. msg-Objekt (L2) >>> Value = msg.payload.verbrauch) und das war's dann eigentlich schon.

Was das Dashboard als solches angeht: Nachdem du die Palette um das Dashboard erweitert hast, tauchen die UI-Nodes in der Liste auf. In den flow ziehen und beim konfigurieren dann die Tabs bzw. Gruppen erstellen. NodeRed wird die Elemente automatisch in den Gruppen anordnen, man kann sie jedoch auch individuell breiter und schmaler machen. Der Einfluss auf das Layout ist aber begrenzt, da NodeRed dynamisch auf das Format des Bildschirms reagiert (Hoch-/Querformat, Auflösung, Fensterbreite, etc)

Hier noch ein paar Links zu den angesprochenen Themen:

Message Object
Function Node
Dashboard

 

[Avenger84]

vielen Dank, werde ich ausprobieren 👍

 

[Avenger84]

In deinem Fall heißt das dann also konkret, dass du dein Skript in den Node kopierst und die Ausgabe von einem String auf Variablen-Ausgabe umbaust bzw. die Gesamt/L1/L2-Objekte erzeugst und in der Funktion zurückgibst.

Nachdem ich mir deine Anleitung 4x durchgelesen habe, habe ich den Ablauf in NR einigermaßen verstanden.
Nur wie kann ich das Skript bzw. es sind ja zwei Skripte da rein kopieren ? Da finde ich keinen Ansatz.

 

[Raijin]

Sorry, ich steh gerade auf dem Schlauch.

Copy&Paste?

Einfach den Python Node doppelt anklicken, dann öffnet sich das Einstellungsfenster des Nodes und dort ist dann auch der Codebereich drin. Zumindest läuft das so beim Function Node. Python habe ich jetzt nicht ausprobiert.

Schau dir sonst mal ein paar Videos bei Youtube an. Da sieht man das ganz gut.