NEWS


  • Hallo,

    hier mal eine kleine Projektvorstellung zur Verwendung von MQTT in Verbindung mit dem ESP8266 zur Realisierung von Sensorfunktionen.

    Meine Wahl fiel auf dem ESP8266 weil er von den Pins für meine Zwecke derzeit ausreicht und direkt ein WLAN-Modul ist.

    Bei der Programmierung für diesen Chip hatte ich anfänglich LUA verwendet, bin aber inzwischen vollständig auf die Arduino-IDE umgestiegen.

    Zu meinen kleinen Projekten:

    Derzeit in Verwendung habe ich zwei MQTT-Temperatur/Lichtsensoren, zwei MQTT-PIR-Sensoren. und einen MQTT-Optischen-Melder,

    die ihre States an den MQTT-Adapter im ioBroker senden, bzw. im Falle des MQTT-Optischen-Melders auf Statusänderung in Topics reagieren.

    Als Basis verwende ich der Einfachheit halber ausschließlich den ESP8266-12E auf einer kleinen Platine von "Neueinsteiger"(Raspberrypi-Forum),

    die eine entsprechende Spannungsversorgung sicher stellt, und die Programmierung auch besser Handhabbar macht.

    Der Link zu dem Platinen-Projekt: http://www.forum-raspberrypi.de/Thread- … in-projekt

    Für die Verwendung als MQTT-Clients habe ich, ein Script "zusammengestellt", welches ich möglichst universell gestaltet habe um die Einbindung in ioBroker zu vereinfachen. Danke auch für die Hilfe einiger User hier aus dem Forum!

    Jeder Sensor erzeugt nach entsprechender Programmierung seine eigenen Topics, welche dann im ioBroker, z.B. in Scripts verwendet werden können.

    Es wird auch ein RESET-Topic erzeugt, mit dem der entsprechende Client(Sensor) vom ioBroker aus neu gestartet werden kann.

    Der Experimentierfreudigkeit sind keine Grenzen gesetzt;).

    Ich denke mal, die Sketches sind auch noch nicht soooo optimal, aber sie funktionieren einwandfrei und erfüllen bei mir ihren Zweck.

    1. ESP8266-MQTT - DHT Humidity/Temperatur-Sensor + DS18x20 Temperatursensor +Lichtsensor:

    ! ```
    `////////////////////////////////////////////////////////////////////////////////
    // MQTT - DHT Humidity/Temperatur-Sensor + DS18x20 Temperatursensor +Lichtsensor
    //
    // Anschluss DHT -> ESP
    // Pin VCC -> +5V (+3,3V)
    // Pin DAT -> DHTPIN
    // Pin GND -> GND
    // 10K resistor DAT -> VCC (wenn nicht auf Modul bereits vorhanden)
    //
    // Anschluss DS18x20 -> ESP
    // Pin VCC -> +5V (+3,3V)
    // Pin DAT -> DSPIN
    // Pin GND -> GND
    // 4,7K resistor DAT -> VCC
    //
    // Anschluss Lichtsensor
    // +3,3V -> Fotowiederstand -> ADC(A0) <- 470R-Resistor <- GND
    //
    ////////////////////////////////////////////////////////////////////////////////
    ! // #define DEBUG // Debug-Modus einschalten fuer spezielle Ausgaben ueber Serial
    ! #include <esp8266wifi.h>extern "C" { // nur fuer ESP8266 systen_deep_sleep()
    #include "user_interface.h"
    } // nur fuer ESP8266 systen_deep_sleep()
    ! #include <pubsubclient.h>#include <onewire.h>#include "DHT.h"
    ! // DS18x20-Settings
    float celsius, fahrenheit;
    #define DSPIN 5 // DS18x20-Pin entsprechend der GPIO z.B GPIO05 -> 5
    OneWire ds(DSPIN);
    ! // Netzwerk-Settings <-------------------------!!ANPASSEN!!
    const char* ssid = "XXXXXXXXX";
    const char* password = "XXXXXXXXX";
    const char* USE_DHCP = "off"; // "on" fuer DHCP
    IPAddress Myip(???, ???, ???, ???); //static IP-Adresse (Sensor)
    IPAddress gateway(???, ???, ???, ???); //IP-Gateway
    IPAddress subnet(255, 255, 255, 0);//Subnet
    ! //// MQTT-Settings
    IPAddress mqtt_server(???,???,???,???); // IP-MQTT-Broker
    const char* mqtt_username = "user"; // MQTT-User
    const char* mqtt_key = "pass"; // MQTT-Password
    ! #define BASE "TempSensor02" // <---------------!!Entsprechend für jeden Sensor anpassen!!
    #define mqtt_client_id BASE
    #define mqtt_topics_ip BASE "/IP"
    #define mqtt_topics_light BASE "/Licht"
    #define mqtt_topics_humidity BASE "/Luftfeuchte"
    #define mqtt_topics_temperature1 BASE "/Temperatur1"
    // #define mqtt_topics_heatindex BASE "/HeatIndex"; // HeatIndex (nicht verwendet)
    #define mqtt_topics_temperature2 BASE "/Temperatur2"
    ! WiFiClient espClient;
    PubSubClient client(espClient);
    ! #define interval 600 // DeepSleep oder delay Zeit in Sekunden
    #define DHTPIN 4 // DHT-Pin entsprechend der GPIO z.B GPIO04 -> 4
    ! // DHT-Typ
    //#define DHTTYPE DHT11 // DHT 11
    #define DHTTYPE DHT22 // DHT 22 (AM2302), AM2321
    //#define DHTTYPE DHT21 // DHT 21 (AM2301)
    ! DHT dht(DHTPIN, DHTTYPE); // DHT initialisieren
    ! char message_humidity[20];
    char message_temperature1[20];
    char message_temperature2[20];
    char message_heatindex[20];
    char message_light[20];
    ! void setup() {
    Serial.begin(115200);
    if(USE_DHCP == "off") {setup_wifi();}
    Serial.println("DHTxx test!");
    dht.begin();
    ! client.setServer(mqtt_server, 1883);
    client.setClient(espClient);
    }
    ! void setup_wifi() {
    Serial.println("");
    delay(10);
    Serial.print("Connecting to ");
    Serial.println(ssid);
    if(USE_DHCP == "off") {WiFi.config(Myip, gateway, subnet); }
    WiFi.begin(ssid, password);
    ! while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    }
    ! Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
    }
    ! void reconnect() {
    // Loop until we're reconnected
    while (!client.connected()) {
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(mqtt_client_id,mqtt_username,mqtt_key)) {
    Serial.println("connected");
    // IP-Adresse umwandeln und publish
    IPAddress localAddr = WiFi.localIP();
    char s[16];
    sprintf(s, "%d.%d.%d.%d", localAddr[0], localAddr[1], localAddr[2], localAddr[3]);
    client.publish(mqtt_topics_ip,s);
    } else {
    Serial.print("failed, rc=");
    Serial.print(client.state());
    Serial.println(" try again in 5 seconds");
    // Wait 5 seconds before retrying
    delay(5000);
    }
    }
    }
    ! void loop() {
    delay(2000); // Pause fuer DHT-Initialisierung
    ! if (!client.connected()) {
    reconnect();
    }
    // DS18x20 lesen
    readDS18x29();

    // Sensor lesen
    float h = dht.readHumidity(); // Luftfeuchtigkeit
    float t = dht.readTemperature(); // Temperatur in Celsius
    float f = dht.readTemperature(true); // Temperatur in Fahrenheit (isFahrenheit = true)

    ! if (isnan(h) || isnan(t) || isnan(f)) { // Auf Lesefehler pruefen -> evtl wiederholen
    Serial.println("Lesefehler DHT-Sensor!");
    return;
    }
    ! float hif = dht.computeHeatIndex(f, h); // Compute heat index in Fahrenheit (the default)
    float hic = dht.computeHeatIndex(t, h, false); // Compute heat index in Celsius (isFahreheit = false)
    ! #if defined DEBUG
    Serial.print("Luftfeuchte: ");
    Serial.print(h);
    Serial.print(" %\t");
    Serial.print("Temperatur: ");
    Serial.print(t);
    Serial.print(" *C ");
    Serial.print(f);
    Serial.print(" *F\t");
    Serial.print("Heat index: ");
    Serial.print(hic);
    Serial.print(" *C ");
    Serial.print(hif);
    Serial.println(" *F");
    #endif
    ! String pub_humidityString = String(h);
    pub_humidityString.toCharArray(message_humidity, pub_humidityString.length()+1);
    client.publish(mqtt_topics_humidity, message_humidity);
    Serial.println("Humidity: "+pub_humidityString+" gesendet");

    String pub_temperature1String = String(t);
    pub_temperature1String.toCharArray(message_temperature1, pub_temperature1String.length()+1);
    client.publish(mqtt_topics_temperature1, message_temperature1);
    Serial.println("Temperatur1: "+pub_temperature1String+" C gesendet");

    ! String pub_temperature2String = String(celsius);
    pub_temperature2String.toCharArray(message_temperature2, pub_temperature2String.length()+1);
    client.publish(mqtt_topics_temperature2, message_temperature2);
    Serial.println("Temperatur2: "+pub_temperature2String+" C gesendet");
    ! // String pub_heatindexString = String(hic); // HeatIndex (nicht verwendet)
    // pub_heatindexString.toCharArray(message_heatindex, pub_heatindexString.length()+1); // HeatIndex (nicht verwendet)
    // client.publish("/sensor1/HeatIndex", message_heatindex); // HeatIndex (nicht verwendet)
    // Serial.println("HeatIndex: "+pub_heatindexString+" gesendet"); // HeatIndex (nicht verwendet)
    ! String pub_lightString = String(analogRead(A0)); // Lichtsensor
    pub_lightString.toCharArray(message_light, pub_lightString.length()+1); // Lichtsensor
    client.publish(mqtt_topics_light, message_light); // Lichtsensor
    Serial.println("Licht: "+pub_lightString+" gesendet"); // Lichtsensor
    ! // nur bei system_deep_sleep() ////////
    delay(3000);
    void disconnect ();
    Serial.println("...DeepSleep enabled!");
    system_deep_sleep(interval1000000); //sleep time in usecs. 10000000 = 10 secs.
    ///////////////////////////////////////
    //delay(interval
    1000); // Interval für Publish - wenn nicht system_deep_sleep()
    }
    ! void readDS18x29(){
    byte i;
    byte present = 0;
    byte type_s;
    byte data[12];
    byte addr[8];
    // float celsius, fahrenheit;

    if ( !ds.search(addr)) {
    #if defined DEBUG
    Serial.println("No more addresses.");
    Serial.println();
    #endif
    ds.reset_search();
    delay(250);
    return;
    }
    #if defined DEBUG
    Serial.println("DS10x20:");
    Serial.print(" ROM =");
    #endif
    for( i = 0; i < 8; i++) {
    #if defined DEBUG
    Serial.write(' ');
    Serial.print(addr[i], HEX);
    #endif
    }

    ! if (OneWire::crc8(addr, 7) != addr[7]) {
    #if defined DEBUG
    Serial.println("CRC is not valid!");
    #endif
    return;
    }
    Serial.println();

    // Chip Identifizieren anhand des 1. Bytes
    switch (addr[0]) {
    case 0x10:
    #if defined DEBUG
    Serial.println(" Chip = DS18S20"); // or old DS1820
    #endif
    type_s = 1;
    break;
    case 0x28:
    #if defined DEBUG
    Serial.println(" Chip = DS18B20");
    #endif
    type_s = 0;
    break;
    case 0x22:
    #if defined DEBUG
    Serial.println(" Chip = DS1822");
    #endif
    type_s = 0;
    break;
    default:
    #if defined DEBUG
    Serial.println("Device is not a DS18x20 family device.");
    #endif
    return;
    }

    ! ds.reset();
    ds.select(addr);
    ds.write(0x44, 1); // start conversion, with parasite power on at the end

    delay(1000); // maybe 750ms is enough, maybe not
    // we might do a ds.depower() here, but the reset will take care of it.

    present = ds.reset();
    ds.select(addr);
    ds.write(0xBE); // Read Scratchpad

    #if defined DEBUG
    Serial.print(" Data = ");
    Serial.print(present, HEX);
    Serial.print(" ");
    #endif
    for ( i = 0; i < 9; i++) { // we need 9 bytes
    data[i] = ds.read();
    #if defined DEBUG
    Serial.print(data[i], HEX);
    Serial.print(" ");
    #endif
    }
    #if defined DEBUG
    Serial.print(" CRC=");
    Serial.print(OneWire::crc8(data, 8), HEX);
    Serial.println();
    Serial.println();
    #endif

    // Convert the data to actual temperature
    // because the result is a 16 bit signed integer, it should
    // be stored to an "int16_t" type, which is always 16 bits
    // even when compiled on a 32 bit processor.
    int16_t raw = (data[1] << 😎 | data[0];
    if (type_s) {
    raw = raw << 3; // 9 bit resolution default
    if (data[7] == 0x10) {
    // "count remain" gives full 12 bit resolution
    raw = (raw & 0xFFF0) + 12 - data[6];
    }
    } else {
    byte cfg = (data[4] & 0x60);
    // at lower res, the low bits are undefined, so let's zero them
    if (cfg == 0x00) raw = raw & ~7; // 9 bit resolution, 93.75 ms
    else if (cfg == 0x20) raw = raw & ~3; // 10 bit res, 187.5 ms
    else if (cfg == 0x40) raw = raw & ~1; // 11 bit res, 375 ms
    //// default is 12 bit resolution, 750 ms conversion time
    }
    celsius = (float)raw / 16.0;
    fahrenheit = celsius * 1.8 + 32.0;
    #if defined DEBUG
    Serial.print("Temperatur2: ");
    Serial.print(celsius);
    Serial.print(" C, ");
    Serial.print(fahrenheit);
    Serial.println(" Fahrenheit");
    #endif
    }</onewire.h></pubsubclient.h></esp8266wifi.h>`

    ! 2. ESP8266-MQTT-Tuersensor(PIR) + Lichtsensor
    ! >! [spoiler]`[code]////////////////////////////////////////////////////////////////////////////////
    // MQTT - Tuersensor + Lichtsensor
    //
    // Sensor1 (Anschluss PIR)
    // Pin VCC -> +5V
    // Pin DAT -> SENSORPIN1
    // Pin GND -> GND
    //
    // Sensor 2 (LowAktiv)
    // Kontakt/ Schalter zwischen SENSORPIN2 und GND
    //
    // Anschluss Lichtsensor
    // +3,3V -> Fotowiederstand -> LIGHTPIN <- 470R-Resistor <- GND
    //
    ////////////////////////////////////////////////////////////////////////////////
    ! // #define DEBUG // Debug-Modus einschalten fuer spezielle Ausgaben ueber Serial
    ! #define RESETPIN 12 // Pin für SoftResetFunktion (verbunden mit RST)
    #define LEDPIN 2 // LED fest verdrahtet auf ESP8266-12E auf GPIO02 -> 2
    #define SENSORPIN1 4 // Pin entsprechend der GPIO z.B GPIO04 -> 4
    #define SENSORPIN2 5
    #define LIGHTPIN A0 // ESP8266 ADC-Pin
    ! #include <esp8266wifi.h>#include <pubsubclient.h>// Netzwerk-Settings <-------------------------!!ANPASSEN!!
    const char* ssid = "XXXXXXXXX";
    const char* password = "XXXXXXXXX";
    const char* USE_DHCP = "off"; // "on" fuer DHCP
    IPAddress Myip(???, ???, ???, ???); //static IP address (Sensor)
    IPAddress gateway(???, ???, ???, ???); //gateway
    IPAddress subnet(255, 255, 255, 0);//subnet
    ! //// MQTT-Settings
    IPAddress mqtt_server(???,???,???,???); // IP-MQTT-Broker
    const char* mqtt_username = "user"; // MQTT-User
    const char* mqtt_key = "pass"; // MQTT-Pass
    ! #define BASE "TuerSensor01" // <---------------!!ClientID Anpassen!!
    #define mqtt_client_id BASE
    #define mqtt_topics_ip BASE "/IP"
    #define mqtt_topics_light BASE "/Light"
    #define mqtt_topics_sensor1 BASE "/Sensor1"
    #define mqtt_topics_sensor2 BASE "/Sensor2"
    #define mqtt_topics_reset BASE "/RESET"
    ! WiFiClient espClient;
    PubSubClient client(espClient);
    ! char message_sensor1[20];
    char message_sensor2[20];
    char message_light[20];
    const char* sensor1 = "-?-";
    const char* sensor2 = "-?-";
    const char* res = "0";
    byte s1 = 1;
    byte s2 = 1;
    byte li = 1;
    ! void setup() {
    pinMode(RESETPIN, OUTPUT);
    digitalWrite(RESETPIN, HIGH);

    pinMode(SENSORPIN1, INPUT_PULLUP);
    pinMode(SENSORPIN2, INPUT_PULLUP);
    pinMode(LEDPIN, OUTPUT);

    Serial.begin(115200);
    if(USE_DHCP == "off") {setup_wifi();}
    client.setServer(mqtt_server, 1883);
    client.setCallback(callback);
    client.setClient(espClient);
    }

    ! void setup_wifi() {
    Serial.println("");
    delay(10);
    Serial.print("Connecting to ");
    Serial.println(ssid);
    if(USE_DHCP == "off") {WiFi.config(Myip, gateway, subnet); }
    WiFi.begin(ssid, password);
    ! while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    }
    ! Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
    }
    ! //// Callback Funktion von MQTT. (Hier nur für Topic RESET)
    void callback(char* topic, byte* payload, unsigned int length) {
    int i = 0;
    char message_buff[100];
    Serial.print("Empfangen: " + String(topic));
    for(i=0; i <length; i++)/{/message_buff[i]="payload[i];" }/;/string/msgstring="String(message_buff);" konvertierung/der/nachricht/in/ein/serial.println("/-="">" + msgString);
    if (msgString == "1"){ // Wenn 1 dann Reset
    client.publish(mqtt_topics_ip,"RESET");
    Serial.println("Reset");
    digitalWrite(RESETPIN, LOW);
    delay(1000);
    }
    }
    ! void reconnect() {
    // Loop until we're reconnected
    while (!client.connected()) {
    Serial.println(BASE);
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(mqtt_client_id,mqtt_username,mqtt_key)) {
    Serial.println("connected");
    // IP-Adresse umwandeln und publish
    IPAddress localAddr = WiFi.localIP();
    char s[16];
    sprintf(s, "%d.%d.%d.%d", localAddr[0], localAddr[1], localAddr[2], localAddr[3]);
    client.publish(mqtt_topics_ip,s);
    client.publish(mqtt_topics_reset,res);
    } else {
    Serial.print("failed, rc=");
    Serial.print(client.state());
    Serial.println(" try again in 5 seconds");
    // Wait 5 seconds before retrying
    delay(5000);
    }
    }
    }
    ! void mqtt_publish(){
    if (!client.connected()) {
    reconnect();
    }
    if (LEDPIN){ digitalWrite(LEDPIN,LOW);}
    ! String pub_lightString = String(analogRead(A0)); // Lichtsensor senden
    pub_lightString.toCharArray(message_light, pub_lightString.length()+1);
    client.publish(mqtt_topics_light, message_light);
    ! if (s1 == 1){ // nur Sensor1 Status senden
    String pub_sensor1String = String(sensor1); // Sensor1
    pub_sensor1String.toCharArray(message_sensor1, pub_sensor1String.length()+1);
    client.publish(mqtt_topics_sensor1, message_sensor1);
    Serial.println("Sensor1: "+pub_sensor1String+" gesendet");
    s1 = 0;
    }
    if (s2 == 1){ // nur Sensor 2 Status senden
    String pub_sensor2String = String(sensor2); // Sensor2
    pub_sensor2String.toCharArray(message_sensor2, pub_sensor2String.length()+1);
    client.publish(mqtt_topics_sensor2, message_sensor2);
    Serial.println("Sensor2: "+pub_sensor2String+" gesendet");
    s2 = 0;
    }
    !
    if (LEDPIN){ digitalWrite(LEDPIN,HIGH);}
    }
    ! byte io1 = digitalRead(SENSORPIN1);
    byte io2 = digitalRead(SENSORPIN2);
    ! void loop() {
    //client.subscribe(mqtt_topics_reset);
    if (s1 == 1){
    mqtt_publish();
    }
    if (digitalRead(SENSORPIN1) != io1){
    if (digitalRead(SENSORPIN1) == 0) {
    sensor1 = "true";
    io1 = digitalRead(SENSORPIN1);
    } else{
    sensor1 = "false";
    io1 = digitalRead(SENSORPIN1);
    }
    s1 = 1;
    mqtt_publish();
    }
    ! if (digitalRead(SENSORPIN2) != io2){
    if (digitalRead(SENSORPIN2) == 0) {
    sensor2 = "true";
    io2 = digitalRead(SENSORPIN2);
    } else{
    sensor2 = "false";
    io2 = digitalRead(SENSORPIN2);
    }
    s2 = 1;
    mqtt_publish();
    }
    client.loop();
    }</length;></pubsubclient.h></esp8266wifi.h>` [/i][/i][/i][/code][/spoiler][/i][/i][/i]


  • [erledigt;)]


  • Hallo

    Ich habe einmal versucht dein Projekt nachzubauen und deine Sketche probiert geht bei mir nicht

    Ich verwende Ardunino 1.6.7 die nötigen Bibliotheken sind installiert die IP Adressen angepasst habe mit DHCP on und off probiert

    error: 'setup_wifi' was not declared in this scope

    if(USE_DHCP == "off") {setup_wifi();}

    ^

    esp_test:73: error: 'callback' was not declared in this scope

    client.setCallback(callback);

    Gruß

  • Most Active

    Der Post ist zwar inzwischen schon etwas älter, aber das Thema ESP8266 und MQTT interessiert mich.

    Was muß man auf seiten iobroker Installieren und tun, um die Sache zu starten?

    Ich nutze DHCP mit eingefrorenen Adressen.


  • @klassisch:

    Der Post ist zwar inzwischen schon etwas älter, aber das Thema ESP8266 und MQTT interessiert mich.

    Was muß man auf seiten iobroker Installieren und tun, um die Sache zu starten?

    Ich nutze DHCP mit eingefrorenen Adressen. `

    Hallo,

    eigentlich brauchst du nur den MQTT-Adapter.

    Bei mir läuft dieser als Server.

    Die ESP8266 in Verbindung mit meinem Scripts melden sich dann beim ersten Start im ioBroker an und legen selbstständig die notwendigen Objekte unter mqtt.0 an.

    SSL ist bei mir ausgeschaltet.

    @onkeltom9:

    Also die Scripts funktionieren definitiv korrekt.

    Hast du etwas verändert?

    Bei der Anpassung ein ";" ,eine "}" oder irgendwo eine ")" vergessen?

    Meist ist es dann so, dass die voids danach nicht mehr erkannt werden.

  • Most Active

    Vielen Dank, MQTT Adapter ist installiert. Dann werde ich am WE mal Deine Sketches durchschauen um herauszufinden, was die einzelnen Einstellungen im Adapter bedeuten.

  • Most Active

    Vielleicht vorab noch eine Frage. Bei der Zusammenarbeit zwischen meinem WeMos-Sensoren/Aktoren und der CCU gibt es verschiedene Kommunikationsformen, die in jener Welt gelöst sind. Dafür suche ich die Pendants in der MQTT/ioBroker Welt. Das wären:

    1 Sensor liefert Wert bei ioBroker ab

    2 ioBroker liefert Wert an Sensor/Aktor

    3 Sensor/Aktor fordert bei ioBroker eine Aktion an, z.B. Starten eines Programms

    4 ioBroker fordert bei Sensor/Aktor eine Aktion an, z.B. Starten eines Programms, z.B. email-Versand

    Damit kann man dann auch komplexere Kommunikationen durchführen wie

    5 Sensor/Aktor fordert bei ioBroker einen Wert z-B. eines anderen Sensors an

    6 Sensr/Aktor läßt einen Wert an einen anderen Sensor/Aktor übertragen bzw. dort eine Aktion auslösen

    Lassen sich diese Aufgaben per MQTT Adapter lösen und wie?


  • @klassisch:

    Also wie ich das sehe, lassen sich alle Aufgaben mit MQTT realisieren.

    Schau die vielleicht einfach mal die Grundprinzipien von MQTT an.

    Das Übertragen/ Anfordern eines Wertes zu/ von einem anderen Sensor/ Aktor wird allerdings nur "indirekt" über den Broker gehen.

    Man kann Werte in Topics im ioBroker schreiben und z.B. mit Scripten auf entsprechende Änderungen reagieren.

    Auch kann Topics im ioBroker abbonieren und im Sensor/Aktor mit entsprechenden Programmen darauf reagieren.

    Die Punkte 1-4 werden auch in meinen Scripts verwendet.

    Einfach mal ein wenig analysieren.

  • Most Active

    @AndyUM61:

    Also wie ich das sehe, lassen sich alle Aufgaben mit MQTT realisieren. `
    Prima, hört sich gut an.
    @AndyUM61:

    Schau die vielleicht einfach mal die Grundprinzipien von MQTT an. `
    Ja, habe ich versucht, finde allerdings die wirklich erhellende Quelle nicht. Schleiche seit geraumer Zeit wie die Katze um den heißen Brei. Denn eigentlich habe ich das ja alles via CCU am Laufen und könnte/sollte zufrieden sein. Aber die Weiterentwicklung CCU ist mir zu ruhig, wobei die CCU eigentlich und unangestrengt stabil läuft, wenn man sich diszipliniert verhält und das WebUi nicht offen hat. Aber MQTT verspricht etwas mehr Plattformunabhängigkeit. Habe aber noch keinen Plan für ein Zielsystem. Und das, zusammen mit der fehlenden Notwendigkeit hemmt meinen Eifer enorm.

    Habe mal https://www.youtube.com/watch?v=Rf1jVYewmx4 und https://www.youtube.com/watch?v=cuiuxCEANbw rekapituliert (war damals ja live dabei) und owagners Thread zu diesem Thema im HM-Forum gelesen. Darin betont er ausdrücklich, daß sein MQTT Addon HM-Systemvariablen explizit und gewünschterweise nicht unterstützt. Da sollte aber bei ioBroker gehen, vermute ich mal.
    @AndyUM61:

    Das Übertragen/ Anfordern eines Wertes zu/ von einem anderen Sensor/ Aktor wird allerdings nur "indirekt" über den Broker gehen.

    Man kann Werte in Topics im ioBroker schreiben und z.B. mit Scripten auf entsprechende Änderungen reagieren.

    Auch kann Topics im ioBroker abbonieren und im Sensor/Aktor mit entsprechenden Programmen darauf reagieren. `
    Mit den WeMos geht das auch direkt. Allerdings muß da die IP-Adressen des jewiligen Partners eintragen. Bei MQTT könnte das ja durch eine Abstraktionsebene gelöst werden, so daß man nur den Namen des Datenpunktes eintragen muß. Bei einem Wechsel des WeMos Sensors, der vielleicht eine andere IP aber denselben Namen für den Datenpunkt hat, wäre kein Änderungsbedarf.
    @AndyUM61:

    Die Punkte 1-4 werden auch in meinen Scripts verwendet.

    Einfach mal ein wenig analysieren. ` Habe schon mal reingeschaut, aber noch fehlen mir die MQTT-Basics.


  • Bei Verwendung von MQTT und ioBroker könnte man ja auch DHCP verwenden (optional in meinen Scripts aktivierbar), dann braucht man sich um die IPs absolut nicht zu kümmern.

    Die Datenpunkte sind ja davon unabhängig.

  • Most Active

    Vielen Dank, so hatte ich mir das erhofft.


  • dank tatkräftiger Unterstützung von AndyUM61 konnte ich 2 Relais bzw. LED-Ausgaenge implementieren. Dazu muss der Original-Sketch leicht abgeändert werden. Die ursprüngliche Reset-Funktion habe ich entfernt, da ich sie so nicht benötige.

    ! ```
    `////////////////////////////////////////////////////////////////////////////////
    // MQTT - Tuersensor + Lichtsensor
    //
    // Sensor1 (Anschluss PIR)
    // Pin VCC -> +5V
    // Pin DAT -> SENSORPIN1
    // Pin GND -> GND
    //
    // Sensor 2 (LowAktiv)
    // Kontakt/ Schalter zwischen SENSORPIN2 und GND
    //
    // Anschluss Lichtsensor
    // +3,3V -> Fotowiederstand -> LIGHTPIN <- 470R-Resistor <- GND
    //
    // mod fuer 2 Relais oder Led-Ausgaenge 8_1_2017 by starfish
    //
    ////////////////////////////////////////////////////////////////////////////////
    ! // #define DEBUG // Debug-Modus einschalten fuer spezielle Ausgaben ueber Serial
    ! #define RESETPIN 12 // Pin fuer Relais 1 (ex SoftResetFunktion (verbunden mit RST))
    #define RELAISPIN 13 // Pin fuer Relais 2 /// <----- EINGEFÜGT ------------
    #define LEDPIN 2 // LED fest verdrahtet auf ESP8266-12E auf GPIO02 -> 2
    #define SENSORPIN1 4 // Pin entsprechend der GPIO z.B GPIO04 -> 4
    #define SENSORPIN2 5
    #define LIGHTPIN A0 // ESP8266 ADC-Pin
    ! #include <esp8266wifi.h>
    #include <pubsubclient.h>
    ! // Netzwerk-Settings <-------------------------!!ANPASSEN!!
    const char* ssid = "?????";
    const char* password = "???????????";
    const char* USE_DHCP = "off"; // "on" fuer DHCP
    IPAddress Myip(192, 168, 0, ???); //static IP address (Sensor)
    IPAddress gateway(192, 168, 0, ???); //gateway
    IPAddress subnet(255, 255, 255, 0);//subnet
    ! //// MQTT-Settings
    IPAddress mqtt_server(192,168,0,???); // IP-MQTT-Broker
    const char* mqtt_username = "user"; // MQTT-User
    const char* mqtt_key = "pass"; // MQTT-Pass
    ! #define BASE "TuerSensor01" // <---------------!!ClientID Anpassen!!
    #define mqtt_client_id BASE
    #define mqtt_topics_ip BASE "/IP"
    #define mqtt_topics_light BASE "/Light"
    #define mqtt_topics_sensor1 BASE "/Sensor1"
    #define mqtt_topics_sensor2 BASE "/Sensor2"
    #define mqtt_topics_reset BASE "/RESET"
    #define mqtt_topics_relais BASE "/Relais" /// <----- EINGEFÜGT ------------
    ! WiFiClient espClient;
    PubSubClient client(espClient);
    ! char message_sensor1[20];
    char message_sensor2[20];
    char message_light[20];
    const char* sensor1 = "-?-";
    const char* sensor2 = "-?-";
    const char* res = "0";
    const char* relais = "0"; /// <----- EINGEFÜGT ------------
    byte s1 = 1;
    byte s2 = 1;
    byte li = 1;
    ! void setup() {
    pinMode(RESETPIN, OUTPUT);
    digitalWrite(RESETPIN, HIGH);

    pinMode(SENSORPIN1, INPUT_PULLUP);
    pinMode(SENSORPIN2, INPUT_PULLUP);
    pinMode(LEDPIN, OUTPUT);
    pinMode(RELAISPIN, OUTPUT); /// <----- EINGEFÜGT ------------
    digitalWrite(RELAISPIN, LOW);

    !
    Serial.begin(115200);
    if(USE_DHCP == "off") {setup_wifi();}
    client.setServer(mqtt_server, 1883);
    client.setCallback(callback);
    client.setClient(espClient);
    }
    ! void setup_wifi() {
    Serial.println("");
    delay(10);
    Serial.print("Connecting to ");
    Serial.println(ssid);
    if(USE_DHCP == "off") {WiFi.config(Myip, gateway, subnet); }
    WiFi.begin(ssid, password);
    ! while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    }
    ! Serial.println("");
    Serial.println("WiFi connected");
    Serial.println("IP address: ");
    Serial.println(WiFi.localIP());
    }
    ! //// Callback Funktion von MQTT. (Hier nur für Topic RESET)
    void callback(char* topic, byte* payload, unsigned int length) {
    int i = 0;
    char message_buff[100];
    Serial.print("Empfangen: " + String(topic));
    for(i=0; i <length; i++)/{/message_buff[i]="payload[i];" }/;/string/msgstring="String(message_buff);" konvertierung/der/nachricht/in/ein/serial.println("/-="">" + msgString);

    /// <----- EINGEFÜGT ------------ alter RESET-Teil entfernt
    if (String(topic) == mqtt_topics_reset){
    if (msgString == "1"){
    Serial.println("Relais1 ein");
    digitalWrite(RESETPIN, HIGH);
    }
    }
    if (String(topic) == mqtt_topics_reset){
    if (msgString == "0"){
    Serial.println("Relais1 aus");
    digitalWrite(RESETPIN, LOW);
    }
    }

    ! if (String(topic) == mqtt_topics_relais){
    if (msgString == "1"){
    Serial.println("Relais2 ein");
    digitalWrite(RELAISPIN, HIGH);
    }
    }
    if (String(topic) == mqtt_topics_relais){
    if (msgString == "0"){
    Serial.println("Relais2 aus");
    digitalWrite(RELAISPIN, LOW);
    }
    }
    /// <----- EINGEFÜGT bis hier ------------
    }
    ! void reconnect() {
    // Loop until we're reconnected
    while (!client.connected()) {
    Serial.println(BASE);
    Serial.print("Attempting MQTT connection...");
    // Attempt to connect
    if (client.connect(mqtt_client_id,mqtt_username,mqtt_key)) {
    Serial.println("connected");
    // IP-Adresse umwandeln und publish
    IPAddress localAddr = WiFi.localIP();
    char s[16];
    sprintf(s, "%d.%d.%d.%d", localAddr[0], localAddr[1], localAddr[2], localAddr[3]);
    client.publish(mqtt_topics_ip,s);
    client.publish(mqtt_topics_reset,res);
    client.publish(mqtt_topics_relais,relais); /// <----- EINGEFÜGT ------------
    } else {
    Serial.print("failed, rc=");
    Serial.print(client.state());
    Serial.println(" try again in 5 seconds");
    // Wait 5 seconds before retrying
    delay(5000);
    }
    }
    }
    ! void mqtt_publish(){
    if (!client.connected()) {
    reconnect();
    }
    if (LEDPIN){ digitalWrite(LEDPIN,LOW);}
    ! String pub_lightString = String(analogRead(A0)); // Lichtsensor senden
    pub_lightString.toCharArray(message_light, pub_lightString.length()+1);
    client.publish(mqtt_topics_light, message_light);
    ! if (s1 == 1){ // nur Sensor1 Status senden
    String pub_sensor1String = String(sensor1); // Sensor1
    pub_sensor1String.toCharArray(message_sensor1, pub_sensor1String.length()+1);
    client.publish(mqtt_topics_sensor1, message_sensor1);
    Serial.println("Sensor1: "+pub_sensor1String+" gesendet");
    s1 = 0;
    }
    if (s2 == 1){ // nur Sensor 2 Status senden
    String pub_sensor2String = String(sensor2); // Sensor2
    pub_sensor2String.toCharArray(message_sensor2, pub_sensor2String.length()+1);
    client.publish(mqtt_topics_sensor2, message_sensor2);
    Serial.println("Sensor2: "+pub_sensor2String+" gesendet");
    s2 = 0;
    }
    !
    if (LEDPIN){ digitalWrite(LEDPIN,HIGH);}
    }
    ! byte io1 = digitalRead(SENSORPIN1);
    byte io2 = digitalRead(SENSORPIN2);
    ! void loop() {
    //client.subscribe(mqtt_topics_reset);
    if (s1 == 1){
    mqtt_publish();
    }
    if (digitalRead(SENSORPIN1) != io1){
    if (digitalRead(SENSORPIN1) == 0) {
    sensor1 = "true";
    io1 = digitalRead(SENSORPIN1);
    } else{
    sensor1 = "false";
    io1 = digitalRead(SENSORPIN1);
    }
    s1 = 1;
    mqtt_publish();
    }
    ! if (digitalRead(SENSORPIN2) != io2){
    if (digitalRead(SENSORPIN2) == 0) {
    sensor2 = "true";
    io2 = digitalRead(SENSORPIN2);
    } else{
    sensor2 = "false";
    io2 = digitalRead(SENSORPIN2);
    }
    s2 = 1;
    mqtt_publish();
    }
    client.loop();
    }</length;></pubsubclient.h></esp8266wifi.h>`[/i][/i][/i]


  • hab eben ein Problem entdeckt: bei einem WiFi - Unterbruch wird die Verbindung nicht wieder hergestellt. offenbar ist das Problem bekannt http://tech.scargill.net/esp8266-and-lo … nection-2/

  • Most Active

    Ermöglicht eine ESP8266 - MQTT - Kopplung auch die burstartige Übertragung von Wertepaaren (ZEIT, Wert)?

    Ich möchte diese Wertepaare auf dem ESP errechnen und zwischenspeichern. Dann als Burst übertragen, um den Traffic zu konzentrieren.

    Mit HM/CUX geht das nicht, da jedem Wert die Eingangszeit zugeordnet wird.

    Jetzt möchte ich eben zu jedem Wert auch die Zeit abspeichern und dann an ioBroker per MQTT übertragen. Dann müßte MQTT/ioBroker die Daten entsprechend der mitgesendeten Zeiten einsortieren oder diese Datenpaare speichern und handeln.

    Geht das?


  • Hallo

    Habe das zweite Sketch MQTT - Tuersensor + Lichtsensor auf meinen ESP2266E12 gespielt.

    Vorher noch die Netzwerk-Settings und MQTT-Settings geändert.

    // Netzwerk-Settings <-------------------------!!ANPASSEN!!
    const char* ssid = "xxxx";                                                          WLAN SSID
    const char* password = "xxxxxx";                                                WLAN Password
    const char* USE_DHCP = "off"; // "on" fuer DHCP
    IPAddress Myip(192,168,2,99); //static IP address (Sensor)              IP des ESP2266E12
    IPAddress gateway(192,168,2,1); //gateway                                  ? IP der Fritzbox
    IPAddress subnet(255,255,255,0);//subnet
    
    //// MQTT-Settings
    IPAddress mqtt_server(192,168,2,74); // IP-MQTT-Broker                IP des iOBroker Rechners
    const char* mqtt_username = "xxxxxx"; // MQTT-User                     Username in Konfig MQTT
    const char* mqtt_key = "xxxxxxxx"; // MQTT-Pass                          Passwort in Konfig MQTT
    
    

    Der ESP2266E12 wird mir in der FritzBox angezeigt und ein Ping auf 192.168.2.99 kann ich auch absetzen.

    Wenn ich den Taster auf den ESP drücke zeigt er mir in der Arduino IDE Konsole auch den Text das der Taster geschaltet hat an.

    Ist die Gateway IP der FritzBox so richtig ?

    Braucht kein Port eingetragen werden ?

    Hier die Konfig des MQTT in iOBroker
    1563_screenshot-2017-10-13_iobroker_admin_1_.png 1563_screenshot-2017-10-13_iobroker_admin.png
    Ist das so richtig konfiguriert ?

    Wenn ich in IOBroker Instanzen auf das Symbol ganz links vom MQTT gehe wird mir folgendes angezeigt:

    Verbunden mit Host: falsch

    Lebenszeichen: falsch

    Verbunden mit mqtt: falsch

    Wenn ich MQTT einschalte bekomme ich in der Log folgendes:

    mqtt.0	2017-10-13 13:46:21.249	error	exception by stop: server.destroy is not a function
    mqtt.0	2017-10-13 13:46:21.249	error	Error: listen EADDRINUSE 0.0.0.0:1883 at Object.exports._errnoException (util.js:907:11) at exports._exceptionWithHostPort (util.js:930:20) at Server._listen2 (net.js:1253:14) at liste
    mqtt.0	2017-10-13 13:46:21.238	error	uncaught exception: listen EADDRINUSE 0.0.0.0:1883
    mqtt.0	2017-10-13 13:46:20.226	info	starting. Version 1.3.2 in /opt/iobroker/node_modules/iobroker.mqtt, node: v4.8.4
    host.netfritz-FUTRO-S900	2017-10-13 13:46:18.051	info	instance system.adapter.mqtt.0 started with pid 17527
    host.netfritz-FUTRO-S900	2017-10-13 13:46:18.018	info	object change system.adapter.mqtt.0
    
    

    Was muss ich mache das es läuft ?

    Gruß NetFritz


  • Hallo

    Habe mal gesucht nach der Bedeutung von EADDRINUSE

    EADDRINUSE = Die angegebene Adresse wird schon verwendet.

    Ist damit die IP 0.0.0.0 oder der Port 1883 gemeint ?

    Gruß NetFritz


  • Hallo

    Habe mit mit lsof -i die Portbelegung angeschaut und festgestellt

    das mosquitto die Ports belegt.

    Danach den Port auf 1882 in mqtt und Sketch eingestellt und siehe da

    jetzt läuft es.

    Gruß NetFritz

  • Most Active

    Super, vielen Dank für die Info!

    Gesendet von meinem ZTE A2016 mit Tapatalk


  • Hallo

    Zum Port

    Die Internet Assigned Numbers Authority (IANA) reserviert für MQTT die Ports 1883 und 8883

    Ist es ratsam den Port auf 1883 oder 8883 einzustellen ?

    Gruß NetFritz

  • Most Active

    Auch mit MQTT kenne ich mich leider nicht aus. Aber der ioBroker hat einen MQTT Adapter. Und der gibt den Port 1883 an. Das wäre dann der für mich naheliegende Port.

    Gesendet von meinem ZTE A2016 mit Tapatalk

Suggested Topics

1.2k
Online

34.8k
Users

40.8k
Topics

559.9k
Posts