www.mikrocontroller.net

Forum: Compiler & IDEs String Array bestehend aus Arrays Hilfe


Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Karl Heinz (kbuchegg) (Moderator)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.
char Zeichensatz[128][5] =   // 128 Zeichen, 5 Displaycodes pro Zeichen
{
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x00
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x01
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x02
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x03
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x04
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x05
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x06
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x07
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x08
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x09
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0A
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0B
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0C
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0D
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0E
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x0F
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x10
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x11
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x12
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x13
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x14
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x15
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x16
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x17
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x18
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x19
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1A
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1B
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1C
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1D
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1E
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x1F
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x20  = Leerzeichen
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x21
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x22
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x23
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x24
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x25
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x26
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x27
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x28
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x29
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2A
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2B
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2C
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2D
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2E
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x2F
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x30   = '0'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x31   = '1'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x32   = '2'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x33   = '3'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x34   = '4'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x35   = '5'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x36   = '6'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x37   = '7'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x38   = '8'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x39   = '9'
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3A
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3B
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3C
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3D
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3E
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x3F
  { 0x00,0x00,0x00,0x00, 0x00 },     // 0x40   = '@'
  { 0x7E,0x11,0x11,0x11,0x7E },      // 0x41   = 'A'
  { 0x41,0x7F,0x49,0x49,0x36},       // 0x42   = 'B'
  { 0x3E,0x41,0x41,0x41,0x22},       // 0x43   = 'C'
  { 0x41,0x7F,0x41,0x41,0x3E},       // 0x44   = 'D'
  { 0x7F,0x49,0x49,0x49,0x49},
  { 0x7F,0x09,0x09,0x09,0x01},
  { 0x3E,0x41,0x41,0x49,0x7A},
  { 0x7F,0x08,0x08,0x08,0x7F},
  { 0x00,0x41,0x7F,0x41,0x00},
  { 0x20,0x40,0x41,0x3F,0x01},
  { 0x7F,0x08,0x14,0x22,0x41},
  { 0x7F,0x40,0x40,0x40,0x40},
  { 0x7F,0x02,0x06,0x02,0x7F},       // 0x4D = 'M'
  { 0x7F,0x06,0x08,0x30,0x7F},
  { 0x3E,0x41,0x41,0x41,0x3E},
  { 0x7F,0x09,0x09,0x09,0x06},
  { 0x3E,0x41,0x51,0x21,0x5E},
  { 0x7F,0x09,0x19,0x29,0x46},
  { 0x26,0x49,0x49,0x49,0x32},
  { 0x01,0x01,0x7F,0x01,0x01},
  { 0x3F,0x40,0x40,0x40,0x3F},
  { 0x1F,0x20,0x40,0x20,0x1F},
  { 0x7F,0x20,0x18,0x20,0x7F},
  { 0x63,0x14,0x08,0x14,0x63},
  { 0x07,0x08,0x70,0x08,0x07},
  { 0x61,0x51,0x49,0x45,0x43},       // 0x5A = 'Z'
  { 0x00,0x00,0x00,0x00,0x00),
  { 0x00,0x00,0x00,0x00,0x00),
  { 0x00,0x00,0x00,0x00,0x00),
   ....
};

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
void put_char( char character )
{
  unsigned char count;

  for( count = 0; count<5; count++ )
  {
    SPDR = Zeichensatz[character][count];
    while( !(SPSR & (1<<SPIF)) )
      ;
  }
}

Soweit so gut. Du kannst jetzt einzelne Zeichen ausgeben.
zb. so
int main()
{
  put_char( 'H' );
  put_char( 'A' );
  put_char( 'L' );
  put_char( 'L' );
  put_char( 'O' );

  while( 1 )
    ;
}

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
void put_string( char* text )
{
  while( *text ) {
    put_char( *text )
    text++;
  }
}

Benutzt wird diese Funktion zb so
int main()
{
  char Text[] = "WELT";

  put_string( "HALLO " );
  put_string( Text );
}

Und dann liest du dir nochmal das Kapitel über Arrays in deinem
Textbuch durch.

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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 :-)

Autor: Rolf Magnus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.

Autor: Micha (Gast)
Datum:
Angehängte Dateien:

Bewertung
0 lesenswert
nicht lesenswert
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 ????

Autor: Stefan Ernst (sternst)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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

Autor: Micha (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Sven P. (haku) Benutzerseite
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Hastu soweit richtig verstanden. Pass trotzdem auf, weil ASCII 
englischer Natur ist. Umlaute beispielsweise können - je nach 
Zeichensatz - an verschiedenen Stellen stehen.

Autor: Johannes M. (johnny-m)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
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.

Autor: Rolf Magnus (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
> 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.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.