3x3 RGB LED - Multiplexing und Bit Angle Modulation

[Danny (Gast)]

Ich habe mir zu Testzwecken eine 3x3 RGB LED Matrix auf einem Breadboard 
gebastelt. Die LEDs haben eine gemeinsame Kathode.

Für die Zeilen benutze ich pro Farbe ein Shift-Register (74HC595) und 
für die Spalten welche ich Multiplexen möchte laufen pro Spalte die 
gemeinsamen Kathoden zusammen und werden via NPN-Transistor (pro Spalte 
einen) mit einem GPIO meines Raspberry Pi verbunden.

Das reine ansprechen aller 9 LEDs in allen Farben ist sowei kein 
Problem.
Auch gezielt einzelne LEDs mittels BAM zu dimmen geht problemlos. Was 
ich aber noch nicht verstanden habe wie ich das ganze so gestalten kann, 
dass ich "Animationen" hinbekomme. Habe immer ein riesen durcheinander, 
dass die Abfolgen zu schnell sind oder die LEDs gewaltig flakern.
Bisher habe ich es mit Sleep (in Python time.sleep(x)) versucht und 
nicht mit interrupts. Soll ich das ändern?

Mein code sieht in etwa wie folgt aus (nicht optimiert mit Bit 
Operationen sondern als Prototyp mit String-Manipulation):

import RPi.GPIO as GPIO
import time

# Row  Pins
ROW0_PIN = 22
ROW1_PIN = 17
ROW2_PIN = 4

# RGB Pins
RED_PIN = 25
BLUE_PIN = 23
GREEN_PIN = 24

# I/O Pins
CLOCK_PIN = 27
LATCH_PIN = 18
RESET_PIN = 7

# GPIO Setup
GPIO.setmode(GPIO.BCM)
GPIO.setup(ROW0_PIN, GPIO.OUT)
GPIO.setup(ROW1_PIN, GPIO.OUT)
GPIO.setup(ROW2_PIN, GPIO.OUT)
GPIO.setup(RED_PIN, GPIO.OUT)
GPIO.setup(GREEN_PIN, GPIO.OUT)
GPIO.setup(BLUE_PIN, GPIO.OUT)
GPIO.setup(CLOCK_PIN, GPIO.OUT)
GPIO.setup(LATCH_PIN, GPIO.OUT)
GPIO.setup(RESET_PIN, GPIO.OUT)

# GPIO Initial
GPIO.output(ROW0_PIN, GPIO.LOW)
GPIO.output(ROW1_PIN, GPIO.LOW)
GPIO.output(ROW2_PIN, GPIO.LOW)
GPIO.output(RED_PIN, GPIO.LOW)
GPIO.output(GREEN_PIN, GPIO.LOW)
GPIO.output(BLUE_PIN, GPIO.LOW)
GPIO.output(CLOCK_PIN, GPIO.LOW)
GPIO.output(LATCH_PIN, GPIO.LOW)
GPIO.output(RESET_PIN, GPIO.HIGH)

# Send latch
def send_latch():
  GPIO.output(LATCH_PIN, GPIO.HIGH)
  GPIO.output(LATCH_PIN, GPIO.LOW)

# Send clock
def send_clock():
  GPIO.output(CLOCK_PIN, GPIO.HIGH)
  GPIO.output(CLOCK_PIN, GPIO.LOW)

def setRow(row):
  if row < 0:
    GPIO.output(ROW0_PIN, GPIO.LOW)
    GPIO.output(ROW1_PIN, GPIO.LOW)
    GPIO.output(ROW2_PIN, GPIO.LOW)
  if row == 0:
    GPIO.output(ROW0_PIN, GPIO.HIGH)
    GPIO.output(ROW1_PIN, GPIO.LOW)
    GPIO.output(ROW2_PIN, GPIO.LOW)
  elif row == 1:
    GPIO.output(ROW0_PIN, GPIO.LOW)
    GPIO.output(ROW1_PIN, GPIO.HIGH)
    GPIO.output(ROW2_PIN, GPIO.LOW)
  elif row == 2:
    GPIO.output(ROW0_PIN, GPIO.LOW)
    GPIO.output(ROW1_PIN, GPIO.LOW)
    GPIO.output(ROW2_PIN, GPIO.HIGH)      

def lowHigh(bit):
  if bit == '0':
    return GPIO.LOW
  else:
    return GPIO.HIGH

# Shift Register reset
def reset():
  GPIO.output(RESET_PIN, GPIO.LOW)
  GPIO.output(RESET_PIN, GPIO.HIGH)
  GPIO.output(LATCH_PIN, GPIO.HIGH)
  GPIO.output(LATCH_PIN, GPIO.LOW)

# Led Funktion
def led(x, y, red, green, blue):

  # Generiert das Bitmuster rückwärts mit führenden Nullen
  # Aus 254 wird 01111111
  # Aus  13 wird 11100000
  red_bit = bin(red)[2:].zfill(8)[::-1]
  green_bit = bin(green)[2:].zfill(8)[::-1]
  blue_bit = bin(blue)[2:].zfill(8)[::-1]

  # 1s / (3 Reihen mit 100Hz) / 255 Dimm-Stufen
  cycleTime = 1 / (3 * 100) / 255
  
  # Spalten 0 - 2
  for r in range(0, 3):
    # BAM Auflösung von 8 Bit (0-255)
    for i in range (0, 8):
      if y == r:
        if x == 2:
          red_shift = red_bit[i] + '00'
          green_shift = green_bit[i] + '00'
          blue_shift = blue_bit[i] + '00'
        elif x == 1:
          red_shift = '0' + red_bit[i] + '0'
          green_shift = '0' + green_bit[i] + '0'
          blue_shift = '0' + blue_bit[i] + '0'
        elif x == 0:
          red_shift = '00' + red_bit[i] 
          green_shift = '00' + green_bit[i]
          blue_shift = '00' + blue_bit[i]
      else:
          red_shift = '000'
          green_shift = '000'
          blue_shift = '000'

      # Anzeige ausschalten
      setRow(-1)

      # Für die 3 LEDs in der aktuellen Reihe das Muster anlegen
      for pinsInRow in range (0, 3):
        GPIO.output(RED_PIN, lowHigh(red_shift[pinsInRow]))
        GPIO.output(GREEN_PIN, lowHigh(green_shift[pinsInRow]))
        GPIO.output(BLUE_PIN, lowHigh(blue_shift[pinsInRow]))
        send_clock()

      # Muster für die aktuelle Reihe ausgeben
      send_latch()

      # Aktuelle Reihe einschalten
      setRow(r)

      # Die Wartezeit soll sich pro höherwertigem Bit erhöhen -> längere Leuchtzeit
      time.sleep(cycleTime * i)

reset()

try:
  while True:

    # Da brauche ich Hilfe


except KeyboardInterrupt:
  pass

GPIO.cleanup()

Wie muss ich z.B. die Main Methode gestalten, damit ich in der ersten 
Zeile Rot habe (LED 1: 100% LED 2: 75% LED 3: 50%)
in der zweiten Grün (LED 1: 100% LED 2: 75% LED 3: 50%)
und in der dritten Blau (LED 1: 100% LED 2: 75% LED 3: 50%)

Zuerst soll nur Zeile 1 (rot) leuchten, dann soll nach 1 Sekunde Zeile 2 
(grün) dazukommen und nach einer weiteren Sekunde soll noch Zeile 3 
dazukommem und gemeinsam leuchten. Danach wieder von vorne.

Bin da total irgend wie total auf dem Holzweg, bei all meinen Versuchen.

Ich erwarte keinen fertigen Lösungscode, sondern was ich umstellen muss 
resp. Pseudocode wie es vom Algorithnus her funktionieren sollte =)

Vielen Dank und Gruss
Danny

[Danny (Gast)]

Bin nochmals auf einem Notizblock den gewünschten Ablauf durchgegangen 
und meinen Code entsprechend korrigiert. Nun funktioniert das 
Multiplexing und Dimmen (mit BAM) wie gewünscht =)

Thread hat sich somit erledigt.