Brauche Hilfe beim Multiplexen mit Schieberegister (74hc595)

[T0m (werwolf92)]

Moin,

vorab bitte keine Kritik an der Schaltung selbst (außer sie hilft bei 
meinem Problem). (funktioniert btw hervorragend)
Die Schaltung habe ich mit Absicht so gewählt, weil ich mit den 
Bauelementen und den Programmiercode so üben möchte.
(Wenn ichs schnell und leicht haben wollte, würde ich auch andere 
Komponenten wählen).

So zu meinem Problem.
Das was die Schaltung aktuell kann ist das alle 5 RGB LEDs den selben 
Farbwechsel haben.
Was ich aber noch zusätzlich möchte ist das jede RGB LED einen eigenen 
Farbwechsel hat. Quasi LED1 geht grad von blau zu lila, LED 2 von rot zu 
gelb usw.

Allerdings wie kann ich denn sowas am besten "maskieren"?
Sowie ich es aktuell habe, habe ich es ja sehr leicht, da die Maske dazu 
einfach ist, da sich alle ändern und somit ich alle Pins gleichzeitig 
lösche oder setze.

Wie stelle ich es denn am schlauesten an, das jede LED ihr eigenes PWM 
mit Farbwechsel über die Schieberegister bekommt?

Ich suche btw keine fertige Lösung sondern nur den Ansatz dazu. Der 
Groschen fällt aktuell noch nicht.

Ich hoffe ich habe es verständlich erklärt.

Vielen Dank schonmal!

Gruß
T.

Edit: Am Atmega ist ein 20MHz Quarz

[Thomas E. (thomase)]

Betrachte die beiden SRs einfach als 16-Bit-Port.
Als Portregister legst du eine unsigned int Variable an.
Schreib dir eine ISR, die im Hintergrund diese Variable auf die SRs 
schiebt. Erst das Highbyte, dann das Lowbyte sendet und dann den Latch 
Up macht. Die Übertragung mußt du nach der Initialisierung nur einmal 
anschubsen. Die SPI-Geschwindigkeit setzt du soweit runter, daß noch 
genug Rechenzeit übrig bleibt für die anderen Sachen. Bei Fullspeed 
kommt er praktisch gar mehr raus aus dem Interrupt.

Deine Leds sind jetzt Bitpositionen in deinem Portregister. Das benutzt 
du genau so, wie du jeden anderen Port auch benutzt. Abgesehen davon, 
daß der jetzt 16 Bit breit ist.

Ob da SRs hinterhängen oder kleine grüne Männchen Kerzen anzünden, 
interessiert dich ab jetzt überhaupt nicht mehr.

[A. S. (Gast)]

Du hast 5 LEDs.

Behandle alle 5 LEDs parallel in eigenem Code, mit einer 3-Bit-Struktur 
(oder auch bytes, wenn RAM egal;

typedef struct
{
unsigned char rot;
unsigned char gruen;
unsigned char blau;
}TLed;
TLed L1, L2, L3, L4, L5;

/* code fuer L1 */
   L1.rot = 0;
   ....
   L1.gruen = 1;
   ... 
/* dito fuer L2 */

/* Dann packe am Ende die Bits in eine 16-Bit struktur */

typedef struct
{
   unsigned char L1_rot  :1;
   unsigned char L1_gruen:1;
   unsigned char L1_blau :1;

   unsigned char L2_rot  :1;
   unsigned char L2_gruen:1;
   unsigned char L2_blau :1;
   ...
   unsigend char L5_blau :1;
}TLeds;

TLeds Leds;

   Leds.L1_rot   = L1.rot;
   Leds.L1_gruen = L1.gruen;
   ...
   Leds.L5_blau  = L5.blau;

   und versende die 2 Leds-Bytes.

Ja, man könnte hier optimieren und ganze Strukturen kopieren... Aber bei 
16 Zeilen ("Leds.L1_rot = L1.rot") ist der Nutzen gering.
Bleibt noch sehr viel kopierter Code fuer die einzelnen LEDs ...
a) Spendiere der TLed-Struktur noch einen "Zustand", z.B int State.
b) Mache eine Funktion "void LedState(TLed *Led, int change);", die 
abhängig von "change" z.B. die nächste Farbe einträgt, oder bleibt (wenn 
change = 0).
c) Rufe LedState für jede Led mit verschiedenen "change" auf. Oder mache 
"change" von Taster 1 bis 5 abhängig, oder oder oder

[T0m (werwolf92)]

Moin,

Danke euch zwei schonmal!

ich habe ungefähr glaub ich verstanden was ihr meint!
Ich glaube aber ich mache es ein wenig umständlicher...
Musste mir grad erstmal typedef struct angucken was dies genau ist....^^

Habe nun folgendes erstmal erstellt:

#define maskeLed1Rot  0b0000000000000001
#define maskeLed2Rot  0b0000000000001000
#define maskeLed3Rot  0b0000000001000000
#define maskeLed4Rot  0b0000001000000000
#define maskeLed5Rot  0b0001000000000000

#define maskeLed1Green  0b0000000000000010
#define maskeLed2Green  0b0000000000010000
#define maskeLed3Green  0b0000000010000000
#define maskeLed4Green  0b0000010000000000
#define maskeLed5Green  0b0010000000000000

#define maskeLed1Blue  0b0000000000000100
#define maskeLed2Blue  0b0000000000100000
#define maskeLed3Blue  0b0000000100000000
#define maskeLed4Blue  0b0000100000000000
#define maskeLed5Blue  0b0100000000000000

#define maskeLed1Start  maskeLed1Blue    // Blau
#define maskeLed2Start  0b0000000000110000   // Grün und blau
#define maskeLed3Start  maskeLed3Green    // Grün
#define maskeLed4Start  0b0000011000000000  // rot und grün
#define maskeLed5Start  maskeLed5Rot    // rot

uint16_t volatile    maskeStart = (maskeLed1Start|maskeLed2Start|maskeLed3Start|maskeLed4Start|maskeLed5Start),
            maske0NextUp =  (maskeLed1Rot|maskeLed3Blue|maskeLed5Green),
            maske0NextDown = (maskeLed2Blue|maskeLed4Rot);

und dann erst mal so eingefügt:

  if(firstTry)
  {
    for(counter=0;counter<maxCount;counter++)
    if(fade < counter)
    {
      data |= (maskeStart);
      SPI_DATA((data));
    }
    
    else
    {
      data &= ~(maskeStart);
      SPI_DATA((data));
    }
    
    if((maxCount-1) == fade)
    {
      firstTry = false;
      fade=0;
    }
  }

/******************************************Step 1*/

  else if(next == 0 && firstTry== false)
  {
    for(counter=5;counter<maxCount;counter++)
    {
      
      if(fade <= counter)
      {
        data |= (maske0NextUp);
        data &= ~(maske0NextDown);
        SPI_DATA((data));
      }
      
      else
      {
        data |= (maske0NextDown);
        data &= ~(maske0NextUp);
        SPI_DATA((data));
      }
    }
  }

Funktioniert sogar!

Ich denke aber ich werde es versuchen nach dem Prinzip von Achim machen.
Ich habe nämlich noch nie etwas mit typedef struct gemacht und es ist ja 
auch "nur" ein Übungsprojekt.

Wenn ich nochmal mal Hilfe, meld ich mich nochmal! Vielen dank :)