Hilfe bitte schnell!!! Problem mit zwei 74HC595N Schieberegister

Hey Leute,

ich habe ein Problem mit zwei Schieberegister und ich finde den Fehler nicht. Also mein Projekt ist eine Treppenschaltung bei der alle 12 Stufen nach einander angehen soll wenn ein Bewegungsmelder aktiviert wird. Mein Code funktioniert für 8 Stufen perfekt. Nachdem ich allerdings mein Code auf 12 Stufen erweitert habe und ich ein zweites Schieberegister mit eingebaut habe kommt irgendwie alles durcheinander. Ich hoffe ihr könnt mir helfen, danke schon mal im voraus. Das ist mein Code für das anschalten der LEDs wenn der untere Sensor aktiviert wird.

byte daten1[] = {B00000000,
                 B00000001,
                 B00000011,
                 B00000111,
                 B00001111,
                 B00011111,
                 B00111111,
                 B01111111,
                 B11111111};

byte daten2[] = {B00000000,
                 B00000001,
                 B00000011,
                 B00001111,
                 B00001111};



void anschaltenLED_BOT() {
  Mir:
  delay(250);
   if (pirStatusBOT == HIGH && pirStatusTOP == LOW && safePin_BOT == true){
    for (aktivLED_BOT; aktivLED_BOT < 9; aktivLED_BOT++){
      if(aktivLED_BOT<=9){
         digitalWrite(storePin, LOW);
         shiftOut(dataPin, shiftPin, MSBFIRST, daten1[1]);
         //shiftOut(dataPin, shiftPin, MSBFIRST, daten2[aktivLED_BOT]);
      }
      else if(aktivLED_BOT>9 && aktivLED_BOT<=13){
          //shiftOut(dataPin, shiftPin, MSBFIRST, daten1[8]);
          //shiftOut(dataPin, shiftPin, MSBFIRST, daten2[i]);
          i++;
          Serial.println("ANDAWJDNWJNDIANIDN");
          }
        digitalWrite(storePin, HIGH);
            for (int f = 0; f < 20; f++){
              delay(50);
              Serial.println(f);
              BewegungTOP = digitalRead(PIR_PIN_TOP);
                if (BewegungTOP == HIGH){
                  pirStatusTOP = HIGH;
                  Serial.println("Hallo");
                  safePin_BOT = false;
                  Breaker_BOT = 5;
                      }
                    }
      if (Breaker_BOT == 5) {
        BreakLED_BOT();
        goto Mir;
      }
    }
    digitalWrite(storePin, LOW);
    if(aktivLED_BOT >= 13 && time<15){
        time ++/1000;
        Serial.println(time);
      }
   }
}

Das ist mit Sicherheit nicht der komplette Sketch.
Um zu helfen, brauchen wir den kompletten.

Eine Schaltung, wie Du die beiden Schieberegister angeschlossen hast, wäre auch sinnvoll.

Gruß Tommy

Aber wir sollen schnell helfen. :smiling_imp:

Wie immer :confused:

Gruß Tommy

HotSystems:
Aber wir sollen schnell helfen. :smiling_imp:

Wieso? Hab Ihr ja, innerhalb 2h 2 vernünftige und ziehlführende Antworten gegeben.
Grüße Uwe

uwefed:
Wieso? Hab Ihr ja, innerhalb 2h 2 vernünftige und ziehlführende Antworten gegeben.
Grüße Uwe

Naja, weil keinerlei Antworten kommen, wo es doch schnell gehen muss.

Übringens:

Wenn irgendwas besonders schnell gehen soll, dann vergisst man meistens ganz wichtige Dingen, welche dafür Sorge tragen würden, dass es mit ihnen schneller geht, als ohne.

Fangfrage:
Worauf liegt der Fokus?
Geschwindigkeit
Lösung

Nachtrag:

time ++/1000;

Da hätte ich mal gerne gewusst, was das bewirken soll?

Hallo,

die Treppe ist praktisch ein wachsender LED Balken. Könnte man so machen. Erspart Arrays bzw. die pow Rechnung.
Initialisierung:
unsigned int new_value = 1
unsigned int old_value = 0

byte_shift_out(new_value);
old_value = new_value;
new_value = new_value << 1;
new_value = new_value | old_value;
if (new_value > 4095) new_value = 1;  // 12. Stufe erreicht oder anders passend zurücksetzen

und rausschieben mit Software SPI mache ich so

void byte_shift_out( uint16_t data ) 
{    
  // in das Schieberegister eintakten //   
  for(uint8_t i=0; i<16; i++) {
    if(data & 0x01) {     // nur unterstes Bit betrachten
      shift_Data_ON;      // und Datenleitung entsprechend setzen
    }
    else {
      shift_Data_OFF;
    }
    shift_Clock_ON;       // Takt erzeugen
    data = data >> 1;     // nächstes Bit rechts schieben
    shift_Clock_OFF;
  }

  // vom Schieberegister ins Ausgaberegister übernehmen //
  shift_Latch_ON;
  shift_Latch_OFF;
  
}

Mach was daraus.

Umso schneller es gehen muss desto länger wartet man auf Rückmeldung :zipper_mouth_face:

Wenn man wüßte welchen Arduino er benutzt bräuchte er nichtmals die Schieberegister

Scherheinz:
Wenn man wüßte welchen Arduino er benutzt bräuchte er nichtmals die Schieberegister

Wieso hängt das vom Arduino ab- Alle haben mindestens I/O 20 Pins.
Grüße Uwe

Ok alle Bords die ich kenne auch, kenne aber mit Sicherheit nicht alle, deshalb lieber so ausgedrückt :slight_smile:

Tut mir leid das ich nicht mehr geantwortet habe, hatte viel für die Schule zu tun.

Das ist der komplette Code:

#define PIR_PIN_BOT 3
#define PIR_PIN_TOP 4

int shiftPin = 8;
int storePin = 9;
int dataPin = 10;

bool safePin_BOT = true;
bool safePin_TOP = true;

int time = 0;
int Breaker_BOT = 0;
int Breaker_TOP = 0;
int aktivLED_BOT = 0;
int aktivLED_TOP = 0;
int BewegungBOT = LOW;
int BewegungTOP = LOW;
int pirStatusBOT = LOW;
int pirStatusTOP = LOW;

byte daten1[] = {B00000000,
                 B00000001,
                 B00000011,
                 B00000111,
                 B00001111,
                 B00011111,
                 B00111111,
                 B01111111,
                 B11111111};

byte daten2[] = {B00000000,
                 B00000001,
                 B00000011,
                 B00000111,
                 B00001111};
                  
void setup() {
  Serial.begin(9600);

  pinMode(PIR_PIN_BOT, INPUT);
  pinMode(PIR_PIN_TOP, INPUT);
  pinMode(shiftPin, OUTPUT);
  pinMode(storePin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
  Bewegung();
  anschaltenLED_BOT();
  ausschaltenLED_BOT();
}

void Bewegung() {
  Serial.println("TIME");
  Serial.println(time);
  BewegungBOT = digitalRead(PIR_PIN_BOT);
  if (BewegungBOT == HIGH) {
    delay(50);
    pirStatusBOT = HIGH;
  }
  Serial.println("BOT");
  Serial.println(pirStatusBOT);
  BewegungTOP = digitalRead(PIR_PIN_TOP);
  
  if (BewegungTOP == HIGH) {
    pirStatusTOP = HIGH;
  }
  delay(50);
  Serial.println("TOP");
  Serial.println(pirStatusTOP);
}

void resetSensors() {
  pirStatusBOT = LOW;
  pirStatusTOP = LOW;
  safePin_BOT = true;
  safePin_TOP = true;
  aktivLED_BOT = 0;
  aktivLED_TOP = 0;
  Breaker_BOT = 0;
  Breaker_TOP = 0;
}

void anschaltenLED_BOT() {
  Mir:
  delay(250);
   if (pirStatusBOT == HIGH && pirStatusTOP == LOW && safePin_BOT == true){
    for (aktivLED_BOT; aktivLED_BOT < 13; aktivLED_BOT++){
      digitalWrite(storePin, LOW);
      if(aktivLED_BOT<=8){
         shiftOut(dataPin, shiftPin, MSBFIRST, daten2[0]);
         shiftOut(dataPin, shiftPin, MSBFIRST, daten1[aktivLED_BOT]);
      }
      else{
          shiftOut(dataPin, shiftPin, MSBFIRST, daten2[aktivLED_BOT -8]);
          shiftOut(dataPin, shiftPin, MSBFIRST, daten1[8]);
          }
        digitalWrite(storePin, HIGH);
            for (int f = 0; f < 10; f++){
              delay(50);
              Serial.println(f);
              BewegungTOP = digitalRead(PIR_PIN_TOP);
                if (BewegungTOP == HIGH){
                  pirStatusTOP = HIGH;
                  Serial.println("Hallo");
                  safePin_BOT = false;
                  Breaker_BOT = 5;
                      }
                    }
      if (Breaker_BOT == 5) {
        BreakLED_BOT();
        goto Mir;
      }
    }
    digitalWrite(storePin, LOW);
    if(aktivLED_BOT >= 13 && time<15){
        time ++/1000;
        Serial.println(time);
      }
   }
}


void ausschaltenLED_BOT() {
    delay(250);
if(pirStatusBOT == HIGH && pirStatusTOP == HIGH || time>=15){
    Serial.println("geht AUS");
    for (aktivLED_BOT; aktivLED_BOT >= 0; aktivLED_BOT--) {
      digitalWrite(storePin, LOW);
      if(aktivLED_BOT > 4){
         shiftOut(dataPin, shiftPin, MSBFIRST, daten2[4]);
         shiftOut(dataPin, shiftPin, LSBFIRST, daten1[aktivLED_BOT -5]);
      }else{
        Serial.println("AKTIVLED_BOT");
        Serial.println(aktivLED_BOT);
         shiftOut(dataPin, shiftPin, MSBFIRST, daten2[aktivLED_BOT]);
         shiftOut(dataPin, shiftPin, MSBFIRST, daten1[0]);
         
      }
        digitalWrite(storePin, HIGH);
        digitalWrite(storePin, LOW);
      delay(500);
    }
      resetSensors();
  }
}

void BreakLED_BOT() {
  for (aktivLED_BOT; aktivLED_BOT >= 0; aktivLED_BOT--) {
    digitalWrite(storePin, LOW);
    shiftOut(dataPin, shiftPin, MSBFIRST, daten2[aktivLED_BOT -8]);
    shiftOut(dataPin, shiftPin, MSBFIRST, daten1[aktivLED_BOT]);
    digitalWrite(storePin, HIGH);
    delay(1000);   
  }
  resetSensors();
}


void anschaltenLED_TOP() {
  Hier:
  delay(250);
   if (pirStatusTOP == HIGH && pirStatusBOT == LOW && safePin_TOP == true){
    for (aktivLED_TOP; aktivLED_TOP < 9; aktivLED_TOP++){
      digitalWrite(storePin, LOW);
      shiftOut(dataPin, shiftPin, LSBFIRST, daten1[aktivLED_TOP]);
      digitalWrite(storePin, HIGH);
        for (int f = 0; f < 20; f++){
          delay(50);
          Serial.println(f);
          BewegungBOT = digitalRead(PIR_PIN_BOT);
            if (BewegungBOT == HIGH){
              pirStatusBOT = HIGH;
              Serial.println("Hallo");
              safePin_TOP = false;
              Breaker_TOP = 5;
        }
      }
      if (Breaker_TOP == 5) {
        BreakLED_TOP();
        goto Hier;
      }
    }
    digitalWrite(storePin, LOW);
        if(aktivLED_TOP >= 9 && time<15){
        time ++/1000;
        Serial.println(time);
    }
  }
}

void ausschaltenLED_TOP() {
    delay(250);
  if (aktivLED_TOP == 9) {
    aktivLED_TOP = 8;
  }
  if (pirStatusTOP == HIGH && pirStatusBOT == HIGH || time >= 15) {
    for (aktivLED_TOP; aktivLED_TOP >= 0; aktivLED_TOP--) {
      shiftOut(dataPin, shiftPin, LSBFIRST, daten1[aktivLED_TOP]);
      digitalWrite(storePin, HIGH);
      digitalWrite(storePin, LOW);
      delay(1000);
    }
    resetSensors();
  }
}

void BreakLED_TOP(){
   for (aktivLED_TOP; aktivLED_TOP >= 0; aktivLED_TOP--) {
    digitalWrite(storePin, LOW);
    shiftOut(dataPin, shiftPin, LSBFIRST, daten1[aktivLED_TOP]);
    digitalWrite(storePin, HIGH);
    delay(1000);   
  }
  resetSensors(); 
}

Und hier ist der Link zum Aufbau der Schaltung: https://smarthomeyourself.de/anleitung-zum-selber-bauen/unabhaengige-projekte/treppen-lauflicht-mit-bewegungserkennung/

tut mir wirklich leid das es so lange gedauert hat :confused: