Funktion MatrixLED

Hallo Leute,
ich möchte um meine LED Matrix einfacher zu Programieren mein Programm anpassen.
Ich habe schon allen Bustaben die passenden Bytes zugeordnet jetzt möchteich ein Funktion Schriebne die mir die Jeweilegn Bustaben ausdrückt.
Ich hab gedacht ich könnnte vorab eine Funktion deklarieren und diese dann in Void Loop anpassen also ca. So:
void writeArduinoOnMatrix() {

lc.setRow(0,0,ab[0]);
lc.setRow(0,1,ab[1]);
lc.setRow(0,2,ab[2]);
lc.setRow(0,3,ab[3]);
lc.setRow(0,4,ab[4]);
delay(500);
}

void loop() {
writeArduinoOnMatrix(ab=a);
writeArduinoOnMatrix(ab=b);
writeArduinoOnMatrix(ab=c);
}
in diesen Fall soll ab für meine Variabel Stehen die ich in Nachinen für mein bustaben austauschen möchte doch da habe ich wohl zu einfach gedacht. Muss ich jedes mal mein lc.setRow für jeden Bstaben neu schreiben oder gibt es da eine Andere möglichkeit. vieleicht habe ich ja auch ein denkfehlern.

MFG Simon

schaut nach Max7219 aus. Ja/nein/weisnicht?
Was hast da genau?
Bitte Produkt verlinken.
Bitte Schaltplan ergänzen.
Microcontroller?

Moin,
ich habe eine UNO R3 und habe die 8x8 matrix an pin 12/11/10 angeschlossen.
Ich bin Progamier technisch leider noch nicht so fit deshalb möchte ich mir selbst eine Datenbank bzw so eine funktion bauen.

wieso?= :smiley:
ich hab keine Schlatplan.. und ich weis nur das ich eine Elegoo uno R3 hab steht drauf

Sorry Elego MAX7219

ich möcte keine Beleidigen oder verärgern ich bin neu auf den gebiet anbei ein Foto.


aber zur info dsas übertragen klappt ich finde es nur relativ aufwenig. also ich kann schon Bustaben oder zeichen auf der Matrix wiedergeben. meine Frage bezieht sich wie ich dies eventeull im Programm einfacher machen kann

nimm statt der LedControl die MD_MAX7219, die kann Buchstaben auf einer MAX7219 Matrix drucken. Installierbar über den Bibliotheksmanager der IDE.

Schau dir die Beispiele an. Da wirst fündig. Es macht aus meiner Sicht keinen Sinn das Rad neu erfinden zu wollen.

P.S.: das ist ein anklickbarer Link
https://github.com/MajicDesigns/MD_MAX72XX - damit macht man es anderen Leuten leicht, draufklicken zu können.

Danke für die Antwort.
ich möchte das rad auch nicht neu erfinden ich möchte nur das system verstehen. Dass gleiche Problem kann mir an andere Stelle ja wieder passieren. ich möchte nicht worklich effektiv die Matrix Programieren ich möchte das Programieren an sich leren und daher kommt meine Frage wie man eine solche Situation eleganter lösen kann wenn ich wiederholt eine Ablauf mit verschidenen Variabel Progamieren will so wie in diesen Falls. Ich setzte einen Ablauf fest und möchte diese immer wieder nutzen nur bite verschidennen Varaibeln. Geht soetwas?

ja geht.

Also das Rad neu erfinden:

Ich würde für jeden Buchstaben eine Bitamp der aufzuleuchtenden Pixel festlegen.
also so etwa

0b00000011
0b00000101
0b00001001
0b00000001
0b00000001
0b00000001
0b00000000

also ein byte array legt den Buchstaben fest, nicht eine Funktion.

Dann ein Array für all diese Arrays als ganzer Zeichensatz.

Und dann eine writeSpezial Funktion (später was anderes), um das jeweilige "Zeichen" gem. dem Byte Array auf das Display rauszuschieben.

ok ich hab das so gemacht das ich jeden Bustaben in byts bisslang schon defeniert haben #include <LedControl.h>

LedControl lc=LedControl(12,10,11,1);

/ we always wait a bit between updates of the display /
int bustabe = 700;
int wort = 1200;
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); *
  • byte a[5]={B01111110,B10001000,B10001000,B10001000,B01111110}; *
  • byte b[5]={B00000000,B01101100,B10010010,B10010010,B11111110}; *
  • byte c[5]={B00000000,B10000010,B10000010,B01000100,B00111000};*
  • byte d[5]={B11111110,B00010010,B00100010,B00100010,B00011100};*
  • byte e[5]={B00000000,B10010010,B10010010,B10010010,B11111110};*
  • byte f[5]={B00000000,B10010000,B10010000,B10010000,B11111110};*
  • byte g[5]={B00000000,B10011110,B10010010,B10010010,B11111110};*
  • byte h[5]={B00000000,B11111110,B00010000,B00010000,B11111110};*
  • byte i[5]={B00000000,B00000010,B10111110,B00100010,B00000000};*
  • byte j[5]={B00000000,B11111110,B00000010,B00000110,B00001100};*
  • byte k[5]={B00000000,B10000010,B01000100,B00101000,B11111110};*
  • byte l[5]={B00000000,B00000010,B00000010,B00000010,B11111110};*
  • byte m[5]={B11111110,B10000000,B11111110,B10000000,B11111110};*
  • byte n[5]={B00000000,B01111110,B01000000,B01000000,B11111110};*
  • byte o[5]={B00011100,B00100010,B00100010,B00100010,B00011100};*
  • byte p[5]={B00000000,B00110000,B01001000,B01000100,B11111110};*
  • byte q[5]={B00011100,B00100010,B00100010,B00100010,B00011110};*
  • byte r[5]={B01100010,B10010100,B10011000,B10010000,B11111110};*
  • byte s[5]={B00000000,B10001100,B10010010,B10010010,B01100010};*
  • byte t[5]={B10000000,B10000000,B11111110,B10000000,B10000000};*
  • byte u[5]={B00111110,B00000100,B00000010,B00000010,B00111100};*
  • byte v[5]={B11000000,B00110000,B00001100,B00110000,B11000000};*
  • byte w[5]={B11100000,B00001110,B11100000,B00001110,B11100000};*
  • byte x[5]={B01000010,B00100100,B00011000,B00100100,B01000010};*
  • byte y[5]={B10000000,B01000000,B11111110,B01000000,B10000000};*
  • byte z[5]={B11000010,B10100010,B10010010,B10001010,B10000110}; *
  • byte herz[8]={B01100000,B10001,B10000010,B01100001,B10000010,B01000100,B00111000,B00111000};*
  • byte kill [8]={B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000,B00000000};*
    }

void writeArduinoOnMatrix() {

  • lc.setRow(0,0,ab[0]);*
  • lc.setRow(0,1,ab[1]);*
  • lc.setRow(0,2,ab[2]);*
  • lc.setRow(0,3,ab[3]);*
  • lc.setRow(0,4,ab[4]);*
  • delay(500);*
    }

*void loop() { *

  • writeArduinoOnMatrix(ab=a);*
  • writeArduinoOnMatrix(ab=b);*
  • writeArduinoOnMatrix(ab=c);*
    }

ca. So und anstatt jedesmall die Funktion lc.seetROW zu schreiben und die Bustabe dort abzurufen ist meine Überlegung wie geschreiben dies in der loop Funktion die Varaibel abzurufen damit ich in der theorie nur noch die Fun ktions auffruf schreiben muss und den jeweiligen Bustaben.?!?

du lies mal im Forum how to nach wie man Code postest.

schau, wie willst von einer Ausgabe in einem char-Array "abc" am besten auf deine Variablen a, b, c kommen? ja kannst mit einem großen if wurst oder swicht/case machen. Ist aber ein schmarren.
daher mach dir einen array von arrays. Ein zwei dimensionales Array. Erste Dimension ist der Buchstabe, die zweite sind die 5 bytes.

const byte character[][5] {
  {B01111110,B10001000,B10001000,B10001000,B01111110}, // a
  {B00000000,B01101100,B10010010,B10010010,B11111110}  // b
  // usw
};

jetzt brauchst nur deinen Buchstaben z.B. "a" mappen auf den nullten Index im character und dann die 5 Zeichen ausgeben. "b" ist der index 1, "c" der Index 2 ... klar?

Beispiel:
du hast ein bestimmtes Zeichen zum Ausgeben in in einer Variable

char toBePrinted = 'c';

wie kommst auf deine Index-position im Array?
Das Array beginnt für den Buchstaben 'a'. Also subdrahierst einfach von c - a

byte indexPosition = toBePrinted - 'a';

Rechen mit Buchstaben. Ist aber egal, weil der Buchstabe einfach als ASCII Code gespeichert ist.

'c' in ASCII ist 99
'a' in ASCII ist 97
99 - 97 = 2
du bekommst also Index 2 zurück geliefert --> genau dein Zeichen 'c'

Und irgendwann wird dir der SRAM ausgehen daher sollst du so eine Tabelle in den PROGMEM geben. Das kannst dir aber selber ergoogeln wie das geht und wie man dann auf die Array Daten zugreift.