Funktion mit variablem Namen aufrufen

Hallo!
Ich habe mit meinen Schülern eine 5x5 LED Matrix gelötet und programmiert.
Ich kann Jeden beliebigen Buchstaben mit der erstellten Methode
zeige();
an die Matrix senden und anzeigen lassen.
z.B. zeige(A) erzeugt ein A auf der Matrix.

Jetzt wäre es praktisch den ganzen Text in eine Variable zu schreiben und dann Buchstabenweise ausgeben zu lassen .

Das Auslesen der einzelnen Buchstaben aus char myStr = “ABCD” ist kein Problem.
myStr[0] ließt das A usw. Das kommt in eine Schleife und fertig.

Nur wie übergebe ich das an meine METHODE zeige()?
zeige [myStr[0]]; // funktioniert nicht und zeigt nur eine leere Matrix.
… dass 2 zeige() hintereinander als solches nicht funktionieren ist mir klar - das muss in eine “Zeitschleife”. Es geht nur um das Prinzip.

Ich habe mich schon informiert und festgestellt, das es mit Variablentypen, Zeigervariablen und der Benennung zu tun haben muss, aber wo genau mein offensichtlicher Denkfehler liegt … ???
Ich habe schon gegoogelt und finde eigentlich nur sehr alte posts die die selbe Frage stellen aber für mich nicht so recht zielführend sind.

Vielleicht kann mir hier jemand helfen.
DANKE!

5x5_bitread_-_test.ino (1.15 KB)

In C sind Arrays Pointer. Du übergibst also das Array myStr und zeige(char* str) erwartet einen Pointer. Mit myStr[0] übergibst Du nur das Zeichen, das in myStr[0] steht, aber nicht seine Adresse.

mein Ansatz wäre:

adaptiere (belasse) die FUNKTION zeige() zur Ausgabe EINES Zeichens.

mach dir eine zweite FUNKTION wort() die zwei Parameter bekommt:

  • einen Pointer auf dein char Array
  • und die Textlänge in diesem Array

Die Funktion wort() ruft dann in einer for schleife die Funktion zeige() für jeden einzelnen Buchstaben auf.
Deswegen sollst du auch die Textlänge übergeben damit du in der Funktion wort() weist wie lang dein char Array ist.

das ist sehr ähnlich was in der print Klasse passiert:

es gibt ein write das ein Zeichen ausgibt,
es gibt viele implementierungen von print die z.B. verschiedene Variablen übernehmen können und dann einzeln write aufrufen für jedes Zeichen das ausgegeben werden muss.

p.s.: von METHODEN sprechen wir im Zusammenhang von Strukturen und Klassen. Das sehe ich aber in deinem Sketch nicht. Du hast dir FUNKTIONEN angelegt.

p.s2: sind weitere Anmerkungen zu deinem Sketch erwünscht?

adaptiere die FUNKTION zeige zur Ausgabe EINES Zeichens.
... zeige() gibt jetzt schon nur ein Zeichen an die Matrix aus.

mach dir eine zweite FUNKTION wort die zwei Parameter bekommt:

  • einen Pointer auf dein char Array
  • und die Textlänge in diesem Array

Das ist mein Problem ... wie genau geht das mit den Pointern.
Ich finde leider im Netz und auch hier im Forum nicht wirklich brauchbare Anleitungen zur Verwendung von Pointern. Jedenfalls für mich als Laien.

Erstmal so nebenbei: dein 'zeige' ist eine ganz normale Funktion und keine Methode. Das ist ein durchaus relevanter Unterschied. Methoden gibt es nur im Zusammenhang mit Klassen.

Nun zu deinem Problem. Wenn Du einen Char-string anlegst, stehen dort ASCII-Zeichen drin. ein 'A' ist z.B. als hexadezimaer Wert 0x41, oder dezimal 65. Dein Array 'A' , das die Bitinformation für die Darstellung eines A enthält, hat aber mit einem ASCII-Zeichen nichts zu tun, auch wenn Du es A nennst. Das ist mal das erste Problem.
Und dann kommt noch das von DrDiettrich angesprochene Problem hinzu, dass Du an deine Funkton 'zeige' einen Pointer auf ein Array übergeben musst, und kein ASCII-Zeichen.
Du brauchst also eine Umsetzung des ASCII-Zeichens - z.B. 'A' auf das Array -hier dann A - mit den Bitinformationen für die Darstellung. Dazu solltest Du dein Array mit den Bitinformationen in ein 2-dimensionales Array umbauen, so dass Du die Bit-Informationen eines Zeichens auch über einen Index ansprechen kannst, und nicht nur über einen Namen. Diesen Index kannst Du dann aus dem ASCII-Zeichen berechnen. Wenn Du z,B, schreibst

myStr[i]-'A'

erhälst Du die Werte 0..3 für deine Buchstaben A...B und kannst Damit das entsprechende Bitmuster anwählen.

ok, noiasca war schneller :wink:

P.S. Für dein Problem musst Du dich gar nicht direkt mit Pointern beschäftigen. Das geht alles auf Array-Ebene. Dass der Compiler das intern mit Pointern realisiert, sollte man wissen, aber für dein Programm reicht eine reine Array-Syntax aus. Aber mit 2-dimensionalen Arrays solltest Du dich beschäftigen.

noiasca:
mein Ansatz wäre:

adaptiere (belasse) die FUNKTION zeige() zur Ausgabe EINES Zeichens.
-- OK
mach dir eine zweite FUNKTION wort() die zwei Parameter bekommt:

  • einen Pointer auf dein char Array
  • und die Textlänge in diesem Array
    --- void wort(*myStr, int myStr.length()){ .... } so in etwa ?

Die Funktion wort() ruft dann in einer for schleife die Funktion zeige() für jeden einzelnen Buchstaben auf.
-- In etwa so hatte ich es mir vorgestellt.
Deswegen sollst du auch die Textlänge übergeben damit du in der Funktion wort() weist wie lang dein char Array ist.

p.s.: von METHODEN sprechen wir im Zusammenhang von Strukturen und Klassen. Das sehe ich aber in deinem Sketch nicht. Du hast dir FUNKTIONEN angelegt.
-- OK mein Fehler. Ich habe das alles rein autodidakt zusammengesucht und kannte den Unterschied nicht.

p.s2: sind weitere Anmerkungen zu deinem Sketch erwünscht?
--NATÜRLICH... aber bitte alles einfach halten für mich und meine Schüler!

ohne Bereinigungen der hässlichen Sachen.
ohne Hardwaretest
kompiliert aber fehlerfrei und gibt auf der Seriellen was plausibles aus.

// https://forum.arduino.cc/index.php?topic=731407.0


int zeile[] = {4, 5, 6, 7, 8};                         // hässlich (2x)
int spalte[] = {9, 10, 11, 12, 13};                    // hässlich

byte A [] = {B01100, B10010, B11110, B10010, B10010};  // hässlich (3x)
byte B [] = {B11100, B10010, B11110, B10010, B11100};  // hässlich
byte C [] = {B01110, B10000, B10000, B10000, B01110};  // hässlich
byte D [] = {B11100, B10010, B10010, B10010, B11100};  // hässlich
byte E [] = {B11110, B10000, B11100, B10000, B11110};  // hässlich


const byte charTable[][5] = {
  {0b01100, 0b10010, 0b11110, 0b10010, 0b10010},       // A
  {0b11100, 0b10010, 0b11110, 0b10010, 0b11100},       // B
  {0b01110, 0b10000, 0b10000, 0b10000, 0b01110},       // C
  {0b11100, 0b10010, 0b10010, 0b10010, 0b11100},       // D
  {0b11110, 0b10000, 0b11100, 0b10000, 0b11110}        // E
};

const byte firstChar = 'A';                            // mit welchem Zeichen beginnt der charTable

void setup() {
  Serial.begin(9600);

  for (int i = 4; i < 14; i++) {                       // hässlich(3x)
    pinMode(i, OUTPUT);
  }
}

void loop() {
  char myStr[] = "ABCD"; // Variable mit dem anzuzeigenden Text

  //   zeige(A); // Aufruf der Methode um einen Buchstaben anzuzeigen - funktioniert und zeigt A in der Matrix

  //zeige [myStr[0]]; // soll den ersten Buchstaben aus myStr[] in der Matrix anzeigen, zeigt aber nichts
  //zeige [myStr[1]]; // soll den zweiten Buchstaben aus myStr[] in der Matrix anzeigen, zeigt aber nichts

  wort(myStr, sizeof(myStr) - 1);
}

void wort(char *toPrint, size_t len)
{
  for (size_t i = 0; i < len; i++)
  {
    // convert character to a variable
    byte myIndex = toPrint[i] - firstChar; // ASCII minus erstem Zeichen somit 0 für das erste Zeichen in deinem Char-Table
   
    zeige(charTable[myIndex]);
    Serial.print(myIndex);      // Debug Meldungen - nur für mich zum kontrollieren, weil ich deine HW nicht habe
    Serial.print("\t");
    Serial.println(toPrint[i]); 
    // evtl eine Zeitsteuerung, oder eine Verzögerung zwischen den Buchstaben
  }
}


// ***** Ausgabe an die 5x5 LED MAtrix ******
void zeige(const byte buffer2[]) {
  for (int a = 0; a <= 4; a++) {
    digitalWrite(zeile[a], 1);
    for (int i = 0; i < 5; i++) {
      digitalWrite(spalte[i], bitRead (buffer2[a], i));
      digitalWrite(spalte[i], 0);
    }
    digitalWrite(zeile[a], 0);
  }
}

Du solltest vielleicht auch mal deine HW-Schaltung zeigen. So wie ich deinen Sketch verstehe, wird die Matrix vom Arduino dynamisch angesteuert, d.h. die Funktion 'zeige' muss zyklisch immer wieder aufgerufen werden, damit das Zeichen sichtbar bleibt. Das wird wichtig, wenn Du die Zeitsteuerung für deine Buchstaben aufbaust. Die darf dann nämlich nicht blockierend sein ( keine delay() ).

Drakkheen:
...

Achte beim Antworten bitte auf lesbares Zitieren. Es ist sonst schwer, Deine Antwort(en) herauszulesen.

Gruß

Gregor

Anmerkungen zu #6

2x hässlich

int zeile[] = {4, 5, 6, 7, 8};                         // hässlich (2x)
int spalte[] = {9, 10, 11, 12, 13};                    // hässlich

pins ändern sich nie → mach sie const
int braucht zwei byte. die ports brauchen aber nur ein byte

const byte zeile[] = {4, 5, 6, 7, 8};                         
const byte spalte[] = {9, 10, 11, 12, 13};

3x hässlich

byte A [] = {B01100, B10010, B11110, B10010, B10010};  // hässlich (3x)

Variablen nicht mit Großbuchstaben beginnen lassen
nicht const gemacht
Arduino precompiler define genutzt statt Standard 0b01100

aber ohnehin besser in einem 2D-Array da leichter erweiterbar und leichter im Code zu behandeln.

3x hässlich

  for (int i = 4; i < 14; i++) {                       // hässlich(3x)
    pinMode(i, OUTPUT);
  }

du hast dir oben Arrays angelegt, nutzt es aber nicht, dein for nutzt de facto magic numbers
du nutzt ein int wo du nur ein byte brauchst

  for (size_t i = 0; i < sizeof(zeile); i++) {       // aufpassen, das klappt erst nach umstellen der Variable zeile auf byte!                
    pinMode(zeile[i], OUTPUT);
  }
  for (size_t i = 0; i < sizeof(spalte); i++) {                       
    pinMode(spalte[i], OUTPUT);
  }

du sollst auto nutzen (seit C++11):

  for (auto &i : zeile) {                       
    pinMode(i, OUTPUT);
  }
  for (auto &i : spalte {                       
    pinMode(i, OUTPUT);
  }

so jetzt du.

MicroBahner:
Du solltest vielleicht auch mal deine HW-Schaltung zeigen. So wie ich deinen Sketch verstehe, wird die Matrix vom Arduino dynamisch angesteuert, d.h. die Funktion 'zeige' muss zyklisch immer wieder aufgerufen werden, damit das Zeichen sichtbar bleibt. Das wird wichtig, wenn Du die Zeitsteuerung für deine Buchstaben aufbaust. Die darf dann nämlich nicht blockierend sein ( keine delay() ).

So eine „zu Fuß“ angesteuerte LED-Matrix habe ich mir neulich auch einmal gebaut. Ich habe mir eine Funktion zur Darstellung geschrieben, die in loop() immer wieder aufgerufen wird. Wenn man günstig programmiert, sind durchaus 100 loop()-Durchläufe pro Sekunde drin, d.h. das Display wird 100 mal pro Sekunde dargestellt.
@OP: Mach' Dich mit dem Strickmuster eines „endlichen Automaten“ vertraut. Evtl. hilft das hier.

Gruß

Gregor

Hier ein Schaltbild. NPN Transistoren für GND.

Und der Code den ich schnell kopiert habe um Zeichen hintereinander anzuzeigen...
Das muss noch auf millis() geändert werden.

5x5_bitread_-_HELLO_WORLD.ino (2.88 KB)

Ich habe die Hardware nicht, aber mir scheint theoretisch die Software nicht zur Hardware passend. Das ergibt für mich keinen Sinn:

     digitalWrite(spalte[i], bitRead (puffer[a], i));
      digitalWrite(spalte[i], 0);

So stelle ich es mir vor:

  • Zeilentransistor aus
  • alle Spalten auf 0 oder 1 setzen
  • Zeilentransistor ein
  • kurz warten, damit der Zeilentransistor durchsteuert und die LEDs leuchten

Was meint Gregor?

Jetzt habe ich den Code wie oben vorgeschlagen umgebaut.

Der Teil mit dem Umbauen von
for (int i = 4; i < 14; i++) {
pinMode(i, OUTPUT);
}
tut mir weh, da ich WIRKLICH NUR absolute Anfänger in meiner Klasse (14 jährige) habe. SO verstehen sie was passiert.

Daher ist meine einfache Schleife für die Schüler leichter zu verstehen als der auto Befehl
for (auto &i : zeile) {
pinMode(i, OUTPUT);
}
for (auto &i : spalte {
pinMode(i, OUTPUT);
}
… der zwar einwandfrei funktioniert, den ich in der Arduino Referenz nicht einmal gefunden habe.

Es fehlt mir nur eine Pause Funktion zwischen den einzelnen Buchstaben.
Meine bisherige Version mit dem timeCount += 1; dazwischen funktioniert nicht mehr.

UND… wie rufe ich eventuelle Sonderzeichen :slight_smile: auf?

5x5_-_NEU.ino (3.65 KB)

agmue:
Ich habe die Hardware nicht, aber mir scheint theoretisch die Software nicht zur Hardware passend. Das ergibt für mich keinen Sinn:

     digitalWrite(spalte[i], bitRead (puffer[a], i));

digitalWrite(spalte[i], 0);



So stelle ich es mir vor:

- Zeilentransistor aus **<==== ZEILENTRANSITOR EIN!! NPN Transistor damit Funktioniert die Matrix genau umgekehrt zu denen ohne Transistor.** 
- *Die Zeilen werden gegen GND geschaltet indem man den Transistor EINschaltet.**


- alle Spalten auf 0 oder 1 setzen
- Zeilentransistor ein **<=== siehe OBEN**


- kurz warten, damit der Zeilentransistor durchsteuert und die LEDs leuchten

Was meint Gregor?

agmue:
Was meint Gregor?

Ich verstehe den OP. Sein Code und die Schaltung sind eben so, wie es 14jährige verstehen. Mit dem Corona-Scheiß haben die schon mehr als genug am Hals.

Wenn die aktuelle Version zufriedenstellend funktioniert, ist es meiner Meinung nach an der Zeit, das Konzept von Klassen und Methoden anzugehen - das Display (die 5x5-Matrix) als Klasse zu abstrahieren, die eine Methode show() enthält. Diese Methode muss man dann lediglich in jedem loop()-Durchlauf aufrufen. Die Matrix als Klasse zu abstrahieren hält zudem das Hauptprogramm klein und übersichtlich.

Gruß

Gregor

tut mir dahingegen weh, da ich WIRKLICH NUR absolute Anfänger

deshalb hab ich dir ja auch die Schmalspurvariante gezeigt.
Aber das hardcoded 4…14 geht wirklich gar nicht.

Die Sonderzeichen hast ans ende des char-Table gepanscht. Also würde das mit
[

]
eigentlich eh funktionieren.

Besser: suche dir zunächst einen ANSI Zeichen dass du für dein Sonderzeichen verwenden möchtest

z.B. ‘}’ = 0x7D und wenn du das 0x7D hereinbekommst, wandelst auf deine tatsächliche Index-Position 28 (oder was auch immer).

so was in der Art:

    // convert character to a variable
    byte myIndex;
    if (toPrint[i] == '{') 
      myIndex = 28
    else
      myIndex = toPrint[i] - firstChar; // ASCII minus erstem Zeichen somit 0 für das erste Zeichen in deinem Char-Table

zur Ausgabe:
Das liegt aber an DEINER Zeichenausgabe.
imho musst die blockadefrei umschreiben.
Daher habe ich das nicht angegriffen :wink:

also mach zunächst ein nicht blockierendes “zeige()” auf Basis milis()/blinkWithoutDelay
dann strukturieren wir die Funktionen etwas um. Aber die blockadefreie zeige() muss von dir kommen.
Sonst will ich dein Lehrergehalt :wink:

PS: OOP würde ich noch nicht machen. Das klappt alles mit einer sauberen zeige() und einer einzigen weiteren globalen für den aktuellen Zeichenbuffer.

Nee, Du verstehst mich nicht. Mal ganz untechnisch:

  • Anzeige aller LEDs aus
  • alle Spalten auf 0 oder 1 setzen
  • Anzeige der LEDs in einer Zeile ein
  • kurz warten

Das für alle Zeilen wiederholen.

technischer Vorschlag,

Es wird nur das A ausgegeben.

Einfach die erste for schleife auflösen und in ein “BlinkWithoutDelay” Konstrukt überführen.
die variable a halt händisch mitführen.
Ganz ohne Tricks, sodass es ein anfänger verstehen kann.

zum Lernen:
was sind die Variablentypen,
was macht static

Den zeige Ablauf hab ich etwas angepasst. Macht für mich so mehr Sinn die LEDs weiterleuchten zu lassen.
(agmue findet das vermutlich auch besser, er schreibt es auch so in seinem Ablauf).

// https://forum.arduino.cc/index.php?topic=731407.0
// nonblocking - hardware test

const byte zeile[] = {4, 5, 6, 7, 8};
const byte spalte[] = {9, 10, 11, 12, 13};

const byte charTable[][5] = {                             // aus meiner Sicht ist die zweite Dimension (=jedes einzelne Zeichen) 5
  {0b01100, 0b10010, 0b11110, 0b10010, 0b10010},          //A
  {0b11100, 0b10010, 0b11110, 0b10010, 0b11100},          //B
  {0b01110, 0b10000, 0b10000, 0b10000, 0b01110},          //C
  {0b11100, 0b10010, 0b10010, 0b10010, 0b11100},          //D
  {0b11110, 0b10000, 0b11100, 0b10000, 0b11110},          //E
  {0b11110, 0b10000, 0b11100, 0b10000, 0b10000},          //F
  {0b01110, 0b10000, 0b10110, 0b10010, 0b11110},          //G
  {0b10010, 0b10010, 0b11110, 0b10010, 0b10010},          //H
  {0b00100, 0b00100, 0b00100, 0b00100, 0b00100},          //I
  {0b00100, 0b00100, 0b00100, 0b10100, 0b11100},          //J
  {0b10010, 0b10100, 0b11000, 0b10100, 0b10010},          //K
  {0b10000, 0b10000, 0b10000, 0b10000, 0b11110},          //L
  {0b10001, 0b11011, 0b10101, 0b10001, 0b10001},          //M
  {0b10010, 0b11010, 0b10110, 0b10010, 0b10010},          //N
  {0b01100, 0b10010, 0b10010, 0b10010, 0b01100},          //O
  {0b11100, 0b10010, 0b10010, 0b11100, 0b10000},          //P
  {0b01110, 0b10001, 0b10101, 0b10010, 0b01101},          //Q
  {0b11100, 0b10010, 0b11100, 0b10010, 0b10010},          //R
  {0b11110, 0b10000, 0b11110, 0b00010, 0b11110},          //S
  {0b11111, 0b00100, 0b00100, 0b00100, 0b00100},          //T
  {0b10010, 0b10010, 0b10010, 0b10010, 0b01100},          //U
  {0b10001, 0b10001, 0b10001, 0b01010, 0b00100},          //V
  {0b10001, 0b10001, 0b10101, 0b10101, 0b01110},          //W
  {0b10010, 0b10010, 0b01100, 0b10010, 0b10010},          //X
  {0b10001, 0b10001, 0b01110, 0b00100, 0b00100},          //Y
  {0b11110, 0b00010, 0b00100, 0b01000, 0b11110},          //Z
  {0b00000, 0b00000, 0b00000, 0b00000, 0b00111},          //_
  {0b11111, 0b11111, 0b11111, 0b11111, 0b11111},          //ALL <======== wie rufe ich diese Sonderzeichen auf ?
  {0b01010, 0b00000, 0b00100, 0b10001, 0b01110},          //smile <======== wie rufe ich diese Sonderzeichen auf ?
  {0b10001, 0b00100, 0b00000, 0b01110, 0b10001},          //frown <======== wie rufe ich diese Sonderzeichen auf ?
};

const byte firstChar = 'A';                            // mit welchem Zeichen beginnt der charTable

void setup() {
  Serial.begin(9600);

  for (size_t i = 0; i < sizeof(zeile); i++) {       // aufpassen, das klappt erst nach umstellen der Variable zeile auf byte!
    pinMode(zeile[i], OUTPUT);
  }
  for (size_t i = 0; i < sizeof(spalte); i++) {
    pinMode(spalte[i], OUTPUT);
  }

  // verwenden wir in einer späteren Variante wieder
  //   char myStr[] = "ABCD"; // Variable mit dem anzuzeigenden Text
  //   wort(myStr, sizeof(myStr) - 1);

}

void loop() {

  zeige(charTable['A' - firstChar]);          // das soll eigentlich ein A ausgeben

}

// muss noch etwas umgebaut werden
void wort(char *toPrint, size_t len)
{
  for (size_t i = 0; i < len; i++)
  {
    // convert character to a variable
    byte myIndex = toPrint[i] - firstChar; // ASCII minus erstem Zeichen somit 0 für das erste Zeichen in deinem Char-Table

    zeige(charTable[myIndex]);
    Serial.print(myIndex);      // Debug Meldungen - nur für mich zum kontrollieren, weil ich deine HW nicht habe
    Serial.print("\t");
    Serial.println(toPrint[i]);
    // evtl eine Zeitsteuerung, oder eine Verzögerung zwischen den Buchstaben
  }
}

//

// ***** Ausgabe an die 5x5 LED MAtrix ******
void zeige(const byte buffer2[]) {
  const byte interval = 10;                    // quasi die Zeilenfrequenz
  static unsigned long previousMillis = - interval; // statische Variable, damit sie den Funktionsablauf überlebt, initialisiert mit einem hohen Wert damit sie beim ersten Aufruf schon überfällig ist
  unsigned long currentMillis = millis();
  static byte a = 0;                           // ersetzt das "a" aus der ersten for schleife

  if (currentMillis - previousMillis > interval)
  {
    digitalWrite(zeile[a], 0);                // Anfangs schalten wir die alte(!) Zeile aus.
    a++;                                      // jetzt gehts weiter in der nächsten Zeile
    if (a > 4) a = 0;                         // Überlauf verhindern
    for (byte i = 0; i < 5; i++) {
      digitalWrite(spalte[i], bitRead (buffer2[a], i));
      // digitalWrite(spalte[i], 0);          // das braucht es meiner Meinung nicht, wir lassen weiter leuchten
    }
    digitalWrite(zeile[a], 1);                // da nun die Spalten passen, schalten wir die aktuelle Zeile ein
    // wir lassen die Zeile + alle Spalten leuchten bis zur nächsten Änderung!
    previousMillis = currentMillis;           // Zeitstempel merken für den nächsten durchlauf
  }
}


// ***** Ausgabe an die 5x5 LED MAtrix ******
// kann man löschen
void zeigeAlt(const byte buffer2[]) {
  for (int a = 0; a <= 4; a++) {
    digitalWrite(zeile[a], 1);
    for (int i = 0; i < 5; i++) {
      digitalWrite(spalte[i], bitRead (buffer2[a], i));
      digitalWrite(spalte[i], 0);
    }
    digitalWrite(zeile[a], 0);
  }
}

bitte um Prüfung mit Hardware.

Dann muss man noch die Wortausgabe anpassen, aber das ist dann nur mehr was kleines.
Erst muss mal das Zeichen blockadefrei gehen.

OK das zeigt auf der Hardware ein A.
GROSSER Vorteil ... das Ganze ist jetzt WESENTLICH HELLER!

2 Probleme....

  1. Das A steht auf dem Kopf. => habe ich gelöst durch Umkehrung der
    const byte zeile = {8,7,6,5,4};

  2. 10 als Intervall ist viel zu lang das flimmert wie verrückt. Bei 1 geht es gerade so aber ist eindeutig sichtbar...
    const byte interval = 1; // quasi die Zeilenfrequenz
    Die Zeilenfrequenz muss höher werden.

Jetzt fehlt eben noch der
// verwenden wir in einer späteren Variante wieder
// char myStr = "ABCD"; // Variable mit dem anzuzeigenden Text
// wort(myStr, sizeof(myStr) - 1);

Teil...
Einzelne Buchstaben gingen ja vorher schon.