Navigation

    Logo
    • Register
    • Login
    • Search
    • Recent
    • Tags
    • Unread
    • Categories
    • Unreplied
    • Popular
    • GitHub
    • Docu
    • Hilfe
    1. Home
    2. Deutsch
    3. Skripten / Logik
    4. GPIO Status Wemos d1 mini an iobroker 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

    GPIO Status Wemos d1 mini an iobroker senden

    This topic has been deleted. Only users with topic management privileges can see it.
    • Andreios
      Andreios Forum Testing @TT-Tom last edited by

      @tt-tom sagte in GPIO Status Wemos d1 mini an iobroker senden:

      @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

      Dabei laufen sie natürlich durch die Lichtschranke - diese erkennt das und gibt es an den Wemos weiter. Dadurch stottert dann der Motor.

      wenn ich das richtig gemacht habe sollte der Stopp/Lichtschranke nur in Richtung zu auslösen. @andreas-5 kannst du da auch mal mit rauf sehen, danke.

      Ok, bisher hatte ich mir nur den kleinen Teil angeschaut, der mit dem Lebenszeichen zu tun hatte.
      Bei der Steuerung fallen mir ein paar Sachen auf, die ich erst noch einmal hinterfragen muss:

      Wenn ich es richtig verstehe, gibt es keinen Stopp-Taster, sondern das ist die Lichtschranke, ansonsten sollte die Tür stoppen, wenn die Taste los gelassen wird, oder?

      Dann würde ich auf jeden Fall die Teile nicht alle einzeln bearbeiten! Erstens, um eine Priorisierung hinein zu bringen und zweitens, um das Drücken von 2 Tasten gleichzeitig zu verhindern.

      Prio wäre dazu also:

      1. Lichtschranke, nur bei Richtung "Schliessen"
      2. Endlagen (Auf/Zu)
      3. Öffnen
      4. Schliessen

      Die Merker für die Tasten würde ich auch innerhalb der if-Statements setzen und nicht generell.
      Das könnte auch für das Stottern sorgen, weil der Stop-Merker jedesmal gesetzt wird und damit immer wieder in das if gelaufen wird.

      	tasterStoppState = digitalRead(pinTasterStopp); // Taster STOP bzw Lichtschranke
      	endlageAufState = digitalRead(pinTuerAuf); // Endlage AUF
      	endlageZuState = digitalRead(pinTuerZu); // Endlage ZU
      	tasterAufState = digitalRead(pinTasterAuf); // Taster AUF
      	tasterZuState = digitalRead(pinTasterZu); // Taster ZU
      
      	// Prio 1 Stop bei Schliessen (Lichtschranke)
      	if (   tasterStoppState != lastTasterStoppState // Status geändert
      	    && tasterStoppState == LOW 				  	// Lichtschranke belegt	
      	    && richtung == 2							// Tür schliesst
             ) {
      		Serial.println("Taster Stop LOW");
      		TuerSteuerung(STOP);
      		lastTasterStoppState = tasterStoppState;
      	} 
      	else if (endlageAufState != lastEndlageAufState) {
      		if (endlageAufState == LOW) {
      			TuerEndlagen(TUERAUF);
      		}
      		lastEndlageAufState = endlageAufState;
      	} 
      	else if (endlageZuState != lastEndlageZuState) {
      		if (endlageZuState == LOW) {
      			TuerEndlagen(TUERZU);
      		}
      		lastEndlageZuState = endlageZuState;
      	}
      	else if (tasterAufState != lastTasterAufState) {
      		if (tasterAufState == LOW) {
      			Serial.println("Taster AUF");
      			TuerSteuerung(OEFFNEN);
      		}
      		lastTasterAufState = tasterAufState;
      	} 
      	else if (tasterZuState != lastTasterZuState) {
      		if (tasterZuState == LOW) {
      			Serial.println("Taster ZU");
      			TuerSteuerung(SCHLIESSEN);
      		}
      		lastTasterZuState = tasterZuState;
      	}
      
      

      Natürlich auch wieder ungetestet,, sollte aber so passen.

      1 Reply Last reply Reply Quote 0
      • Andreios
        Andreios Forum Testing @Beowolf last edited by

        @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

        lebenszeichen

        Klar, weil ich eine Variable long lebenszeichen; vereinbart habe und nicht darauf geachtet, dass die Routine genauso heißt.
        Also habe ich jetzt lebenszeichen_ein_aus daraus gemacht.

        mqtt_iobroker_huehnertuer.ino

        Ich hoffe, jetzt klappts, sonst muss ich mir die IDE einmal auf das Notebook installieren und meine Quellen selber prüfen. 🙂

        B 2 Replies Last reply Reply Quote 0
        • B
          Beowolf @Andreios last edited by

          @andreas-5

          Was die Funktion des Programmes betrifft - eigentlich ganz einfach.

          Die Tür ist eine Hühnertür die waagerecht auf und zu gefahren wird. Wie eine Automatiktür in einem Geschäft.

          Der Befehl AUF und ZU soll von ioBroker per mqtt kommen. Die Öffnungszeiten mache ich dort.

          Die Tür hat jeweil einen Endschalter (Reedkontakt).

          TÜR-AUF Befehl - Tür fährt auf bis zum Endschalter.

          TÜR-ZU Befehl - Tür fährt zu bis zum Endschalter.

          Wenn die Tür zu fährt, überwacht eine Lichtschranke den Durchgang. Kommt ein Huhn "verspätet" so soll die Tür anhalten - einen Moment warten - und dann weiter schliessen. (Soll ja kein Hunh halbiert werden, das kommt später)

          Fährt die Tür auf, soll sich die Lichtschranke raus halten. Würde sie in der ÖFFNEN Phase die Tür ständig anhalten, würden sich die Hühner halb umbringen um raus zu kommen.

          Eine VOR-ORT Bediehung sollte auch eingebaut sein.

          Das sind erst mal die Rahmenbedingungen.

          Die Updatemöglichkeit per Wlan ist nur ein Luxus.

          Ich glaube ich habe alles.

          Grüße
          Manfred

          1 Reply Last reply Reply Quote 0
          • B
            Beowolf @Andreios last edited by

            @andreas-5 sagte in GPIO Status Wemos d1 mini an iobroker senden:

            Ich hoffe, jetzt klappts, sonst muss ich mir die IDE einmal auf das Notebook installieren und meine Quellen selber prüfen.

            Löpp - vielen Dank dafür.

            Muß jetzt erst die Augen ein wenig schliessen - war ein sehr langer Tag.

            Gute Nacht.

            Andreios 1 Reply Last reply Reply Quote 0
            • Andreios
              Andreios Forum Testing @Beowolf last edited by

              @beowolf Habe noch ein wenig weiter geschaut und eine Sache ist mir noch aufgefallen:

              /// Tuer / Motorsteuerung
              void TuerSteuerung(byte zustand) {
              
                stopp();
                Serial.println("Neuer Fahrbefehl");
              
                digitalWrite(MotorStatus, LOW);  //Motor aktiviert
              
                switch (zustand) {
              
                  // Manuelle Steuerung
              
                  case STOP:
                    stopp();
              

              Das erste stopp() in der Routine könnte auch ein Stottern verursachen! Da stoppst Du ja bei jedem Aufruf und der fand ja in der Ursprungsversion bei jedem Betätigen der Lichtschranke statt.
              Das würde ich entfernen und, wenn Du die Sicherheit einbauen willst, falls ein falscher Aufruf erfolgt, hinten im switch noch einen default einfügen.

              	default:
              		stopp();
              		break;
              
              
              B T 2 Replies Last reply Reply Quote 0
              • B
                Beowolf @Andreios last edited by

                @andreas-5

                Also sollte es so aussehen?

                
                  Serial.println("Neuer Fahrbefehl");
                
                  digitalWrite(MotorStatus, LOW);  //Motor aktiviert
                
                  switch (zustand) {
                
                    // Manuelle Steuerung
                
                    case STOP:
                      stopp();
                      Serial.println("Motor HAlT");
                      pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
                      pixels.show();
                      delay(stopzeitTuer);
                      Serial.println("Pausenzeit abgelaufen");
                
                  default:
                    stopp();
                    break;
                
                    // Tür wird geöffnet
                
                    case OEFFNEN:
                      richtung = 1;
                      if (digitalRead(pinTuerAuf)) {
                
                B T Andreios 3 Replies Last reply Reply Quote 0
                • B
                  Beowolf @Beowolf last edited by

                  Stottert noch ein klein wenig. Das ist aber egal. Die Lichtschranke spricht ja an, wenn ein Huhn durchläuft. Das sind event. zwei oder drei Impulse bis die Tür ganz auf ist. Das merkt das Huhn nicht! 👍 👍

                  Andreios 1 Reply Last reply Reply Quote 0
                  • T
                    TT-Tom @Andreios last edited by

                    @andreas-5 sagte in GPIO Status Wemos d1 mini an iobroker senden:

                    Habe noch ein wenig weiter geschaut und eine Sache ist mir noch aufgefallen:

                    Das erste stopp() in der Routine könnte auch ein Stottern verursachen! Da stoppst Du ja bei jedem Aufruf und der fand ja in der Ursprungsversion bei jedem Betätigen der Lichtschranke statt.
                    Das würde ich entfernen und, wenn Du die Sicherheit einbauen willst, falls ein falscher Aufruf erfolgt, hinten im switch noch einen default einfügen.

                    der erste Stop war drin, um den Motor vor Richtungswechsel an zu halten.
                    @beowolf Die Frage ist, muss vor Richtungswechsel ein Stop gemacht werden? ist das dem Controller / Motor egal?

                    B 1 Reply Last reply Reply Quote 0
                    • T
                      TT-Tom @Beowolf last edited by

                      @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

                      @andreas-5

                      Also sollte es so aussehen?

                      
                        Serial.println("Neuer Fahrbefehl");
                      
                        digitalWrite(MotorStatus, LOW);  //Motor aktiviert
                      
                        switch (zustand) {
                      
                          // Manuelle Steuerung
                      
                          case STOP:
                            stopp();
                            Serial.println("Motor HAlT");
                            pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
                            pixels.show();
                            delay(stopzeitTuer);
                            Serial.println("Pausenzeit abgelaufen");
                      
                        default:
                          stopp();
                          break;
                      
                          // Tür wird geöffnet
                      
                          case OEFFNEN:
                            richtung = 1;
                            if (digitalRead(pinTuerAuf)) {
                      

                      in Zeile 17 müsste noch ein

                      break;
                      
                      1 Reply Last reply Reply Quote 0
                      • Andreios
                        Andreios Forum Testing @Beowolf last edited by

                        @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

                        @andreas-5

                        Also sollte es so aussehen?

                        Genau, wobei ich das "default:" immer als letztes in das switch schreibe, weil es mir dann beim Lesen/Debuggen logisch ist, dass das dann kommt, wenn alles Andere nicht trifft.
                        Aber das ist nur persönliche Präferenz, die Funktionalität sollte gegeben sein, egal wo das steht! 😉

                        1 Reply Last reply Reply Quote 0
                        • Andreios
                          Andreios Forum Testing @Beowolf last edited by

                          @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

                          Stottert noch ein klein wenig. Das ist aber egal. Die Lichtschranke spricht ja an, wenn ein Huhn durchläuft. Das sind event. zwei oder drei Impulse bis die Tür ganz auf ist. Das merkt das Huhn nicht! 👍 👍

                          Das kam mir trotzdem komisch vor, weil das, meiner Meinung nach, nicht mehr vorkommen sollte,
                          Ich habe dann noch einmal nachgesehen, was ich da hochgeladen habe und da sind einige Änderungen gar nicht drin.
                          Was habe ich denn da gemacht?
                          War wohl doch zu müde gestern.

                          Ich stelle den Teil gleich noch einmal um.

                          Andreios 1 Reply Last reply Reply Quote 0
                          • B
                            Beowolf @TT-Tom last edited by

                            @tt-tom sagte in GPIO Status Wemos d1 mini an iobroker senden:

                            @beowolf Die Frage ist, muss vor Richtungswechsel ein Stop gemacht werden? ist das dem Controller / Motor egal?

                            Keinen Dunst.

                            Ich glaube diese AccelStepper.h Bibliothek braucht das. Dem Motor ist das glaube ich egal.

                            T 1 Reply Last reply Reply Quote 0
                            • T
                              TT-Tom @Beowolf last edited by

                              @beowolf

                              hast du jeden einzeln Eingang mit einem Widerstand (10k) auf 3,3,V gezogen?

                              B 1 Reply Last reply Reply Quote 0
                              • Andreios
                                Andreios Forum Testing @Andreios last edited by

                                @andreas-5 So, jetzt noch einmal die Umstellung:

                                // Vorher 
                                
                                  // Taster STOP bzw Lichtschranke
                                  tasterStoppState = digitalRead(pinTasterStopp);
                                
                                  // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                  if (tasterStoppState != lastTasterStoppState) {
                                    // Stoptaster und Richtung Zu löst Halt aus
                                    if ((tasterStoppState == LOW) && (richtung == 2)) {
                                      Serial.println("Taster Stop LOW");
                                      TuerSteuerung(STOP);
                                    } else {
                                      Serial.println("Taster Stop High");
                                      //      if (richtung == 1) {
                                      //        TuerSteuerung(OEFFNEN);
                                      //      }
                                      if (richtung == 2) {
                                        TuerSteuerung(SCHLIESSEN);
                                      }
                                    }
                                  }
                                
                                  lastTasterStoppState = tasterStoppState;
                                
                                  // Taster AUF
                                  tasterAufState = digitalRead(pinTasterAuf);
                                
                                  // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                  if (tasterAufState != lastTasterAufState) {
                                    if (tasterAufState == LOW) {
                                      Serial.println("Taster AUF");
                                      TuerSteuerung(OEFFNEN);
                                    }
                                  }
                                
                                  lastTasterAufState = tasterAufState;
                                
                                  // Taster ZU
                                  tasterZuState = digitalRead(pinTasterZu);
                                
                                  // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                  if (tasterZuState != lastTasterZuState) {
                                    if (tasterZuState == LOW) {
                                      Serial.println("Taster ZU");
                                      TuerSteuerung(SCHLIESSEN);
                                    }
                                  }
                                
                                  lastTasterZuState = tasterZuState;
                                
                                  // Endlage AUF
                                  endlageAufState = digitalRead(pinTuerAuf);
                                
                                  // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird,
                                  // sondern nur bei Änderung
                                  if (endlageAufState != lastEndlageAufState) {
                                    if (endlageAufState == LOW) {
                                      TuerEndlagen(TUERAUF);
                                    }
                                  }
                                
                                  lastEndlageAufState = endlageAufState;
                                
                                  // Endlage ZU
                                  endlageZuState = digitalRead(pinTuerZu);
                                
                                  // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird,
                                  // sondern nur bei Änderung
                                  if (endlageZuState != lastEndlageZuState) {
                                    if (endlageZuState == LOW) {
                                      TuerEndlagen(TUERZU);
                                    }
                                  }
                                
                                  lastEndlageZuState = endlageZuState;
                                
                                
                                // Nachher
                                  
                                  tasterStoppState = digitalRead(pinTasterStopp); // Taster STOP bzw Lichtschranke
                                  endlageAufState  = digitalRead(pinTuerAuf); 	  // Endlage AUF
                                  endlageZuState   = digitalRead(pinTuerZu); 	  // Endlage ZU
                                  tasterAufState   = digitalRead(pinTasterAuf);   // Taster AUF
                                  tasterZuState    = digitalRead(pinTasterZu); 	  // Taster ZU
                                
                                  // Hardwaretasten
                                  // Ich gehe davon aus, dass der Motor so lange laufen soll, wie die Taste festgehalten wird.
                                  // Wird die Taste losgelassen, soll gestoppt werden.
                                  // 
                                  // Wird die Klappe über ioBroker/MQTT gesteuert, müssen da ja eigene Variablen her, damit sich das nicht
                                  // vermischt.
                                  // Dann würde ich aber genau dieses Vorgehen hier nutzen, aber die tasterAufState und tasterZuState aus den
                                  // beiden Möglichkeiten, Hardwaretaster und ioBroker/MQTT erzeugen.
                                  // Dabei muss dann ein wenig Sicherheit mit rein, z.B. wenn einer von beiden Zuständen wieder auf "Stopp" geht
                                  // sollte gestoppt werden, auch wenn der andere noch auf fahren steht. Beispiel: ioBroker fährt die Klappe zu, 
                                  // jemand steht daneben und sieht, das etwas nicht stimmt, dann braucht er nur auf die Taste drücken und loslassen,
                                  // dann stoppt die Tür. Das kann man natürlich noch weiter spinnen, so dass zum stoppen egal ist, welche Taste 
                                  // gerade gedrückt wird. (Na, jetzt schweife ich schon wieder ab!) ;-)
                                  
                                  if (tasterStoppState != lastTasterStoppState) { // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                    // Stoptaster und Richtung Zu löst Halt aus
                                    if ((tasterStoppState == LOW) && (richtung == 2)) {
                                      Serial.println("Taster Stop LOW");
                                      TuerSteuerung(STOP);
                                    } else {
                                      Serial.println("Taster Stop High"); // Lichtschranke wieder frei
                                      if (richtung == 2) // Nur dann, wenn vorher auch schon SCHLIESSEN aktiv war, hier weiter fahren, wenn Lichtschranke frei.
                                        TuerSteuerung(SCHLIESSEN);
                                    }
                                  }
                                  else if (endlageAufState != lastEndlageAufState) { // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird, sondern nur bei Änderung
                                    if (endlageAufState == LOW) {
                                      TuerEndlagen(TUERAUF);
                                    }
                                  }
                                  else if (endlageZuState != lastEndlageZuState) { // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird, sondern nur bei Änderung
                                    if (endlageZuState == LOW) {
                                      TuerEndlagen(TUERZU);
                                    }
                                  }
                                  else if (tasterAufState != lastTasterAufState) { // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                    if (tasterAufState == LOW && endlageAufState != LOW) { // Hier würde ich auf jeden Fall die Endlage mit einbeziehen, da ansonsten der Motor zumindest startet.
                                      Serial.println("Taster AUF");
                                      TuerSteuerung(OEFFNEN);
                                    } else {                                          // Und auch beim loslassen stoppen.
                                      Serial.println("Taster AUF losgelassen");
                                      TuerSteuerung(STOP);
                                    }
                                  }
                                  else if (tasterZuState != lastTasterZuState) { // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                    if (tasterZuState == LOW && endlageZuState != LOW) { // Hier würde ich auf jeden Fall die Endlage mit einbeziehen, da ansonsten der Motor zumindest startet.
                                      Serial.println("Taster ZU");
                                      TuerSteuerung(SCHLIESSEN);
                                    } else {                                          // Und auch beim loslassen stoppen.   
                                      Serial.println("Taster ZU losgelassen");
                                      TuerSteuerung(STOP);
                                    }
                                  }
                                
                                  lastTasterStoppState = tasterStoppState;
                                  lastEndlageAufState  = endlageAufState;
                                  lastEndlageZuState   = endlageZuState;
                                  lastTasterAufState   = tasterAufState;
                                  lastTasterZuState    = tasterZuState;
                                
                                
                                

                                Das last???State-Merker-Setzen habe ich an das Ende gesetzt.
                                Ich hatte zwar weiter oben geschrieben, dass das in den If gemacht werden sollte, aber wenn man das hinterher macht ist der Effekt, dass, wenn die Prio so trifft, dass z.B. die Endlage erreicht wurde und jedoch gleichzeitig sich der Tastenstatus geändert hat, dieser nicht im nächsten Zyklus noch zuschlägt, sondern einfach ignoriert wird.
                                Das war mir sicherer.

                                B 1 Reply Last reply Reply Quote 0
                                • B
                                  Beowolf @TT-Tom last edited by Beowolf

                                  @tt-tom sagte in GPIO Status Wemos d1 mini an iobroker senden:

                                  @beowolf

                                  hast du jeden einzeln Eingang mit einem Widerstand (10k) auf 3,3,V gezogen?

                                  nö. Das ist doch mit "INPUT_PULLUP" erledigt, oder?

                                  T 1 Reply Last reply Reply Quote 0
                                  • B
                                    Beowolf @Andreios last edited by

                                    @andreas-5 sagte in GPIO Status Wemos d1 mini an iobroker senden:

                                    Das last???State-Merker-Setzen habe ich an das Ende gesetzt.
                                    Ich hatte zwar weiter oben geschrieben, dass das in den If gemacht werden sollte, aber wenn man das hinterher macht ist der Effekt, dass, wenn die Prio so trifft, dass z.B. die Endlage erreicht wurde und jedoch gleichzeitig sich der Tastenstatus geändert hat, dieser nicht im nächsten Zyklus noch zuschlägt, sondern einfach ignoriert wird.
                                    Das war mir sicherer.

                                    Kannst Du den kompletten Code noch einmal einstelle? Habe jetzt was kopiert - geht aber nicht.

                                    Andreios 1 Reply Last reply Reply Quote 0
                                    • Andreios
                                      Andreios Forum Testing @Beowolf last edited by

                                      @beowolf mqtt_iobroker_huehnertuer-2022-06-15-01.ino

                                      Ich hoffe, das ist jetzt die richtige Version, nachdem ich gestern wohl 'nen Wurm drin hatte. Deshalb hatte ich nur den Teil genommen, um den es ging. 🤦‍♂️

                                      B 1 Reply Last reply Reply Quote 0
                                      • T
                                        TT-Tom @Beowolf last edited by

                                        @beowolf sagte in GPIO Status Wemos d1 mini an iobroker senden:

                                        @tt-tom sagte in GPIO Status Wemos d1 mini an iobroker senden:

                                        @beowolf

                                        hast du jeden einzeln Eingang mit einem Widerstand (10k) auf 3,3,V gezogen?

                                        nö. Das ist doch mit "INPUT_PULLUP" erledigt, oder?

                                        Wie ich dir schon geschrieben hatte, habe ich auf meinem Testbrett die Taster mit den zusätzlichen Widerständen versehen. Danach ging der Fahrbefehl auch nur einmal raus Richtung auf. Wenn das mit der Anpassung von @Andreas-5 jetzt funktioniert, okay. Wie gesagt man kann nur lernen hier.
                                        Ich würde das sonst nochmal probieren.

                                        Werde den Code heute Abend mal bei mir laufen lassen. Danke für die Hilfe Andreas.

                                        @Andreas-5 Was hast du für Erfahrungen mit dem Befehl INPUT_PULLUP gemacht?

                                        Andreios 1 Reply Last reply Reply Quote 0
                                        • B
                                          Beowolf @Andreios last edited by Beowolf

                                          @andreas-5 sagte in GPIO Status Wemos d1 mini an iobroker senden:

                                          @beowolf mqtt_iobroker_huehnertuer-2022-06-15-01.ino

                                          Ich hoffe, das ist jetzt die richtige Version, nachdem ich gestern wohl 'nen Wurm drin hatte. Deshalb hatte ich nur den Teil genommen, um den es ging. 🤦‍♂️

                                          Tut mir leid, aber die Version läuft nicht. Die Steuerung per Tasten geht nicht.

                                          Per mqtt nur begrenzt. Auf und ZU geht. Bei ZU und Unterbrechung per Lichtschranke läuft der Motor nicht wieder an.

                                          Diese Version funktioniert.

                                          #include <ESP8266WiFi.h>
                                          #include <ArduinoOTA.h>
                                          #include <PubSubClient.h>
                                          #include <AccelStepper.h>
                                          #include <Adafruit_NeoPixel.h>
                                          
                                          #ifndef STASSID
                                          #define STASSID "------"
                                          #define STAPSK  "------------"
                                          #endif
                                          
                                          #define MotorStatus D2 // Steppermotor aktivieren/deaktivieren
                                          #define LEDpin 3 // Umgesteuerter GPIO für die NEO-Led
                                          #define NUMPIXELS 1 // Anzal der LEDs
                                          
                                          const char* ssid = STASSID;
                                          const char* password = STAPSK;
                                          
                                          char* mqtt_client_id = "Huehnerklappe";
                                          const char* mqtt_server = "----";
                                          const int mqtt_port = ----;
                                          const char* mqtt_user = "-----";
                                          const char* mqtt_password = "-----";
                                          
                                          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 =  61000;
                                          const unsigned int TuerbewegungAuf = -61000;
                                          enum ZUSTAENDE {STOP, TUERZU, OEFFNEN, TUERAUF, SCHLIESSEN};
                                          
                                          int lastEndlageAufState = 1;
                                          int endlageAufState = 1;
                                          int lastEndlageZuState = 1 ;
                                          int endlageZuState = 1;
                                          
                                          int lastTasterAufState = 1;
                                          int tasterAufState = 1;
                                          int lastTasterZuState = 1;
                                          int tasterZuState = 1;
                                          int lastTasterStoppState = 1;
                                          int tasterStoppState = 1;
                                          
                                          int richtung = 0; //  1 > Auf, 2 > Zu
                                          int stopzeitTuer = 10000; //Pausenzeit bis Weiterfahrt in ms
                                          int lebenszeichen_zaehler = 0; // Zähler um Lebenzeichen an MQTT Broker zusenden
                                          int lebenszeichen_interval = 10; // interval für MQTT Broker in sek
                                          
                                          long led_takt    = 500; // Zeittakt (ms) für die LED  ##takt##
                                          long led_zeit; // Letzter Durchlauf (ms) für die LED  ##takt##
                                          long lebenszeichen_takt = lebenszeichen_interval * 1000; // Zeittakt (ms)  ##takt##
                                          long lebenszeichen_zeit; // Letzter Durchlauf (ms)  ##takt##
                                          long lebenszeichen_ein_aus = 0; // ##takt##
                                          
                                          
                                          WiFiClient espClient;
                                          PubSubClient mqttClient(espClient);
                                          
                                          AccelStepper stepper(1, D3, D4);  //Pins für den Steppermotor STEP , DIR
                                          AccelStepper stepperauf(1, D3, D4);  //Pins für den Steppermotor STEP , DIR
                                          Adafruit_NeoPixel pixels = Adafruit_NeoPixel(1, LEDpin, 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);
                                            pinMode(LEDpin, 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(MotorStatus, OUTPUT); // Enable Motor 1
                                            pinMode(LED_BUILTIN, OUTPUT); // Board-LED nutzen
                                            stepper.setMaxSpeed(1000);
                                            stepperauf.setMaxSpeed(6000);
                                            stepper.setAcceleration(1500);
                                            stepperauf.setAcceleration(6000);
                                          
                                            Serial.begin(9600);
                                            //  while(!Serial){
                                            //    ; // wartet bis die serielle Schnittstelle eine Verbindung hergestellt hat. Wird für natives USB benötigt
                                            //  }
                                          
                                            // Per WLAN mit dem Netzwerk verbinden
                                            Serial.print("Verbinden mit ");
                                            Serial.println(ssid);
                                            WiFi.begin(ssid, password);
                                            while (WiFi.status() != WL_CONNECTED) {
                                              delay(500);
                                              Serial.print(".");
                                            }
                                          
                                            ///////////////////////////////////////////
                                            // Anfang Update über Wlan
                                            ///////////////////////////////////////////
                                          
                                            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();
                                          
                                            ///////////////////////////////////////////
                                            // Ende Update über Wlan
                                            ///////////////////////////////////////////
                                          
                                            // Die IP vom Webserver auf dem seriellen Monitor ausgeben
                                            Serial.println("");
                                            Serial.println("WLAN verbunden.");
                                            Serial.println("IP Adresse: ");
                                            Serial.println(WiFi.localIP());
                                          
                                            // MQTT Brocker
                                            // Mit ioBroker Mqtt verbinden
                                            mqttClient.setServer(mqtt_server, mqtt_port);//MQTT Server, - Port
                                            mqttClient.setCallback(callback);
                                          
                                            // NEO_Pixel Start
                                            pixels.begin(); // This initializes the NeoPixel library.
                                          
                                            lebenszeichen_zeit = millis(); // ##takt##
                                            led_zeit = millis(); // ##takt##
                                            
                                            Serial.println("Programmanfang");
                                          }
                                          
                                          //ende Setup
                                          //////////////////////////////////////////////////////////////////////////////////
                                          
                                          void loop() {
                                          
                                            lebenszeichen();
                                          
                                            ArduinoOTA.handle();
                                            ArduinoOTA.setHostname("Huehnerklappe");
                                          
                                            stepper.run();
                                            stepperauf.run();
                                          
                                            // Taster STOP bzw Lichtschranke
                                            tasterStoppState = digitalRead(pinTasterStopp);
                                          
                                            // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                            if (tasterStoppState != lastTasterStoppState) {
                                              // Stoptaster und Richtung Zu löst Halt aus
                                              if ((tasterStoppState == LOW) && (richtung == 2)) {
                                                Serial.println("Taster Stop LOW");
                                                TuerSteuerung(STOP);
                                              } else {
                                                Serial.println("Taster Stop High");
                                                //      if (richtung == 1) {
                                                //        TuerSteuerung(OEFFNEN);
                                                //      }
                                                if (richtung == 2) {
                                                  TuerSteuerung(SCHLIESSEN);
                                                }
                                              }
                                            }
                                          
                                            lastTasterStoppState = tasterStoppState;
                                          
                                            // Taster AUF
                                            tasterAufState = digitalRead(pinTasterAuf);
                                          
                                            // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                            if (tasterAufState != lastTasterAufState) {
                                              if (tasterAufState == LOW) {
                                                Serial.println("Taster AUF");
                                                TuerSteuerung(OEFFNEN);
                                              }
                                            }
                                          
                                            lastTasterAufState = tasterAufState;
                                          
                                            // Taster ZU
                                            tasterZuState = digitalRead(pinTasterZu);
                                          
                                            // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                            if (tasterZuState != lastTasterZuState) {
                                              if (tasterZuState == LOW) {
                                                Serial.println("Taster ZU");
                                                TuerSteuerung(SCHLIESSEN);
                                              }
                                            }
                                          
                                            lastTasterZuState = tasterZuState;
                                          
                                            // Endlage AUF
                                            endlageAufState = digitalRead(pinTuerAuf);
                                          
                                            // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird,
                                            // sondern nur bei Änderung
                                            if (endlageAufState != lastEndlageAufState) {
                                              if (endlageAufState == LOW) {
                                                TuerEndlagen(TUERAUF);
                                              }
                                            }
                                          
                                            lastEndlageAufState = endlageAufState;
                                          
                                            // Endlage ZU
                                            endlageZuState = digitalRead(pinTuerZu);
                                          
                                            // Abfrage damit nicht bei jedem Durchlauf die Endlage neu gesetzt wird,
                                            // sondern nur bei Änderung
                                            if (endlageZuState != lastEndlageZuState) {
                                              if (endlageZuState == LOW) {
                                                TuerEndlagen(TUERZU);
                                              }
                                            }
                                          
                                            lastEndlageZuState = endlageZuState;
                                          
                                            // MQTT Broker
                                            mqttClient.loop();
                                            if (!mqttClient.connected()) {
                                              reconnectToMQTT();
                                            }
                                          
                                          
                                          }
                                          
                                          //ende loop
                                          /////////////////////////////////////////////////////////////////////////////////
                                          
                                          
                                          long pos(int winkel) {
                                            return (winkel * SchritteUmdrehung / 360L);
                                          }
                                          
                                          
                                          
                                          // Endlagen Steuerung
                                          void TuerEndlagen(byte zustand) {
                                          
                                            stopp();
                                            richtung = 0;
                                            Serial.println("Motor HAlT Endlage erreicht");
                                          
                                            switch (zustand) {
                                          
                                              // Tür ist offen
                                          
                                              case TUERAUF:
                                                Serial.println("Tuer geoeffnet");
                                                pixels.setPixelColor(0, pixels.Color(0, 255, 0)); //LED Farbe grün
                                                pixels.show();
                                                // Schaltzustände übermitteln
                                                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 ist geschlossen
                                          
                                              case TUERZU:
                                                Serial.println("Tuer geschlossen");
                                                pixels.setPixelColor(0, pixels.Color(255, 0, 0)); //LED Farbe rot
                                                pixels.show();
                                                // Schaltzustände übermitteln
                                                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;
                                          
                                            }
                                          }
                                          
                                          
                                          /// Tuer / Motorsteuerung
                                          void TuerSteuerung(byte zustand) {
                                          
                                            Serial.println("Neuer Fahrbefehl");
                                          
                                            digitalWrite(MotorStatus, LOW);  //Motor aktiviert
                                          
                                            switch (zustand) {
                                          
                                              // Manuelle Steuerung
                                          
                                              case STOP:
                                                stopp();
                                                Serial.println("Motor HAlT");
                                                pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
                                                pixels.show();
                                                delay(stopzeitTuer);
                                                Serial.println("Pausenzeit abgelaufen");
                                                
                                              break; 
                                            default:
                                              stopp();
                                              break;
                                          
                                              // Tür wird geöffnet
                                          
                                              case OEFFNEN:
                                                richtung = 1;
                                                if (digitalRead(pinTuerAuf)) {
                                                  stepperauf.move(pos(TuerbewegungAuf));
                                                  Serial.print("Tuer oeffnet ... ");
                                                  pixels.setPixelColor(0, pixels.Color(0, 0, 255)); //LED Farbe blau
                                                  pixels.show();
                                                  // Schaltzustände übermitteln
                                                  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 wir geschlossen
                                          
                                              case SCHLIESSEN:
                                                richtung = 2;
                                                if ((digitalRead(pinTuerZu)) && (digitalRead(pinTasterStopp))) {
                                                  stepper.move(pos(TuerbewegungZu));
                                                  Serial.print("Tuer schliesst ... ");
                                                  pixels.setPixelColor(0, pixels.Color(0, 0, 255)); //LED Farbe blau
                                                  pixels.show();
                                                  // Schaltzustände übermitteln
                                                  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;
                                            }
                                          }
                                          
                                          
                                          void stopp() {
                                            stepper.stop();
                                            digitalWrite(MotorStatus, HIGH); //Motor deaktiviert
                                          }
                                          
                                          
                                          
                                          // MQTT Funktion
                                          // *************
                                          void reconnectToMQTT() {
                                          
                                            if (mqttClient.connect(mqtt_client_id , mqtt_user, mqtt_password)) {
                                              Serial.println("Per MQTT mit ioBroker verbunden");
                                          
                                              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", "0");
                                              mqttClient.publish("Huehnertuer/Innen/alive", "0");
                                          
                                              mqttClient.subscribe("Huehnertuer/Innen/Tuer");
                                            } else {
                                              Serial.print("failed with state ");
                                              Serial.print(mqttClient.state());
                                              Serial.println(" try again in 5 seconds");
                                              // Wait 5 seconds before retrying
                                              delay(5000);
                                            }
                                          }
                                          
                                          
                                          // MQTT Callback
                                          void callback(char* topic, byte* payload, unsigned int length)
                                          {
                                          
                                            payload[length] = '\0';
                                            String strTopic = String(topic);
                                            String strPayload = String((char * ) payload);
                                          
                                            Serial.print("Message arrived [");
                                            Serial.print(strTopic);
                                            Serial.print("----");
                                            Serial.print(strPayload);
                                            Serial.print("] ");
                                            Serial.println();
                                          
                                          
                                            if (strTopic == "Huehnertuer/Innen/Tuer")
                                            {
                                              // Tuer schliessen
                                              if (strPayload == "false") {
                                                Serial.println("Tuer schliesst über IoBroker");
                                                TuerSteuerung(SCHLIESSEN);
                                              }
                                          
                                              // Tuer öffnen
                                              if (strPayload == "true") {
                                                Serial.println("Tuer oeffnet über IoBroker");
                                                TuerSteuerung(OEFFNEN);
                                              }
                                            }
                                          }
                                          
                                          void lebenszeichen() {
                                          	
                                          	// ##takt## -->	
                                          	long current_time = millis();
                                          	// LED auf dem Board blinken lassen
                                          	if (led_zeit <= current_time) {
                                          		if (digitalRead(LED_BUILTIN) == HIGH)
                                          			digitalWrite(LED_BUILTIN, LOW);
                                          		else
                                          			digitalWrite(LED_BUILTIN, HIGH);
                                          		while (led_zeit <= current_time)
                                          			led_zeit += led_takt;
                                          	}
                                            
                                          	if (lebenszeichen_zeit <= current_time) {
                                          		if (lebenszeichen_ein_aus == 0) {
                                          			mqttClient.publish("Huehnertuer/Innen/alive", "1");
                                          			lebenszeichen_ein_aus = 1;
                                          		} else {
                                          			mqttClient.publish("Huehnertuer/Innen/alive", "0");
                                          			lebenszeichen_ein_aus = 0;
                                          		}
                                          		while (lebenszeichen_zeit <= current_time)
                                          			lebenszeichen_zeit += lebenszeichen_takt;
                                          	}
                                          	// ##takt## <--	
                                          }
                                          
                                          T 1 Reply Last reply Reply Quote 0
                                          • T
                                            TT-Tom @Beowolf last edited by TT-Tom

                                            @beowolf

                                            Ich habe die Version von Andreas getestet. Diese Funktion hat er eingebaut. Über Taster fährt die Tür nur, solange der Taster festgehalten wird.

                                             else if (tasterAufState != lastTasterAufState) { // Abfrage damit nur bei Änderung am Taster Aktion ausgeführt wird
                                                if (tasterAufState == LOW && endlageAufState != LOW) { // Hier würde ich auf jeden Fall die Endlage mit einbeziehen, da ansonsten der Motor zumindest startet.
                                                  Serial.println("Taster AUF");
                                                  TuerSteuerung(OEFFNEN);
                                                } else {                                          // Und auch beim loslassen stoppen.
                                                  Serial.println("Taster AUF losgelassen");
                                                  TuerSteuerung(STOP);
                                                }
                                              }
                                            

                                            @Andreas-5
                                            Des Weiteren ist ein Fehler drin, die Richtung wird bei Stop gelöscht / auf Null gesetzt. Zeile 3 müsste raus, sonst fährt die Tür Richtung Zu nicht weiter nach Ablauf der Pausenzeit.

                                               case STOP:
                                                  stopp();
                                                  richtung = 0;
                                                  Serial.println("Motor HAlT");
                                                  pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
                                                  pixels.show();
                                                  delay(stopzeitTuer);
                                                  Serial.println("Pausenzeit abgelaufen");
                                            
                                                  break;
                                            
                                            1 Reply Last reply Reply Quote 0
                                            • First post
                                              Last post

                                            Support us

                                            ioBroker
                                            Community Adapters
                                            Donate

                                            610
                                            Online

                                            31.9k
                                            Users

                                            80.1k
                                            Topics

                                            1.3m
                                            Posts

                                            5
                                            193
                                            16659
                                            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