TODOPIC

Microcontroladores PIC => dsPIC => Mensaje iniciado por: KALLITOS en 21 de Diciembre de 2013, 03:40:56

Título: Función para tipos de letra
Publicado por: KALLITOS en 21 de Diciembre de 2013, 03:40:56
Hola amigos, acá les dejo una función que acondicioné para el manejo de diferentes tipos de letra:

(https://fbcdn-sphotos-b-a.akamaihd.net/hphotos-ak-prn2/p480x480/1515002_558083077601853_1479190816_n.jpg)


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.