GPIO Status Wemos d1 mini an iobroker senden

TT-Tom

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

Andreios

@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.

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?

Beowolf

@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

@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.

TT-Tom

@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?

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## <--	
}

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;

TT-Tom

@Andreas-5

Wie kann man verhindern, das nach einem Neustart des WEMOS der alte Fahrbefehl vom mqtt ignoriert wird. Das gleiche Problem wird auch auftreten, wenn er die Verbindung zum mqtt-Broker verliert. hast du da eine Idee.

Beowolf

Das ist das aktuelle Programm:

// Programm zur Ansteuerung eines Schrittmotors um eine kleine Schiebetür (Hühnerklappe) zu betätigen
// Alles läuft auf einen Wemos D1 mini.
// In Verbindung mit ioBroker ist per mqtt eine Kontrolle/Öffnen/Schliessen der Tür möglich.
// Eine lokale Steuerung ist per Taster zu jederzeit durchführbar.
// Endanschläge sind durch Reedkontakte ausgeführt.

//*******************************************************
// Das Programm und die vielen Änderungen sind mit der Hilfe von Forenmitgliedern aus dem ioBroker Forum entstanden (https://forum.iobroker.net).
//
// https://forum.iobroker.net/topic/54852/gpio-status-wemos-d1-mini-an-iobroker-senden
//
// Ein spezieller Dank geht an TT-Tom, Andreas-5, SBorg. Ohne  Mithilfe dieser Forenmitglieder würden die Hühner noch immer vor verschlossener Tür stehen.
//*******************************************************


#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();

  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 zuum 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;


  // 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 angehalten - Endlage erreicht");

  switch (zustand) {

    // Tür ist offen

    case TUERAUF:
      Serial.println("Tuer geoeffnet");
      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", "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(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", "0");
      mqttClient.publish("Huehnertuer/Innen/Tuer_schliesst", "0");
      mqttClient.publish("Huehnertuer/Innen/Tuer_zu", "1");
      break;

  }
}


/// Tuer / Motorsteuerung
void TuerSteuerung(byte zustand) {

  // stopp();
  Serial.println("Neuer Fahrbefehl");

  digitalWrite(MotorStatus, LOW);  //Motor aktiviert

  switch (zustand) {

    // Manuelle Steuerung

    case STOP:
      stopp();
      Serial.println("Motor angehalten");
      pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
      pixels.show();
      delay(stopzeitTuer);
      Serial.println("Pausenzeit abgelaufen");

      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("mqtt-Verbindung fehlgeschlagen ");
    Serial.print(mqttClient.state());
    Serial.println(" versuchen es in 5 Sekunden erneut");
    // 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("Nachricht angekommen [");
  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## <--	
}

Mqtt über ioBroker geht.

Tastensteuerung nicht wirklich.

Drücke und halte ich z.B. die Taste für ZU, fährt die Tür auch zu. Lasse ich die Taste loß bleibt die Tür stehen und ich kann sie nicht weiter schliessen.

Auch wird die LED weiß wenn ich die Taste loslasse.

Es würde reichen, wenn durch Tastendruck die Tür auf bzw. zu fährt.

Grüße
Manfred

TT-Tom

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

Das ist das aktuelle Programm:

Drücke und halte ich z.B. die Taste für ZU, fährt die Tür auch zu. Lasse ich die Taste loß bleibt die Tür stehen und ich kann sie nicht weiter schliessen.

Auch wird die LED weiß

Hi in dem Moment wo du die Taste loslässt wird die Pause von 10sek gestartet. Danach kannst du weiterfahren. Werde das umschreiben und reinstellen.

So jetzt kannst du nach dem Loslassen gleich weiterfahren, wenn du das nicht möchtest, die Zeile bei Auf und Zu Taster auskommentieren.

  TuerSteuerung(STOP_TASTER);

// Programm zur Ansteuerung eines Schrittmotors um eine kleine Schiebetür (Hühnerklappe) zu betätigen
// Alles läuft auf einen Wemos D1 mini.
// In Verbindung mit ioBroker ist per mqtt eine Kontrolle/Öffnen/Schliessen der Tür möglich.
// Eine lokale Steuerung ist per Taster zu jederzeit durchführbar.
// Endanschläge sind durch Reedkontakte ausgeführt.

//*******************************************************
// Das Programm und die vielen Änderungen sind mit der Hilfe von Forenmitgliedern aus dem ioBroker Forum entstanden (https://forum.iobroker.net).
//
// https://forum.iobroker.net/topic/54852/gpio-status-wemos-d1-mini-an-iobroker-senden
//
// Ein spezieller Dank geht an TT-Tom, Andreas-5, SBorg. Ohne  Mithilfe dieser Forenmitglieder würden die Hühner noch immer vor verschlossener Tür stehen.
//*******************************************************


#include <ESP8266WiFi.h>
#include <ArduinoOTA.h>
#include <PubSubClient.h>
#include <AccelStepper.h>
#include <Adafruit_NeoPixel.h>

#ifndef STASSID
#define STASSID "TomTom24"
#define STAPSK  "Kj1fQv7u"
#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 = "192.168.178.120";
const int mqtt_port = 1883;
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_LICHTSCHRANKE, STOP_TASTER, 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();

  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 zuum 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 / Lichtschranke LOW");
      TuerSteuerung(STOP_LICHTSCHRANKE);
    } else {
      Serial.println("Taster Stop / Lichtschranke 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_TASTER);
    }
  }
  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_TASTER);
    }
  }

  lastTasterStoppState = tasterStoppState;
  lastEndlageAufState  = endlageAufState;
  lastEndlageZuState   = endlageZuState;
  lastTasterAufState   = tasterAufState;
  lastTasterZuState    = tasterZuState;


  // 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 angehalten - Endlage erreicht");

  switch (zustand) {

    // Tür ist offen

    case TUERAUF:
      Serial.println("Tuer geoeffnet");
      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", "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(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", "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_TASTER:
      stopp();
      richtung = 0;
      Serial.println("Motor angehalten über Taster");
      pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
      pixels.show();
      break;

    case STOP_LICHTSCHRANKE:
      stopp();
      Serial.println("Motor angehalten über Lichtschranke");
      pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
      pixels.show();
      delay(stopzeitTuer);
      Serial.println("Pausenzeit abgelaufen");
      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("mqtt-Verbindung fehlgeschlagen ");
    Serial.print(mqttClient.state());
    Serial.println(" versuchen es in 5 Sekunden erneut");
    // 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("Nachricht angekommen [");
  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## <-- 
}

Andreios

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

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

Nein, den habe ich bisher nicht genutzt.
Allerdings habe ich bisher auch keine Anwendung mit Tastern, nur automatisch laufende mit Sensoren.

TT-Tom

@andreas-5
okay, ich ja auch nicht habe immer externe Widerstände genutzt.

Hast du noch eine Idee zum MQTT-Problem?

@Beowolf ist dir das schon mal aufgefallen das die Tür nach einem Neustart des WEMOS losgefahren ist?

Andreios

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

@Andreas-5

Wie kann man verhindern, das nach einem Neustart des WEMOS der alte Fahrbefehl vom mqtt ignoriert wird. Das gleiche Problem wird auch auftreten, wenn er die Verbindung zum mqtt-Broker verliert. hast du da eine Idee.

Zum Einen müsste der MQTT-Server dem Subscriber die letzten Befehle/Status senden. Das ist eine Einstellungssache, aber vielleicht ist das ja schon so eingestellt.

Dann müsste der Statusmerker undefiniert sein, also z.B. -1, aktuell sind die auf 1:

int lastTasterAufState = 1;
int tasterAufState = 1;
int lastTasterZuState = 1;
int tasterZuState = 1;
int lastTasterStoppState = 1;
int tasterStoppState = 1;

Wahrscheinlich, um den "normalen" Status 0 nach dem Start mit zu bekommen.
Wenn die auf einem nicht gültigen Wert stehen, wird auf jeden Fall einmal der Status erwischt.
Aber ACHTUNG: So wie ich das mit den Abfragen umgestellt habe, um die Prio hinein zu bringen funktioniert das nicht, weil am Ende alle Merker gesetzt werden und durch die else if nur immer einer pro Zyklus bearbeitet wird.
In dem Fall würde ich das Setzen der Merker jeweils an das Ende jedes if-Block setzen:

  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);
    }
    lastTasterStoppState = tasterStoppState;
  }
  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);
    }
    lastEndlageAufState  = endlageAufState;
    lastEndlageZuState   = endlageZuState;
  }
  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);
    }
    lastTasterAufState   = tasterAufState;
  }
  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);
    }
    lastTasterZuState    = tasterZuState;
  }

Damit wird allerdings wieder auch im normalen Ablauf jeder Statuswechsel bearbeitet, aber zumindest die höher priorisierten zuerst.
Da gibt es aber auch noch Möglichkeiten. Falls nötig muss ich da noch einmal drüber scchauen.

TT-Tom

@andreas-5
Wir warten mal auf @Beowolf seine Antworten.
Habe das Stop ja noch einmal angepasst und wenn er bis jetzt noch kein Problem mit dem MQTT hatte, lassen wir es erstmal so. Vielleicht fällt mir dazu noch was ein.

Beowolf

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

@Beowolf ist dir das schon mal aufgefallen das die Tür nach einem Neustart des WEMOS losgefahren ist?

Jepp. Schon gemerkt. Die Tür fährt zu.

Besser wäre es glaube ich, wenn die Tür nichts machen würde.

Zu der aktuellen Version.

Tastersteuerung geht fast.

Taste für AUFgedrückt - Tür fährt auf solange ich den Taster gedrückt halte - bis zum Endschalter - Tür hält an.

ABER

Wenn ich nun den Taster für ZU drücke möchte die Tür noch weiter auf fahren.

Auch bleibt die LED auf weiß wenn ich per Taster die Tür zu gefahren habe.

Das sind aber alles Dinge die im Normnalbetrieb glaube ich vollkommen egal sind.

TT-Tom

@beowolf

ich konnte leider es nicht nachstellen. Kannst du bitte mal im IoBroker den Meldungen im MQTT mit kontrollieren, wenn du von Hand fährst?

Hast du die Möglichkeit dich per USB Kabel mit dem WEMOS zu verbinden und mit Arduino IDE die Debugmeldungen im seriellen Monitor mit zu lesen?

Das mit de LED sehe ich mir nochmal an.

Beowolf

@tt-tom
Tür ist ZU - drücke Taster Tür auf bis Tür an Endschalter kommt

Taster AUF
Neuer Fahrbefehl
Tuer oeffnet ... Motor angehalten - Endlage erreicht
Tuer geoeffnet
Taster AUF losgelassen
Neuer Fahrbefehl
Motor angehalten über Taster

Jetzt ist die Tür auf - rote LED war an - weisse geht an wenn ich den Taster loaslasse.

Tür ist AUF - Taste für Tür ZU gedrückt bis Tür an Endschalter kommt

Taster ZU
Neuer Fahrbefehl
Tuer schliesst ... Motor angehalten - Endlage erreicht
Tuer geschlossen
Taster ZU losgelassen
Neuer Fahrbefehl
Motor angehalten über Taster

Jetzt ist die Tür zu - grüne LED war an - weisse geht an wenn ich den Taster loaslasse.

Tür ist ZU - drücke Taster Tür auf bis Tür an Endschalter kommt

Taster AUF
Neuer Fahrbefehl
Tuer oeffnet ... Motor angehalten - Endlage erreicht
Tuer geoeffnet
Taster AUF losgelassen
Neuer Fahrbefehl
Motor angehalten über Taster
Taster ZU
Neuer Fahrbefehl
Tuer schliesst ... Motor angehalten - Endlage erreicht
Tuer geschlossen
Taster ZU losgelassen
Neuer Fahrbefehl
Motor angehalten über Taster
Taster ZU losgelassen
Neuer Fahrbefehl
Motor angehalten über Taster

Tür ist AUF - Taste für Tür ZU gedrückt bis Tür an Endschalter kommt

Wenn ich jetzt direkt auf die ZU-TASTE drücke fährt die Tür noch ein klein wenig auf und geht dann langsam zu.

Das wird hiermit zusammen hängen

const unsigned int TuerbewegungZu =  61000;
const unsigned int TuerbewegungAuf = -61000;

Der Motor fährt bis zu diesen Werten ÜBER die Endschalter und fährt dann wieder in die entgegengesetzte Richtung. Das scheint im "Hintergrund" weiter zu laufen. Je nachdem wie schnell ich den ZU Taster drücke dreht der Motor mehr oder weniger noch nach.

Das ist alles ok so - es handelt sich immer noch um eine Hühnertür, nicht um einen Hochsicherheitssafe.

Beowolf

Was mir etwas wichtiger ist, ist das der Motor still ist nach einem Reset bzw. Stromausfall oder so.

TT-Tom

@beowolf

wenn der Motor die Endlage erreicht hat sollte er stumm sein. Das sollte über diese Funktion ausgelöst werden.

void stopp() {
  stepper.stop();
  digitalWrite(MotorStatus, HIGH); //Motor deaktiviert
}

diese wird über die Endlagen aufgerufen.
Damit der Motor nach dem Reset / Neustart ruhig bleibt, sollte im Setup folgende Zeile eingetragen werden.

digitalWrite(MotorStatus, HIGH); //Motor deaktiviert

Damit die LED beim Taster loslassen nicht die Farbe wechselt, kannst du die beiden Zeilen aus kommentieren

    case STOP_TASTER:
      stopp();
      richtung = 0;
      Serial.println("Motor angehalten über Taster");
 //     pixels.setPixelColor(0, pixels.Color(255, 255, 255)); //LED Farbe weiss
 //     pixels.show();
      break;

NEWS

GPIO Status Wemos d1 mini an iobroker senden

Support us

748
Online

31.6k
Users

79.5k
Topics

1.3m
Posts

NEWS

GPIO Status Wemos d1 mini an iobroker senden

Support us

748Online

31.6kUsers

79.5kTopics

1.3mPosts

748
Online

31.6k
Users

79.5k
Topics

1.3m
Posts