Dot Matrix Spalten/Zeilen tauschen

[Stefan S. (sschultewolter)]

Hallo,

ich habe mir eine Libary für die Ansteuerung der Max7219 in Verbindung 
mit einem Atmega328p geschrieben.

Nun habe ich keine Möglichkeit, die Dot Matrizen in der typischen 
Orientierung später aufzubauen. Soll heißen, jede Matrize wird um 90° 
gedreht.

Im Anhang einmal die Platine, um zu sehen was ich meine. Die Matrizen 
sollen später in der waagerechten kaskadiert werden.

void max7219_puts(char *s, uint8_t bold, uint8_t invert, uint8_t scroll)
{
  uint8_t size_text = strlen(s);

  uint8_t width = 0;

  if(bold) width = 8;
  else width = 5;

  uint16_t i = 0;
  static uint16_t j = 0;
  while(i < (MAX7219_NUM_IC * 8))
  {
    uint8_t x = s[((i + j) / width) % size_text];
    uint8_t y = ((i + j) % width);
    uint8_t data = 0;
    if(bold) data = pgm_read_byte(&font_bold[x][y]);
    else data = pgm_read_byte(&font[x][y]);
    if(invert)max7219_send(i >> 3, ((i % 8) + 1), 255 - data);
    else max7219_send(i >> 3, ((i % 8) + 1), data);
    i++;
  }
  if(scroll)  if(++j > (size_text * width)-1) j = 0;
}

Wenn die Schrift angepasst werden muss, wäre das kein Problem. Habe 
diese in allen Variationen.

[Easylife (Gast)]

Du glaubst nicht allen ernstes, dass jemand versuchen wird das Programm 
zu analysieren, und Datenblätter zu wälzen, um rauszufinden, wie die 
Schaltung zu dem PCB wohl aussehen könnte, um dann zu erraten, was dein 
Problem sein könnte?

[Stefan S. (sschultewolter)]

Es gibt sicherlich Leute, die sich mit dem typischen Matrix(7-Segment) 
Baustein schon auseinander gesetzt haben.

Das Problem ist, das man hier nicht einfach die Spalten mit den Zeilen 
tauschen kann.

Die Spalten sind festgelegt vom Baustein und werden einzeln 
angesprochen. Jedoch muss mit jeder ausgewählten Spalte die komplette 
Zeile(8bit) mitgeschickt werden.

Ich habe irgendwo, meine sogar hier, einen Ansatz gefunden, eine 
Umrechnung zu machen damit Spalten wie Zeilen und Zeilen wie Spalten 
genutzt werden können.

Die PCB habe ich nur zur Veranschaulichung mitgeliefert, dass die Matrix 
nicht in der orginalen Orientierung sich befindet.

[Hartmut (Gast)]

Stefan S. schrieb:
> Dot Matrizen

Stefan S. schrieb:
> Matrix(7-Segment)

Was denn nun? Brust oder Keule?

[Stefan S. (sschultewolter)]

Edit, da Hartmut sich gemeldet hat.
Ich meine schon Dot Matrizen(8x8). Das mit 7-Segment war nur darauf 
bezogen, da sich das Datenblatt hauptsächlich nur um diese 
Segment-Anzeigen kümmert.



Also das Layoutformat muss beigehalten werden mit den Pinanordnungen. 
Die Leiterbahnen könnten neugeroutet werden.

Sehe ich das richtig, das wenn ich anstatt der Common Cathode nun Common 
Annode nehme, dass es die gewünschte Ausrichtung hat?

Derzeit sind die Spalten (COL) an die SEG_ benannten Pins des MAX 
angeschlossen. Bei der draufsicht ergibt das aber, dass sich diese als 
Reihen darstellen. Die DIG_ Pins sind die Reihen (ROW) des Displays, die 
als Spalten dargestellt werden.
Somit alles um 90° verdreht.

Nun meine Idee mit den Common Anode. Hierbei werden die SEG_ benannten 
Pins des MAX mit den Reihen verbunden. Die DIG_ benannten Pins des MAX 
mit den Spalten.
Somit wären die Spalten und Reihen rein technisch verdreht. Jedoch mit 
der Drehung von 90° würden diese wieder passen.

Dem Programm würde es in dem Moment nicht einmal interessieren, dass 
diese vertauscht wurden. Denn ich schalte mit MAX immer noch die 
Cathoden.

Links CA, Rechts CC
http://img.weiku.com/a/000/439/8x8_led_dot_matrix_with_brightness_4529_2.jpg

[Oliver R. (orb)]

Stefan S. schrieb:
> Links CA, Rechts CC
> http://img.weiku.com/a/000/439/8x8_led_dot_matrix_with_brightness_4529_2.jpg

Nö, die Bezeichnung CC und CA ist hier (bei einfarbigen) unsinnig, bei 
den Matrixanzeigen hast Du immer gleichviele gemeinsame Anoden wie 
Kathoden.
Das hatten wir doch grad erst in einem anderen Thread.
Im Datenblatt vom MAX steht, welche Anschlüsse mehr Strom liefern und 
welche mehr abführen können, das solltest Du beachten.

[Stefan S. (sschultewolter)]

Hallo Oliver,

das ist mir bewusst, dass es hier der eigentliche Begriff CA/CC falsch 
ist.
Darum geht es mir auch nicht.

Ich habe die 16 Pins (2x8) waagerecht auf dem Breadboard angeordnert.

Soll heißen
M1.16 => Matrix 1, physikalischer Pin 16.


obere Reihe auf dem Breadboard
M1.16 - M1.09, M2.16 - M2.09, ...

untere Reihe auf dem Breadboard
M1.01 - M1.08, M2.01 - M2.08, ...

Da ich diese sehr platzsparend 1dimensional kaskadieren möchte (PCB nur 
unter der Matrixenfläche selber, ist die einfachste und passenste 
Möglichkeit, die Matrizen hochkant zu stellen. (siehe PCB oben).

Edit:
Der Kontrolle halber,

Die Segmente(Spalten/Col/Anode) könne mit bis zu 320mA (Source) 
angetrieben werden. Digits können mit ~40mA (Sink/Row/Cathode) gegen 
Masse geschaltet werden. Soweit denke ich ist das richtig, und von daher 
würde ich jetzt sagen, dass ich bei den "CA" Modulen die Möglichkeit 
habe, Spalten und Reihen zu vertauschen. So dass die Matrizen auf der 
Seite liegen können. Testen kann ich es gerade nicht, da ich nur die 
anderen Module hier hab.

[Peter D. (peda)]

Ich würde das Programm aufteilen:
1. Ausgabe des Bildspeichers an die MAX7219.
Dieser Routine ist es wurscht, wie die Anordnung ist.

2. Schreiben des Pixelmusters eines Zeichens in den Bildspeicher.
Diese Routine muß die Pixel entsprechend der Anordnung setzten.
Man sollte dann auch den Zeichensatz so definieren, daß er dafür optimal 
ist.

Quasi, wie es jede Grafikkarte macht.
Dazu muß man einen Bildspeicher über die komplette Matrix (Bildschirm) 
anlegen.

[Stefan S. (sschultewolter)]

Peter Dannegger schrieb:
> Ich würde das Programm aufteilen:
> 1. Ausgabe des Bildspeichers an die MAX7219.
> Dieser Routine ist es wurscht, wie die Anordnung ist.
>
> 2. Schreiben des Pixelmusters eines Zeichens in den Bildspeicher.
> Diese Routine muß die Pixel entsprechend der Anordnung setzten.
> Man sollte dann auch den Zeichensatz so definieren, daß er dafür optimal
> ist.
>
> Quasi, wie es jede Grafikkarte macht.
> Dazu muß man einen Bildspeicher über die komplette Matrix (Bildschirm)
> anlegen.

Hallo Peter, danke für die Antwort. So könnte ich es mal angehen. Der 
Zeichensatz ist kein Problem.
Der liegt als 8x5 und 8x8 in allen Ausrichtungen vor

[Stefan S. (sschultewolter)]

So, habe mich mal an Peters Vorschlag gehalten. Habe noch nicht so viel 
Zeit gehabt. Aber einen ersten Test gestartet. So geht es eigentlich 
ganz gut. Alles nur als Test angelegt. Werde das ganze später noch 
einkürzen, da je Pixel ein Byte doch etwas zu viel des guten ist.

uint8_t max7219_buffer[8][MAX7219_NUM_IC*8]  =
{
  {1, 1, 1, 0, 0, 0, 0, 1, /**/ 1, 1, 1, 1, 1, 1, 1, 1, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 0, 0, 0, 0, 1, 0, /**/ 0, 0, 0, 0, 0, 0, 1, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 0, 0, 0, 1, 0, 0, /**/ 0, 0, 0, 0, 0, 1, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {0, 0, 0, 0, 1, 0, 0, 0, /**/ 0, 0, 0, 0, 1, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 0, 1, 0, 0, 0, 0, /**/ 0, 0, 0, 1, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 1, 0, 0, 0, 0, 0, /**/ 0, 0, 1, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 1, 0, 0, 0, 0, 0, 0, /**/ 0, 1, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
  {1, 0, 0, 0, 0, 0, 0, 0, /**/ 1, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0, /**/ 0, 0, 0, 0, 0, 0, 0, 0},
};

void max7219_out()
{
  for(int i = 0; i < 8; i++)
  {
    uint8_t val = 0;
    for(int j = 0; j < 8; j++)
    {
      val += max7219_buffer[i][j] << (7 - j);
    }
    max7219_send(0, i+1, val);
    val = 0;
  }
}

[Stefan S. (sschultewolter)]

Hallo,

habe mich mit dem Problem nun ein paar Tage auseinandergesetzt. Soweit 
funktioniert das alles ganz gut. Was mich aber wundert ist die 
Ausführungszeit. Es wird laut dem Logik Level Analyser 6ms gebraucht, 
den Puffer zu beschreiben und abzusenden.
Habe dazu einen Pin überwacht der am Anfang sowie am Ende gesetzt/nicht 
gesetzt wird.

Wo kann ich jetzt noch ansetzen um es weiter zu optimieren.

  while(1)
  {
    static int start = -1;
    static uint32_t last_output_millis;
    if(millis() - last_output_millis >= 50)
    {
      last_output_millis = millis();
      
      max7219_puts_scroll("abcdefg_", &start);
    }
  }

void max7219_puts_scroll(char *s, int8_t *run)
{
MAX7219_PORT |= (1 << MAX7219_DEBUG);  // DEBUG

  int16_t size_str = max7219_width_string(s);
  static int16_t offset = MAX7219_MAX_COL;
  int16_t x = offset;
  
  if(*run == 0) return;
  // Ausfuehren, solange noch mindesten 1 Durchlauf ansteht,
  // oder -1 fuer unendlich Durchlaeufe
  else if(*run < 0 || *run > 0)
  {
    for(uint8_t c = 0; c < strlen(s); c++)
    {
      // Spalten des Zeichens ermitteln (0 - 8 Spalten)
      uint8_t size_char = pgm_read_byte(&font_bold[s[c]][0]);
      
      for(uint8_t i = 0; i < size_char; i++)
      {
        max7219_buffer_write(i+x, pgm_read_byte(&font_bold[s[c]][i+1]));
      }
      
      // Leere Spalte nach jedem Zeichen schreiben
      max7219_buffer_write(x+size_char, 0x00);
      
      x += size_char+1;
    }
    
    // Speicher an MAX7219 senden
    max7219_buffer_send();
    
    // Wenn Ende erreicht, von vorne anfangen
    if(--offset < 0 - size_str ) { offset = MAX7219_MAX_COL; *run -= 1; }
  }
  MAX7219_PORT &= ~(1 << MAX7219_DEBUG);  // DEBUG ENDE
}