Font tool von Christian R. verbessert

[Stephan K. (dustpuppy)]

Hi zusammen,
ich weiss ja nicht, ob die Sache noch aktuell ist und irgend Wen noch 
interessiert. Es geht um diesen Beitrag: 
Beitrag "GLCD T6963C Font-Tool"
Erst mal muss ich sagen, ich finde das Fonttool richtig gut.
Nu kommt das Aber.
Da die Zeichen Pixel fuer Pixel geschrieben werden, ist die Ausgabe 
meiner Meinung nach etwas sehr langsam. Also hab ich mir mal die Muehe 
gemacht das Ganze komplett um zu kloeppeln. Ich schreibe die Daten byte 
weise auf das Display. Dafuer musste ich die Positionierung mit ein 
bisschen shifterei korrigieren, weil beim schreiben eines Bytes sonst 
das Zeichen immer verschoben war. Ausserdem musste ich auf das Inverse 
verzichten. Da bastel ich noch dran. Dafuer ist die Ausgabe jetzt aber 
transparent und ca. 8 mal schneller. Das Ganze laeuft ueber einen 
Puffer.
"lcd_char" gibt nur 1 Zeichen an der angegeben Position aus.
"lcd_print" geht durch den String durch und nutzt dann "lcd_char" um ihn 
anzuzeigen. "strlenght" ist nur eine Hilfe, weil es weniger Speicher 
braucht, als strlen.
Fuer Kritik bin ich immer offen. Wer eine Idee hat, wie man die inverse 
Darstellung hin bekommt, kann sich auch gerne melden.

uint8_t lcd_char(unsigned char x,unsigned char y, char in, const struct FONT_DEF *strcut1, unsigned char invers)
{
  uint8_t map;
  uint8_t width;
  uint16_t offset;
  uint8_t height;
  unsigned char buffer[glcd_BYTES_PER_ROW];
  
  uint8_t spalte,zeile;
  uint8_t counter=0;
  uint8_t buffer_counter=0;
  uint8_t pixel=0,bc;
  uint8_t o;
  
  map = in;                  // Index des Zeichens
  map = pgm_read_byte(&strcut1->mapping_table[map]);
  width = pgm_read_byte(&strcut1->width_table[map]);        // Breite des Zeichens
  offset = pgm_read_word(&strcut1->offset_table[map]);        // Die Startadresse, wo das Zeichen anfaengt
  height = strcut1->glyph_height;            // Die Hoehe des Fonts
  
  for(zeile=0;zeile<=height;zeile++)            // Zeilenweise lesen wir das Zeichen
  {
    glcd_goto(x,y+zeile);              // Zur Position auf dem Screen gehen
    for(spalte=0;spalte<((width-1)/8)+1;spalte++)        // Wir lesen pro Spalte nur soviel bytes, wie benoetigt
    {
      buffer[buffer_counter]=pgm_read_byte(&strcut1->glyph_table[offset+counter]);// Ein Byte lesen
      counter++;                // Zaehler erhoehen
      buffer_counter++;
      buffer[buffer_counter]=0;              // das naechste buffer byte loeschen, sonst steht muell drin
    }
    
    for(pixel=0;pixel<x-((x/8)*8);pixel++)          // Um soviel bits muessen wir das Zeichen nach rechts verschieben
    {
      for(bc=buffer_counter;bc>0;bc--)            // Rueckwaerts zaehlen, bis die Anzahl der gelesenen Bytes um 1 bit verschoben ist
      {
        buffer[bc]>>=1;                // Buffer um 1 bit nach rechts shiften
        buffer[bc]|=(buffer[bc-1] & 1<<0)<<7;          // Ueberlauf bit vom vorherigen byte holen
      }
      buffer[0]>>=1;                // Buffer 0 muss nur geshiftet werden, hier gibt's keinen Ueberlauf
    }

    glcd_goto(x,y+zeile);              // Zur Position auf dem Screen gehen
    for(o=0;o<=buffer_counter;o++)            // Alle bytes + 1 durchzaehlen
    {
      
      glcd_cput(0xC5);                // 0xC5 = Lese Display ohne adresse zu aendern
      buffer[o]|=glcd_dget();              // Hintergrund-byte mit buffer-byte zusammenfuegen
      glcd_dput(buffer[o]);              // Den buffer ausgeben
      glcd_cput(0xC0);                // 0xC0 = Schreibe und erhoehe die adresse +1
    }

    buffer_counter=0;

  }
  
  return width;                  // Rueckgabewert ist die Breite des Zeichens
}
/****************************************************************************
*
* Gives lenght of string
*
****************************************************************************/
uint8_t strlenght(const char *string) {
  const char *s;

  s = string;
  while (*s)
    s++;
  return s - string-1;
}

void lcd_print(unsigned char x, unsigned char y, const char *in,  const struct FONT_DEF *strcut1, unsigned char invers)
{
  unsigned int z;
  int width=x;
  for(z=0;z<=strlenght(in);z++)
  {
    width+=lcd_char(width,y,in[z],strcut1,invers);
      width--;
  }
    //glcd_box(s,y+2,s+width,y+h-1,TRUE);
}

Viel Spass

Dusty

[Erik .. (erik_mit_k)]

Hab mich noch nicht ganz hineingedacht aber ich denke du musst den aus 
dem Flash gelesenen Block nur bitweise invertieren...
so in etwa:

buffer[buffer_counter]= pgm_read_byte(&strcut1->glyph_table[offset+counter]);// Ein Byte lesen

if(invers > 0) buffer[buffer_counter]= ~buffer[buffer_counter];//bitweises invertieren des Blocks

[Christoph (Gast)]

Hallo,

im vorraus vielen Dank für diese Super Funktion.
Ich kam nicht umher, da ich diese auch gern für mein Projekt verwenden 
möchte,
einige kleine Modifikationen durch zu führe. Ich nutze einen Anderen 
Display
Treiber, daher.

Ich nutze den hier:

// Graphic LCD with Toshiba T6963 controller
// Copyright (c) Radoslaw Kwiecien, 2007r
// http://en.radzio.dxp.pl/t6963/

Ich musste also deine Schreib befehle anpassen. Das hat im nachhinein 
auch gut Funktioniert.
Ich habe nur festgestellt, dass wenn ich variablen anzeige, das feld 
überschrieben wird. Es werden also so zu sagen alle Zahlen die mal im
Speicher waren gleichzeitig angeziegt. Ich will nicht anmaßend sein, 
kann
das von diesen Zeilen kommen ?

      buffer[o]|=glcd_dget();              // Hintergrund-byte mit buffer-byte zusammenfuegen
      glcd_dput(buffer[o]);              // Den buffer ausgeben

Ich hab das mal Spaßeshalber in ein

buffer[o]=glcd_dget();              // Hintergrund-byte mit

geändert. Damit zeigt er jetzt auch immer nur den Aktuellen wert an.
Es flimmert nur. Hm..

Ich habe noch ein Bild angehängt, wie die Zeichen bei mir dargestellt 
werden,
auf dem Display. Irgendwie fehlt da nur etwas von den Ziffern.
Hängt das vielleicht mti meinem Treiber zusammen?

Ich hänge mal die ab geänderte Funktion mit an. Vielleicht kann mir wer 
dabei weiterhelfen :)

uint8_t GLCD_lcd_char(unsigned char x,unsigned char y, char in, const struct FONT_DEF *strcut1, unsigned char invers)
{
  uint8_t map;
  uint8_t width;
  uint16_t offset;
  uint8_t height;
  unsigned char buffer[GLCD_GRAPHIC_AREA];
  
  uint8_t spalte,zeile;
  uint8_t counter=0;
  uint8_t buffer_counter=0;
  uint8_t pixel=0,bc;
  uint8_t o;
  
  map = in;                  // Index des Zeichens
  map = pgm_read_byte(&strcut1->mapping_table[map]);
  width = pgm_read_byte(&strcut1->width_table[map]);        // Breite des Zeichens
  offset = pgm_read_word(&strcut1->offset_table[map]);        // Die Startadresse, wo das Zeichen anfaengt
  height = strcut1->glyph_height;            // Die Hoehe des Fonts
  
  for(zeile=0;zeile<=height;zeile++)            // Zeilenweise lesen wir das Zeichen
  {
    GLCD_GraphicGoTo(x,y+zeile);              // Zur Position auf dem Screen gehen
    for(spalte=0;spalte<((width-1)/8)+1;spalte++)        // Wir lesen pro Spalte nur soviel bytes, wie benoetigt
    {
      buffer[buffer_counter]= pgm_read_byte(&strcut1->glyph_table[offset+counter]);// Ein Byte lesen
      if(invers > 0) buffer[buffer_counter]= ~buffer[buffer_counter];//bitweises invertieren des Blocks
    counter++;                // Zaehler erhoehen
      buffer_counter++;
      buffer[buffer_counter]=0;              // das naechste buffer byte loeschen, sonst steht muell drin
    }
    
    for(pixel=0;pixel<x-((x/8)*8);pixel++)          // Um soviel bits muessen wir das Zeichen nach rechts verschieben
    {
      for(bc=buffer_counter;bc>0;bc--)            // Rueckwaerts zaehlen, bis die Anzahl der gelesenen Bytes um 1 bit verschoben ist
      {
        buffer[bc]>>=1;                // Buffer um 1 bit nach rechts shiften
        buffer[bc]|=(buffer[bc-1] & 1<<0)<<7;          // Ueberlauf bit vom vorherigen byte holen
      }
      buffer[0]>>=1;                // Buffer 0 muss nur geshiftet werden, hier gibt's keinen Ueberlauf
    }

    GLCD_GraphicGoTo(x,y+zeile);              // Zur Position auf dem Screen gehen
    for(o=0;o<=buffer_counter;o++)            // Alle bytes + 1 durchzaehlen
    {
      
      GLCD_WriteCommand(T6963_DATA_READ_AND_NONVARIABLE);        // 0xC5 = Lese Display ohne adresse zu aendern
      // Das ist auch noch nicht der Weisheit letzter Schluss
    //buffer[o] = GLCD_ReadData();              // Hintergrund-byte mit buffer-byte zusammenfuegen
      GLCD_WriteData(buffer[o]);              // Den buffer ausgeben
      GLCD_WriteCommand(T6963_DATA_WRITE_AND_INCREMENT);           // 0xC0 = Schreibe und erhoehe die adresse +1
    }

    buffer_counter=0;

  }
  
  return width;                  // Rueckgabewert ist die Breite des Zeichens
}

Meinen kompletten Display Treiber hänge ich auch mal mit an
Mit meinem Modifikationen. Ist sehr viel gebastel drin bitte nicht all 
zu stren sein :)

[Christoph (Gast)]

Hallo nochmal

okay ich bin der sache auf die schliche gekommen.

Mein Display arbeitet im 6Bit Modus. Das würde erklären warum 1.
teile der Buchstaben fehlen und 2. die Anordnung nicht passt!

Weis jemand ein Font tool das Zeichen in 6 Bit konvertiert vielleicht?

Grüße
Christoph