[Gelöst] Intertechno 433Mhz per MQTT über einen ESP8266 steuern

[BigDo]

Hallo allerseits,


ich habe folgende Geräte im Einsatz:
20x Intertechno ITL-500, Raspberry Pi 4 als WLAN Access Point und FHEM-Zentrale mit Mosquitto-Server, ESP8266 mit RC433Mhz Sender

ich möchte die Intertechno-Geräte über MQTT schalten, dazu habe ich den ESP8266 eingerichtet. Das Schalten der Rolladen direkt über den ESP funktioniert,
ich kann auch Nachrichten mit dem Programm MQTT.fx per MQTT versenden und die kommen am ESP auch an.
Die Anbindung an FHEM scheitert momentan noch. Ich muss in FHEM de 20 Rolladen anlegen und von diesen per MQTT-Publish den entstprechenden Code senden.
Hat einer ne Idee wie ich das in FHEM realisieren kann?

MFG

Niko

[Beta-User]

Hi, tendenziell sollte das "halbwegs" mit dem ROLLO-Modul gehen, wobei dann eben für jedes "Relay" ein direktes publish an das MQTT-IO erfolgen kann (würde MQTT2_CLIENT empfehlen).
Problem dabei ist "nur", dass FHEM/ROLLO es eventuell nicht mitbekommst, wenn jemand von extern die Rollläden schaltet.

[BigDo]

ich habe zum Testen ein Rollo als MQTT2_Client eingerichtet, soweit sogut. Nur wie sende ich einen Befehl an den ESP? Da happert es bei mir noch.
Der Befehl muss ja durch klicken auf das entsprechende Icon gesendet werden. Hat jemand evtl. sowas im Einsatz und kann mir eine Beispiel-Konfi zeigen?

Ich habe auch versucht ein Rollo als IT Gerät mit

define Rollo_1 IT  00000FF00F FF F0
on:rauf off:runter

es werden auch die richtigen Symbole angezeigt be rauf und runter
aber wie verknüpfe ich das mit MQTT?

Die RCSwitch - Library unterstützt auch Befehle im Format: Hauscode, Gruppe, Device
mySwitch.switchOn('a', 1, 4);
mein Problem ist, das Absenden von MQTT-Nachrichten an den ESP

[Beta-User]

ich habe zum Testen ein Rollo als MQTT2_Client eingerichtet, soweit sogut.

Ähm, vermutlich hast du einen MQTT2_CLIENT eingerichtet, aber das ist ein IO-Modul. Falls du auch ein MQTT2_DEVICE eingerichtet hast, ist das zwar vermutlich nicht wirklich falsch, aber was anderes, als ich mir gedacht hatte...

Nur wie sende ich einen Befehl an den ESP? Da happert es bei mir noch.

Du verwendest dann direkt

Code Auswählen Erweitern

set <MQTT2_CLIENT-Device> publish <topic + payload>
topic + payload genau so, wie du das mit MQTT.fx ermittelt hattest.

Der Befehl muss ja durch klicken auf das entsprechende Icon gesendet werden. Hat jemand evtl. sowas im Einsatz und kann mir eine Beispiel-Konfi zeigen?

Dazu definierst du je ein ROLLO-Device für jeden Rollladen und machst da dann die Attribute entsprechend, dass die publish-Befehle für hoch/runter/stop eingetragen werden.

[BigDo]

bei welchem attrTemplate muss ich den Befehl hinterlegen?

[Beta-User]

du brauchst KEIN MQTT2_DEVICE und damit auch kein attrTemplate, sondern ROLLO (zum dritten)...

Code Auswählen Erweitern

define rollo_A ROLLO
attr rollo_A rl_commandUp set <m2client> publish <topic + command für 1. Rollo up>
attr rollo_A rl_commandDown set <m2client> publish <topic + command für 1. Rollo down>
attr rollo_A rl_secondsDown 25
attr rollo_A rl_secondsUp 30

Code Auswählen Erweitern

help ROLLO

MQTT2_DEVICE wird evtl. dann interessant, wenn es um externe Schaltungen geht, die mit dem ESP _empfangen_ werden... (für "set rollo_A extern stop" etc.)

[BigDo]

Juhu es kommen Nachrichten am ESP an 
Besten Dank!

[Beta-User]

Schön, dass das jetzt geklappt hat.

Vielleicht im Nachgang noch ein paar Anmerkungen:
- [gelöst]?
- es wäre nett, wenn du das ROLLO-Device dann am Ende auch "fertig" zeigen würdest, Fragen in diese Richtung sind nicht eben selten, aber die Lösung mit dem publish nicht unbedingt naheliegend;
- Falls du externe Taster hast: dafür (=Auswertung eingehender RF-Messages) muss man was zusätzliches bauen, wenn man korrekte Status-Anzeigen im ROLLO haben will;
- der Vorteil von ROLLO gg. einem reinen MQTT2_DEVICE ist (in dieser Konstellation!) v.a., dass die pct-Werte direkt ermittelt werden und das dann unmittelbar auch für AutoShuttersControll verwendet werden kann;
- Falls du den Mosquitto nicht für externe Zwecke brauchst: MQTT2_SERVER ist einfacher als die Kombination Mosquitto und MQTT2_CLIENT.

[BigDo]

danke noch mal. Wenn es fertig ist, werde ich es hier posten.

MFG

Niko

[BigDo]

Hab noch ne Frage.
Mein Telegramm sieht momentan so aus:
set myBroker publish ESP8266_Rolladen433/Subscribe Rollo_A:0:a:1:4

mein Array:
Rollo_A:0:a:1:4
Rollo_A = Name des Gerätes
0/1 = Aktion (0=zu, 1=auf)
a = Hauscode
1 = Gruppencode
4 = Gerätecode

evtl. ergenze ich das Telegramm noch um einen Zeitfaktor

kann man für das Rollo_A evtl. über eine Variable, den internen Namen in FHEM einsetzten?

[Beta-User]

Hmm, ich _glaube_, dass das (in den ROLLO-Attributen) nicht geht, im Zweifel müßtest du das durch Code-Analyse von ROLLO rausfinden oder mal im ROLLO-Thread nachfragen. Ich sehe aber auch keinen großen Vorteil: die Einrichtung in FHEM ist ja eine Einmalaktion, und wenn man eine funktionierende RAW-Definition hat, kann man die mit search&replace auch gut für alle anderen anpassen...

Die Payload ist aber auch "speziell", irgendwie irritiert es mich, dass der ESP mit dem FHEM-Namen "irgendwas am Hut" haben soll. Aber gut, man lernt ja nie aus, vielleicht kommt dann auch bei Tastendrücken (auf RF-Fernbedienungen) schon irgendwas in die Payload, das uns positiv überrascht . Aber bisher war der (ohne Code-Tags gepostete...!) publish-Befehl die einzige Codezeile, die wir bisher gesehen haben .

[BigDo]

Die Payload ist aber auch "speziell", irgendwie irritiert es mich, dass der ESP mit dem FHEM-Namen "irgendwas am Hut" haben soll. Aber gut, man lernt ja nie aus, vielleicht kommt dann auch bei Tastendrücken (auf RF-Fernbedienungen) schon irgendwas in die Payload, das uns positiv überrascht . Aber bisher war der (ohne Code-Tags gepostete...!) publish-Befehl die einzige Codezeile, die wir bisher gesehen haben .

den FHEM-Namen gebe ich nur für ne eventuelle Statusmeldung mit

[Beta-User]

Na ja, _falls_ deine firmware kein einfaches "dummes" RF-IO ist, sondern die Öffnungsgrade der Rollläden direkt überwachen kann, ist der Umweg via ROLLO evtl. doch nicht erforderlich.

Aber ohne nähere Infos, was denn nun die firmware kann und was nicht, ist es schlicht ziemliches Nebelgestochere...

[BigDo]

Das ist mein Hauptsketch, meine WLAN-Konfiguration habe ich im zweiten Tab (code weiter unten)


ESP8266_RC733Sender.ino (erster Tab in der Arduino IDE)

Code Auswählen Erweitern

/*
Sketch zum Versenden von 433MHz-Signalen per MQTT
  Die Codes kann man fur Intertechno hier
  https://wiki.fhem.de/wiki/Intertechno_Code_Berechnung
  nachlesen
*/
#include <ESP8266WiFi.h> 
#include <PubSubClient.h> //https://github.com/knolleary/pubsubclient
#include <RCSwitch.h> //https://github.com/sui77/rc-switch

// Transmitter is connected to ESP8266 Pin D2 GBIO4 
#define RC433DataPin  4

//MQTT Configuration

const char* mqtt_clientName = "ESP8266_RC433";
const char* mqtt_server = "192.168.1.1";
const int mqtt_port = 1883;
const char* mqtt_user = "username";
const char* mqtt_password = "password";
const char* mqtt_subscribe = "ESP8266_Rolladen433/Subscribe";
const char* mqtt_publish = "ESP8266_RolladenRC433/Publish";

WiFiClient ESP8266_RC433;
PubSubClient client(ESP8266_RC433);
RCSwitch mySwitch = RCSwitch();

void setup() {

  Serial.begin(115200);
  setup_wifi();
 
  mySwitch.enableTransmit(RC433DataPin);

  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);

  while (!client.connected()) {
    Serial.println("Connecting to MQTT...");

    if (client.connect(mqtt_clientName, mqtt_user, mqtt_password )) {
       Serial.println("connected"); 
     } else {
       Serial.print("failed with state ");
      Serial.print(client.state());
      delay(2000);
     }
  }

  client.publish(mqtt_publish,"ESP8022RC433");
  client.subscribe(mqtt_subscribe);
}

  String getValue(String data, char separator, int index)
{
  int found = 0;
  int strIndex[] = {0, -1};
  int maxIndex = data.length()-1;

  for(int i=0; i<=maxIndex && found<=index; i++){
    if(data.charAt(i)==separator || i==maxIndex){
        found++;
        strIndex[0] = strIndex[1]+1;
        strIndex[1] = (i == maxIndex) ? i+1 : i;
    }
  }

  return found>index ? data.substring(strIndex[0], strIndex[1]) : "";
}

void callback(char* topic, byte* payload, unsigned int length) {
  String MessageIn = "";
  Serial.print("Message arrived in topic: ");
  Serial.println(topic);
  Serial.print("Message:");
  for (int i = 0; i < length; i++) {
    //Serial.println((char)payload[i]);
    MessageIn +=(char)payload[i];
  }
  Serial.println(MessageIn);
  String Name = getValue(MessageIn,':',0);
  String Aktion = getValue(MessageIn,':',1);
  String Haus =  getValue(MessageIn,':',2);
  String Gruppe = getValue(MessageIn,':',3);
  String Device = getValue(MessageIn,':',4);

  //Serial.println(Haus.charAt(0));
  if (Aktion.toInt() == 1) {
    mySwitch.switchOn(Haus.charAt(0), Gruppe.toInt(), Device.toInt());
     delay(500);
  }
  if (Aktion.toInt() == 0) {
    mySwitch.switchOff(Haus.charAt(0), Gruppe.toInt(), Device.toInt());
     delay(500);
  }
  Serial.println();
  Serial.println("-----------------------");

}

void loop() {
  client.loop();
}


WIFISetup.ino (zweiter Tab in der Arduino IDE)

Code Auswählen Erweitern


//WLAN Configuration
const char* wifi_ssid = "WLAN SSID";
const char* wifi_password = "password";

// config static IP
IPAddress ip(192, 168, 1, 33); // where xx is the desired IP Address
IPAddress gateway(192, 168, 1, 1); // set gateway to match your network
IPAddress subnet(255, 255, 255, 0); // set subnet mask to match your network
IPAddress nameserver(192,168,1,1); // set nameserver

void setup_wifi() {
// Static IP Setup Info Here...
  WiFi.config(ip, gateway, subnet, nameserver);
  delay(10);
  // We start by connecting to a WiFi network
  Serial.println();
  Serial.print("Connecting to ");
  Serial.println(wifi_ssid);
  WiFi.begin(wifi_ssid, wifi_password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());
}


Einrichtung in FHEM

define TestROLLO_1 ROLLO
attr TestROLLO_1 rl_commandUp set myBroker publish ESP8266_RolladenRC433/Subscribe TestROLLO_1:0:a:1:4
attr TestROLLO_1 rl_commandDown set myBroker publish ESP8266_RolladenRC433/Subscribe TestROLLO_1:0:a:1:4
attr TestROLLO_1 rl_secondsDown 30
attr TestROLLO_1 rl_secondsUp 25^

myBroker ist der MQTT2_Client in FHEM
ESP8266_RolladenRC433/Subscribe <--- hier wird es von FHEM hingeschickt

Das ist das Array, welches an den ESP gesendet wird

TestROLLO_1:0:a:1:4

TestROLLO_1 = Name des Gerätes
0/1 = Aktion (0=zu, 1=auf)
a = Hauscode
1 = Gruppencode
4 = Gerätecode

Falls man nicht alles davon benötigt, kann das auch angepasst werden.

[Beta-User]

Ah, OK. Also derzeit "im Prinzip" tatsächlich ein "dummes RF-IO; dann passt das mit ROLLO.