Benötige hilfe für Fonts

[HerrmannA (Gast)]

Hallo

Habe mir ein Nokia 6100 GLC mit Atmega 128 von Display 3000.

Dort sind zwar alle Beispiele in Bascom und auch nur die standart font
6x8 aber nirgendwo findet man etwas über die vorehensweise von Windows
Fonts auf einen GLCD.

Habe mir mal den Fontgen 2.0 geladen und die Fontarrays in den Atmega
EEPROM gelegt.

hier ist ein Array für ein "S"
unsigned char CharS[] = {
    /* 'S' 0x0053 charwidth: 9 */
    0x00, 0x00,   /*  [         ]  */
    0x00, 0x00,   /*  [         ]  */
    0x3F, 0x00,   /*  [  ****** ]  */
    0x61, 0x80,   /*  [ **    **]  */
    0x60, 0x00,   /*  [ **      ]  */
    0x60, 0x00,   /*  [ **      ]  */
    0x3F, 0x00,   /*  [  ****** ]  */
    0x01, 0x80,   /*  [       **]  */
    0x01, 0x80,   /*  [       **]  */
    0x61, 0x80,   /*  [ **    **]  */
    0x3F, 0x00,   /*  [  ****** ]  */
    0x00, 0x00,   /*  [         ]  */
    0x00, 0x00,   /*  [         ]  */
};

int drawchar()
{
 uint16_t index=0;
 uint8_t myByte=0;



window(40,54,60,74);


    int i,u,z;

  for(i=0;i<sizeof(CharS);i++)
  {
 myByte=eeprom_read_byte(&CharS[index]);


  for (u=0;u<8;u++)
{


if(myByte & 0x01)
{


sendData(Black);

}
else
{
sendData(White);
}

myByte >>= 1;
}


index++;

}
return 0;
}

void window(int x1,int x2,int y1,int y2)
{
 sendCMD(0x2A);
 sendData(x1);
 sendData(x2);
 sendCMD(0x2B);
 sendData(y1);
 sendData(y2);
 sendCMD(0x2C);


}

Als Ergenis auf dem Display ist ein schräggestelltes S zu sehen.

Was könnte hier falsch sein??

Danke

[HerrmannA (Gast)]

Habe mir mal die Bits ausgeben lassen über RS232.

ich glaube mein Problem ist dieses


0x3f=00111111;

über rs232 kommt 11111100;

wie kann ich nun die reihen folge ändern???

das die 0 als erstes kommt???

[HerrmannA (Gast)]

Hat sich erledigt

habe die bits eingelesen und rückwärts wieder ausgelesen jetzt gehts.

Danke

[Wegstabenverbuchsler (Gast)]

schön das wir helfen und an deinem Leiden teilhaben konnten g

[HerrmannA (Gast)]

Kann mir jemand sagen wie ich die fonts nutzen kann wie man den Index
berechnet für ein Char zb. "A" wie aus der Nokia 6100 Libary.

bekomme immer nur wirres zeugs als ob der index nicht stimmt.

[Karl H. (kbuchegg)]

Durch 'vergleichende Dateiforschung' hab ich folgendes
rausgefunden:

Am Anfang des ByteArrays steht ein Header. Der Aufbau des
Headers ist im Kommentar darüber dokumentiert.

Bsp:
Ich hab mir mal den Font 'Terminal' erzeugen lassen.
Der Anfang der Daten lautet:

    0x06, 0xFA, 0x06, 0x0C, 0x01, 0x01, 0xFE,

Wende ich jetzt die Beschreibung von weiter oben an, dann
lese ich:

  uint16_t font_size_in.....       06FA
  uint8_t  font_Width_in_Pixel     06
  uint8_t  font_Height_in_Pixel    0C
  uint8_t  font_Bits_per_Pixel      1
  uint8_t  font_First_Char          1
  uint8_t  font_Last_Char          FE

danach kommen laut Kommentar
 font_Last_Char - font_First_Char +1
Bytes die für jeden Character die tatsaechliche Pixelbreite
angibt. FE - 1 + 1 = FE, also 254

Ohne das jetzt nachgezählt zu haben, schaut das plausibel aus.
Da sind ungefähr 250 Bytes, die entweder alle Werte von 2 bis 5
enthalten.
Danach gehts weiter mit

    0xFE, 0x91, 0x24, 0x81, 0x92, 0x24, 0xFE, 0xE1, 0x1F, 0xB7, 0xF3,
0x37, 0xB7, 0xE3, 0x1F, 0x7C,

Wenn ich das mal binaer umwandle

  FE 11111110
  91 10010001
  24 00100100
  81 10000001
  92 10010010
  24 00100100
  FE 11111110
  E1 11100001


und immer 12 Bits zusammenfasse (Fonthöhe) ergibt sich
(Trickreicherweise sieht es so aus als ob die fehlenden Bits
links angefügt werden muessen, also so

  FE         11111110
           ^
           |
         ----
  91 10010001
)

     000111111110
     001001001001
     001010000001
     001001001001
     000111111110

um 90 Grad zur Seite gedreht und alle 1 durch * ersetzt
ergibt das


       ***
         
         
      **  *
         
         
      ** **
        *
         
       ***

und das entspricht dann eigentlich schon dem Muster im
Fonteditor.

Probier mal ein bischen rum. Lass dir einen Font generieren.
Dann setze ein Feld auf gefüllt und vergleiche was sich in der
Datei verändert. Damit hab ich das was ich bis jetzt habe
rausgefunden.

[Karl H. (kbuchegg)]

Ich hab mal ein DOS-Programm geschrieben, dass
die Daten auswertet. Das Ganze ist in keinster Weise
optimiert, sondern es geht nur darum, den Zugriff mal
zu testen.

#include <stdio.h>

typedef unsigned char uint8_t;
typedef unsigned short int uint16_t;

#define FONT Terminal

static uint8_t Terminal[] = {
    0x06, 0xFA, 0x06, 0x0C, 0x01, 0x01, 0xFE,
    0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x02, 0x05, 0x03, 0x05, 0x05,
0x04, 0x04, 0x04, 0x05, 0x04,

   ...
   ... hier kommen die Daten rein, so wie sie vom
   ... Fontgenerator kommen
   ...

    0xF0, 0x03, 0x11, 0x50, 0x02, 0x25, 0xB0, 0x01, 0x32, 0x90, 0x02,
0x29, 0x60, 0x02, 0x00, 0x80,
    0x0F, 0xF8, 0x80, 0x0F, 0x00
};

struct Font {
  uint16_t Len;
  uint8_t  Width;
  uint8_t  Height;
  uint8_t  Bits;
  uint8_t  First;
  uint8_t  Last;
};

struct Font* pDesc;
uint8_t* pWidths;
uint8_t* pData;
uint16_t Index[256];

uint8_t GetBit( uint16_t BitPos )
{
  uint16_t ByteNr = BitPos / 8;
  uint8_t BitNr = BitPos % 8;

  return ( pData[ ByteNr ] & ( 1 << BitNr ) ) != 0;
}

void PrintCharacter( uint8_t Code )
{
  uint16_t BitPos;
  uint8_t i, j, Bit;

  printf( "%d - %c (%d):\n", Code, Code, Index[Code] );

  BitPos = Index[Code] * pDesc->Height;
  printf( "Start: Byte %d, Bit %d\n", BitPos / 8, BitPos % 8 );

  for( i = 0; i < pWidths[Code - pDesc->First]; ++i ) {
    for( j = 0; j < pDesc->Height; ++j ) {
      Bit = GetBit( BitPos++ );
      if( Bit )
        printf( "*" );
      else
        printf( " " );
    }
    printf( "\n" );
  }
}

int main()
{
  uint8_t i;
  uint16_t Tmp;

  pDesc = (struct Font*)FONT;

  printf( "Total Length: %d\n", pDesc->Len );
  printf( "Width:   %d\n", pDesc->Width );
  printf( "Height:  %d\n", pDesc->Height );
  printf( "Bits:    %d\n", pDesc->Bits );
  printf( "Erstes:  %d\n", pDesc->First );
  printf( "Letztes: %d\n", pDesc->Last );

  pWidths = FONT + 7;
  pData   = FONT + 7 + ( FONT[6] - FONT[5] + 1 ) ;

  Tmp = 0;
  for( i = pDesc->First; i < pDesc->Last; ++i ) {
    Index[i] = Tmp;
    Tmp += pWidths[i - pDesc->First];
  }

  for( i = pDesc->First; i < pDesc->Last; ++i )
    PrintCharacter( i );
}

[Karl H. (kbuchegg)]

Ach ja.
Mit RLE (Run length encoding) kompremierten Fonts
kommt der Code nicht klar. Da wirst du selbst ran
muessen. Erkennbar ist RLE daran, dass das MSB in
'Bits' gesetzt ist. Anders ausgedrückt: sobald Bits
nicht mehr 1 ist, geht alles schief.