RGB Cube 4x4x4 probleme

system · May 12, 2014, 11:40am

Hey Forum

Ich und mein Partner arbeiten gerade an einem 4x4x4 RGB LED Cube.
Er entwirft gerade (also sollte heute fertig werden) die Platine und ich programmiere die Software an meinem Steckbrett.
da mein Steckbrett nicht unendlich groß ist kann ich erstmal nur eine Farbe und die ersten 2 ebenen ansteuern.

Ich habe es schonmal geschafft das die erste ebene von links nach rechts "zählt" also jeweils eine led wandert
und die 2. ebene von rechts nach links. und das durch Multiplexing

nun wollte ich das Programm schon mal erweitern mit allen Ebenen und alle Farben mit ein paar Funktionen. doch nun Funktioniert garnichts mehr

es blinkt nur abwechselnd die vorderste erste LED immer abwechselnd von der 1. und dann 2. Ebene..

Hier mal der Code:

//Pin connected to ST_CP of 74HC595
int latchPin_r = 10;
int latchPin_g = 8;
int latchPin_b = 9;
//Pin connected to SH_CP of 74HC595
int clockPin_r = 14;
int clockPin_g = 12;
int clockPin_b = 13;
////Pin connected to DS of 74HC595
int dataPin_r = 6;
int dataPin_g = 11;
int dataPin_b = 7;

int ebene1 = 2;
int ebene2 = 4;
int ebene3 = 3;
int ebene4 = 5;

char ebene1_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene1_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,};
char ebene3_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,};

void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin_r, OUTPUT);
  pinMode(latchPin_g, OUTPUT);
  pinMode(latchPin_b, OUTPUT);
  pinMode(clockPin_r, OUTPUT);
  pinMode(clockPin_g, OUTPUT);
  pinMode(clockPin_b, OUTPUT);
  pinMode(dataPin_r, OUTPUT);
  pinMode(dataPin_g, OUTPUT);
  pinMode(dataPin_b, OUTPUT);
  pinMode(ebene1, OUTPUT);
  pinMode(ebene2, OUTPUT);
  pinMode(ebene3, OUTPUT);
  pinMode(ebene4, OUTPUT);

}  

void loop() {
  for(int i=0; i<=(sizeof(ebene1_links)); i++)
  {
    for(int j=0; j<500; j++)
    {
      funktion(i, ebene1, 'g');
      funktion(i, ebene2, 'g');
      delay(100);
    }
  }
}

void funktion(int i, char ebene, char farbe){
  ebenenlatch(ebene, farbe, 1); 
  
  shift(ebene, farbe, i);
  
  ebenenlatch(ebene, farbe, 0);
}

void shift (char ebene, int farbe, int i){
  
  if(ebene == 'ebene1')
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_links[i]); 
    }
  }
  if(ebene == 'ebene2')
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_links[i]); 
    }
  }
  if(ebene == 'ebene3')
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_links[i]); 
    }
  }
  if(ebene == 'ebene4')
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_links[i]); 
    }
  }
}

void ebenenlatch (char ebene, char farbe, int zustand){
  
  if( farbe == 'r')
    { 
     digitalWrite(latchPin_r, ~zustand); 
    }
    if( farbe == 'g')
    { 
     digitalWrite(latchPin_g, ~zustand); 
    }
    if( farbe == 'b')
    { 
     digitalWrite(latchPin_b, ~zustand); 
    }
  if(zustand==0) delay(50);
  digitalWrite(ebene, zustand);
}

Arduino Uno mit den 47HC595 Schieberegistern. der 2. Register ist am 1. "angehangen" mit gleichem Latch und clockpin + Dataout in den Datain vom 2.

Meine Frage ist nun. warum er mein char Array nicht durchgeht sondern immer nur die erste LED blinkt?

Über Code-vereinfachungen wäre ich auch sehr erfreut
ist n bisschen durcheinander alles und kompliziert gemacht ^^

Mit freundlichen Grüßen

Kevin Baier

EDIT: Also ich hab jeweils ein Schieberegister für jeweils die linke hälfte einer Farbe LED's. sind ja 2x4 Pins. mit dem 2. Register die andere hälfte der Farbe. so steuer ich alle 3 farben mit 6 Schieberegistern an..
Das Ground pro Ebene steuer ich mit einem BUZ11 Mosfet

pylon · May 12, 2014, 12:15pm

void shift (char ebene, int farbe, int i){
  
  if(ebene == 'ebene1')

Du übergibst nie eine Ebene, die gleich 'e' ist, denn das wird hier geprüft. Nach meiner Interpretation Deines Codes sind hier einfach die Single-Quotes falsch, wenn Du die wegnimmst, könnte es funktionieren.

Du solltest in Betracht ziehen, zweidimensionale Arrays zu verwenden, das würde den Code angenehm vereinfachen.

Serenifly · May 12, 2014, 12:25pm

Ja, du musst lernen was C Strings sind und wie man diese verwendet. Strings kommen in Gänsefüschen. Und da Arrays Zeiger auf das erste Element sind, muss man einen char* als Parameter machen. Und aus dem gleichen Grund vergleicht man bei Arrays/C Strings mit == nur die Zeiger und nicht den Inhalt. Um Strings zu vergleichen gibt es strcmp()

Es ist aber höchstgradiger Unsinn für sowas Strings zu verwenden. Das verschwendet nur RAM

Nummeriere die Ebenen einfach durch und übergebe einen int oder ein byte. Ansonsten kann man das auch schön mit enums machen:

enum ebenen { EBENE1, EBENE2, EBENE3, EBENE4 };

In C sind enums direkt mit Integern gleichzusetzen. Man kann also einfach das machen:

void func(int state)
{
    if(state == EBENE1)
    {
    }
}

void loop()
{
    func(EBENE1);
}

Dann hat man sprechende Namen, aber der Compiler arbeitet einfach mit Zahlen.

system · May 12, 2014, 2:29pm

Hey

danke für die schnelle hilfe
ja ich muss zugeben ich hab einfach bisschen rumprobiert mit den ' und " bis es keine Fehler mehr gezeigt hat

das mit dem enum ebenen hat nicht geklappt..er hat mir danach ganz viele komische fehler angezeigt..sogar meine Kommentare waren falsch

ich hab es jetzt so gemacht:

//Pin connected to ST_CP of 74HC595
int latchPin_r = 10;
int latchPin_g = 8;
int latchPin_b = 9;
//Pin connected to SH_CP of 74HC595
int clockPin_r = 14;
int clockPin_g = 12;
int clockPin_b = 13;
////Pin connected to DS of 74HC595
int dataPin_r = 6;
int dataPin_g = 11;
int dataPin_b = 7;

int ebene1 = 2;
int ebene2 = 4;
int ebene3 = 3;
int ebene4 = 5;

char ebene1_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene1_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};



void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin_r, OUTPUT);
  pinMode(latchPin_g, OUTPUT);
  pinMode(latchPin_b, OUTPUT);
  pinMode(clockPin_r, OUTPUT);
  pinMode(clockPin_g, OUTPUT);
  pinMode(clockPin_b, OUTPUT);
  pinMode(dataPin_r, OUTPUT);
  pinMode(dataPin_g, OUTPUT);
  pinMode(dataPin_b, OUTPUT);
  pinMode(ebene1, OUTPUT);
  pinMode(ebene2, OUTPUT);
  pinMode(ebene3, OUTPUT);
  pinMode(ebene4, OUTPUT);

}  

void loop() {
  for(int i=0; i<=(sizeof(ebene1_links)); i++)
  {
    for(int j=0; j<500; j++)
    {
      funktion(i, 1, 'g');
      funktion(i, 2, 'g');
    }
    delay(100);
  }
}

void funktion(int i, int ebene, char farbe){
  ebenenlatch(ebene, farbe, 1); 
  
  shift(ebene, farbe, i);
  
  ebenenlatch(ebene, farbe, 0);
}

void shift (int ebene, int farbe, int i){
  
  if(ebene == 1)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_links[i]); 
    }
  }
  if(ebene == 2)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_links[i]); 
    }
  }
  if(ebene == 3)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_links[i]); 
    }
  }
  if(ebene == 4)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_links[i]); 
    }
  }
}

void ebenenlatch (int ebene, char farbe, int zustand){
  
  if( farbe == 'r')
    { 
     digitalWrite(latchPin_r, ~zustand); 
    }
    if( farbe == 'g')
    { 
     digitalWrite(latchPin_g, ~zustand); 
    }
    if( farbe == 'b')
    { 
     digitalWrite(latchPin_b, ~zustand); 
    }
  if(zustand==0) delay(50);
  
  if(ebene = 1) digitalWrite(ebene1, zustand);
  if(ebene = 2) digitalWrite(ebene2, zustand);
  if(ebene = 3) digitalWrite(ebene3, zustand);
  if(ebene = 4) digitalWrite(ebene4, zustand);
}

einfach mit Integer. ich weiß ja was gemeint ist

hat wer noch iwelche verbesserungsvorschläge um es übersichtlicher, einfacher oder besser zu machen?
das ich später einfach und leicht zu verstehen Muster anzeigen lassen kann

system · May 12, 2014, 3:25pm

funktioniert immer noch nicht
hab noch kleine fehler ausgebessert wie "==" anstatt = in der ebenenlatch funktion aber es passiert immer noch nur ein blinken...

doch was mir aufgefallen ist durch rumprobieren, das wenn ich in meiner inneren schleife(die ja eig nur die wiederholungen von jeweils einem "muster" bestimmt) ändere, also die mit dem j zähler, blinken andere LED's, was eigentlich nicht sein dürfte?

findet irgendjemand das problem?

EDIT: Fehler gefunden..das delay() in meiner ebenenlatch funktion... das musste nur raus
aber stimmen tuts immer noch nicht richtig
es leuchten beide ebenen gleichzeitig.. und überspringen tun sie auch ab und zu was
also zählen funktioniert wenn ich nur die funktion für die 1. ebene aufruf. dann gehts

mein jetziger code:

//Pin connected to ST_CP of 74HC595
int latchPin_r = 10;
int latchPin_g = 8;
int latchPin_b = 9;
//Pin connected to SH_CP of 74HC595
int clockPin_r = 14;
int clockPin_g = 12;
int clockPin_b = 13;
////Pin connected to DS of 74HC595
int dataPin_r = 6;
int dataPin_g = 11;
int dataPin_b = 7;

int ebene1 = 2;
int ebene2 = 4;
int ebene3 = 3;
int ebene4 = 5;

char ebene1_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene1_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};



void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin_r, OUTPUT);
  pinMode(latchPin_g, OUTPUT);
  pinMode(latchPin_b, OUTPUT);
  pinMode(clockPin_r, OUTPUT);
  pinMode(clockPin_g, OUTPUT);
  pinMode(clockPin_b, OUTPUT);
  pinMode(dataPin_r, OUTPUT);
  pinMode(dataPin_g, OUTPUT);
  pinMode(dataPin_b, OUTPUT);
  pinMode(ebene1, OUTPUT);
  pinMode(ebene2, OUTPUT);
  pinMode(ebene3, OUTPUT);
  pinMode(ebene4, OUTPUT);

}  

void loop() {
  for(int i=0; i<=16; i++)
  {
    for(int j=0; j<500; j++)
    {
      ausgabe(i, 1, 'g');
      ausgabe(i, 2, 'g');
    }
    delay(100);
  }
}

void ausgabe(int i, int ebene, char farbe){
  ebenenlatch(ebene, farbe, 0); 
 
  shift(ebene, farbe, i);
  
  ebenenlatch(ebene, farbe, 1);
}

void shift (int ebene, int farbe, int i){
  
  if(ebene == 1)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_links[i]); 
    }
  }
  if(ebene == 2)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_links[i]); 
    }
  }
  if(ebene == 3)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_links[i]); 
    }
  }
  if(ebene == 4)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_links[i]); 
    }
  }
}

void ebenenlatch (int ebene, char farbe, int zustand){
  
  if( farbe == 'r')
    { 
     digitalWrite(latchPin_r, zustand); 
    }
    if( farbe == 'g')
    { 
     digitalWrite(latchPin_g, zustand); 
    }
    if( farbe == 'b')
    { 
     digitalWrite(latchPin_b, zustand); 
    }
  //if(zustand==1) delay(50);
  
  if(ebene == 1) digitalWrite(ebene1, ~zustand);
  if(ebene == 2) digitalWrite(ebene2, ~zustand);
  if(ebene == 3) digitalWrite(ebene3, ~zustand);
  if(ebene == 4) digitalWrite(ebene4, ~zustand);
}

system · May 12, 2014, 3:51pm

Selbst ist der Mann
meine Funktion "funktion" in ausgabe umbenannt und abgeändert
jetzt funktioniert alles wie es soll

//Pin connected to ST_CP of 74HC595
int latchPin_r = 10;
int latchPin_g = 8;
int latchPin_b = 9;
//Pin connected to SH_CP of 74HC595
int clockPin_r = 14;
int clockPin_g = 12;
int clockPin_b = 13;
////Pin connected to DS of 74HC595
int dataPin_r = 6;
int dataPin_g = 11;
int dataPin_b = 7;

int ebene1 = 2;
int ebene2 = 4;
int ebene3 = 3;
int ebene4 = 5;

char ebene1_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene1_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene2_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000};
char ebene2_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_links[] = {B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001,
                       B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};
char ebene3_rechts[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_links[] = {B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000,
                        B10000000, B01000000, B00100000, B00010000, B00001000, B00000100, B00000010, B00000001};
char ebene4_rechts[] = {B00000001, B00000010, B00000100, B00001000, B00010000, B00100000, B01000000, B10000000,
                        B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000, B00000000};



void setup() {
  //set pins to output so you can control the shift register
  pinMode(latchPin_r, OUTPUT);
  pinMode(latchPin_g, OUTPUT);
  pinMode(latchPin_b, OUTPUT);
  pinMode(clockPin_r, OUTPUT);
  pinMode(clockPin_g, OUTPUT);
  pinMode(clockPin_b, OUTPUT);
  pinMode(dataPin_r, OUTPUT);
  pinMode(dataPin_g, OUTPUT);
  pinMode(dataPin_b, OUTPUT);
  pinMode(ebene1, OUTPUT);
  pinMode(ebene2, OUTPUT);
  pinMode(ebene3, OUTPUT);
  pinMode(ebene4, OUTPUT);
  
  showlatch('r', 0);
  showlatch('g', 0);
  showlatch('b', 0);
  showebene(1, 0);
  showebene(2, 0);
  showebene(3, 0);
  showebene(4, 0);

}  

void loop() {
  for(int i=0; i<=16; i++)
  {
    for(int j=0; j<500; j++)
    {
      ausgabe(i, 1, 'g');
      ausgabe(i, 2, 'g');
    }
    delay(50);
  }
}

void ausgabe(int i, int ebene, char farbe){
  
  shift(ebene, farbe, i);
  showebene(1, 0);
  showebene(2, 0);
  showebene(3, 0);
  showebene(4, 0);
  showlatch(farbe, 1);
  showlatch(farbe, 0);
  showebene(ebene, 1);
  
}

void shift (int ebene, int farbe, int i){
  
  if(ebene == 1)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene1_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene1_links[i]); 
    }
  }
  if(ebene == 2)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene2_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene2_links[i]); 
    }
  }
  if(ebene == 3)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene3_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene3_links[i]); 
    }
  }
  if(ebene == 4)
  {
     if( farbe == 'r')
    { 
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_r, clockPin_r, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'g')
    { 
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_g, clockPin_g, LSBFIRST, ebene4_links[i]); 
    }
    if( farbe == 'b')
    { 
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_rechts[i]);
     shiftOut(dataPin_b, clockPin_b, LSBFIRST, ebene4_links[i]); 
    }
  }
}

void showlatch (char farbe, int zustand){
  
    if( farbe == 'r')
    { 
     digitalWrite(latchPin_r, zustand); 
    }
    if( farbe == 'g')
    { 
     digitalWrite(latchPin_g, zustand); 
    }
    if( farbe == 'b')
    { 
     digitalWrite(latchPin_b, zustand); 
    }
}

void showebene (int ebene, int zustand){
  
  if(ebene == 1) digitalWrite(ebene1, zustand);
  if(ebene == 2) digitalWrite(ebene2, zustand);
  if(ebene == 3) digitalWrite(ebene3, zustand);
  if(ebene == 4) digitalWrite(ebene4, zustand);
}

bin trotzdem für Verbesserungsvorschläge für die Mustereingabe oder sonstigem offen :)) sind sogar sehr erwünscht

Serenifly · May 12, 2014, 6:33pm

kennobe:
hab noch kleine fehler ausgebessert wie "==" anstatt = in der ebenenlatch funktion aber es passiert immer noch nur ein blinken...

Wie gesagt, selbst wenn du korrekt "" verwendest, kannst du mit == keine Strings vergleichen. Nur weil der Code kompiliert, heißt das nicht dass er macht was du denkst.

Wenn du das hast:

char str[] = "test";

Dann ist str lediglich ein Zeiger auf das 't'. Mit == vergleichst du daher nur ob die Zeiger identisch sind.

Ein ähnliches Problem gibt es auch in manchen objekt-orientierten Sprachen wie Java. Da vergleicht == auch nur ob man das gleiche Objekt hat. Um den Inhalt eines Strings zu vergleichen braucht man da equals(). In C# ist in diesem einfachen Fall wieder anders. Da ist der == Operator überladen und vergleicht bei der String Klasse auch den Inhalt. Wenn man aber mit generischen Methoden oder Instanzen der Object Klasse arbeitet, dann ist der Verhalten wieder identisch wie bei Java.

In C ist die Funktion um Strings zu vergleichen strcmp():
http://www.cplusplus.com/reference/cstring/strcmp/
Die liefert bei Gleichheit 0 zurück

Hier mal ein praktisches Beispiel das das illustriert:

bool beginsWith(const char* str1, const char* str2)
{
  const char* ptr = strstr(str1, str2);
  return ptr != NULL && ptr == str1;
}

strstr() sucht nach einem Teilstring str2 in str1 und liefert einen Zeiger auf diesen wenn er gefunden wurde. NULL wenn er nicht gefunden wurde. Wenn der Zeiger also != NULL ist, ist der Teilstring enthalten. Dann fragt man noch ab ob der Zeiger identisch zu str1 ist. Wenn ja, zeigt ptr auf den Anfang von str1. Wenn nein wurde der Teilstring gefunden, aber er steht weiter hinten im String.

system · May 13, 2014, 5:31am

an dem Thema bin ich schon längst vorbei. ich habs verstanden^^

die anführungsstriche bei "==" waren nur zum zeigen gedacht das ich == meine hatten keine programmiertechnische bedeutung wenn man den code anschaut

Topic		Replies	Views
8x8x8 RGB Cube Schieberegister Probleme Deutsch	46	1035	November 10, 2023
How do I use variables in functions/procedures Programming	32	198	September 29, 2025
4x4x4 Cube mit 74HC595 Array Problem Deutsch	25	2040	May 6, 2021
5x5x5 RGB led cube Programming	15	753	May 20, 2024
Mitgabe von Werten für Variablen möglich? Deutsch	76	1149	February 18, 2024

RGB Cube 4x4x4 probleme

Related topics