Kleine Probleme

Einzig meine gewohnte Freiluftverdrahtung mit einem Gummi der den Reedkontakt am Zähler festhält (der die Klebeband-Halterung ablöste) wurde regelmäßig porös und der Reedkontakt fiel runter. Meistens merkte ich das erst Tage später. Da ich mir Ende letzten Jahres einen 3D-Drucker angeschafft habe, wollte ich bei diesem Projekt mein erstes ordentliches Gehäuse für meine Sensoren erstellen wo mal nichts irgendwo einfach nur herum baumelt.

Bei Makerworld, Printables & Co gibt es sehr viele fertige Modelle für entsprechende Halterungen. Danke an die kreativen Designer! Manche sind für den NodeMCU inklusive Reedkontakt, manche für einen Wemos D1 inklusive Reedkontakt und manche nur für verschiedene Reedkontakte alleine. Ich habe ein Gehäuse für beides gesucht. Nachdem ich ein passendes Model gefunden und ausgedruckt hatte, ging es an die Montage. Die meisten dieser fertig designten Gehäuse nutzen einen axialen Reedkontakt. Diese haben meistens nur einen simplen Glaskörper. Hier war schon mein erstes Problem das diese Glasreeds echt empfindlich sind wenn man mal an den Beinchen biegt. Ich bin wahrscheinlich zu grobmotorisch aber sie sind ja billig…

Das größere Problem war aber, dass diese Reedkontakte nicht oder unzuverlässig anziehen wenn der Magnet des Zählers vorbei kommt da dieser recht schwach ist (Stichwort Anzugsempfindlichkeit). Auch hundertmaliges Ausrichten in der Öffnung des Zählers, Ausrichten des Reedkontaktes parallel zum Magneten, testen verschiedene andere Reedkontakte (aus zylinderförmig eingegossene Exemplare) etc. war nicht zielführend und raubte mir den letzten Nerv weil alles ja schon mal gut funktionierte. Nur mein alter Meder MK471 funktionierte zuverlässig.

Das neue Gehäuse

Der MK471 passt aber in fast alle fertigen Gehäusedesigns nicht rein. Und die wenigen Gehäuse die den MK471 beherbergen können, passten nicht an meinen Gaszähler. Also hab ich mir ein schönes Gehäuse für den Wemos D1 Mini als Basis gesucht und mit FreeCad (ich komme mit dem 3D-Drucker eh nicht drumherum das zu lernen) entsprechende Anpassungen gemacht damit anstatt einem axialen Reedkontakt der MK471 rein passt. Das war nicht wirklich schwer und sehr viel Mühe hab ich auch nicht rein gesteckt. Die STL-Datei muss in Freecad einen Festkörper gewandelt werden und danach einfach die Aufnahme für den axialen Reedkontakt mittels „Pocket“ mit einem passenden Rechteck aus dem Sketch „durchbohrt“. Da klemmt sich der MK471 jetzt ohne Probleme fest.

Neue Softwareversion

Neben dem Gehäuse hab ich dann doch noch ein bisschen den Quellcode erneuert. Ich musste ja noch die LED die im Gehäuse vorgesehen ist einprogrammieren. Bisher blinke nur die interne LED des Mikrocontrollers. Aber die sieht man ja im Gehäuse nicht mehr. Dazu gab es noch ein paar andere kleine Korrekturen und Verbesserungen. Die LED muss mit Vorwiderstand an D3, der Reedkontakt bleibt wie gehabt an D4 wo jetzt per Software auch der interne Pullup aktiviert wird. Einen Plan für die Verdrahtung hab ich dafür hier nicht gemacht.

Aber wirklich schlecht implementiert hatte ich das Senden der Impulse an den MQTT-Server. Hier hatte ich bei jedem Impuls eine neue Verbindung zum Server geöffnet und dann das Publish gesendet. Das dauerte gefühlt immer ewig und war auch der Grund warum in der Vergangenheit der ein oder andere Impuls in Richtung MQTT verschluckt wurde.

Der neue Ansatz baut nun einmal bei Start die Verbindung zum MQTT auf, prüft im Loop ob diese Verbindung noch besteht und macht ggf. ein Reconnect. Bei einem Impuls durch den Reedkontakt wird dann nur noch der Impuls per Publish an den MQTT-Server gesendet. Viel besser

Den aktuellen Quellcode für die Version 1008 inkl. vorkompiliertem Binary gibt es wie immer auf Github:

https://github.com/diefenbecker/opengasmeter

Viel Spaß damit
Gruß Chris

In den Einstellungen des Sensors gibt es daher nun die Möglichkeit das entsprechend zu konfigurieren zu können.

Zudem hatte ich noch in geistiger Umnachtung, den Namen/IP des Rechners, den Port und den Endpunkt zum Aufruf der eigenen API hart mit einer internen URL von mir verdrahtet. Immerhin hatte ich mir einen Kommentar im Quellcode geschrieben, dass das noch geändert werden muss. Hat nix geholfen, ist aber jetzt auch korrigiert.

Hier die aktuelle bin-Datei in der Version 1006:

http://www.bubux.de/heimautomatisierung/ota/gaszaehler_aktuell.bin

Für die Installation, weitere Erklärungen etc. gilt noch die Beschreibung aus dem ursprünglichen Artikel. Zudem der Artikel zum Auswerten der Impulse in Grafana.

Gruß Chris

Offensichtlich waren aber die dunklen Wintermonate bei einigen Leuten Ansporn, um ihre Heimautomatisierung und Sensorik zu überarbeiten. Es gab viele Einträge im Blog und ich bekam viele Anfragen per Mail bzgl. des Time Of Flight-Sensor VL53L0X als möglicher Ersatz des Ultraschallsensors HC-SR04. Ich hatte ja auch bei der Version 1028 nach fleißigen Testern und Rückmeldungen gefragt. Vielen Dank euch dafür! Das hat mich auch motiviert mal wieder was an dieser Front zu tun.

Auch wenn mein Ultraschallsensor für seine 2,50€ seit 3 Jahren tadellos seine Arbeit in der Zisterne verrichtet und ich bisher keine Notwendigkeit sehe diesen zu ersetzen, habe ich mir einen weiteren Sensor zu Testzwecken beschafft und in die Software implementiert. Ergebnis ist die Version 1029 der Software.

Neben dem ToF VL53L0X kann nun auch der VL53L1X angeschlossen und genutzt werden. Zu den Unterschieden der beiden Sensoren findet man einiges im Internet. Welcher Sensor nun im jeweiligen Anwendungsfall die bessere Wahl ist, muss jeder selber herausfinden bzw. freue ich mich auch wieder auf Rückmeldungen im Blog oder per Mail bzgl. eurer Erfahrungen.

Zu den beiden ToF-Sensoren nur ganz kurz folgende Zeichnung bzgl. der Öffnungskegel in Abhängigkeit zum Messabstand. Dazu aber noch weiter unten ein bisschen mehr Details da es anscheinend bei den möglichen Abständen etc. nicht verallgemeinert werden kann, welcher Sensor die bessere Wahl ist. Ich habe dazu auch (bisher) keine Tests gemacht!

Der Anschluss des VL53L1X erfolgt analog des VL53L0X. Die notwendigen PINs zum Anschluss sind u.a. in der Applikation angegeben. Hier aber nochmal schnell das Anschlussschema für die beiden ToF-Sensoren.

Die Version 1029 unterstützt weiterhin den Ultraschallsensor sowie die Displays und den Temperatursensor. Für das komplette Anschluss-Schema schaut bitte in den älteren Blog-Eintrag hier.

Die beiden ToF-Sensoren unterstützen seitens der API noch verschiedene Einstellungen die ich in der ersten Version 1028 nicht implementiert hatte und für den VL53L0X nur die Nutzung der Default-Einstellungen möglich war. In der neuen Version habe ich im ersten Anlauf zumindest ein paar wenige Einstellungsmöglichkeiten implementiert.

Dazu gehört für beide ToF-Sensoren die Möglichkeit den Abstandsmodus anzupassen. Hier holt man auch aus dem VL53L0X noch mehr heraus als im Datenblatt angegeben ist und muss bei größeren Abständen nicht zwingend auf den VL53L1X wechseln. Zudem habe ich beim VL53LoX noch die mögliche Anpassung des Timings implementiert. Hier kann zwischen dem Default-Wert auch noch High-Accuracy (hohe Genauigkeit) und High-Speed gewählt werden. Auch hier gibt es anscheinend kein Patentrezept um gute Messwerte zu erreichen und ausprobieren scheint die Devise.

Da ich diese Werte im „Setup“ setze, ist nach Änderung in der WebUI ein Neustart des Sensors notwendig damit die neu eingstellten Werte greifen. Beim VL53L1X muss man den ESP auch ggf. mal vom Strom trennen. Der scheint da etwas zickig was ich auch schon erfahren musste als es nur seltsame Werte bei der Messung gab.

Die weiteren Einstellmöglichkeiten des VL53L1X muss ich mir noch genauer anschauen und implementiere sie dann ggf. in einem nächsten Update. Hier gibt es z.B. noch die Möglichkeit zur Anpassung des Timings (ähnlich dem VL53L0X was ich dort bereits implementiert habe), die Anpassung der Größe des Empfangs-Arrays (SPAD) sowie der Anpassung der Region of Interest (ROI) und Definition eines Offsets. Mit diesen Parametern kann man u.a. „spielen“, falls der Sensor hinter eine Glasscheibe verbannt werden soll.

Den Download der neuesten Version gibt es hier:

http://www.bubux.de/heimautomatisierung/ota/zisterne_aktuell.bin

Gruß Chris

Meine Implementierung ist schon etwas älter und auch mit der Zeit gewachsen. Da es sich bei dieser Webseite um ein recht überschaubares Projekt handelt und ich mit dem Ergebnis zufrieden bin, habe ich mir nie die Mühe gemacht die Seite generischer zu gestalten. Daher muss bei nötigen Anpassungen der Code direkt geändert werden und es gibt auch keine Trennung von HTML und PHP, keine durchgehende allumfassende Fehlerbehandlung, evtl. „unschönes“ HTML usw.

Der Code soll als Anregung und Grundlage für eine eigene Seite dienen…nicht mehr, nicht weniger. Wem´s ausreicht kann es natürlich auch 1:1 übernehmen. Positiv an meiner Lösung finde ich immer noch die Flexibilität in den Auswertungen die direkt auf der Datenbank mittels SQL ausgeführt werden können.

Die Startseite

Die Startseite wird mittels „Meta-Refresh“ alle 180 Sekunden neu geladen und dient der Übersicht der wichtigsten Sensordaten. Mit Klick auf die (verlinkten) Boxen gelangt man jeweils zu einer detaillierteren Übersicht der Sensordaten. In der Übersicht werden keine komplizierten Datenbankauswertungen gemacht. Hier werden die Snapshot-Tabellen mit den aktuellen Werten ausgelesen und einige SQL-Aggregat-Funktionen genutzt. Das ging auch auf einem alten Raspi einigermaßen schnell. Das hängt natürlich von den Tabellengrößen in den Datenbanken ab. Da bei mir einige Tabellen mit den Jahren relativ groß geworden sind (~500k Zeilen), bin ich irgendwann auf einen Odroid umgestiegen.

Übersicht der Außentemperaturen

Die Übersicht der Außentemperatur wird aus den Daten des Außenfühlers der Viessmann-Heizung generiert. Die Übersichten für anderen Sensoren sehen analog dieser Ansicht aus.

Die Übersicht der Heizungsdaten

Die Übersicht der Heizungsdaten stellt verschiedene Daten dar die mittels openv aus der Heizung ausgelesen werden. Aktuell lese ich mit openv nur aus und setze keine Werte (z.B. Sommer-/Winterumschaltung).

Voraussetzung und Grundlagen

Details zum Auslesen der verschiedenen Sensordaten findet ihr in vorangegangenen Artikeln hier im Blog:

• Viessmann Heizung mittels openv auslesen
• M-Bus Wasserzähler auslesen
• Gaszähler mit Reed auslesen
• Stromzähler mit optischem Lesekopf auslesen

Die Webseite liest die Datenbanken des Wasserzähler, des Gaszählers, der Heizung und des Stromzählers aus. Folgend nochmal eine Übersicht der Tabellenstrukturen welche auch in den Artikel oben zu finden sind. In MySQL (bzw. MariaDB) habe ich zwei Datenbanken angelegt (vito, haus) mit verschiedenen Tabellen.

Die Tabellen der Datenbank „vito“:

 CREATE TABLE `brenner` (
 `timestamp` datetime NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `brennerstatus` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
 ) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `snapshot` (
 `timestamp` datetime NOT NULL,
 `brennerstatus` float NOT NULL,
 `brennerstarts` float NOT NULL,
 `brennerstunden` float NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `aussentemperatur` float NOT NULL,
 `warmwasser` float NOT NULL,
 `speicher_unten` float NOT NULL,
 `kollektor` float NOT NULL,
 `kesseltemperatur` float NOT NULL,
 `vorlauftemperaturM2` float NOT NULL,
 `vorlaufsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturM1` float NOT NULL,
 `raumsolltemperaturM2` float NOT NULL,
 `raumsolltemperaturredM1` float NOT NULL,
 `raumsolltemperaturredM2` float NOT NULL,
 `warmwassersoll` float NOT NULL,
 `kesseltemperatursoll` float NOT NULL,
 `pumpestatusM1` float NOT NULL,
 `pumpestatusSP` float NOT NULL,
 `pumpestatussolar` float NOT NULL,
 `statusstoerung` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `systemzeit` varchar(100) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `error0` varchar(500) CHARACTER SET latin1 COLLATE latin1_german1_ci NOT NULL,
 `BetriebArt` varchar(20) NOT NULL,
 `BetriebArtM2` varchar(20) NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `solar` (
 `timestamp` datetime NOT NULL,
 `solarstunden` float NOT NULL,
 `solarleistung` float NOT NULL,
 `solarpumpe` int(11) NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `temperaturen` (
 `timestamp` datetime NOT NULL,
 `aussentemperatur` float NOT NULL,
 `warmwasser` float NOT NULL,
 `speicher_unten` float NOT NULL,
 `kollektor` float NOT NULL,
 `vorlaufsolltemperaturM2` float NOT NULL,
 KEY `timestamp` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

Die Tabellen der Datenbank „haus“:

CREATE TABLE `gaszaehler` (
 `timestamp` datetime NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `stromzaehler` (
 `timestamp` datetime NOT NULL,
 `public_key` varchar(100) NOT NULL,
 `zaehlerstand` float DEFAULT NULL,
 `active_power` float NOT NULL,
 KEY `strom_index` (`timestamp`)
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `strom_snapshot` (
 `zeitstempel` date NOT NULL,
 `zaehlerstand` float NOT NULL,
 `wirkleistung` float NOT NULL,
 `aktuelles_jahr` float NOT NULL,
 `aktueller_monat` float NOT NULL,
 `aktueller_tag` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `wasserzaehler` (
 `timestamp` datetime NOT NULL,
 `zaehlerid` int(11) NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

CREATE TABLE `wasser_snapshot` (
 `timestamp` date NOT NULL,
 `zaehlerstand` float NOT NULL
) ENGINE=InnoDB DEFAULT CHARSET=latin1

„Installation“

Einen funktionierenden Webserver (z.B. Apache) mit PHP und eine MySQL oder MariaDB vorausgesetzt, muss das unten verlinkte tar.gz in ein beliebiges Verzeichnis im www-Verzeichnis des Webservers entpackt werden.

Das funktioniert mit 

tar -xvzf webseite_sensordaten.tar.gz

Konfiguration

In der Datei config.inc müssen ein paar wenige Einstellungen vorgenommen werden. Folgende Einstellungen werden für die Verbindung zur Datenbank benötigt:

$mysqlhost="<hostname>";
$mysqluser="<username>";
$mysqlpwd="<passwort>";
$mysqldbvito="<name_der_db_mit_den_vito_tabellen>";
$mysqldbhaus="<name_der_db_mit_den_haus_tabellen>";

Die folgenden Werte dienen der Auswertung des Gaszählers. Da dieser per Reed-Kontakt ausgelesen keinen Gesamtstand ausgibt und nur die einzelnen Impulse zählt, kann hier ein Startwert definiert. Auch die Werte zur Umrechnung von m³ in KW werden hier eingetragen. Diese Informationen gibt es beim Gaslieferanten.

Zudem kann noch definiert werden wie viel Tage in der Übersicht angezeigt werden sollen. Entsprechender Werte gibt es auch für den Wasserzähler und den Stromzähler.

$gas_startwert="2311650";
$brennwert_gas=10.097;
$zustandszahl_gas=0.9309;
$anz_tage_gas=7;

$anz_tage_wasser=7;

$anz_tage_strom=7;

Wichtiger und letzter Schritt: Das Verzeichnis „tmp“ muss schreibbar für den Webserver sein. Dort werden die generierten Graphen als PNG gespeichert. Das war es schon!

Fehlt nur noch das Paket mit den PHP-Seiten: webseite_sensordaten.tar.gz

Viel Spaß mit

Chris

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

Anschluss Windsensor
Gelb	Masse (GND)
Grün	Masse (DTR)
Rot	3,3V (Vcc)
Schwarz	GPIO_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

Einer der beiden Raspis soll nun dem neuen Odroid weichen. Dabei entschied ich mich für den zweiten Raspi, da die ganzen PHP-Scripte erstmal nicht anzupassen sind. Das scheint mir der meiste Aufwand zu werden.

Pi-Hole umziehen

Auch wenn „Pi“ im Namen steckt, läuft die Installation mit dem curl-Script auf den Odroid genauso problemlos wie auf dem Raspberry. Daher ist der Artikel über Pi-Hole auch für den Odroid soweit noch aktuell. Eine positive Anmerkung ist, das man neben den bereits vorkonfigurierten DNS-Servern aus der Installationsroutine, in der aktuellen Version von Pi-Hole jetzt auch die eigene Fritzbox als DNS in den Einstellungen der Pi-Hole-Oberfläche bequem eingeben kann. Damit entfällt die manuelle Anpassung in der Datei /etc/dnsmasq.d/01–pihole.conf.

Beim Aufbau der Pi-Hole-Oberfläche ist der Odroid auch spürbar schneller als der Raspberry Pi. Im Netz merkt man keinen Unterschied.

Das Script für den Gaszählers umziehen

Beim Gaszähler nutze ich ein Python-Script, welches die Schließimpulse eines Reed-Kontaktes mitzählt. Also einfach mal Pythonscript kopiert, gestartet und … Fehlermeldungen angeschaut! Das Python auf dem Odroid hat die von mir genutzte RPi.GIOP-Klasse angemeckert was auch verständlich ist. Auf dem Odroid muss das gegen WiringPi2 getauscht werden.

1. WiringPi 2 für Python installieren

git clone https://github.com/hardkernel/WiringPi2-Python.git
cd WiringPi2-Python
git submodule init
git submodule update

2. Bauen & Installieren

sudo python setup.py install

Das angepaßte Script zum Auslesen des Gaszählers schaut dann für den Odroid wie folgt aus:

[cc lang=“python“ tab_size=“2″ lines=“50″]
import wiringpi2 as wpi
import time
import MySQLdb
import sys

wpi.wiringPiSetupPhys()
# GPIO definieren
REED_gas = 21
# definierten GPIO als Eingang setzen
# 0 output, 1 input, 2 PWM mode
wpi.pinMode(REED_gas,0)

lt = time.localtime()
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“

logger = open(dateiname,“w“)
logger.write(„gestartet…“+“\n“)
logger.close()

status_alt=1
while True:
try:
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“
logger = open(dateiname,“a“)
status_aktuell = wpi.digitalRead(REED_gas)
# KONTAKT -> geoeffnet
if status_aktuell == 1:
#logger.write(„Kontakt offen“+“\n“)
status_alt=wpi.digitalRead(REED_gas)
# KONTAKT -> geschlossen
elif status_aktuell==0:
logger.write(„Kontakt geschlossen“+“\n“)
if status_alt!=status_aktuell:
logger.write(„Impuls“+“\n“ )
status_alt=wpi.digitalRead(REED_gas)
# Datenbankverbindung
db = MySQLdb.connect(host=““, user=““, passwd=““, db=““)
# Impuls in Datenbank eintragen
cursor = db.cursor()
cursor.execute(„““INSERT INTO gaszaehler (timestamp,zaehlerstand) VALUES (CURRENT_TIMESTAMP,1)“““)
db.commit()
cursor.close()
logger.close()
except:
e = sys.exc_info()[0]
dateiname=“gaszaehler_“+time.strftime(„%Y%m%d“,lt) +“.log“
logger = open(dateiname,“a“)
logger.write(„Es ist ein Fehler aufgetreten: %s“ % e)
logger.close()
time.sleep(1)
[/cc]

Neben WiringPi habe ich auch die Verbindung zur DB in die while-Schleife gepackt. Vorher wurde die Verbindung einmal am Anfang hergestellt und in der Schleife nur noch die Daten per Insert eingetragen. Es zeigt sich aber, das der Odroid oder die Datenbank die noch auf dem anderen Pi läuft die Verbindung nach einer Zeit kappt und es zu Fehlern kam. Auch das Logging habe ich etwas abgeändert, da während das while lief nur Blockweise wenn gerade Zeit war in die Datei geschrieben wurde. Das störte bei der Fehlersuche.

Hier auch nochmal die Pinbelegung des Odroid C2 und deren Zusammenhang mit den PinModes von WiringPi2:

Das war es schon für die Anpassungen des Scriptes für den Gaszähler. Bei diesem Script gibt es keine Performanceunterschiede im Vergleich wenn es auf dem Raspi lief.

Das Script für den Wasserzähler umziehen

Als nächstes kam der Wasserzähler mit M-BUS an die Reihe. Hier habe ich mir die Quellen in der Version 0.8.0 von rScada gezogen und anschliessend versucht diese zu bauen. Dies führte schon beim ./configure zu Fehlermeldungen. Die Quellen waren zu alt und konnten die Prozessorarchitektur des Odroid (ARM) nicht ermitteln. Um das zu beheben benötigt man aktuelle Versionen der Dateien config.guess und config.sub. Diese sind unter den beiden folgenden Links zu finden.

http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess;hb=HEAD

http://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub;hb=HEAD

Die beiden Dateien einfach gegen die bereit vorhanden ersetzen und ./configure läuft durch. make und make install laufen dann auch fehlerfrei durch wie im Artikel beschrieben.

Die Pins zum zum Anschluss des M-BUS-Master (Tx & Rx) sind gleich belegt wie auf dem Raspberry.

Die Scripte von rScada funktionieren identisch wie vorher. Mit mbus-serial-scan wurde der Wasserzähler auf fehlerfrei erkannt. Leider scheiterte anschliessend der Versuch mit mbus–serial–request–data die Daten aus dem vorher erkannten Zähler auszulesen. Nahc den ersten ausgelesenen Bytes verabschiedete sich mbus–serial–request–data mit einem Segmentation Fault. In den Systemlogs war nicht wirklich rauszufinden warum dem so ist. Nach ein kurzer Analyse dachte ich ein Versuch mit der vorherigen Version 0.7.0 kann nicht schaden. Damit tat es dann auch fehlerfrei. Was nun genau das Problem des Segfaults war, weiß ich nicht. Die Unterschiede zur Version 0.8.0 sind auch anscheinend nicht relevant da alles wie gewünscht funktioniert.

Soviel zu den ersten beiden „Umzügen“. Fehlen noch der DVB-S Empfänger mit tvheadend und dann geht´s schon an die Dinge die aktuell noch auf dem anderen Raspberry Pi laufen.

Gruß

Chris

Die Tage habe ich ein neues Spielzeug bekommen (nein, nicht zu Weihnachten). Es ist ein Odroid C2 mit eMMC-Speicherkarte. Den gab es im Komplettpaket mit Odroid, eMMC, Gehäuse und Netzteil für 70€. Der Odroid besitzt einen Quad-Core mit 1,5 GHz, 2 GB RAM und ein Gigabit-LAN welches er sich, im Gegensatz zur Raspberry-Architektur, nicht mit den USB-Ports teilen muss. Somit sollte die Gesamtleistung in allen Belangen deutlich höher ausfallen als die des Raspberry 2 oder 3. Auf der eMMC war ein Ubuntu 16.04 LTS mit Mate Desktop vorinstalliert.

Schneller Test versus schlampige Programmierung

Ein erster schneller Test sollte die Geschwindigkeitsmessung bei der Anzeige meiner Intranet-Seite für die mitgeloggten Daten (Temperaturen, Gasverbrauch, Stromverbrauch, …) sein. Die Tabellen sind in den letzten 3 Jahren teilweise doch recht groß geworden und der Raspberry 2 tut sich mit der Anzeige der ein oder anderen Auswertung merklich schwer. Zum Beispiel dauert die Abfrage des wöchentlichen Wasserverbrauches rund 38 Sekunden…nichts für ungeduldige Gemüter.

Also MySQL, Apache und PHP installiert. Dabei ließ sich MySQL nach der Installation nicht starten. Da scheint es einen bekannten Fehler zu geben. Ich habe mich dann einen halben Tag mit Versuchen rumgeschlagen es ans laufen zu bekommen. Letztendlich habe ich mich dann geschlagen gegeben und MariaDB installiert. MariaDB funktionierte auf Anhieb inkl. des Datenimportes der Daten aus der MySQL-Datenbank des Raspberrys. Die Installation von Apache und PHP 7 funktionierte auf Anhieb. Dann die PHP-Scripte auf den Odroid kopiert, einen Browser geöffnet und … nichts gesehen außer einer weißen Seite. Nach kurzem Blick in das Apache-Log dann die Ernüchterung: Einfach die Scripte kopieren ist nicht, da ich in der Vergangenheit schlampig programmiert hatte. So unterstützt PHP 7 unter anderem nur noch MySQLi (i wie improved). So hatte ich mir das nicht vorgestellt, aber es ist ein guter Anlass um den kompletten Code zu überarbeiten. Und ein Downgrade auf PHP 5.x ist wohl auch keine Alternative mehr.

Code-Korrektur

Um trotzdem die Geschwindigkeit testen zu können, habe ich die Seite zur Anzeige des wöchentlichen Wasserverbrauches PHP 7-tauglich gemacht. In dieser Seite wird eine kleine Datenbanktabelle mit ~ 700 Zeilen ausgelesen (den Wasserzähler habe ich noch nicht so lange). Die beiden SQL-Statements die im Script verwendet werden sehen folgendermaßen aus:

Folgendes Select liest den Gesamtzählerstand aus:

SELECT zaehlerstand FROM wasserzaehler

Das etwas länglichere Select liest den Verbrauch der letzten 7 Tage, gruppiert nach Wochentag, aus:

SELECT
CASE DATE_FORMAT(wz1.timestamp,'%w')
WHEN 0 THEN 'Sonntag'
WHEN 1 THEN 'Montag'
WHEN 2 THEN 'Dienstag'
WHEN 3 THEN 'Mittwoch'
WHEN 4 THEN 'Donnerstag'
WHEN 5 THEN 'Freitag'
WHEN 6 THEN 'Samstag'
ELSE 'fehler' END,
wz1.zaehlerstand - IFNULL(wz2.zaehlerstand, 0) AS verbrauch
FROM wasserzaehler wz1
LEFT JOIN wasserzaehler wz2
ON wz2.timestamp = (
SELECT MAX(timestamp) FROM wasserzaehler wz3 WHERE wz3.timestamp < wz1.timestamp
)
WHERE DATE(wz1.timestamp) >= DATE_SUB(NOW(),INTERVAL 7 DAY) GROUP BY day(wz1.timestamp)
ORDER BY wz1.timestamp";

Das Ergebnis ist eine Übersicht des Gesamtverbrauch und des Wasserverbrauches der letzten 7 Tage:

Warpgeschwindigkeit

Der Raspberry 2 benötigt bis zur Anzeige dieser Seite geschlagene 38 Sekunden. Der Odroid etwas mehr als 1 Sekunde! Diesen eklatanten Geschwindigkeitsunterschied hätte ich nicht erwartet. Allerdings weiß ich auch nicht, was den Raspberry bei der Auswertung dieser kleinen Tabelle genau überfordert. Es ist jedenfalls mal ein dicker Pluspunkt für den Odroid. Mal sehen wie er sich mit den anderen Abfragen schlägt sobald ich die restlichen PHP-Scripte angepasst habe.

Das wird allerdings neben der PHP-Problematik noch ein steiniger Weg werden, da ich die komplette FHEM-Implementierung irgendwie vom Raspberry auf den Odroid bekommen muss. Problem ist dabei wahrscheinlich weniger FHEM selber, sondern die COC-Hardware die auf den GPIOs des Raspberry sitzt und die GPIOs des Raspberry nicht kompatibel mit denen des Odroid sind. Dazu aber mehr, wenn es soweit ist.

Nebenbei habe ich bei dieser Gelegenheit auch noch kurz den Leistungsmesser dazwischen gehangen. Im Leerlauf (die Abfrage des Wasserzählers kann man nicht als mehr bezeichnen) konsumiert der Odroid etwa 3 Watt.

Gruß Chris

Nochmal zur Erinnerung: Ich speichere jede gezählte Umdrehung des Gaszählers als separate Zeile in einer MySQL-Datenbank.

Daher müssen die einzelnen Zeilen nach den jeweiligen Kriterien gruppiert und dann das Ergebnis der Spalte „zaehlerstand“ summiert werden. Beim Stromzähler wird hingegen immer der aktuelle Gesamtverbrauch in die Datenbank geschrieben und aus den Datenbankeinträgen für die Tages-, Monats- und Jahresverbräuche die Differenz gebildet um entsprechende Auswertungen zu erzeugen.

Auswertung der letzten 12 Monate

Folgendes SQL-Statement ermittelt aus den einzelnen Datenbankeinträgen die Summe gruppiert nach Jahr und Monat. Dabei werden die letzten 12 Monate mittels „INTERVAL“ betrachtet.

SELECT
     CASE DATE_FORMAT(timestamp,'%m')
          WHEN 1 THEN 'Jan'
          WHEN 2 THEN 'Feb'
          WHEN 3 THEN 'Mär'
          WHEN 4 THEN 'Apr'
          WHEN 5 THEN 'Mai'
          WHEN 6 THEN 'Jun'
          WHEN 7 THEN 'Jul'
          WHEN 8 THEN 'Aug'
          WHEN 9 THEN 'Sep'
          WHEN 10 THEN 'Okt'
          WHEN 11 THEN 'Nov'
          WHEN 12 THEN 'Dez'
     ELSE 'fehler' END as Monat,
     year(timestamp), sum(zaehlerstand)
FROM gaszaehler WHERE year(timestamp) >= YEAR(CURRENT_DATE - INTERVAL 12 MONTH) AND  month(timestamp) >= month(CURRENT_DATE - INTERVAL 12 MONTH)
GROUP BY month(timestamp), year(timestamp) ORDER BY timestamp;

Auswertung der Jahresverbräuche

Fehlt noch der jährliche Verbrauch. Das SQL-Statement ist einfacher aufgebaut als vorheriges und summiert den Verbrauch pro Jahr für alle in der Datenbank enthaltenen Daten an.

SELECT 
     year(timestamp), sum(zaehlerstand) 
FROM gaszaehler
GROUP BY year(timestamp) ORDER BY timestamp;

Im Ergebnis sieht das Ganze dann wie folgt aus. Die Grafik zur Anzeige der Daten der letzten 12 Monate erstelle ich wie in diesem Artikel beschrieben

Viel Spaß bei der Kontrolle des Gasverbrauchs

Gruß

Chris

Über Sinn und Unsinn bei der Heimautomatisierung kann man ja vortrefflich diskutieren. Wenn für das Aufwecken des Tablet/Handy, dem Öffnen der App oder Intranet-Seite und anschliessendem Klick auf „Licht Wohnzimmer an“ mehr Zeit benötigt wird als den Lichtschalter an der Wand zu betätigen, ist man meistens schon am Ziel der (intelligenten) Hausautomation vorbei geschossen…

Die Abbrandsteuerung selber ist unabhängig von der eigentlichen Hydraulik zum Anschluss des Kachelofens an den Warmwasserspeicher. Hier nutzen wir eine Steuerung der Fa. ÖkoCentro mit einer SHR 10-Steuerung von EnergieControl. Aber auch diese hat keine mir bekannte Schnittstelle die man einfach abfragen kann.

Als eine einfache Möglichkeit zumindest schon mal die Vorlauf- und Rücklauftemperatur zu messen, dachte ich an 1-Wire Temperatursensoren der Firma DALLAS (DS18B20). Diese sind günstig (z.B. 1,85€ bei Reichelt) und einfach am Raspberry PI zu implementieren. Die Vorbereitungen zur Nutzung der 1-Wire Sensoren ist nicht aufwändig und schnell passiert.

Sollen die 1-wire Sensoren nur parasitär versorgt werden, folgendes in der Shell eingeben um das entsprechende Kernelmodul zu laden:

sudo modprobe w1-gpio

oder wenn ein Pullup zur externen Stromversorgung genutzt wird, folgendes Kommando:

sudo modprobe w1-gpio pullup=1

Sollen Temperaturen über 70°C gemessen werden, wird zwecks der Genauigkeit der Sensoren die zusätzliche Stromversorgung mittels Pullup-Widerstand angeraten.
Mehr zum Thema Anschlussarten gibt es z.B. hier.

Unabhängig ob Pull-Up oder nicht wird noch ein weiteres Kernelmodul benötigt:

sudo modprobe w1-therm

Ab der Kernelversion 3.18.3 muss noch eine Anpassung gemacht werden. Die Kernelversion wird wie folgt bestimmt:

uname -r

Ist die Kernelversion > 3.18.3 muss in der Datei

/boot/config.txt

folgende Zeile eingefügt werden

# activating 1-wire with pullup
dtoverlay=w1-gpio-pullup

Ich habe die Sensoren mit separater Versorgung am Raspberry Pi angeschlossen. Wie das funktioniert, ist im Internet in verschiedensten Foren etc. zu lesen. Ich hatte mal eine kleine Platine rs232_raspi.fzz mit einem MAX3232 für eine RS232-Schnittstelle für das M-Bus-Projekt in Fritzing aufgebaut. Da hat auch noch der eine 4.7K Widerstand und eine Steckerleiste für 1-wire drauf gepaßt (oben Links zu sehen).

Sind die Kernelmodule geladen, alle Konfigurationen gemacht und alles angeschlossen, sollten die 1-wire Sensoren nach einem Neustart des Raspberry PI unter

cd /sys/bus/w1/devices

auftauchen.

Die Sensoren werden z.B. per „cat“ mit folgendem Befehl ausgelesen

cat 28-000005db9cea/w1_slave

Das Ergebnis sollte dann ähnlich wie folgt aussehen:

08 03 4b 46 7f ff 08 10 9e : crc=9e YES
08 03 4b 46 7f ff 08 10 9e t=48500

Die Temperatur wird hinter dem „t=“ in der zweiten Zeile ausgegeben. Um diese Temperatur z.B. mit PHP abzufragen und für weitere Verarbeitung nutzen zu können, folgendes PHP-Code-Schnipsel

[cc lang=“php“]

[/cc]

Die Temperatur schreibe ich dann per Script, welches 10-minütig per Cron aufgerufen wird, in eine MySQL-Datenbank und stelle das Ergebnis in einer Webseite dar.

Soviel zum Thema 1-wire. Die größere Herausforderung wird es aber, an die Werte der EAS heran zu kommen. Diese sind in soweit auch interessanter, als das diese Steuerung den Abbrand überwacht und informiert ob das Feuer heiß genug ist (>450°C) um den geregelten Abbrand zu starten, zu heiß (>750°C) und eine Gewisse Panik zu erzeugen, der Abbrand beendet ist und Holz nach gelegt werden könnte oder die Türe des Kachlofens nicht richtig geschlossen ist.

Ein Anfang ist aber gemacht und die EAS eine neue Herausforderung.

Gruß
Chris