Daten speichern + 16x16 RGB-LED-Matrix ansteuern

Ok, dann war meine Rechnung richtig.
Kann das ganze trotzdem ein Problem der Spannung/Stromstärke sein?

Wenn ich mich nicht irre benutzt Du den ULN2981, der hat ein Turn-Off Delay von 5µs und ein Turn-On Delay von 1µs.

Ich weis jetzt nicht in welchem µs Abstand die Zeilen durch die TLCMux Library weitergeschaltet werden, aber theoretisch könnte es sein das für kurze Zeit 2 benachbarte Zeilen Strom ziehen.

Kann natürlich auch ein Irrtum meinerseits sein !

Fast, ich benutze UDNs.
Uwe hat doch auch ein 16x8 und bei dem hats doch mein ich auch funktioniert.
Könnte man die Frequenz zum Shiften irgendwie umstellen?

Wieviel Ampere kann dein Netzteil den liefern ?

Momentan zu wenig, aber ich werde mal nach einem 1A für die 16x8 Matrix suchen.

Habe das Flackern für die 16x8 beseitigen können, jedenfalls das bei rot.
Ich werde versuchen die komplette 16x8 weiß zu färben, wenn ich das passende Netzteil habe.
Anschließend werde ich versuchen, die 16x16 zum leuchten zu bringen.
Ich melde mich sobald ich mehr oder weniger Erfolg habe, könnte allerdings ein paar Wochen dauern, da ich momentan sehr beschäftigt bin.

Tu Dir was gutes und kauf dir eins mit 2A, dann hast Du in deiner Schaltung noch Erweiterungspotential.

Wie hast Du das Flackern bei Rot entfernt ?

Ja, ich werde eins mit 2A nehmen. Wir haben noch ganz viele zu hause. Muss nur später gucken, ob ein passendes dabei ist.

Zu dem Flackern, sorry, hab vergessen das zu erwähnen. Ich habe die eine Matrix an den einen, die andere an den anderen Schieberegister+UDN drangeschlossen, vorher beide "Anoden-Blöcke" an zwei, parallel vom SR angesteuerte, UDNs.

Genau durch diesen AHA-Effekt lernt man dazu !

Ist das denn überhaupt logisch?
Ich meine ob das so muss, wie ich das jetzt angeschlossen habe,
und es vorher falsch war?

Vielleicht hat die Power eines 74HC595 Ausganges nicht dazu ausgereicht um 2 UDN2981 Eingänge gleichzeitig sauber zu schalten ?!?

Hmmm... wenn man an den + und - der ext. Schaltung ein 2,5A 5V Netzteil klemmt, dann wird der TLC für die rote Farbe ganz warm (rot wird gerade angesteuert) und das Bild wird nicht korrekt dargestellt.

http://tlc5940arduino.googlecode.com/svn/wiki/images/breadboard-arduino-tlc5940.png

Stimmen die Widerstandswerte bei deinen TLC's ?

Hi,

ich habe jetzt einige Seite gelesen aber noch keine genauere Spezifikation zu der Speicherung gefunden.
Wie ist das denn geplant? Die Bytecodes für die Farben, in der Reihenfolge der LEDs in einer Text-Datei ablegen?
Oder in einer Art "Sprache" um z.B. die Datei noch kompakter zu bekommen (SetPixel, SetRange, SetAll, SetLine, usw.).

Da ich gerade eine Desktopanwendung schreiben, mit der man am PC eine Matrix darstellen und testen kann, würde ich gerne nun eine Steuerung implementieren.
Optimaler Weise so, dass man diese unabhängig der genutzten Bauteile verwenden kann.

Schön wäre zum Einen eine Steuerung per Serieller Schnittstelle und zum Anderen die Erstellung einer Datei, die dann sequentiell abgearbeitet wird.

Vielleicht können wir da ja zusammen einen "Standard" für uns definieren :slight_smile:

Gruß,
trib

Die Widerstände betragen je 1,99kOhm.
Sollte doch passen, oder?

Ich habe bis jetzt ein Programm geschrieben, dass Bitmaps im Format r[1][1],g[1][1],b[1][1],r[2][1],g[2][1],b[2][1], ... r[8][1],g[8][1],b[8][1],r[1][2],g[1][2],b[1][2], ...
auf eine SD schreibt (Text-Datei). Ein Arduino-Sketch kann dieses Format auslesen und das Bild darstellen (8x8-Matrix).
Ich habe versucht mehrere Bilder zu speichern und diese nacheinander auszulesen und darzustellen, allerdings kann ich beim Multiplexen nicht mehr auf die SD zugreifen, daher kann ich die Bilder nur bevor die TLC angesteuert werden in den RAM des Arduinos laden. Bezüglich dieses Problems habe ich mir einen zweiten Arduino gekauft, der das auslesen der Frames übernimmt und diese seriell an den 2ten Arduino schicken soll, der das ganze dann darstellt. So würde rein theoretisch eine live Auslesemethode funktionieren. Da kommen wir auch schon zu unserem gemeinsamen Problem, Trib, das serielle Übertragen der Daten. Ich habe es bereits geschafft, mit langsamer Geschwindigkeit die Matrix mit Farben zu füllen, komplette Bilder konnte ich jedoch noch nicht übertragen. Es wäre schön gemeinsam mit dir an einer Lösung zu arbeiten, die recht kompakt gehalten ist, sodass sie universell auch für andere einsetzbar ist.

Ob wir später eine "Sprache" entwickeln um das ganze noch "schneller" zu machen können wir ja entscheiden, wenn die Basics funktionieren.

In welcher Sprache schreibst du die Desktopanwendung?

PS: Ich werde weiterhin versuchen, die 16x8 Matrix zum Laufen zu bekommen und bin für Hilfe jederzeit dankbar.

Hier ein alter Thread von mir bezüglich der Kommunikation:
http://arduino.cc/forum/index.php/topic,126870.15.html

Mal ne Frage:
Kann ein Schieberegister überhaupt 2 UDNs parallel ansteuern, oder ist das zu "schwach" dafür?

Könnte es sein, dass 1 Arduino alleine einfach zu "schwach" ist, eine 16x16 RGB-LED-Matrix zu multiplexen?

Nathax:
Mal ne Frage:
Kann ein Schieberegister überhaupt 2 UDNs parallel ansteuern, oder ist das zu "schwach" dafür?

Nein, müßte funktionieren.

Nathax:
Könnte es sein, dass 1 Arduino alleine einfach zu "schwach" ist, eine 16x16 RGB-LED-Matrix zu multiplexen?

Ja, könnte sein. Hängt aber viel vom Sketch und der Programmlogik ab.
Grüße Uwe

Hier nochmal mein Sketch:

#define  NUM_TLCS  3 // Hier Anzahl der verwendeten TLC5940 hinschreiben
#define  NUM_ROWS  16 // Anzahl der ROWS der Matrix
#define  NUM_COLUMNS 8 // An zahl der Columns der Matrix
#include "Tlc5940Mux.h"
//#define __AVR_ATmega2560__

volatile uint8_t isShifting;
uint8_t shiftRow;
                     
// SHIFT_DATA_PIN (PF0 is analog 0) = '595 SER pin
#define SHIFT_DATA_PORT PORTF
#define SHIFT_DATA_PIN  PF0
#define SHIFT_DATA_DDR  DDRF
// SHIFT_CLK_PIN (PF1 is analog 1) = '595 SRCLK
#define SHIFT_CLK_PORT  PORTF
#define SHIFT_CLK_PIN   PF1
#define SHIFT_CLK_DDR   DDRF
// '595 RCLK is hooked to tlc XLAT pin

uint16_t Led_Red;
uint16_t Led_Green;
uint16_t Led_Blue;

static inline void
shift8_595_row(uint8_t row)
{
  // the output of the '595 for the selected row should be low, all others
  // high
  //uint8_t output = ~(1 << row);
  uint8_t output = (1 << row); // Eventuell beides mal probieren
  for (uint8_t bit = 0x80; bit; bit >>= 1) {
    if (bit & output) {
      SHIFT_DATA_PORT |= _BV(SHIFT_DATA_PIN);
    } else {
      SHIFT_DATA_PORT &= ~_BV(SHIFT_DATA_PIN);
    }    
    // pulse the '595 sclk
    SHIFT_CLK_PORT |= _BV(SHIFT_CLK_PIN);
    SHIFT_CLK_PORT &= ~_BV(SHIFT_CLK_PIN);
  }
}

ISR(TIMER1_OVF_vect)
{
  if (!isShifting) {
    disable_XLAT_pulses();
    isShifting = 1;
    sei();
    TlcMux_shiftRow(shiftRow);
    shift8_595_row(shiftRow);
    shiftRow++;
    if (shiftRow == NUM_ROWS) {
      shiftRow = 0;
    }
    enable_XLAT_pulses();
    isShifting = 0;
  }
}


const int MatrixWidth = NUM_ROWS;
const int MatrixHeight = NUM_COLUMNS;

int PixelColor[MatrixWidth+1][MatrixHeight+1][4];


void setup()
{
  SHIFT_DATA_DDR |= _BV(SHIFT_DATA_PIN);
  SHIFT_CLK_DDR  |= _BV(SHIFT_CLK_PIN);
  TlcMux_init();
}



void loop()
{
  for(int i = 1; i <= MatrixWidth; i++)
  {
    for(int j = 1; j <= MatrixHeight; j++)
    {
      PixelColor[i][j][1] = 255;
      PixelColor[i][j][2] = 0;
      PixelColor[i][j][3] = 0; 
    }
  }
  Render();
  delay(10);
}



void Render()
{
  Display();
}



void Display()
{
  for(int i = 1; i <= MatrixWidth; i++)
  {
    for(int j = 1; j <= MatrixHeight; j++)
    {
      Matrix_Pixel(i, j, PixelColor[i][j][1], PixelColor[i][j][2], PixelColor[i][j][3]);
    }
  }  
}



void Clear()
{
  for(int i = 1; i <= MatrixWidth; i++)
  {
    for(int j = 1; j <= MatrixHeight; j++)
    {
      PixelColor[i][j][1] = 0;
      PixelColor[i][j][2] = 0;
      PixelColor[i][j][3] = 0; 
    }
  }    
}



void Matrix_Pixel(uint8_t Row, uint8_t Column, byte Red, byte Green, byte Blue)
{   
   Row -= 1;
   Column -= 1;
   Led_Red = map(Red, 0, 255, 0, 4095);
   Led_Green = map(Green, 0, 255, 0, 4095);
   Led_Blue = map(Blue, 0, 255, 0, 4095);
   
   if(Row < 8)
   {
     TlcMux_set(Row, Column, Led_Red / 1.8);
     TlcMux_set(Row, Column+16, Led_Green);
     TlcMux_set(Row, Column+32, Led_Blue);
   }
   else
   {
     TlcMux_set(Row-7, Column+8, Led_Red / 1.8);
     TlcMux_set(Row-7, Column+16+8, Led_Green);
     TlcMux_set(Row-7, Column+32+8, Led_Blue);
   }
}

Was meint ihr: Ich hab ja den Mega2560 2x. Soll ich je 16x8 bzw. 8x16 mit einem Mega verbinden, sprich zwei Arduinos benutzen, von denen jeder die halbe Matrix ansteuert?
Dann müsste ich allerdings die Platinen umlöten und die Arduinos auch noch synchronisieren. Oder hat jemand ne andere Idee,
warum bei einer bestimmten Anzahl von LEDs manche Pixel verrückt spielen?