Laufschrift LED Matrix

fl3xizzz:
ich habe ja immer 8 Zahlen für einen Buchstaben und dann muss ich ja die zwei Buchstaben mit den Werten kobinieren und das kriege ich nicht hin die zusammen zu rechnen...

Kannst Du dann mal Deinen Font (Deine Zahlen für die Zeichen) als Font-Datei posten, den Du verwendest?
Dann kann ich Dir was als Ansatz für diesen Font zusammenschreiben.

Allerdings nur zur testweisen Ausgabe auf der seriellen Schnittstelle, denn ich habe nicht so eine 8x8 Matrix.
Die Ausgabe von Serial auf LED umschreiben müßtest Du dann selbst.
Oder ich muß mir mal selbst so ein 8x8 Modul in China bestellen, die kosten glaube ich nicht so sehr viel.

Am besten du speicherst das Muster in einem int Array:

int pattern[8] =
{
B0111 1110 0111 1110,
B0100 0000 0100 0000,
B0100 0000 0100 0000,
B0111 1110 0100 0000,
B0100 0000 0100 0000,
B0100 0000 0100 0000,
B0111 1110 0111 1110,
B0000 0000 0000 0000
}

Ohne die Leerzeichen!! Die habe ich mal einfügt, damit man es besser lesen kann und sieht was was ist.

Das reicht für 16 Bits pro Zeile. Für mehr macht man einfach ein zwei-dimensionales Array draus und hängt in jeder Zeile noch mehr ints dran. Man kann auch long verwenden für 32 Bit pro Variable. Um das auzulesen gibt es bitRead():
http://arduino.cc/en/Reference/BitRead

Das gibt dir den Wert des jeweiligen Bits einer Variable zurück. Du kannst dann eine for-Schleife machen und einfach den Start-Index jedesmal eins höher setzen um mit einem anderen Bit anzufangen. Das sind dann wahrscheinlich mindestens 3 for-Schleifen ineinander, aber sowas solltest du schon haben.

      • x x x x x 248
      • x - - - - 8
      • x - - - - 8
      • x x x x - 120
      • x x x x - 120
      • x - - - - 8
      • x - - - - 8
      • x x x x x 248

so sieht ein E bei mir aus

Ok, dann hast du es schon in Bits gespeichert. :slight_smile:
Du willst dann wahrscheinlich ein mehr-dimensionales Array aus Bytes. Das ist einfacher für die Erstellung eines vollständigen Fonts. Das vorher war eher für eine festen String der sich nie ändert.

Für sowas ist auch der Modulo-Operator gut:
http://arduino.cc/de/Reference/Modulo

z.B. 8 % 8 = 0
9 % 8 = 1

Damit kann man Teile von zwei Buchstaben anzeigen. z.B. Bits 3-0 eines Bytes und danach Bits 7-4 eines weiteren Bytes. Dann hast du Teile von zwei Buchstaben. Im nächsten Durchlauf sind es dann Bits 2-0 und Bits 7-3, usw.

z.B. dieser Testcode:

	for(int i = 0; i < 3*8 + 1; i++)     //3 Zeichen mit je 8 Bit
	{
		Serial.print("Buchstabe ");
                Serial.print(i / 8);
		Serial.print(" - ab Index ");
                Serial.print(7 - (i % 8));

		if(i % 8 > 0)
		{
			Serial.print(" * Buchstabe ");
                        Serial.print(i / 8 + 1);
			Serial.print(" - bis Index ");
                        Serial.print(8 - (i % 8));
		}
		Serial.println();
	}

Das liefert:

Buchstabe 0 - ab Index 7 //alle Zeichen des 1. Buchstabens: Index 7 bis 0
Buchstabe 0 - ab Index 6 * Buchstabe 1 - bis Index 7 //1. Buchstabe von Index 6 bis 0. Dann den ersten Index (7) des zweiten Buchstabens
Buchstabe 0 - ab Index 5 * Buchstabe 1 - bis Index 6 //Index 5-0 und Index 7-6
Buchstabe 0 - ab Index 4 * Buchstabe 1 - bis Index 5 //Index 4-0 und Index 7-5
Buchstabe 0 - ab Index 3 * Buchstabe 1 - bis Index 4
Buchstabe 0 - ab Index 2 * Buchstabe 1 - bis Index 3
Buchstabe 0 - ab Index 1 * Buchstabe 1 - bis Index 2
Buchstabe 0 - ab Index 0 * Buchstabe 1 - bis Index 1
Buchstabe 1 - ab Index 7
Buchstabe 1 - ab Index 6 * Buchstabe 2 - bis Index 7
Buchstabe 1 - ab Index 5 * Buchstabe 2 - bis Index 6
Buchstabe 1 - ab Index 4 * Buchstabe 2 - bis Index 5
Buchstabe 1 - ab Index 3 * Buchstabe 2 - bis Index 4
Buchstabe 1 - ab Index 2 * Buchstabe 2 - bis Index 3
Buchstabe 1 - ab Index 1 * Buchstabe 2 - bis Index 2
Buchstabe 1 - ab Index 0 * Buchstabe 2 - bis Index 1
Buchstabe 2 - ab Index 7
Buchstabe 2 - ab Index 6 * Buchstabe 3 - bis Index 7
Buchstabe 2 - ab Index 5 * Buchstabe 3 - bis Index 6
Buchstabe 2 - ab Index 4 * Buchstabe 3 - bis Index 5
Buchstabe 2 - ab Index 3 * Buchstabe 3 - bis Index 4
Buchstabe 2 - ab Index 2 * Buchstabe 3 - bis Index 3
Buchstabe 2 - ab Index 1 * Buchstabe 3 - bis Index 2
Buchstabe 2 - ab Index 0 * Buchstabe 3 - bis Index 1
Buchstabe 3 - ab Index 7

Wenn man dann einen String hat, kann man über die Nummer des Buchstabens auf den jeweiligen Character Zugreifen. Bei einem kompletten Font kommt man über den char code auf den Speicherplatz des Buchstabens. Und über den Modulus kommt man auf die Anzahl der darzustellenden Bits des Buchstabens.

fl3xizzz:

      • x x x x x 248
      • x - - - - 8
      • x - - - - 8
      • x x x x - 120
      • x x x x - 120
      • x - - - - 8
      • x - - - - 8
      • x x x x x 248

so sieht ein E bei mir aus

Das ist jetzt aber nur die Codierung für ein einzelnes Zeichen.

Wenn Du eine Lauftext-Funktion haben möchtest, bei der Du mit einem einzigen Funktionsaufruf, z.B.

  showLauftext("Hallo Welt!");

beliebige Texte über die LED-Matrix scrollen lassen kannst, benötigst Du aber einen kompletten "Font", also alle Zeichen vom Leerzeichen (ASCII-32) bis mindestens zum Kleinbuchstaben z (ASCII-122). Also gute 90 verschiedene Zeichen als einen kompletten Font, der dann aus Platzgründen im Sketch am besten in Form von PROGMEM-Konstanten abgespeichert wird.

Hast Du keinen solchen kompletten Font in passender Größe für Deine LED-Matrix?
Soll ich mal im Internet nach einem passenden Font suchen?

Oder willst Du nur nach Bedarf genau diejenigen Buchstaben einzeln codieren, die in Deinen Texten Verwendung finden und gar keinen kompletten Font zur Ausgabe beliebiger Texte ins Programm packen?

Einen Font Editor gibt es hier:

Da sind glaube ich schon fertige Fonts drin.

Ist eine Excel Datei, die ein Addin benötigt

Serenifly:
Einen Font Editor gibt es hier:
http://www.instructables.com/id/LED-Scolling-Dot-Matrix-Font-Graphics-Generator-/?ALLSTEPS

Da sind glaube ich schon fertige Fonts drin.

Henning Karlson hat auf seiner Seite auch zwei kleine 8x8 Fonts, die er für seine UTFT-Library verwendet:
http://www.henningkarlsen.com/electronics/r_fonts.php

Die habe ich da jetzt mal einfach abgegriffen und in ein Testprogramm gepackt. Über das Entfernen von Kommentarstrichen kann das Programm also schon mal zwei verschiedene 8x8 Fonts darstellen.

Um RAM-Speicher zu sparen, sind die Fonts nicht im RAM abgelegt, sondern im PROGMEM-Speicher. Dadurch kann auf die Daten nicht einfach per Array-Index zugegriffen werden, sondern das Auslesen der Fontdaten aus dem PROGMEM erfolgt über die Funktion pgm_read_byte.

Da ich keine 8x8 LED Matrix habe und auch nicht weiß, wie die angesteuert wird, habe ich mal testweise eine Ausgabe der Animationsphasen auf Serial gemacht. Für die Ansteuerung echter LEDs muss noch die Funktion "void showPhase(byte phase)" angepasst werden. Wo im Testprogramm steht "Serial.print("X");" muß der Code zum Einschalten der LED stehen, wo im Testprogramm steht "Serial.print(" ");" muss der Code zum Ausschalten der LED stehen. Bei der Ausgabe auf Serial erfolgt die Ausgabe von links-oben nach rechts-unten. Falls die Steuer-Reihenfolge auf der LED-Matrix eine andere ist, müssen ggf. auch die Schleifen zur Ausgabe der einzelnen Bits angepaßt werden.

Code ist als Anhang beigefügt.

tinyFont.ino (10.3 KB)

Danke schön für die guten Antworten :slight_smile:
Das mit der Font ist auch richtig gut aber soweit bin ich ja noch nicht. Modulo ist mir bekannt, ich blicke aber noch nicht so ganz dahinter wie du das mit dem zusammen führen der Buchstaben meinst :confused: vielleicht kannst du es noch mal erklären.

fl3xizzz:
ich blicke aber noch nicht so ganz dahinter wie du das mit dem zusammen führen der Buchstaben meinst :confused: vielleicht kannst du es noch mal erklären.

Siehe meine Reply #1 und Reply #3.

Ein einzelner Buchstabe ist doch in Form von 8 Stück 8-Bit Zahlen ("Byte") gespeichert.
Nehmen wir mal das "A" wie es im tinyFont codiert ist:
0x38,0x6C,0xC6,0xFE,0xC6,0xC6,0xC6,0x00, // A

In diesen acht 8-Bit-Zahlen steht jedes gesetzte 1-Bit für eine eingeschaltete LED und jetzes nicht gesetzte 0-Bit für eine ausgeschaltete LED. Wenn Du die acht Zahlen mal in der Binärdarstellung darstellst, kann man die Buchstaben sogar schon richtig sehen, achte in der Binärdarstellung darauf, wo die "1" Bits stehen:

Buchstabe "A"
HEX   BIN
0x38= 0b00111000
0x6C= 0b01101100
0xC6= 0b11000110
0xFE= 0b11111110
0xC6= 0b11000110
0xC6= 0b11000110
0xC6= 0b11000110
0x00= 0b00000000

Erkennst Du das "A" in der Binärdarstellung?
Diese 64 Bits in der Binär-Matrix entsprechen den 64 LEDs in Deiner LED-Matrix.
Ein 1-Bit in der Binär-Matrix entspricht einer eingeschalteten LED.

Und wenn jetzt nicht 8 Bits nebeneinander in einer Zeile stehen, sondern 16 Bits, dann hast Du zwei Buchstaben nebeneinander stehen, so wie in Reply #3 mit der den beiden Buchstaben "E" und "C" als Kombination "EC" dargestellt (dort allerdings mit "X" für ein gesetztes Bit dargestellt).

Und nun legst Du über die 16x8 Darstellung der zwei Buchstaben ein 8x8 großes Fenster drüber, das Du Schritt für Schritt von links nach rechts verschiebst. Dann hast Du bei jedem Verschiebeschritt eine 8x8 große Zwischenphase im Ausschnitt, die dann dargestellt wird. So erscheint dann eine Phasenanimation, die in acht Schritten einen Buchstaben langsam nach links rausrollen läßt, während von rechts der nächste Buchstabe reinrollt.

Nachdem ich inzwischen auch so ein 8x8-LCD-Matrix Modul mit Max7219 besitze, habe ich das weiter oben skizzierte Konzept zur Darstellung einer Laufschrift einmal in ein Beispielprogramm umgesetzt.

// Laufschrift-Demo für 8x8 LED Matrix mit Max7219
// By 'jurs' for German Arduino Forum

/* Used Pins */
int Max7219_pinCLK = 10;
int Max7219_pinCS = 9;
int Max7219_pinDIN = 8;

#define NUMCHARS 37 // Kleiner Zeichensatz aus 37 Zeichen (0..9, A..Z und Leerzeichen)
const char chars[NUMCHARS+1]="0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ ";
const unsigned char disp1[NUMCHARS][8]={
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//0
{0x10,0x30,0x50,0x10,0x10,0x10,0x10,0x10},//1
{0x7E,0x2,0x2,0x7E,0x40,0x40,0x40,0x7E},//2
{0x3E,0x2,0x2,0x3E,0x2,0x2,0x3E,0x0},//3
{0x8,0x18,0x28,0x48,0xFE,0x8,0x8,0x8},//4
{0x3C,0x20,0x20,0x3C,0x4,0x4,0x3C,0x0},//5
{0x3C,0x20,0x20,0x3C,0x24,0x24,0x3C,0x0},//6
{0x3E,0x22,0x4,0x8,0x8,0x8,0x8,0x8},//7
{0x0,0x3E,0x22,0x22,0x3E,0x22,0x22,0x3E},//8
{0x3E,0x22,0x22,0x3E,0x2,0x2,0x2,0x3E},//9
{0x8,0x14,0x22,0x3E,0x22,0x22,0x22,0x22},//A
{0x3C,0x22,0x22,0x3E,0x22,0x22,0x3C,0x0},//B
{0x3C,0x40,0x40,0x40,0x40,0x40,0x3C,0x0},//C
{0x7C,0x42,0x42,0x42,0x42,0x42,0x7C,0x0},//D
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x7C},//E
{0x7C,0x40,0x40,0x7C,0x40,0x40,0x40,0x40},//F
{0x3C,0x40,0x40,0x40,0x40,0x44,0x44,0x3C},//G
{0x44,0x44,0x44,0x7C,0x44,0x44,0x44,0x44},//H
{0x7C,0x10,0x10,0x10,0x10,0x10,0x10,0x7C},//I
{0x3C,0x8,0x8,0x8,0x8,0x8,0x48,0x30},//J
{0x0,0x24,0x28,0x30,0x20,0x30,0x28,0x24},//K
{0x40,0x40,0x40,0x40,0x40,0x40,0x40,0x7C},//L
{0x81,0xC3,0xA5,0x99,0x81,0x81,0x81,0x81},//M
{0x0,0x42,0x62,0x52,0x4A,0x46,0x42,0x0},//N
{0x3C,0x42,0x42,0x42,0x42,0x42,0x42,0x3C},//O
{0x3C,0x22,0x22,0x22,0x3C,0x20,0x20,0x20},//P
{0x1C,0x22,0x22,0x22,0x22,0x26,0x22,0x1D},//Q
{0x3C,0x22,0x22,0x22,0x3C,0x24,0x22,0x21},//R
{0x0,0x1E,0x20,0x20,0x3E,0x2,0x2,0x3C},//S
{0x0,0x3E,0x8,0x8,0x8,0x8,0x8,0x8},//T
{0x42,0x42,0x42,0x42,0x42,0x42,0x22,0x1C},//U
{0x42,0x42,0x42,0x42,0x42,0x42,0x24,0x18},//V
{0x0,0x49,0x49,0x49,0x49,0x2A,0x1C,0x0},//W
{0x0,0x41,0x22,0x14,0x8,0x14,0x22,0x41},//X
{0x41,0x22,0x14,0x8,0x8,0x8,0x8,0x8},//Y
{0x0,0x7F,0x2,0x4,0x8,0x10,0x20,0x7F},//Z
{0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0},// [Space]
};


void Write_Max7219_byte(unsigned char DATA)
{
  unsigned char i;
  digitalWrite(Max7219_pinCS,LOW);		
  for(i=8;i>=1;i--)
  {		  
    digitalWrite(Max7219_pinCLK,LOW);
    digitalWrite(Max7219_pinDIN,DATA&0x80);//Obtain the MSB of the data
    DATA = DATA<<1;
    digitalWrite(Max7219_pinCLK,HIGH);
  }
}


void Write_Max7219(unsigned char address,unsigned char data)
{
  digitalWrite(Max7219_pinCS,LOW);
  Write_Max7219_byte(address);
  Write_Max7219_byte(data); 
  digitalWrite(Max7219_pinCS,HIGH);
}

void writeChar2Matrix(byte* databytes)
{
  int i;
  for(i=0;i<8;i++)
  {
    Write_Max7219(i+1,databytes[i]);
  }  
}

void Init_MAX7219(void)
{
 Write_Max7219(0x09, 0x00);       //decode: BCD
 Write_Max7219(0x0a, 0x03);       //Brightness
 Write_Max7219(0x0b, 0x07);       //
 Write_Max7219(0x0c, 0x01);       //
 Write_Max7219(0x0f, 0x00);       //
}



void setup()
{
  pinMode(Max7219_pinCLK,OUTPUT);
  pinMode(Max7219_pinCS,OUTPUT);
  pinMode(Max7219_pinDIN,OUTPUT);
  delay(50);
  Init_MAX7219();
}



void textloop(char* text)
{ 
  byte i,j,k;
  byte data[8];
  byte thischar, nextchar;
  for(j=0;j<strlen(text);j++)
  {
    thischar=strchr(chars,text[j])-chars; // Index des Buchstaben im disp1 Array
    // Index des nächsten Buchstaben im disp1 Array
    if (j+1<strlen(text)) nextchar=strchr(chars,text[j+1])-chars;
    else nextchar=strchr(chars,' ')-chars;
    
    for (k=0;k<8;k++)
    {
      for (i=0;i<8;i++)
      {
        data[i]=((unsigned int)disp1[thischar][i]<<8 | disp1[nextchar][i]) >>8-k;
      }
      writeChar2Matrix(data);
      delay(50);
    } 
  } 		
}

void loop()
{
 textloop(" LED 8X8 MATRIX LAUFSCHRIFT ");
}

Für ein reales Programm müßte man sicher noch RAM-Speicher sparen und die Font-Definition in den PROGMEM-Flashspeicher verschieben und anstelle der delay-Logik eine delayfreie Animation realisieren. Ist also mehr eine Proof-of-Concept-Demo, wie es gehen könnte, der Schrift das Laufen beizubringen.

Nur zur Vervollständigung des Threads mit ein wenig Demo-Code. :wink:

schön gemacht :slight_smile: läuft bei mir auch soweit.. kannst du mal bitte posten wie du die LEDs an den Max angeschlossen hast bei mir ist alles falsch rum :smiley:

fl3xizzz:
schön gemacht :slight_smile: läuft bei mir auch soweit.. kannst du mal bitte posten wie du die LEDs an den Max angeschlossen hast bei mir ist alles falsch rum :smiley:

Ich habe selbst gar nichts angeschlossen, sondern fertig gekauft!
Beim billigsten China-Händler auf eBay, den ich für die Matrix finden konnte. Artikelnummer (190867212840).
Und wohl dem Händler, der den längsten Postweg hat: Am 06.12. bestellt und am 23.01. geliefert.
Schaltbild habe ich dafür nicht.

Was heißt "alles falsch rum"?
Läuft die Schrift bei Dir um 90, 180, 270 Grad gedreht? Und ggf. spiegelverkehrt?

spiegelverkert

fl3xizzz:
spiegelverkert

Spiegelverkehrter Font zum Einsetzen statt des normalen Fonts im Quellcode:

unsigned char disp1[NUMCHARS][8]={
{0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, }, // 0
{0x8, 0xC, 0xA, 0x8, 0x8, 0x8, 0x8, 0x8, }, // 1
{0x7E, 0x40, 0x40, 0x7E, 0x2, 0x2, 0x2, 0x7E, }, // 2
{0x7C, 0x40, 0x40, 0x7C, 0x40, 0x40, 0x7C, 0x0, }, // 3
{0x10, 0x18, 0x14, 0x12, 0x7F, 0x10, 0x10, 0x10, }, // 4
{0x3C, 0x4, 0x4, 0x3C, 0x20, 0x20, 0x3C, 0x0, }, // 5
{0x3C, 0x4, 0x4, 0x3C, 0x24, 0x24, 0x3C, 0x0, }, // 6
{0x7C, 0x44, 0x20, 0x10, 0x10, 0x10, 0x10, 0x10, }, // 7
{0x0, 0x7C, 0x44, 0x44, 0x7C, 0x44, 0x44, 0x7C, }, // 8
{0x7C, 0x44, 0x44, 0x7C, 0x40, 0x40, 0x40, 0x7C, }, // 9
{0x10, 0x28, 0x44, 0x7C, 0x44, 0x44, 0x44, 0x44, }, // A
{0x3C, 0x44, 0x44, 0x7C, 0x44, 0x44, 0x3C, 0x0, }, // B
{0x3C, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3C, 0x0, }, // C
{0x3E, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3E, 0x0, }, // D
{0x3E, 0x2, 0x2, 0x3E, 0x2, 0x2, 0x2, 0x3E, }, // E
{0x3E, 0x2, 0x2, 0x3E, 0x2, 0x2, 0x2, 0x2, }, // F
{0x3C, 0x2, 0x2, 0x2, 0x2, 0x22, 0x22, 0x3C, }, // G
{0x22, 0x22, 0x22, 0x3E, 0x22, 0x22, 0x22, 0x22, }, // H
{0x3E, 0x8, 0x8, 0x8, 0x8, 0x8, 0x8, 0x3E, }, // I
{0x3C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x12, 0xC, }, // J
{0x0, 0x24, 0x14, 0xC, 0x4, 0xC, 0x14, 0x24, }, // K
{0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x2, 0x3E, }, // L
{0x81, 0xC3, 0xA5, 0x99, 0x81, 0x81, 0x81, 0x81, }, // M
{0x0, 0x42, 0x46, 0x4A, 0x52, 0x62, 0x42, 0x0, }, // N
{0x3C, 0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x3C, }, // O
{0x3C, 0x44, 0x44, 0x44, 0x3C, 0x4, 0x4, 0x4, }, // P
{0x38, 0x44, 0x44, 0x44, 0x44, 0x64, 0x44, 0xB8, }, // Q
{0x3C, 0x44, 0x44, 0x44, 0x3C, 0x24, 0x44, 0x84, }, // R
{0x0, 0x78, 0x4, 0x4, 0x7C, 0x40, 0x40, 0x3C, }, // S
{0x0, 0x7C, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, }, // T
{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x44, 0x38, }, // U
{0x42, 0x42, 0x42, 0x42, 0x42, 0x42, 0x24, 0x18, }, // V
{0x0, 0x92, 0x92, 0x92, 0x92, 0x54, 0x38, 0x0, }, // W
{0x0, 0x82, 0x44, 0x28, 0x10, 0x28, 0x44, 0x82, }, // X
{0x82, 0x44, 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, }, // Y
{0x0, 0xFE, 0x40, 0x20, 0x10, 0x8, 0x4, 0xFE, }, // Z
{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, }, //  
};

Deinen Code finde ich echt gut :slight_smile: für mich als Anfänger ist es schwierig sowas zu lesen aber ich habe mich schon mal da durch gearbeitet. Wo ich noch nicht so durch blicke ist das eigentliche verschieben.

    for (k=0;k<8;k++)
    {
      for (i=0;i<8;i++)
      {
        data[i]=((unsigned int)disp1[thischar][i]<<8 | disp1[nextchar][i]) >>8-k;
      }
      writeChar2Matrix(data);
      delay(50);
    }

Vom Aufbau hab ich es so halb verstanden. Du nimmst den geschobenen Buchstaben und packst ihn in ein Array mit 8 Plätzen und das wiederholst du halt 8x. Die Ausgabe und das Delay sind mir klar aber könntest du den Rest noch ein mal für Anfänger erklären?

fl3xizzz:

    for (k=0;k<8;k++)

{
      for (i=0;i<8;i++)
      {
        data[i]=((unsigned int)disp1[thischar][i]<<8 | disp1[nextchar][i]) >>8-k;
      }
      writeChar2Matrix(data);
      delay(50);
    }




Vom Aufbau hab ich es so halb verstanden. Du nimmst den geschobenen Buchstaben und packst ihn in ein Array mit 8 Plätzen und das wiederholst du halt 8x. Die Ausgabe und das Delay sind mir klar aber könntest du den Rest noch ein mal für Anfänger erklären?

Eigentlich habe ich es in Reply #1, #3 und #9 in diesem Thread schon dreimal erklärt.

Ein Byte hat 8 Bits, und immer 8 Bytes mal 8 Bits = 64 Bits stehen für die 64 LEDs auf dem Anzeigemodul.

Jeder Buchstabe besteht aus 8 Bytes a 8 Bits, und wenn man sich zwei Buchstaben nebeneinanderlegt bekommt man 8 words a 16 bits. Und aus diesem 8x16 Raster greift man sich dann jeweils ein 8x8 Raster heraus, als Übergang von einem Buchstaben auf den nächsten. Der so pro Phase neu berechnete "Übergangsbuchstabe", der auch wieder aus 8 Bytes a 8 Bits besteht, wird dann auf der LED-Matrix dargestellt.

ich meinte auch eigentlich, dass du mir die Zeilen mit den Behfehlen erklärst. Ich bin am basteln und probieren aber aber ich kriege einen letzten Fehler nicht weg. Er schiebt den Buchstabe von rechts nach links komplett rein bis er komplett zu sehen ist dann geht der Buchstabe aus und es dauert kurz und dann kommt der nächste. Also der Buchstabe steht auf der rechten seite komplett.

data[i]=((unsigned int)disp1[thischar][i]>>8 | disp1[nextchar][i]) <<8-k;

so habe ich es geändert.

fl3xizzz:

data[i]=((unsigned int)disp1[thischar][i]>>8 | disp1[nextchar][i]) <<8-k;

so habe ich es geändert.

Warum geändert? Was möchtest Du bewirken? Damit löschst Du einen der beiden Buchstaben immer komplett aus!

Der Code auf der rechten Seite vom Gleichheitszeichen "(unsigned int) x<<8 | y" bedeutet:

Mache aus der 8-Bit Variablen x eine 16-Bit Variable (unsigned int) und schiebe die Bits um 8 Stellen nach links.
Aus der 8-Bit Variablen mit dem angenommenen Wert x== 0b10101010 würde zunächst
(unsigned int) x == 0b0000000010101010 (eine 16 Bit-Variable) und dann die Bits um 8 Stellen nach links geschoben
(unsigned int) x << 8 = 0b1010101000000000 (fehlende Stellen rechts werden beim Schieben mit 0 aufgefüllt)
dann wird eine bitweise Oder-Verknüpfung ("|") mit der Variablen y gemacht. y sei mal angenommen 0b00001111.

0b1010101000000000 |
0b0000000000001111 =
0b1010101000001111

Am Ende wird der Wert bei meinem Code um den Betrag 8-k nach rechts geschoben (">>8-k")
Für die Werte k=8 bis k=0 ergeben sich also verschiebungen von 0 bis 8 bits.
Und das niederwertigste Byte (die acht untersten Bits) werden dann als Daten dargestellt. Je nachdem, wie oft geschoben wird, ergibt sich für die LED-Zeile nacheinander das Muster:

1010101000001111
0101010100000111
0010101010000011
0001010101000001
0000101010100000
0000010101010000
0000001010101000
0000000101010100
0000000010101010
Wovon die 8 Bits an der rechten Seite als LED-Zeile nacheinander dargestellt werden
00001111
00000111
10000011
01000001
10100000
01010000
10101000
01010100
10101010

Wohlgemerkt, als zeitliche Abfolge ein und derselben LED-Zeile nacheinander. Das erfolgt natürlich immer für 8 LED-Zeilen a 8 Bits, also pro Schritt für insgesamt 64 LEDs.

Der von Dir geänderte Code, mit dem eine Byte-Variable um 8 Stellen nach rechts geschoben werden, z.B.
disp1[thischar][i]>>8 ist völlig sinnlos und könnte auch durch disp1[thischar][i]=0 ersetzt werden. Denn wenn Du in einer 8-Bit Variablen achtmal rechts eine Stelle rausschiebst und links mit einer Null auffüllst, bestehen danach alle 8 Bits in jedem Fall nur aus Nullen. Also "alles aus".

Ahhh es hat glaube ich so langsam Klick gemacht bei mir :smiley:

Aber ich will ja nicht sinnlos kopieren, ich will es ja verstehen. Danke schön noch mal :slight_smile:
Werde es mal versuchen mit eigenem Code umzusetzen. Eine Frage habe ich aber noch, wie sieht das aus wenn ich nun einen dritten Buchstaben habe das wird mir aus deinem Code nicht ganz klar ich kann es mir vorstellen.... wäre nett wenn du mir das noch beantworten könntest.

:slight_smile: