Weitere Artikel aus dem Elo-Magazin

Eine kleine Laufschrift auf der Ping-Pong-Platine

von Sascha Bader

Mit der Ping-Pong-Platine und ihren vielen hellen LEDs kann man prima eine Laufschrift realisieren, bei der ein Text Buchstabe für Buchstabe über die Anzeige läuft. Im Grunde funktioniert so eine Laufschrift recht simpel. Es wird einfach der Inhalt der Anzeige verschoben und der leer gewordene Bereich auf der rechten Seite mit Inhalt aus dem Text aufgefüllt, so dass die Buchstaben von rechts nach links über die Anzeige wandern.

Ganzen Artikel lesen...

Der Knackpunkt ist dabei, dem Mikrocontroller beizubringen, wie die Schriftzeichen aussehen sollen und wie sie gezeichnet werden. Ein einfacher Ansatz ist es, für jeden Buchstaben zu definieren, welche LED an und welche aus sein soll. Baut man die Buchstaben aus 8*10 LEDs auf, so benötigt man, da 8 LEDs durch ein Byte beschrieben werden, 1280 Bytes für den ASCII-Zeichensatz mit 128 Zeichen. Diese passen, inklusive eines kleinen Textes und des Steuerprogramms, noch ohne Probleme in den Flash-Speicher des Mikrocontrollers.

Zum Programm

Das Programm ist in C realisiert. Nach den schönen Programmbeispielen in Basic (Bascom) mag es vielleicht für den einen oder anderen interessant sein, wie man das Ping-Pong in C programmieren kann. Das ist zwar etwas komplizierter, weil man viele Funktionen, die Bascom schon vorgefertigt bereitstellt, mühsam selbst programmieren muss, aber dafür hat man dann auch vollen Zugriff auf die Hardware und kann das letzte aus dem Mikrocontroller herauskitzeln. Außerdem lassen sich leistungsfähige Entwicklungstools, wie WinAVR, AVR-Studio oder Eclipse (mit AVR Plugin) nutzen, die frei oder kostenlos verfügbar sind.

Die Anzeige funktioniert ganz ähnlich wie bei den Basic Beispielen. Die Informationen für alle LEDs, das sind 12 Spalten mit je 10 LEDs, werden in einem Array mit 12 „16 Bit Werten" abgelegt. Für jede Spalte werden dabei nur jeweils 10 Bit verwendet. Aber mit dieser „kleinen Speicherverschwendung" kann man gut leben.

Da der Mikrocontroller nicht genügend Ausgänge hat, um alle LEDs einzeln zu schalten, muss man ein wenig „tricksen", indem man die LEDs der einzelnen Anzeigespalten schnell nacheinander aufleuchten lässt. Wenn man das schnell genug macht, dann bemerkt das Auge diesen Trick nicht. Dieses Verfahren nennt man „Multiplexing" (siehe auch www.mikrocontroller.net/articles/LED-Matrix).

Dazu wird einer der eingebauten Timer des Mikrocontrollers so programmiert, dass er etwa alle zwei Millisekunden einen "Overflow"-Interrupt auslöst und eine Routine aufruft, die das „Multiplexing" erledigt. Dort wird die entsprechende Spalte per Schieberegister aktiviert und das Bitmuster für die 10 LEDs der Spalte auf die Ports B,C und D verteilt ausgegeben.

Die eigentliche Verarbeitung der Laufschrift geschieht in der Hauptschleife der main()-Funktion. Diese verschiebt zyklisch den Inhalt der Anzeige um eine Spalte nach links und gibt eine Spalte des jeweils aktuellen Textzeichens am rechten Rand aus. Nach 8 Verschiebungen (ein Zeichen ist 8 Bit breit) wird dann ein neuer Buchstabe aus dem Text geholt und das nächste Zeichen verarbeitet. Das Ende des Texts wird durch ein „~" markiert, das bewirkt, dass wieder zum Anfang des Texts gesprungen wird.

Projekt

Der Sourcecode kann mit AVR Studio oder mit WinAVR übersetzt werden. Auch die Projektdefinitionen für die leistungsfähige Entwicklungsumgebung Eclipse sind enthalten, so dass es sich als „Existing Projekt" in den „Workspace" importieren lässt. Man benötigt aber das Plugin „AVR Eclipse" (siehe http://avr-eclipse.sourceforge.net/wiki/index.php/The_AVR_Eclipse_Plugin).

Ausblick

Natürlich gibt es noch allerhand Verbesserungs- und Erweiterungsmöglichkeiten. Denkbar sind z.B. Effekte, wie eine blinkende Anzeige oder Zeichen, die nach oben oder unten verschwinden bzw. rollen, wie man es von den Anzeigen mancher Flipperautomaten kennt.
Fortgeschrittene können sich überlegen, ob man nicht mehrere Ping-Pong-Boards miteinander vernetzen und zu einer großen Anzeige kombinieren kann.

Download: Quelltext und Hex-Datei: Laufschrift.zip

Laufschrift.c:

/*
* laufschrift.c
*
* Ein einfache "Laufschrift" auf dem Ping-Pong Board.
*
* Kompilierbar mittels AVR Studio 4 oder WinAVR
*
* Der Sourcecode und das Hexfile dürfen frei verwendet werden.
* Nutzung erfolgt auf eigene Gefahr.
*
* Ver. Date Author Comments
* ------- ---------- -------------- ------------------------------
* 1.00 07.11.2009 Sascha Bader initial
*/

/* -----------------------------------------
* Defines (Präprozessor Makros)
* -----------------------------------------*/

#define F_CPU 8000000UL /* CPU Takt (für delay-Routine) */

#define WIDTH 12 /* Breite des Displays */
#define HEIGHT 10 /* Höhe des Displays */
#define FONTWIDTH 8 /* Breite des Zeichensatzes */
#define FONTHEIGHT 10 /* Höhe des Zeichensatzes */

#define GetPixel(x,y) leds[y]&(1<<x) /* Makro: Ein "Pixel" auslesen */
#define SetPixel(x,y) leds[y]|=1<<x /* Makro: Ein "Pixel" setzen */
#define ClearPixel(x,y) leds[y]&=~(1<<x) /* Makro: Ein "Pixel" löschen */

/* -----------------------------------------
* Includes
* -----------------------------------------*/
#include <inttypes.h> /* Definition der Datentypen uint8_t usw. */
#include <avr/interrupt.h> /* Interruptbehandlungsroutinen (für Timerinterrupt) */
#include <avr/delay.h> /* Definition der Verzögerungsfunktionen (_delay_ms) */
#include <avr/pgmspace.h> /* Hilfsfunktionen um Daten aus dem Flash zu lesen */
#include "font.h" /* Definition des Zeichensatzes */

/* -----------------------------------------
* Globale Variablen
* -----------------------------------------*/
uint16_t leds[WIDTH]; /* Inhalt der LED-Matrix */
prog_uint8_t * fnt = (prog_uint8_t *) font; /* Zeiger auf den Zeichensatz im Flash */
volatile uint8_t col = 0; /* Aktuelle Spalte (für Interruptroutine)
"volatile", da durch Interrupt verändert */

/* -----------------------------------------
* Text der Laufschrift (Globele Variable)
* -----------------------------------------*/
prog_uint8_t text[] =
" Es gibt eine Theorie, die besagt, wenn jemals irgendwer genau herausfindet,\
wozu das Universum da ist und warum es da ist, dann verschwindet es auf der Stelle\
und wird durch noch etwas Bizarreres und Unbegreiflicheres ersetzt.\
- Es gibt eine andere Theorie, nach der das schon passiert ist. \
~"; /* Ende-Kennzeichen (nicht vergessen) */

/* -----------------------------------------
* Prototypen der Funktionen
* -----------------------------------------*/
void PrintScrollColumn(uint8_t c, int pixelx, int y);
void ScrollLeft(void);

/* -------------------------------------------------------------------------
* Main Funktion
*
* Initialisiert den Timer Interrupt und
* behandelt die Laufschrift
* -------------------------------------------------------------------------*/
int main(void)
{
uint8_t * tpos;
uint8_t softx;

cli(); // Interrupts sperren (damit keiner dazwischenfunkt)

/*---------------------------------------------------
* Ports konfigurieren (Ein-/Ausgänge)
*---------------------------------------------------*/
DDRC = 0x0f; // ( 0x0f PORTC als AD-Eingang)
DDRB = 0xff; // Portb = Output
DDRD = 0xff; // Portd = Output

/*---------------------------------------------------------------------------
* 8-Bit Timer TCCR0 für das Multiplexing der LEDs initialisieren
* Es wird ca. alle 2 Mikrosekunden ein Overflow0 Interrupt ausgelöst
* Berechnung: T = Vorteiler * Wertebereich Zähler / Taktfreuenz
* = 64 * 256 / ( 8000000 Hz ) = 2,048 ms
*---------------------------------------------------------------------------*/
TCCR0 |= (1<<CS01) | (1<<CS00); // 8-bit Timer mit 1/64 Vorteiler
TIFR |= (1<<TOV0); // Clear overflow flag (TOV0)
TIMSK |= (1<<TOIE0); // timer0 will create overflow interrupt

sei(); // Interrupts erlauben

/*---------------------------------------------------
* Hauptschleife (Laufschrift erzeugen)
*---------------------------------------------------*/
while(1) // Endlosschleife
{
for (tpos=text;pgm_read_byte(tpos)!='~';tpos++) // Aktuelles Zeichen lesen
{
for (softx=0;softx<FONTWIDTH;softx++) // Pixel des Zeichens abarbeiten
{
ScrollLeft(); // Platz schaffen und Zeilen nach links schieben
PrintScrollColumn(pgm_read_byte(tpos),softx,0); // Ganz rechts eine Spalte des Zeichens ausgeben
_delay_ms(35); // Ein bischen warten damit es nicht zu schnell wird
}
}
}
return 0;
}

/* -------------------------------------------------------------------------
* Funktion PrintScrollColumn
*
* Aktualisiert die Spalte ganz rechts mit
* einem 1 "Pixel" breitem Ausschnitt des
* Lauftextes.
*
* \param c Auszugebendes Zeichen
* \param pixelx Auszugebende Spalte des Zeichens
* \param y Vertikale Vverschiebnung
* -------------------------------------------------------------------------*/
void PrintScrollColumn(uint8_t c, int pixelx, int y)
{
unsigned char fontbyte = 0;
uint8_t pixelpos;
uint8_t fonty;
uint8_t mask;

pixelpos = pixelx & 0x07; /* Auf 8 Pixel pro Zeichen limitieren */

for (fonty=0;fonty<FONTHEIGHT;fonty++)
{
fontbyte = pgm_read_byte_near(fnt+c*FONTHEIGHT+fonty); /* Ein Byte (Zeile) des aktuellen Zeichens lesen */

mask = 1<<pixelpos; /* Maske auf die gewünschte Spalte zurechtschieben */
if ((fontbyte & mask) != 0) /* Prüfen ob das Bit in der Spalte des Zeichens gesetzt ist */
{
leds[WIDTH-1]|=1<<fonty; /* Setzen eines Pixels im Display ganz rechts */
}
else
{
leds[WIDTH-1]&=~(1<<fonty); /* Löschen eines Pixels im Display ganz rechts */
}
}
}

/* -------------------------------------------------------------------------
* Funktion ScrollLeft
*
* Verschiebt den Inhalt LED-Matrix um eine Spalte nach links.
* Die erste Spalte tritt dabei an die Position der letzten Spalte.
* -------------------------------------------------------------------------*/
void ScrollLeft(void)
{
uint8_t xcol; /* Spaltenzähler */
uint16_t first; /* Zwischenspeicher der ersten Spalte */

first = leds[0]; /* Erste Spalte sichern */
for (xcol=0;xcol<WIDTH-1;xcol++)
{
leds[xcol]=leds[xcol+1]; /* Spalten nach links verschieben */
}
leds[WIDTH-1] = first; /* Erste Spalte an letzte Spalte kopieren */
}

/* -------------------------------------------------------------------------
* Interrupt Routine
*
* Gibt nacheinander alle Spalten mit LED-Daten aus.
* Dazu wird mittels der Schieberegister die aktuelle Spalte
* ausgewählt und dann das Bitmuster derselben auf die Ports
* gegeben.
* Beim nächsten Interrupt ist dann die nächste Spalte dran.
* -------------------------------------------------------------------------*/
// interrupt routine
SIGNAL (SIG_OVERFLOW0)
{
uint16_t ledval;
uint8_t portcout;
uint8_t portdout;

cli(); /* Interrupts verbieten */

/*--------------------------------------------------
* Aktuelle Spalte ermitteln
*--------------------------------------------------*/
col++;
if (col == 12)
{
col = 0;
}

/*--------------------------------------------------
* Ports initialisieren
*--------------------------------------------------*/
PORTD = 0;
PORTB = 0;
PORTC = 0;

/*---------------------------------------------------
* Eine einzelne 0 durch die Schiebergister schieben
*---------------------------------------------------*/
if ( col == 0 )
{
PORTB &= ~(1 << 4); /* Bei der ersten Spalte eine 0 ausgeben (PB4 = 0) */
/* Diese 0 geht auf die Reise durch die Schieberegister */
}
else
{
PORTB |= (1 << 4); /* Danach Einsen hinterherschicken (PB4 = 1) */
}

/*---------------------------------------------------
* Impulse für die Schieberegister generieren
*---------------------------------------------------*/
PORTB |= (1 << 3); /* PB3 = 1 (cl) */
PORTB &= ~(1 << 3); /* PB3 = 0 (!cl) */

PORTB |= (1 << 2); /* PB2 = 1 (str) */
PORTB &= ~(1 << 2); /* PB2 = 0 (!str) */

/*---------------------------------------------------
* Daten der Spalte holen und auf die Ports verteilen
*---------------------------------------------------*/
ledval = leds[col];
portdout = ledval & 0xff; /* low byte */
portcout = portdout & 0x0f; /* low nibble */
portdout = portdout & 0xf0; /* high nibble */

PORTD = portdout & 0xff;
PORTC = portcout & 0xff;
PORTB = (ledval >> 8) & 0x03; /* high byte */

sei(); /* Interrupts wieder erlauben */
}

font.h:

#include <avr/pgmspace.h>

prog_uint8_t font[128][10] = {
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x00
{0x7E,0xC3,0x81,0xA5,0x81,0xBD,0x99,0xC3,0x7E,0x00}, // 0x01
{0x7E,0xFF,0xFF,0xDB,0xFF,0xC3,0xE7,0xFF,0x7E,0x00}, // 0x02
{0x00,0x22,0x77,0x7F,0x7F,0x7F,0x3E,0x1C,0x08,0x00}, // 0x03
{0x08,0x1C,0x3E,0x7F,0x7F,0x3E,0x1C,0x08,0x00,0x00}, // 0x04
{0x18,0x3C,0x3C,0xFF,0xE7,0xE7,0x18,0x18,0x7E,0x00}, // 0x05
{0x18,0x3C,0x7E,0xFF,0xFF,0x7E,0x18,0x18,0x7E,0x00}, // 0x06
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x07
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x08
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x09
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x0A
{0x7C,0x70,0x5C,0x4E,0x1F,0x33,0x33,0x33,0x1E,0x00}, // 0x0B
{0x3C,0x66,0x66,0x66,0x3C,0x18,0x7E,0x18,0x18,0x00}, // 0x0C
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x0D
{0xFE,0xC6,0xFE,0xC6,0xC6,0xC6,0xE6,0xE7,0x67,0x03}, // 0x0E
{0x00,0x18,0xDB,0x7E,0xE7,0xE7,0x7E,0xDB,0x18,0x00}, // 0x0F
{0x01,0x03,0x07,0x1F,0x7F,0x1F,0x07,0x03,0x01,0x00}, // 0x10
{0x40,0x60,0x70,0x7C,0x7F,0x7C,0x70,0x60,0x40,0x00}, // 0x11
{0x18,0x3C,0x7E,0x18,0x18,0x18,0x7E,0x3C,0x18,0x00}, // 0x12
{0x66,0x66,0x66,0x66,0x66,0x00,0x00,0x66,0x66,0x00}, // 0x13
{0xFE,0xDB,0xDB,0xDB,0xDE,0xD8,0xD8,0xD8,0xD8,0x00}, // 0x14
{0x7E,0xC6,0x0C,0x3C,0x66,0x66,0x3C,0x30,0x63,0x7E}, // 0x15
{0x00,0x00,0x00,0x00,0x00,0x00,0x7F,0x7F,0x7F,0x00}, // 0x16
{0x18,0x3C,0x7E,0x18,0x18,0x18,0x7E,0x3C,0x18,0x7E}, // 0x17
{0x18,0x3C,0x7E,0x18,0x18,0x18,0x18,0x18,0x18,0x00}, // 0x18
{0x18,0x18,0x18,0x18,0x18,0x18,0x7E,0x3C,0x18,0x00}, // 0x19
{0x00,0x00,0x18,0x30,0x7F,0x30,0x18,0x00,0x00,0x00}, // 0x1A
{0x00,0x00,0x0C,0x06,0x7F,0x06,0x0C,0x00,0x00,0x00}, // 0x1B
{0x00,0x00,0x00,0x03,0x03,0x03,0x7F,0x00,0x00,0x00}, // 0x1C
{0x00,0x00,0x24,0x66,0xFF,0x66,0x24,0x00,0x00,0x00}, // 0x1D
{0x00,0x08,0x08,0x1C,0x1C,0x3E,0x3E,0x7F,0x7F,0x00}, // 0x1E
{0x00,0x7F,0x7F,0x3E,0x3E,0x1C,0x1C,0x08,0x08,0x00}, // 0x1F
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x20
{0x0C,0x1E,0x1E,0x1E,0x0C,0x0C,0x00,0x0C,0x0C,0x00}, // 0x21
{0x66,0x66,0x66,0x24,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x22
{0x36,0x36,0x7F,0x36,0x36,0x36,0x7F,0x36,0x36,0x00}, // 0x23
{0x0C,0x3E,0x03,0x03,0x1E,0x30,0x30,0x1F,0x0C,0x0C}, // 0x24
{0x00,0x00,0x23,0x33,0x18,0x0C,0x06,0x33,0x31,0x00}, // 0x25
{0x0E,0x1B,0x1B,0x0E,0x5F,0x7B,0x33,0x3B,0x6E,0x00}, // 0x26
{0x0C,0x0C,0x0C,0x06,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x27
{0x30,0x18,0x0C,0x06,0x06,0x06,0x0C,0x18,0x30,0x00}, // 0x28
{0x06,0x0C,0x18,0x30,0x30,0x30,0x18,0x0C,0x06,0x00}, // 0x29
{0x00,0x00,0x66,0x3C,0xFF,0x3C,0x66,0x00,0x00,0x00}, // 0x2A
{0x00,0x00,0x18,0x18,0x7E,0x18,0x18,0x00,0x00,0x00}, // 0x2B
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x1C,0x06}, // 0x2C
{0x00,0x00,0x00,0x00,0x7F,0x00,0x00,0x00,0x00,0x00}, // 0x2D
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1C,0x1C,0x00}, // 0x2E
{0x00,0x40,0x60,0x30,0x18,0x0C,0x06,0x03,0x01,0x00}, // 0x2F
{0x3E,0x63,0x73,0x7B,0x6B,0x6F,0x67,0x63,0x3E,0x00}, // 0x30
{0x08,0x0C,0x0F,0x0C,0x0C,0x0C,0x0C,0x0C,0x3F,0x00}, // 0x31
{0x1E,0x33,0x33,0x30,0x18,0x0C,0x06,0x33,0x3F,0x00}, // 0x32
{0x1E,0x33,0x30,0x30,0x1C,0x30,0x30,0x33,0x1E,0x00}, // 0x33
{0x30,0x38,0x3C,0x36,0x33,0x7F,0x30,0x30,0x78,0x00}, // 0x34
{0x3F,0x03,0x03,0x03,0x1F,0x30,0x30,0x33,0x1E,0x00}, // 0x35
{0x1C,0x06,0x03,0x03,0x1F,0x33,0x33,0x33,0x1E,0x00}, // 0x36
{0x7F,0x63,0x63,0x60,0x30,0x18,0x0C,0x0C,0x0C,0x00}, // 0x37
{0x1E,0x33,0x33,0x33,0x1E,0x33,0x33,0x33,0x1E,0x00}, // 0x38
{0x1E,0x33,0x33,0x33,0x3E,0x18,0x18,0x0C,0x0E,0x00}, // 0x39
{0x00,0x00,0x1C,0x1C,0x00,0x00,0x1C,0x1C,0x00,0x00}, // 0x3A
{0x00,0x00,0x1C,0x1C,0x00,0x00,0x1C,0x1C,0x18,0x0C}, // 0x3B
{0x30,0x18,0x0C,0x06,0x03,0x06,0x0C,0x18,0x30,0x00}, // 0x3C
{0x00,0x00,0x00,0x7E,0x00,0x7E,0x00,0x00,0x00,0x00}, // 0x3D
{0x06,0x0C,0x18,0x30,0x60,0x30,0x18,0x0C,0x06,0x00}, // 0x3E
{0x1E,0x33,0x30,0x18,0x0C,0x0C,0x00,0x0C,0x0C,0x00}, // 0x3F
{0x3E,0x63,0x63,0x7B,0x7B,0x7B,0x03,0x03,0x3E,0x00}, // 0x40
{0x0C,0x1E,0x33,0x33,0x33,0x3F,0x33,0x33,0x33,0x00}, // 0x41
{0x3F,0x66,0x66,0x66,0x3E,0x66,0x66,0x66,0x3F,0x00}, // 0x42
{0x3C,0x66,0x63,0x03,0x03,0x03,0x63,0x66,0x3C,0x00}, // 0x43
{0x1F,0x36,0x66,0x66,0x66,0x66,0x66,0x36,0x1F,0x00}, // 0x44
{0x7F,0x46,0x06,0x26,0x3E,0x26,0x06,0x46,0x7F,0x00}, // 0x45
{0x7F,0x66,0x46,0x26,0x3E,0x26,0x06,0x06,0x0F,0x00}, // 0x46
{0x3C,0x66,0x63,0x03,0x03,0x73,0x63,0x66,0x7C,0x00}, // 0x47
{0x33,0x33,0x33,0x33,0x3F,0x33,0x33,0x33,0x33,0x00}, // 0x48
{0x1E,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00}, // 0x49
{0x78,0x30,0x30,0x30,0x30,0x33,0x33,0x33,0x1E,0x00}, // 0x4A
{0x67,0x66,0x36,0x36,0x1E,0x36,0x36,0x66,0x67,0x00}, // 0x4B
{0x0F,0x06,0x06,0x06,0x06,0x46,0x66,0x66,0x7F,0x00}, // 0x4C
{0x63,0x77,0x7F,0x7F,0x6B,0x63,0x63,0x63,0x63,0x00}, // 0x4D
{0x63,0x63,0x67,0x6F,0x7F,0x7B,0x73,0x63,0x63,0x00}, // 0x4E
{0x1C,0x36,0x63,0x63,0x63,0x63,0x63,0x36,0x1C,0x00}, // 0x4F
{0x3F,0x66,0x66,0x66,0x3E,0x06,0x06,0x06,0x0F,0x00}, // 0x50
{0x1C,0x36,0x63,0x63,0x63,0x73,0x7B,0x3E,0x30,0x78}, // 0x51
{0x3F,0x66,0x66,0x66,0x3E,0x36,0x66,0x66,0x67,0x00}, // 0x52
{0x1E,0x33,0x33,0x03,0x0E,0x18,0x33,0x33,0x1E,0x00}, // 0x53
{0x3F,0x2D,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x1E,0x00}, // 0x54
{0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x1E,0x00}, // 0x55
{0x33,0x33,0x33,0x33,0x33,0x33,0x33,0x1E,0x0C,0x00}, // 0x56
{0x63,0x63,0x63,0x63,0x6B,0x6B,0x36,0x36,0x36,0x00}, // 0x57
{0x33,0x33,0x33,0x1E,0x0C,0x1E,0x33,0x33,0x33,0x00}, // 0x58
{0x33,0x33,0x33,0x33,0x1E,0x0C,0x0C,0x0C,0x1E,0x00}, // 0x59
{0x7F,0x73,0x19,0x18,0x0C,0x06,0x46,0x63,0x7F,0x00}, // 0x5A
{0x3C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x0C,0x3C,0x00}, // 0x5B
{0x00,0x01,0x03,0x06,0x0C,0x18,0x30,0x60,0x40,0x00}, // 0x5C
{0x3C,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x3C,0x00}, // 0x5D
{0x1C,0x36,0x63,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x5E
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xFF}, // 0x5F
{0x0C,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x60
{0x00,0x00,0x00,0x1E,0x30,0x3E,0x33,0x33,0x6E,0x00}, // 0x61
{0x07,0x06,0x06,0x3E,0x66,0x66,0x66,0x66,0x3B,0x00}, // 0x62
{0x00,0x00,0x00,0x1E,0x33,0x03,0x03,0x33,0x1E,0x00}, // 0x63
{0x38,0x30,0x30,0x3E,0x33,0x33,0x33,0x33,0x6E,0x00}, // 0x64
{0x00,0x00,0x00,0x1E,0x33,0x3F,0x03,0x33,0x1E,0x00}, // 0x65
{0x1C,0x36,0x06,0x06,0x1F,0x06,0x06,0x06,0x0F,0x00}, // 0x66
{0x00,0x00,0x00,0x6E,0x33,0x33,0x33,0x3E,0x30,0x1E}, // 0x67
{0x07,0x06,0x06,0x36,0x6E,0x66,0x66,0x66,0x67,0x00}, // 0x68
{0x18,0x18,0x00,0x1E,0x18,0x18,0x18,0x18,0x7E,0x00}, // 0x69
{0x30,0x30,0x00,0x3C,0x30,0x30,0x30,0x30,0x33,0x1E}, // 0x6A
{0x07,0x06,0x06,0x66,0x36,0x1E,0x36,0x66,0x67,0x00}, // 0x6B
{0x1E,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x7E,0x00}, // 0x6C
{0x00,0x00,0x00,0x3F,0x6B,0x6B,0x6B,0x6B,0x63,0x00}, // 0x6D
{0x00,0x00,0x00,0x1F,0x33,0x33,0x33,0x33,0x33,0x00}, // 0x6E
{0x00,0x00,0x00,0x1E,0x33,0x33,0x33,0x33,0x1E,0x00}, // 0x6F
{0x00,0x00,0x00,0x3B,0x66,0x66,0x66,0x66,0x3E,0x06}, // 0x70
{0x00,0x00,0x00,0x6E,0x33,0x33,0x33,0x33,0x3E,0x30}, // 0x71
{0x00,0x00,0x00,0x37,0x76,0x6E,0x06,0x06,0x0F,0x00}, // 0x72
{0x00,0x00,0x00,0x1E,0x33,0x06,0x18,0x33,0x1E,0x00}, // 0x73
{0x00,0x04,0x06,0x3F,0x06,0x06,0x06,0x36,0x1C,0x00}, // 0x74
{0x00,0x00,0x00,0x33,0x33,0x33,0x33,0x33,0x6E,0x00}, // 0x75
{0x00,0x00,0x00,0x33,0x33,0x33,0x33,0x1E,0x0C,0x00}, // 0x76
{0x00,0x00,0x00,0x63,0x63,0x6B,0x6B,0x36,0x36,0x00}, // 0x77
{0x00,0x00,0x00,0x63,0x36,0x1C,0x1C,0x36,0x63,0x00}, // 0x78
{0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x3C,0x30,0x18}, // 0x79
{0x00,0x00,0x00,0x3F,0x31,0x18,0x06,0x23,0x3F,0x00}, // 0x7A
{0x38,0x0C,0x0C,0x06,0x03,0x06,0x0C,0x0C,0x38,0x00}, // 0x7B
{0x18,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x18,0x00}, // 0x7C
{0x07,0x0C,0x0C,0x18,0x30,0x18,0x0C,0x0C,0x07,0x00}, // 0x7D
{0xCE,0x5B,0x73,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, // 0x7E
{0x00,0x00,0x08,0x1C,0x36,0x63,0x63,0x7F,0x00,0x00} // 0x7F
};