Windsensor TX20 mit ESP8266

Update am 28.05.2018 (Rot gekennzeichnet)

Heute nochmal was zum Thema Hausautomatisierung bzw. Messung von Umweltdaten.

Von Homematic gibt es eine komplette Wetterstation die wahrscheinlich ohne größeres Zutun in meine bestehende FHEM-Installation integriert werden kann. Allerdings ist das Ding recht teuer und schaut dafür noch nach viel Plastik aus. Auf der Suche nach einem günstigeren Windsensor bin ich über den TechnoLine TX20 gestolpert (auch Plastik, aber weniger und preislich günstiger). Diesen gibt es ab 30€ im Netz. Allerdings ist der Sensor zum kabelgebundenen Anschluss an eine Wetterstation gedacht (z.B. WS 2300, WS 2307, WS 2350).

Ich wollte meinen zukünftigen Windsensor aber irgendwie kabellos in meine bestehende Infrastruktur integrieren, entweder per Funk oder per WLAN. Da ich noch ein paar ESP8266 von der letzten China-Bestellung im Keller liegen hatte, habe ich mich auf die Suche nach der Anbindung des TX20 Windsensors an den ESP8266 gemacht. Im ersten Schritt half die folgende Webseite wo der Kollege aus Neuseeland viel Arbeit in die Auswertung des Kommunikationsprotokoll des TX20 gesteckt hat:

La Crosse TX20 Anemometer Communication Protocol

Die Integration des oben herausgefundenen Protokolls des TX20 für den ESP8266 ist auf folgender Webseite zu finden: http://fabrizio.zellini.org/decoding-la-crosse-tx20-anemometer-with-arduino. Das Beispielscript von dieser Seite kann man direkt mittels Arduino IDE auf den ESP8266 laden. Wie das funktioniert und was sonst noch so beim ESP zu beachten ist, findet man unter anderem in diesem Heise-Artikel.

In dem Beispielscript fehlte für meine Zwecke nur noch die WLAN-Funktionalität und eine komfortable Möglichkeit an die Messdaten für die weitere Nutzung zu gelangen. Das unten stehende angepasste Script ermöglicht beides. Aber zuerst ein paar Worte über die Anpassungen:

Integration von WLAN

Die Zugangsdaten für ein bestehendes WLAN werden fest im Code eingegeben. Der ESP verbindet sich mit diesem ein paar Sekunden nach Anschluss der Betriebsspannung. Die Konfiguration der WLAN-Zugangsdaten über einen vom ESP erstellten Access Point (AP) ist noch nicht implementiert (siehe Todo).

Zugriff auf Messdaten

Ich hatte drei Möglichkeiten zum Zugriff auf die Messdaten implementiert. Im Beispielscript sind alle Möglichkeiten aktiv. Das Script sollte also entsprechend des genutzten Zugriffes auf die Messdaten angepasst werden.

1. Webseite

Darstellung der Webseite nur im alten Script!

Zum einen stellt der ESP8266 nun eine einfache Webseite zur Verfügung. Neben der Windgeschwindigkeit und der Windrichtung werden auch noch verschiedene andere Daten des ESP8266 ausgelesen und dargestellt. Unter anderem auch die Betriebsspannung des Mikrocontrollers welche beim Betrieb mit Batterien auf deren Zustand zurück schließen lässt. Die Seite einfach im Webbrowser mittels IP oder Hostnamen des ESP8266 öffnen.

2. JSON

Implementierung von JSON nur im alten Script!

Um die Daten einfacher automatisiert weiter verarbeiten zu können, wird beim Anhängen von /json an die URL ein JSON-String zurück geliefert. Dieser schaut wie folgt aus:

{“Windgeschwindigkeit”:61,”Windrichtung”:2}

Mit PHP funktioniert das Auswerten des JSON-Strings wie folgt. Solch ein Script könnte z.B. zeitgesteuert per Cronjob aufgerufen werden und die extrahierten Daten in eine Datenbank schreiben oder anderweitig darauf reagieren.

<!--?php $json = file_get_contents('http://esp8266-windsensor/json'); $json_ergebnis=json_decode($json); $windgeschwindigkeit=$json_ergebnis-&gt;Windgeschwindigkeit;&lt;br ?--> $windrichtung=$json_ergebnis-&gt;Windrichtung;

// hier kann die weitere Verarbeitung der Daten erfolgen...
?&gt;

 

3. Scriptaufruf durch den ESP8266

Die beiden oberen Varianten bedürfen einen aktiven Aufruf durch einen Client (Webbrowser) oder den Aufruf der Webseite durch ein Script. Nachteil dieser Variante ist, das der ESP immer aktiv sein muss da er den Zeitpunkt der Abfrage nicht kennt. Um Strom zu sparen ist eine aktive Datenübermittlung durch den ESP vorteilhafter. D.h der ESP kann in definierten Intervallen messen, die Daten übermitteln und sich wieder schlafen legen. Die aktive Übermittlung der Daten wird durch den Aufruf einer Webseite (die auf einem Server hinterlegt ist) durch den ESP realisiert. Der entsprechende Host (Zeile 8) und URL (Zeile 235) sind im Programm für den ESP fest hinterlegt.

Hier ein beispielhaftes PHP-Script welches auf einem Webserver liegt und durch den ESP aufgerufen wird, die Daten auswertet und diese dann in eine Textdatei auf dem Server schreibt:

Update am 28.05.2018 (nur für neues ESP-Script mit Boe-Funktion)

 

Hier nun das Programm für den ESP8266

Update am 28.05.2018 mit Boe-Funktion und ohne eigene Webseite & ohne JSON

 

Altes Script:

 

Die vom Sensor ausgelesenen Werte müssen noch “konvertiert” werden. Auf der Seite von John ist eine entsprechende Tabelle zur Umwandlung der 15 nummerischen Werte für die Windrichtung in deren “Himmelsrichtungen”, als auch die Einheit der Windgeschwindigkeit zu finden.

Aufbau

Anstatt einer Freiluftverdrahtung habe ich diesmal eine kleine Platine zur Aufnahme des ESP, einer Steckerleiste für den FTDI (oder für den Batteriehalter) sowie den Anschluss des Windsensors gelötet. Aktuell hängt es noch an der “langen Leine” durchs geschlossene Fenster, später soll die Platine aber in ein Kistchen in die Nähe des Sensors. Der Jumper setzt den GPIO_0 zum programmieren des ESP auf Masse. WICHTIG: Das FTDI muss 3,3V unterstützen da der ESP keine 5V verträgt.

Das Ganze dann nochmal von unten…

…und der schematische Aufbau zum Anschluss des FTDI an den ESP

Der Anschluss des Windsensors ist wie folgt (den ursprünglichen Western-Stecker am Windsensor habe ich abgeschnitten):

Anschluss Windsensor 
GelbMasse (GND)
GrünMasse (DTR)
Rot3,3V (Vcc)
SchwarzGPIO_2 (TxD)

Ist der grüne Anschluss (DTR) auf Masse gelegt, sendet der Sensor alle zwei Sekunden Daten. Das kann bzgl. des Stromverbrauchs und dem Ansatz unter Punkt 3) evtl. noch auf einen GPIO des ESP gelegt werden.

Wofür das Ganze?

Weil es Spaß gemacht hat! Einen wirklichen Einsatz für den Windsensor habe ich noch nicht. Eigentlich war das nur die Gelegenheit, etwas mit dem ESP experimentieren zu können. Vielleicht steuere ich damit später mal die aktuell noch nicht vorhandene Markise oder ich weiß wie stark der Wind war, wenn nochmal unser Sonnenschirm von einer Windhose zerstückelt wird.

Probleme

  • Wenn die Betriebsspannung sinkt bzw. nicht genug Strom geliefert wird (z.B. beim Betrieb an Batterien), sind die Messdaten nicht korrekt (Prüfsumme falsch)

Todo

  • Sensor schlafen legen
  • Mit Batterieversorgung experimentieren
  • Update mittels OTA
  • WLAN-Konfig über Access Point (AP), dann Station (STA) einrichten
  • Konfiguration des URL zur aktiven Übergabe der Daten über Webseite

 

33 Gedanken zu „Windsensor TX20 mit ESP8266

  • 3. Juli 2017 um 20:44
    Permalink

    hallo,
    ich bin gerade durch deinen Heizungsbeitrag (Viesmann darstellung auf Website) auf diesen Projekt gestossen und vielen Dank für die Erläuterung!
    ich habe heute zufällig erstmals von dem ESP8266 gehört und gelesen (in anderem zusammenhang) und habe deshalb gleich drauf geklickt! 🙂

    ich möchte bei uns messen wie stark der Wind ist um herauszufinden ob es sich lohnt ein kleines Windrad aufzubauen, daher ist dein Ansatz sehr gut für mich (weil er kostengünstig und digital auswertbar ist).

    ich setze z.B. als Hausautomationsoberfläche “Openhab” ein, wo sich viele Geräte unter einer Oberfläche “zusammenfinden” können und per sogenannten Rules verarbeitet werden können.
    Dort gibt es auch eine REST-API, welches es ermöglicht externe Daten in die Variablen (ITEMS genannt) einspielen kann. Ich werde sobald möglich mal deinen Ansatz versuchen aufzunehmen und in mein Openhab zu bringen.

    Ich bin gerade dabei die Viessmann Heizung darein zu bringen…

    Also weiter so! 🙂
    Liebe Grüße

    Antwort
  • 8. Oktober 2017 um 18:45
    Permalink

    Hallo,
    ich nochmal…
    ich habe jetzt einen ESP8266 (D1 mini) und den TX20 da.
    Ich kam soweit das ich den Wemos D1 mini per Arduino (v 1.8.5) beschreiben kann (wie im Heise Beitrag konnte ich Blink Schreiben und ausführen).
    Aber wenn ich dein Script kompilieren möchte bricht er 3x ab mit den Fehler:
    error: expected ‘;’ before ‘Windgeschwindigkeit’
    Zeile 180: content += “{“Windgeschwindigkeit”:”;
    error: expected ‘;’ before ‘Windrichtung’
    Zeile 182: content += “,”Windrichtung”:”;
    error: expected ‘;’ before ‘font’
    Zeile 188: content = “HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n\r\nWindsensor\r\n”;

    Wenn ich die 3 Zeile mit // auskommentiere komme keine Fehler, er kompiliert und läd auch hoch, aber im D1 mini geschieht einfach nichts (ich sehe in der FritzBox keinen WLAN-Connect, beim einschalten blinkt kurz die LED)

    Ich komme nicht weiter, ggf. kannst du mir helfen?
    Im Kontakt habe ich meine E-Mailadresse eingetragen.
    Ich würde mich über eine kurze Nachricht freuen! 🙂
    Vielen Dank!

    Antwort
    • 12. Oktober 2017 um 16:43
      Permalink

      Oh man ,sorry… Anscheinend war mein WLAN Passwort einfach zu sicher wegen Sonderzeichen, testweise im Gäste WLAN mit niedrigstem Passwort standard angemeldet und schwups konnte sich der ESP verbinden und ich die Website aufrufen.
      Danke für die tolle Idee und Umsetzung! Super Projekt

      Antwort
      • 6. Dezember 2017 um 16:01
        Permalink

        hallo
        habe die gleichen fehlermeldungen wie oliver
        habe noch keinen windsensor dran
        im serial terminal sehe ich wifi connected und die ip
        kann die ip im browser nicht connecten
        benötige da einen tipp
        gruß
        meinolf

        Antwort
        • diefenbecker
          6. Dezember 2017 um 16:11
          Permalink

          Hallo Meinolf,

          vermutlich ist das Problem der fehlende Sensor. Im Code kommt irgendwann die “if (TX20IncomingData)”-Abfrage.
          D.h. dort wird nur reingesprungen wenn auch Daten vom Sensor kommen. Innerhalb dieser if-Abfrage wird die kleine Webseite zusammen gebaut und die Daten an den Client gesendet.

          Gruß
          Chris

          Antwort
  • 3. Januar 2018 um 12:15
    Permalink

    Hallo,

    vielen Dank für die Anleitung. Meine Basisstation ist leider defekt und so habe ich den Windsensor über.
    Ich habe ein NodeMCU V3 Board gekauft und die IDE von Arduino (V1.8.5) auf meinem Windows Rechner installiert. Wenn ich nun des Sketch kompilieren möchte, bekomme ich die Meldung, dass er die Bibliothek nicht finden kann.
    Woher bekomme ich diese Bibliothek?

    Grüße
    Markus

    Antwort
    • diefenbecker
      3. Januar 2018 um 16:33
      Permalink

      Hallo Markus,

      meinst Du die beiden Bibliotheken #include ESP8266WiFi.h und WiFiManager.h?
      Ui, das ist schon lange her wo ich die eingebunden habe…

      Das sollte aber hier -> https://github.com/tzapu/WiFiManager zu finden sein.
      Dort ist auch die Einbindung in die Arduino IDE erklärt.

      Gruß
      Chris

      Antwort
  • 5. Januar 2018 um 19:45
    Permalink

    Hallo
    läuft jetzt bei mir. Ich habe den sketch so erweitert das ich die durchschnittliche windgeschwindigkeit und die max geschwindigkeit ( also boe ) in 10 minuten ermittele.
    und alle 10 min schicke ich es zu einem raspi in eine mysql datenbank
    scheint bis jetzt stabil zu laufen

    danke für die Anregung

    Antwort
    • 5. Januar 2018 um 20:33
      Permalink

      Hallo, kannst du den Sketch mal zusenden? Danke!

      Antwort
      • 8. Januar 2018 um 19:13
        Permalink

        Ich übermittele an den raspi die momentane windgeswchwindigkeit, boe , windmittel, summe aller messwerte im interval , zahl der messungen, und richtung

        die summe und die zahl der messungen dienten mir zur überprüfung ob er richtig rechnet.
        könnt ihr ja rausschmeissen

        #include
        #include
        #include

        // WLAN Zugangsdaten
        const char* ssid = “xxxxxxxxxxxxxxx”;
        const char* password = “xxxxxxxxxxxxxxx”;
        // Host wo Daten hingesendet werden soll
        const char* datahost = “192.168.xxx.xxx”;

        unsigned long previousMillis = 0;
        const long interval = 600000; // 600000ms = 10 Minuten Intervall
        // const long interval = 300000; // 300000ms = 5 Minuten Intervall
        // const long interval = 60000; // 1min intervall

        WiFiServer server(80);
        ADC_MODE(ADC_VCC);

        const byte DATAPIN=2;
        volatile boolean TX20IncomingData = false;

        unsigned char chk;
        unsigned char sa,sb,sd,se;
        unsigned int sc,sf,pin;
        String tx20RawDataS = “”;

        int boe=0;
        // counter für mittelwert
        int counter=0;
        long summe=0;
        float mittelw=0;
        String mittelw2string = “” ;

        void isTX20Rising() {
        if (!TX20IncomingData) {
        TX20IncomingData = true;
        }
        }

        void setup() {
        boe=0;
        pinMode(DATAPIN, INPUT);
        attachInterrupt(digitalPinToInterrupt(DATAPIN), isTX20Rising, RISING);
        Serial.begin(115200);
        delay(10);

        Serial.println();
        Serial.println();

        WiFiManager wifiManager;

        // AP deaktivieren
        WiFi.softAPdisconnect();
        WiFi.disconnect();
        WiFi.mode(WIFI_STA);
        delay(100);

        Serial.print(“Connecting to “);
        Serial.println(ssid);
        WiFi.begin(ssid, password);
        while (WiFi.status() != WL_CONNECTED) {
        WiFi.hostname(“ESP-wind”);
        delay(500);
        Serial.print(“.”);
        }

        Serial.println(“”);
        Serial.println(“WiFi connected”);
        // server.begin();
        Serial.println(“Server started”);
        Serial.println(WiFi.localIP());
        }

        boolean readTX20() {
        int bitcount=0;

        sa=sb=sd=se=0;
        sc=0;sf=0;
        tx20RawDataS = “”;

        for (bitcount=41; bitcount>0; bitcount–) {
        pin = (digitalRead(DATAPIN));
        if (!pin) {
        tx20RawDataS += “1”;
        } else {
        tx20RawDataS += “0”;
        }
        if ((bitcount==41-4) || (bitcount==41-8) || (bitcount==41-20) || (bitcount==41-24) || (bitcount==41-28)) {
        tx20RawDataS += ” “;
        }
        if (bitcount > 41-5){
        // start, inverted
        sa = (sa< 41-5-4){
        // wind dir, inverted
        sb = sb>>1 | ((pin^1)< 41-5-4-12){
        // windspeed, inverted
        sc = sc>>1 | ((pin^1)< 41-5-4-12-4){
        // checksum, inverted
        sd = sd>>1 | ((pin^1)< 41-5-4-12-4-4){
        // wind dir
        se = se>>1 | (pin<>1 | (pin<>4)&0xf) + ((sc>>8)&0xf) );chk&=0xf;
        delayMicroseconds(2000); // just in case
        TX20IncomingData = false;

        if (sa==4 && sb==se && sc==sf && sd==chk){
        return true;
        } else {
        return false;
        }
        }

        void loop() {

        if (TX20IncomingData) {

        char a[90];
        boolean validData = readTX20();
        Serial.println(tx20RawDataS);
        sprintf(a, “ID: %d\t%d\n”, sa, B00100);
        Serial.write (a);
        sprintf(a, “Windrichtung: %d\t%d\n”, sb, se);
        Serial.write (a);
        sprintf(a, “Windgeschwindigkeit: %d\t%d\n”, sc, sf);
        Serial.write (a);

        // #################################################################
        // boe feststellen
        // speichert den maximalwert eines Messzyklus in der variablen boe
        // #################################################################
        if (sc>boe){
        boe=sc;
        }
        if (boe>1000){
        boe=0;
        }
        Serial.write(“Windboe= “);
        Serial.println(boe);

        // 4095 im eeprom ??
        if (sc>1000){
        sc=0;
        }

        // #####################################################
        // zur mittelwertberechnung
        // durchschnittlichen windgeschwindigkeit während des messzyklus
        // 8 messwerte pro minute
        // #####################################################
        counter = counter +1;
        Serial.write(“Messinterval= “);
        Serial.println(counter);
        summe=summe+sc;
        float mittelw = summe/counter;

        mittelw2string = String(mittelw);
        Serial.write(“summe aller Messwerte = “);
        Serial.println(summe);
        Serial.write(“Mittelwert= “);
        Serial.println(mittelw2string);

        // sendData();

        sprintf(a, “Pruefsumme: %d\t%d\n”, sd, chk);
        Serial.write (a);
        if (validData){
        Serial.println(“OK”);
        } else {
        Serial.println(“Fehler”);

        }
        Serial.println(“”);

        // #########################################################
        // “externe” Webseite aufrufen um Sensordaten zu übergeben
        // #####################################################
        // reconnect
        if ( WiFi.status() != WL_CONNECTED ) {
        Serial.println (“kein connect –> reconnect”);

        Serial.print(“Connecting to “);
        Serial.println(ssid);
        WiFi.begin(ssid, password);
        while (WiFi.status() != WL_CONNECTED) {
        WiFi.hostname(“ESP-wind”);
        delay(500);
        Serial.print(“.”);
        }

        }

        unsigned long currentMillis = millis();

        // ester übermittelter messwert = fehlerhaft sc = 4095

        if(currentMillis – previousMillis >= interval && sc 5000) {
        Serial.println(“[Client Timeout]”);
        client.stop();
        return;
        }
        }

        while(client.available()){
        String line = client.readStringUntil(‘\r’);
        Serial.print(line);
        }
        Serial.println(“”);
        Serial.print(F(“Verbindung zu ‘”));
        Serial.print(datahost);
        Serial.println(F(“‘ beendet.”));
        }

        Antwort
        • diefenbecker
          12. Januar 2018 um 16:21
          Permalink

          Hi Meinolf,

          vielen Dank für das Script. Werde es am Wochenende mal testen.

          Gruß
          Chris

          Antwort
    • diefenbecker
      5. Januar 2018 um 21:10
      Permalink

      Hallo Meinolf,

      schön zu hören das es jetzt funktioniert. Dein Idee mach absolut Sinn! Der aktuelle Wert sagt nicht wirklich was aus. Würdest Du deinen Sketch teilen?

      Gruß
      Chris

      Antwort
  • 8. Januar 2018 um 11:46
    Permalink

    Hallo Chris,
    klar kann ich das weitergeben. Muss ich erst noch den source entmüllen .
    Da steht noch jede Menge auskommentiertes unnützes Zeug drin.

    Meinolf

    Antwort
  • 8. Januar 2018 um 20:37
    Permalink

    Cool, werde ich morgen mal ausprobieren.
    Nur eine Frage, wie visualisierst du die Daten?
    Ich möchte die Werte auch in meine MySQL datenbank schreiben und dann her Highcharts visualiseren.
    Aber die Werte wie sie da rauskommen müssen ja erst mit einer Tabelle auf m/s umgerechnet werden bzw. auf Windrichtumg. Kann das nicht der ESP machen und dann nur die ‘umgerechneten’ Werte übertragen?
    (Macht doch Sinn oder?)

    Antwort
      • 17. Januar 2018 um 15:47
        Permalink

        Hallo Oliver
        das geht jetzt bei mir auch mit highcharts und der windrose.
        schick mir mal deine emailadresse . ich möchte den link nicht öffentlich machen
        gruß
        meinolf

        Antwort
    • 12. Januar 2018 um 13:09
      Permalink

      das kannst du auch im php script machen welches die daten in die mysql schreibt
      aber im prinzip kann das auch der esp. werden dann aber alles fliesskomma operationen.
      wenn du die umrechnung vor der übertragung auf den server vornimmst denke ich unproblematisch. in der messschleife .. weiss ich nicht
      visualisieren mache ich mit googlecharts .
      highcharts sieht auch toll aus. wenn du da resultate hast kannste dich mal melden

      meinolf

      Antwort
  • 5. Mai 2018 um 17:27
    Permalink

    hallo diefenbecker,
    Ich bin sehr von dem Thema Hausautomatisierung und Sensor Datenerfassung mittels dem esp8266 angesteckt worden. Jetzt bin ich gerade dabei eine Wetterstation aufzubauen. Habe da auch diese Anleitung durchgeführt. Du hast in deinem Text stehen dass du den Windsensor an der “langen Leine” liegen hattest. Heißt das dass du die komplette Länge des original Anschlusskabels verwendet hattest? Das habe ich nämlich so gemacht und ich bekomme keine Sensordaten. Ich dachte mir es könnte an der länger liegen. Im Netz steht das S bei one-wire Sensoren keine Längenbeschränkung geben soll. Somit möchte ich das ausschließen. Kann natürlich sein dass es auch ein Fehler im Sketch ist. Ich habe nämlich die ganzen Web Geschichten herausgenommen. Wäre für eine Antwort sehr dankbar.

    Antwort
    • 5. Mai 2018 um 17:28
      Permalink

      Entschuldigung ich muss mich korrigieren es gibt natürlich an der Längenbeschränkung bei one wire Sensoren. 150 Meter

      Antwort
    • diefenbecker
      8. Mai 2018 um 18:16
      Permalink

      Hallo,

      ich hab das original Kabel verwendet ohne zu kürzen (ausser das ich den Westernstecker kurz abgeschnitten habe).
      Schicke Dir mal einen neuen Sketch zum Testen…

      Gruß
      Chris

      Antwort
  • 28. Mai 2018 um 06:23
    Permalink

    Hi,
    besten Dank erst mal für die Arbeit. Ich versuche gerade, meinen TX 20 ans Laufen zu bekommen. Allerdings gab es schon beim übersetzen Schwierigkeiten.
    Meiner Meinung nach fehlen hier einige Backslashes – auch der Compiler ist dieser Meinung und gab folgerichtig Fehler aus. Ich gebe hier meine Korrekturen an, es sollte kein Problem sien die stellen im Code zu finden:

    content += “{\”Windgeschwindigkeit\”:”;

    content += “,\”Windrichtung\”:”;


    content = “HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n\r\nWindsensor\r\n”;

    Mich wundert, dass das noch keinem aufgefallen ist (vermutlich habe ich’s überlesen)…
    Ciao
    jürgen

    Antwort
    • diefenbecker
      28. Mai 2018 um 17:33
      Permalink

      Hallo Jürgen,

      gern geschehen und vielen Dank für die Spende. Habe mich sehr gefreut!
      Der Quellcode ist wahrscheinlich durch den Editor von WordPress zerhackt worden. Mit dem stehe ich Kriegsfuss.
      Ich habe das nochmal neu gemacht und dabei eine andere, aktuellere Version des Quellcodes eingestellt (und den Alten zusätzlich).
      Die neue Version basiert auf dem Eintrag von meinolf aus den Kommentaren.

      Gruß
      Chris

      Antwort
      • 28. Mai 2018 um 19:24
        Permalink

        Hi Chris,
        ich werde es morgen früh nochmal probieren. Ich habe allerdings noch andere Probleme (nach einiger Zeit hängt sich der ESP auf und nix geht mehr). Aber da muss ich erst mal etwas Forschung betreiben, um vernünftige Fehlermeldungen machen zu können.
        Ciao
        Jürgen

        Antwort
      • 29. Mai 2018 um 05:17
        Permalink

        Das Skript läuft jetzt seit 2 Stunden ohne Probleme. Super!
        Ich werde es jetzt für meine Zwecke anpassen. Wenn ich meine, es kommt was Interessantes für die Allgemeinheit heraus, schicke ich es Dir (z.B. eine “Beruhigungspille” für die Windrichtung in Form einer speziellen Mittelwertfunktion oder dgl.). Im Augenblick herrscht hier allerdings Windstille…

        Antwort
      • 29. Mai 2018 um 10:18
        Permalink

        So, einen hab ich noch: Die Werte für die Windrichtung waren bei mir sehr merkwürdig…
        Ich hatte noch im Hinterkopf, dass irgendwo im weiten Netz jemand die Verzögerungszeit von 1200 auf 1220 uSec geändert hatte und dass das Problem damit verschwand. So auch hier:
        delayMicroseconds(1200); –>> delayMicroseconds(1220);
        in der Funktion readTX20()

        und schon geht’s.
        Vielleicht ist das ein Wert den man weiter oben, gut sichtbar, konfigurierbar machen sollte. Ich bin mir nicht sicher , wovon der genaue Wert abhängig ist. Er scheint ja bei anderen mit 1200 uSec richtig gewesen zu sein.

        Ciao & Danke nochmal
        Jürgen

        Antwort
  • 3. Juni 2018 um 05:24
    Permalink

    Nee, hab noch einen 🙂
    In der Funktion sendData() wird beim Zusammenbau der URL sc für die Windrichtung verwendet. Meiner Meinung nach müsste dort sb verwendet werden.
    Der Fluch der bösen Tat… (glob. Variable) 🙂
    Ciao
    Jürgen

    Antwort
  • 12. August 2018 um 10:53
    Permalink

    Ich glaube ich komm da nicht ganz mit mit der ganzen Technik und Programmierung der Wetterstation. Ich dachte mir ich kauf einRaspberry undinstalliere das Betriebssystem Steck an gpio4 pin zb data TXD und häng ein 868 MHZ Funk empfängermodul drann. Dann Installiere ich Weewex. und lade die daten auf Weather Underground hoch. Aber es fängt ja schon bei der Python Programmierung und datenausgabe der Scrip t s an. Schde für die Investition und die Technoline Wetterstation. Werde Jetzt eine Wetterstation PCE FCS 20 anschaffen mit usb anschluß. Bei der bekomme ich das besser zum laufen. Oder Verkauft mir jemand die Micro SD Karte mit Fertiger Konfigurierter Software für mein PI und anleitung Trau mich fast nicht mehr was zufragen. Wenn mann davon keine ahnung hat sollte mann die finger weg lassen. Auch wenn mann gerne eine Eigene Wetterstation hätte.

    Antwort
    • 23. August 2018 um 15:25
      Permalink

      @Michael Schneider

      Hallo
      Das ganze ist ein Projekt um den ESP8266 Mikrocontroller – steht ja auch da oben. Was soll das ganze mit dem Raspberry Pi zu tun haben? Ich meine, man kann doch wenigstens mal lesen, oder? Und wenn man keinerlei Erfahrung und Ahnung von der Materie hat – Finger von lassen. Oder aber: lernen, wie es geht. Mach dich schlau über den ESP8266, kaufe dir ein Board damit und lerne mit Arduino IDE zu programmieren.

      Antwort
  • 11. September 2018 um 20:23
    Permalink

    Hallo Christopher,
    ich baue mir gerade eine eigene Wetterstation mit dem ESP12E (alias Lua Lolin V3). Das klappt soweit alles. Nun habe ich die o.g. Sites eingehend studiert und mir den zum La Crosse Aneometer kompatiblen Technoline TX20 gekauft. Jetzt stehe ich aber vor einem Problem. Ich habe alles so beschaltet wie bei jhon.geek.nz u.ä. angeheben und den Code von ihm zu Testzwecken auf den ESP geladen. Das Anemometer liefert auch die Windrichtung und der CRC ist immer OK, jedoch bleibt die Windgeschwindigkeit immer 0. Hast Du eine Idee, was das sein kann? Spannung am TX20 sind 3,3V und nicht 5. DataPin ist D6 und nicht D2. Auf D2 liegen bei mir die I2C-Sensoren.
    Über eine bloße Anregung würde ich mich schon freuen!
    Herzliche Grüße.
    Christian

    Antwort
  • 13. September 2018 um 18:20
    Permalink

    hi,
    super artikel, vielen dank! habs gleich nachgebaut und läuf, bin begeistert. bei mir sendet er die daten direkt an fhem.

    zwei fragen habe ich allerdings:
    1) bei mir ist valuddata immer false, trotzdem erscheinen die daten sinnvoll. validdata wird im skript ja auch nicht verwendet (vermurlich deswegen?). ist das bei euch auch der fall? woran liegt es?
    2) ich habe alle paar tage mal morgens ein ausreisser bei der boe (und nur bei dem wert). selbst bei windstille ist dann auf einmal ein wert mit 80 dazwischen. habt ihr das auch? ich weiss noch nicht, ob es falsche daten sind (check validdata wird ja nicht verwendet, könnte also theoretisch durch noise auf der leitung kommen, aber warum dann jr bei dem wert?) oder ob ein vogel gegen den sensor kommt oder so….

    Antwort

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.