Einen Kubus aus 125 LEDs mit dem RasPi steuern (Seite 3)

Das Programm rufen Sie von der Kommandozeile mit dem Befehl go run test.go auf. Zur Veranschaulichung finden Sie auf Youtube ein Video, das die Funktion demonstriert [3].

Multiplexen

Wie schon zu Beginn angesprochen, lässt sich der LED-Kubus nur im Multiplex-Betrieb voll ausnutzen. Um uns das Leben an dieser Stelle einfacher zu machen, verwenden wir die Parallelverarbeitungsmöglichkeiten von Go.

Das entsprechende Programm mit dem Namen mplex.go finden Sie in Listing 3. Speichern Sie es zusammen mit dem ersten Beispiel ab. Es stößt zwei parallel ablaufende Prozesse an, die eine gemeinsame Datenstruktur (ein dreidimensionales Array) verwenden. Die Datenstruktur müssen Sie nicht synchronisieren, weil ein Prozess immer nur schreibt und der andere ausschließlich liest.

package main
import (
  "fmt"
  "github.com/stianeikeland/go-rpio"
  "time"
)
var gpio[16] rpio.Pin
var cube[5][5][5] int
func gndOn(gnd int) { gpio[gnd+4].High() }
func gndOff(gnd int) { gpio[gnd+4].Low() }
func outputEnable() { gpio[10].Low() }
func outputDisable() { gpio[10].High() }
func clock(cl int) {
  gpio[cl+10].High()
  time.Sleep(time.Nanosecond * 100)
  gpio[cl+10].Low()
}
func resetAll(){
  for i:=0; i<5; i++ { gpio[i].Low() }
  for i:=1; i<6; i++ { clock(i) }
  for i:=1 ;i<6 ;i++ { gndOff(i) }
}
func multiplex() {
  for {
    for z:=0; z<5; z++ {    // Level
      if z==0 { gndOff(5) } else { gndOff(z) }
      outputDisable()
      for y:=0; y<5; y++ {  // Rows
        for x:=0 ; x<5; x++ { // Leds
          value:=cube[z][y][x]
          if value==1 { gpio[x].High() } else { gpio[x].Low() }
        }
        clock(y+1)
      }
      outputEnable()
      gndOn(z+1)
      time.Sleep(time.Millisecond * 1) // LEDs on time
    }
  } // endless loop
}
func cleanCube(){
  for x:=0;x<5;x++ {
    for y:=0;y<5;y++ {
      for z:=0;z<5;z++ {
        cube[x][y][z]=0
      }
    }
  }
}
func main() {
  if err := rpio.Open(); err != nil {fmt.Println(err)}
  defer func () {
    cleanCube()
    time.Sleep(time.Millisecond * 100)
    rpio.Close()
  } ()
  pins := [16]int{17,18,27,22,23,24,25,4,2,3,8,7,10,9,11,14}
  for i:=0 ; i<16 ; i++ {
    gpio[i] = rpio.Pin(pins[i])
    gpio[i].Output()
    gpio[i].Low()
  }
  var speed time.Duration = time.Millisecond * 100
  resetAll()
  go multiplex()
  for {
    for i:=0; i<5; i++ { cube[i][i][i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][2][i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][4-i][i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][4-i][2]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][4-i][4-i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][2][4-i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][i][4-i]=1 }
    time.Sleep(speed)
    cleanCube()
    for i:=0; i<5; i++ { cube[i][i][2]=1 }
    time.Sleep(speed)
    cleanCube()
  } // endless loop
}

Der lesende Prozess kümmert sich nur um das multiplexen der Anzeige. Wir nennen ihn ab jetzt den Multiplexer; der Aufruf erfolgt über die Funktion multiplex(). Er läuft im Hintergrund, liest kontinuierlich die Daten aus dem dreidimensionalen Array und schreibt sie auf die GPIO.

Der Multiplexer, der in einer Endlosschleife läuft, sieht unserem ersten Testprogramm sehr ähnlich. Der Unterschied liegt darin, dass er die LEDs nicht einfach nur an- und ausschaltet: Die LEDs erhalten ihre Werte stattdessen aus dem dreidimensionalen Array. Der Multiplexer läuft so schnell, wie die CPU es zulässt. Die Leuchtdioden leuchten mindestens eine Millisekunde – die Leuchtdauer gibt die Zeile mit dem Kommentar // LEDs on time vor.

Das Hauptprogramm in der main() Funktion belädt das dreidimensionale Array nur mit interessanten Mustern und steuert über die time.Sleep-Funktionen, wie lange ein bestimmtes Muster erscheint.

Die Funktion cleanup() löscht das komplette Array, damit es sich neu beschreiben lässt. Das führt eventuell zu einem Leuchten der LEDs; besser wäre es, jede einzelne Diode wieder kontrolliert auszuschalten. Der Code-Aufwand dafür wäre allerdings sehr hoch und brächte auch eine Menge Fehlerquellen mit sich. Daher verzichten wir darauf.

Apropos Flackern: Der Raspberry Pi ist kein echtzeitfähiges System. Sobald das Betriebssystem dazwischenfunkt und beispielsweise Daten auf die SD-Karte schreibt, stoppt das LED-Kubus-Programm für einen kurzen Moment, wodurch die Lichter der Kubus eventuell kurz flackern.

Um das Programm auf der Kommandozeile zu starten, verwenden Sie den Befehl go run mplex.go. Das Ergebnis zeigt wiederum ein Youtube-Video [4], auch ohne dass Sie dafür zum Lötkolben greifen müssen.

Fazit

Eine Frage bleibt am Ende noch zu klären: Wofür braucht man einen solchen LED-Kubus? Ganz einfach: Er sieht toll aus, und nicht jeder hat einen. Auf Messen oder in Schaufenstern aufgestellt, fängt der Würfel die Blicke der Passanten zuverlässig ein. Nach dem Zusammenbau darf man zudem mit Fug und Recht von sich behaupten, geübt im Umgang mit dem Lötkolben zu sein. Im Rahmen einer Ausbildung dient das Projekt somit dem Erlernen wichtiger Fähigkeiten.

Auch auf der Software-Seite vermittelt unser Kubus viel Neues: Echtzeit-Programmierung mit Go dürfte für viele Auszubildende noch ein unbekanntes Kapitel darstellen. Für angehende Fachinformatiker gibt es daher eine Menge zu lernen. Alles in allem finden Sie mit dem LED-Cube ein pädagogisch wertvolles Projekt, das noch dazu cool aussieht. Viel Spaß damit!