Ecowitt API - diverse Wetterstationen

[gent]

Hallo,

ich bin vor einiger Zeit mal auf die Seite https://www.wetterstationsforum.info/wiki/doku.php?id=wiki:wetterstationen:ecowitt-stationen gestoßen. Da ich selber ein GW1000 (baugleich mit dem Froggit DP1500) habe, war ich schon immer interessiert an einer Integration in FHEM. Diese mache ich derzeit umständlich über einen zusätzlichen rPi mit weewx und mqtt. Jetzt wurde vor einiger Zeit endlich die Ecowitt API öffentlich gemacht:

https://osswww.ecowitt.net/uploads/20210716/WN1900%20GW1000,1100%20WH2680,2650%20telenet%20v1.6.0%20.pdf

Die Frage an alle, die hier mitlesen: Was braucht es, um daraus ein Modul zu bauen und geht das alleine mit der API-Dokumentation überhaupt? Hätte jemand überhaupt - neben mir - Interesse daran, sich damit näher zu beschäftigen? Alleine werde ich das leider nicht schaffen, also wenn jemand Zeit und Interesse hätte: Ich wäre mit dabei.

LG, Holger

[sepo83]

Hab selber eine WH2650 und hätte großes Interesse.

Vorteile:
* durch die direkte Client-Server Verbindung würde die (potentiell unsichere) zusätzliche FHEM-WebInstanz wegfallen
* wenn man die API komplett umsetzt kann man die WIFI-Station komplett in FHEM konfigurieren (inkl. WLAN Settings, Sensor-Kalibrierung, etc)
* man kann auch weitere angeschlossene Sensoren auslesen (z.B. weitere Temperatur-Sensoren von Frogit)

Wenn ich die Doku richtig verstehe ist das grundlegende Vorgehen zum auslesen der live SensorDaten auch gar nicht so schwer, wenn man die WIFI-Station bereits eingerichtet hat (sie also im WLAN Daten sendet). Dann wären die Schritte:
1. Fhem verbindet sich via TCP auf die WIFI-Station (Port 45000)
2. Fhem fragt aktiv die Daten mit einem konfigurierbaren Intervall ab (TCP-Paket mit CMD-Wort an WIFI-Station; WIFI antwortet mit einem Paket, welches die Sensor-Daten enthält); z.B:
   a. Kapitel 3 Punkt 22) --> CMD_GW1000_LIVEDATA --> angeschlossene extra Sensoren
   b. Kapitel 3 Punkt 25) --> CMD_READ_RAINDATA--> Regenmenge
   c. Kapitel 3 Punkt 29) --> CMD_READ_SENSOR_ID --> Baterie, Sensor ID
   d. Kapitel 3 Punkt 13) -->  CMD_GET_SOILHUMIAD --> Feuchtigkeit
3. Fhem schreibt die Daten als Reading

Mit dem Programm Packet-Sender (https://packetsender.com/) kann ich grundsätzlich so von meinem PC zur WIFI Station kommunizieren; z.B. CMD_READ_SATION_MAC:
* senden via TCP an IP meiner WIFI-Station / Port 45000: ff ff 26 04 00 2a
* Antwort: FF FF 26 09 BC DD C2 A8 FF A4 D5 --> MAC Adresse =  BC DD C2 A8 FF A4

Nun zu meinem Problem. Ich hab zwar ein grundlegendes Verständnis wie die Kommunikation läuft, bin aber kein wirklicher Perl-Programmierer. Für Unterstützung (zB CodeSnipets für TCP Verbindung; Packen und Entpacken von Paketen) wäre ich dankbar. Dann könnte ich evtl. eine erste Implementierung des Moduls machen.

[kjmEjfu]

Diese mache ich derzeit umständlich über einen zusätzlichen rPi mit weewx und mqtt.

weewx braucht man aber doch nur, wenn man damit auch die ganzen Übersichten (Webseiten) generieren möchte.
Ansonsten ist IMO https://loxwiki.atlassian.net/wiki/spaces/LOXBERRY/pages/1252524456/FOSHKplugin+-+generic+version die viel bessere Alternative. Erleichtert auch viel, wenn man die eigenen Daten an die vielen Wetterdienste weitergeben möchte. Führt auch noch Korrekturen durch. Hat man in einer halben Stunde am Laufen.
Ich würde das nicht alles in FHEM nachcoden wollen

[sepo83]

Ich hab eine erste Version eines FHEM-Moduls entwickelt, welches die Daten von der GW1000/WH2650 via TCP anfragt. Funktioniert bei mir auf den ersten Blick. Ich hab das ganze auf github veröffentlicht: https://github.com/sepo83/FHEM_GW1000_TCP

Bei meinen Tests gab es aber immer wieder Verbindungsabbrüche vom WH2650 ins WLAN, sodass ich die Daten jetzt direkt über SIGNALduino und 868MHz einlese. Das funktioniert aber nur mit der SIGNALduino-Version von Ralf9 (https://forum.fhem.de/index.php/topic,111653.msg1058900.html#msg1058900).

Entsprechend würde hier nicht mehr aktiv weiter machen. Vielleicht kann ja jemand anderes noch was mit meiner Vorarbeit anfangen.

EDIT: Das Module braucht noch das perl-package IO::Socket::INET.

[gent]

weewx braucht man aber doch nur, wenn man damit auch die ganzen Übersichten (Webseiten) generieren möchte.
Ansonsten ist IMO https://loxwiki.atlassian.net/wiki/spaces/LOXBERRY/pages/1252524456/FOSHKplugin+-+generic+version die viel bessere Alternative. Erleichtert auch viel, wenn man die eigenen Daten an die vielen Wetterdienste weitergeben möchte. Führt auch noch Korrekturen durch. Hat man in einer halben Stunde am Laufen.
Ich würde das nicht alles in FHEM nachcoden wollen

Hi, und gibt's dafür auch eine Anleitung, wie man das dann in FHEM integriert? Die Installation scheint ja einfach zu sein, aber ich will die Werte der Station in FHEM als Reading sehen und diese nicht über den Umweg eines Wetterdienstes in FHEM anzeigen.

LG

[gent]

Ich hab eine erste Version eines FHEM-Moduls entwickelt, welches die Daten von der GW1000/WH2650 via TCP anfragt. Funktioniert bei mir auf den ersten Blick. Ich hab das ganze auf github veröffentlicht: https://github.com/sepo83/FHEM_GW1000_TCP

Bei meinen Tests gab es aber immer wieder Verbindungsabbrüche vom WH2650 ins WLAN, sodass ich die Daten jetzt direkt über SIGNALduino und 868MHz einlese. Das funktioniert aber nur mit der SIGNALduino-Version von Ralf9 (https://forum.fhem.de/index.php/topic,111653.msg1058900.html#msg1058900).

Entsprechend würde hier nicht mehr aktiv weiter machen. Vielleicht kann ja jemand anderes noch was mit meiner Vorarbeit anfangen.

EDIT: Das Module braucht noch das perl-package IO::Socket::INET.

Vielen Dank. ich schau mir das gleich mal an.

LG

[gent]

Hi sepo83,

schade, das sah schon vielversprechend aus, aber leider bekomme ich im log einen Fehler und dann ist FHEM nicht mehr erreichbar:

Code Auswählen Erweitern


2022.03.15 19:31:15 2: GW1000_TCP <MYGW1000>: connected to server (192.168.178.184:45000)
2022.03.15 19:31:15 2: GW1000_TCP <MYGW1000>: sent data (size: 6):ffff2604002a
2022.03.15 19:31:15 2: GW1000_TCP <MYGW1000>: received response: ffff2609e8db849a08273f (255 255 38 9 232 219 132 154 8 39 63)
2022.03.15 19:31:15 2: GW1000_TCP <MYGW1000>: HEADER: 0xff 0xff; CMD: 0x26; SIZE: 9; CHECKSUM: 63; DATA: 232 219 132 154 8 39
2022.03.15 19:31:15 2: GW1000_TCP: Received CMD_READ_STATION_MAC (0x26). Unpacking data...
Undefined subroutine &main::ReadingsSingleUpdate called at ./FHEM/50_GW1000_TCP.pm line 442.


Ich weiß, dass Du das nicht weiterentwickeln willst, aber könntest Du mir bitte hierbei noch einmal helfen, damit ich dein Modul wenigsten einmal testen kann?

LG

[gent]

Hab den Fehler selber gefunden:

Kleiner Schreibfehler in Zeile 442

Code Auswählen Erweitern


# ReadingsSingleUpdate($hash, "StationMac", sprintf("%x %x %x %x %x %x", @data), 1 );
# ^ das R muss klein geschrieben werden

readingsSingleUpdate($hash, "StationMac", sprintf("%x %x %x %x %x %x", @data), 1 );


Läuft jetzt mal soweit. Danke auch für die Erklärungen zu packetsender.

LG, Holger

[fume]

Hallo

Danke für das Modul, Ich aber aber bei den Readings die Leerzeichen entfernt, dann werden sie in fhem auch richtig aktualisiert.
Ansonsten funktioniert es bisher super.

Grüsse Norbert

[gent]

Hallo Norbert,

können wir uns dazu mal austauschen?

Viele Grüße,

Holger

[fume]

Gerne
Ich habe in den Zeilen 57 bis 163 die Leerzeichen durch Unterstriche ersetzt, da Leerzeichen immer wieder Probleme in Readings machen, dann wird auch im Webfrontend aktualisiert.

Norbert

[gent]

Hallo Norbert,

Danke Dir für die Info. Das passt jetzt.

LG, Holger

[gent]

Ich hab eine erste Version eines FHEM-Moduls entwickelt, welches die Daten von der GW1000/WH2650 via TCP anfragt. Funktioniert bei mir auf den ersten Blick. Ich hab das ganze auf github veröffentlicht: https://github.com/sepo83/FHEM_GW1000_TCP

Bei meinen Tests gab es aber immer wieder Verbindungsabbrüche vom WH2650 ins WLAN, sodass ich die Daten jetzt direkt über SIGNALduino und 868MHz einlese. Das funktioniert aber nur mit der SIGNALduino-Version von Ralf9 (https://forum.fhem.de/index.php/topic,111653.msg1058900.html#msg1058900).

Entsprechend würde hier nicht mehr aktiv weiter machen. Vielleicht kann ja jemand anderes noch was mit meiner Vorarbeit anfangen.

EDIT: Das Module braucht noch das perl-package IO::Socket::INET.

Hallo sepo83,

Das Modul ist echt gut. Du scheinst Dich ja auch auszukennen in der Modul-Entwicklung. Das Modul ist im Moment noch zu gesprächig im log. Kannst Du mir bitte verraten, wie ich das ändern kann? Verbose=0 bringt leider nichts.

Ich vermute, es liegt daran, dass Du manchmal einfach die Funktion Log verwendest, manchmal aber die Funktion Log3. Wenn man das einfach so ändern kann, weil Log3 den Verbose-Level berücksichtigt, dann schaffe ich das selber.

Oder muss da noch etwas programmiert werden, damit man nur Einträge im Log erhält, die man laut Verbode-Level auch haben will?

LG, Holger

[sepo83]

Hallo Holger,

freut mich, dass jemand meine Arbeit weiter führt...

Ich hab die Entwicklung des Moduls auf "halben Wege" abgebrochen. Entsprechend muss noch "aufgeräumt" werden .
Ich denke du kannst die Log Funktionen ohne weiteres durch Log3 Funktionen ersetzen; natürlich Syntax beachten (siehe https://wiki.fhem.de/wiki/DevelopmentModuleAPI#Log3). Beispiel (ohne das jetzt ausprobiert zu haben) Zeile 340:
Alt:

Code Auswählen Erweitern

Log 2, "GW1000_TCP <$hash->{name}>: connected to server ($hash->{I_GW1000_IP}:$hash->{I_GW1000_Port})" ;

Neu:

Code Auswählen Erweitern

Log3, $name , 2, "connected to server ($hash->{I_GW1000_IP}:$hash->{I_GW1000_Port})" ;

Die Log Funktion müsste den Verbose-Level aber eigentlich auch richtig berücksichtigen (siehe https://wiki.fhem.de/wiki/DevelopmentModuleAPI#Log).  Mein Vorschlag wäre alle Log-Aufrufe zu vereinheitlichen (also alle auf Log3) und nochmal bei jedem Aufruf das Log-Level auf "was sinnvolles" anzupassen.

Grüße,
Sebastian

[gent]

Hallo Sebastian,

wieder was gelernt: log nimmt nur das global verbose Attribut, bei log3 kann man dann für ein einzelnes Device noch den verbose level angeben. Das ist nun auch geändert und funktioniert.

Außerdem habe ich noch ein paar "factor" geändert (z.B. Outdoor Temperature und Rain...)

Kann ich Dir mal die Änderungen schicken und Du checkst es in Git ein?

Grüße, Holger

[gent]

Gerade eben bei den Kollegen vom wetterstationsforum.info gelesen:

API* für alle auf www.ecowitt.net registrierten Konsolen

Seit Kurzem (Ende Februar 2022) hat Ecowitt die Definition seines API für den Cloud-Server ecowitt.net veröffentlicht/freigegeben. Jeder Benutzer kann damit aus der Ecowitt-Cloud die von seiner(n) Konsole(n) auf ecowitt.net im 5-Minuten-Intervall gespeicherten lokalen Wetterdaten mit Hilfe eines entsprechenden Programmes herunterladen. Manuell war das schon immer interaktiv auf der Webseite möglich.
Benötigt werden dazu ein API-Key (Schlüssel) und ein App-Key (Anwendungsschlüssel), die jeder registrierte Benutzer in seinem Konto erzeugen kann. Hinzu kommt noch die MAC Adresse der Konsole (siehe WS View [Plus] Geräteliste (Device List).
Damit kann man z.B. bei Datenverlust o.ä. die Daten der letzten 90 Tage im 5-Minuten-Intervall herunterladen.
Oder auch, wenn man seinen Datenlogger nicht 24/7 laufen lassen möchte und einem ein 5-minütiges Speicherintervall genügt.


Man braucht dazu auf seiner ecowit.net page unter dem User Profile einen API-Key und einen Application Key. Als Label kann man eingeben, was man will und bekommt die beiden Keys dann direkt angezeigt.

Mit folgendem Aufruf bekommt man die Daten als JSON zurück:

https://api.ecowitt.net/api/v3/device/real_time?application_key=APPLICATION_KEY&api_key=API_KEY&mac=YOUR_MAC_CODE_OF_DEVICE&call_back=all

Alle weiter Infos zur API hier : https://doc.ecowitt.net/web/#/apiv3en?page_id=1

Ich schaue mir das heute Abend mal an. Allerdings bin ich eigentlich für die Hausautomatisierung Verfechter von Cloud-Free Lösungen, daher finde ich das Modul von sepo83 prinzipiell besser, auch wenn hier noch etwas Finetuning nötig ist / war. Aber wer es lieber einfach haben will und die Werte ALLER Sensoren in FHEM haben will (nicht nur die über WU bereitgestellten Werte), dem kann hiermit geholfen werden.

Liebe Grüße, Holger

[Fistandantilus]

Hi, wie ist denn der aktuelle Stand? Der Weg über TCP wäre mir grundsätzlich auch lieber, als erst alles in die Cloud zu schicken und von da wieder zu holen.
Wenn sepo83 nicht mehr weiterentwickelt, könnten wir das Ganze auch in einem neuen Repository weiterführen. Wir bräuchten halt jemanden, der das in die Hand nimmt Ich kann soweit möglich gern mit Testen und Supporten, bin aber ansonsten beruflich ziemlich eingespannt.

Viele Grüße, F.

[kjmEjfu]

die aus meiner Sicht einfachste Variante ist ein "Plugin" zwischenzuschalten: https://loxwiki.atlassian.net/wiki/spaces/LOXBERRY/pages/1252524456/FOSHKplugin+-+generic+version
Das kommt zwar von LoxBerry, aber in der Generic Version läuft es ohne. Das konfiguriert man, lässt Ecowitt dorthin die Daten schicken und FOSHKplugin schiebt alles auf einen MQTT Server.
Hast damit Zugriff auf alle Daten und FOSHKplugin generiert sogar noch ein paar zusätzliche Daten.

(und wer will, setzt sich noch https://www.weewx.com/ auf und schiebt die Daten auch dorthin).

[gent]

Hallo kjmEjfu, Fistandantilus

beides hatte ich bereits im Einsatz. Viel zu kompliziert. Wenn Modul, dann Modul und ohne 3rd Party Tools. Alleine weewx so zu konfigurieren, dass es die korrekt umgerechneten Werte an fhem per mqtt schickt, war grauenhaft umzusetzen. Support = 0.

Den Weg über TCP (zumindest in der Version, die sepo83 bereitgestellt hatte) legt bei mir sporadisch FHEM komplett lahm, weil es - im Falle das das GW1000 im WLAN mal nicht erreichbar ist - den Prozess nicht abbricht. War für mich also keine Lösung, da ich auch zu wenig von Fhem Modulentwicklung verstehe. Ein paar Dinge konnte ich ändern und auch nachvollziehen, aber das ganze "non blocking" umzuprogrammieren, daran fehlt es.

Das "neue" GW1000 (GW1500 ?) hat einen eigenen Webserver, weil ein ESP8266 mit mehr RAM verbaut und ich hoffe, dass man darüber die API auch direkt bekommt. Kann das aber nicht wirklich testen.

Im Moment läuft das über die API sehr gut, weil ich auch die App von Ecowitt nutze und mir 60 Sekunden update-time locker reichen. Schön ist, dass man über die API alle Werte aller Sensoren bekommt und nicht nur die, die WeatherUnderground versteht. Und genau das war auch mein Ziel.

Liebe Grüße, Holger

[kjmEjfu]

beides hatte ich bereits im Einsatz. Viel zu kompliziert. Wenn Modul, dann Modul und ohne 3rd Party Tools. Alleine weewx so zu konfigurieren, dass es die korrekt umgerechneten Werte an fhem per mqtt schickt, war grauenhaft umzusetzen. Support = 0.

Stimmt, weewx ist die Hölle. Aber deshalb würde ich das nur im zweiten Schritt aufsetzen.

Rein um die Daten von Ecowitt Stationen nach FHEM zu nutzen, würde ich nur das FOSHKplugin nutzen. Das läuft Standalone und braucht wenig Konfiguration.
Das macht quasi nix anderes als Daten von der Ecowitt entgegen nehmen, etwas aufbereiten und an x (von einem selbst bestimmte) Dienste weiterleiten.

[LukeSky007]

Hallo zusammen,

ich habe gerade meine neue ecowitt mit GW2000  mit dem Modul konfiguriert.  Hat auf  Anhieb gelappt - Ich habe das GW2000  zuvor ins Netzwerk eingebunden.
Habe das Reading für die Firmware Version gefixt.

Code Auswählen Erweitern

    elsif ($cmd == $GW1000_cmdMap{CMD_READ_FIRMWARE_VERSION}) {
        shift(@data);
        my $x = join '', map chr, @data;
        readingsSingleUpdate($hash, "Firmware Version", sprintf("%s" , $x), 1 );
    }

und die Aufrufe der Log  Methode nach  Log3   konvertiert.
Die Änderung findet Ihr in meinem github-fork
Gruß
Luke

[minierm]

Hallo!
Seit zwei Tagen habe ich das Ecowitt Gateway GW1100 (plus Bodensensor), das ja einen eingebauten Webserver mitbringt.
Nachdem mein erster Versuch, die Seite mit Regex zu graben, fehlgeschlagen ist, hab ich im Netzwerktraffic die URL gefunden, die alle Daten bereitstellt:

Code Auswählen Erweitern

get_livedata_info
Die liefert schönes JSON (Zentrale plus Bodenfeuchtigkeit):

Code Auswählen Erweitern

{ "wh25": [{ "intemp": "26.0", "unit": "C", "inhumi": "48%", "abs": "949.9 hPa", "rel": "1014.9 hPa" }],
"ch_soil": [{ "channel": "1", "name": "", "battery": "0", "humidity": "30%" }] }

Als Device sieht es dann z.B. aus:

Code Auswählen Erweitern

defmod Ecowitt_GW HTTPMOD http://192.168.178.187/get_livedata_info 30
attr Ecowitt_GW comment https://www.ecowitt.net
attr Ecowitt_GW event-on-change-reading .*
attr Ecowitt_GW extractAllJSON 1
attr Ecowitt_GW group Ecowitt,Wetter
attr Ecowitt_GW room Wetter
attr Ecowitt_GW showBody 0
attr Ecowitt_GW showError 1
attr Ecowitt_GW stateFormat wh25_01_intemp°; wh25_01_inhumi wh25_01_rel
attr Ecowitt_GW timeout 10

Mit Logfile:

Code Auswählen Erweitern

defmod Log_Ecowitt FileLog ./log/Log_Ecowitt-%Y-%m.log Ecowitt_GW.*
attr Log_Ecowitt group SVG,Ecowitt,Wetter
attr Log_Ecowitt room Wetter

Die Sensoren kann man als ReadingsProxy definieren:
Bodenfeuchte:

Code Auswählen Erweitern

defmod Ecowitt_Sensor_Soil_01 readingsProxy Ecowitt_GW:ch_soil_01_humidity
attr Ecowitt_Sensor_Soil_01 group Ecowitt,Wetter
attr Ecowitt_Sensor_Soil_01 room Wetter
attr Ecowitt_Sensor_Soil_01 userReadings battery {ReadingsVal("Ecowitt_GW", "ch_soil_01_battery", "")},\
channel {ReadingsNum("Ecowitt_GW", "ch_soil_01_channel", "")},\
name {ReadingsVal("Ecowitt_GW", "ch_soil_01_name", "")}

Temperatur:

Code Auswählen Erweitern

defmod Ecowitt_Sensor_Aisle_01 readingsProxy Ecowitt_GW:ch_aisle_01_temp
attr Ecowitt_Sensor_Aisle_01 alias Carport
attr Ecowitt_Sensor_Aisle_01 comment Draussen Carport
attr Ecowitt_Sensor_Aisle_01 event-on-change-reading .*
attr Ecowitt_Sensor_Aisle_01 group Ecowitt,Wetter
attr Ecowitt_Sensor_Aisle_01 room Wetter,Wetterlage
attr Ecowitt_Sensor_Aisle_01 stateFormat state°; humidity
attr Ecowitt_Sensor_Aisle_01 userReadings battery     {ReadingsNum("Ecowitt_GW", "ch_aisle_01_battery", "")},\
channel     {ReadingsNum("Ecowitt_GW", "ch_aisle_01_channel", "")},\
humidity    {ReadingsVal("Ecowitt_GW", "ch_aisle_01_humidity", "")},\
temperature {sprintf("%s°", ReadingsVal("Ecowitt_GW", "ch_aisle_01_temp", "?"))},
name        {ReadingsVal("Ecowitt_GW", "ch_aisle_01_name", "")}

Nach dem Start des GW (Stromverbindung) muss man sich einmalig anmelden, um die Oberfläche freizuschalten. Dies trifft jedoch nicht auf die API zu, die ist immer verfügbar, also kein Problem. (Getestet ohne Passwort).
Eine Registrierung bei Ecowitt ist nicht notwendig.

Ecowitt ist damit mein drittes Funknetz neben Rademacher Duofern (Rollläden) und Zigbee (Sensoren).

[LukeSky007]

Hallo zusammen,

ich habe das 50_GW1000_TCP.pm von @sepo83  auf  DevIo  umgestellt.
Mit meinem ecowitt GW200X  funktioniert das auch schon fast.
Der Temperaturwert  von der WS90 hat eine falsche Skalierung  (221,0  statt  22,1) 
könnte das mal einer mit einer anderen Station verifizieren?

Da ich hier keine Datei anhängen kann, wie schon beim
letzten Post der Link auf mein github-fork

Grüsse
Luke

[LukeSky007]

Hallo zusammen,

ich habe die Hilfe ergänzt, die "statischen" Readings werden asyncron  zu Anfang eingelesen.
in der Update-Schleife werden "aktuelle" Werte, ID's und Rain Werte abgefragt.
Gruß
Luke

[miot]

Nur zur Info da ich gerade d'rüber gestolpert bin.
Ich habe gestern ein Firmware Update in meiner Ecowitt GW auf die Version GW1100A_V2.2.3 durchgeführt. Diese liefert Werte für ein Device mit der Kennung 0x7b, welches in der Auflistung des Moduls jedoch unbekannt ist. Daraufhin meldet das Modul beim Update 'GW1000_TCP: Item (0x7b) is unknown. Skipping complete package!'

Bedauerlicherweise wird damit im Code nicht nur das Datenpaket geskipped sondern durch ein nachfolgendes 'return 1' die Update Schleife terminiert was dazu führt, dass der interne Timer nicht mehr initialisiert wird. Damit erfolgt nach Erhalt eines Datenpaketes für ein unbekanntes Device kein GetUpdate mehr.

Viele Grüße
Michael

[LukeSky007]

Hallo miot,
vielen Dank für die Rückmeldung. Habe momentan noch die Version GW2000A_V2.2.0  installiert.
Leider gibt es auf der ecoWitt Seite keinen direkten Download der neuesten GW2000 Firmware - oder
hast Du da einen brauchbaren Link?
Momentan zeigt das Webinterface eine aktuelle Version V2.2.4 an - auf die ich auch updaten werde.
Hast Du ein älteres Gateway?  Weil beim  GW2001 WittBoy  ist ein GW2000A  mit bei (was ich benutze).
Ich mach mal das Gateway - Update auf 2.2.4 und schaue dann mal nach dem Item (0x7b).

Grüße
Luke

[LukeSky007]

Hallo zusammen,
nach dem Firmwareupdate auf 2.2.4  bekam ich auch die unbekannte Item-Id 0x7B in der Antwort auf das Kommando CMD_READ_RSTRAIN_TIME.
Habe die fehlenden ID's  von 0x7B bis 0x7F ergänzt.
Werde mal bei den ecoWitt Jungs nachfragen was diese Item's bedeuten.

Die neue Version habe ich auf meinem Fritz-NAS Onlinespeicher für Euch bereitgestellt, da das max. Anhang-Kontigent überschritten wäre.

@miot: bitte um Rückmeldung, ob das Problem bei Dir behoben ist.

Grüße Luke

[miot]

Hallo Luke,

das Problem hatte ich in dem Modul bei mir selbst behoben nachdem ich es entdeckt hatte und wollte nur einen Hinweis auf meine Entdeckung äußern.
Im Übrigen habe ich die Ecowitt Gateway GW1100 und nutze auch nur die dort vorhandene Firmware-Update-Funktion.

Viele Grüße
Michael

[minierm]

Der Temperaturwert  von der WS90 hat eine falsche Skalierung  (221,0  statt  22,1) 

Naja, falsche Skalierung...Was ein Programmierer halt tut, wenn man eine Nachkommastelle haben möchte aber Float scheut: Einfach auf Integer mappen

[Elektronikus]

Hallo Allerseits,

ich habe seit kurzem die WeatherScreenPro und möchte die gerne einbinden.
Vielen Dank für die 50_GW1000_TCP. Ich habe das Device definiert und es scheint auch zu connecten, aber dann passiert nichts mehr und ich sehe auch keine weiteren events:
2023-10-31 11:56:59 GW1000_TCP WeatherScreen test
Ich habe mal das Test Kommando ausgelöst, aber dann pasiert auch nichts.
Muss ich die WeatherScreenPro irgendwie konfigurieren?
Wenn ich mein Handy benutze zum Testen kommen Messages wie:
ffff1200... was ich so interpretiere, das die Wetterstation was sendet

[Elektronikus]

Hier meine Definition:

Code Auswählen Erweitern

define WeatherScreen GW1000_TCP 192.168.0.170 45000
attr WeatherScreen room KS300
#   DEF        192.168.0.170 45000
#   DevState   3
#   DeviceName 192.168.0.170:45000
#   FUUID      6540d137-f33f-bc07-fa0b-4a8d7f3fff580af6
#   I_GW1000_IP 192.168.0.170
#   I_GW1000_Port 45000
#   NAME       WeatherScreen
#   NOTIFYDEV  global
#   NR         231
#   NTFY_ORDER 50-WeatherScreen
#   STATE      opened
#   TYPE       GW1000_TCP
#   UpdateCmd  60
#   name       WeatherScreen
#   READINGS:
#     2023-10-31 11:36:56   state           opened
#
setstate WeatherScreen opened
setstate WeatherScreen 2023-10-31 11:36:56 state opened



[Elektronikus]

Das Modell ist die HP2550A, HW Version 2.0, Firmware Pro_V1.90, WiFi Firmware EasyWeather V1.6.6

Habe ich bei dem Modell eine Chance mit der GW1000_TCP Daten zu empfangen?

Schon mal vielen Dank

[Elektronikus]

Hallo Allerseits,
Ich habe jetzt ein kleines Python Program geschrieben, das die Daten der Wetterstation empfangen kann (Custom Setting der HP2550A) und schicke das dann über MQTT als JSON Struktur an FHEM

Vielleicht hilft das jemandem.

Viele Grüße
 
-----------
import nclib
import re
import paho.mqtt.client as mqtt
import json

# Define Regexp Filter
Tempsens =re.compile('^temp(.{0,2})f=(-?\d{1,2}\.\d*)$', re.IGNORECASE)
Humiditysens = re.compile('^humidit(y.{1,2}|y)=(\d{1,2})$', re.IGNORECASE)
Barosens = re.compile('^(.*)barom(rel|abs)(.{1,2})=(\d{1,2}\.\d*)$', re.IGNORECASE)
Winddirsens = re.compile('^wind(dir|dir_avg10m)=(\d{1,3}\.?\d?)$', re.IGNORECASE)
Windsens = re.compile('^wind(speed|spd)(mph|mph_avg10m)=(\d{1,3}.\d)$', re.IGNORECASE)
Gustsens = re.compile('^(wind|maxdaily)gus(t|tmph)=(\d{1,3}.\d)$')
Rainsens = re.compile('^(\D*)rain(ratein|in)=(\d{1,3}\.\d{3})$', re.IGNORECASE)
Solarsens = re.compile('^solarradiation=(\d{1,4}\.\d{1,3})$', re.IGNORECASE)
Batterystatus = re.compile('^(.*)batt(.{0,2})=(\d)$', re.IGNORECASE)
StationTimestamp = re.compile('^dateutc=(\d{4})-(\d{2})-(\d{2})\+(\d{2})\d{2})\d{2})$')
StationID = re.compile('^stationtype=(.*)$')
StationFrequency = re.compile('^freq=(\d{3})M$')
StationModel = re.compile('^model=(.*)$')

MQTT_HOST = 'Hier gehört die MQTT Serveradresse hin['
ACCESS_TOKEN = ''

client = mqtt.Client()
#client.on_connect = on_connect
#client.on_message = on_message


# Set access token
client.username_pw_set(ACCESS_TOKEN)

# Connect to Server using default MQTT port and 60 seconds keepalive interval
client.connect(MQTT_HOST, 1883, 600)

client.loop_start()

#------------------------------------------------------------------
# Read Weatherstation Message
#------------------------------------------------------------------
port = 46000
TCPserver = nclib.TCPServer(('0.0.0.0', int(port)))
for TCPclient in TCPserver:
    try:
      # if command was entered by the user
      # get output until dollar sign (bash --posix forces bash-X.X$)
      data = TCPclient.read_until('$')
      #print(data.decode('utf-8'), end="")  # print string of received bytes

    # handle exceptions and exiting
    except KeyboardInterrupt:
        print("\nKeyboardInterrupt")
        exit(1)
    except Exception as e:
        print("\nException Occurred\n")
        print(e)
        exit(1)
    datalines = data.decode('utf-8').split('&')
    print('\n')
    sensoren = {}
    for textelement in datalines:
        m = Tempsens.match(textelement)
        if m :
            print(f'temp{m[1]}C = {(float(m[2])-32.0)*5/9:.1f}°C')
            sensoren[f'temp{m[1]}C'] = f'{(float(m[2])-32.0)*5/9:.1f}'
           
        m = Barosens.match(textelement)
        if m :
            print (f'barom{m[1]}{m[2]}hPa = {29.262*33.86:.2f}hPa')
            sensoren[f'barom{m[1]}{m[2]}hPa'] = f'{29.262*33.86:.2f}'
           
        m = Humiditysens.match(textelement)
        if m :
            print(f'humidity{m[1][1:]}={m[2]}')
            sensoren[f'humidity{m[1][1:]}'] = f'{m[2]}'
           
        m = Winddirsens.match(textelement)
        if m :
            print (f'wind{m[1]} = {float(m[2]):.1f}°')
            sensoren[f'wind{m[1]}'] = f'{float(m[2]):.1f}'
           
        m = Windsens.match(textelement)
        if m :
            print (f'wind{m[1]}kmh{m[2][3:]} = {1.609344 * float(m[3]):.1f} km/h')
            sensoren[f'wind{m[1]}kmh{m[2][3:]}'] = f'{1.609344 * float(m[3]):.1f}'
           
        m = Gustsens.match(textelement)
        if m:
            print(f'{m[1]}gust{m[2][1:-3]} = {1.609344 * float(m[3]):.1f} km/h')
            sensoren[f'{m[1]}gust{m[2][1:-3]}kmh'] = f'{1.609344 * float(m[3]):.1f}'
           
        m = Rainsens.match(textelement)
        if m :
            print(f'{m[1]}rain{m[2][:-2]}mm = {float(m[3])*25.4:.1f} mm')
            sensoren[f'{m[1]}rain{m[2][:-2]}mm'] = f'{float(m[3])*25.4:.1f}'
           
        m = Solarsens.match(textelement)
        if m :
            print(f'solarradiation = {float(m[1]):.1f}')
            sensoren[f'solarradiation'] = f'{float(m[1]):.1f}'
           
        m = Batterystatus.match(textelement)
        if m :
            print(f'batt{m[1]+m[2]}={m[3]}')
            sensoren[f'batt{m[1]+m[2]}'] = f'{m[3]}'
           
        m = StationTimestamp.match(textelement)
        if m :
            print(f'StationTimestamp = {m[3]}.{m[2]}.{m[1]} {m[4]}:{m[5]}:{m[6]}')
            sensoren[f'StationTimestamp'] = f'{m[1]}-{m[2]}-{m[3]} {m[4]}:{m[5]}:{m[6]}'
           
        m = StationID.match(textelement)
        if m:
            print(f'StationID = {m[1]}')
            sensoren[f'StationID'] = f'{m[1]}'
           
        m = StationFrequency.match(textelement)
        if m:
            print(f'StationFreq = {m[1]} MHz')
            sensoren[f'StationFreqM'] = f'{m[1]}'
           
        m = StationModel.match(textelement)
        if m:
            print(f'StationModel = {m[1]}')
            sensoren[f'StationModel'] = f'{m[1]}'
           

    #------------------------------------------------------------------
    # Publish Weatherstation Message
    #------------------------------------------------------------------
    client.publish('tele/WeatherScreen/data', json.dumps(sensoren), 1)

    #break
   
#------------------------------------------------------------------
# MQTT aufräumen
#------------------------------------------------------------------

client.loop_stop()
client.disconnect()
TCPserver.close()
print("Disconnected ")
print('\n')

   

[JoWiemann]

Hallo Allerseits,
Ich habe jetzt ein kleines Python Program geschrieben, das die Daten der Wetterstation empfangen kann (Custom Setting der HP2550A) und schicke das dann über MQTT als JSON Struktur an FHEM

Vielleicht hilft das jemandem.

Viele Grüße
   

Hallo,

klammere doch bitte den Code in Code Tags.

Grüße Jörg

[Elektronikus]

Code Auswählen Erweitern

# -*- coding:utf-8 -*-
import nclib
import re
import paho.mqtt.client as mqtt
import json
import time

# Define Regexp Filter
Tempsens =re.compile('^temp(.{0,2})f=(-?\d{1,2}\.\d*)$', re.IGNORECASE)
Humiditysens = re.compile('^humidit(y.{1,2}|y)=(\d{1,2})$', re.IGNORECASE)
Barosens = re.compile('^(.*)barom(rel|abs)(.{1,2})=(\d{1,2}\.\d*)$', re.IGNORECASE)
Winddirsens = re.compile('^wind(dir|dir_avg10m)=(\d{1,3}\.?\d?)$', re.IGNORECASE)
Windsens = re.compile('^wind(speed|spd)(mph|mph_avg10m)=(\d{1,3}.\d)$', re.IGNORECASE)
Gustsens = re.compile('^(wind|maxdaily)gus(t|tmph)=(\d{1,3}.\d)$')
Rainsens = re.compile('^(\D*)rain(ratein|in)=(\d{1,3}\.\d{3})$', re.IGNORECASE)
Solarsens = re.compile('^solarradiation=(\d{1,4}\.\d{1,3})$', re.IGNORECASE)
Batterystatus = re.compile('^(.*)batt(.{0,2})=(\d)$', re.IGNORECASE)
StationTimestamp = re.compile('^dateutc=(\d{4})-(\d{2})-(\d{2})\+(\d{2}):(\d{2}):(\d{2})$')
StationID = re.compile('^stationtype=(.*)$')
StationFrequency = re.compile('^freq=(\d{3})M$')
StationModel = re.compile('^model=(.*)$')

MQTT_HOST = 'ehinger-server'
ACCESS_TOKEN = ''

#time.sleep(120)

client = mqtt.Client()
#client.on_connect = on_connect
#client.on_message = on_message


# Set access token
client.username_pw_set(ACCESS_TOKEN)

# Connect to Server using default MQTT port and 60 seconds keepalive interval
client.connect(MQTT_HOST, 1883, 600)

client.loop_start()

#------------------------------------------------------------------
# Read Weatherstation Message
#------------------------------------------------------------------
port = 46000
TCPserver = nclib.TCPServer(('0.0.0.0', int(port)))

for TCPclient in TCPserver:
    try:
       # if command was entered by the user
       # get output until dollar sign (bash --posix forces bash-X.X$)
       data = TCPclient.read_until('$')
       #print(data.decode('utf-8'), end="")  # print string of received bytes

    # handle exceptions and exiting
    except KeyboardInterrupt:
        print("\nKeyboardInterrupt")
        exit(1)
    except Exception as e:
        print("\nException Occurred\n")
        print(e)
        exit(1)
    datalines = data.decode('utf-8').split('&')
    sensoren = {}
    for textelement in datalines:
        m = Tempsens.match(textelement)
        if m :
            sensoren[f'temp{m[1]}C'] = f'{(float(m[2])-32.0)*5/9:.1f}'
            continue

        m = Humiditysens.match(textelement)
        if m :
            sensoren[f'humidity{m[1][1:]}'] = f'{m[2]}'
            continue

        m = Batterystatus.match(textelement)
        if m :
            sensoren[f'batt{m[1]+m[2]}'] = f'{m[3]}'
            continue

        m = Winddirsens.match(textelement)
        if m :
            sensoren[f'wind{m[1]}'] = f'{float(m[2]):.1f}'
            continue

        m = Windsens.match(textelement)
        if m :
            sensoren[f'wind{m[1]}kmh{m[2][3:]}'] = f'{1.609344 * float(m[3]):.1f}'
            continue

        m = Gustsens.match(textelement)
        if m:
            sensoren[f'{m[1]}gust{m[2][1:-3]}kmh'] = f'{1.609344 * float(m[3]):.1f}'
            continue

        m = Rainsens.match(textelement)
        if m :
            sensoren[f'{m[1]}rain{m[2][:-2]}mm'] = f'{float(m[3])*25.4:.1f}'
            continue

        m = Barosens.match(textelement)
        if m :
            sensoren[f'barom{m[1]}{m[2]}hPa'] = f'{float(m[4])*33.86:.2f}'
            continue

        m = Solarsens.match(textelement)
        if m :
            sensoren[f'solarradiation'] = f'{float(m[1]):.1f}'
            continue

        m = StationTimestamp.match(textelement)
        if m :
            sensoren[f'StationTimestamp'] = f'{m[1]}-{m[2]}-{m[3]} {m[4]}:{m[5]}:{m[6]}'
            continue

        m = StationID.match(textelement)
        if m:
            sensoren[f'StationID'] = f'{m[1]}'
            continue

        m = StationFrequency.match(textelement)
        if m:
            sensoren[f'StationFreqM'] = f'{m[1]}'
            continue

        m = StationModel.match(textelement)
        if m:
            sensoren[f'StationModel'] = f'{m[1]}'
           

    #------------------------------------------------------------------
    # Publish Weatherstation Message
    #------------------------------------------------------------------
    client.publish('tele/WeatherScreen/data', json.dumps(sensoren), 1)

    #break
   
#------------------------------------------------------------------
# MQTT aufräumen
#------------------------------------------------------------------

client.loop_stop()
client.disconnect()
TCPserver.close()
print("Disconnected :-)")
print('\n')





[Elektronikus]

Anbindung einer dnt WeatherScreen PRO an FHEM

Mein Modell ist die HP2550A, HW Version 2.0, Firmware Pro_V1.90, WiFi Firmware EasyWeather V1.6.6

Ich habe FHEM auf einem Raspi4 und einen mosquitto MQTT server für meine Heimautomatisierung verwendet.

Ziel war es, alle Daten lokal zu handhaben. Deswegen konnte ich auch die Implementierten Server nicht verwenden.
Dankenswerterweise kann die WeatherScreen PRO aber einen fremden Server ansprechen und dort habe ich meinen Raspi4 eingetragen.

Als Gegenstelle musste ich jetzt noch einen Server aufsetzen, der die Daten empfängt und für FHEM aufbereitet.

Als Dateinamen habe ich Read_WeatherScreen_Pro.py verwendet:
Bitte noch <hier den Namen des MQTT Servers eintragen> durch den richtigen Namen ersetzen

Code Auswählen Erweitern

# -*- coding:utf-8 -*-
import nclib
import re
import paho.mqtt.client as mqtt
import json
import time

# Define Regexp Filter
Tempsens =re.compile('^temp(.{0,2})f=(-?\d{1,2}\.\d*)$', re.IGNORECASE)
Humiditysens = re.compile('^humidit(y.{1,2}|y)=(\d{1,2})$', re.IGNORECASE)
Barosens = re.compile('^(.*)barom(rel|abs)(.{1,2})=(\d{1,2}\.\d*)$', re.IGNORECASE)
Winddirsens = re.compile('^wind(dir|dir_avg10m)=(\d{1,3}\.?\d?)$', re.IGNORECASE)
Windsens = re.compile('^wind(speed|spd)(mph|mph_avg10m)=(\d{1,3}.\d)$', re.IGNORECASE)
Gustsens = re.compile('^(wind|maxdaily)gus(t|tmph)=(\d{1,3}.\d)$')
Rainsens = re.compile('^(\D*)rain(ratein|in)=(\d{1,3}\.\d{3})$', re.IGNORECASE)
Solarsens = re.compile('^solarradiation=(\d{1,4}\.\d{1,3})$', re.IGNORECASE)
Batterystatus = re.compile('^(.*)batt(.{0,2})=(\d)$', re.IGNORECASE)
StationTimestamp = re.compile('^dateutc=(\d{4})-(\d{2})-(\d{2})\+(\d{2}):(\d{2}):(\d{2})$')
StationID = re.compile('^stationtype=(.*)$')
StationFrequency = re.compile('^freq=(\d{3})M$')
StationModel = re.compile('^model=(.*)$')

MQTT_HOST = '<hier den Namen des MQTT Servers eintragen >'
ACCESS_TOKEN = ''

#time.sleep(120)

client = mqtt.Client()
#client.on_connect = on_connect
#client.on_message = on_message


# Set access token
client.username_pw_set(ACCESS_TOKEN)

# Connect to Server using default MQTT port and 60 seconds keepalive interval
client.connect(MQTT_HOST, 1883, 600)

client.loop_start()

#------------------------------------------------------------------
# Read Weatherstation Message
#------------------------------------------------------------------
port = 46000
TCPserver = nclib.TCPServer(('0.0.0.0', int(port)))

for TCPclient in TCPserver:
    try:
       # if command was entered by the user
       # get output until dollar sign (bash --posix forces bash-X.X$)
       data = TCPclient.read_until('$')
       #print(data.decode('utf-8'), end="")  # print string of received bytes

    # handle exceptions and exiting
    except KeyboardInterrupt:
        print("\nKeyboardInterrupt")
        exit(1)
    except Exception as e:
        print("\nException Occurred\n")
        print(e)
        exit(1)
    datalines = data.decode('utf-8').split('&')
    sensoren = {}
    for textelement in datalines:
        m = Tempsens.match(textelement)
        if m :
            sensoren[f'temp{m[1]}C'] = f'{(float(m[2])-32.0)*5/9:.1f}'
            continue

        m = Humiditysens.match(textelement)
        if m :
            sensoren[f'humidity{m[1][1:]}'] = f'{m[2]}'
            continue

        m = Batterystatus.match(textelement)
        if m :
            sensoren[f'batt{m[1]+m[2]}'] = f'{m[3]}'
            continue

        m = Winddirsens.match(textelement)
        if m :
            sensoren[f'wind{m[1]}'] = f'{float(m[2]):.1f}'
            continue

        m = Windsens.match(textelement)
        if m :
            sensoren[f'wind{m[1]}kmh{m[2][3:]}'] = f'{1.609344 * float(m[3]):.1f}'
            continue

        m = Gustsens.match(textelement)
        if m:
            sensoren[f'{m[1]}gust{m[2][1:-3]}kmh'] = f'{1.609344 * float(m[3]):.1f}'
            continue

        m = Rainsens.match(textelement)
        if m :
            sensoren[f'{m[1]}rain{m[2][:-2]}mm'] = f'{float(m[3])*25.4:.1f}'
            continue

        m = Barosens.match(textelement)
        if m :
            sensoren[f'barom{m[1]}{m[2]}hPa'] = f'{float(m[4])*33.86:.2f}'
            continue

        m = Solarsens.match(textelement)
        if m :
            sensoren[f'solarradiation'] = f'{float(m[1]):.1f}'
            continue

        m = StationTimestamp.match(textelement)
        if m :
            sensoren[f'StationTimestamp'] = f'{m[1]}-{m[2]}-{m[3]} {m[4]}:{m[5]}:{m[6]}'
            continue

        m = StationID.match(textelement)
        if m:
            sensoren[f'StationID'] = f'{m[1]}'
            continue

        m = StationFrequency.match(textelement)
        if m:
            sensoren[f'StationFreqM'] = f'{m[1]}'
            continue

        m = StationModel.match(textelement)
        if m:
            sensoren[f'StationModel'] = f'{m[1]}'


    #------------------------------------------------------------------
    # Publish Weatherstation Message
    #------------------------------------------------------------------
    client.publish('tele/WeatherScreen/data', json.dumps(sensoren), 1)

    #break

#------------------------------------------------------------------
# MQTT aufräumen
#------------------------------------------------------------------

client.loop_stop()
client.disconnect()
TCPserver.close()
print("Disconnected :-)")
print('\n')
unter /home/pi/Read_WeatherScreen_Pro.py



Dann einen Service mit dem Namen Wetterstation.service anlegen:

Code Auswählen Erweitern

[Unit]
Description=Oeffnet Port 46000, wartet auf Messages und sendet diese an MQTT
After=anzeige.service

[Service]
ExecStart=/usr/bin/python3 -u /home/pi/Read_WeatherScreen_Pro.py
WorkingDirectory=/home/pi/myscript
StandardOutput=inherit
StandardError=inherit
RestartSec=5s
Restart=always
User=pi

[Install]
WantedBy=multi-user.target

und mit

Code Auswählen Erweitern

sudo cp ./Wetterstation.service /lib/systemd/system/ ins richtige Verzeichnis kopieren.

Starten kann man das Ganze dann mit

Code Auswählen Erweitern

sudo systemctl start Wetterstation.servicetesten mit

Code Auswählen Erweitern

sudo systemctl status Wetterstation.serviceund dauerhaft verankern mit

Code Auswählen Erweitern

sudo systemctl enable Wetterstation.service