Probleme mit MaxMatrix Modul 8*8

Hallo liebe Leute!

Ich habe mir über Amazon 10 Stück von diesen MaxMatrix Modulen (Max7219) bestellt. Die Dinger schauen in Ordnung aus und auch die Kabel sind dabei.
Gestern packte ich meinen Uno aus, schloss das Modul folgender Massen an:

VCC → 5V
GND → GND
DIN → Pin8
CLS → Pin9
CLK → Pin10

folgende Code spielte ich auf den Arduino:

#include <MaxMatrix.h>
#include <avr/pgmspace.h>
const byte maxInUse = 1;        // Anzahl der MAX7219-Anzeigen (8x8-Matrix)
const byte DIN = 8;   // verbunden mit DIN
const byte CS  = 9;   // verbunden mit CS,
const byte CLK = 10;  // verbunden mit CLK
MaxMatrix m(DIN, CS, CLK, maxInUse);

const unsigned char CH[] PROGMEM = {
  3, B00000000, B00000000, B00000000, B00000000, B00000000, // space
  1, B01011111, B00000000, B00000000, B00000000, B00000000, // |
  3, B00000011, B00000000, B00000011, B00000000, B00000000, // "
  5, B00010100, B00111110, B00010100, B00111110, B00010100, // #
  4, B00100100, B01101010, B00101011, B00010010, B00000000, // $
  5, B01100011, B00010011, B00001000, B01100100, B01100011, // %
  5, B00110110, B01001001, B01010110, B00100000, B01010000, // &
  1, B00000011, B00000000, B00000000, B00000000, B00000000, // '
  3, B00011100, B00100010, B01000001, B00000000, B00000000, // (
  3, B01000001, B00100010, B00011100, B00000000, B00000000, // )
  5, B00101000, B00011000, B00001110, B00011000, B00101000, // *
  5, B00001000, B00001000, B00111110, B00001000, B00001000, // +
  2, B10110000, B01110000, B00000000, B00000000, B00000000, // ,
  4, B00001000, B00001000, B00001000, B00001000, B00000000, // -
  2, B01100000, B01100000, B00000000, B00000000, B00000000, // .
  4, B01100000, B00011000, B00000110, B00000001, B00000000, // /
  4, B00111110, B01000001, B01000001, B00111110, B00000000, // 0
  3, B01000010, B01111111, B01000000, B00000000, B00000000, // 1
  4, B01100010, B01010001, B01001001, B01000110, B00000000, // 2
  4, B00100010, B01000001, B01001001, B00110110, B00000000, // 3
  4, B00011000, B00010100, B00010010, B01111111, B00000000, // 4
  4, B00100111, B01000101, B01000101, B00111001, B00000000, // 5
  4, B00111110, B01001001, B01001001, B00110000, B00000000, // 6
  4, B01100001, B00010001, B00001001, B00000111, B00000000, // 7
  4, B00110110, B01001001, B01001001, B00110110, B00000000, // 8
  4, B00000110, B01001001, B01001001, B00111110, B00000000, // 9
  2, B01010000, B00000000, B00000000, B00000000, B00000000, // :
  2, B10000000, B01010000, B00000000, B00000000, B00000000, // ;
  3, B00010000, B00101000, B01000100, B00000000, B00000000, // <
  3, B00010100, B00010100, B00010100, B00000000, B00000000, // =
  3, B01000100, B00101000, B00010000, B00000000, B00000000, // >
  4, B00000010, B01011001, B00001001, B00000110, B00000000, // ?
  5, B00111110, B01001001, B01010101, B01011101, B00001110, // @
  4, B01111110, B00010001, B00010001, B01111110, B00000000, // A
  4, B01111111, B01001001, B01001001, B00110110, B00000000, // B
  4, B00111110, B01000001, B01000001, B00100010, B00000000, // C
  4, B01111111, B01000001, B01000001, B00111110, B00000000, // D
  4, B01111111, B01001001, B01001001, B01000001, B00000000, // E
  4, B01111111, B00001001, B00001001, B00000001, B00000000, // F
  4, B00111110, B01000001, B01001001, B01111010, B00000000, // G
  4, B01111111, B00001000, B00001000, B01111111, B00000000, // H
  3, B01000001, B01111111, B01000001, B00000000, B00000000, // I
  4, B00110000, B01000000, B01000001, B00111111, B00000000, // J
  4, B01111111, B00001000, B00010100, B01100011, B00000000, // K
  4, B01111111, B01000000, B01000000, B01000000, B00000000, // L
  5, B01111111, B00000010, B00001100, B00000010, B01111111, // M
  5, B01111111, B00000100, B00001000, B00010000, B01111111, // N
  4, B00111110, B01000001, B01000001, B00111110, B00000000, // O
  4, B01111111, B00001001, B00001001, B00000110, B00000000, // P
  4, B00111110, B01000001, B01000001, B10111110, B00000000, // Q
  4, B01111111, B00001001, B00001001, B01110110, B00000000, // R
  4, B01000110, B01001001, B01001001, B00110010, B00000000, // S
  5, B00000001, B00000001, B01111111, B00000001, B00000001, // T
  4, B00111111, B01000000, B01000000, B00111111, B00000000, // U
  5, B00001111, B00110000, B01000000, B00110000, B00001111, // V
  5, B00111111, B01000000, B00111000, B01000000, B00111111, // W
  5, B01100011, B00010100, B00001000, B00010100, B01100011, // X
  5, B00000111, B00001000, B01110000, B00001000, B00000111, // Y
  4, B01100001, B01010001, B01001001, B01000111, B00000000, // Z
  2, B01111111, B01000001, B00000000, B00000000, B00000000, // [
  4, B00000001, B00000110, B00011000, B01100000, B00000000, // backslash
  2, B01000001, B01111111, B00000000, B00000000, B00000000, // ]
  3, B00000010, B00000001, B00000010, B00000000, B00000000, // ^
  4, B01000000, B01000000, B01000000, B01000000, B00000000, // _
  2, B00000001, B00000010, B00000000, B00000000, B00000000, // `
  4, B00100000, B01010100, B01010100, B01111000, B00000000, // a
  4, B01111111, B01000100, B01000100, B00111000, B00000000, // b
  4, B00111000, B01000100, B01000100, B00101000, B00000000, // c
  4, B00111000, B01000100, B01000100, B01111111, B00000000, // d
  4, B00111000, B01010100, B01010100, B00011000, B00000000, // e
  3, B00000100, B01111110, B00000101, B00000000, B00000000, // f
  4, B10011000, B10100100, B10100100, B01111000, B00000000, // g
  4, B01111111, B00000100, B00000100, B01111000, B00000000, // h
  3, B01000100, B01111101, B01000000, B00000000, B00000000, // i
  4, B01000000, B10000000, B10000100, B01111101, B00000000, // j
  4, B01111111, B00010000, B00101000, B01000100, B00000000, // k
  3, B01000001, B01111111, B01000000, B00000000, B00000000, // l
  5, B01111100, B00000100, B01111100, B00000100, B01111000, // m
  4, B01111100, B00000100, B00000100, B01111000, B00000000, // n
  4, B00111000, B01000100, B01000100, B00111000, B00000000, // o
  4, B11111100, B00100100, B00100100, B00011000, B00000000, // p
  4, B00011000, B00100100, B00100100, B11111100, B00000000, // q
  4, B01111100, B00001000, B00000100, B00000100, B00000000, // r
  4, B01001000, B01010100, B01010100, B00100100, B00000000, // s
  3, B00000100, B00111111, B01000100, B00000000, B00000000, // t
  4, B00111100, B01000000, B01000000, B01111100, B00000000, // u
  5, B00011100, B00100000, B01000000, B00100000, B00011100, // v
  5, B00111100, B01000000, B00111100, B01000000, B00111100, // w
  5, B01000100, B00101000, B00010000, B00101000, B01000100, // x
  4, B10011100, B10100000, B10100000, B01111100, B00000000, // y
  3, B01100100, B01010100, B01001100, B00000000, B00000000, // z
  3, B00001000, B00110110, B01000001, B00000000, B00000000, // {
  1, B01111111, B00000000, B00000000, B00000000, B00000000, // |
  3, B01000001, B00110110, B00001000, B00000000, B00000000, // }
  4, B00001000, B00000100, B00001000, B00000100, B00000000, // ~
};

byte sprite[] = {0, 0, 0, 0, 0, 0, 0};
byte helligkeit = 5;    // Helligkeit der Matrix 0 - 15, dunkel - hell
byte anzeigePuffer[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9'};
void setup() {
  Serial.begin(9600);
  m.init();
  m.setIntensity(helligkeit);
  Serial.print("Clear wird aufgerufen");
  m.clear();
  Serial.print("Clear ist beendet");
}

void loop() {
/*  byte t = displayChar(anzeigePuffer[7], 2);
  delay(2000);
  t = displayChar(anzeigePuffer[5], 2);
  delay(2000);*/
}

byte displayChar(byte zeichen, byte x) {
  memcpy_P(sprite + 1, CH + (zeichen - 32) * 6, 6);
  sprite[0] = sprite[1];
  sprite[1] = 8;
  m.writeSprite(x, 0, sprite);
  return sprite[0];
}

Aber egal welches dieser Module ich ausprobierte, es tat sich nichts, das Muster war immer das selbe:



**



**



:o :o :o :o

Hat jemand eine Idee?

Danke, Claus

Was macht denn die MaxMatrix Bibliothek?
Gibt's Beispielcode dazu?

Claus_M:
Hat jemand eine Idee?

Du verwendest offenbar eine Drittanbieter-Library:
#include <MaxMatrix.h>

Üblicherweise kommen solche Libraries mit mindestens einem Beispielprogramm.

Teste das Beispielprogramm zur Library!

Hi, keine Beispiele in der Library vorhanden, aber selbst wenn ich mit der LEDControl Library arbeite, das selbe:

/*
 Now we need a LedControl to work with.
 ***** These pin numbers will probably not work with your hardware *****
 pin 12 is connected to the DataIn 
 pin 11 is connected to the CLK 
 pin 10 is connected to LOAD 
 We have only a single MAX72XX.
 */
LedControl lc=LedControl(12,11,10,1);

/* we always wait a bit between updates of the display */
unsigned long delaytime=100;

void setup() {
  /*
   The MAX72XX is in power-saving mode on startup,
   we have to do a wakeup call
   */
  lc.shutdown(0,false);
  /* Set the brightness to a medium values */
  lc.setIntensity(0,8);
  /* and clear the display */
  lc.clearDisplay(0);
}

/*
 This method will display the characters for the
 word "Arduino" one after the other on the matrix. 
 (you need at least 5x7 leds to see the whole chars)
 */
void writeArduinoOnMatrix() {
  /* here is the data for the characters */
  byte a[5]={B01111110,B10001000,B10001000,B10001000,B01111110};
  byte r[5]={B00111110,B00010000,B00100000,B00100000,B00010000};
  byte d[5]={B00011100,B00100010,B00100010,B00010010,B11111110};
  byte u[5]={B00111100,B00000010,B00000010,B00000100,B00111110};
  byte i[5]={B00000000,B00100010,B10111110,B00000010,B00000000};
  byte n[5]={B00111110,B00010000,B00100000,B00100000,B00011110};
  byte o[5]={B00011100,B00100010,B00100010,B00100010,B00011100};

  /* now display them one by one with a small delay */
  lc.setRow(0,0,a[0]);
  lc.setRow(0,1,a[1]);
  lc.setRow(0,2,a[2]);
  lc.setRow(0,3,a[3]);
  lc.setRow(0,4,a[4]);
  delay(delaytime);
  lc.setRow(0,0,r[0]);
  lc.setRow(0,1,r[1]);
  lc.setRow(0,2,r[2]);
  lc.setRow(0,3,r[3]);
  lc.setRow(0,4,r[4]);
  delay(delaytime);
  lc.setRow(0,0,d[0]);
  lc.setRow(0,1,d[1]);
  lc.setRow(0,2,d[2]);
  lc.setRow(0,3,d[3]);
  lc.setRow(0,4,d[4]);
  delay(delaytime);
  lc.setRow(0,0,u[0]);
  lc.setRow(0,1,u[1]);
  lc.setRow(0,2,u[2]);
  lc.setRow(0,3,u[3]);
  lc.setRow(0,4,u[4]);
  delay(delaytime);
  lc.setRow(0,0,i[0]);
  lc.setRow(0,1,i[1]);
  lc.setRow(0,2,i[2]);
  lc.setRow(0,3,i[3]);
  lc.setRow(0,4,i[4]);
  delay(delaytime);
  lc.setRow(0,0,n[0]);
  lc.setRow(0,1,n[1]);
  lc.setRow(0,2,n[2]);
  lc.setRow(0,3,n[3]);
  lc.setRow(0,4,n[4]);
  delay(delaytime);
  lc.setRow(0,0,o[0]);
  lc.setRow(0,1,o[1]);
  lc.setRow(0,2,o[2]);
  lc.setRow(0,3,o[3]);
  lc.setRow(0,4,o[4]);
  delay(delaytime);
  lc.setRow(0,0,0);
  lc.setRow(0,1,0);
  lc.setRow(0,2,0);
  lc.setRow(0,3,0);
  lc.setRow(0,4,0);
  delay(delaytime);
}

/*
  This function lights up a some Leds in a row.
 The pattern will be repeated on every row.
 The pattern will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void rows() {
  for(int row=0;row<8;row++) {
    delay(delaytime);
    lc.setRow(0,row,B10100000);
    delay(delaytime);
    lc.setRow(0,row,(byte)0);
    for(int i=0;i<row;i++) {
      delay(delaytime);
      lc.setRow(0,row,B10100000);
      delay(delaytime);
      lc.setRow(0,row,(byte)0);
    }
  }
}

/*
  This function lights up a some Leds in a column.
 The pattern will be repeated on every column.
 The pattern will blink along with the column-number.
 column number 4 (index==3) will blink 4 times etc.
 */
void columns() {
  for(int col=0;col<8;col++) {
    delay(delaytime);
    lc.setColumn(0,col,B10100000);
    delay(delaytime);
    lc.setColumn(0,col,(byte)0);
    for(int i=0;i<col;i++) {
      delay(delaytime);
      lc.setColumn(0,col,B10100000);
      delay(delaytime);
      lc.setColumn(0,col,(byte)0);
    }
  }
}

/* 
 This function will light up every Led on the matrix.
 The led will blink along with the row-number.
 row number 4 (index==3) will blink 4 times etc.
 */
void single() {
  for(int row=0;row<8;row++) {
    for(int col=0;col<8;col++) {
      delay(delaytime);
      lc.setLed(0,row,col,true);
      delay(delaytime);
      for(int i=0;i<col;i++) {
        lc.setLed(0,row,col,false);
        delay(delaytime);
        lc.setLed(0,row,col,true);
        delay(delaytime);
      }
    }
  }
}

void loop() { 
  writeArduinoOnMatrix();
  rows();
  columns();
  single();
}

lg, Claus

Claus_M:
Hi, keine Beispiele in der Library vorhanden, aber selbst wenn ich mit der LEDControl Library arbeite, das selbe:

Falls Du ein Beispielprogramm suchst, hier hatte letztens mal jemand was aus dem Forum herausgesucht ("Laufschrift auf 8x8 Matrix"), das ich vermutlich als Code mal vor Jahren hier im Forum gepostet habe:

Hat er zum Laufen bekommen, allerdings läuft bei ihm die Laufschrift wohl in die "falsche Richtung".

Hi Jurs,

vielen Dank, auch keine Änderung, bin am Verzweifeln...

lg, Claus

Claus_M:
vielen Dank, auch keine Änderung, bin am Verzweifeln...

Was siehst Du denn am Modul: Leuchten irgendwelche LED, oder gar keine?

Und an welches Board hast Du das Modul angeschlossen und in der IDE eingestellt? Arduino UNO (oder kompatibel)?

War der Max7219 schon montiert? Steckt der in einer Steckfassung)? Festen Sitz in der Fassung geprüft, oder könnten Chip-Beinchen zu locker in der Fassung sitzen?

Also,
es leuchten einige, habe das versucht mit den Sternchen in meinem ersten Post zu illustrieren. Module waren vormontiert, steckt in einer Steckfassung, alles fest und nichts verbogen. Ist bei allen 10 Modulen (war ein 10er Pack) das selbe :frowning:

ähm, nur 'ne Frage am Rande...
Ganz oben im Beispiel-Code, welcher auf den Arduino geschickt wird, ist der Bereich innerhalb von void loop() als /* Remark */ ausgeblendet. Ist das so beabsichtigt und soll das etwas bewirken?

das ist richtig, ich wollte sehen, ob der Befehl

m.clear

funktioniert...

tut er nicht, es tut sich gar nichts...

lg, Claus

Claus_M:
Also,
es leuchten einige, habe das versucht mit den Sternchen in meinem ersten Post zu illustrieren. Module waren vormontiert, steckt in einer Steckfassung, alles fest und nichts verbogen. Ist bei allen 10 Modulen (war ein 10er Pack) das selbe :frowning:

Dürfte unwahrscheinlich sein, dass alle 10 Module denselben Fehler haben.

Wahrscheinlich machst Du eher mit allen Modulen denselben systematischen Fehler. Z.B. beim Anschließen an das Arduino-Board, das so geheim zu sein scheint, dass Du nicht mal schreibst, welches Arduino-Board Du verwendest.

Vielleicht hast Du am Board bereits einen der verwendeten Pins kaputtgespielt und geschrottet?

Hast Du am Board (und sinngemäß im Sketch geändert) vielleicht auch mal andere Pins ausprobiert?

Claus_M:
Hallo liebe Leute!

Ich habe mir über Amazon 10 Stück von diesen MaxMatrix Modulen (Max7219) bestellt. Die Dinger schauen in Ordnung aus und auch die Kabel sind dabei.
Gestern packte ich meinen Uno aus, schloss das Modul folgender Massen an:

VCC --> 5V
GND --> GND
DIN --> Pin8
CLS --> Pin9
CLK --> Pin10

Hmmmm,

...gestern packte ich meinen UNO aus... das ist doch eindeutig, oder?

ja, auch andere Pins probiert, 13,12,11 oder 12,11,10

UNO ist okay, andere Projekt mit dem UNO probiert, funktioniert, auch mit den genannten PINS..

lg, Claus

Claus_M:
…gestern packte ich meinen UNO aus… das ist doch eindeutig, oder?

Ja, UNO ist eindeutig. Vielleicht hat ja doch der China-Fertiger Ausschuss produziert, z.B bei der gesamten Serie den Platinendruck falsch gemacht, also Pin-Beschriftung am Modul falsch. Das kannst Du natürlich nur herausfinden, wenn Du mal den MAX Chip ziehst, die Pin-Belegung im Datenblatt nachschlägst und dann per Durchgangsprüfung zwischen IC-Fassung und Pins am Modul testest, ob die Pins des MAX-Chips wirklich an den Pins ankommen, die am Modul beschriftet sind.

So, hat mir keine Ruhe gelassen, habe jetzt nochmal genau geschaut, und die Vollpfosten haben die IC's alle verkehrt herum eingesetzt, alles aus dem Sockel, richtig eingesetzt und meine Laufschrift über 5 Module werkelt vor sich hin.

Danke an alle, die mir hier geantwortet haben, macht echt Spaß hier :slight_smile:

lg, Claus