Tabelle (Zeichensatz) auslesen?

**izaseba** · 01.08.2007, 00:48

Klar hat const einen Sinn. Du willst ja auch Deine Arrays im Flash ablegen, Du mußt es aber dem Kompiler so mitteilen:

Code:

const uint8_t beispiel PROGMEM = 255;

Willst Du z.B. die Konstante auf ein Port ausgeben mußt Du es mit
pgm_read_byte() auslesen z.B. so

Code:

PORTB = pgm_read_byte(&beispiel);

Wichtig ist, daß Du pgm_read_byte einen Zeiger auf die Flashadresse übergibst.
Nachlesen kannst Du es z.B. hier

Tja, Buch...
Vergiss es, es gibt kein Buch, das von C und AVR handelt.
Ich kann Dir wirklich das obengenannte Werk "Programmieren in C" von den Vätern der Sprache empfehlen, klar ist es für PC gedacht, es macht aber nichts, die Unterschiede sind nicht so groß.
Dafür gibt es das Tutorial auf www.mikrocontroller.net und die AVR libc Doku auf http://www.nongnu.org/avr-libc/user-manual/index.html
Gruß Sebastian
P.S.

Am Anfang erschlagt einem der Umfang von den neuen Befehlen

In C gibt es etwa 30 Befehle, das ist doch nicht viel, oder

Schon klar, aber ich habe halt da einen Code in Bascom der da funktioniert und denn will ich als erste Aufgabe, in C mal umschreiben.

Manchmal kann man Sachen nicht 1:1 übersetzen, man muß halt komplett umdenken.

P.P.S Irgendwo hab ich noch meinen Code für eine Propelleruhr, da hab ich es ähnlich gemacht, muß mal morgen danach gucken, kannst Du Dir als Beispiel anschauen.

**Roberto** · 01.08.2007, 02:28

Hallo izaseba

Willst Du z.B. die Konstante auf ein Port ausgeben musst Du es mit
pgm_read_byte() auslesen z.B. so

Eine blöde Frage:
Was passiert, wenn ich es nicht so mache ?

Habe mich jetzt weitergespielt und kann jetzt schon mal den Zeichensatz am LCD ausgeben.
(nur mit Const..... und normalem Zugriff (Datensatz [][] ))
Funktioniert eigentlich soweit

(Compiler= CodeVison)

l.G. Roberto
Ps.:
Habs im Tutorial nachgelesen.
Ganz verstehe ich es zwar noch nicht, aber kann es vielleicht deshalb funktionieren, weil ich keinen AVR-GCC verwende?

**Sternthaler** · 01.08.2007, 04:01

Hallo Roberto,
wegen eines Buches zu C und AVR kann auch ich nicht weiterhelfen. Allerdings ist der von izaseba angegebene Link doch eigendlich dann genau richtig um mal einen kompletten Überblick zu erhalten.

Zu deiner Frage: "Was passiert, wenn ich es nicht so mache?":
Als Vermutung kann ich nur annehmen, dass die Funktion pgm_read_byte eben deshalb notwendig ist, da ja schon der Assembler-Befehl nun mal anders ist wenn im RAM bzw. im FLASH Daten gelesen werden sollen. Somit hat da irgendjemand die Funktion pgm_read_byte() geschrieben damit du es leichter hast.

Was izaseba mit den 30 Befehlen von C meint, ist natürlich nur das reine 'Grundgerüst'. Je nachdem wie viele Lib's du dazu holst wächst das was du zur Zeit als Befehl ansieht 'etwas' an. Vielleicht hilft der Begriff Unterfunktion oder Subfunction aus Basic eher um einen Vergleich zu den aus Lib's kommenden 'Befehlen' zu erklären.
Im allgemeinen musst du ein #include in deinen Sourcen aufnehmen. Alle in diesem Include declarierten 'Funktionen' sind z.B. solche Unterfunktionen. Es bleibt also beim "Kernighan und Ritchie" von izaseba.

Beim Compiler ist es fast egal welchen man nimmt, solange der auch Code für die gewünschte 'Zielmaschine' (also ATmega) produzieren kann.

P.S.: Tutorial lesen ist immer gut. Nicht alles verstehen, heißt eigendlich: Ich habe einen Teil verstanden. Das ist Erfolg

**Roberto** · 01.08.2007, 10:35

Danke Euch einstweilen!

Werde das mit dem Const einstweilen so lassen...
Wenns Probleme gibt, kann ich es ja mal mit den Befehlen probieren...
Jetzt brauche ich dann nur mehr einen Befehl wo ich Strings umwandeln kann..
Aber da werde ich eventuell einen anderen Thread aufmachen

P.S.: Tutorial lesen ist immer gut. Nicht alles verstehen, heißt eigendlich: Ich habe einen Teil verstanden. Das ist Erfolg

Danke für die aufmunterten Worte

Wird schon werden

Wegen Buch:
Schade das es da nix für den AVR gibt

Dann werde ich derzeit mal nix kaufen.

l.G. Roberto

Ps.:

P.P.S Irgendwo hab ich noch meinen Code für eine Propelleruhr, da hab ich es ähnlich gemacht, muß mal morgen danach gucken, kannst Du Dir als Beispiel anschauen.

Ja, dass wäre sehr nett! \

/
Da könnte ich auch gleich bei der Stringumwandlung nachschauen

(in Bascom hatte ich das auch schon mal gemacht)

**izaseba** · 01.08.2007, 17:43

Funktioniert eigentlich soweit
(Compiler= CodeVison)

HALT

Hab ich das irgendwo überlesen

Mein Ausführungen beziehen sich auf GCC !
Es kann sein, daß CodeVision es anders macht, vielleicht braucht man hier kein PROGMEM und pgm_read*
Damit ist das Tutorial auch nicht ganz richtig für Dich, das weiß ich aber nicht.
Hmm, da hilft nur probieren, es hat mich auch die Warnung mit Stack gewundert, weil soweit ich weiß gibt GCC keine Warnungen dieser Art, das weiß ich auch nur von lesen im Forum, selber habe ich es noch nicht probiert Ram zu sprengen

Wie dem auch sei, schön das es bei Dir klappt, darf ich fragen, warum Codevision ?
Mußt Du es beruflich einsetzen ?
Ich mein irgendwo muß es einen Vorteil geben, aber viel Hilfe wirst Du damit nicht bekommen(Zumindest nicht hier, vielleicht bei mikrocontroller.net)

Gruß Sebastian

P.S.

Zu deiner Frage: "Was passiert, wenn ich es nicht so mache?":
Als Vermutung kann ich nur annehmen, dass die Funktion pgm_read_byte eben deshalb notwendig ist, da ja schon der Assembler-Befehl nun mal anders ist wenn im RAM bzw. im FLASH Daten gelesen werden sollen. Somit hat da irgendjemand die Funktion pgm_read_byte() geschrieben damit du es leichter hast.

Genau so ist es, C wurde für Maschinen geschrieben, bei denen sich alles in Ram abspielt (Du weißt ja,AVR hat getrennte Daten und Programmräume)

Damit gibt es bei AVR 3 mal gleiche Speicheradressen im Ram,Flash und EEPROM.
Damit der arme Kompiler weißt, woher er die Werte nehmen soll gibt es halt dieses PROGMEM, was einfach nur sagt, diese Konstante soll bitteschön in den Flash, und eben noch pgm_read* um zu sagen, ich möchte aus dem Flash lesen und nicht aus dem Ram.
Wenn man es nicht beachtet gibt es Salat und man sucht ziemlich lange nach dem Fehler.
Genauso ist es mit Zeigern, man muß anders einen Zeiger auf Werte im Flash deklarieren und anders auf Werte im Ram und noch anders auf EEprom.

Ich weiß aber nicht wieweit es bei Codevision wichtig ist! Da mußt Du schon selber in der Doku zu Deinem Kompiler nachschlagen

**Roberto** · 01.08.2007, 22:06

Hallo Izaseba

darf ich fragen, warum Codevision ?
musst Du es beruflich einsetzen ?

Nein eigentlich nicht.

Habe zuerst mal mit dem GCC probiert, aber das mit Make-File war mir ein bisschen zu blöd

Dann habe ich einen Tipp für CodeVision bekommen.

Bis jetzt kann ich nichts negatives sagen

Schöne Übersichten über alle Variablen, Funktionen und Include-Files, die man verwendet.
Einen klick für Make und einen Klick zum schreiben in den AVR
und fertig ist die Laube \

/

Genau so ist es, C wurde für Maschinen geschrieben, bei denen sich alles in Ram abspielt (Du weißt ja,AVR hat getrennte Daten und Programmräume)

Darum wundert es mich auch ein bisschen, dass es da noch keine Bücher gibt. Ein Marktlücke ?

Ps.:
Findest Du deinen Code für die Propelleruhr noch ?
Würde mich sehr interessieren

l.G. Roberto

**izaseba** · 01.08.2007, 23:42

Darum wundert es mich auch ein bisschen, dass es da noch keine Bücher gibt. Ein Marktlücke ?

Vielleicht, vielleicht auch nicht, ich finde die Entwicklung geht ziemlich schnell, das Buch könnte schon veraltet sein, bevor es überhaupt rausgekommen ist

Findest Du deinen Code für die Propelleruhr noch ?
Würde mich sehr interessieren

Ja kein Problem, mein Programme halte ich mehrfach gespeichert

Ich wollte Teile davon als Beispiel für den Flashzugriff zeigen, da es aber in Codevision wohl doch anders geht ist es unnötig, aber naja, so habe ich das gemacht und zwar zuerst ein 2D Array für Zahlen und Buchstaben, ich wollte nicht die Ganze ASCII Tabelle implementieren sondern nur das wichtigste sie sieht etwa so aus:

Code:

/* Alphabet kleine Buchstaben*/
const uint8_t zeichen_k[][5] PROGMEM  = {
  /*0*/
  { 0x83,0x75,0x6D,0x5D,0x83 },
  /*1*/
  { 0xFF,0xBD,0x01,0xFD,0xFF },
  /*2*/
  { 0xBD,0x79,0x75,0x6D,0x9D },  
  /*3*/
  { 0x7B,0x7D,0x5D,0x2D,0x73 },
  /*4*/
  { 0xE7,0xD7,0xB7,0x01,0xF7 },
  /*5*/
  { 0x1B,0x5D,0x5D,0x5D,0x63 },
  /*6*/
  { 0xC3,0xAD,0x6D,0x6D,0xF3 },
  /*7*/
  { 0x7F,0x71,0x6F,0x5F,0x3F },
  /*8*/
  { 0x93,0x6D,0x6D,0x6D,0x93 },
  /*9*/
  { 0x9F,0x6D,0x6D,0x6B,0x87 }, 
  /*a*/
  { 0xFB,0xD5,0xD5,0xD5,0xE1 },
  /*b*/
  { 0x01,0xED,0xDD,0xDD,0xE3 },
  /*c*/
  { 0xE3,0xDD,0xDD,0xDD,0xFB },
  /*d*/
  { 0xE3,0xDD,0xDD,0xED,0x01 },
  /*e*/
  { 0xE3,0xD5,0xD5,0xD5,0xE7 },
  /*f*/
  { 0xEF,0x81,0x6F,0x7F,0xBF },
  /*g*/
  { 0xE7,0xDA,0xDA,0xDA,0xC1 },
  /*h*/
  { 0x01,0xEF,0xDF,0xDF,0xE1 },
  /*i*/
  { 0xFF,0xDD,0x41,0xFD,0xFF },
  /*j*/
  { 0xFD,0xFE,0xDE,0x41,0xFF },
  /*k*/
  { 0x01,0xF7,0xEB,0xDD,0xFF },
  /*l*/
  { 0xFF,0x7D,0x01,0xFD,0xFF },
  /*m*/
  { 0xC1,0xDF,0xE7,0xDF,0xE1 },
  /*n*/
  { 0xC1,0xEF,0xDF,0xDF,0xE1 },
  /*o*/
  { 0xE3,0xDD,0xDD,0xDD,0xE3 },
  /*p*/
  { 0xE0,0xEB,0xEB,0xEB,0xF7 },
  /*q*/
  { 0xF7,0xEB,0xEB,0xF3,0xE0 },
  /*r*/
  { 0xC1,0xEF,0xDF,0xDF,0xEF },
  /*s*/
  { 0xED,0xD5,0xD5,0xD5,0xFB },
  /*t*/
  { 0xDF,0x03,0xDD,0xFD,0xFB },
  /*u*/
  { 0xC3,0xFD,0xFD,0xFB,0xC1 },
  /*v*/
  { 0xC7,0xFB,0xFD,0xFB,0xC7 },
  /*w*/
  { 0xC3,0xFD,0xF3,0xFD,0xC3 },
  /*x*/
  { 0xDD,0xEB,0xF7,0xEB,0xDD },
  /*y*/
  { 0xCF,0xF6,0xF6,0xF6,0xC1 },
  /*z*/
  { 0xDD,0xD9,0xD5,0xCD,0xDD },
 /*SPACE*/
  { 0xFF,0xFF,0xFF,0xFF,0xFF },
  /*:*/
  { 0xFF,0x93,0x93,0xFF,0xFF }

Die Tabelle ist aber Vertikal organisiert (Ist ja eine Propelleruhr, muß also Vertikal eingeblendet werden)
Die Zahlen krieg ich aus einer RTC im gepacktem BCD Format in einer Freien mS werden die Nibbles zerschlagen, womit ich dann die Uhrzeit im normalem binärem Format stehen habe, darum fängt die Null bei zeichen_k[0][] an die 9 steht dann bei [9]
Damit Spare ich mir irgendwelche Umrechnungen

Es müssen noch Monate und Wochentage implementiert werden, da
hab ich solch ein Array erstellt:

Code:

   {36,36,'s'-87,'o'-87,'n'-87,'n'-87,'t'-87,'a'-87,'g'-87,36              },
  { 36,36,'m'-87,'o'-87,'n'-87,'t'-87,'a'-87,'g'-87,36,36                 },
  { 36,'d'-87,'i'-87,'e'-87,'n'-87,'s'-87,'t'-87,'a'-87,'g'-87,36         },
  { 36,'m'-87,'i'-87,'t'-87,'t'-87,'w'-87,'o'-87,'c'-87,'h'-87,36         },
  { 'd'-87,'o'-87,'n'-87,'n'-87,'e'-87,'r'-87,'s'-87,'t'-87,'a'-87,'g'-87 },
  { 36,36,'f'-87,'r'-87,'e'-87,'i'-87,'t'-87,'a'-87,'g'-87,36             },
  { 36,36,'s'-87,'a'-87,'m'-87,'s'-87,'t'-87,'a'-87,'g'-87,36             }
  
};

Die RTC liefert eine 0 für Sonntag 1 für Montag usw.

Um einen einfachen Zugriff auf meine ASCII Tabelle zu bekommen, habe ich zwar die Buchstaben als ASCII Zeichen eingefügt gleichzeitig aber 87 davon abgezogen womit ich auch direkte Adressierung im Array bekomme (Zur Info es wird zu Kompilierzeit subtrahiert es verbraucht also keine Resourcen zu Laufzeit)
naja 36 ist dann direkt die Leerzeile.

der Rest ist denkbar einfach, ein Externer Interrupt startet einen Timer, in dem die Werte aus dem Flash ausgelesen werden, jedes Zeichen kriegt ein Zeitfenster, eine Variable wird inkrementiert um in den vertikalen Strichen weiterzuwandern, fertig es sieht etwa so aus:

Code:

  if (flags.dat_tim == 0){
	tmp = pgm_read_byte(&zeichen_k[time[zahl]][val]);
        PORTD =  tmp & 0xC0;
	PORTB = tmp & 0x3F;
      } else {
	tmp = pgm_read_byte(&zeichen_k[date[zahl]][val+tmp2]);
	asm volatile (
	    
	    "ldi %2,8"          "\n\t"
	    "0:"                "\n\t"
	    "lsr %0"            "\n\t"
            "rol __tmp_reg__"   "\n\t"
            "dec %2"            "\n\t"
            "brne  0b" "\n\t"
            "mov %0,__tmp_reg__" "\n\t"
	    : "=a" (tmp)
	    : "0" (tmp), "a" (count) 
);
	PORTD = tmp & 0xC0;
	PORTB = tmp & 0x3F;
	tmp2 += 2;
      }

Ich will das ganze jetzt nicht weiter komentieren,
zahl ist wohl das Zeichen, das dargestellt werden soll, wohl global definiert und in der Hauptschleife gefüllt
val ist eine statische Variable die in jedem interrupt inkrementiert wird um das ASCII Array durchzuwandern
Der Inlineassembler dreht mir jetzt die Bits um, es wrd ja was oben und was unten gezeigt, unten müssen die Zeichen "auf dem Kopf" dargestellt werden ( aus z.B 11000000 muß dann 0000011 werden)
Da ich keine C idee hatte wurde halt zum Assembler gegriffen

Puh, wenn Du jetzt was mit anfangen kannst...

Gruß Sebastian

**Sternthaler** · 01.08.2007, 23:48

Hallo

Zitat von izaseba

Es kann sein, daß CodeVision es anders macht, vielleicht braucht man hier kein PROGMEM und pgm_read*

Ich kenn mich mit CodeVision zwar nicht besonders aus, aber eigendlich kann es auch dort keinen 'Wahrsager' geben, der vorraussieht wohin ich meine Byte's schreiben möchte.
Von daher bleibt wirklich nur:

Zitat von izaseba

Da musst Du schon selber in der Doku zu Deinem Kompiler nachschlagen

**Roberto** · 01.08.2007, 23:58

Hallo Sebastian

Puh, wenn Du jetzt was mit anfangen kannst...

Ganz zwar nicht, aber danke für die Mühe!!
Ich dachte Du hast da vielleicht eine String zerlegung drinnen, aber Du verwendest da nur Zahlen.

Muss mich jetzt mal umschauen um so eine Zerlegung

(möchte das heute vielleicht noch zum laufen bekommen)

l.G. Roberto