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