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

ShortName · October 26, 2018, 12:39pm

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);
      }
   }
}

HotSystems · October 26, 2018, 12:51pm

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

Tommy56 · October 26, 2018, 1:26pm

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

Gruß Tommy

HotSystems · October 26, 2018, 2:24pm

Aber wir sollen schnell helfen.

Tommy56 · October 26, 2018, 2:28pm

Wie immer

Gruß Tommy

uwefed · October 26, 2018, 2:50pm

HotSystems:
Aber wir sollen schnell helfen.

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

HotSystems · October 26, 2018, 3:11pm

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.

combie · October 26, 2018, 3:32pm

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

Doc_Arduino · October 26, 2018, 9:54pm

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.

Scherheinz · October 27, 2018, 8:27am

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

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

uwefed · October 27, 2018, 8:36am

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

Scherheinz · October 27, 2018, 10:58am

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

ShortName · December 7, 2018, 12:44pm

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

system · May 6, 2021, 1:39pm