Hallo ich hoffe ihr könnt mir helfen. habe schon einige Beträge dazu gelesen, doch irgendwie kapier ich's nicht. Allso, ich möchte auf einem Grafik LCD einen Text aus geben . Das Zeichen besteht aus Pixeln die ich über SPI dem LCD sende. Mein erster Ansatz war: set_Portb(PA4); SPDR = 0b00000000; while(!(SPSR & (1<<SPIF))); SPDR = 0B00000000; while(!(SPSR & (1<<SPIF))); SPDR = 0B11111110; while(!(SPSR & (1<<SPIF))); SPDR = 0B00010000; while(!(SPSR & (1<<SPIF))); SPDR = 0B00010000; while(!(SPSR & (1<<SPIF))); SPDR = 0B00010000; while(!(SPSR & (1<<SPIF))); SPDR = 0B11111110; while(!(SPSR & (1<<SPIF))); SPDR = 0B00000000; while(!(SPSR & (1<<SPIF))); SPDR = 0B00000000; while(!(SPSR & (1<<SPIF))); wait (500); Damit wird jedes Pixel in jeder Zeile einzeln gesetzt! Alao: SPDR = 0B11111110; setzt im Display 7 Pixel. Dann habe ich in meinem C Buch nachgeschaut und Arrays entdeckt: Also habe ich Buchstaben aus 8 X 5 Zeichen entwurfen und in Arrays gespeichert: char Leer[5] = {0x00,0x00,0x00,0x00,0x00}; char Ohm[5] = {0x5C,0x62,0x02,0x62,0x5C}; char A[5] = {0x7E,0x11,0x11,0x11,0x7E}; char B[5] = {0x41,0x7F,0x49,0x49,0x36}; char C[5] = {0x3E,0x41,0x41,0x41,0x22}; char D[5] = {0x41,0x7F,0x41,0x41,0x3E}; char E[5] = {0x7F,0x49,0x49,0x49,0x49}; char F[5] = {0x7F,0x09,0x09,0x09,0x01}; char G[5] = {0x3E,0x41,0x41,0x49,0x7A}; char H[5] = {0x7F,0x08,0x08,0x08,0x7F}; char I[5] = {0x00,0x41,0x7F,0x41,0x00}; char J[5] = {0x20,0x40,0x41,0x3F,0x01}; char K[5] = {0x7F,0x08,0x14,0x22,0x41}; char L[5] = {0x7F,0x40,0x40,0x40,0x40}; char M[5] = {0x7F,0x02,0x06,0x02,0x7F}; char N[5] = {0x7F,0x06,0x08,0x30,0x7F}; char O[5] = {0x3E,0x41,0x41,0x41,0x3E}; char P[5] = {0x7F,0x09,0x09,0x09,0x06}; char Q[5] = {0x3E,0x41,0x51,0x21,0x5E}; char R[5] = {0x7F,0x09,0x19,0x29,0x46}; char S[5] = {0x26,0x49,0x49,0x49,0x32}; char T[5] = {0x01,0x01,0x7F,0x01,0x01}; char U[5] = {0x3F,0x40,0x40,0x40,0x3F}; char V[5] = {0x1F,0x20,0x40,0x20,0x1F}; char W[5] = {0x7F,0x20,0x18,0x20,0x7F}; char X[5] = {0x63,0x14,0x08,0x14,0x63}; char Y[5] = {0x07,0x08,0x70,0x08,0x07}; char Z[5] = {0x61,0x51,0x49,0x45,0x43}; Nun muß ich nur noch schreiben, um z.B.: ein OHM Zeichen anzuzeigen: for (count = 0; count<5; count++) { SPDR = Ohm[count]; while(!(SPSR & (1<<SPIF))); } Bis hierher geht das Super !!!!!!! Nun wäre der nächste schritt eine Zeichenkette ausgeben. Also habe ich mir gedacht. Ich erstelle ein Array mit dem Text den ich ausgeben will z.B.: char text[6] = {H,A,L,L,O}; char *zeiger zeiger = text; for (count1 = 0; count<5; count++) { zeiger = Text[count1]; set_Portb(PA4); for (count = 0; count<5; count++) { SPDR = zeiger[count]; while(!(SPSR & (1<<SPIF))); } Also laut meinem C buch zeigt der Zeiger auf das Array text. Also: solte doch im Zeiger durch zeiger = Text[count1]; Das Zeichen H stehen. H ist ja auch ein Array deshalb solte doch die zweite Schleife alle 5 Hex senden. Läst sich nicht compilieren! 2. Idee: int text[] = {H,A,L,L,O}; int zeiger[5]; for (count1 = 0; count<5; count++) { zeiger[count1] = text[count1]; set_Portb(PA4); for (count = 0; count<5; count++) { SPDR = zeiger[count]; while(!(SPSR & (1<<SPIF))); } } Läst sich nur Compelieren wenn ich den String als Int anlege ?? Kömmt müll bei raus. Wie könnte man das noch machen ? Geht es mit mehrdimensionalen Arrays ? Vielen Dank für jede Hilfe erklärung
> Dann habe ich in meinem C Buch nachgeschaut und Arrays entdeckt: > Also habe ich Buchstaben aus 8 X 5 Zeichen entwurfen und in Arrays > gespeichert: > OK. > Nun muß ich nur noch schreiben, um z.B.: ein OHM Zeichen anzuzeigen: > > for (count = 0; count<5; count++) > { > SPDR = Ohm[count]; > while(!(SPSR & (1<<SPIF))); > } > Gut. Damit hast du mal die Funktionsfähigkeit deiner Ausgabe getestet. > > Nun wäre der nächste schritt eine Zeichenkette ausgeben. > Nein, das ist nicht der nächste Schritt. Der nächste Schritt ist es, eine Ausgabefunktion für ein einzelnes Zeichen zu schreiben, wobei das Zeichen nicht wie in deinem Ohm- Beispiel von vorne herein feststeht. Dazu, veränderst du erst mal dein Zeichensatzarray in ein 2-d Array. Die eine Dimension gibt dir die auszugebenden Codes, die andere Dimension ist der Code des Zeichens das auszugeben ist. Wenn du also ein Zeichen ausgeben willst, dann nimmst du den Code für dieses Zeichen her und interpretierst ihn als die Zeilennummer in deinem 2D Array und kriegst so die Zeile in der die 5 Codes stehen, die du ans Display schicken musst. Im Grunde kannst du deinen eigenen Code erfinden, aber es ist sehr viel simpler, wenn du einen gängigen Code benutzt. Der ASCII Code ist zb so einer. Einfach mal nach ASCII googlen. ASCII gibt dir die Umsetzung der Codezahlen von 0 bis 127 zu Buchstaben und sonstigen Zeichen, also genau das was du brauchst.
1 | char Zeichensatz[128][5] = // 128 Zeichen, 5 Displaycodes pro Zeichen |
2 | {
|
3 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x00 |
4 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x01 |
5 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x02 |
6 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x03 |
7 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x04 |
8 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x05 |
9 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x06 |
10 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x07 |
11 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x08 |
12 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x09 |
13 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0A |
14 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0B |
15 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0C |
16 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0D |
17 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0E |
18 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x0F |
19 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x10 |
20 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x11 |
21 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x12 |
22 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x13 |
23 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x14 |
24 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x15 |
25 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x16 |
26 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x17 |
27 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x18 |
28 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x19 |
29 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1A |
30 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1B |
31 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1C |
32 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1D |
33 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1E |
34 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x1F |
35 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x20 = Leerzeichen |
36 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x21 |
37 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x22 |
38 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x23 |
39 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x24 |
40 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x25 |
41 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x26 |
42 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x27 |
43 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x28 |
44 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x29 |
45 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2A |
46 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2B |
47 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2C |
48 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2D |
49 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2E |
50 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x2F |
51 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x30 = '0' |
52 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x31 = '1' |
53 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x32 = '2' |
54 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x33 = '3' |
55 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x34 = '4' |
56 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x35 = '5' |
57 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x36 = '6' |
58 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x37 = '7' |
59 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x38 = '8' |
60 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x39 = '9' |
61 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3A |
62 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3B |
63 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3C |
64 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3D |
65 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3E |
66 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x3F |
67 | { 0x00,0x00,0x00,0x00, 0x00 }, // 0x40 = '@' |
68 | { 0x7E,0x11,0x11,0x11,0x7E }, // 0x41 = 'A' |
69 | { 0x41,0x7F,0x49,0x49,0x36}, // 0x42 = 'B' |
70 | { 0x3E,0x41,0x41,0x41,0x22}, // 0x43 = 'C' |
71 | { 0x41,0x7F,0x41,0x41,0x3E}, // 0x44 = 'D' |
72 | { 0x7F,0x49,0x49,0x49,0x49}, |
73 | { 0x7F,0x09,0x09,0x09,0x01}, |
74 | { 0x3E,0x41,0x41,0x49,0x7A}, |
75 | { 0x7F,0x08,0x08,0x08,0x7F}, |
76 | { 0x00,0x41,0x7F,0x41,0x00}, |
77 | { 0x20,0x40,0x41,0x3F,0x01}, |
78 | { 0x7F,0x08,0x14,0x22,0x41}, |
79 | { 0x7F,0x40,0x40,0x40,0x40}, |
80 | { 0x7F,0x02,0x06,0x02,0x7F}, // 0x4D = 'M' |
81 | { 0x7F,0x06,0x08,0x30,0x7F}, |
82 | { 0x3E,0x41,0x41,0x41,0x3E}, |
83 | { 0x7F,0x09,0x09,0x09,0x06}, |
84 | { 0x3E,0x41,0x51,0x21,0x5E}, |
85 | { 0x7F,0x09,0x19,0x29,0x46}, |
86 | { 0x26,0x49,0x49,0x49,0x32}, |
87 | { 0x01,0x01,0x7F,0x01,0x01}, |
88 | { 0x3F,0x40,0x40,0x40,0x3F}, |
89 | { 0x1F,0x20,0x40,0x20,0x1F}, |
90 | { 0x7F,0x20,0x18,0x20,0x7F}, |
91 | { 0x63,0x14,0x08,0x14,0x63}, |
92 | { 0x07,0x08,0x70,0x08,0x07}, |
93 | { 0x61,0x51,0x49,0x45,0x43}, // 0x5A = 'Z' |
94 | { 0x00,0x00,0x00,0x00,0x00), |
95 | { 0x00,0x00,0x00,0x00,0x00), |
96 | { 0x00,0x00,0x00,0x00,0x00), |
97 | ....
|
98 | };
|
An der Stelle ... musst du noch Zeilen einsetzen um die restlichen Zeichen bis hoch zum Code 0x7F einsetzen (das sind dann 128 Zeichen) Dann brauchst du erst mal eine Funktion um ein einzelnes Zeichen auszugeben. Wie gesagt: Du nimmst den Code für das Zeichen und siehst damit in der Tabelle nach welche 5 Zeichen für diesen Code auszugeben sind
1 | void put_char( char character ) |
2 | {
|
3 | unsigned char count; |
4 | |
5 | for( count = 0; count<5; count++ ) |
6 | {
|
7 | SPDR = Zeichensatz[character][count]; |
8 | while( !(SPSR & (1<<SPIF)) ) |
9 | ;
|
10 | }
|
11 | }
|
Soweit so gut. Du kannst jetzt einzelne Zeichen ausgeben. zb. so
1 | int main() |
2 | {
|
3 | put_char( 'H' ); |
4 | put_char( 'A' ); |
5 | put_char( 'L' ); |
6 | put_char( 'L' ); |
7 | put_char( 'O' ); |
8 | |
9 | while( 1 ) |
10 | ;
|
11 | }
|
Stell sicher, dass das funktioniert! Dann gehst du erst mal her und ergänzt die fehlenden Zeichen in der Zeichensatztabelle. Such dir eine ASCII Tabelle im Web und geh die Zeichen durch. Weiter gehts: Jetzt bist du bereit, dir eine Funktion zu machen, die einen kompletten Text ausgeben kann. Du kannst dazu die bereits funktionierende put_char Funktion benutzen
1 | void put_string( char* text ) |
2 | {
|
3 | while( *text ) { |
4 | put_char( *text ) |
5 | text++; |
6 | }
|
7 | }
|
Benutzt wird diese Funktion zb so
1 | int main() |
2 | {
|
3 | char Text[] = "WELT"; |
4 | |
5 | put_string( "HALLO " ); |
6 | put_string( Text ); |
7 | }
|
Und dann liest du dir nochmal das Kapitel über Arrays in deinem Textbuch durch.
erstmal Vielen Dank! Werde das gleich mal morgen ah heute ausprobieren. Das der ASCII code, sich aus 5 mal 8 bit reihen zusammensetzt wusste ich nicht! Schreibe Morgen ob es geklappt hat. Gruß, Danke , Gute Nacht :-)
> Das der ASCII code, sich aus 5 mal 8 bit reihen zusammensetzt wusste > ich nicht! Das tut er auch nicht. Aber die Buchstaben, die du entworfen hast, setzten sich so zusammen. Irgendwie muß aber der ASCII-Code in deinen Zeichencode konvertiert werden. Dazu dient die Tabelle, bei der du den ASCII-Code direkt als Index verwenden kannst, um zu deinem dazugehörigen Zeichencode zu gelangen.
Vielen Dank hat alles super geklappt. Nur verstehe ich nicht woher der Compiler oder MC weiß das nach ASCII: put_char( 'H' ); das an der stelle 72 dez Steht. Eigentlich dürfte das doch nicht funktionieren!? Ich müste doch eigentlich put_char(72); schreiben um dann im Zeichensatz: SPDR = Zeichensatz[character][count]; die Zeile 72 auszugeben. Woher weiß der MC das H gleich der Code aus Zeile 72 ist ????
Micha wrote:
> Woher weiß der MC das H gleich der Code aus Zeile 72 ist ????
Weil 'H' und 72 das Selbe sind. Denke daran, dass ein µC sowas wie
Buchstaben gar nicht kennt. Er kennt nur Bitfolgen, also Zahlen.
Z.B. bei einem "HALLO" steht im Speicher die Zahlenfolge:
72 65 76 76 79 0
Ja gut, aber der Compiler muß den ASCII code kennen. Weil H könnte ja auch irgend eine andere Zahl sein. das heißt dann das der ASCII überall gilt. Also wenn ich Zeichen eingebe wird jedes Zeichen einer Zahl zugeordnet. Welche Zahl zu welchen Zeichen wurde einmahl im ASCII festgelegt. Richtig ? Das ist ja extrem praktisch, ich hatte schon angst das ich das alles selber definieren muß. Nochmal Vielen Dank an alle. Ist ne super Seite.
Hastu soweit richtig verstanden. Pass trotzdem auf, weil ASCII englischer Natur ist. Umlaute beispielsweise können - je nach Zeichensatz - an verschiedenen Stellen stehen.
Micha wrote: > Ja gut, aber der Compiler muß den ASCII code kennen. Weil H könnte ja > auch irgend eine andere Zahl sein. Wenn der Parser des Compilers ein in Hochkommata eingeschlossenes Zeichen sieht (z.B. eben 'H') oder einen aus mehreren Zeichen bestehenden Ausdruck in doppelten Hochkommata (also einen String, z.B. "Hallo!"), dann interpretiert er diese Zeichen automatisch als ASCII-Zeichen und ersetzt sie intern durch die entsprechenden Binärcodes. Bei dem String fügt er zusätzlich am Ende einen Nullterminator an, der das Ende des String kennzeichnet > das heißt dann das der ASCII überall gilt. Also wenn ich Zeichen eingebe > wird jedes Zeichen einer Zahl zugeordnet. Welche Zahl zu welchen Zeichen > wurde einmahl im ASCII festgelegt. Richtig ? Richtig. ASCII heißt American Standard Code for Information Interchange, und der wurde irgendwann einmal festgelegt. Allerdings sind im Prinzip nur 128 Zeichen dort definiert (7-Bit-ASCII). Die Erweiterungen auf 8 Bit sind nicht eindeutig festgelegt (z.B. bei vielen alphanumerischen LCDs aus Fernost eine Auswahl japanischer Schriftzeichen. Umlaute sind auch, wenn überhaupt vorhanden, in der zweiten Hälfte zu finden). Gerade das kann (je nach verwendetem Display) dazu führen, dass eben z.B. Umlaute nicht korrekt wiedergegeben werden, weil das Display einen anderen Zeichensatz verwendet. Die Ziffern, "normale" Buchstaben und Satzzeichen sind aber überall gleich.
> Na gut, aber der Compiler muß den ASCII code kennen. Ja. > Weil H könnte ja auch irgend eine andere Zahl sein. Richtig. > das heißt dann das der ASCII überall gilt. Naja, nicht überall. Nur ein kleines gallisches Dorf... ach nee, das war eine andere Geschichte ;-) Sagen wir mal so: ASCII und darauf aufsetzende Kodierungen sind sehr weit verbreitet. > Also wenn ich Zeichen eingebe wird jedes Zeichen einer Zahl zugeordnet. Richtig. > Welche Zahl zu welchen Zeichen wurde einmahl im ASCII festgelegt. Es wird vom Compiler festgelegt, der in diesem Fall ASCII verwendet.
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.