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.

[cclN_php]
$windrichtung=$json_ergebnis->Windrichtung;

// hier kann die weitere Verarbeitung der Daten erfolgen…
?>
[/cclN_php]

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)

<?php
//*************************
// Uebergebene Daten des
// ESP-Aufrufes auslesen
//*************************
$windgeschwindigkeit=$_GET["windgeschwindigkeit"];
$windgeschwindigkeit=$windgeschwindigkeit/10*3.6;
$windrichtung=$_GET["windrichtung"];
$boe=$_GET["boe"];
$boe=$boe/10*3.6;
$vcc=$_GET["vcc"];

//*************************
// Werte in Datei schreiben
//*************************
$datum = date("d.m.Y H:i");
$handle = fopen ('tmp/wind.txt', 'a');
fwrite ($handle, $datum.",".$windgeschwindigkeit.",".$windrichtung.",".$boe.",".$vcc."\n");
fclose ($handle);
?>

Hier nun das Programm für den ESP8266

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

#include <ESP8266WiFi.h>
#include <WiFiManager.h>

#define DEBUG true

// WLAN Zugangsdaten
const char* ssid      = "<ssid_eingeben>";
const char* password  = "<passwort_eingeben>";
// Host wo Daten hingesendet werden soll
const char* datahost  = "<ip_des_hosts>";

unsigned long previousMillis = 0;
const long interval = 600000; // 600000ms = 10 Minuten 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;
// Zaehlerfür Mittelwert
int counter=0;
long summe=0;
float mittelw=0;
String mittelw2string = "";

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


// Verbindung zum WLAN aufbauen
void verbinden() {
  if(DEBUG) {
    delay(10);
    Serial.println("");
    Serial.print(F("Verbinde zu WLAN-Netzwerk '"));
    Serial.print(ssid);
    Serial.print("' ");
  }
  WiFi.begin(ssid, password);
  
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
  }
 
  if(DEBUG) {
    Serial.println(F("-> Verbunden"));  
    Serial.print(F("IP-Adresse: "));
    Serial.print(WiFi.localIP());
    Serial.println("");
  }
  //sendData();
}


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


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<<1)|(pin^1);
    } else
    if (bitcount > 41-5-4){
      // wind dir, inverted
      sb = sb>>1 | ((pin^1)<<3);
    } else
    if (bitcount > 41-5-4-12){
      // windspeed, inverted
      sc = sc>>1 | ((pin^1)<<11);
    } else
    if (bitcount > 41-5-4-12-4){
      // checksum, inverted
      sd = sd>>1 | ((pin^1)<<3);
    } else 
    if (bitcount > 41-5-4-12-4-4){
      // wind dir
      se = se>>1 | (pin<<3);
    } else {
      // windspeed
      sf = sf>>1 | (pin<<11);
    } 
        
    delayMicroseconds(1200);    
  }
  chk= ( sb + (sc&0xf) + ((sc>>4)&0xf) + ((sc>>8)&0xf) );chk&=0xf;
  delayMicroseconds(2000);
  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);
      
    sprintf(a, "Pruefsumme: %d\t%d\n", sd, chk);
    Serial.write (a);
    if (validData){
      Serial.println("OK");
    } else {
      Serial.println("Fehler");
    }
    Serial.println("");

  }  

  unsigned long currentMillis = millis();   
  if(currentMillis - previousMillis >= interval) 
  {
    previousMillis = currentMillis;
    sendData();
    counter=0;
    summe=0;
    boe=0;
  }
  
}


// Verbindung zu Host herstellen und Sensordaten übermitteln
void sendData() 
{
  Serial.println("");
  Serial.print(F("Verbinde zu '"));
  Serial.print(datahost);
  Serial.print("'");
   
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(datahost, httpPort)) {
    Serial.println(F(" Fehler beim Verbinden zum Host"));
    return;
  }

  // Batteriespannung auslesen
  float vcc = ESP.getVcc() / 1000.0;

 
  String url = "/umwelt/windsensor.php";
  url += "?windgeschwindigkeit=";
  url += mittelw2string;
  url += "&windrichtung=";
  url += sb;
  url += "&boe=";
  url += boe;
  url += "&vcc=";
  url += vcc;

  Serial.println("");
  Serial.print("URL-Anfrage: ");
  Serial.println(url);
   
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + datahost + "\r\n" + 
               "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println("[Client Timeout]");
      client.stop();
      return;
    }
  }
   
  // Lese alle Daten aus der Antwort des Servers
  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."));
}

Altes Script:

#include <ESP8266WiFi.h>
#include <WiFiManager.h>


// WLAN Zugangsdaten
const char* ssid      = "<ssid>";
const char* password  = "<passwort>";
// Host wo Daten hingesendet werden soll
const char* datahost  = "<ip_des_hosts>";


unsigned long previousMillis = 0;  
//const long interval = 30000;       // 30sek Interval beim Senden
const long interval = 60000;       // 1min Interval beim Senden


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;
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();

  Serial.println("Los geht es...");
  Serial.println();

  WiFiManager wifiManager;

  // AP deaktivieren
  WiFi.softAPdisconnect();
  WiFi.disconnect();
  WiFi.mode(WIFI_STA);
  delay(100);
  
  Serial.print("Verbindung zu... ");
  Serial.println(ssid);  
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi verbunden");
  server.begin();
  Serial.println("Server gestartet");
  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<<1)|(pin^1);
      } else
      if (bitcount > 41-5-4){
        // wind dir, inverted
        sb = sb>>1 | ((pin^1)<<3);
      } else
      if (bitcount > 41-5-4-12){
        // windspeed, inverted
        sc = sc>>1 | ((pin^1)<<11);
      } else
      if (bitcount > 41-5-4-12-4){
        // checksum, inverted
        sd = sd>>1 | ((pin^1)<<3);
      } else 
      if (bitcount > 41-5-4-12-4-4){
        // wind dir
        se = se>>1 | (pin<<3);
      } else {
        // windspeed
        sf = sf>>1 | (pin<<11);
      } 
          
      delayMicroseconds(1200);    
    }
    chk= ( sb + (sc&0xf) + ((sc>>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;
    }

    // ############################################################
    // Mittelwertberechnung 
    // Durchschnittliche 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);


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


    // Pruefen ob sich ein Client verbunden hat
    WiFiClient client = server.available();
    if (!client) {
      return;
    }
    
    // Warten bis der Client Daten sendet
    Serial.println("neuer Client");
    while(!client.available()){
      delay(1);
    }

    // Lese die erste Zeile der Anfrage
    String req = client.readStringUntil('\r');
    Serial.println(req);
    client.flush();

    // WIFI Signalstaerke auslesen
    long rssi = WiFi.RSSI();
    Serial.print("RSSI:");
    Serial.println(rssi);

    // Batteriespannung auslesen
    float vcc = ESP.getVcc() / 1000.0;


    // Webseite aufrufen um Sensordaten zu übergeben
    unsigned long currentMillis = millis();  
    if(currentMillis - previousMillis >= interval && sc >= 5000) 
    {
      previousMillis = currentMillis;
      sendData();
    }

    
    // Anfrage beantworten
    int val;
    String content;
    if (req.indexOf("/json") != -1) {
      // Sensordaten als JSON zurueck liefern
      // http://<url_zum_esp>/json
      Serial.println("JSON");
      content = "HTTP/1.1 200 OK\r\nContent-Type: application/json\r\n\r\n";
      content += "{\"Windgeschwindigkeit\":";
      content += sc;
      content += ",\"Mittelwert\":";
      content += mittelw2string;
      content += ",\"Boe\":";
      content += boe;
      content += ",\"Windrichtung\":";
      content += sb;
      content += "}\n";
    } else {
      // Sensordaten als Webseite anzeigen
      Serial.println("HTML");
      content = "HTTP/1.1 200 OK\r\nContent-Type: text/html\r\n\r\n<!DOCTYPE HTML>\r\n<html><head><title>Windsensor</title></head><body style=\"font-family:verdana;\">\r\n";
      content += "<p style='font-size:18px;font-weight:bold;'>Windsensor</p><br>";
      content += "<table>";
      content += "<tr><td>Windgeschwindigkeit (aktuell)</td><td>";
      content += sc;
      content += "</td></tr><tr><td>Windgeschwindigkeit (Mittelwert)</td><td>";
      content += mittelw2string;
      content += "</td></tr><tr><td>Windgeschwindigkeit (Boe)</td><td>";
      content += boe;
      content += "</td></tr><tr><td>Windrichtung</td><td>";
      content += sb;
      content += "</td></tr>";
      content += "<tr><td><br></td><td></td></tr>";
      content += "<tr><td>WIFI-Signal</td><td>";
      content += rssi;
      content += " dBm</td>";
      content += "<tr><td>Signal Qualit&auml;t</td><td>";
      content += 2 * (rssi + 100);
      content += "%</td></tr>";
      content += "<tr><td>Batteriespannung</td><td>";
      content += vcc;
      content += " V</td></tr>";
      content += "</table>";
      content += "</body></html>\n";
    }
   
    // Senden der Antwort zum Webserver
    client.print(content);
    delay(1);
    Serial.println("Client Verbindung beendet");
    
  }
  
}

// Verbindung zu Server herstellen und Sensordaten übermitteln
void sendData() 
{
  
  if ( WiFi.status() != WL_CONNECTED ) {
    Serial.println ("kein connect –> reconnect");
  
    Serial.print("Verbinden zu ");
    Serial.println(ssid);
    WiFi.begin(ssid, password);
    while (WiFi.status() != WL_CONNECTED) {
      WiFi.hostname("ESP-wind");
      delay(500);
      Serial.print(".");
    }
  }


  
  Serial.println("");
  Serial.print(F("Verbinde zu '"));
  Serial.print(datahost);
  Serial.print("'");
   
  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(datahost, httpPort)) {
    Serial.println(F(" Fehler beim verbinden zum Host"));
    return;
  }
 
  String url = "/umwelt/windsensor.php";
  url += "?windgeschwindigkeit=";
  url += sc;
  url += "&windrichtung=";
  url += sb;
 
  Serial.print("URL-Anfrage: ");
  Serial.println(url);
   
  client.print(String("GET ") + url + " HTTP/1.1\r\n" +
               "Host: " + datahost + "\r\n" + 
               "Connection: close\r\n\r\n");
  unsigned long timeout = millis();
  while (client.available() == 0) {
    if (millis() - timeout > 5000) {
      Serial.println("[Client Timeout]");
      client.stop();
      return;
    }
  }
   
  // Read all the lines of the reply from server and print them to Serial
  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."));
}

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

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