Tablas ASCII para conversion de Fuentes...

[J1M]

Os cuento, estoy tratando de hacer una libreria para el Display Grafico con el chip PCF8833 (Nokia 6100 Color), tengo que crear las fuentes y la verdad no tengo ni idea de como hacerlo, he visto otras tablas en la libreria del 3310, pero me gustaría generarme la mia propia para así poder usar el tamaño de tipo de fuente que yo quiera... He visto que Lager ha hecho un programa para ello, pero la salida que me da es esta:

Codigo:
$00,$00,$00,$00,          //  Espacio
$BF,$00,$00,$00          //  !
$07,$00,$00,$00,$07,$00,$00,$00          //  "
$E4,$00,$7F,$00,$E7,$00,$FC,$00,$2F,$00,$24,
$00,$00,$00          //  #
$46,$00,$CF,$00,$FF,$01,$99,$00,$F3,$00,$00,
$00          //  $
$06,$00,$0F,$00,$89,$00,$EF,$00,$38,$00,$6E,
$00,$F3,$00,$91,$00,$F0,$00,$00,$00          //  %
$70,$00,$D7,$00,$9D,$00,$BF,$00,$E7,$00,$F0,
$00,$80,$00          //  &
$07,$00,$00,$00          //  "
$78,$00,$FE,$01,$03,$03,$00,$00          //  (
$01,$02,$03,$03,$FC,$00,$00,$00          //  )
$0A,$00,$0F,$00,$0E,$00,$02,$00,$00,$00          //  *
$10,$00,$10,$00,$7C,$00,$10,$00,$10,$00,$10,
$00          //  +
$80,$00,$80,$03,$00,$00          //  ,
$20,$00,$20,$00,$20,$00,$20,$00          //  -
$80,$00,$80,$00,$00,$00          //  .
$F0,$00,$3E,$00,$03,$00,$00,$00          //  /
$7E,$00,$FF,$00,$81,$00,$C3,$00,$7E,$00,$00,
$00          //  0
$00,$00,$06,$00,$FF,$00,$FF,$00,$00,$00          //  1
$C2,$00,$E3,$00,$B1,$00,$99,$00,$8F,$00,$00,
$00          //  2
$42,$00,$C3,$00,$89,$00,$8F,$00,$76,$00,$00,
$00          //  3
$30,$00,$38,$00,$26,$00,$FF,$00,$20,$00,$00,
$00          //  4
$4C,$00,$CF,$00,$89,$00,$89,$00,$79,$00,$00,
$00          //  5
$7E,$00,$DB,$00,$89,$00,$89,$00,$7B,$00,$00,
$00          //  6
$01,$00,$E1,$00,$F9,$00,$0F,$00,$03,$00,$00,
$00          //  7
$76,$00,$DF,$00,$89,$00,$89,$00,$F7,$00,$20,
$00          //  8
$4E,$00,$DB,$00,$91,$00,$D1,$00,$7E,$00,$00,
$00          //  9
$84,$00,$84,$00,$00,$00          //  :
$84,$00,$84,$03,$00,$00          //  ;
$10,$00,$38,$00,$28,$00,$28,$00,$44,$00,$00,
$00          //  <
$28,$00,$28,$00,$28,$00,$28,$00,$28,$00,$00,
$00          //  =
$44,$00,$6C,$00,$28,$00,$28,$00,$10,$00,$00,
$00          //  >
$02,$00,$03,$00,$B1,$00,$19,$00,$0F,$00,$00,
$00          //  ?
$F8,$00,$FE,$01,$72,$01,$DF,$02,$85,$02,$C5,
$02,$FD,$02,$8F,$02,$E6,$03,$7C,$01,$00,$00          //  @
$E0,$00,$78,$00,$2E,$00,$23,$00,$2E,$00,$38,
$00,$E0,$00,$80,$00          //  A
$FF,$00,$FF,$00,$89,$00,$89,$00,$DF,$00,$7E,
$00,$00,$00          //  B
$3C,$00,$7E,$00,$81,$00,$81,$00,$C3,$00,$46,
$00,$00,$00          //  C
$FF,$00,$FF,$00,$81,$00,$81,$00,$C3,$00,$7E,
$00,$00,$00          //  D
$FF,$00,$FF,$00,$89,$00,$89,$00,$89,$00,$00,
$00          //  E
$FF,$00,$FF,$00,$09,$00,$09,$00,$09,$00,$00,
$00          //  F
$3C,$00,$7E,$00,$C3,$00,$81,$00,$91,$00,$93,
$00,$76,$00,$00,$00          //  G
$FF,$00,$FF,$00,$08,$00,$08,$00,$FF,$00,$FF,
$00,$00,$00          //  H
$FF,$00,$FF,$00,$00,$00          //  I
$C0,$00,$80,$00,$FF,$00,$7F,$00,$00,$00          //  J
$FF,$00,$FF,$00,$0C,$00,$3E,$00,$63,$00,$C1,
$00,$81,$00,$00,$00          //  K
$FF,$00,$FF,$00,$80,$00,$80,$00,$80,$00,$80,
$00          //  L
$FF,$00,$FF,$00,$3E,$00,$E0,$00,$7C,$00,$0F,
$00,$FF,$00,$00,$00          //  M
$FF,$00,$FF,$00,$0E,$00,$38,$00,$E0,$00,$FF,
$00,$00,$00          //  N
$3C,$00,$7E,$00,$C3,$00,$81,$00,$81,$00,$E7,
$00,$7E,$00,$00,$00          //  O
$FF,$00,$FF,$00,$11,$00,$11,$00,$1F,$00,$0E,
$00,$00,$00          //  P
$3C,$00,$7E,$00,$C3,$00,$81,$00,$C1,$00,$E7,
$00,$BE,$00,$00,$00          //  Q
$FF,$00,$FF,$00,$11,$00,$31,$00,$7B,$00,$CF,
$00,$80,$00,$00,$00          //  R
$46,$00,$CF,$00,$89,$00,$99,$00,$93,$00,$72,
$00,$00,$00          //  S
$01,$00,$01,$00,$FF,$00,$01,$00,$01,$00,$01,
$00,$00,$00          //  T
$7F,$00,$FF,$00,$80,$00,$80,$00,$FF,$00,$7F,
$00,$00,$00          //  U
$03,$00,$1E,$00,$78,$00,$C0,$00,$F0,$00,$3C,
$00,$07,$00,$01,$00,$00,$00          //  V
$0F,$00,$FC,$00,$E0,$00,$3E,$00,$03,$00,$1F,
$00,$F0,$00,$F8,$00,$1F,$00,$01,$00,$00,$00          //  W
$81,$00,$67,$00,$3C,$00,$18,$00,$76,$00,$C3,
$00,$81,$00,$00,$00          //  X
$01,$00,$06,$00,$0C,$00,$F0,$00,$0C,$00,$06,
$00,$03,$00,$00,$00          //  Y
$C1,$00,$E1,$00,$B1,$00,$9D,$00,$87,$00,$83,
$00,$81,$00          //  Z
$FF,$03,$FF,$03,$01,$02,$00,$00          //  [
$0F,$00,$FC,$00,$C0,$00,$00,$00          //  
$01,$02,$FF,$03,$00,$00          //  ]
$0C,$00,$07,$00,$07,$00,$0C,$00,$00,$00          //  ^
$00,$02,$00,$02,$00,$02,$00,$02,$00,$02,$00,
$02,$00,$00          //  _
$01,$00,$03,$00,$00,$00          //  `
$E8,$00,$FC,$00,$94,$00,$FC,$00,$FC,$00,$00,
$00          //  a
$FF,$00,$FF,$00,$84,$00,$CC,$00,$78,$00,$00,
$00          //  b
$78,$00,$FC,$00,$84,$00,$84,$00,$CC,$00,$48,
$00,$00,$00          //  c
$78,$00,$CC,$00,$84,$00,$CC,$00,$FF,$00,$00,
$00          //  d
$78,$00,$DC,$00,$94,$00,$94,$00,$DC,$00,$10,
$00          //  e
$04,$00,$FE,$00,$FF,$00,$05,$00,$00,$00          //  f
$78,$02,$FC,$02,$84,$02,$CC,$03,$FC,$01,$00,
$00          //  g
$FF,$00,$FF,$00,$04,$00,$0C,$00,$FC,$00,$00,
$00          //  h
$FD,$00,$FD,$00,$00,$00          //  i
$FD,$03,$FD,$01,$00,$00          //  j
$FF,$00,$FF,$00,$78,$00,$C4,$00,$84,$00,$00,
$00          //  k
$FF,$00,$FF,$00,$00,$00          //  l
$FC,$00,$FC,$00,$04,$00,$FC,$00,$F8,$00,$04,
$00,$FC,$00,$F8,$00,$00,$00          //  m
$FC,$00,$FC,$00,$04,$00,$0C,$00,$FC,$00,$00,
$00          //  n
$78,$00,$FC,$00,$84,$00,$CC,$00,$78,$00,$00,
$00          //  o
$FC,$03,$FC,$03,$84,$00,$CC,$00,$78,$00,$00,
$00          //  p
$78,$00,$CC,$00,$84,$00,$CC,$00,$FC,$03,$00,
$00          //  q
$FC,$00,$FC,$00,$04,$00,$04,$00,$00,$00          //  r
$58,$00,$D4,$00,$B4,$00,$BC,$00,$E8,$00,$00,
$00          //  s
$FF,$00,$FF,$00,$84,$00,$00,$00          //  t
$7C,$00,$FC,$00,$80,$00,$E0,$00,$FC,$00,$00,
$00          //  u
$0C,$00,$78,$00,$E0,$00,$F0,$00,$1C,$00,$00,
$00          //  v
$04,$00,$3C,$00,$E0,$00,$F8,$00,$0C,$00,$7C,
$00,$E0,$00,$78,$00,$0C,$00,$00,$00          //  w
$84,$00,$EC,$00,$30,$00,$78,$00,$CC,$00,$80,
$00          //  x
$0C,$02,$78,$02,$E0,$03,$F0,$00,$1C,$00,$04,
$00          //  y
$84,$00,$C4,$00,$B4,$00,$9C,$00,$8C,$00,$00,
$00          //  z
$10,$00,$EF,$03,$01,$02,$01,$02          //  {
$FF,$03,$00,$00          //  |
$01,$02,$EF,$03,$3C,$00,$10,$00,$00,$00          //  }
$18,$00,$08,$00,$18,$00,$10,$00,$18,$00,$00,
$00          //  ~

Y no se por donde cogerlo!!! :S:S

la que tengo como referencia es esta:

Codigo:
const unsigned char ASCII_TABLE1 [240]={
                           0x00,0x00,0x00,0x00,0x00,   // 20 space
                  0x00,0x00,0x5f,0x00,0x00,   // 21 !
                  0x00,0x07,0x00,0x07,0x00,   // 22 "
                  0x14,0x7f,0x14,0x7f,0x14,   // 23 #
                  0x24,0x2a,0x7f,0x2a,0x12,   // 24 $
                  0x23,0x13,0x08,0x64,0x62,   // 25 %
                  0x36,0x49,0x55,0x22,0x50,   // 26 &
                  0x00,0x05,0x03,0x00,0x00,   // 27 "
                  0x00,0x1c,0x22,0x41,0x00,   // 28 (
                  0x00,0x41,0x22,0x1c,0x00,   // 29 )
                  0x14,0x08,0x3e,0x08,0x14,   // 2a *
                  0x08,0x08,0x3e,0x08,0x08,   // 2b +
                  0x00,0x50,0x30,0x00,0x00,   // 2c ,
                  0x08,0x08,0x08,0x08,0x08,   // 2d -
                  0x00,0x60,0x60,0x00,0x00,   // 2e .
                  0x20,0x10,0x08,0x04,0x02,   // 2f /
                  0x3e,0x51,0x49,0x45,0x3e,   // 30 0
                  0x00,0x42,0x7f,0x40,0x00,   // 31 1
                  0x42,0x61,0x51,0x49,0x46,   // 32 2
                  0x21,0x41,0x45,0x4b,0x31,   // 33 3
                  0x18,0x14,0x12,0x7f,0x10,   // 34 4
                  0x27,0x45,0x45,0x45,0x39,   // 35 5
                  0x3c,0x4a,0x49,0x49,0x30,   // 36 6
                  0x01,0x71,0x09,0x05,0x03,   // 37 7
                  0x36,0x49,0x49,0x49,0x36,   // 38 8
                  0x06,0x49,0x49,0x29,0x1e,   // 39 9
                  0x00,0x36,0x36,0x00,0x00,   // 3a :
                  0x00,0x56,0x36,0x00,0x00,   // 3b ;
                  0x08,0x14,0x22,0x41,0x00,   // 3c <
                  0x14,0x14,0x14,0x14,0x14,   // 3d =
                  0x00,0x41,0x22,0x14,0x08,   // 3e >
                  0x02,0x01,0x51,0x09,0x06,   // 3f ?
                  0x32,0x49,0x79,0x41,0x3e,   // 40 @
                  0x7e,0x11,0x11,0x11,0x7e,   // 41 A
                  0x7f,0x49,0x49,0x49,0x36,   // 42 B
                  0x3e,0x41,0x41,0x41,0x22,   // 43 C
                  0x7f,0x41,0x41,0x22,0x1c,   // 44 D
                  0x7f,0x49,0x49,0x49,0x41,   // 45 E
                  0x7f,0x09,0x09,0x09,0x01,   // 46 F
                  0x3e,0x41,0x49,0x49,0x7a,   // 47 G
                  0x7f,0x08,0x08,0x08,0x7f,   // 48 H
                  0x00,0x41,0x7f,0x41,0x00,   // 49 I
                  0x20,0x40,0x41,0x3f,0x01,   // 4a J
                  0x7f,0x08,0x14,0x22,0x41,   // 4b K
                  0x7f,0x40,0x40,0x40,0x40,   // 4c L
                  0x7f,0x02,0x0c,0x02,0x7f,   // 4d M
                  0x7f,0x04,0x08,0x10,0x7f,   // 4e N
                  0x3e,0x41,0x41,0x41,0x3e};   // 4f O


const unsigned char ASCII_TABLE2 [250]={
                           0x7f,0x09,0x09,0x09,0x06,   // 50 P
                  0x3e,0x41,0x51,0x21,0x5e,   // 51 Q
                  0x7f,0x09,0x19,0x29,0x46,   // 52 R
                  0x46,0x49,0x49,0x49,0x31,   // 53 S
                  0x01,0x01,0x7f,0x01,0x01,   // 54 T
                  0x3f,0x40,0x40,0x40,0x3f,   // 55 U
                  0x1f,0x20,0x40,0x20,0x1f,   // 56 V
                  0x3f,0x40,0x38,0x40,0x3f,   // 57 W
                  0x63,0x14,0x08,0x14,0x63,   // 58 X
                  0x07,0x08,0x70,0x08,0x07,   // 59 Y
                  0x61,0x51,0x49,0x45,0x43,   // 5a Z
                  0x00,0x7f,0x41,0x41,0x00,   // 5b [
                  0x02,0x04,0x08,0x10,0x20,   // 5c
                  0x00,0x41,0x41,0x7f,0x00,   // 5d
                  0x04,0x02,0x01,0x02,0x04,   // 5e
                  0x40,0x40,0x40,0x40,0x40,   // 5f
                  0x00,0x01,0x02,0x04,0x00,   // 60
                  0x20,0x54,0x54,0x54,0x78,   // 61 a
                  0x7f,0x48,0x44,0x44,0x38,   // 62 b
                  0x38,0x44,0x44,0x44,0x20,   // 63 c
                  0x38,0x44,0x44,0x48,0x7f,   // 64 d
                  0x38,0x54,0x54,0x54,0x18,   // 65 e
                  0x08,0x7e,0x09,0x01,0x02,   // 66 f
                  0x0c,0x52,0x52,0x52,0x3e,   // 67 g
                  0x7f,0x08,0x04,0x04,0x78,   // 68 h
                  0x00,0x44,0x7d,0x40,0x00,   // 69 i
                  0x20,0x40,0x44,0x3d,0x00,   // 6a j
                  0x7f,0x10,0x28,0x44,0x00,   // 6b k
                  0x00,0x41,0x7f,0x40,0x00,   // 6c l
                  0x7c,0x04,0x18,0x04,0x78,   // 6d m
                  0x7c,0x08,0x04,0x04,0x78,   // 6e n
                  0x38,0x44,0x44,0x44,0x38,   // 6f o
                  0x7c,0x14,0x14,0x14,0x08,   // 70 p
                  0x08,0x14,0x14,0x18,0x7c,   // 71 q
                  0x7c,0x08,0x04,0x04,0x08,   // 72 r
                  0x48,0x54,0x54,0x54,0x20,   // 73 s
                  0x04,0x3f,0x44,0x40,0x20,   // 74 t
                  0x3c,0x40,0x40,0x20,0x7c,   // 75 u
                  0x1c,0x20,0x40,0x20,0x1c,   // 76 v
                  0x3c,0x40,0x30,0x40,0x3c,   // 77 w
                  0x44,0x28,0x10,0x28,0x44,   // 78 x
                  0x0c,0x50,0x50,0x50,0x3c,   // 79 y
                  0x44,0x64,0x54,0x4c,0x44,   // 7a z
                  0x00,0x08,0x36,0x41,0x00,   // 7b
                  0x00,0x00,0x7f,0x00,0x00,   // 7c
                  0x00,0x41,0x36,0x08,0x00,   // 7d
                  0x10,0x08,0x08,0x10,0x08,   // 7e
                  0x78,0x46,0x41,0x46,0x78,    // 7F
                     0x7C,0x09,0x05,0x05,0x78,     // 80 -> ñ   
                        0x7E,0x05,0x09,0x11,0x7E     // 81 -> Ñ
                  };

Veo que usa 5bytes por caracter, aunq he visto otra que usa 14bytes (o eso creo..) y la verdad esq no aclaro por ningun lado!!!

Gracias por adelantado!

[Lager.]

Que onda pana, el generador que elabore,genera la letra respetando su tamaño real en pixel(primer tabla que posteaste). La otra tabla es generada por el FontGen, la cual tiene autocorreccion de tamaño(el tamaño real de algunas letras no es el correcto para respetar el formato ecuanime en todas...) por eso todos los caracteres tienen el mismo ancho(algo que no es correcto vectorialmente). Ambos funcionan, pero el mas sencillo de usar es el que te genera el fontGen v1.x(tambien sirve para imagenes) ya que la rutina de lectura de cada letra es la misma para todas.

Con Fontgen v 1.6:

0000000000000000  //space
0000000000000000
0000000000000000
0000000000000000
0000000000000000

0000000000000000  //!
0000000000000000
0000010111111111
0000000000000000
0000000000000000

0000001111111110   //0
0000010100000001
0000010000001001
0000010000000101
0000001111111110

0000000000000000  //1
0000010000000010
0000011111111111
0000010000000000
0000000000000000

pagina:      http://www.8052.com/users/bahrio/fontgen.phtml
descarga:  http://www.8052.com/users/bahrio/FontGen16.zip


Tabla generada porGenerado TodoPic v1.53:

$00,$00,$04,$00,$FE,$00   //1



000010  lsb                 //1
000010
001010
000010
000000
000010
000010
000010  msb

$C4,$00,$A2,$00,$92,$00,$8C,$00          //  2


00000000  lsb
00101000
10000010
00000010
00001000
00100000
10000000
10101010  msb

El 2 no tiene el mismo ancho que el 1......
De hecho en Proton+ las  rutinas de glcd usan el formato Real de las letras(este formato), por eso manejo este formato. Pero si requieren que haga un autoajuste pero respetando el tamaño real de los caracteres, hago la modificacion en estos dias. De hecho lo unico que habria que hacerse es tomar la rutina de escritura mas ANCHA y escribir ceros de relleno en los caracteres menos ANCHOS.

descargas: http://webs.ono.com/usr008/cucaracha/  EXELENTE WEB del pana cuca!!!!!
                 http://www.pacalaconcurso.com/              Otra EXELENTE web, del pana pacala
                  www.todopic.com.ar                                  El mejor foro de microcontrol !!!!
Salu2 pana

[J1M]

muchas gracias por la explicacion lager!!

Supongo q sería interesante que todos los caracteres tuvieran el mismo ancho en bytes, ya que a la hora de mandarlos al glcd la cosa debe ser mas sencilla (a bote pronto ya que aún no me he puesto...) no será lo mismo hacer un "for" para enviar 5bytes (x ejemplo) que ocupen todos y cada uno de los caracteres, que tener que saber primero lo q va a ocupar ese caracter para despues enviarlo... no se si me explico, ni tan sikiera si lo que he dicho tiene sentido.. jajaj!

en fin, muchas gracias, y en cuanto sake tiempo me pongo con el tema!

Salu2!

[Modulay]

Un pequeño apunte.He intentado proabr el todopi generator y me da error de dll (tanto en windows xp como en el 98) no encontrado.Me ocurre exactamente lo mismo con un programa similar,el FastLcd,que me pide el mismo dll.
Curiosamente se soluciona instalando Visual Basic 6

[Lager.]

Que onda panas , lamentablemente tiene esa contra el G.T.P. nada mas tenga un poco de tiempo libre y hago el autoajuste  para letras para que lo puedan usar directo como el Fontgen. Ahora como tu bien dices sera mas FACIL, mas no lo correcto, ya que si haces del mismo ancho cada caracter estas modificandolo en si, lo cual no esta bien. una opcion es optimizar la rutina de leida de datos para que como proton, detecte el primer valor como ANCHO y asi sepa cuantos PARES va a leer............. . Otra opcion es dejar el espacio comprendido con ceros(en blanco).. pero SIN alterar el ancho.. esto nos dara la facilidad que requieres, haber si este jueves lo hago para que puedan usarlo con confianza panas
EL problema del activex comdlg32.ocx , tambien habia sido resuelto, pero como pesaba demasiado( casi 1 mega) el archivo ya con este incrustado, decidi ya no ponerlo completo, es mas facil bajar el paquete de runtime app de visual basic para el uso de cualquier programa elaborado con este soft. ademas de que el power wrap que tenia incrustaba un virus junto con l com..  y usar el empaquetador... jajaj es una basura el empaquetador de vb, asi que se quedo asi. Aunque usuarios de VB no deben de tener ningun problema.

Un abrazo panas

[J1M]

Muchas gracias por el interes Lager.!!!!

Si tienes razón, no es lo mas correcto ensanchar los caracteres, pero creo q no me refería a eso, lo mismo me equivoco, no se si será posible, pero, no podría tomarse como referencia el caracter mas grande, ya que será este el que mas bytes ocupe, y forzar a los demas caracteres a ocupar el mismo tamaño, pero no ensanchandolos, sino rellenando con "0" ???

En fin, perdona por el lio!! jejejeje

Y GRACIAS!

[Lager.]

Claro que no es ningun lio pana J1m ,  , solo me desocupo de otras cosas y con mucho gusto lo modifico. De hecho la forma que nombras es la mas real, ya que respetaria el tamaño verdadero de los caracteres.

Salu2  pana