Portexpander MCP23017 Problem

Hallo ich bins wieder mal! Die Probleme hören nicht auf.

Ich habe jetzt eine Steuerung mit dem MCP23017 entworfen, die auch soweit funktioniert.
Es tritt aber manchmal der Fall auf, dass alle Ausgänge des MCP23017 auf einmal ausgeschaltet werden, ohne dass ich im Programm irgendwas eingetragen hab! Das passiert zufällig zeitverzögert bei einer Aktion vom Chip oder einem Tastendruck der auch am MCP23017 hängt.

An was könnte das den liegen? Den Reset Pin hab ich dauerhaft auf 3,3V gelegt, und hab aber keine Pullups im I2C Bus, weil die Leitug nur ca. 10cm lang ist!

Wäre dankbar für Hilfe!

Lg Theo

Wenn Deine Module keine Pullups haben (stromlos nachmessen), müssen welche ran.
Ansonsten wie steuerst Du den MCP23017 an?
Ohne Sketch und Link zu den Libs können wir höchstens würfeln.

Gruß Tommy

Okay dann bau ich die Steuerung mal eben schnell aus und bau welche ein! Am besten 1K auf 3,3V oder?

Der Portexpander(MCP23017) wird mit I2C angesteuert

Ich kann den Code gerne Posten, es sind hald 543 Zeilen :smiley:

Die Librarie heißt “Adafruit_MCP23017_Arduino_Library” Github Link

und hab aber keine Pullups im I2C Bus, weil die Leitug nur ca. 10cm lang ist!

Lustige Idee....

:smiling_imp: Du erhellst meinen Tag :smiling_imp:

theo416:
Ich kann den Code gerne Posten, es sind hald 543 Zeilen :smiley:

Du kannst auch den Code so verschlanken, dass das Problem noch auftritt aber alles für die Lösung unnötige raus ist.

Gruß Tommy

Soo, hab jez mal nachgemessen und herausgefunden, dass ich zwischen SDA/SCL und 3,3V 4,7KOhm hab!
Ich habe ja auch noch eine DS3231 RTC eingebaut die höchstwahrscheinlich pullups drinnen hat(wahrscheinlich diese 4,7K). Also liegts am Bus schonmal nicht würd ich jez vermuten!

Zum Code: Egal welchen Teil ich entferne, hab ich schon probiert, der Fehler tritt immer auf. Und nach meinen Erkenntnissen ist am Code auch nichts(vielleicht übertrieben irgendwelche Fehler hat man immer) falsch was die Ausgänge betrifft!

Der Bus steigt nämlich nur so "halb" aus! Alle Eingänge am Expander werden weiterhin an den NODE Mcu gesendet und verarbeitet, aber es kann kein Ausgang mehr gesendet werden.

Ich poste jetzt einfach mal den ganzen Code hier rein, aber da wird sich schwer was finden bei der Länge. Noch kurz was der Code macht: Es ist eine Hühnertürsteuerung die über MQTT-Protokoll mit einem MQTT-Server "redet" und dies dann visualisiert wird. Jeden Tag werden die neuen Auf/Zu Zeiten und die Aktuelle Zeit an das NODE MCU gesendet. Wenn Auf/Zu Zeit erreicht ist, dann fährt auf/zu. Es gibt auch einen Manuellen Modus mit einem Taster für Auf/Stop/Zu/Stop... und einen zum Modus umschalten!

Den Code muss ich einen Extra post schreiben!

Wenn Der Fehler immer auftritt, auch wenn Du Teile weg läßt, dann lasse diese Teile weg. Du erleichterst Dir und uns die Suche und erhöhst evtl. die Lust, sich das anzuschauen.

Übrigens: Wenn nach Deiner Meinung die Schaltung ok ist und auch keine Fehler im Sketch sind, dann funktioniert es. Erkennst Du den Fehler?

Gruß Tommy

Ja klar erkenne ich es! Der Fehler liegt bestimmt an mr in der Soft/Hardware aber ich finde ihn ums verrecken einfach seit 4 Wochen nicht :frowning:

Ich versuche jez mal alle unnötigen Teile wie Außenlicht, ... wegzulassen und den Rest hier zu posten!

Kann kurz dauern bis ich das alles hab :o

So hier der verkürzte Code Teil 1 von 3! Teil 2 und 3 kommt im 5min Interval wegen Postzeit Pause

/*  
 *   NodeMCU:
 *     IP: 192.168.178.39
 *     ID: N01
 *     Gerätenummer: 52277
 *   
 *   I2C Adressen:
 *    RTC EEPROM        : 0x57
 *    RTC selber        : 0x68
 *    MCP23017(IOExp000): 0x20 (Weitere Chips: 0x21 bis 0x27)
 *    Temp Sensor innen : 0x48 > A0=GND A1=GND A2=GND
 *    Temp Sensor außen : 0x4C > A0=GND A1=GND A2=VCC
 */

#include <ESP8266WiFi.h>                          //ESP8266 WLAN Bibliothek einbinden
#include <Wire.h>                                 //I2C Bibliothek einbinden
#include <Adafruit_MCP23017.h>                    //MCP23017 16Bit I2C Portexpander Bibliothek einbinden

//*****************************************
 
Adafruit_MCP23017 IOExp000;                       //I/O Expander IOExp000 erstellen (Chip MCP23017)

//*****************************************

const char* ssid = "ssid";                //WLAN SSID
const char* password = "passwd";           //WLAN Passwort

//*****************************************

WiFiClient espClient;                             //ESP WLAN Objekt erstellen

//*****************************************

int EntprellMs = 3;                               //Wert wie viele ms die Eingänge "entprellt" werden sollen
                                                        
bool WLAN = false;                                //BOOL(binärstatus) ob WLAN Verbindung zum Router vorhanden         
bool MQTT = false;                                //BOOL(binärstatus) ob MQTT Verbindung vorhanden         

int Modus;                                        //Modus der Klappe 0=Manuell 1=Auomatik
int Step = 1;                                     //Schrittzähler Auffahren, Stop, Zufahren, Stop, ...

unsigned long prevMillisWLAN = 0;                 //Speichert wann das letze mal WLAN Status geprüft
const long IntervWLAN = 60000;                    //Im 60 sek intervall WLAN Status prüfen

//*****************************************

int Motor = 12;                                   //Motorausgang an ESP8266 Pin D5(PWM)
int Umpolen = 0;                                  //Wechselrelais an GPA0(Pin28) von IOExp000
int Licht = 1;                                    //Außenlicht an    GPA1(Pin27) von IOExp000
int Modus_LED = 2;                                //Modus LED an     GPA2(Pin26) von IOExp000
int WLAN_LED = 3;                                 //WLAN LED an      GPA3(Pin25) von IOExp000
int MQTT_LED = 4;                                 //MQTT LED an      GPA4(Pin24) von IOExp000

int Limit_unten = 8;                              //Limit unten an   GPB0(Pin01) von IOExp000
int Limit_oben = 9;                               //Limit oben an    GPB1(Pin02) von IOExp000
int Fahren_Taster = 10;                           //Fahren Taster an GPB2(Pin03) von IOExp000
int Modus_Taster = 11;                            //Modus Taster an  GPB3(Pin04) von IOExp000
int Tuer = 12;                                    //Tuerkontakt an   GPB4(Pin05) von IOExp000

//*****************************************

bool Motor_Stat = false;                                        //BOOL(binärstatus) ob Motor an oder aus
bool Umpolen_Stat = false;                                      //BOOL(binärstatus) ob Wechselrelais an oder aus
bool Licht_Stat = false;                                        //BOOL(binärstatus) ob Außenlicht an oder aus
bool Modus_LED_Stat = false;                                    //BOOL(binärstatus) ob Modus LED an oder aus ist
bool WLAN_LED_Stat = false;                                     //BOOL(binärstatus) ob WLAN LED an oder aus ist
bool MQTT_LED_Stat = false;                                     //BOOL(binärstatus) ob MQTT LED an oder aus ist

bool Limit_unten_Akt = false;         
bool Limit_unten_Alt = false;         
//...

//************************************************************************************
void setup() {
  Serial.begin(9600);
  Serial.print("Konfiguration...");  
  
  IOExp000.begin(0);                                  //IOExp000 mit Adresse 0x20 starten (0=0x20, 1=0x21 ... 7=0x27)

  pinMode(Motor, OUTPUT);                             //D5: Motor Buz11

  //MCP Pins konfigurieren
  IOExp000.pinMode(Umpolen, OUTPUT);                  //GPA0(Pin21) IOExp000: Wechselrelais 0=auf 1=zu
  IOExp000.pinMode(Licht, OUTPUT);                    //GPA1(Pin22) IOExp000: Außenlicht Reedrelais
  IOExp000.pinMode(Modus_LED, OUTPUT);                //GPA2(Pin23) IOExp000: Modus LED 1=Manuell 0=Automatik
  IOExp000.pinMode(WLAN_LED, OUTPUT);                 //GPA3(Pin24) IOExp000: WLAN Status LED
  IOExp000.pinMode(MQTT_LED, OUTPUT);                 //GPA4(Pin25) IOExp000: MQTT Status LED

  digitalWrite(Motor, LOW);                           //Motor ausschalten
  IOExp000.digitalWrite(Umpolen, LOW);                //Wechselrelais=0(auf, Stromsparen)
  IOExp000.digitalWrite(Licht, LOW);                  //Licht ausschalten
  IOExp000.digitalWrite(Modus_LED, LOW);              //Modus LED ausschalten
  IOExp000.digitalWrite(WLAN_LED, LOW);               //WLAN LED ausschalten
  IOExp000.digitalWrite(MQTT_LED, LOW);               //MQTT LED ausschalten

  IOExp000.pinMode(Limit_unten, INPUT);               //GPB0(Pin01) IOExp000: Limit unten
  IOExp000.pinMode(Limit_oben, INPUT);                //GPB1(Pin02) IOExp000: Limit oben
  IOExp000.pinMode(Fahren_Taster, INPUT);             //GPB2(Pin03) IOExp000: Auf/Stop/Zu/Stop Taster
  IOExp000.pinMode(Modus_Taster, INPUT);              //GPB3(Pin04) IOExp000: Modus Taster
  IOExp000.pinMode(Tuer, INPUT);                      //GPB4(Pin05) IOExp000: Tuerkontakt
  
  Serial.println("beendet");

  //*****************************************

  WLAN_Verbinden();

}

//************************************************************************************
void loop() {  
  
  Tasterabfrage();                                                                          //Jede Loop Taster, Limits und Tuerkontakt abfragen

  unsigned long currentMillis = millis();  
  if (currentMillis - prevMillisWLAN >= IntervWLAN) {                                       //Alle xx Sekunden prüfen ob WLAN Verbunden
    prevMillisWLAN = currentMillis;    
    if(WiFi.status() != WL_CONNECTED) WLAN_Verbinden();                                       //Wenn nicht, WLAN versuchen zu verbinden
  }
}

//************************************************************************************
void WLAN_Verbinden() {
  WLAN = false;  
  Serial.println(" ");
  Serial.print("Verbinden mit WLAN-Netz ");           //Serielle Nachricht: "Verbinden mit WLAN-Netz xxx"
  Serial.println(ssid);
  IOExp000.digitalWrite(WLAN_LED, LOW);               //WLAN LED ausschalten weil noch keine WLAN Verbindung
  IOExp000.digitalWrite(MQTT_LED, LOW);               //MQTT LED ausschalten weil wenn keine WLAN Verbindung dann auch kein MQTT
  WiFi.begin(ssid, password);                         //WLAN mit SSID und Passwort starten                   
  int z = 0;                                          //Integer z = 0(Jede 400ms +1)
  while (WiFi.status() != WL_CONNECTED && z < 38) {   //Führe diese Loop aus so lange WLAN nicht verbunden und z kleiner 38
    IOExp000.digitalWrite(WLAN_LED, HIGH);            
    delay(200);                                         // Status LED WLAN blinken lassen bei WLAN Verbindungsaufbau
    IOExp000.digitalWrite(WLAN_LED, LOW); 
    delay(200);
    z = z + 1;
    Serial.print(".");                                  //Alle 400ms eine Serielle Nachricht mit "." schicken
  }
  Serial.println(" ");
                                                    //Wenn WLAN dann verbunden oder Zähler Loop gestoppt dann
  if(WiFi.status() != WL_CONNECTED) {                 //Wenn WLAN nicht verbunden dann
    IOExp000.digitalWrite(WLAN_LED, LOW);               //WLAN LED dauerhaft ausschalten
    WLAN = false;                                       //WLAN Status BOOL auf false setzen
    MQTT = false;                                       //MQTT Status BOOL auf false setzen
    Manuell();                                          //Modus auf Manuell setzen weil ja keine Zeitinfos vorhanden
    Serial.println("Weiter ohne WLAN!");                //Serielle Nachricht "Weiter ohne WLAN!"
  } else {                                            //Wenn WLAN aber verbunden dann
    IOExp000.digitalWrite(WLAN_LED, HIGH);              //WLAN LED dauerhaft einschalten
    WLAN = true;                                        //WLAN Status BOOL auf true setzen
    Serial.print("WLAN Verbunden!   ");                 //IP Adresse am Seriellen Monitor ausgeben
    Serial.print("IP Addresse: ");                      
    Serial.println(WiFi.localIP());
  }
}

Teil 2:

//************************************************************************************
void Tasterabfrage() {                          //########Tasterabfrage########*//
  bool Limit_unten_Akt = IOExp000.digitalRead(Limit_unten);             //Limit unten Eingang von Portexpander IOExp000 einlesen
  bool Limit_oben_Akt = IOExp000.digitalRead(Limit_oben);               //Limit oben Eingang von Portexpander IOExp000 einlesen
  bool Fahren_Taster_Akt = IOExp000.digitalRead(Fahren_Taster);         //Fahren Taster Eingang von Portexpander IOExp000 einlesen
  bool Modus_Taster_Akt = IOExp000.digitalRead(Modus_Taster);           //Modus Taster Eingang von Portexpander IOExp000 einlesen
  bool Tuer_Akt = IOExp000.digitalRead(Tuer);                           //Tuerkontakt Eingang von Portexpander IOExp000 einlesen

  //*****************************************
  if(Limit_unten_Akt == HIGH && Limit_unten_Alt == LOW) {               //Wenn Limit unten angesprochen und vorher nicht(positive Flanke) dann
    Serial.println("Limit unten 1");  
    LimitUnten();                                                         //In Sub "LimitUnten" springen
    Limit_unten_Alt = HIGH;                                               //Alten Wert aktualisieren
    delay(EntprellMs);                                                             //3ms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } else if(Limit_unten_Akt == LOW && Limit_unten_Alt == HIGH) {      //Wenn aber Limit unten nicht angesprochen und vorher schon(negative Flanke) dann
    Serial.println("Limit unten 0");
    Limit_unten_Alt = LOW;                                                //Alten Wert aktualisieren
    delay(EntprellMs);                                                             //3ms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  }
  //*****************************************
  if(Limit_oben_Akt == HIGH && Limit_oben_Alt == LOW) {               //Wenn Limit oben angesprochen und vorher nicht(positive Flanke) dann
    Serial.println("Limit oben 1");
    LimitOben();                                                        //In Sub "LimitOben" springen
    Limit_oben_Alt = HIGH;                                              //Alten Wert aktualisieren
    delay(EntprellMs);                                                           //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } else if(Limit_oben_Akt == LOW && Limit_oben_Alt == HIGH) {        //Wenn aber Limit oben nicht angesprochen und vorher schon(negative Flanke) dann
    Serial.println("Limit oben 0");
    Limit_oben_Alt = LOW;                                               //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  }
  //*****************************************
  if(Fahren_Taster_Akt == HIGH && Fahren_Taster_Alt == LOW) {         //Wenn Fahren Taster gedrückt und vorher nicht(positive Flanke) dann
    Serial.println("Fahren Taster 1");
    AufStopZuStopTaster();                                              //In Sub "AufStopZuStopTaster" springen
    Fahren_Taster_Alt = HIGH;                                           //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } else if(Fahren_Taster_Akt == LOW && Fahren_Taster_Alt == HIGH) {  //Wenn aber Fahren Taster nicht gedrückt und vorher schon(negative Flanke) dann
    Serial.println("Fahren Taster 0");
    Fahren_Taster_Alt = LOW;                                            //Alten Wert aktualisieren  
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  }
  //*****************************************
  if(Modus_Taster_Akt == HIGH && Modus_Taster_Alt == LOW) {           //Wenn Modus Taster gedrückt und vorher nicht(positive Flanke) dann
    Serial.println("Modus Taster 1");
    ModusTaster();                                                      //In Sub "Modus Taster" springen   
    Modus_Taster_Alt = HIGH;                                            //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } else if(Modus_Taster_Akt == LOW && Modus_Taster_Alt == HIGH) {    //Wenn aber Modus Taster nicht gedrückt und vorher schon(negative Flanke) dann
    Serial.println("Modus Taster 0");
    Modus_Taster_Alt = LOW;                                             //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  }
  //*****************************************
  if(Tuer_Akt == HIGH && Tuer_Alt == LOW) {                           //Wenn Tuerkontakt angesprochen(Tür zu) und vorher nicht(positive Flanke) dann
    Serial.println("Tuer geschlossen");
    //client.publish(outTopicTuer, "geschlossen");                        //Nachricht an MQTT-Server schicken "geschlossen"    
    Tuer_Alt = HIGH;                                                    //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } else if(Tuer_Akt == LOW && Tuer_Alt == HIGH) {                    //Wenn aber Tuerkontakt nicht angesprochen(Tür offen) und vorher schon(negative Flanke) dann
    Serial.println("Tuer geöffnet");
    //client.publish(outTopicTuer, "offen");                              //Nachricht an MQTT-Server schicken "offen"    
    Tuer_Alt = LOW;                                                     //Alten Wert aktualisieren
    delay(EntprellMs);                                                  //Xms Pause zum entprellen, die nächsten "Schwankler" ausblenden
  } 
  //*****************************************  
}

//************************************************************************************
void AufStopZuStopTaster() {                  //########Auf, Stop, Zu, Stop, ... Taster########//
  bool Limit_unten_Akt = IOExp000.digitalRead(Limit_unten);   //Limit oben, unten BOOL's aktualisieren
  bool Limit_oben_Akt = IOExp000.digitalRead(Limit_oben);
  if(Umpolen_Stat == LOW && Motor_Stat == HIGH) Step = 1;     //Wenn auffährt weitermachen mit stop
  if(Limit_oben_Akt == HIGH) Step = 2;                        //Wenn offen dann weitermachen mit zufahren
  if(Umpolen_Stat == HIGH && Motor_Stat == HIGH) Step = 3;    //Wenn zufährt dann weitermachen mit stop
  if(Limit_unten_Akt == HIGH) Step = 4;                       //Wenn geschlossen dann weitermachen mit auffahren
  Step += 1;                                                  //Zählerwert + 1
  if (Step >= 5) Step = 1;                                    //Wenn Step 5 oder höher dann wieder auf 1 setzen
  Serial.print("Auf/Stop/Zu/Stop Taster Step:");
  Serial.println(Step);
  if (Step == 1) Auffahren();                                 //Wenn Step=1 > Auffahren
  if (Step == 2) AufStoppen();                                //Wenn Step=2 > Stoppen
  if (Step == 3) Zufahren();                                  //Wenn Step=3 > Zufahren
  if (Step == 4) ZuStoppen();                                 //Wenn Step=4 > Stoppen
}

void ModusTaster() {                  //########Modus Taster########
  if (Modus == 1) {                                           //Wenn aktueller Status=Automatik dann
    Manuell();                                                  //In Sub "Manuell" springen                         
  } else if (Modus == 0 && MQTT == true && WLAN == true) {    //Wenn aktueller Status=Manuell und WLAN, MQTT Verbindung dann
    Automatik();                                                //In Sub "Automatik" springen     
  }
}

Und Teil 3:

//************************************************************************************
void LimitOben() {                                          //Wenn Limit oben anspricht dann
  if(Umpolen_Stat == LOW && Motor_Stat == HIGH) {            //Wenn auffährt
    delay(500);                                               //500ms warten (weitgenug hochfahren)
    digitalWrite(Motor, LOW);                                 //Motor ausschalten
    Motor_Stat = false;
    delay(10);                                                //10ms warten
    IOExp000.digitalWrite(Umpolen, LOW);                      //Wechselrelais=0(Stromsparen)
    Umpolen_Stat = false;
    //client.publish(outTopicKlappe, "ist offen!");             //Nachricht an MQTT Server schicken > "ist offen!"
    Serial.println("Limit oben angesprochen");                //SerialPrint "Limit oben angesprochen"
  }
}
void LimitUnten() {                                         //Wenn Limit unten anspricht dann
  if(Umpolen_Stat == HIGH && Motor_Stat == HIGH) {            //Wenn zufährt
    delay(200);                                                 //200ms warten (weitgenug zufahren)
    digitalWrite(Motor, LOW);                                   //Motor ausschalten
    Motor_Stat = false;
    delay(10);                                                  //10ms warten
    IOExp000.digitalWrite(Umpolen, LOW);                        //Wechselrelais=0(Stromsparen)
    Umpolen_Stat = false;
    //client.publish(outTopicKlappe, "ist geschlossen!");         //Nachricht an MQTT Server schicken > "ist geschlossen!"
    Serial.println("Limit unten angesprochen");                 //SerialPrint "Limit unten angesprochen"
  }
}

//************************************************************************************
void Auffahren() {                                          //Wenn Aufgefahren werden soll dann
  bool Limit_oben_Akt = IOExp000.digitalRead(Limit_oben);
  Serial.println("Soll auffahren");   
  if (Limit_oben_Akt == LOW) {                                //Wenn nicht schon offen dann               
    IOExp000.digitalWrite(Umpolen, LOW);                      //Wechselrelais=0(auf)
    Umpolen_Stat = false;
    delay(10);                                                //10ms warten
    for(int PWM=1000; PWM<1023; PWM++) { 
      analogWrite(Motor, PWM);                                //Innerhalb 255ms Motor hochfahren
      delay(50);
    }
    Motor_Stat = true;
    //client.publish(outTopicKlappe, "fährt auf");              //Nachricht an MQTT Server schicken > "fährt auf"
    Serial.println("Fährt auf");                              //SerialPrint "Auffahren"
  }
}
void AufStoppen() {                                         //Wenn gestoppt werden soll wenn auffährt dann
  digitalWrite(Motor, LOW);                                   //Motor ausschalten
  Motor_Stat = false;
  delay(10);                                                  //10ms warten
  IOExp000.digitalWrite(Umpolen, LOW);                        //Wechselrelais=0(Stromsparen)
  Umpolen_Stat = false;
  //client.publish(outTopicKlappe, "Auffahren gestoppt");       //Nachricht an MQTT Server schicken > "Auffahren gestoppt!"
  Serial.println("Auffahren gestopppt");                      //SerialPrint "Auffahren gestoppt"
}
void ZuStoppen() {                                             //Wenn gestoppt werden soll wenn zufährt dann
  digitalWrite(Motor, LOW);                                     //Motor ausschalten
  Motor_Stat = false;
  delay(10);                                                    //10ms warten
  IOExp000.digitalWrite(Umpolen, LOW);                          //Wechselrelais=0(Stromsparen)
  Umpolen_Stat = false;
  //client.publish(outTopicKlappe, "Zufahren gestoppt");          //Nachricht an MQTT Server schicken > "Zufahren gestoppt!"
  Serial.println("Zufahren gestoppt");                          //SerialPrint "Zufahren gestoppt"
}
void Zufahren() {                                           //Wenn Zugefahren werden soll dann
  bool Limit_unten_Akt = IOExp000.digitalRead(Limit_unten);
  Serial.println("Soll zufahren"); 
  if (Limit_unten_Akt == LOW) {                               //Wenn nicht schon zu dann
    IOExp000.digitalWrite(Umpolen, HIGH);                         //Wechselrelais=1(zu)
    Umpolen_Stat = true;
    delay(10);                                                  //10ms warten
    for(int PWM=1000; PWM<1023; PWM++) { 
      analogWrite(Motor, PWM);                                  //Innerhalb 255ms Motor hochfahren
      delay(50);
    }    
    Motor_Stat = true;
    //client.publish(outTopicKlappe, "fährt zu");                 //Nachricht an MQTT Server schicken > "fährt zu"
    Serial.println("Fährt zu");                                 //SerialPrint "Zufahren"
  }  
}

//************************************************************************************
void Automatik() {                                          //Wenn Automatik Modus gesetzt werden soll dann
  Modus = 1;                                                  //Modus=1
  //client.publish(outTopicModus, "Automatik");                 //Nachricht an MQTT Server schicken > "Automatik"
  IOExp000.digitalWrite(Modus_LED, LOW);                      //Modus LED ausschalten
  Modus_LED_Stat = LOW;
  Serial.println("Modus auf Automatik gesetzt");              //SerialPrint "Modus auf Automatik gesetzt"
}
void Manuell() {                                            //Wenn Manuell Modus gesetzt werden soll dann
  Modus = 0;                                                  //Modus=0
  //client.publish(outTopicModus, "Manuell");                   //Nachricht an MQTT Server schicken > "Manuell"
  IOExp000.digitalWrite(Modus_LED, HIGH);                     //Modus LED anschalten
  Serial.println("Modus auf Manuell gesetzt");                //SerialPrint "Modus auf Manuell gesetzt"
}

Wieso redest Du von 3,3V?
Läuft die Schaltung auf 3,3V? Woher bekommst Du die 3,3V? Was hängt denn alles an den 3,3V? was ist an den Pins des MCP23017 angeschlossen (bitte Schaltung oder gute Fotos).

Grüße Uwe

So ich poste mal meinen Schaltplan hier! Kurze erklärung zum eigenkreierten Schaltplan:

5.GPA4 heißt > Dieser Verweis geht auf Blatt 5. bei Blatt 5 steht dann z.B. 1.GPA4. Das bedeutet dann also, dass dieser Strompfad von Blatt 1 zu 5 oder andersrum geht! Hoffe es is bissl verständlich! Es war mir zu aufwendig das in eagle zu zeichnen.

3 kleine Fehler im Plan: Auf Blatt 1 oben links gehört noch AC anstatt DC hin wei es vorm Gleichrichter ist!
Auf Blatt 2 gehört beim NODE-Mcu bei 3,3V der Verweis 2.3V3 in 3.3V3 getauscht.
Der Portexpander läuft mit 3,3V nict mit 5V

Was mir gerade in den Sinn gekommen ist:

Meine 3,3V kommen nur vom NODE-MCU eingebautem AMS1117(Spannungsregler).

Da hängt dran: die RTC Uhr, der Portexpander, die Taster-/Limitabfragen, 3 Transistoren und ein Reed Relais!

Es kann doch gut sein, dass dann manchmal die Spannung so sehr zusammenbricht, dass sich einer der Chips aufhängt oder?

Da musst Du mal die Werte in den Datenblättern suchen und aufaddieren.
Hat das Relais eine (integrierte) Freilaufdiode?

Gruß Tommy

Das Reed-Relais ist das "Meder MS05-1A87-75LHR" und hat bei der 5V Version eine Minimale Spulenspannung von 0,5V und einen Innenwiderstand von 280 Ohm was bei 3,3V einen Strom von 12mA ergibt.
Dann hab ich noch 2x Buz11 und einen BC547

Buz11 braucht fast null Strom weil es ein Feldeffekt-transistor ist

der Portexpander ca. 3µA

der BC547 hat einen verstärkungsfaktor von 800 was dann einen Gate-Strom von 250µA verursacht.

die 5 Taster/Limitabfragen mit 10K ergeben einen Strom von ca. 660µA

und die RTC-Uhr mit ausgebauter LED ca. 700µA

Also wären wir dann bei 13,611mA(plus Buz11 weiß ned wie genau ich das ausrechnen kann)

Eigentlich dürfte es ja leicht reichen der Strom vom NodeMcu. Aber es könnte sein, in dem Moment wo sich die Buz11 "aufladen", dass das den Spannungsfall auslöst oder?

Soo

Ich hab jetzt erstmal einen 12 bis 20V Step Down Regler auf 3,3V gestellt, und dem NodeMCU so die Last abgenommen!

Bis jetzt läuft die Steuerung ohne “Aufhänger” aber es wird sich noch zeigen ob das so bleibt!

Im Anhang jetzt nochmal die abgewandelte Version für die Spannugsversorgung wen es interessiert!

Eine kurze Frage hab ich noch:

Ich hab jetzt den Motor am NODE-Mcu an Pin D5 angeschlossen.

Wenn ich jetzt eine neue Software auf den Chip aufspiele muss ich den Motor immer abstecken, weil sonst der Motor solange läuft wie programmiert wird.

Muss ich da bloß einen anderen Pin nehmen oder gibts da einen Befehl beim Programmieren?

Schalte mal einen Widerstand (so ca. 15 kOhm) von D5 nach GND, dann sollte das Problem gelöst sein.
Zumindest bei einer LED bewirkt das, dass sie während der Programmierung aus ist.

Gruß Tommy

Oke sehr gut! Danke!

Probier ich heute gleich noch aus!

Schöne Ostern noch :wink: