Control LED - Arduino & Raspberry Pi Projekte, How To's und Ideen...

LED Strip Matrix Animationsoftware für Arduino und Teensy

Oft werden Schaufenster oder Tresen mit leuchtenden LED Strips verziert. Im Internet gibt es verschiedene Variationen von LED Strips zu kaufen. Es gibt die 5V Ausführung, bei der jede LED adressierbar ist, sowie die 12V Ausführung, bei der 3 LEDs in Serie adressiert werden.

Für den kostengünstigen Anschaffungspreis ist die Verarbeitung und Robustheit der LED Strips sehr gut. Die LEDs sind in Serie geschalten und können an den vorgesehenen Anschlussstellen voneinander getrennt werden. Dadurch können die LED Strips auf kreative Weise den Raum beleuchten.

 

Ah okay, das hört sich cool an. Wie willst du dein Zimmer beleuchten?

 

Ich möchte mit den LEDs eine Anzeigetafel aufbauen, mit der ich Animationen und Lauftexte anzeigen kann. Das sieht schön aus und macht Spaß zu programmieren. Außerdem habe ich bereits ein ähnliches Projekt in der Vergangenheit gemacht. 8x12 RGB Matrix . Darauf kann ich aufbauen. Diesmal soll die LED Anzeige größer werden.

 

In dem Projekt hast du einzelne LEDs benutzt und keine LED Strips. Wie wird die Anzeige jetzt angesteuert?

 

Die LED Strips werden mit einem Microcontroller angesteuert. Dafür eignet sich ein einfacher Arduino Nano. Jedoch wird mit zunehmender Länge der LED Strips eine größere Speicherleistung des Microcontrollers erforderlich.
Welcher Microcontroller für dein Projekt in Frage kommt, klären wir nachher. Vorerst möchte ich dir meine Software vorstellen, sowie das Funktionsprinzip kurz erläutern. Das Programm für die Anzeigetafel ist aufgrund der Vielzahl von LEDs mühselig zu schreiben. Ein Bild benötigt mehrere Pixelpunkte, die alle im Speicher gesetzt werden müssen. Manuell alle Punkte zu setzen ist sehr aufwändig und wenig professionell.

Abhilfe habe ich durch meine LED Control Software schaffen können. Mit einer grafischen Oberfläche lassen sich die Pixelpunkte setzen, speichern und wieder löschen. Das Programm läuft unter Windows und Linux. Die Übertragung auf den Microcontroller erfolgt mit der seriellen USB Verbindung.

 

Das Programmieren der LED Strips ist dadurch einfach und ohne Programmierkenntnisse möglich.

Ok, das bedeutet ich benötige den Arduino Sketch und die LED Control Software aus diesem Post und kann direkt loslegen?

 

Nein, ganz so einfach ist es nicht. Du musst den Sketch auf die Größe deiner LED Anzeige anpassen. Zusätzlich müssen Einstellungen in der config.txt gemacht damit das Python Programm mit deinem Microcontroller kommuniziert. Die Einstellung sind in 10 Minuten gemacht und ich erklär die Schritt für Schritt, was du im Detail verändern musst.

Das hört sich ja kinderleicht an. Ich will die LED Anzeigetafel nachbauen!

 

Okay, dann les dir die nachfolgenden Abschnitte gründlich durch. Falls du Fragen zu dem Projekt hast oder nicht weiter weist, beantworte ich dir deine Fragen gerne in den Kommentaren oder per Email. 

 

 

1. LED Strips platzieren und verkabeln:

 

►Schneide die LED Strips in gleichlange Streifen.

►Befestige die LED Strips auf einer Unterlage. Ich habe dafür ein Brett genommen.

>►Verlöte die Leitungen GND nach GND, 5V nach 5V und Daten nach Daten. Beachte die korrekte Datenrichtung. Die zertrennten Strips müssen in Pfeilrichtung verbunden werden.

 

Datenrichtung LED Strips

 

►Schließe an den Anfang der LED Strips ausreichend lange Kabel an und crimpe einen 3 poligen Steckverbinder an die Kabel. (Crimpverbindungen raussuchen...). Die LED Ketten sollten nicht zu lang sein, da die Spannung bei zunehmender Länge sich langsam verringert, sowie die Datenübertragung länger dauert. Ich habe nach ca. 100 LEDs nicht mehr in Serie geschalten sondern parallel an den Anfang. Für die Daten habe ich einen weiteren Output benutzt. Insgesamt habe ich für 660 LEDs, 4 Ausgangskanäle am Microcontroller gelegt. Mit den Kondensatoren zwischen Vcc und GND lässt sich zwar der Spannungseinbruch etwas verringern, jedoch hilft das bei einer bestimmten Länge nicht mehr viel.

Datenleiltungen

 

2. Auswahl des geeigneten Microcontrollers

 

Wie am Anfang des Beitrags bereit geschrieben, wird für lange LED Strips viel Speicher benötigt. Der benötigte Speicher kann rechnerisch ermittelt werden:

In der LED Control Software können 34 Farben gesetzt werden. Sie werden als 2 stellige Dezimalzahlen an den Microcontroller übermittelt. Ein Bild benötigt demnach 2bytes/LED, die seriell über den USB Ausgang des PCs an den µC übertragen werden.

Dazu kommt das Setzen der LED Farben auf dem Strip. Die Aufgabe übernimmt der Microntroller. Das Datenprotokoll zur Ansteuerung der LED Strips benötigt 3 bytes/LED, da jede LED 256 Helligkeitsstufen der RGB Farben als Einstellwert benötigt.

 

Datenfluss PC Microcontroller

Der Microcontroller muss demzufolge 5bytes/LED bis zum nächsten Umschalten des Bildes speichern. Diese Anzahl an Bytes wird im SRAM (static random memory access) gespeichert, da dieser Speicherplatz für wechselnde Variablenwerte(i.d.F. LED Farbwerte), reserviert ist. Sobald der Microcontroller ausgeschaltet wird, löschen sich die Werte. Dieser Speicher ist nicht zu verwechseln mit dem Flashspeicher. Der Speicher ist für den Sketch reserviert. Die folgende Skizze verdeutlich den Datenfluss zwischen PC-µC und µC-LED Anzeige.

Die Rechnung lautet also: 5 bytes x Anzahl LEDs = Anzahl Speicher In meinem Projekt steuer ich 660 LEDs an was einen SRAM von 5 x 660 LEDs = 3.3 kb benötigt. Der Arduino Nano hat nur 2kb, weshalb er für die Anzahl an LEDs nicht möglich ist.

Auf der Suche im Internet nach Alternativen für den Arduino habe ich das Teensy Board entdeckt. Es ist leistungsstärker als der normale Arduino und zudem billiger als der Arduino Mega. Für 20 Euro habe ich mir einen Teensy bestellt.

Der Teensy 3.2 ist schnell, funktioniert zuverlässig und hat ausreichend SRAM Speicher. Die Boardinformationen für die Erstellung der Build Datei können in die Arduino IDE integriert werden. Dafür stehen auf der Herstellerseite des Teensy Boards die nötigen Addins zum Download bereit. Die Installation ist gut dokumentiert und hat bei mir einwandfrei funktioniert.

Welchen Microcontroller brauche ich jetzt? Es soll funktionieren und das mit der kostengünstigsten Methode!

 

Das ist abhängig von der Anzahl der LEDs. Für 2 x 5 Meter LED Strips sollte ein Arduino Nano oder Uno ausreichend sein. Solltest du mehr als 300 LEDs (1x 5m Rolle) ansteuern wollen würde ich dir einen Teensy raten, da der Arduino an seine Speichergrenzen stößt. Für kleinere LED Anzeigen reicht der Arduino aus.

 

3. Platine für die Elektronik erstellen

 

Die Bauteile sind nun alle angekommen. Dann wird es Zeit die Platine zu erstellen. Ich habe die Schaltung auf einer Lochrasterplatine zusammengebaut.

Im Anhang unter dem Post, findest du den Schaltplan.

Die Datenleitungen der LED Strips kannst du mit einer Steckverbindung auf der Platine platzieren.

Bei den Ausgangspegeln des Teensy verhält es sich gleichermaßen. Bei einem HIGH Signal liegen 3,3V an und bei einem LOW 0V. Die auf dem LED Strip integrierten WS2812b LED Treiber, arbeiten jedoch mit 5V Pegeln. Es gibt 2 Möglichkeiten das Problem für den Teensy zu lösen. Entweder mit einem Pegelconverter von 3,3V auf 5V, was ich gemacht habe... oder..

...was schneller geht und gar keinen Unterschied macht...

die Betriebsspannung des Netzteils der Versorgungsspannung der LEDs mit dem Poti auf ca 4,4V-4.5V einstellen. Die Referenzspannung für die HIGH und LOW Signale der WS2812B Treiber fällt dabei ebenfalls und der HIGH PEGEL des Teensy von 3,3V wird von dem Treiber als HIGH erkannt.

Warum brauche ich überhaupt den FTDI Converter? Ich kann doch einfach über die serielle Verbindung, über die ich den Arduino/Teensy programmiere auch die Daten über den seriellen Monitor senden.
 

 

Ja das stimmt schon. Damit kannst du die Daten senden. Leider ist der serielle Input Puffer dieser Leitung auf 64byte begrenzt. Wie vorhin erwähnt, schickt die LED Control Software pro LED 2byte. Damit könntest du 32 LEDs ansteuern und der Speicher wäre voll. Damit die Verarbeitung der Daten nicht zu kompliziert wird, ist es einfacher die HardwareSerial UART Ports des Arduino/Teensy zu benutzen. Für diese Ports kann der Speicherplatz für eingehende Daten bis zum maximalen physikalische RAM definiert werden. In meinem Projekt habe ich den Input Speicher von voreingestellten 64kb auf 2048kb gesetzt.

Zusätzlich sind die Datenpakete ausgehend vom PC als USB Signale bekannt. Die Microcontroller arbeiten jedoch mit TTL Levels. Der FTDI Stick wandelt die USB Signale des PCs in TTL Levels (3,3V oder 5V) um. Eine direkte Verbindung des USB Kabels an den Microcontroller ist demnach nicht möglich.

 

4. Arduino/Teensy Sketch einstellen

 

Der Teensy lässt sich mit der Arduino IDE programmieren. Dafür wird der Teensyloader und die Software Teensyduino benötigt.

Der Teensyloader wird für die Programierung des Teensys benutzt. Um Sketches auf den Teensy zu laden können, muss der Teensy in den "Programm Mode" gesetzt werden. Diese Aufgabe übernimmt der Teensy Loader.

Auf der Herstellerseite findest du die Doku, wie der Teensyloader installiert werden muss.
https://www.pjrc.com/teensy/loader.html

Der Teensyloader ist mit der Arduino IDE verknüpft, weshalb bei jedem Sketch Upload, der Teensyloader automatisch gestartet wird.

Als nächstes benötigst du das AddIn Teensyduino. Es implementiert die nötigen Boardinformationen der Teensy Microcontrollereihe in die Arduino IDE. Die Doku hierzu, findest du auf der Herstellerseite.
https://www.pjrc.com/teensy/teensyduino.html
 

Ok, ich habe alles installiert und die Arduino IDE erneut geöffnet. Wo kann ich jetzt den Teensy als Microcontroller einstellen?

 

Schau mal unter dem Reiter "Werkzeuge-Board". Da stehen jetzt neben den Arduino Boards auch die Teensy Boards!

Nachdem du alles nötige installiert hast um den Sketch zu kompilieren und auf das Board des Teensys zu flashen, beginnen wir jetzt mit den Sketch Einstellungen:
 

►Lade dafür den Sketch Serial_Teensy_Python.rar im Anhang herunter und öffne den Sketch in der Arduino IDE.

 

►Downloade die FastLED 3.1 Library vonGithub. Es beinhaltet die FastLED library für den Teensy. Die Arduino FastLED library findest du im Bibliothekmanager. Dort kannst du die aktuelle Version downloaden.

 

►Entpacke die ZIP datei in den library Ordner des Teensys C:\Program Files (x86)\Arduino\hardware\teensy\avr\libraries. Während der Installation des Teensyduino wurde der Ordner ...\hardware\teensy\... erstellt. Für den Arduino ist die library unter ...\hardware\arduino\... zu finden.

 

►Wechsel in den Ordner C:\Program Files (x86)\Arduino\hardware\teensy\avr\cores\teensy3
(Teensy) 
C:\Program Files (x86)\Arduino\hardware\teensy\avr\cores\arduino 
(Arduino) und öffne die Datei HardwareSerial1.cpp und ändere die Zeile in: #define SERIAL1_RX_BUFFER_SIZE 2048. Damit änderst du den SRAM für den seriellen Input Buffer auf 2048bytes.

 

►Wechsel wieder in den Sketch.

 

►Trage die Anzahl der LEDs ein:

#define NUM_LEDS 680        			//Setzt die Anzahl der LEDs

►Trage die Anzahl der Zeilen und Spalten ein:


#define num_rows 20                 //Setzt die Anzahl der Zeilen
#define num_cols 34                 //Setzt die Anzahl der Spalten

►Lege die Ausgangspins zu den Datenleitungen der LED Strips fest. Das sind die Teensy Pins an denen die Datenleitungen der LED Strips angeschlossen sind. Die Werte beziehen sich auf meine LED Anzeige! Änder die Anzahl und den Datenkanal auf deine Schaltung. Wie du siehst, sind bei mir 204 LEDs über einen Kanal angesteuert.

 

FastLED.addLeds(leds, 0, 204);                //A9 = Datenleitung; 0 = erste LED im Kanal; 203 = letzte LED im Kanal
FastLED.addLeds(leds, 204, 408);				//A8 = Datenleitung; 204 = erste LED im Kanal; 407 = letzte LED im Kanal
FastLED.addLeds(leds, 408,544);				//A7 = Datenleitung; 408 = erste LED im Kanal; 543 = letzte LED im Kanal
FastLED.addLeds(leds, 544, 680);				//A6 = Datenleitung; 544 = erste LED im Kanal; 679 = letzte LED im Kanal

♦Beachte: Die Aufzählung der LEDs beginnt programmtechnisch bei 0!

Wie finde ich die Bezeichnung meiner Pins raus?

 

Google nach Teensy oder Arduin Pinout. Die Pinbezeichnungen werden in Grafiken dargestellt.

Sobald du alle Einstellungen gemacht hast, kannst du den Sketch auf den Teensy/Arduino uploaden.

Falls es nicht funktioniert, kannst du mir gerne eine Email schreiben, dann kann ich dir weiterhelfen. 

 

5. Animationssoftware einstellen

 

►Downloade und entpacke die LED_Control_Software.rar aus dem Anhang am Ende des Posts.
Damit die Software mit dem µC richtig kommuniziert, müssen Variablen in der config.txt eingestellt werden.

►Öffne die Datei config.txt

►Trage hinter "anzahl_zeilen = " die Anzahl der Zeilen und hinter "anzahl_spalten = " die Anzahl der Spalten der LED Anzeige ein.

►Ändere die variable pathname in den Pfad um, indem auf deinem PC der Ordner animationengespeichert ist.
Achte darauf die Pfadstruktur C:/../LED_Tafel_v3/animationen/ nicht zu verändern.

►Gebe den COM_PORT an, an den der FTDI Converter angeschlossen ist. Die Nummer des COM Port findest du unter Start-Systemsteuerung-Geräte Manager-Anschlüsse (COM & LPT).

COM Port FTDI Converter

 

♦Die "screen_width = " (Fensterbreite) kannst du beliebig ändern, je nachdem welche Auflösung dein Bildschirm hat.

►Wechsel in den Ordner der LED_Control_Software und starte das Programm durck Klicken auf LED_Anzeige.exe Die Verbindung zum µC wird nun aufgebaut und das Programm startet.

 

6. Animationssoftware benutzen

 

Nachdem die Software gestartet, hast siehst du die Oberfläche und die Konsole. In der Konsole ist der verundenen COM-Port aufgelistet. Sollte der COM-Port in der config.txt falsch benannt sein, schließt das Programm nach dem Start direkt wieder. Du kannst die Software ohne Microcontroller benutzen indem du in der config.txt bei der Variablen den Wert None gibst. (COM_PORT = None).

Die Oberfläche ist selbsterklärend.

Neue Animationen können durch den Klick auf "Neue Animation" erstellt werden. Dabei öffnet sich die Tabelle und die Farbauswahl auf der linken Seite. Die Farben werden mit Linksklick gewählt und können durch das Anklicken auf die Zellen gesetzt werden. Dabei können mit gedrückter Maustaste auch Muster gezogen werden.

Mit der Funktion "Zeiteinstellung" wird die Umschaltzeit zwischen LED Bildern eingestellt. Es kann zwischen 0.02s und 2s gewählt werden

Über den Reiter "Animationen" werden die erstellen Animationen aufgerufen, sowie über Animation anzeigendargestellt. Die gespeicherten Animationen werden als HEX Zahlen in den Textdateien im Ordner "animationen" gespeichert und können durch das ändern des Textnamen umbenannt werden.

Das Starten eines Textes oder der Uhrzeit erfolgt durch das Klicken auf "Start Schrift". Dadurch wird der Text der in der config.txt neben der Variablen "text" eingetragen wird abgespielt. Wenn dort "text = Uhrzeit" eingetragen ist, läuft die aktuelle Uhrzeit ab.

So, das wars. wink Wenn dir das Projekt gefällt, würde ich mich freuen wenn du einen Kommentar hinterlässt.  smiley

 

Bauteilliste:

 

Bauteil Beschreibung Link
Teensy 3.2 ARM Cortex A4 Entwicklerboard amazon* affiliate
Bestellen
Netzteil 5V Netzteil 5V/200Watt/40A amazon* affiliate
Bestellen
RGB LED Streifen WS2812B LED Streifen amazon* affiliate
Bestellen
FTDI 232RL Converter USB to UART/TTL Level Signal Converter 5v/3,3V amazon* affiliate
Bestellen
10x Pegelconverter 3,3V -5V Logic Level Shifter Bidirectional 3.3V <-> 5V amazon* affiliate
Bestellen
Elektrobauteile 4x 300 Ohm Widerstand, 4x 1000µF Kondenstator  
Elektroaurüstung Lochrasterplatine, Kabel, Stecker  

Adressierung von LED Strips (WS2812B) mit dem Arduino

In diesem Tutorial zeige ich dir, wie du LED Strips einfach mit der NEOPIXEL Library von Adafruit adressieren kannst.
Du benötigst dafür einen Arduino,einen LED Streifen und einen 300-500 Ohm Widerstand. Auf dem LED Streifen ist ein Chip integriert, durch den die LEDs mit nur einer Datenleitung adressierbar sind.

Mit Hilfe der Adafruit Neopixel library ist das Programmieren der LED Strips sehr einfach.

Im folgendem, findest du eine Anleitung, wie du die LED Strips anschließen musst und wie du das Programm einstellst um schöne Farbfades anzuschauen.

 

1. LED Strip an den Arduino anschließen.

 

►Die Datenleitung (DIN) mit einem 300-500 Ohm Widerstand mit D6 des Arduino verbinden.

►Das Netzteil (5V) mit +5V(Arduino + LED Strip) und GND (Arduino + LED Strip) verbinden. (Je nach Länge des Strips muss ein stärkeres Netzteil verwendet werden)

►Der 5V Anschluss des Arduino kann ebenfalls für ganz kurze Ketten (<500mA) verwendet werden. Beachte eine LED in weißem Zustand verbraucht ca. 60mA.

►Bei längeren Ketten empfiehlt sich ebenfalls ein großer Kondensator an dem Netzteil, weil die Spannung bei längeren Ketten am Ende einbricht und die Farben sich dadurch verändern.

LED Strip Arduino anschließen

Beachte das eine LED bis zu 60mA benötigt.
 

 

 

2. Arduino programmieren:

 

►Lade den Sketch im Anhang herunter.

►Entpacke die Dateien led_strip_anzeige.ino und neopixel_fade_sketch.ino.

►Öffne die Dateien.

►Downloade in der Arduino IDE die Neopixel library. Die library befindet sich unter den Reiter
Sketch->Bibliothek einbinden->Bibliothek verwalten->Suche: Neopixel library

 

Arduino Neopixel library

 

►Uploade den Sketch auf den Arduino.

 

Lese das nächste Kapitel "3. Funktion des Sketches" um den Code anzupassen.

 

3. Funktion des Sketches

 

►Schau dir das Funktionsdiagramm void loop an.


♦Zuerst wird die Anzahl der Fades eingestellt. Das bedeutet, das ein Farbverlauf zwischen zwei Farben entsteht.
Die Farben werden als RGB Werte gespeichert.

Funktionsdiagramm Fade LED

 

Die Farbwerte werden im array "led_color_soll" über 3 for-Schleifen aufgerufen und anschließend in der Funktion "led_strip_anzeige" eingestellt . 
In der Funktion "led_strip_anzeige" werden die "led_color_soll" Werte mit den "led_color_ist" Werten verglichen und dementsprechend um 1 erhöht oder gesenkt. Die neuen Farbwerte werden daraufhin über die Neopixel library auf den LED Strip übertragen und das ganze wiederholt sich, bis alle Soll Werte erreicht sind.

 

Funktionsdiagramm Anzahl Fades

Die Farben werden als RGB Werte gespeichert. Dafür werden Werte zwischen 0-255 vergeben. Damit werden die RGB Farben gemischt und Zwischenfarben entstehen. Das nächste Bild zeigt die Mischzusammensetzungen der Farben.

 

RGB Farben

Jeder Farvwechsel (RGB (0,255,0) zu RGB (0,255,255)) ist ein Fade.
Weiterhin wird die Anzahl der LEDS in einer Variablen deklariert, sowie ein Variablenspeicher "farbwerte" für die späteren Vergleichswerte.

 

3.1 Neopixel library einstellen:

 

Die Adafruit_Neopixel library in der Arduino IDE unter ->Sketch->Bibliothek einbinden->Bibliothek verwalten suchen und downloaden. Sie wird mit dem Befehl #include Adafruit_NeoPixel.h in Zeile 1 importiert.

#include Adafruit_NeoPixel.h 
#define PIN 6 //DatenPin D6 am Arduino 
#define num_pixel 6 //Anzahl der LEDs 

 

3.2 Farbwerte einstellen

#define n_fades 6 //Anzahl der Fadevorgäne 
#define n_leds 6 //Anzahl der LEDs 
#define farbwerte 3 //Anzahl der Farbwerte 

int led_color_soll[n_leds][n_fades][farbwerte] = {{{0,0,255}, {255,0,100}, {255,0,0}, {255,255,0}, {0,255,0}, {0,255,255}}, //LED1
                                                  {{255,0,0}, {255,255,0}, {0,255,0}, {0,255,255}, {0,0,255}, {255,0,255}}, //LED2
                                                  {{255,255,0}, {0,255,0}, {0,255,255}, {0,0,255}, {255,0,255}, {255,0,0}}, //LED3
                                                  {{0,255,0}, {0,255,255}, {0,0,255}, {255,0,255}, {255,0,0}, {255,255,0}}, //LED4
                                                  {{0,255,255}, {0,0,255}, {255,0,255}, {255,0,0}, {255,255,0}, {0,255,0}}};//LED5
                                                                                              

In Array "led_color_soll" kannst du die Farbwerte (0-255) eintragen zwischen den gefadet werden soll.
Davor musst du n_fades, n_leds ebenfalls eintragen, damit die Listengröße bekannt ist.

Trage in der Liste "led_color_soll" die Farben ein.

 

Der Befehl Adafruit_NeoPixel strip = Adafruit_NeoPixel(num_pixel, PIN, NEO_GRB + NEO_KHZ800); stellt die Datensignale ein.
Dabei beschreibt NEO_GRB die Datenfolge des Bitstream und NEO_KHZ800 die Geschwindigkeit des Bitstream.

 

3.3 void_loop:

void loop() {
  for (int fade =0; fade< n_fades; fade++){                              
   for (int i = 0; i<255;i++) {                     
      for (int led =0; led

Es werden immer alle 3 Farben an die Funktion "led_strip_anzeige" übergeben. Sobald eine Fade durchgeführt wurde, kann durch das delay in Zeile 38 eine kurze Pause zwischen den Fades eingestellt werden.
In Zeile 35 werden der Bitstream mit Befehl strip.show() aus dem Speicher geladen und auf die LEDs übertragen.

 

3.4 Fade-Funktion "led_strip_anzeige"

int vergleiche_ist_soll_wert(int ist_wert, int soll_wert) {                 
    int differenz = soll_wert - ist_wert;   
    return differenz;                                                      
}
int neuer_ist_wert(int differenz, int wert ) {                              
                                                                      
    if (differenz > 0) {                                                                                                                 
       wert += 1;                                     
    }
    else if (differenz < 0) {               
       wert -= 1;                                       
    }
    else if(differenz == 0) {                           
       wert = wert;
    }
    
  if ( wert > 255) {                                   
     wert = 255;
  } 
  else if (wert < 0) {
     wert = 0;
  }
  int neuer_wert_ist = wert;
  return neuer_wert_ist;                                            

}
int led_strip_anzeige(int color[3], int led) {

int soll_farbwert_rot = color[0];
int soll_farbwert_gruen = color[1];
int soll_farbwert_blau = color[2];

int differenz_rot = vergleiche_ist_soll_wert(led_color_ist[led][0], soll_farbwert_rot);          
int differenz_gruen = vergleiche_ist_soll_wert(led_color_ist[led][1], soll_farbwert_gruen); 
int differenz_blau = vergleiche_ist_soll_wert(led_color_ist[led][2], soll_farbwert_blau);
 
int neuer_ist_wert_rot = neuer_ist_wert(differenz_rot, led_color_ist[led][0]);  
int neuer_ist_wert_gruen = neuer_ist_wert(differenz_gruen, led_color_ist[led][1]);
int neuer_ist_wert_blau = neuer_ist_wert(differenz_blau, led_color_ist[led][2]);

led_color_ist[led][0] = neuer_ist_wert_rot;                             
led_color_ist[led][1] = neuer_ist_wert_gruen;
led_color_ist[led][2] = neuer_ist_wert_blau;

strip.setPixelColor(led , led_color_ist[led][0], led_color_ist[led][1], led_color_ist[led][2]);

►Die Funktion "led_strip_anzeige" überprüft den Soll-Wert der Farbe mit dem aktuellen Ist-Wert. Die Differenz dafür wird in "vergleiche_ist_soll_wert"(Zeile 2) berechnet. Je nach Ergebnis wird der neue Ist-Wert um 1 kleiner (Zeile 11) oder um 1 größer (Zeile 8), ansonsten bleibt er gleich. Die nachfolgende if Abfrage (Zeile 17-Zeile 22) dient zur Überprüfung, damit der Wert nicht größer als 255 bzw. kleiner als 0 wird.

►Der neue Wert wird in "led_color_ist" eingetragen und mit der Neopixel Funktion strip.setPixelColor() in den Speicher für die Datenleitung gesetzt.

►Dieser Vorgang wiederholt sich für alle Werte, die in led_color_soll eingetragen werden.

 

Es gibt sicher noch elegantere Lösungen. Damit kannst du jedoch schon schöne Effekte programmieren!

 

Bauteilliste:

Bauteil Beschreibung Link
RGB LED Streifen WS2812B LED Streifen amazon* affiliate
Bestellen
1x Arduino Nano Entwicklerboard mit CH340 Chip Atmega328P amazon* affiliate
Bestellen
300-500Ohm Widerstand Widerstand 1/4W  
Schaltnetzteil 5V, 2A, 10W amazon* affiliate
Bestellen
Elektroausrüstung Kabel, Stecker, Lochrasterplatine  

Li-Ion Akku 4.2V Ladestatusanzeige (LM3914)

Um die Batteriespannung von Akkus anzuzeigen eignet sich ein einfacher Indikator, der den Batteriezustand auf LEDs ausgibt. Eine simple Methode habe ich dafür im Internet gefunden, für die ich einen LED DOT/BAR Graph und den LM3914 Chip bestellt habe. Der DOT/BAR Graph kann jedoch auch mit einzelnen LEDs ersetzt werden.

Du kannst den folgenden Text auch einfach überspringen und die Schaltung nach dem Schaltplan im Anhang nachbauen.

 

Der Schaltplan im Anhang funktioniert zum Messen von einem Li Ionen Akku.
 

 

Wie funktioniert der LM3914 Chip?

Der Chip hat 10 Ausgänge a, die über über 10 Komparatoren ein bzw. ausgeschaltet werden. Die Komparatoren sind intern im Chip mit 1kOhm Widerständen als Spannungsteiler parallel zu den Ausgängen RLo und RHi geschaltet.


Angenommen:

#An RLo liegen 2.95V an und die interne Referenzspannung wird als Messweite (2.95V Batterie leer -> 4,2V Batterie voll) festgelegt.

#An Pin 5 (SIG) wird eine Batterie, mit einer momentanen Spannung von 3.55V angeschlossen.

An jedem Spannungsteiler fällt nun Vref/10 = 0.125V ab. Die 0.125V addieren sich von RLo bis RHi und werden mittels den nicht invertierenden Komparatoren verglichen. Die Batteriespannung (SIG) fungiert dabei als Referenzspannung des Komparators und liegt am - Eingang der Komparatoren. Wird die Spannung am + Eingang> - Eingang, was bei diesem Fall bei 3.55V der Fall ist, schaltet der Komparator nicht mehr durch und die LED bleibt aus.

An jedem Spannungsteiler fällt nun Vref/10 = 0.125V ab. Die 0.125V addieren sich von RLo bis RHi und werden mittels den nicht invertierenden Komparatoren verglichen. Die Batteriespannung (SIG) fungiert dabei als Referenzspannung des Komparators und liegt am - Eingang der Komparatoren. Wird die Spannung am + Eingang> - Eingang, was bei diesem Fall bei 3.55V der Fall ist, schaltet der Komparator nicht mehr durch und die LED bleibt aus. 

LM3914 Komparatoren

Schaltung fürSpannungsindikatorfür1 Li-Ion Akku 2.95V - 4.2V

Der LM3914 wird mit einem DC/DC Wandler mit 5.5V betrieben. Auf dem Eingang liegt die Batterie. Wichtig ist es das der DC/DC Wandler auch bei kleineren Batteriespannungen<3V, konstant 5.5V liefert, da sonst die Schaltung nicht funktioniert. Die Betriebsspannung muss immer mind. 1.25 V größer als die obere Messspannung (RHi) sein. Um beispielsweise einen Li-Ion Akku (leer: 2.95V voll: 4.2V) zu messen, müssen an RLo 2.95V und an RHi 4.2V anliegen. Diese Spannungen werden, sowie der Ausgangsstrom für die LEDs mit den Widerständen R1 und R2 eingestellt.

Dafür wird der potentialfreie(!!!) Ausgang REFOUT auf RHi gebrückt. Potentialfrei bedeutet, dass unabhängig der Beschaltung um den Chip, immer 1.25V an REFOUT anliegen. Die Ausgangsspannung an REFOUT kann jedoch durch den PIN REFADJ verändert werden. Somit können anhand der Referenzspannung unterschiedliche Spannungen erzeugt werden, mit denen beispielsweise die Messgrenzen an RHi und RLo individuell eingestellt werden können. Dieser Effekt wird für die Anwendung genutzt.

 

Die Betriebsspannung muss immer 1.25V über der oberen Dividerspannung liegen, dafür wird der DC/DC Wandler (siehe Schaltplan) benötigt.

 

Referenzspannungseinstellung mit R1 und R2 des LM3914:

1. Widerstandsberechnung R1:

Die Widerstände R1 und R2 bilden einen Spannungsteiler zwischen REFOUT und Masse.
Zwischen REFOUT und REFADJ liegen 1.25V Referenzspannung. Der RHi Pin wird direkt auf REFOUT gebrückt. Somit liegen an RHi vorerst 1.25V. Dadurch fließt Strom zwischen REFOUT durch den Widerstand R1 nach REFADJ Strom, da REFADJ intern an Masse geschaltet ist. An R1 fallen nun 1.25V ab.Der Widerstandswert muss jedoch noch ermittelt werden. Dieser Wert ist abhängig für die LED Ausgangsstromwerte.

 Achtung: R1 ist parallel geschalten an die Pins RLo und RHi. Deshalb wird der Spannungsteiler belastet berechnet. 

Spannungsteiler für Referenzspanungungseinstellung des LM3914

2. Widerstandsberechnung R2

Wie im Schaltplan zu sehen, ist REFADJ nicht direkt an die externe Masse angeschlossen, sondern an die Mitte des Spannungsteilers. Somit fließt der Strom weiter durch R2 und erzeugt dort einen Spannungsabfall.
Die Spannung wird als Potential für die untere Dividerspannung verwendet und soll 2.95V betragen. Dafür wird der Strom durch R1 sowie der Strom aus REFADJ addiert. Durch die Stromangabe sowie den gewünschten Spannungswert von 2.95V, lässt sich der Widerstand R2 berechnen,

Kurz: Der Spannungsteiler hat die Funktion durch den Spannungsabfall an R2 die untere Dividerspannung auf 2.95V zu setzen und durch den Spannungsabfall an R1+R2 die obere Dividerspannung auf 4.2V zu setzen.

Dot oder Bargraph Mode des LM3914?

Über den PIN 9 "Mode" werden die Ausgänge in der "Bargraph" oder "Dotanzeige" betrieben.
Bei der Bargraphanzeige leuchten alle Balken(LEDs) bis zum aktuellen Ladezustand der Batterie. Einstellung:PIN9 an 5V
Die Dotanzeige zeigt mit einem leuchtenden Balken den aktuellen Ladezustand der Batterie. Einstellung:PIN9 an GND

Zusätzlich könntest du noch ein Laderegler für den Akku dazuhängen und hättest ein funktionsfähiges Akku Ladegerät.

 

Bauteil Beschreibung Link
LM3914 IC LED Treiber IC Bar/Dotgraph amazon* affiliate
Bestellen
Dot/Bargraph Indikator mit 10 LEDs (rot, gelb, grün) amazon* affiliate
Bestellen
2x LiIon Akku 3.7V Li Ion Akku 3400mAh amazon* affiliate
Bestellen
1x LiIon Akku 18650 Batteriehalter Batteriehalter für Lithium Ionen Akku amazon* affiliate
Bestellen
5x TP4056 Ladereglermodul 1A Ladereglermodul mit Tiefentladeschutz amazon* affiliate
Bestellen
DC/DC Wandler 2V/5V Eingangsspannung: DC 2V-24V; Ausgangsspannung: DC 5V-28V; amazon* affiliate
Bestellen
Elektrobauteile 1x 8,6 kOhm, 1x 9,8 kOhm  
Elektroaurüstung Lochrasterplatine, Kabel, Stecker  

High Power RGB LED Bambusleuchte (PWM Expander TLC5940)

Neben den kleinen LED's, die es schon lange gibt, sind in den letzten Jahr mehr und mehr LED Lampen auf den Markt gekommen. Neben den standardisierten LED Lampen, die in die gängigen Sockelfassungen passen, gibt es noch LED DIY Chips.

Die LED Chips sind klein und günstig, jedoch brauchst du eine Konstantstromquelle + LED Treiber um die LEDs zu betreiben. Bei LEDs mit großen Wattzahlen ist ebenfalls eine gute Wärmeableitung wichtig.Diese Chips wollte ich ausprobieren und habe mir 3W RGB High Power LEDs gekauft. Wie ich die LEDs anschließen und per PWM dimmen kann, war mir zu dem Zeitpunkt noch nicht klar.Ich habe erst versucht, den Strom per Vorwiderstand einzustellen, was zwar funktioniert hat, jedoch war der Widerstand extrem heiß, da viel Leistung am Widerstand abgefallen ist. Die Spannung an den LED's war nicht stabil und per PWM mit dem Arduino dimmen konnte ich auch nicht, da kein Output soviel Strom liefert.

 

Es werden 350mA Konstantstromquellen benötigt, damit keine Verlustleistungen durch Vorwiderstände auftreten und die LEDS aufgrund von hitzebedingten Stromschwankungen nicht beschädigt werden!

 

 

 Als nächstes habe ich im Internet nach Schaltungen für Konstantstromquellen gesucht und eine Schaltung mit zwei gegeneinander geschalteten Transistoren gefunden, die in dieser Anordnung Strom konstant regeln.Die Stromregelung hat funktioniert, jedoch konnte ich damit nie exakt 350mA einstellen. Dieser Stromwert ist wichtig, da es für LEDs eine U-I Kennlinie gibt. Bei 350mA fällt über jeder Farbe die Spannung ab, die nötig ist, damit die LED so hell wie möglich scheint ohne kaputt zu gehen. Da die U-I Kennlinie nicht linear ist, ändert sich der Spannungswert bei einer Veränderung des Stromwertes stark.

Schlussendlich habe ich in ebay dimmbare (PWM oder analog) Konstantstromquellen für 350mA gekauft. Die Stromregelung funktioniert mit dem IC ZXDL1360. An die KSQ's könnte auch Wechselspannung angeschlossen werden, da ein Gleichrichter verbaut ist. (siehe Schaltplan im Anhang) Nachdem alles funktioniert hat, habe ich mich entschlossen eine Raumbeleuchtung mit 15 x 3W RGB LEDs zu machen. Mit meinem Onkel habe ich den Rahmen und die 2 OSB Platten gemacht.

 

Holzrahmen

 

♦ Der Rahmen ist aus Holz und die Kanten verlaufen schräg nach innen. Die Rahmenteile sind mit 45° Gehrungen miteinander verleimt.

Holzrahmen

 

♦ Die 1. OSB Platte ist in die Nut gesteckt (gelb) und die 2. OSB Platte in den Versatz geschraubt.(rot)

 

Verbindung OSB Platten

 

♦OSB Platte 1 Vorderseite: Es sind 15 Löcher für die LEDs gebohrt, auf denen die Bambusblenden sitzen. Die Bambusblenden sind schräg aufgeleimt, damit die LEDs nicht blenden.
♦OSB Platte 1 Rückseite: Die Rückseite ist in 5 Flächen eingeteilt, die durch Holzbalken voneinander lichtdicht abgetrennt sind

 

OSB Platte Rückseite

 

♦OSB Platte 2 Vorderseite: Auf der 2. OSB Platte sitzen, die mit Wärmeleitkleber befestigten LED's mit Linsen. Die Löcher (außen) sind für Schrauben, die die Aluminiumbleche halten.

 

LED mit Linsen

 

TLC 5940 - 16 Channel LED PWM Expander

 

Wie ich am Anfang dieses Beitrags geschrieben habe, werden die LEDs an dimmbare Konstantstromquellen (KSQ) angeschlossen. Insgesammt sind es 15 RGB LEDs. Dabei sind 3 LEDs in Serie geschaltet. Da jede LED 3 Kanäle hat (RGB) sind 3 Kanäle in Serie geschalten. 

 

Serienschaltung LED Kanäle

Da jeder Kanal eine Farbe ansteuert sind 15 Kanale nötig, damit der komplette RGB Farbverlauf sichtbar werden kann. Der Arduino Nano hat jedoch keine 15 PWM Ausgänge.

 

Als PWM Expander für Microcontroller eignet sich das 16 PWM Kanal Breakoutboard von Sparkfun TLC5940 mit 12 Bit Auflösung.
 
 

 

Es gibt ein fertiges Modul von SparkFun, das auf dem TLC5940 Chip basiert und 16 PWM Ausgänge hat. Im Schaltplan ist die Verbindung zwischen dem Arduino und dem TLC5940 Breakoutboard zu finden. Mit diesem Modul und den bereits vorhanden KSQ's, habe ich die LEDs zwar dimmen können, jedoch war das Ausgangssignal invertiert. Dadurch waren die LEDs bei einem Tastgrad von 100% durchgehend aus.

 

SN74HC04N PWM Inverter IC

 

Mit diesem Problem bin ich zum Elektrofachhandel gegangen und habe das Problem geschildert. Mir wurde der Chip SN74HC04N empfohlen, den ich daraufhin erfolgreich gestestet habe. Ohne zusätzliche Bauteile war es möglich, den Chip als Invertierer zu benutzen. Somit wird das Ausgangssignal des Arduino 2x invertiert und somit wird regulär.

Spannungsversorgung und Stromverbrauch:

Mit folgende Spannungen werden die Module der Schaltung betrieben:


  • Bluetooth Stick HC06 = 3,3V

  • TLC5940 Breakoutboard = 5V

  • SN74HC04N = 3,3V

  • LED Serienschaltungen = 12V

  • Arduino Nano = 5V

Netzteilauswahl:

Stromverbrauch der Module:
 

  • Arduino Nano: ~25mA
  • TLC 5940 Breakout Board: 17,5 mA/Channel * 15/Channel = ~250mA
  • SN74HC04N: 50mA * 3 Stück = 150mA
  • Bluetooth Stick HC06 = k.A. vernachlässigt
  • LED Kanäle: 350mA * 15 Kanäle = 5250 mA

  • Zusammengerechnet: ca. 5,65A



Geeignetes Netzteil: 12V (mind. 70W)!
Die 5V Spannungsversorgung für den Arduino sowie TLC Board erfolgt über den DC-DC Wandler! Die 3,3V Spannungen werden direkt am Arduino abgegriffen.

 

Android App

Die Ansteuerung erfolgt über Bluetooth oder direkt über den seriellen USB Eingang des Arduino Nano. Als Regler kann ein Smartphone benutzt werden. Mit der App können die LED Kanäle 1-5, sowie die Farbe ausgewählt werden. Die Verbindung zum Bluetoothempfänger HC06 kann ebenfalls über die App aufgebaut werden. Dafür wird benötigt:

 

►Die App RGBLED_Control.apk. Sie ist in RGBLED_Control.rar komrimiert.

►Den Arduino Code zum Empfang der Daten: bluetooth_verbindung.rar

 

Arduino Sketch Upload:

►Lade die bluetooth_verbindung.rar herunter

►Entpacke die bluetooth_receive.ino und die fading.ino

>►Ziehe beide Dateien in einen Ordner und uploade die bluetooth_receive.ino auf den Microcontroller

Bevor du eine Bluetoothverbindung mit der HC06 Bluetoothadapter aufbauen kannst, musst du den Adapter mit deinem Handy koppeln. (Code: 1234)
 
 

Bluetooth App Farbeinstellung LED

Falls du Fragen zu dem Code oder der Schaltung hast, kannst du einen Kommentar hinterlassen. Viel Spaß beim Probieren.

 

Bauteilliste:

Bauteil Beschreibung Link
15x 3W LED Chips RGB mit Lötanschluss auf PCB amazon* affiliate
Bestellen
15x Konstant-
stromquelle
Eingangsspannung bis 24V Ausgangsstrom ~350mA amazon* affiliate
Bestellen
12V Netzteil Netzteil 12V/5A/60Watt amazon* affiliate
Bestellen
TLC5940 Breakoutboard 16 PWM Kanäle, Auflösung 12 Bit amazon* affiliate
Bestellen
3x SN74HC04N IC Signal Invertierer Chip amazon* affiliate
Bestellen
Arduino Nano Entwicklerboard mit CH340 Chip Atmega328P amazon* affiliate
Bestellen
DC/DC Step Down Wandler 12V/5V DC-DC Step Down Wandler, Eingangsspannung: 3,2 - 40V, Ausgangsspannung: 1,25 - 35V
Strom max. 3A
amazon* affiliate
Bestellen
Bluetooth-
adapter HC06
Wireless Bluetooth Transceiver TTL zu UART Konverter amazon* affiliate
Bestellen
Elektrobauteile 16 x 10kOhm, 1x kOhm  
Elektroaurüstung Lochrasterplatine, Kabel, Stecker  

RGB LED Matrix 8x12 Animationsoftware

Wie du eine RGB LED Matrix mit 8 Zeilen und 12 Spalten bauen kannst, zeige ich dir in diesem Post.
Die LED Tafel eignet sich als Zimmerdeko und als Uhr. Jede LED ist einzeln adressierbar und kann 8 Farben anzeigen. Die Ansteuerung funktioniert mit einem Linux oder Windows PC.

Mit dem Programm LED_Matrix (im Anhang) kannst du LEDs samt Farbe adressieren. Zusätzlich hat es eine grafische Oberfläche mit der du Animation erstellen, abspielen und speichern kannst. Lauftexte und Uhrzeitdarstellung ist ebenfalls möglich. Die Installation und die Funktionsweise des Programms findest du im späteren Teil dieses Posts.

Als Grundplatte habe ich einfach ein Stück Karton genommen, in den ich die LEDs reingesteckt und anschließend dahinter verkabelt habe. Für weitere Verbindungen zwischen eingestochen LEDs und der Platine habe ich Flachbandkabel mit Stecker benutzt, damit ich die LEDs von der Schaltung abstecken kann. Aufgrund der Vielzahl an benötigten Bauteilen und Verbindungen hat der Schaltungsaufbau mit dem Lötkolben lange gedauert.

Gerne kann ich dir die Fritzing Datei schicken und du kannst daraus ein PCB layouten. Den Schaltplan findest du hier hier oder im Anhang dieses Posts.
Das Ergebnis sieht dann in etwa so aus.

Auf dem PC kannst du die Animationen und Einstellungen ändern und per USB Kabel auf den Controller (bei mir Arduino Nano) übertragen. Der Arduino wertet die Datenpakete aus und steuert die Lichter dabei an. so aus.

 

Animationen LED Matrix

 

Die LED Tafel besteht aus insgesamt 96 LEDs. Aufgeteilt ist sie in 8 rows(Zeilen) und 12 columns(Spalten).
Um jede einzelne LED mit den Digital Pins des Arduino anzusteuern wären 96 LED * 3 Farben= 288 Digital Out Pins nötig. Um diesem Problem abhilfe zu leisten, gibt es den SN74HC595N Chip, der als PIN Expander genutzt werden kann.

 

Port Erweiterung mit Schieberegister SN74HC595N

 

Zum Verständnis: Die 12 Anoden (12 pro Zeile) der LEDs sind in Serie geschaltet. Für jede Zeile wird eine Steuerleitung benötigt. Also sind 8 Steuerleitungen nötig.
Alle Kathoden (3 Farben * 12 Spalten = 36 Steuerleitungen) werden angesteuert.
44 Steuerleitungen
Wie die Ansteuerung im Detail mit den verwendeten Transistoren funktioniert, erkläre ich im nächsten Abschnitt.
Als nächstes beschreibe ich die Funktionsweise der Schieberegister.

Über die Leitung Data Signal (DS), sendet der Arduino eine 0 oder eine 1 zum Schieberegister. Sobald an ShiftClock (SH_CP) ein Flankenwechsel von 0V auf 5V stattfindet, wird der momentane Wert (0 oder 1) der DS Leitung in den Schieberegisterspeicher geschoben. Nach erneutem Flankenwechsel von 0V auf 5V, wird ein weiteres Bit in den Speicher einfügt und das erste wandert einen Platz weiter. Sobald der erste Speicher voll ist (8Bit), wird das nächste Bit in das 2. Register geschoben usw... Falls kein Register mehr nachgeschaltet ist, "fallen" die Bits raus.

Nach vollendeter Schiebeoperation wird der Wert im Speicher an die Ausgänge übergeben. Das geschieht durch den Flankenwechsel von 0 auf 1 an der ST_CP Leitung (StoreClock) . Dadurch werden zur gleichen Zeit die Zustände an die Ausgänge übergeben und das LED Bild entsteht. Zum besseren Verständnis, habe ich ein gif erstellt, das den Schiebevorgang zeigt. 

Schiebevorgang Schieberegister

 

Multiplexing LEDs

 

Es wäre bei kleineren Strömen durchausmöglich die LEDs ohne die Transistoren an die Ausgänge der Schieberegister anzuschließen. Jedoch besteht die Gefahr, dass alle 8 Ausgänge eines Register mit Strom belastet sind. Bei 20mA pro Spalte, wären es 20mA*8 =160mA die durch das Register fließen. Im Datenblatt ist ein Maximum von 70mA angegeben, weshalb das SR kaputt gehen würde.

LED Transistorschaltung

Im Detail funktioniert die Transistorschaltung so:

♦ Q4 High Pegel (Basisstrom an T4)
⇒ Spannung an LED2.
♦ Q3 High Pegel (Basisstrom an T3)
⇒ LED2 leuchtet blau.

Angenommen:
 Q4 Hig♦h Pegel, Q5 High Pegel
⇒ Spannung an LED1 und LED2.
♦ Q2 High Pegel
⇒ LED1 und LED2 leuchten Grün
♦ Q1 High Pegel
⇒LED1 und LED2 leuchten Gelb!!!

LED 1 soll aber grün und LED 2 rot leuchten!
Ja das geht trotzdem... und zwar:

Aus diesem Grund wird immer nur eine Zeile kurz eingeschaltet. Damit jede Zeile leuchten kann wird "Multiplexing" angewendet. Dabei werden die Zeilen werden nacheinander in einem schnellen Takt, ein und aus geschaltet. Da der Umschaltvorgang so schnell ist nimmt das menschliche Auge die Off- Zeit der LED nicht wahr. Parallel zu jedem Zeilensprung schalten die Spaltentransistoren den Strom durch nach Farbwunsch durch und er fließt auf Masse ab. So ist es möglich jede Farbe einzustellen.

Der Nachteil daran ist, dass die LEDs nur noch 1/8 der Zeit leuchten und dadurch die Helligkeit sinkt. Es ist möglich den Helligkeitsunterschied auszugleichen, indem man die Vorwiderstände(rot: 150 Ohm, grün: 140 Ohm, blau: 52 Ohm) niedriger wählt, jedoch steigt dadurch der kurzzeitige Spitzenstrom der LEDs. Da ich über meine LEDs keine Angabe über den maximalen Spitzenstrom im Datenblatt gefunden habe, sind die Widerstandswerte so gewählt, dass die LEDs nicht kaputt gehen.

 

auteilberechnungen LED Matrix 8x12

 

Vorwiderstände der LEDs:

Flussspannungen der LEDS:

V;rot=1,8V;Imax=20mA
Vgrün=2V;Imax=20mA
Vblau=3,1V;Imax=20mA

Igewählt=12,5mA

Die Widerstände können auch mit einem Strom von 20mA berechnet werden.

Im Schaltkreis der LEDs sind neben den Vorwiderständen 2 Transistoren, an denen Spannung abfällt.
An der Basis-Emitterstrecke des Transistors(BD139) fallen ca.VTBE=0,65Vab.


RFarbe=V-VT1- V T2 - V Farbe I LED

R Rot = 5V - 0,65V - 0,65V - 1,8V 12,5mA=152Ω≈150Ω
R Grün = 5V - 0,65V - 0,65V - 2V 12,5mA=136Ω≈140Ω
R Blau = 5V - 0,65V - 0,65V - 3,1V 12,5mA=48Ω≈52Ω

Basisstromberechnung Transistoren


Maximaler Strom durch eine Zeile:

I max = 3 * 12,5mA / LED * 12 LED = 450mA
Transistor Verstärkungsfaktor: h fe = 250
Basisstrom Zeilentransistoren: I B = V Q / R br = 5V/1kΩ=5mA
Kollektorstrom Zeilentransistoren: I C = I B * h fe =5mA*250=
1,25A>Imax


Maximaler Strom durch eine Spalte:

I max = 12,5mA

Transistor Verstärkungsfaktor: h fe = 250
Basisstrom Spaltentransistor: I B = V Q /Rbc=5V/47kΩ=;0,106mA
Kollektorstrom Spaltentransistoren: I C = I B*hfe&=0,106*250=
26mA>Imax

 

Python Arduino Verbindung mit PySerial

 

Die Ansteuerungssoftware wird auf dem Eingabegerät(PC, Raspberry Pi...) gestartet. Über den Python Code wird der Arduino angesprochen. Dafür gibt es die umfangfreiche Python lib "pyserial", mit der eine USB Verbindung aufgebaut werden kann. Es können Daten gesendet und empfangen werden. Am Arduino wird eine serielle Verbindung erstellt, die auf die Daten von PySerial wartet und an die Schieberegister weiterführt.

Die Oberfläche (GUI) habe ich mit dem Python modul "pygame" erstellt, mit der du in Echtzeit ein Bild zusammenbauen kannst und auf die Tafel übertragen. Wie die Oberfläche genau funktioniert siehst du anhand dem folgendem Gif. Den Source Code bzw. die kompilierte Windows Version kannst du im Anhang dieses Posts downloaden. Damit sowohl die USB Kommunikation funktioniert, als auch die richtige Bitreihenfolge in die Schieberegister geschoben wird, müssen folgende Werte angepasst werden.

 

LED

 

Einstellungen der LED Control Software:

 

Die Software kann im Anhang gedownloadet werden!

Die folgenden Listenwerte müssen im Arduino eingestellt werden, da sie je nach Verkabelung unterschiedlich sind.

19
20
21
22
const int LEDS_R[] = {10,13,27,24,37,30,21,18,29,34,43,40}; //Kathode Rote LEDS
const int LEDS_G[] = {8,11,14,26,39,36,23,20,17,28,33,42};  //Kathode Grüne LEDS
const int LEDS_B[] = {9,12,15,25,38,31,22,19,16,35,32,41};  //Kathode Blaue LEDS
const int zeilen[] = {0,1,2,3,4,5,6,7}                      //Anode Alle LEDs

►Lade die Datei serial_arduino_python.rar im Anhang herunter und entpacke Sie. In der .rar Datei befindet sich der Arduino Code, den du anpassen musst.

►Öffne die Datei Led_Matrix_Control.ino. Falls du noch noch nicht die Arduino IDE hast, lade Sie auf der Herstellerseite herunter.

►Ändere die Schieberegisterausgänge in die Listen LEDS_R, LEDS_G, LEDS_B auf deine Schieberegisterausgänge ab. Die Listenwerte für die Spalten entsprechen der LED Anordnung von Links nach Rechts. Die Listenwerte für die Spalten entsprechen der Anordnung von oben nach unten.

Ausgangsnummerierung Schieberegister

►Kompiliere die Datei und lade Sie auf den Arduino.

 

Einstellungen der LED Control Software. Zum Download im Anhang!

 

Über die "config.txt" kann auf die Software zugegriffen werden. Mögliche Einstellungen sind dort auskommentiert. Um die Anwendung zu benutzen müssen 2 Grundeinstellungen getätigt werden. Zum einem muss der USB Port angegeben werden, indem der Arduino angeschlossen ist und zum anderen der Ordnerpfad, in denen die erstellten Animationen gespeichert sind.

►Lade die LED_Matrix_Control.rar runter und entpacke die Ordner.

►Wechsle in den Ordner "LED_Matrix".

►Öffne die Datei config.txt.

►Ändere den COM_PORT Variablenwert in die Nummer des USB Ausgangs, indem der Arduino mit dem PC verbunden ist.

►Schreibe in die Variable "pathname" die vollständige Pfadbezeichnung zu dem Ordner "animationen". Achte auf das Backslash (\) hinter dem Wort animationen!

►Weitere Einstellmöglichkeiten sind in der Datei config.txt beschrieben.

►Wichtig ist es dabei, Groß und Kleinschreibung zu beachten und die Pfadstruktur der Variable "pathname" einzuhalten.

 

LED Animationssoftware benutzen

Im Anhang des Posts findest du die LED Matrix Control Software.
Die Software kann unter Windows über die LED_Matrix_Control.exe gestartet werden. Für den Python Interpreter der SourceCode verfügbar. Um das Programm darin zu starten werden neben den Standardbibliotheken das PySerial und PyGame Modul benötigt.

 

Der Code für die LED Steuerung ist als .exe Datei im Anhang als rar Datei gepackt. Du benötigst kein Python Compiler!
 
 

 

 

Sobald die USB Verbindung aufgebaut ist (dauert ca. 5 Sekunden) kannst du Animationen abspielen, die Umschaltzeit zwischen Bildern ändern oder neue Animationen erstellen. Dabei auf "Neue Animation" klicken und eine Farbe auswählen. Mit gedrückter linker Maustaste kann ein Muster erstellt werden.
Um ein Bild zu speichern auf den Button " Bild Speichern" drücken. Das Bild wird daraufhin als "neue_animation.txt" im Ordner "animationen" gespeichert.
Wenn die Animation fertig ist auf den Button "Speichern" drücken und die Datei "neue_animation.txt", wird in "animation0.txt" umbenannt.
Über den Button "Animationsauswahl" wird die Animation ausgewählt und durch den Button "Start Animation" auf die Tafel übertragen.
Falls du der Animation einen Namen geben willst, kannst du den Dateinamen umbenennen.

 

Bauteillliste

Bauteil Beschreibung Link
100x 2.54mm RGB LEDs Common Cathode RGB LEDs amazon* affiliate
Bestellen
Netzteil 5V 5V, 1A, 5W Netzteil amazon* affiliate
Bestellen
44x BD139 Transistoren BD139 NPN Bipolar Transistor amazon* affilliate
Bestellen
SN74HC595N 8 Bit Schieberegister amazon* affiliate
Bestellen
Arduino Nano Entwicklerboard mit CH340 Chip Atmega328P amazon* affiliate
Bestellen
Elektrobauteile 12x 52 Ohm, 12x 140 Ohm, 12x 150 Ohm, 44 x 1k Ohm  
Elektroaurüstung Kabel, Stecker, Lochrasterplatine