2 Schieberegister 74HC595 Anschließen

Hallo erst mal!! Ich bin neu hier und habe vieles zu Schieberegister gefunden aber leider wurde niergends mein Problem erörtert oder im Ansatz besprochen! Seit einen Monat bin ich auf der Suche nach der Lösung und hoffe das mir jemand HIER helfen kann bevor ich Verzweifle !!

Ich habe versucht meine 16 LED mit zwei Schieberegister anzusteuern, aber leider machen die Schieberegister das gleiche.

Ich habe den ersten Schieberegister den Pin 9 mit den Schieberegister mit den Pin 14 verbunden für dataPin(SER)! Vom 1 Schieberegister den Pin 11 auf den 2 Schieberegister auf Pin11 und dann noch vom 1Schieberegister von Pin 12 auf den 2 Schieberegister auf Pin12

Wie kann ich vom 2ten Schieberegister die LED´s Ansteuern ohne das mir die LED´s vom 1ten Schieberegister Leuchten ???

int dataPin=11;
int clockPin=12;
int lachPin=8;


void setup()
{
   
    
    pinMode(dataPin,OUTPUT);
    pinMode(clockPin,OUTPUT);
    pinMode(lachPin,OUTPUT);     
}

void loop()
{
 
   digitalWrite(lachPin,LOW);
   shiftOut(dataPin,clockPin,MSBFIRST,8); //Hier möchte ich das die 4 LED auf Leuchtet (2^4=8) 
   digitalWrite(lachPin,HIGH);
   delay(50);   

   digitalWrite(lachPin,LOW);
   shiftOut(dataPin,clockPin,MSBFIRST,256); //Hier möchte ich das die 9 LED auf Leuchtet (2^8=256) 
   digitalWrite(lachPin,HIGH);
   delay(50); 
}

Willkommen im Club! Deiner Beschreibung nach hast du das ebenso wie hier angeschlossen, nehme ich zumindest an: http://www.arduino.cc/en/Tutorial/ShiftOut
Funktioniert denn deine Beschaltung mit dem Beispielcode des ShiftOut-Befehls?

//Pin connected to ST_CP of 74HC595
int latchPin = 8;
//Pin connected to SH_CP of 74HC595
int clockPin = 12;
////Pin connected to DS of 74HC595
int dataPin = 11;

void setup() {
  //set pins to output because they are addressed in the main loop
  pinMode(latchPin, OUTPUT);
  pinMode(clockPin, OUTPUT);
  pinMode(dataPin, OUTPUT);
}

void loop() {
  //count up routine
  for (int j = 0; j < 256; j++) {
    //ground latchPin and hold low for as long as you are transmitting
    digitalWrite(latchPin, LOW);
    shiftOut(dataPin, clockPin, LSBFIRST, j);  
    //return the latch pin high to signal chip that it
    //no longer needs to listen for information
    digitalWrite(latchPin, HIGH);
    delay(1000);
  }
}

Kannst ja die Schleife ein bisschen ausweiten, dass noch was am 2. Schieberegister ankommt.

Nebenbei gesagt, hast du nen lustigen lachPin, da fehlt ein t. :wink: Ach ja, du solltest die Code-Tags verwenden und beim Präsentieren unnötige Leerzeilen rausnehmen, lässt sich für uns leichter lesen.

Ja genau so habe ich es auch angeschlossen!! Der Code geht bei mir!! Aber wie schon erwähnt machen die zwei das gleiche !! Und ich will ja das ich die einzeln Steuern kann !!! ?????

Sorry, dass ist beim zweiter POST den ich je in meinen Leben gemacht habe! Ich habe mich sonst immer nur über Google Informiert! Aber jetzt habe ich mir gedacht ich versuch es auch mal mit so ein Forum wo Gleichgesinnte sind !! Ich hoffe meine Rechtschreibung stört keinen hier!! Sorry, in Voraus!!!!

Schaut man sich die Doku an: http://arduino.cc/en/Reference/ShiftOut und schaut man sich die Datei "./hardware/arduino/cores/arduino/Arduino.h" der IDE an:

void shiftOut(uint8_t dataPin, uint8_t clockPin, uint8_t bitOrder, uint8_t val);

Dann sieht man, das der Wert der per shiftout übertragen werden soll ein BYTE ist, also nur 8 Bit. Der Wert 256, den ihr beide verwendet passt aber nicht in ein Byte. Da die "Latch"-Leitung parallel an beiden Registern hängt, wird zwangsläufig immer der übertragene Wert für beide Register geschrieben. Man kann somit nicht eine einzelne LED dazu oder abschalten, es muss jedesmal die komplette Liste aller zu schaltenden Ausgänge übertragen werden.

Ein Beispiel. Zuerst schalten wir LED 4 des ersten Registers

shiftOut(dataPin, clockPin, LSBFIRST, 0); //alle LEDs am 2. Register aus
shiftOut(dataPin, clockPin, LSBFIRST, 8);  //LED 4 am ersten Register an

Dann soll die 2 LED des 2. Registers zusätzlich eingeschaltet werden:

shiftOut(dataPin, clockPin, LSBFIRST, 2); //LED 2 am zweiten Register an
shiftOut(dataPin, clockPin, LSBFIRST, 8);  //LED 4 am ersten Register immer noch an

Wie man sieht, müssen immer beide Bytes nacheinander überrtagen werden. (oder 3 bei 3 Registern) Dabei kommt das letzte Register immer zuerst, weil die Daten ja bis nach hinter durchgeschoben werden.

Autsch! Steht ja auch in der ShiftOut-Hilfe: "value: the data to shift out. (byte)" Das hatte ich nicht bedacht, danke für den Hinweis. Also zwei Bytes reinschieben und dann den latchPin aktivieren.

Ooooooooooooooooooooooooh mein GOOOOOOOT, dass kann nicht wahr sein !!! Echt mal VIELEN DANK !!!! Das ist echt der Hammer, ich habe sehr oft die shiftOut hintereinander geschrieben aber da kam immer fehler!! Dazu kam das ich dachte das wenn ich z.b 256 eingebe das dann die 9 LED leuchtet und wenn ich 512 dann die 10 LED , weil das dann durchschieben würde, weil 128 ja die 8 LED ist !! Vielleicht kannst mir Folgen, ist aber auch egal ich habe es verstanden !!! Echt witzig !! das das so einfach war !!

Jetzt kann ich endlich meine 8x8 matrix mit den Bc333(Transistor) verwirklichen !! Ich weiss, es ist einfacher mit den Max7219 aber ich wollte es umbedingt mit denn 595er Realisieren !!

Nachmal VIELEN DANK an auch BEIDEN !!! Vielleicht bis zum nächsten mal !!

Genau. Man sieht auch sehr schön im Beispielcode: http://arduino.cc/en/Tutorial/ShftOut13 Das dort 2 Mal das shiftOut() aufgerufen wird.

Die Seite sehe ich zum ersten mal, schade!! Aber jetzt habe ich es ja :D :grin: XD 8) :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD

DANKE

Quark: Die Seite sehe ich zum ersten mal, schade!! Aber jetzt habe ich es ja :D :grin: XD 8) :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D :D XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD XD

DANKE

Einer hätte es auch getan ;-)

Ich wollte dem Ganzen, noch mehr ausdruck verleihen !! :grin:

Hallo Leute,
ich habe genau das gleiche Problem wie der Topic-Eröffner. Allerdings möchte ich nur ein simples Lauflicht über 16 LEDs realisieren.
Ich benutze 2 74HC595. Die Schaltung ist exakt wie im ShiftOut Tutorial geschaltet. Die ganze Problematik das nur ein 1 Byte geshiftet werden kann ist mir bekannt.
Dennoch bin ich einfach zu unfähig ein Algorithmus zu entwickeln der meine Aufgabe löst. Ihr müsst entschuldigen ich fang grade erst an damit.
Hat jmd eventuell ein Sketch-Beispiel oder ein Tip für mich? Wäre für jede Hilfe dankbar. Bei meinem Bsp. unten laufen die LEDs der beiden Register immer synchron.

// Lauflicht mittels 74HC595 und shiftOut

const int taktPin = 8;     // SH_CP ClockPin
const int speicherPin = 9; // ST_CP 
const int datenPin = 10;   // LS Byte

void setup(){
  pinMode(taktPin, OUTPUT);
  pinMode(speicherPin, OUTPUT);
  pinMode(datenPin, OUTPUT);
}

void loop(){
  for (int i=0; i<16; i++){
    digitalWrite(speicherPin, LOW);
    if(i<8)shiftOut(datenPin, taktPin, MSBFIRST, 0B0000000000000001 << i);
    else shiftOut(datenPin, taktPin, MSBFIRST, 0B0000000000000001 << i-8);
    digitalWrite(speicherPin, HIGH);
    delay(62);
    digitalWrite(speicherPin, LOW);  
  }
}

Du hast das gleiche Problem?
Du hast 2 Schieberigister hintereinandergeschaltet, sendest die Daten aber nur für eines und diese Diskussion nicht gelesen. 8) 8)

Soviel ich weiß kann man im Binärschreibweise nur 8 bit angeben nicht 16, außerdem ist das ja unnütz da shiftout nur 8Bit überträgt.
Du mußt wie meine Vorredner bereits gesagt haben immer 16 Bit (2 Byte) übertragen.
also:

for (int i=0; i<16; i++){
    digitalWrite(speicherPin, LOW);
    if(i<8)
     { 
    shiftOut(datenPin, taktPin, MSBFIRST, 0B00000001 << i);
    shiftOut(datenPin, taktPin, MSBFIRST, 0);
    }
    else 
    }
    shiftOut(datenPin, taktPin, MSBFIRST, 0);
    shiftOut(datenPin, taktPin, MSBFIRST, 0B00000001 << i-8);
    }
    digitalWrite(speicherPin, HIGH);
    delay(62);
    digitalWrite(speicherPin, LOW);  
  }

Grüße Uwe

OMG...jetzt erst habe ich die 2 shiftOut Zeilen verstanden. Uwe, du hast mein Tag gerettet. Tausend Dank!!!!!

Ist jetzt nicht so wichtig aber vllt. hat ja jmd. eine Antwort parat. Beim Arduino Tutorial ShftOut13 leuchten bei mir die LEDs nur ganz schwach. Woran könnte das liegen?

Gruß Andy

Ist jetzt nicht so wichtig aber vllt. hat ja jmd. eine Antwort parat. Beim Arduino Tutorial ShftOut13 leuchten bei mir die LEDs nur ganz schwach. Woran könnte das liegen?

Welche Vorwiderstände verwendest Du an den LED?

Ich habe an meiner Schaltung nix verändert, sprich ich verwende 220Ohm Vorwiderstände. Beim Sketch mit Deiner Lösung leuchten sie wunderbar nur beim besagten Sketch eben nicht. War ja zunächst auch meine Gedanke, dass der Strom eventuell nicht mehr ausreicht. Aber selbst wenn ich den Widerstand weg lassen, gibt es nur eine maginale Veränderung der Leuchtkraft.

for (int thisLed = 0; thisLed < 16; thisLed++) {    
    registerWrite(thisLed, HIGH);                 // schaltet 1 LED an
    if (thisLed > 0) {
      registerWrite(thisLed - 1, LOW);           // schaltet alle LED aus 
    }     
    else {
      registerWrite(15, LOW);                       // schaltet alle LED aus
    } 
    delay(250);
  }

und die Funktion:

void registerWrite(int whichPin, int whichState) {  
  unsigned int bitsToSend = 0;                                    // alle led aus (alle Bit auf LOW)
  digitalWrite(latchPin, LOW); 
  bitWrite(bitsToSend, whichPin, whichState);              // setzt das entsprechende LED; hat aber nur Sinn wenn HIGH da alle Bit sowiso LOW sind
  byte registerOne = highByte(bitsToSend);                 // sendet die Daten
  byte registerTwo = lowByte(bitsToSend);  
  shiftOut(dataPin, clockPin, MSBFIRST, registerTwo);
  shiftOut(dataPin, clockPin, MSBFIRST, registerOne); 
  digitalWrite(latchPin, HIGH);
}

Die Funktion registerWrite setzt ein Byte auf H. Anders als man es vermutet werden alle anderen Byte auf LOW gesetzt. Also wird eine LED angeschaltet und dann gleich wieder gelöscht. Nach 250mS wiederholt es sich.
Abhilfe: die Variable bitsToSend muß aus der Funktion registerWrite heraus und global definiert werden.
also:

//Pin connected to latch pin (ST_CP) of 74HC595
const int latchPin = 8;
//Pin connected to clock pin (SH_CP) of 74HC595
const int clockPin = 12;
////Pin connected to Data in (DS) of 74HC595
const int dataPin = 11;

unsigned int bitsToSend = 0;   
 
char inputString[2];

void setup() {
...

und

void registerWrite(int whichPin, int whichState) {  
  // unsigned int bitsToSend = 0;      
  digitalWrite(latchPin, LOW);
...

Grüße Uwe

Hab eine Email an den Support geschrieben und das Problem erklährt. Grüße Uwe

Einfach superklasse. Du hast es ziemlich gut drauf!! :wink:
Gruß Andy

Danke für den Lob. Uwe