Función para tipos de letra

[KALLITOS]

Hola amigos, acá les dejo una función que acondicioné para el manejo de diferentes tipos de letra:

El codigo de la función:

Código: C++

1. void glcd_text57(short x, short y, char* textptr, const unsigned char* Font, unsigned short color, unsigned short color_fondo)
2. {
3. unsigned short   j;
4. unsigned short   k;
5. //   unsigned short   l;
6. unsigned short   y2;
7. //   unsigned short   m;
8. unsigned short   S,X,Y,Z;
9. unsigned char   letra;
10. unsigned char   caracter;
11. unsigned char   pixelData[100];
12.  
13. unsigned short   ancho_letra;
14. unsigned char   alto_de_letra;          ///CANTIDAD DE BYTES DE ALTURA QUE TIENE LA LETRA
15.  
16. for(; *textptr != '\0'; ++textptr)// Loop through the passed string
17.         {
18.         alto_de_letra = Font[0];
19.         S = 1;
20.         letra = ' ';
21.         caracter = *textptr;
22.         if(caracter > '[')caracter--;    ///TUVE PROBLEMAS CON EL CARACTER '\' ASI QUE  LO SALTO
23.         for(;letra < caracter;letra++)S += (Font[S]<<1)+1;              ///recorre todo el alfabeto en la tabla de caracteres de Fonts.c
24.         ancho_letra = Font[S];                  ///OBTENGO EL TAMAÑO DE LA LETRA PARA SUMARLE AL INICIO DE LA SIGUIENTE LETRA
25.  
26.         for(j=0;j<ancho_letra*alto_de_letra;j++)pixelData[j] = Font[S+j];       ///COPIO LOS VALORES QUE CONFORMAN LA LETRA
27.         pixelData[j] = 0;
28.         ///DIBUJANDO LA LETRA
29.         X = x;
30.         Y = y;                                                                         
31.         Z = 1;                                                                          // ME POSICIONO EN EL BYTE 1 YA QUE EL 0 TIENE EL ANCHO DEL CARACTER
32.      for(y2=0; y2<alto_de_letra; y2++)          // CATIDAD DE BYTES DE ALTURA DEL CARACTER
33.                 {
34.              for(j=0; j<ancho_letra; j++)               // RECORRE EN ANCHO DEL CARACTER
35.                         {
36.                         for(k=0; k < 8; k++)                    // RECORRE CADA BIT Y DEL BYTE PARTE DEL CARACTER
37.                                 {
38.                                 if(pixelData[Z] & 0x80>>k)              // VERIFICO SI EXISTE PIXEL A DIBUJAR
39.                                         {
40.                                         Lcd_pixel(X, Y+k, color);       // DIBUJO EL PIXEL
41.                                         }//
42.  
43.                                 else                                            // RELLENO DE PIXELES VACIOS
44.                                         {
45.                                         Lcd_pixel(X, Y+k,color_fondo); //DIBUJO EL PIXEL
46.                                         }//
47.  
48.                          }//
49.                         X++;              ///ME DESPLAZO EN EL DISPLAY LO ANCHO DEL CARACTER
50.                         Z++;              ///ME DESPLAZO EN EL MAPA DEL CARACTER
51.                         }//
52.                 X = x;                                                                  // REINICIO POSICION X PARA LA 2 LINEA DE BYTES
53.                 Y += 8;                                                                 // AUMENTO LA POSICION DE Y PARA LA 2 LINEA DE BYTES
54.                 }//
55.  
56.         x += ancho_letra+alto_de_letra-1;       ///ESPACIO ENTRE LETRAS
57.         glcd_line(x-1,y,x-1,y+(alto_de_letra*8),color_fondo);   ///ESPACIO ENTRE LETRAS
58.         }//
59. }//

Codigo de ejemplo para su uso:

Código: C++

1. #include "logo_3.h"
2. #include "cabecera.h"
3. #include "ILI9327.h"
4.  
5. #include "eeprom.h"
6.  
7. _FOSCSEL(IESO_OFF & FNOSC_PRIPLL); // Oscilador primario + PLL
8. _FOSC(FCKSM_CSDCMD & OSCIOFNC_OFF & POSCMD_XT); // Conmutación de Clock y Fail-Safe Clock des-habilitados, OSC2 Clout, Cristal XT.
9. _FWDT(FWDTEN_OFF);// Watchdog des-habilitado.
10. _FPOR(FPWRT_PWR2);// Power-on Reset  2ms.
11.  
12.  
13. extern const char __logo_BMP_desa4[] __attribute__((space(prog), aligned(2)));
14. extern const unsigned char Arial_12[];
15. extern const unsigned char Times_New_Roman_12[];
16. extern const unsigned char Lucida_Sans_Unicode_12[];
17.  
18. unsigned char           cont;                                                   ///uasdo en el manejo de la eeprom
19. char    cadena_impresion[200];
20.  
21. int main()
22. {
23. PLLFBD = 0x004E;          // M=80.    
24. CLKDIV = 0x0000;          //N1=2, N2=2.  
25.  
26. ANSELA = ANSELB = ANSELC = ANSELD = ANSELE = 0;
27. Lcd_Init();
28.  
29. glcd_fillScreen(NEGRO);
30.  
31.  
32. glcd_text57(10,1,"Lucida Sans Unicode 12",Lucida_Sans_Unicode_12,BLANCO,0);
33. glcd_text57(10,19,"@ABCDEFGHIJKLMNOPQRSTUVWXYZ",Lucida_Sans_Unicode_12,AZUL,0);
34. glcd_text57(10,37,"1234567890(|)<>\"=!#$%&/ ?+[]{}^`-.:,;",Lucida_Sans_Unicode_12,AZUL,0);
35. glcd_text57(10,55,"abcdefghijklmnopqrstuvwxyz",Lucida_Sans_Unicode_12,AZUL,0);
36.  
37.  
38. glcd_text57(10,73,"Times New Roman 12",Times_New_Roman_12,BLANCO,0);
39. glcd_text57(10,91,"@ABCDEFGHIJKLMNOPQRSTUVWXYZ",Times_New_Roman_12,ROJO,0);
40. glcd_text57(10,109,"1234567890(|)<>\"=!#$%&/ ?+[]{}^`-.:,;",Times_New_Roman_12,ROJO,0);
41. glcd_text57(10,127,"abcdefghijklmnopqrstuvwxyz",Times_New_Roman_12,ROJO,0);
42.  
43. glcd_text57(10,145,"Arial 12",Arial_12,BLANCO,0);
44. glcd_text57(10,163,"@ABCDEFGHIJKLMNOPQRSTUVWXYZ",Arial_12,AMARILLO,0);
45. glcd_text57(10,181,"1234567890(|)<>\"=!#$%&/ ?+[]{}^`-.:,;",Arial_12,AMARILLO,0);
46. glcd_text57(10,199,"abcdefghijklmnopqrstuvwxyz",Arial_12,AMARILLO,0);
47.  
48.  
49. __delay_ms(3000);
50. glcd_fillScreen(NEGRO);
51. glcd_text57(10,1,"Lucida Sans Unicode 12",Lucida_Sans_Unicode_12,BLANCO,0);
52.  
53. glcd_text57(10,73,"Times New Roman 12",Times_New_Roman_12,BLANCO,0);
54.  
55. glcd_text57(10,145,"Arial 12",Arial_12,BLANCO,0);
56.  
57. unsigned short contar = 0;
58.  
59. while(1)
60.    {
61.         sprintf(cadena_impresion,"%5u",contar++);
62.         glcd_text57(10,19,cadena_impresion,Lucida_Sans_Unicode_12,AZUL,0);
63.         glcd_text57(10,91,cadena_impresion,Times_New_Roman_12,ROJO,0);
64.         glcd_text57(10,163,cadena_impresion,Arial_12,AMARILLO,0);
65.  
66.    }//
67. }//

Usé el BitFontCreator Pro 2.3.2 como referencia para generar los puntos de los caracteres, no lo tengo funcionando al 100% asi que utilicé la imagen de los caracteres y con excel obtuve las tablas, si, hechas a mano, es bastante trabajo pero es lo que usé 

Cada caracter tiene altura fija y ancho variable
Al inicio del array de cada tipo de letra coloque la altura en bytes:

asi en el codigo de la funcion se ve:

Código: C++

1. alto_de_letra = Font[0];

Y el ancho de cada caracter va al comienzo de cada uno asi:

Código: C++

1. /// A                        >>>>ME INDICA QUE CARACTER ES
2. 13,                                                                  >>> CANTIDAD DE BYTES POR FILA
3. 0,0,0,0,3,28,96,28,3,0,0,0,0,                                >>> BYTES QUE CONFORMAN EL CARACTER
4. 0,16,16,112,144,128,128,128,144,112,16,16,0,
5.  
6. ///EN ESTE CASO 27 EN TOTAL
7. /// ANCHO = 13
8. ///ALTO     = 2
9. /// INDICADOR DE ANCHO  = 1

Espero les sea útil.
Si pueden y le suman tipos y/o tamaños de letra subánlo por aca para asi tener mas variedad.

Saludos.