5x7 dot Matrix TA01-11

[Thor Wallhall]

So.... jetzt bin ich verzweifelt.....
die ganze Geschichte ist eigentlich die... ich möchte 6 dieser 5x7 led Steine nebeneinander setzen und es soll dann "Oxygen" darin stehen...also bräuchte ich nur in jedem Stein einen Buchstaben aufleuchten lassen... ich dachte mir das es einfach wird, da ich ja nur die einzelnen dots ansteuern muss... nur kapier ich es anscheinend nicht.... um später platz zu sparen wollte ich dann jeden stein mit einem ATtiny 167 ansteuern dem ich vorher den entsprechenden Sketch aufspiele.... ich hab jetzt auch schon eine Sketches aus dem Internet bzw. YouTube probiert, bei manchen leuchtet zwar was aber nicht das was ich möchte.... bei den folgenden Sketches bekomme ich die Meldung "Fehler beim Kompilieren für das Board Arduino Nano", warum.... keinen Plan... könnte sich das jemand mal anschauen und mir helfen bzw. sagen was ich falsch mache oder wo ich den Denkfehler hab..



CodeBox C

#define A { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,0,0),\
(0,0,0,1,0,1,0),\
(0,1,1,1,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define B { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,1,0,1,0,1,0),\
(0,0,1,0,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define C { \
(0,0,0,0,0,0,0),\
(0,0,1,1,1,0,0),\
(0,1,0,0,0,1,0),\
(0,0,1,0,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define D { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,1,0,0,0,1,0),\
(0,0,1,1,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define E { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,1,0,1,0,1,0),\
(0,1,0,1,0,1,0),\
(0,0,0,0,0,0,0)\
}
#define F { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,1,0,1,0),\
(0,0,0,1,0,1,0),\
(0,0,0,0,0,0,0)\
}
#define G { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,1,0,1,0,1,0),\
(0,1,1,1,0,1,0),\
(0,0,0,0,0,0,0)\
}
#define H { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,1,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define I { \
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0)\
#define J { \
(0,0,0,0,0,0,0),\
(0,0,1,1,0,0,0),\
(0,1,0,0,0,0,0),\
(0,0,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define K { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,1,0,0,0),\
(0,1,1,0,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define L { \
(0,0,0,0,0,0,0),\
{0,1,1,1,1,1,0),\
(0,1,0,0,0,0,0),\
(0,1,0,0,0,0,0),\
(0,0,0,0,0,0,0)\
}
#define M { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,1,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define N { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,1,1,1,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define O { \
(0,0,0,0,0,0,0),\
(0,0,1,1,1,0,0),\
(0,1,0,0,0,1,0),\
(0,0,1,1,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define P { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,1,0,1,0),\
(0,0,0,0,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define Q { \
(0,0,0,0,0,0,0),\
(0,0,1,1,1,0,0),\
(0,1,0,0,0,1,0),\
(0,1,1,1,1,0,0),\
(1,0,0,0,0,0,0)\
}
#define R { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,1,1,0,1,0),\
(0,1,0,0,1,0,0),\
(0,0,0,0,0,0,0)\
}
#define S { \
(0,0,0,0,0,0,0),\
(0,1,0,0,1,0,0),\
(0,1,0,1,0,1,0),\
(0,0,1,0,0,1,0),\
(0,0,0,0,0,0,0)\
}
#define T { \
(0,0,0,0,0,0,0),\
(0,0,0,0,0,1,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,1,0),\
(0,0,0,0,0,0,0)\
}
#define U { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,1,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define V { \
(0,0,0,0,0,0,0),\
(0,0,1,1,1,1,0),\
(0,1,0,0,0,0,0),\
(0,0,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define W { \
(0,0,0,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,1,0,0,0,0),\
(0,1,1,1,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define X { \
(0,0,0,0,0,0,0),\
(0,1,1,0,1,1,0),\
(0,0,0,1,0,0,0),\
(0,1,1,0,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define Y { \
(0,0,0,0,0,0,0),\
(0,0,0,0,1,1,0),\
(0,1,1,1,0,0,0),\
(0,0,0,0,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define Z { \
(0,0,0,0,0,0,0),\
(0,1,1,0,0,1,0),\
(0,1,0,1,0,1,0),\
(0,1,0,0,1,1,0),\
(0,0,0,0,0,0,0)\
}
#define DASH { \
(0,0,0,0,0,0,0),\
(0,0,0,1,0,0,0),\
(0,0,0,1,0,0,0),\
(0,0,0,1,0,0,0),\
(0,0,0,0,0,0,0)\
}
#define SPACE { \
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0),\
(0,0,0,0,0,0,0)\
}
#define DOT { \
(0,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,0,0,0)\
}

das sollte eine Fonts lib sein....

und das der Sketch mit dem es dann eigentlich gehen sollte....



CodeBox C

#include <TimeOne.h>
#include <MatrixFonts3x5.h>

#define COLS 5
#define ROWS 7
#define PINS 13
#define MATRIX1 {\
(1,0,1,0,1,0,1),\
(0,1,0,1,0,1,0),\
(1,0,1,0,1,0,1),\
(0,1,0,1,0,1,0),\
(1,0,1,0,1,0,1)\
}
#define MATRIX2 {\
(0,1,0,1,0,1,0),\
(1,0,1,0,1,0,1),\
(0,1,0,1,0,1,0),\
(1,0,1,0,1,0,1),\
(0,1,0,1,0,1,0)\
}
byte col = 0;
byte leds[COLS][ROWS];
int pins[PINS]= {-1,1,2,3,4,5,6,7,8,9,10,11,12};
int cols[COLS] = {pins[1], pins[3], pins[10], pins[7], pins[8]};
int rows[ROWS] = {pins[12], pins[11], pins[2], pins[9], pins[4], pins[5], pins[6]};
const int numPatterns = 14;
byte patterns[numPatterns][COLS][ROWS] = 
{H,A,L,L,O,DASH,W,E,L,T,DOT,DOT,DOT,SPACE};
int pattern = 0;
void setup(){
  //Serial.begin(9600);
  for (int i = 0; i < PINS, i++){
    pinMode(pins[i], OUTPUT);
  }
  for (int i = 1; i <= COLS; i++){
    digitalWrite(cols[i - 1], 0);
  }
  for (int i = 1; i <= ROWS; i++){
    digitalWrite(rows[i - 1], 1);
  }
  blink();
  five2one();
  clearLeds();
  Timer1.initalize(2000);
  Timer1.attachInterrupt(display);
  setPattern(pattern);
}
void loop(){
  pattern = ++pattern % numPatterns;
  slidePattern(pattern, 180);
  }
void display(){
  digitalWrite(cols[col], 0);
  col++;
  if (col == 5) {
    col = 0;
  }
  for (int row = 0; row < 7; row++){
    if (leds[col][(ROWS - 1) - row] == 1){
      digitalWrite(rows[row], 0);
    }else{
      digitalWrite(rows[row], 1);
    }
    //delay(10);
  }
  digitalWrite(cols[col], 1);
}
void slidePattern(int pattern, int del){
  for (int 1 = 0; 1 < COLS; 1++){
    for (int i = 0; i < (COLS - 1); i++){
      for (int j = 0; j < ROWS; j++){
        leds[i][j] = leds[i + 1][j];
        
      }
    }
    for (int j = 0; j < ROWS; j++){
      leds[4][j] = patterns[pattern][0 + 1][j];
    }
    delay(del);
    
    }
  }
void clearLeds() {
  for (int i = 0; i<COLS; i++){
    for (int j = 0; j < ROWS; j++){
      leds[i][j] = 0;
    }
    }
  }
void setPattern(int pattern){
  for (int i = 0; i < COLS; i++){
    for (int j = 0; j < ROWS; j++){
      leds[i][j] = patterns[pattern][i][j];
    }
    }
  }
void blink(){
  for (int i = 0; i< 12; i++){
    if[i % 2 != 0){
      digitalWrite(cols[0], 1);
      digitalWrite(cols[1], 0);
      digitalWrite(cols[2], 0);
      digitalWrite(cols[3], 0);
      digitalWrite(cols[4], 0);
      digitalWrite(rows[0], 0);
      digitalWrite(rows[1], 1);
      digitalWrite(rows[2], 1);
      digitalWrite(rows[3], 1);
      digitalWrite(rows[4], 1);
      digitalWrite(rows[5], 1);
      digitalWrite(rows[6], 1);
    }else{
      digitalWrite(cols[0], 0);
      digitalWrite(cols[1], 0);
      digitalWrite(cols[2], 0);
      digitalWrite(cols[3], 0);
      digitalWrite(cols[4], 0);
      digitalWrite(rows[0], 1);
      digitalWrite(rows[1], 1);
      digitalWrite(rows[2], 1);
      digitalWrite(rows[3], 1);
      digitalWrite(rows[4], 1);
      digitalWrite(rows[5], 1);
      digitalWrite(rows[6], 1);
      
    }
    delay(100);
  }
}
void five2one(){
  digitalWrite(cols[0], 1);
  digitalWrite(cols[1], 0);
  digitalWrite(cols[2], 0);
  digitalWrite(cols[3], 0);
  digitalWrite(cols[4], 0);
  digitalWrite(rows[0], 0);
  digitalWrite(rows[1], 1);
  digitalWrite(rows[2], 1);
  digitalWrite(rows[3], 1);
  digitalWrite(rows[4], 1);
  digitalWrite(rows[5], 1);
  digitalWrite(rows[6], 1);
  delay(100);
  digitalWrite(cols[0], 0);
  digitalWrite(cols[1], 1);
  digitalWrite(cols[2], 0);
  digitalWrite(cols[3], 0);
  digitalWrite(cols[4], 0);
  digitalWrite(rows[0], 0);
  digitalWrite(rows[1], 1);
  digitalWrite(rows[2], 1);
  digitalWrite(rows[3], 1);
  digitalWrite(rows[4], 1);
  digitalWrite(rows[5], 1);
  digitalWrite(rows[6], 1);
  delay(100);
  digitalWrite(cols[0], 0);
  digitalWrite(cols[1], 0);
  digitalWrite(cols[2], 1);
  digitalWrite(cols[3], 0);
  digitalWrite(cols[4], 0);
  digitalWrite(rows[0], 0);
  digitalWrite(rows[1], 1);
  digitalWrite(rows[2], 2);
  digitalWrite(rows[3], 3);
  digitalWrite(rows[4], 4);
  digitalWrite(rows[5], 5);
  digitalWrite(rows[6], 6);
  delay(100);
  digitalWrite(cols[0], 0);
  digitalWrite(cols[1], 0);
  digitalWrite(cols[2], 0);
  digitalWrite(cols[3], 1);
  digitalWrite(cols[4], 0);
  digitalWrite(rows[0], 0);
  digitalWrite(rows[1], 1);
  digitalWrite(rows[2], 1);
  digitalWrite(rows[3], 1);
  digitalWrite(rows[4], 1);
  digitalWrite(rows[5], 1);
  digitalWrite(rows[6], 1);
  delay(100);
  digitalWrite(cols[0], 0);
  digitalWrite(cols[1], 0);
  digitalWrite(cols[2], 0);
  digitalWrite(cols[3], 0);
  digitalWrite(cols[4], 1);
  digitalWrite(rows[0], 0);
  digitalWrite(rows[1], 1);
  digitalWrite(rows[2], 1);
  digitalWrite(rows[3], 1);
  digitalWrite(rows[4], 1);
  digitalWrite(rows[5], 1);
  digitalWrite(rows[6], 1);
  delay(100);
}

tut mir echt leid das ich mich so dumm anstelle..... ich versuch mein bestes

hilft es vlt. wenn ich die Arduino Software deinstalliere und neu installiere??

Bin für jede Hilfe dankbar!!!!

 

[Dirk]

Hallo,

ich habe mir dein Programm angesehen. Mir ist hierbei etwas aufgefallen:

Im unteren Code Block

Zeile 32
Setup


CodeBox C

for (int i = 0; i < PINS, i++){
    pinMode(pins[i], OUTPUT);
  }

Ich denke der Startwert für i müsste 1 sein, da pins[0] = -1 ist.


Zeile 48
Loop

Du änderst zwar das Array der LEDs indem du slidePattern() aufrufst, allerdings wird das Array nicht an den Portpins ausgegeben.
Hier wird also die Funktion display() in loop() noch fehlen.


Zeile 68
slidePattern


CodeBox C

void slidePattern(int pattern, int del)
{
  for (int 1 = 0; 1 < COLS; 1++)
  {
    for (int i = 0; i < (COLS - 1); i++)
    {
      for (int j = 0; j < ROWS; j++)
      {
        leds[i][j] = leds[i + 1][j];   
      }
    }
    for (int j = 0; j < ROWS; j++)
    {
      leds[4][j] = patterns[pattern][0 + 1][j];
    }
    delay(del);
     
  }
}

Ich habe jetzt nicht genau geschaut, wie das led Array aufgebaut wird (mir fehlt hier auch ein bisschen Info über den Anschluss des Displays am Mikrocontroller), aber siehe dir mal die erste for-Schleife an. Das wird der Grund sein, warum der Compiler abbricht.

Selber in der Arduino Umgebung testen konnte ich heute leider nicht.

Vielleicht helfen dir die Hinweise schon mal etwas weiter.

Dirk

 

[LotadaC]

Was hast Du an Controllern da?
Wie kannst Du diese in Hardware flashen (nur über irgendeinen Arduino Bootloader, oder mittels STK500/AVRisp/...)?
Welche Software würdest Du einsetzen?

 

[Thor Wallhall]

Controller hab ich nur Arduino Nano und ich benutze die Arudino IDE 1.8.4

 

[Thor Wallhall]

Es kann doch nicht so schwer sein da zum Beispiel ein O zu schreiben

ich hab 12 PINS an der Matrix, 5 Columns, 7 Rows, die ich am Arduino an den Pins 2-13 angeschlossen hab bzw. auch von 1-12....

 

[Dirk]

Es kann doch nicht so schwer sein da zum Beispiel ein O zu schreiben

ich hab 12 PINS an der Matrix, 5 Columns, 7 Rows, die ich am Arduino an den Pins 2-13 angeschlossen hab bzw. auch von 1-12....

Meinen Beitrag #22 hast du gelesen?

Es sind Fehler in deinem Code und in loop() machst du keine Portpin Ausgabe.

Dirk

 

[Thor Wallhall]

Hi... danke..... ja hab ich gelesen... werde das nochmal alles durchgehen....

 

[Thor Wallhall]

Hab mir nochmal alles angeguckt und die Fehler ausgebessert..... geht auch nicht....

hab jetzt den Beispielcode aus der Arduino IDE ausprobiert....



CodeBox C

/*
  Row-Column Scanning an 8x8 LED matrix with X-Y input
  This example controls an 8x8 LED matrix using two analog inputs.
  This example works for the Lumex LDM-24488NI Matrix. See
  http://sigma.octopart.com/140413/datasheet/Lumex-LDM-24488NI.pdf
  for the pin connections.
  For other LED cathode column matrixes, you should only need to change the pin
  numbers in the row[] and column[] arrays.
  rows are the anodes
  cols are the cathodes
  ---------
  Pin numbers:
  Matrix:
  - digital pins 2 through 13,
  - analog pins 2 through 5 used as digital 16 through 19
  Potentiometers:
  - center pins are attached to analog pins 0 and 1, respectively
  - side pins attached to +5V and ground, respectively
  created 27 May 2009
  modified 30 Aug 2011
  by Tom Igoe
  This example code is in the public domain.
  http://www.arduino.cc/en/Tutorial/RowColumnScanning
  see also http://www.tigoe.net/pcomp/code/category/arduinowiring for more
*/
// 2-dimensional array of row pin numbers:
const int row[7] = {
  12, 11, 2, 9, 4, 5, 6
};
// 2-dimensional array of column pin numbers:
const int col[5] = {
  1, 3, 10, 7, 8
};
// 2-dimensional array of pixels:
int pixels[7][5];
// cursor position:
int x = 5;
int y = 5;
void setup() {
  // initialize the I/O pins as outputs iterate over the pins:
  for (int colPin = 0; colPin < 5; colPin++) {
    for (int rowPin = 0; rowPin < 7; rowPin++){
    // initialize the output pins:
    pinMode(col[colPin], OUTPUT);
    pinMode(row[rowPin], OUTPUT);
    // take the col pins (i.e. the cathodes) high to ensure that the LEDS are off:
    digitalWrite(col[colPin], HIGH);
  }
  }
  // initialize the pixel matrix:
  for (int x = 0; x < 5; x++) {
    for (int y = 0; y < 7; y++) {
      pixels[x][y] = HIGH;
    }
  }
}
void loop() {
  // read input:
  readSensors();
  // draw the screen:
  refreshScreen();
}
void readSensors() {
  // turn off the last position:
  pixels[x][y] = HIGH;
  // read the sensors for X and Y values:
  x = 7 - map(analogRead(A0), 0, 1023, 0, 7);
  y = map(analogRead(A1), 0, 1023, 0, 7);
  // set the new pixel position low so that the LED will turn on in the next
  // screen refresh:
  pixels[x][y] = LOW;
}
void refreshScreen() {
  // iterate over the rows (anodes):
  for (int thisRow = 0; thisRow < 7; thisRow++) {
    // take the row pin (anode) high:
    digitalWrite(row[thisRow], HIGH);
    // iterate over the cols (cathodes):
    for (int thisCol = 0; thisCol < 5; thisCol++) {
      // get the state of the current pixel;
      int thisPixel = pixels[thisRow][thisCol];
      // when the row is HIGH and the col is LOW,
      // the LED where they meet turns on:
      digitalWrite(col[thisCol], thisPixel);
      // turn the pixel off:
      if (thisPixel == LOW) {
        digitalWrite(col[thisCol], HIGH);
      }
    }
    // take the row pin low to turn off the whole row:
    digitalWrite(row[thisRow], LOW);
  }
}

es leuchten zumindest alle leds.....

 

[Dirk]

So wie ich den Code verstehe, sollten alle LEDs aus sein, bis auf eine.
Es sind zwei Potentiometer an den ADC pins A0 und A1. Die beiden analogen Werte bestimmen die x und y Position einer leuchtenden Led in der Matrix.

Das Beispiel ist eigentlich für dieses 8x8 LED Display. Du müsstes nun ggf. den Code und die Anschlussbelegung an dein Display anpassen.

Die Zuordnung der col und row Pins hast du ja gemacht.


CodeBox C

// 2-dimensional array of row pin numbers:
const int row[7] = {
  12, 11, 2, 9, 4, 5, 6
};
// 2-dimensional array of column pin numbers:
const int col[5] = {
  1, 3, 10, 7, 8
};

Output Pins:


CodeBox C

  // initialize the I/O pins as outputs iterate over the pins:
  for (int colPin = 0; colPin < 5; colPin++) {
    for (int rowPin = 0; rowPin < 7; rowPin++){
    // initialize the output pins:
    pinMode(col[colPin], OUTPUT);
    pinMode(row[rowPin], OUTPUT);
    // take the col pins (i.e. the cathodes) high to ensure that the LEDS are off:
    digitalWrite(col[colPin], HIGH);
  }
}

Die for-Schleifen sind hier verschachtelt, ich denke das ist unnötig. Mach zwei for-Schleifen hintereinander, jeweils eine für col und row.

Alle Col Pins werden auf high gesetzt. Sind hier die Kathoden angeschlossen sind die LEDs aus.
Sind aber die Anoden angeschlossen (ggf. anderes Display), dann leuchten die LEDs, da alle row Pins low sind (das ist nach Reset so, da das Portregister den Inhalt 0 hat).
Das wäre ein Grund, warum alles leuchtet.


Bei der Initialisierung des Pixel-Arrays verwechselst du row und col:



CodeBox C

// 2-dimensional array of pixels:
int pixels[7][5];

// ...

  // initialize the pixel matrix:
  for (int x = 0; x < 5; x++) {
    for (int y = 0; y < 7; y++) {
      pixels[x][y] = HIGH;
    }
  }

Der Startwert für ein Index des Pixel Array überschreitet die Arraygröße.


CodeBox C

// cursor position:
int x = 5;
int y = 5;

Das passiert auch bei der ADC Messung in der map Funktion. Index x und y können zu hoch werden.
Dies musst du an das Array noch anpassen.


CodeBox C

  // read the sensors for X and Y values:
  x = 7 - map(analogRead(A0), 0, 1023, 0, 7);
  y = map(analogRead(A1), 0, 1023, 0, 7);

Schau dir das erst mal an, vielleicht helfen dir die Hinweise schon mal weiter.
Weiter habe ich mir den Code nicht angesehen, da es inzwischen auch schon ein bisschen spät ist

Dirk

 

[LotadaC]

Das Beispiel ist eigentlich für dieses 8x8 LED Display

Beide Datenblätter zeigen reine LED-Matrizen, ohne irgendwelcher Treiber oder Strombegrenzung.
Nach dem Bild in #28 ist diese Matrix direkt an den Arduino geklemmt.
Auf der Shop-Seite wird bei den technischen Spezifikationen nur 40mA pro I/O angegeben. Das entspräche den absolute maximum ratings des Mega328P - Arduino geht aber nicht weiter auf die anderen Grenzen ein (zB max 200mA durch die Stromversorgungspins des AVR).
Die empfohlenen einzuhaltenden Grenzen sind die hälfte, und dabei wäre zu beachten, welche I/Os gemeinsam an welchen Stromversorgungspins hängen...
Aus dem Schaltplan des Nano (Shop->Documentation) geht hervor, daß die Pins des AVR (lediglich umgenannt) direkt am Arduino-Header liegen.
An einer LED der Matrix würden also 5V abzüglich der beiden Push-/Pull-Spannungen im AVR (angenommen je 0,7V) anliegen: 3,6V.
Die LEDs die parallel an eine/r Col oder Row hängen überlasten den AVR-Pin, da geht möglicherweise erstmal nur die Spannung runter - aber mMn ist das weder für die LEDs noch für den AVR verträglich.

 

[Dirk]

... ist das weder für die LEDs noch für den AVR verträglich.

Ja, das ist eigentlich nicht in Ordnung, macht mir auch Kopfschmerzen . Problematisch besonders dann, wenn das Programm fehlerhaft ist und ständig derselbe IO Pin statisch belastet wird. Aber auch wenn periodisch Spalten/Zeilen-Treiber umgeschaltet werden (multiplex) ist es problematisch.

Ich würde für solche LED-Matrix-Displays einen Treiber verwenden, der auch den Strom unter Kontrolle hat, zum Beispiel HT16K33 von Holtek.

Dirk

 

[LotadaC]

einen Treiber verwenden

Ist ja nicht nur ein Treiber, sondern schon ein ganzer Controller, der das Multiplexing selbst macht, oder?
Natürlich macht es Sinn, sone Sachen vom AVR auszulagern, aber um was zu lernen, kann man auch den AVR multiplexen lassen. Nur, dann muß man eben auch auf den Strom achten (Vorwiderstände), und bei Bedarf (da wo mehrere LEDs parallel aktiviert sein könnten) Treiber (Transistoren/Transistor-ICs (ULNxxxx)) verwenden.

P.S.: Du kommst als C'ler sicher besser mit Arduinesisch zurecht, aber werden da überall Integervariablen (16Bit ? )reserviert (also zB ThisPixel in der refreshScreen bzw das ganze zweidimensionale pixels[][]-array sollten doch je nur ein Bit sein.)
Das beinweise setzen der Ausgänge ist bei Multiplexing auch nicht gerade sinnig (ok flexibilität bei der Zuordnung...)

 

[Dirk]

Natürlich macht es Sinn, sone Sachen vom AVR auszulagern, aber um was zu lernen, kann man auch den AVR multiplexen lassen

Ja, das stimmt natürlich, wenn du das Display direkt an den Mikrocntroller anschließt lernst du was über Multiplexen. Verwendest du zum Beispiel den HT16K33 dann lernst du was über I2C

P.S.: Du kommst als C'ler sicher besser mit Arduinesisch zurecht, aber werden da überall Integervariablen (16Bit ? )reserviert (also zB ThisPixel in der refreshScreen bzw das ganze zweidimensionale pixels[][]-array sollten doch je nur ein Bit sein.)
Das beinweise setzen der Ausgänge ist bei Multiplexing auch nicht gerade sinnig (ok flexibilität bei der Zuordnung...)

Ja, das ist Verschwendung von Speicherplatz eventuell auch von Rechenzeit

 

[Thor Wallhall]

vielen vielen Dank für die vielen Kommentare.....
ich hab mir jetzt schon überlegt die Matrix mit einem max7219 Treiber zu steuern......
da in den meisten tutos dieser verwendet wird...
und ich werde mir den Sketch nochmal richtig und gründlich vornehmen....

Danke danke danke nochmal

ich melde mich dann nochmal wenn es was neues gibt... muss die Treiber ja erstmal kaufen

 

[Mikro23]

Der MAX7219/MAX7221 ist ein Treiber für 7-Segment-Anzeigen, für Dot-Matrix eher ungeeignet.

Da hier am Anfang mal vom 74xx595 die Rede war, den gibt es auch mit Treiberausgängen: TPIC6B595
Der hat Open Drain Ausgänge mit 150 mA, 50 V.

 

[LotadaC]

Der MAX7219/MAX7221 ist ein Treiber für 7-Segment-Anzeigen, für Dot-Matrix eher ungeeignet.

Hab ich auch erst gedacht, aber der kann auch (bis zu) 8x8 Matrizen ansteuern. (acht Siebensegmente mit DP). Man muß den internen Decoder nicht nutzen, und kann dann 'ne Matrix ansteuern.
Man sollte auch 'ne (dann kleinere, klar) Matrix mit ein oder vier Siebensegmenten kombinieren können...
(also nur für einen Teil der COLs den Decoder aktivieren)
Wäre dann eher ein Beispiel für "Ich lerne SPI".

Empfehlen tät ich den wohl nicht unbedingt für den Anfang, aber...

da in den meisten tutos dieser verwendet wird

 

[Mikro23]

aber der kann auch (bis zu) 8x8 Matrizen ansteuern

Ok, dann braucht man aber pro Matrix ein IC, also für 6 Anzeigen 6 ICs.

 

[Thor Wallhall]

So... ich bekomme das jetzt wenigstens so hin...



CodeBox C

int spalte[]={2,3,4,5,6};
int reihe[]={7,8,9,10,11,12,13};

void setup() {
  for(int i=0;i<=4;i++){
    pinMode(spalte[i], OUTPUT);
  }
  for(int i=0;i<=6;i++){
    pinMode(reihe[i], OUTPUT);
  }
  ////////////////////////
  for(int i=0;i<=4;i++){
    digitalWrite(spalte[i], LOW);
  }
  for(int i=0;i<=6;i++){
    digitalWrite(reihe[i],HIGH);
  }
}
void loop() {
digitalWrite(
 
digitalWrite(spalte[1], HIGH);
digitalWrite(reihe[3], LOW);
delay(1);
digitalWrite(spalte[1], LOW);
digitalWrite(reihe[3], HIGH);
delay(1);
digitalWrite(spalte[3], HIGH);
digitalWrite(reihe[3], LOW);
delay(1);
digitalWrite(spalte[3], LOW);
digitalWrite(reihe[3], HIGH);
delay(1);
digitalWrite(spalte[2], HIGH);
digitalWrite(reihe[4], LOW);
delay(1);
digitalWrite(spalte[2], LOW);
digitalWrite(reihe[4], HIGH);
delay(1);
digitalWrite(spalte[1], HIGH);
digitalWrite(reihe[5], LOW);
delay(1);
digitalWrite(spalte[1], LOW);
digitalWrite(reihe[5], HIGH);
delay(1);
digitalWrite(spalte[3], HIGH);
digitalWrite(reihe[5], LOW);
delay(1);
digitalWrite(spalte[3], LOW);
digitalWrite(reihe[5], HIGH);
delay(1);
}

zwar ein langer Sketch aber es funzt....
noch eine Frage... kann ich diesen Sketch auf einen ATtiny 167 hochladen und dann damit die Matrix ansteuern....?
So bräuchte ich 6 ATtinys und auf jeden Spiele ich den entsprechenden Sketch für den jeweiligen Buchstaben drauf

 

[LotadaC]

kann ich diesen Sketch auf einen ATtiny 167 hochladen

Die Frage ist falsch gestellt, bzw so nur mit nein zu beantworten.
In einen AVR kannst Du nur Maschinencode laden.
Aus Deinem Sketch/Programmcode controllerspezifischen Maschinencode zu erzeugen, ist Aufgabe der verwendeten Entwicklungsumgebung - die muß also erstmal den Controller unterstützen. Ob Deine Arduino-IDE den Tiny87/167 unterstützt, mußt Du wissen. wenn sie dies tut, wird sie auch die "Arduino-Umbenennung" der Pins vornehmen - der Code oben scheint keine nennenswerten Hardwareanforderungen zu stellen, denen der Tiny nicht gewachsen sein sollte.
So, hast Du also den entsprechenden Maschinencode, muß er auch irgedwie in den Controller kommen. Wie?
Während des Reset, können beide Controller über eine serielle Schnittstelle (SPI) in einen Programmiermodus versetzt werden, und mit einem speziellen Protokoll programmiert werden. Dazu benötigt die IDE also physischen Zugriff auf diese Schnittstelle - üblicherweise über einen externen Programmer (wurde früher teilweise einfach über den Parallelport eines Rechners gemacht).
Variante zwei löst einen High-Voltage (12V)-Reset aus, und verwendet dann festgelegte Pins parallel. Das geht auch, wenn die SPI deaktiviert ist oder der Reset deaktiviert ist - sozusagen der Generalschlüssel. Erfordert natürlich auch 'nen entsprechenden Hardware-Programmer (mit dem die IDE dann auch arbeiten muß.

Außerdem können sich viele AVR "von innen" selbst programmieren. D.h. der AVR kann auf einem beliebigen Kommunikationskanal neuen (Maschinen-)Code entgegennehmen, und in seinen Programmspeicher schreiben.
ABER dazu muß sich das Programm, welches den Code von dem Kanal entgegennimmt, und in den Flash schreibt, bereits im AVR befinden.
Du brauchst also einen Arduino-fähigen Bootloader im Tiny167.
Ülicherweise wird für diesen Weg ein UART verwendet, der vom PC aus via USB-Seriell-Wandler angesteuert werden kann (auf den Arduino-Platinen meist mit drauf).

Wenn Du also einen Tiny167 mit Arduino Bootloader und der nötigen Schnittstellenanbindung an die Arduino-IDE hast, sollte die IDE den Sketch (genauer: den controllerspezifischen Maschinencode) in den Controller flashen können (genauer: übertragen, und den Controller sich selbst beschreiben lassen).

So...

Eigentlich willst Du 'ne 8x30-Matrix leuchten lassen. Da jetzt je Brick einen eigenen Controller mit 'nem statischen Muster einzusetzen, ist etwa genauso elegant, wie die Vergußmasse aus dem Bricks zu popeln, und die LEDs (mit Vorwiderständen) direkt zu verlöten (jaja, inzwischen werden das SMDs auf 'ner Platine sein blabla...).
Auf der anderen Seite kann auch ein Mega328 nicht allein 38 Pins ansteuern - es müßten also weitere ICs verwendet werden. Bei Verwendung von weiteren AVR (einer pro Brick) würde ich allerdings eher auf einen Controller setzen, der UART und einen zweiten Kanal bietet (TWI, USI), um in der Darstellung flexibler sein zu können (Anbindung an PC etc, Lauftexte, ...).
Prinzipiell sollte auch ein Tiny167 gleichzeitig mit einem PC via UART kommunizieren können, und nebenbei Portexpander/Schieberegister oder Treiberbausteune füttern können. Dann sollte man aber keine einzelnen Pins mehr setzen und löschen lassen, sondern die Hardware byteweise selbst arbeiten lassen (USI, UART usw).

 

[LotadaC]

Hi Thorsten,

ich weiß jetzt nicht, ob das Thema für Dich überhaupt noch von Interesse ist, aber:

Im Code aus #28 wird das "klassische" Multiplexing eunes solchen Displays angedeutet. Es wird eine Zeile aktiviert, und dann alle Spalten, die in dieser Zeile an sein sollen. Anschließend wird die Zeile wieder deaktiviert. Es leuchten also immer alle (aktivierten) LEDs in einer Zeile gleichzeitig.
(Deswegen die Empfehlung eines Treiber-Transistors oder ICs. Sinnigerweise setzt man dabei nicht alle Pins einzeln, sondern gleichzeitig alle. Dabei nutzt man möglichst aus, daß die Register der Pins acht Bits groß sind (=8 LEDs). Ggf ist es also sinniger, Zeilen und Spalten zu tauschen.
Die Darstellungsroutine muß quasi permanent ausgeführt werden - üblicherweise koppelt man das (mehr oder weniger direkt) an einen Interrupt. Dann wird bei jedem Aufruf eine Zeile (mit den dazugehörigen LEDs) bis zum nächsten Aufruf aktiviert, da dann die nächste Zeile usw.

Beim Code aus #38 leuchtet immer nur eine LED gleichzeitig, und zwar 'ne Millisekunde lang (delay).

P.S.: noch zu digitalwrite...
hier mal ein Reassemblat eines Arduino-Codes - digitalWrite scheint recht... opulent zu sein (Flash und Rechenzeit betreffend). Ab 0x0324 gehts los (Zeile 606 im Code-Fenster). Die Parameter werden beim Aufruf in folgenden Registern geparkt: Arduino-Pinnummer in R24, Soll-Zustand in R22 (0=low, 1=high).
Wenns schnell sein soll (und das solls ja bei Multiplexing, insbesondere wenn der Controller nebenbei noch was anderes machen soll), wäre also digitalWrite nicht zu empfehlen. Die IDE scheint auch die Register verwenden zu können - ähnlich wie C. Allerdings muß man dann mit den konkreten AVR-Registern (also den korrekten Bein-namen) umgehen können, und nicht mit den Arduino-Umbenennungen...