Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. ioBroker Allgemein
    4. Von ioBroker per MQTT auf Arduino ESP8266 Senden

    NEWS

    • Neuer Blog: Fotos und Eindrücke aus Solingen

    • ioBroker@Smart Living Forum Solingen, 14.06. - Agenda added

    • ioBroker goes Matter ... Matter Adapter in Stable

    Von ioBroker per MQTT auf Arduino ESP8266 Senden

    This topic has been deleted. Only users with topic management privileges can see it.
    • Thisoft
      Thisoft last edited by

      So ganz schlecht sieht das doch schon mal gar nicht aus.

      Was genau ist denn jetzt dein Problem?

      Wenn Du im ioBroker in der in deinem Bild markierten Zeile mal den Wert "1" auf "0" änderst - tut sich dann was in Deinem ESP?

      Fällt mir gerade noch auf - mach mal in deinen MQTT-Einstellungen den Haken bei "Sende auch Zustände…" raus...

      1 Reply Last reply Reply Quote 0
      • B
        B3ta last edited by

        Es passiert leider nichts am esp !

        Problem ist genau das sich der pin am ESP nicht schaltet.

        1 Reply Last reply Reply Quote 0
        • Thisoft
          Thisoft last edited by

          Hast du den Haken in den Einstellungen rausgenommen?

          Ansonsten füge mal in die callback-Routine als 4. Zeile ein:

          Serial.println(strPayload);
          

          und schau dir mal an ob überhaupt und was dort ankommt.

          1 Reply Last reply Reply Quote 0
          • B
            B3ta last edited by

            Ja haken hab ich raus.

            mit der hinzugefügten zeile kommt im serial monitor 0,1 im wechsel.

            strTopic simmt auch nach meiner ansicht.

            example1/led
            1
            example1/led
            0
            example1/led
            1
            example1/led
            0
            example1/led
            1
            example1/led
            0
            example1/led
            1
            example1/led
            0
            
            
            1 Reply Last reply Reply Quote 0
            • B
              B3ta last edited by

              So es geht habe einen wirklich blöden Fehler begangen. Habe in der Arduino IDE vergessen den Pin als Output zu deklarieren! :shock:

              1 Reply Last reply Reply Quote 0
              • Thisoft
                Thisoft last edited by

                Freut mich dass es jetzt geht. Sind meistens so einfache Sachen die man übersieht…

                1 Reply Last reply Reply Quote 0
                • D
                  Dirk18 last edited by

                  Hallo,

                  bin auf der Suche nach einem kleinen Script wie deinem,

                  mit dem ich aus iobroker leds an einem esp8266, z.b. Wemos d1,

                  ansteuern kann.

                  Hab dein Script kurz probiert es wird aber im mqtt Adapter keine led angezeigt, nur der leere Ordner, kannst du mir nochmal auf die Sprünge helfen, damit auch mehrere Ausgänge angezeigt werden.

                  Wäre super

                  Vielen Dank Dirk

                  Hab es durch probieren selbst hinbekommen, trotzten Danke 🙂

                  1 Reply Last reply Reply Quote 0
                  • Andreas K
                    Andreas K last edited by

                    Hallo,

                    @B3ta wärst du bereit mir den Sketch oder ein Beispiel für den Temp Sensor für den Nano und für den ESP zu posten? Habe es bereits geschafft etwas mit dem ESP01 Modul mit Mqtt zu posten (Led ein und aus).
                    Nun hänge ich beim Verbinden zwischen Nano und ESp01.
                    Eine kleine Hilfestellung wäre sehr nett.

                    Danke und schönen Feiertag 🙂
                    Ps: ich weiß der Thread ist schon älter, aber trz. sehr passend für mein Problem.
                    Mfg Andreas

                    1 Reply Last reply Reply Quote 0
                    • W
                      warp735 last edited by

                      Hallo zusammen,

                      ich hab eine ähnliche Anforderung. Ich möchte zwei min und max Werte an esp übergeben. Aber egal was ich mache, es kommt nix an 😞
                      Unter welchen Umständen läuft er denn in das callback? Bei mir läuft er da nie rein.

                      Anbei mal mein "saustall"... Bin halt am rumprobieren 🙂

                      #include "DHT.h"
                      #include "Wire.h"
                      #include "U8g2lib.h"
                      #include "ESP8266WiFi.h"
                      #include "WiFiClient.h"
                      #include "PubSubClient.h"
                      
                      
                      
                      U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
                      
                      
                      const char* ssid = "xxx";
                      const char* password = "xxx";
                      
                      const int MQTT_PORT = 1883;
                      const char* MQTT_HOST = "192.168.10.20";
                      const char* MQTT_CLIENTID = "ServerRack";
                      const char* MQTT_USERNAME = "xxx";
                      const char* MQTT_PASSWORD = "xxx";
                      const String MQTT_BASE_TOPIC = "ServerRack";
                      
                      
                      
                      WiFiClient espClient;
                      PubSubClient client(espClient);
                      
                      
                      // DHT
                      #define DHTPIN 12    // DHT pin
                      #define SIGNAL_PIN 13
                      #define FAN_PIN 14
                      #define DHTTYPE DHT22
                      #define DELAY_TIME 30000 // time between measurements [ms]
                      #define MIN_FAN_SPEED_PERCENT 20 // minimum fan speed [%]
                      #define MIN_TEMP 25 // turn fan off below [deg C]
                      #define MAX_TEMP 35 // turn fan to full speed above [deg C]
                      
                      #define LED_pin 16
                      
                      DHT dht(DHTPIN, DHTTYPE);
                      
                      
                      void connectWifi() {
                        WiFi.mode(WIFI_AP_STA);
                        if (WiFi.waitForConnectResult() != WL_CONNECTED) {
                          WiFi.begin(ssid, password);
                          Serial.println("no WiFi");
                        }
                      
                        Serial.println("WiFi connected");
                      }
                      
                      
                      
                      
                      void connectMqtt() {
                        Serial.println("Connecting to MQTT...");
                        client.setServer(MQTT_HOST, MQTT_PORT);
                        client.subscribe("example1/led");
                        
                      
                        if (!client.connected()) {
                          if (!client.connect(MQTT_CLIENTID, MQTT_USERNAME, MQTT_PASSWORD)) {
                            Serial.print("MQTT connection failed:");
                            Serial.print(client.state());
                            Serial.println("Retrying...");
                          } else {
                          Serial.println("MQTT connected"); }
                        }
                      }
                      
                      
                      
                      
                      
                      
                      void setFanSpeedPercent(int p) {
                        int value = (p / 100.0) * 255;
                        analogWrite(FAN_PIN, value);
                      }
                      
                      
                      int getFanSpeedRpm() {
                        int highTime = pulseIn(SIGNAL_PIN, HIGH);
                        int lowTime = pulseIn(SIGNAL_PIN, LOW);
                        int period = highTime + lowTime;
                        if (period == 0) {
                          return 0;
                        }
                        float freq = 1000000.0 / (float)period;
                        return (freq * 60.0) / 2.0; // two cycles per revolution
                      }
                      
                      
                      
                      
                      void setup() { 
                        Serial.begin(115200); 
                        u8g2.begin();
                        dht.begin();
                      
                        client.setServer(MQTT_HOST, MQTT_PORT);
                        client.setCallback(callback);
                      
                        
                        
                        
                      pinMode(FAN_PIN, OUTPUT); 
                      analogWriteFreq(25000);
                      
                      // connecting wifi
                          connectWifi();
                      
                        //Startup
                      
                        Serial.println("Starting and Testing...");
                        u8g2.clearBuffer();
                        u8g2.setFont(u8g2_font_fur11_tf);
                        u8g2.drawUTF8(0,12,"Rack Fan Control");
                        u8g2.drawUTF8(0,28,"by Benni ");
                        u8g2.drawUTF8(0,60,"Startup test...");
                        u8g2.sendBuffer();
                      
                        analogWrite(FAN_PIN, 125);
                        delay(10000); // zur Sicherheit falls im Boot hängt
                      }
                      
                      
                      void loop() {
                          if (!client.connected()) {
                          reconnect();
                        }
                        client.loop();
                        
                          // Read humidity
                          float h = dht.readHumidity();
                          // Read temperature as Celsius
                          float t = dht.readTemperature();
                      
                        
                        int fanSpeedPercent, actualFanSpeedRpm;
                      
                        if (t < MIN_TEMP) {
                          fanSpeedPercent = 0;
                        } else if (t > MAX_TEMP) {
                          fanSpeedPercent = 100;
                        } else {
                          fanSpeedPercent = (100 - MIN_FAN_SPEED_PERCENT) * (t - MIN_TEMP) / (MAX_TEMP - MIN_TEMP) + MIN_FAN_SPEED_PERCENT;
                        }
                      
                        Serial.print("Setting fan speed to ");
                        Serial.print(fanSpeedPercent);
                        Serial.println(" %");
                        setFanSpeedPercent(fanSpeedPercent);
                      
                        actualFanSpeedRpm = getFanSpeedRpm();
                        Serial.print("Fan speed is ");
                        Serial.print(actualFanSpeedRpm);
                        Serial.println(" RPM");
                      
                        Serial.println();
                      
                          
                          connectWifi();
                          connectMqtt();
                      
                      
                          Serial.print("Feuchtigkeit: ");
                          Serial.print(h);
                          Serial.print(" %\t");
                          Serial.print("Temperatur: ");
                          Serial.print(t);
                          Serial.print(" *C\t");
                          Serial.print("Luefter: ");
                          Serial.print(fanSpeedPercent);
                          Serial.println(" % ");
                         Serial.println(digitalRead(LED_pin));
                          u8g2.clearBuffer();
                          u8g2.setFont(u8g2_font_fur35_tn);
                          u8g2.setCursor(20,37);
                          u8g2.print(t, 1);
                        
                          u8g2.setFont(u8g2_font_unifont_tf);
                          u8g2.setCursor(65,64);
                          u8g2.drawUTF8(112,37,"°C");
                          
                          u8g2.drawUTF8(18,50,"Fan");
                          u8g2.setCursor(18,64);
                          u8g2.print(fanSpeedPercent, 1);
                          u8g2.drawUTF8(40,64,"%");
                      
                          u8g2.drawUTF8(85,50,"Hum");
                          u8g2.setCursor(85,64);
                          u8g2.print(h, 1);
                          u8g2.drawUTF8(120,64,"%");
                          
                          u8g2.drawFrame(0,0,10,128);
                          u8g2.drawBox(0,map(fanSpeedPercent, 0, 100, 60, 0),10,128);
                          u8g2.sendBuffer();
                          delay(5000);
                          u8g2.clearDisplay();
                      
                        
                      
                        if (!isnan(h) || !isnan(t) || !isnan(fanSpeedPercent)) {
                            
                            client.publish("ServerRack/temperature", String(t).c_str(), true);
                            client.publish("ServerRack/humidity", String(h).c_str(), true);
                            client.publish("ServerRack/fanSpeedPercent", String(fanSpeedPercent).c_str(), true);
                      
                      //      disconnectMqtt();
                          
                          delay(DELAY_TIME);
                        }
                      }
                      
                      
                      
                      
                      void callback(char* topic, byte* payload, unsigned int length) {
                      Serial.print("Start callback ");
                        payload[length] = '\0';
                        String strTopic = String(topic);
                        String strPayload = String((char * ) payload);
                        Serial.print("hier Ausgabe ioBroker: ");
                      Serial.println(strPayload);
                        if (strTopic == "example1/led") {
                          if (strPayload == "off" || strPayload == "0" || strPayload == "false") digitalWrite(LED_pin, LOW);
                          if (strPayload == "on" || strPayload == "1" || strPayload == "true") digitalWrite(LED_pin, HIGH);
                        }
                      
                      }
                      
                      
                      
                      
                      
                      
                      
                      
                      void reconnect() {
                        while (!client.connected()) {
                          if (client.connect("ServerRack")) {
                      
                            client.subscribe("example1/led");
                      
                          } else {
                            delay(5000);
                          }
                        }
                        }
                      
                      
                      
                      
                      
                      
                      
                      B 1 Reply Last reply Reply Quote 0
                      • B
                        Beowolf @warp735 last edited by Beowolf

                        @warp735

                        So, ich habe das jetzt mal angepasst und eingefügt.

                        #include <ESP8266WiFi.h>
                        #include <ESP8266mDNS.h>
                        #include <WiFiUdp.h>
                        #include <ArduinoOTA.h>
                        #include <ESP8266WebServer.h>
                        #include <PubSubClient.h>
                        
                        WiFiClient espClient; 
                        PubSubClient mqttClient(espClient); 
                        
                        #ifndef STASSID
                        #define STASSID "------"
                        #define STAPSK  "----------------------"
                        #endif
                        
                        
                        ESP8266WebServer server(80);
                        
                        
                        
                        
                        #include <AccelStepper.h>
                        #include <Adafruit_NeoPixel.h>
                        
                        
                        
                        
                        const char* ssid = STASSID;
                        const char* password = STAPSK;
                        
                        char* mqtt_client_id = "Huehnerklappe";
                        const char* mqtt_server = "192.168.--.--";
                        const int mqtt_port = 1886;
                        const char* mqtt_user = "---------";
                        const char* mqtt_password = "---------------";
                        
                        
                        
                        //WiFiServer server(80);
                        
                        
                        AccelStepper stepper(1, D3, D4);  //Pins für den Steppermotor STEP , DIR
                        
                        #define ProgrammstartTuerAuf D0
                        #define Enable D2 // Steppermotor aktivieren/deaktivieren
                        #define PIN 3 // Umgesteuerter GPIO für die NEO-Led
                        #define NUMPIXELS 1 // Anzal der LEDs
                        
                        const byte pinTuerAuf = D6;    // Endschalter Tür offen
                        const byte pinTuerZu = D5;   // Endschalter Tür geschlossen
                        const byte pinTasterAuf = D0; // Taster Tür öffnen
                        const byte pinTasterZu = D7;  // Taster Tür schließen
                        const byte pinTasterStopp = D1; // Taster Bewegung anhalten
                        
                        const long SchritteUmdrehung = 200; // Schritte des Schrittmotors für 360 Grad der Tür
                        const unsigned int TuerbewegungZu = -15000;
                        const unsigned int TuerbewegungAuf = 15000;
                        enum ZUSTAENDE {MANUELL, TUERZU, OEFFNEN, TUERAUF, SCHLIESSEN};
                        byte zustand = MANUELL;
                        
                        Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, PIN, NEO_GRB + NEO_KHZ800);
                        
                        
                        
                        
                        void setup() {
                        
                        //GPIO Umsteuerung
                        //GPIO 1 (TX) swap the pin to a GPIO.
                        pinMode(1, FUNCTION_3);
                        //GPIO 3 (RX) swap the pin to a GPIO.
                        pinMode(3, FUNCTION_3);
                          
                        
                          Serial.begin(9600);
                          // Per WLAN mit dem Netzwerk verbinden
                          Serial.print("Connecting to ");
                          Serial.println(ssid);
                          WiFi.begin(ssid, password);
                          while (WiFi.status() != WL_CONNECTED) {
                            delay(500);
                            Serial.print(".");
                          }
                        
                        ///////////////////////
                        
                          ArduinoOTA.onStart([]() {
                            String type;
                            if (ArduinoOTA.getCommand() == U_FLASH) {
                              type = "sketch";
                            } else { // U_FS
                              type = "filesystem";
                            }
                        
                            // NOTE: if updating FS this would be the place to unmount FS using FS.end()
                            Serial.println("Start updating " + type);
                          });
                          ArduinoOTA.onEnd([]() {
                            Serial.println("\nEnd");
                          });
                          ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
                            Serial.printf("Progress: %u%%\r", (progress / (total / 100)));
                          });
                          ArduinoOTA.onError([](ota_error_t error) {
                            Serial.printf("Error[%u]: ", error);
                            if (error == OTA_AUTH_ERROR) {
                              Serial.println("Auth Failed");
                            } else if (error == OTA_BEGIN_ERROR) {
                              Serial.println("Begin Failed");
                            } else if (error == OTA_CONNECT_ERROR) {
                              Serial.println("Connect Failed");
                            } else if (error == OTA_RECEIVE_ERROR) {
                              Serial.println("Receive Failed");
                            } else if (error == OTA_END_ERROR) {
                              Serial.println("End Failed");
                            }
                          });
                          ArduinoOTA.begin();
                        //}
                        
                        //////////////////////
                          
                          // Die IP vom Webserver auf dem seriellen Monitor ausgeben
                          Serial.println("");
                          Serial.println("WLAN verbunden.");
                          Serial.println("IP Adresse: ");
                          Serial.println(WiFi.localIP());
                        
                          connectToMQTT();
                          
                        
                          server.onNotFound([](){
                            server.send(404, "text/plain", "Link wurde nicht gefunden!");  
                          });
                          server.on("/", []() {
                            server.send(200, "text/plain", "Startseite");
                          });
                          server.on("/WebTuerAuf", []() {
                            server.send(200, "text/plain", "Tuer wird geoeffnet.");
                            WebTuerAuf();
                          });
                          server.on("/WebTuerZu", []() {
                            server.send(200, "text/plain", "Tuer wird geschlossen.");
                            WebTuerZu();
                          });
                          server.begin();
                          Serial.println("Webserver gestartet.");
                        
                        
                        pixels.begin(); // This initializes the NeoPixel library.
                          
                          Serial.println("Programmanfang");
                          pinMode(PIN, OUTPUT); // NEO-LED
                          pinMode(pinTuerAuf, INPUT_PULLUP);    // Endschalter Tür offen
                          pinMode(pinTuerZu, INPUT_PULLUP);   // Endschalter Tür geschlossen
                          pinMode(pinTasterAuf, INPUT_PULLUP);  // Taster Tür öffnen
                          pinMode(pinTasterZu, INPUT_PULLUP); // Taster Tür schließen
                          pinMode(pinTasterStopp, INPUT_PULLUP);  // Taster Bewegung anhalten
                          pinMode(ProgrammstartTuerAuf, OUTPUT);
                          stepper.setMaxSpeed(1000);
                          stepper.setAcceleration(1500);
                          pinMode(Enable, OUTPUT); // Enable Motor 1
                        }
                        
                        void loop() {
                        
                          ArduinoOTA.handle();
                          ArduinoOTA.setHostname("Huehnerklappe");
                        
                          server.handleClient();
                          mqttClient.loop(); 
                        
                        
                        digitalWrite(Enable, LOW);  //Motor aktiviert
                          
                          stepper.run();
                          digitalWrite(ProgrammstartTuerAuf, digitalRead(pinTuerAuf));
                          if (!digitalRead(pinTasterStopp)) {
                            zustand = MANUELL;
                               pixels.setPixelColor(0, pixels.Color(255,255,255));  //LED Farbe weiss
                               pixels.show();
                          }
                          switch (zustand) {
                        
                        // Manuelle Steuerung
                            
                            case MANUELL:
                              if ((!digitalRead(pinTasterAuf)) && (digitalRead(pinTuerAuf))) {
                                stepper.move(10);
                              } else if ((!digitalRead(pinTasterZu)) && (digitalRead(pinTuerZu))) {
                                stepper.move(-10);
                              } else {
                                stopp();
                              }
                              if (!digitalRead(pinTuerZu)) {
                                zustand = TUERZU;
                                Serial.println("Tuer geschlossen");
                              }
                              if (!digitalRead(pinTuerAuf)) {
                                zustand = TUERAUF;
                                Serial.println("Tuer geoeffnet");
                              }
                              break;
                        
                        // Tür wird geöffnet
                              
                            case TUERZU:
                              stopp();
                              if (!digitalRead(pinTasterAuf)) {
                                stepper.move(pos(TuerbewegungAuf));
                                zustand = OEFFNEN;
                                Serial.print("Tuer oeffnet ... ");
                                  pixels.setPixelColor(0, pixels.Color(0,0,255));  //LED Farbe blau
                                  pixels.show();
                        // Schaltzustände übermitteln
                          if(digitalRead(pinTuerAuf) == HIGH){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "1");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                              }
                              break;
                        
                        // Tür ist offen
                              
                            case OEFFNEN:
                              if (!digitalRead(pinTuerAuf)) {
                                zustand = TUERAUF;
                                Serial.println("Tuer geoeffnet");
                                  pixels.setPixelColor(0, pixels.Color(255,0,0));  //LED Farbe rot
                                  pixels.show();
                        // Schaltzustände übermitteln
                          if(digitalRead(pinTuerAuf) == LOW){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "1");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                              }
                              break;
                        
                        // Tür wir geschlossen
                              
                            case TUERAUF:
                              stopp();
                              if (!digitalRead(pinTasterZu)) {
                                stepper.move(pos(TuerbewegungZu));
                                zustand = SCHLIESSEN;
                                Serial.print("Tuer schliesst ... ");
                                  pixels.setPixelColor(0, pixels.Color(0,0,255));  //LED Farbe blau
                                  pixels.show();
                        // Schaltzustände übermitteln
                          if(digitalRead(pinTuerZu) == HIGH){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "1");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                              }
                              break;
                        
                        // Tür ist geschlossen
                              
                            case SCHLIESSEN:
                              if (!digitalRead(pinTuerZu)) {
                                zustand = TUERZU;
                                Serial.println("Tuer geschlossen");
                                  pixels.setPixelColor(0, pixels.Color(0, 255,0));  //LED Farbe grün
                                  pixels.show();
                        // Schaltzustände übermitteln
                          if(digitalRead(pinTuerZu) == LOW){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "1");
                          }
                              }
                              break;
                          }
                        }
                        
                        long pos(int winkel) {
                          return (winkel * SchritteUmdrehung / 360L);
                        }
                        
                        
                        
                        void WebTuerAuf(){
                                stepper.move(pos(TuerbewegungAuf));
                                zustand = OEFFNEN;
                                Serial.print("Tuer oeffnet ... ");
                                // Schaltzustände übermitteln
                            if(digitalRead(pinTuerAuf) == HIGH){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "1");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                                // Schaltzustände übermitteln
                            if(digitalRead(pinTuerAuf) == LOW){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "1");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                                  pixels.setPixelColor(0, pixels.Color(0,0,255));  //LED Farbe blau
                                  pixels.show();
                        }
                        void WebTuerZu(){
                                stepper.move(pos(TuerbewegungZu));
                                zustand = SCHLIESSEN;
                                Serial.print("Tuer schliesst ... ");
                                // Schaltzustände übermitteln
                            if(digitalRead(pinTuerZu) == HIGH){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "1");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "0");
                          }
                                // Schaltzustände übermitteln
                            if(digitalRead(pinTuerZu) == LOW){
                            mqttClient.publish("Huehnertuer/Innen/Tuer_oeffnet", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_auf", "0");
                            mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");    
                            mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "1");
                          }
                                  pixels.setPixelColor(0, pixels.Color(0,0,255));  //LED Farbe blau
                                  pixels.show();
                        }
                        
                        
                        void stopp() {
                          stepper.stop();
                          digitalWrite(Enable, HIGH); //Motor deaktiviert
                        }
                        
                        
                        // MQTT Funktion
                        // *************
                        void connectToMQTT() {
                         mqttClient.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
                         mqttClient.subscribe("Huehnertuer/Innen");
                          
                          if (mqttClient.connect(mqtt_client_id , mqtt_user, mqtt_password)) {
                            Serial.println("connected");
                          }
                          else {
                         
                              Serial.print("failed with state ");
                              Serial.print(mqttClient.state());
                              delay(2000);
                         
                          }
                        }
                        

                        Ich habe jetzt " mqttClient.loop(); " im "void loop() {" Teil eingefügt.

                        Ist das so richtig?

                        Die Statusänderungen werden auch nach langer Zeit an ioBroker übermittel. Es funktioniert also anscheinend.

                        1 Reply Last reply Reply Quote 0
                        • First post
                          Last post

                        Support us

                        ioBroker
                        Community Adapters
                        Donate
                        FAQ Cloud / IOT
                        HowTo: Node.js-Update
                        HowTo: Backup/Restore
                        Downloads
                        BLOG

                        777
                        Online

                        31.9k
                        Users

                        80.2k
                        Topics

                        1.3m
                        Posts

                        6
                        11
                        9608
                        Loading More Posts
                        • Oldest to Newest
                        • Newest to Oldest
                        • Most Votes
                        Reply
                        • Reply as topic
                        Log in to reply
                        Community
                        Impressum | Datenschutz-Bestimmungen | Nutzungsbedingungen
                        The ioBroker Community 2014-2023
                        logo