Adressierung über Index

[gulliver]

Hallo

Seit Tagen verbiege ich mich bei folgendem Problem:
Ich beschäftige mich zur Zeit mit der Programmierung einer Laufschrift, ähnlich der auf der Seite

http://home.wanadoo.nl/electro1/avr/dotmatrix.htm

Ich benutze aber kein intelligentes Display, sondern verwende die 5x7-Punktmatrixmodule TA07-11 von Reichelt.
Die Zeilen werden mit einem ULN2803A durchgetickert, die Spalten zeilenweise in 5 mal 74HC595 eingetaktet (40 Spalten).
Um die richtige Taktung zu überprüfen und die Zeilenfrequenz einzustellen, damit die Anzeige nicht flimmert, habe ich einen Punkt spalten- und zeilenweise durchlaufen lassen. Das ist soweit ok.

Der Zeichensatz ist zeilenweise im Speicher abgelegt (7 Zeilen je 8 Bit) und jeweils, wie üblich, über ein Label erreichbar.
Dabei habe ich mich an die Organisation des LCD-Zeichensatzes gehalten (ist einfacher, brauchte nur die Bits übernehmen).
Dies sieht dann so aus:

A:
.db 0b01110000, 0b10001000, 0b10001000, 0b10001000, 0b11111000, 0b10001000, 0b10001000, 0

B:
.db 0b11110000, 0b10001000, 0b10001000, 0b11110000, 0b10001000, 0b10001000, 0b11110000, 0

C:
.db ... usw., Sch...arbeit, den kompletten Zeichensatz einzutippen :-)

Das Bit0 wird zuerst gelesen, der ganze Ramsch nach links rausgeschoben und in den Datenpin des 74HC595 eingetaktet.
Das erste Byte ist dabei die oberste Zeile, das letzte die unterste und die abschliessende Null wegen der Wortadressierung.
Beim Einlesen wird bis zum 6.Bit gezählt (6.Bit ist Leerspalte zwischen den Buchstaben) und der Rest wird verworfen und das entsprechende Zeilenbyte des nächsten Zeichen eingelesen. Die einzelnen Zeichen werden von rechts ins Display geschoben. So kann man den Satz Zeichen für Zeichen so einlesen, wie man ihn liest und erscheint auch so im Display. Da die Anzeige während des Eintakten abgeschaltet ist, sieht man dies nicht.

Nach jeder komplett eingelesenen Zeile wird das Display eingeschaltet. Die ganze Taktung geschieht während eines Interrupts. So ist gewährleistet, daß die Zeilen nicht gegeneinander verschoben werden.

Nun stehe ich vor dem Problem, das in ein Register eingelesene Zeichen einem Label in der Tabelle zuzuordnen. Bei Hochsprachen hat ja jedes Zeichen eine Ordnungszahl, diese könnte ich dann als Index verwenden. Da ich keine rechte Lust habe, mich in C einzuarbeiten, programmiere ich in Assembler. Da weiß ich nicht, wie diese Nuß zu knacken ist.

Z.B.: es wird 'e' eingelesen und es soll zum Label "e:" gesprungen werden und das entsprechende Zeilenbyte übernommen werden.
Die einzelnen Zeilen lassen sich über einen Index-Zähler adressieren, das wäre nicht das Problem. Das Problem ist, daß ein Label als Adresse definiert wird. An dieser Verbindung vom Zeichen zum entsprechenden Label beiße ich mir die Zähne aus.

Wäre nicht schlecht, wenn jemand einen Tip hätte. Ich hoffe, daß dies alles verständlich und nachvollziehbar ist.

mfg

Roger

[PicNick]

Weiß gott wie elektronisch ist das Thema ja eigentlich nicht.

Bei Tabellen wird in allen Hoch- und Tiefsprachen eigentlich gleich adressiert: Tab-Base + index * element-Length
Vorsicht: bei adressen im Flash muß du den Tabellen-Label * 2 nehmen, weißt du ja
Wenn du Elementlänge 7 hast, mußt du blöderweise wirklich multiplizieren, bei 8 würde shiften ja reichen
Ich würde 'e' * 7 , dann + tab-base, und dann noch + zeile

Das ist dann, wenn du die Pattern genauso wie die Zeichen angelegt hast.
Du wirst aber wohl zumindest 0x020 abziehen, nix druckbar, nix pattern.

wenn du noch platz hast , wäre schneller über vector-tabelle dazwischen

vec_tab:
db vector_a
db vector_b
....
db vector_z

vector_a: db 0, 0, 0 ,0 , 0 , 0 , 0 ; 7 byte pattern "A"
vector_b: db 0, 0, 0 ,0 , 0 , 0 , 0 ; 7 byte pattern "B"
.......
vector_z: db 0, 0, 0 ,0 , 0 , 0 , 0 ; 7 byte pattern "Z"


finden : vec_tab + Zeichen ------> address zeichen -pattern


Ist da wo eine Idee dabei, die hilft ?

[gulliver]

Hallo Robert

Nun, ja, wie elektronisch...
Einerseits ist es eine Elektronikgeschichte, andererseits auch Programmierung. In welche Sparte paßt dieses Thema am besten, ich habe mich nun mal für Elektronik entschieden. Programmierung wäre vielleicht doch geeigneter.

Das ist für mich ein sehr guter Denkansatz, ich danke dir. Hätte auch selber drauf kommen können, daß der Zeichensatz auch als fortlaufende Nummerierung interpretiert werden kann. Wenn man dann noch den Zählwert des ersten Zeichens abzieht, hat man wieder eine Basis zum Indizieren. Das mit der Elementlänge habe ich zwar nicht richtig verstanden, wie du das meinst, aber wenn du damit die Zeilen meinst, habe ich kein Problem damit. Die Anzahl der Einträge in den jeweiligen Labeln ist ja für jedes Zeichen gleich (mit dem 0-Byte sind es 8 Byte) und damit auch die Adressenabstände.

Für die Zeilen verwende ich einen Zähler von 0...6, dessen Zählerstand als Index bei der Adressierung benutzt wird. Das erste Byte würde bei Zählbeginn mit 0, das zweite Byte mit Zählerstand 1 usw. indiziert werden. Es wird ja immer eins zur Adresse hinzugezählt. Dein Gedanke, den eigentlichen Vektor über eine Vektortabelle anzuspringen und dann den Zeilenindex hinzuaddieren finde ich brillant. Da können im Zeichensatz auch Lücken elegant übersprungen werden. Diese Art der Adressierung kenne ich übrigens aus meiner Atarizeit. Habe immer noch einen auf 320 kB aufgemotzten 800XL, der sich übrigens sehr gut mit seinen 77 Assemblerbefehlen programmieren läßt, nur die Hardware drumrum macht einem das Leben ganz schön schwer. Da wird diese Adressierung sehr häufig angewendet, aber mein Kumpel Alz Heimer redet mir leider immer häufiger vieles aus :-), so daß mich nicht mal ein Schimmer von einem Geistesblitz erhellte. Käse, wenn man älter wird.

Werde mich morgen mal drüber hermachen. Wenn das klappt, wird die nächste Stufe angepackt. Da ich die Anzeige aus Kostengründen nur mit 8 LED-Matrixen bestückt habe, werde ich versuchen, einen längeren Text durchscrollen zu lassen. Mal sehen, ob ich da mit dem Timing noch hinkomme. Takte hätte ich in der Interrupt-Routine jedenfalls noch genug übrig.

Danke und tschüß

Roger

[kalledom]

Hallo Roger,
für PIC-Controller empfehle ich eine Internet-Seite mit ASM-Beispielen (http://www.domnick-elektronik.de/picasm.htm), auch mit indirekter Adressierung, die ich hierfür vorschlagen würde.

[gulliver]

Hallo Karl-Heinz

Danke dir für den Tip, aber der Link ist heute morgen noch dicht und nicht erreichbar. Egal, kein Problem. Wenn ich mich noch mit dem deutlich anderem Befehlssatz herumschlagen müßte, würde ich C vorziehen.

Ich hatte mich vor 15 Jahren mit Assembler auf dem 8-Bit-Atari beschäftigt. Dessen Befehlssatz ist mir noch sehr vertraut. Da lauten diese LDA, DEC, BCC, STA AND, INX, JMP usw. Ist zwar alles auf Akku fixiert, aber es läßt sich hervorragend auf Atmel umsetzen. Außerdem habe ich noch Assemblerlektüre, wie z.B. "Das Assemblerbuch" von Peter Finzel, darin ist die Programmierung sehr gut beschrieben. In Zukunft werde ich dieses zu meiner Standardlektüre machen ;-).

mfg

Roger

Edit: Ich muß mich korrigieren, der Link ist ok. Habe nur die Erweiterung nach dem '/' wegnehmen müssen.

[PicNick]

Wenn du vom Assembler kommst, aber nicht emotional damit verbunden bist, kann ich dir nur den C von GCC als schreibhilfe empfehlen. der nimmt dir den Kleinkram ab, haut dir aber trotzdem noch ausreichend die einzelnen Bits um die Ohren, damit du nicht auf Entzug kommst.

[kalledom]

Sorry, war mein Fehler; ich hatte für die ASM-Beispiele die Erweiterung .HTM vergessen.

[gulliver]

Hallo Robert

Mein Problem ist nicht die Sprache C an sich, sondern das ganze Procedere drumrum mit den Parametern beim Compiler/Precompiler, und auch mit der manchmal cryptischen Schreibweise mit doppelteten Unterstrichen usw. in den *.h-Dateien. Da gibt es viele Sachen, die ich nicht nachvollziehen kann. Das macht mich dann unsicher.

Ich habe nach der Wende mit Turbopascal angefangen und auch Assembler auf dem Atari noch nebenbei (hatte ich schon vor der neuen Zeitrechnung :-) ). In Pascal gibt man den Befehl zum Compilieren und das war's, bei C muß ich erst einige Vorkehrungen treffen, wie Compilereinstellungen, Komandozeilenoptionen usw., sonst geht das in die Hose.

Mit C++ bin ich erst in einer Weiterbildung in Berührung gekommen. Vieles kann ich ja nicht übernehmen. Einige Routinen kennt die Atmel-Version nicht und außerdem gibt es da in den Bibliotheken noch so einige Unterschiede, so daß ich mit Fehlermeldungen nur so zugesch...en wurde. Dazu noch die Case-Sensitivität, da sind Fehler schon vorprogrammiert. Da verliere ich dann immer wieder die Lust und bin beim Assembler geblieben.

An sich ist Assembler ja eine klare Sprache, nur man muß genau wissen, was man tut. Viele Probleme lassen sich in einer Hochsprache relativ einfach ausdrücken. In Assembler knabbert man daran tagelang und sieht evt. den Wald vor lauter Bäumen nicht, wie in meinem Fall mit dem Zeichensatz.

Ich denke, ich muß mir nur ein komplettes C-Paket installieren und nur mit dessen Bibliotheken arbeiten, und keine Fremdbibliotheken installieren und mich dann langsam vorarbeiten. Vor allem muß ich mich öfter mit der Programmierung beschäftigen, und nicht alle 3 Wochen mal. Da festigt sich kein Wissen. Man müßte nur etwas mehr Zeit haben ;-).
Irgendwann packe ich das auch noch. Irgendwo hatte ich mal eine Seite gesehen, wo jemand mit einem Universal-Script für den Compiler arbeitet und nur den Prozessortyp ändert. Da ich vergessen hatte, den Link zu speichern, habe ich diese Seite bis heute nicht wiedergefunden.

mfg Roger

[kalledom]

Da stimme ich Gulliver zu, ich mag aus den genannten Gründen auch kein C und habe mein Leben lang nur in Assembler programmiert. Wenn ich z.B. im PIC-Forum in den Beiträgen sehe, was für Probleme unter den C-Versionen und -Varianten auftauchen, bin ich froh, bei Assembler geblieben zu sein. Außerdem kenne ich kaum ein C-Listing, in dem nicht einige Assembler-Befehle mit drin sind. Die (frühere) Begründung für C, auf jeden Rechner übertragbar zu sein, ist ja wohl schon lange vom Tisch.

[PicNick]

C und drumherum: Nun, beim WinAVR (GCC-C) ist das ganze schon recht zusammengepackt und man ist mit dem makefile-brimborium in der Grundausstattung kaum konfrontiert. Aber klar, Übung (und Gewöhnung) braucht man für alles. C programmierer neigen ja leider zu IT-Schamanismus und unleserlichen Beschwörungsformeln, das stimmt schon.
Grad bei Microkontroller gibt es wenig zwingende Gründe, sich das anzutun. Weil, wie Kalle ja bemerkt hat, viele C-Sourcen oft ohne Not nichteinmal artenrein sind.
Die Portierbarkeit von C leidet natürlich unter solchen Konzeptlosigkeiten, ist auch richtig.

[gulliver]

Hallo

Am Wochende habe ich mir mein Projekt wieder mal zur Brust genommen und mir die Laune verdorben. Irgendwie bin ich mit meinen Programmierkünsten am Ende.
Um mir mein Original nicht zu vermurksen, habe ich mir mal eine Testumgebung nur für den Zugriff auf den Zeichensatz geschrieben, um zu sehen, ob die Bitmuster auch wie gewünscht ausgegeben werden.
Das Prog liefert mir immer ein ff, obwohl dieses garnicht vorkommen kann, da im letzten Nibble die letzten drei Bit auf 0 sind.

In diesem Stadium sollte das Prog den Text durchflitzen und mir die ersten Bitmuster ausgeben. Als nächsten Schritt würde noch der Zeilenindex hinzuaddiert werden. Mit dem Durchflitzen klappt es ja, aber dann wird es ziehmlich nebulös. Die Adressierung scheint ja richtig zu funktionieren. Beim ersten Buchstaben (H) sollte eine 0x88 in wreg drinstehen.

Vielleicht sieht ein Außenstehender mehr. Die Werte der Konstanten scheinen sich auch nicht ändern zu lassen. Heißen ja nicht umsonst Konstanten. Die indizierte Adressierung funktioniert leider nur mit Displacements. Ich bin der Meinung, es sind Konstanten. Bin ziemlich ratlos.

mfg Roger

Edit: Wie funktioniert das mit dem scrollbaren Code im Text einfügen? Habe auf die Schnelle nichts finden können.

[PicNick]

Ja, lieber Herr Kollege, so einfach ist das nicht:
für den FLASH brauchst du 16-bit pointer (d.h. jeder Schmarrn * 2)

Schau die das Prog an, ich habe für den ersten Buchstaben "H" alles gecheckt, ein bißchen was darfst du dann auch

*grmpf* Im Flash muttu mit LPM u. Z lesen !





;************************************************* *****************************
;
; Testen des indizierten Tabellenzugriffs
; MCU: AT90S2313 Takt: 4,433618 MHz
;
;Zeiger_Text_Anfang = Register X
;Zeiger_Pattern = Register Y
;Zeiger_Text_Basis = Register Z
;************************************************* *****************************
;
.nolist
.include <2313def.inc>
.list
;
; Konstanten
.equ Offset = 0x20 ;Offset zum ersten Zeichens im Zeichensatz (32)
.equ Counter_Spalte = 0 ;Spaltenzähler
.equ Counter_Zeile = 0 ;Index für Pattern
;
; Benutzte Register
.def wreg = R16
.def temp = R17
;
; Codebeginn
;
.CSEG
.ORG 0000
rjmp main

; Reset- und Interruptroutinen

;*********** Hauptprogramm ******************************************
main:
ldi wreg,low(RAMEND)
out SPL,wreg ;der übliche Stack
ldi wreg,0
sts Counter_Spalte, wreg ;clear
sts Counter_Zeile, wreg ;clear
sts Counter_Spalte, wreg ;clear

ldi ZH, high (Text*2)
ldi ZL, low (Text*2)

loop_Zeile:


loop_Zeichen:
lpm ;Zeichen aus Text holen und erhöhen
tst R0
breq ende ;ja,nächste Zeile (vorläufig ende)
adiw ZL,1

push ZL ;Basisadresse sichern ...
push ZH ;Basisadresse sichern ...

ldi ZH, high (Zeichensatz*2)
ldi ZL, low (Zeichensatz*2)

mov temp,R0 ; character
subi temp,Offset ;Offset des Zeichensatzes abziehen
rol temp
add ZL,temp ;Zeichen als Offset zur Basis addieren
clr temp
adc ZH, temp
lpm
mov temp,R0 ; character vec low
adiw ZL,1
lpm
mov zh,R0 ; character vec high
mov zl, temp
lpm

mov temp,R0 ; pattern

;Zeilenmuster holen
pop ZH ;... und wieder zurückholen
pop ZL ;... und wieder zurückholen


neue_Zeile:
rjmp loop_Zeile

ende:
rjmp ende

;************* Tabellen *********************************************
Text:
.db "Hallo 2&4-eR",0

;Einsprungtabelle,vom Zeichsatz müssen 32 abgezogen werden,
;damit mit der Zählung bei Null begonnen werden kann
Zeichensatz:
.dw char_leer, char_ausr, char_gf, char_dk, char_dol, char_proz
.dw char_und, char_hkom, char_likl, char_rekl, char_mal, char_plus
.dw char_kom, char_minus, char_pkt, char_slash
;-------------------------------------------
.dw char_0, char_1, char_2, char_3, char_4, char_5, char_6, char_7
.dw char_8, char_9, char_dp, char_sk, char_li, char_gl, char_re, char_fr
;-------------------------------------------
.dw char_at, char_A, char_B, char_C, char_D, char_E, char_F, char_G
.dw char_H<<1, char_I, char_J, char_K, char_L, char_M, char_N, char_O
;-------------------------------------------
.dw char_P, char_Q, char_R, char_S, char_T, char_U, char_V, char_W
.dw char_X, char_Y, char_Z, char_lie, char_yen, char_ree, char_da, char_us
;-------------------------------------------
.dw char_hk, char_a
.dw char_b, char_c, char_d, char_e, char_f, char_g
.dw char_h, char_i, char_j, char_k, char_l, char_m
.dw char_n, char_o, char_p, char_q, char_r, char_s
.dw char_t, char_u, char_v, char_w, char_x, char_y
.dw char_z, char_res, char_pip, char_lis, char_rep, char_lip

;Zeichensatz Bitmuster
char_leer: ;Leerzeichen
.db 0b00000000, 0b00000000, 0b00000000, 0b00000000
.db 0b00000000, 0b00000000, 0b00000000,0 ;0,0,0,0,0,0,0

char_ausr: ;Ausrufezeichen
.db 0b00100000, 0b00100000, 0b00100000, 0b00100000
.db 0b00000000, 0b00000000, 0b00100000,0 ;20,20,20,20,0,0,20

char_gf: ;Gänsefüsse
.db 0b01010000, 0b01010000, 0b01010000, 0b00000000
.db 0b00000000, 0b00000000, 0b00000000,0 ;50,50,50,0,0,0,0

char_dk: ;Doppelkreuz
.db 0b01010000, 0b01010000, 0b11011000, 0b01010000
.db 0b11011000, 0b01010000, 0b01010000,0 ;50,50,d8,a0,d8,50,50

char_dol: ;Dollar
.db 0b00100000, 0b01111000, 0b10100000, 0b01110000
.db 0b00101000, 0b11110000, 0b00100000,0 ;20,78,a0,70,28,f0,20

char_proz: ;Prozent
.db 0b11000000, 0b11001000, 0b00010000, 0b00100000
.db 0b01000000, 0b10011000, 0b00011000,0 ;60,68,10,20,40,98,18

char_und: ;kaufmännisch-und
.db 0b01100000, 0b10010000, 0b10100000, 0b01000000
.db 0b10101000, 0b10010000, 0b01101000,0 ;60,90,a0,40,a8,90,68

char_hkom: ;Hochkomma
.db 0b01100000, 0b00100000, 0b01000000, 0b00000000
.db 0b00000000, 0b00000000, 0b00000000,0 ;60,20,40,0,0,0,0

char_likl: ;linke Klammer
.db 0b00010000, 0b00100000, 0b01000000, 0b01000000
.db 0b01000000, 0b00100000, 0b00010000,0 ;10,20,40,40,40,20,10

char_rekl: ;rechte Klammer
.db 0b01000000, 0b00100000, 0b00010000, 0b00010000
.db 0b00010000, 0b00100000, 0b01000000,0 ;40,20,10,10,10,20,40

char_mal: ;Mal-Zeichen
.db 0b00000000, 0b00100000, 0b10101000, 0b01110000
.db 0b10101000, 0b00100000, 0b00000000,0 ;0,20,a8,70,a8,20,0

char_plus: ;Plus-Zeichen
.db 0b00000000, 0b00100000, 0b00100000, 0b11111000
.db 0b00100000, 0b00100000, 0b00000000,0 ;0,20,20,f8,20,20,0

char_kom: ;Komma
.db 0b00000000, 0b00000000, 0b00000000, 0b00000000
.db 0b01100000, 0b00100000, 0b01000000,0 ;0,0,0,0,60,20,40

char_minus: ;Minus-Zeichen
.db 0b00000000, 0b00000000, 0b00000000, 0b11111000
.db 0b00000000, 0b00000000, 0b00000000,0 ;0,0,0,f8,0,0,0

char_pkt: ;Punkt
.db 0b00000000, 0b00000000, 0b00000000, 0b00000000
.db 0b00000000, 0b01100000, 0b01100000,0 ;0,0,0,0,0,60,60

char_slash: ;/ Slash-Zeichen
.db 0b00000000, 0b00001000, 0b00010000, 0b00100000
.db 0b01000000, 0b10000000, 0b00000000,0 ;0,80,10,20,40,80,0

char_0:
.db 0b01110000, 0b10001000, 0b10011000, 0b10101000
.db 0b11001000, 0b10001000, 0b01110000,0 ;70,88,98,a8,c8,88,70

char_1:
.db 0b00100000, 0b01100000, 0b00100000, 0b00100000
.db 0b00100000, 0b00100000, 0b01110000,0 ;20,60,20,20,20,20,70

char_2:
.db 0b01110000, 0b10001000, 0b00001000, 0b00010000
.db 0b00100000, 0b01000000, 0b11111000,0 ;70,88,08,10,20,40,f8

char_3:
.db 0b11111000, 0b00010000, 0b00100000, 0b00010000
.db 0b00001000, 0b10001000, 0b01110000,0 ;f8,10,20,10,08,88,70

char_4:
.db 0b00010000, 0b00110000, 0b01010000, 0b10010000
.db 0b11111000, 0b00010000, 0b00010000,0 ;10,30,50,90,f8,10,10

char_5:
.db 0b11111000, 0b10000000, 0b11110000, 0b00001000
.db 0b00001000, 0b10001000, 0b01110000,0 ;f8,80,f0,80,80,88,70

char_6:
.db 0b00100000, 0b01000000, 0b10000000, 0b111100000
.db 0b10001000, 0b10001000, 0b01110000,0 ;20,40,80,f0,88,88,70

char_7:
.db 0b11111000, 0b00010000, 0b00100000, 0b01000000
.db 0b01000000, 0b01000000, 0b01000000,0 ;f8,10,20,40,40,40,40

char_8:
.db 0b01110000, 0b10001000, 0b10001000, 0b01110000
.db 0b10001000, 0b10001000, 0b01110000,0 ;70,88,88,70,88,88,70

char_9:
.db 0b01110000, 0b10001000, 0b10001000, 0b01111000
.db 0b00001000, 0b00010000, 0b00100000,0 ;70,88,88,78,80,10,20

char_dp: ;Doppelpunkt
.db 0b00000000, 0b01100000, 0b01100000, 0b00000000
.db 0b01100000, 0b01100000, 0b00000000,0 ;0,60,60,0,60,60,0

char_sk: ;Symikolon
.db 0b00000000, 0b01100000, 0b01100000, 0b00000000
.db 0b01100000, 0b00100000, 0b01000000,0 ;0,60,60,0,60,20,40

char_li: ;Spitze links
.db 0b00010000, 0b00100000, 0b01000000, 0b10000000
.db 0b01000000, 0b00100000, 0b00010000,0 ;10,20,40,80,40,20,10

char_gl: ;gleich
.db 0b00000000, 0b00000000, 0b11111000, 0b00000000
.db 0b11111000, 0b00000000, 0b00000000,0 ;0,0,f8,0,f8,0,0

char_re: ;Spitze rechts
.db 0b01000000, 0b00100000, 0b00010000, 0b00001000
.db 0b00010000, 0b00100000, 0b01000000,0 ;40,20,10,08,10,20,40

char_fr: ;Fragezeichen
.db 0b01110000, 0b10001000, 0b00001000, 0b00010000
.db 0b00100000, 0b00000000, 0b00100000,0 ;70,88,08,10,20,0,20

char_at: ;@-Zeichen
.db 0b01110000, 0b10001000, 0b00001000, 0b01101000
.db 0b10101000, 0b10101000, 0b01110000,0 ;70,88,08,68,a8,a8,70

char_A:
.db 0b01110000, 0b10001000, 0b10001000, 0b10001000
.db 0b11111000, 0b10001000, 0b10001000,0 ;70,88,88,88,f8,88,88

char_B:
.db 0b11110000, 0b10001000, 0b10001000, 0b11110000
.db 0b10001000, 0b10001000, 0b11110000,0 ;f0,88,88,f0,88,88,f0

char_C:
.db 0b01110000, 0b10001000, 0b10000000, 0b10000000
.db 0b10000000, 0b10001000, 0b01110000,0 ;70,88,80,80,80,88,70

char_D:
.db 0b11100000, 0b10010000, 0b10001000, 0b10001000
.db 0b10001000, 0b10010000, 0b11100000,0 ;e0,90,88,88,88,90,e0

char_E:
.db 0b11111000, 0b10000000, 0b10000000, 0b11110000
.db 0b10000000, 0b10000000, 0b11111000,0 ;f8,80,80,f0,80,80,f8

char_F:
.db 0b11111000, 0b10000000, 0b10000000, 0b11110000
.db 0b10000000, 0b10000000, 0b10000000,0 ;f8,80,80,f0,80,80,80

char_G:
.db 0b01110000, 0b10001000, 0b10000000, 0b10110000
.db 0b10001000, 0b10001000, 0b01110000,0 ;70,88,80,b0,88,88,70

char_H:
.db 0b10001000, 0b10001000, 0b10001000, 0b11111000
.db 0b10001000, 0b10001000, 0b10001000,0 ;88,88,88,f8,88,88,88

char_I:
.db 0b01110000, 0b00100000, 0b00100000, 0b00100000
.db 0b00100000, 0b00100000, 0b01110000,0 ;70,20,20,20,20,20,70

char_J:
.db 0b00111000, 0b00010000, 0b00010000, 0b00010000
.db 0b00010000, 0b10010000, 0b01100000,0 ;38,10,10,10,10,90,60

char_K:
.db 0b10001000, 0b10010000, 0b10100000, 0b11000000
.db 0b10100000, 0b10010000, 0b10001000,0 ;88,90,a0,c0,a0,90,90

char_L:
.db 0b10000000, 0b10000000, 0b10000000, 0b10000000
.db 0b10000000, 0b10000000, 0b11111000,0 ;80,80,80,80,80,80,f8

char_M:
.db 0b10001000, 0b11011000, 0b10101000, 0b10101000
.db 0b10001000, 0b10001000, 0b10001000,0 ;88,d8,a8,a8,88,88,88

char_N:
.db 0b10001000, 0b10001000, 0b11001000, 0b10101000
.db 0b10011000, 0b10001000, 0b10001000,0 ;88,88,68,a8,98,88,88

char_O:
.db 0b01110000, 0b10001000, 0b10001000, 0b10001000
.db 0b10001000, 0b10001000, 0b01110000,0 ;70,88,88,88,88,88,70

char_P:
.db 0b11110000, 0b10001000, 0b10001000, 0b11110000
.db 0b10000000, 0b10000000, 0b10000000,0 ;f0,88,88,f0,80,80,80

char_Q:
.db 0b01110000, 0b10001000, 0b10001000, 0b10001000
.db 0b10101000, 0b10010000, 0b01101000,0 ;70,88,88,88,a8,90,68

char_R:
.db 0b11110000, 0b10001000, 0b10001000, 0b11110000
.db 0b10100000, 0b10010000, 0b10001000,0 ;f0,88,88,f0,90,90,90

char_S:
.db 0b01111000, 0b10000000, 0b10000000, 0b01110000
.db 0b00001000, 0b00001000, 0b11110000,0 ;78,80,80,70,08,08,f0

char_T:
.db 0b11111000, 0b00100000, 0b00100000, 0b00100000
.db 0b00100000, 0b00100000, 0b00100000,0 ;f8,20,20,20,20,20,20

char_U:
.db 0b10001000, 0b10001000, 0b10001000, 0b10001000
.db 0b10001000, 0b10001000, 0b01110000,0 ;88,88,88,88,88,88,70

char_V:
.db 0b10001000, 0b10001000, 0b10001000, 0b10001000
.db 0b10001000, 0b01010000, 0b00100000,0 ;88,88,88,88,88,50,20

char_W:
.db 0b10001000, 0b10001000, 0b10001000, 0b10101000
.db 0b10101000, 0b10101000, 0b01010000,0 ;88,88,88,58,58,58,50

char_X:
.db 0b10001000, 0b10001000, 0b01010000, 0b00100000
.db 0b01010000, 0b10001000, 0b10001000,0 ;88,88,50,20,50,88,88

char_Y:
.db 0b10001000, 0b10001000, 0b10001000, 0b01010000
.db 0b00100000, 0b00100000, 0b00100000,0 ;88,88,88,50,20,20,20

char_Z:
.db 0b11111000, 0b00001000, 0b00010000, 0b00100000
.db 0b01000000, 0b10000000, 0b11111000,0 ;f8,08,10,20,40,80,f8

char_lie: ;eckige Klammer links
.db 0b01110000, 0b01000000, 0b01000000, 0b01000000
.db 0b01000000, 0b01000000, 0b01110000,0 ;70,40,40,40,40,40,70

char_yen: ;Yen-Zeichen
.db 0b10001000, 0b01010000, 0b11111000, 0b00100000
.db 0b11111000, 0b00100000, 0b00100000,0 ;88,50,f8,20,f8,20,20

char_ree: ;eckige Klammer rechts
.db 0b01110000, 0b00010000, 0b00010000, 0b00010000
.db 0b00010000, 0b00010000, 0b01110000,0 ;70,10,10,10,10,10,70

char_da: ;^ Dachzeichen
.db 0b00100000, 0b01010000, 0b10001000, 0b00000000
.db 0b00000000, 0b00000000, 0b00000000,0 ;20,50,88,0,0,0,0

char_us: ;Unterstrich
.db 0b00000000, 0b00000000, 0b00000000, 0b00000000
.db 0b00000000, 0b00000000, 0b11111000,0 ;0,0,0,0,0,0,f8

char_hk: ;`-Zeichen
.db 0b01000000, 0b00100000, 0b00010000, 0b00000000
.db 0b00000000, 0b00000000, 0b00000000,0 ;40,20,10,0,0,0,0

char_a_klein:
.db 0b00000000, 0b00000000, 0b01110000, 0b00001000
.db 0b01111000, 0b10001000, 0b01111000,0 ;0,0,70,08,78,88,78

char_b_klein:
.db 0b10000000, 0b10000000, 0b10000000, 0b11110000
.db 0b10001000, 0b10001000, 0b11110000,0 ;80,80,80,f0,88,88,f0

char_c_klein:
.db 0b00000000, 0b00000000, 0b00000000, 0b01110000
.db 0b10000000, 0b10001000, 0b01110000,0 ;0,0,0,70,80,88,70

char_d_klein:
.db 0b00001000, 0b00001000, 0b01101000, 0b10011000
.db 0b10001000, 0b10001000, 0b01111000,0 ;80,80,68,98,88,88,78

char_e_klein:
.db 0b00000000, 0b00000000, 0b01110000, 0b10001000
.db 0b11111000, 0b10000000, 0b01110000,0 ;,0,0,70,88,f8,80,70

char_f_klein:
.db 0b00110000, 0b01001000, 0b01000000, 0b11100000
.db 0b01000000, 0b01000000, 0b01000000,0 ;30,48,40,e0,40,40,40

char_g_klein:
.db 0b00000000, 0b00000000, 0b01111000, 0b10001000
.db 0b01111000, 0b00001000, 0b01110000,0 ;0,0,78,88,78,08,70

char_h_klein:
.db 0b10000000, 0b10000000, 0b10000000, 0b10110000
.db 0b11001000, 0b10001000, 0b10001000,0 ;80,80,80,b0,c8,88,88

char_i_klein:
.db 0b00100000, 0b00000000, 0b01100000, 0b00100000
.db 0b00100000, 0b00100000, 0b01110000,0 ;20,0,60,20,20,20,70

char_j_klein:
.db 0b00001000, 0b00000000, 0b00001000, 0b00001000
.db 0b00001000, 0b10001000, 0b00110000,0 ;08,0,08,08,08,88,30

char_k_klein:
.db 0b10000000, 0b10000000, 0b10010000, 0b10100000
.db 0b11000000, 0b10100000, 0b10010000,0 ;80,80,90,a0,c0,a0,90

char_l_klein:
.db 0b01100000, 0b00100000, 0b00100000, 0b00100000
.db 0b00100000, 0b00100000, 0b01110000,0 ;60,20,20,20,20,20,70

char_m_klein:
.db 0b00000000, 0b00000000, 0b11010000, 0b10101000
.db 0b10101000, 0b10001000, 0b10001000,0 ;0,0,D0,A8,A8,88,88

char_n_klein:
.db 0b00000000, 0b00000000, 0b10110000, 0b11001000
.db 0b10001000, 0b10001000, 0b10001000,0 ;0,0,B0,C8,88,88,88

char_o_klein:
.db 0b00000000, 0b00000000, 0b01110000, 0b10001000
.db 0b10001000, 0b10001000, 0b01110000,0 ;0,0,70,88,88,88,70

char_p_klein:
.db 0b00000000, 0b00000000, 0b11110000, 0b10001000
.db 0b11110000, 0b10000000, 0b10000000,0 ;0,0,f0,88,f0,80,80

char_q_klein:
.db 0b00000000, 0b00000000, 0b01101000, 0b10011000
.db 0b01101000, 0b00001000, 0b00001000,0 ;0,0,68,98,68,08,08

char_r_klein:
.db 0b00000000, 0b00000000, 0b10110000, 0b11001000
.db 0b10000000, 0b10000000, 0b10000000,0 ;0,0,b0,c8,80,80,80

char_s_klein:
.db 0b00000000, 0b00000000, 0b01110000, 0b10000000
.db 0b01110000, 0b00001000, 0b11110000,0 ;0,0,70,80,70,08,f0

char_t_klein:
.db 0b01000000, 0b01000000, 0b11100000, 0b01000000
.db 0b01000000, 0b01001000, 0b00110000,0 ;40,40,e0,40,40,48,30

char_u_klein:
.db 0b00000000, 0b00000000, 0b10001000, 0b10001000
.db 0b10001000, 0b10011000, 0b01101000,0 ;0,0,88,88,88,98,68

char_v_klein:
.db 0b00000000, 0b00000000, 0b10001000, 0b10001000
.db 0b10001000, 0b01010000, 0b00100000,0 ;0,0,88,88,88,50,20

char_w_klein:
.db 0b00000000, 0b00000000, 0b10001000, 0b10001000
.db 0b10101000, 0b10101000, 0b01010000,0 ;0,0,88,88,54,54,50

char_x_klein:
.db 0b00000000, 0b00000000, 0b10001000, 0b01010000
.db 0b00100000, 0b01010000, 0b10001000,0 ;0,0,88,50,20,50,88

char_y_klein:
.db 0b00000000, 0b00000000, 0b10001000, 0b10001000
.db 0b01111000, 0b00001000, 0b01110000,0 ;0,0,88,88,78,08,70

char_z_klein:
.db 0b00000000, 0b00000000, 0b11111000, 0b00010000
.db 0b00100000, 0b01000000, 0b11111000,0 ;0,0,f8,10,20,40,f8

char_lis: ;geschweift Klammer
.db 0b00010000, 0b00100000, 0b00100000, 0b01000000
.db 0b00100000, 0b00100000, 0b00010000,0 ;10,20,20,40,20,20,10

char_pip: ;| Pipe-Zeichen
.db 0b00010000, 0b00010000, 0b00010000, 0b00010000
.db 0b00010000, 0b00010000, 0b00010000,0 ;10,10,10,10,10,10,10,

char_res: ;geschweift Klammer rechts
.db 0b01000000, 0b00100000, 0b00100000, 0b00010000
.db 0b00100000, 0b00100000, 0b01000000,0 ;40,20,20,10,20,20,40

char_rep: ;Pfeil rechts
.db 0b00000000, 0b00100000, 0b00010000, 0b11111000
.db 0b00010000, 0b00100000, 0b00000000,0 ;0,20,10,f8,10,20,0

char_lip: ;Pfeil links
.db 0b00000000, 0b00100000, 0b01000000, 0b11111000
.db 0b01000000, 0b00100000, 0b00000000,0 ;0,20,40,f8,40,20,0




EDIT: mach dir nix draus, man kann schon mal einrosten ! O:)