la función es strcpy() y no strcopy()Es cierto! :)
Hola Gera!
Tengo un problema parecido, pero el codigo que propones no me funciona.
si hago
#include <string.h>
char *texto1;
strcopy (texto1,"abcdefg");
al compilar me da el error "character constant constructed incorrectly" en la "coma" que está entre texto1 y "abcdefg"
¿Que puedo estar haciendo mal? :shock:
//-------------------------------------------------------------------//
// CALCULADORA CIENTIFICA GRAFICA
// Programa principal
//-------------------------------------------------------------------//
//-------------------------------------------------------------------//
// Includes
//-------------------------------------------------------------------//
#include <16f877a.h>
// Fuses ------------------------------------------------------------//
// Configuracion del PIC
//-------------------------------------------------------------------//
// Aqui hay mucho por corregir todavia. No he mirado tooodos los fuses
// que tiene este PIC
#fuses XT,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT
//#fuses XTPLL,MCLR,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,NOVREGEN
#use delay(clock=4000000)
//#use fast_io(b) //Optimizamos E/S del PORTB
//#use fast_io(c) //Optimizamos E/S del PORTC
//#use fast_io(d) //Optimizamos E/S del PORTD
//#use fast_io(e) //Optimizamos E/S del PORTE
// Bits & Bytes -----------------------------------------------------//
// Declaro la direccion de los puertos.
//-------------------------------------------------------------------//
#BYTE PORTA = 0x05
#BYTE PORTB = 0x06
#BYTE PORTC = 0x07
#BYTE PORTD = 0x08
#BYTE PORTE = 0x09
//Defines -----------------------------------------------------------//
// Declaro el uso de cada pin de E/S
//-------------------------------------------------------------------//
#define VERSION 1 //1=Pinout PCB Ariel - 2=Pinout Version Felixls
#if VERSION == 1 //Pinout PCB Ariel
#define COL1 PIN_E0 //Columna 1 del teclado.
#define COL2 PIN_A5 //Columna 2 del teclado.
#define COL3 PIN_A4 //Columna 3 del teclado.
#define COL4 PIN_A3 //Columna 4 del teclado.
#define COL5 PIN_A2 //Columna 5 del teclado.
#define COL6 PIN_A1 //Columna 6 del teclado.
#define COL7 PIN_A0 //Columna 7 del teclado.
#define FILA1 PIN_D2 //Fila 1 del teclado.
#define FILA2 PIN_D3 //Fila 2 del teclado.
#define FILA3 PIN_D0 //Fila 3 del teclado.
#define FILA4 PIN_D1 //Fila 4 del teclado.
#define FILA5 PIN_D7 //Fila 5 del teclado.
#define FILA6 PIN_D6 //Fila 6 del teclado.
#define FILA7 PIN_D5 //Fila 7 del teclado.
#define FILA8 PIN_D4 //Fila 8 del teclado.
#define GLCD_CS1 PIN_B2 //CS1 del GLCD
#define GLCD_CS2 PIN_B3 //CS2 del GLCD
#define GLCD_RESET PIN_B4 //RESET del GLCD
#define GLCD_E PIN_B5 //Enable del GLCD
#define GLCD_RW PIN_B6 //RW del GLCD
#define GLCD_DI PIN_B7 //DI del GLCD
#DEFINE EEPROM_SCL PIN_B1
#DEFINE EEPROM_SDA PIN_B0
#else //Pinout Version Felixls
//Felixls....a lo tuyo! :)
#endif
//Defines -----------------------------------------------------------//
// Declaro el uso del bus i2c
//-------------------------------------------------------------------//
//#use i2c(master, sda=EEPROM_SDA, scl=EEPROM_SCL)
//#define EEPROM_ADDRESS long int
#include <string.h>
//Incluyo la libreria gráfica---------------------------------------//
//Lados del GLCD
#define GLCD_lado_CS1 0
#define GLCD_lado_CS2 1
BYTE GLCD_leeBYTE(int1 lado);
//-----------------------------------------------------------------------
//Escribe un byte en una de las mitades de la pantalla (lado=0:izq Lado=1:der)
//-----------------------------------------------------------------------
void GLCD_enviaBYTE(int1 lado, BYTE dato)
{
if(lado) output_high(GLCD_CS2); // Selecciono la mitad correspondiente
else output_high(GLCD_CS1);
output_low(GLCD_RW); // Modo escritura
output_d(dato); // Coloco el dato en el puerto y...
delay_us(1); // ...espero.
output_high(GLCD_E); // Pongo el bit Enable en alto y...
delay_us(2); // ...espero.
output_low(GLCD_E); // Pongo el bit Enable en bajo.
output_low(GLCD_CS1); // Libero la linea CS1 y...
output_low(GLCD_CS2); // CS2.
}
//-----------------------------------------------------------------------
// Lee un byte de una de las dos mitades de la pantalla
//-----------------------------------------------------------------------
BYTE GLCD_leeBYTE(int1 lado)
{
BYTE dato;
set_tris_d(0xFF); // Puerto D como entrada
output_high(GLCD_RW); // GLCD en Modo lectura
// Selecciono la mitad del display a leer.
if(lado) output_high(GLCD_CS2);
else output_high(GLCD_CS1);
delay_us(1); // Espero...
output_high(GLCD_E); // Pongo en alto el pin enable y...
delay_us(2); // ...espero.
dato = input_d(); // Guardo en "dato" el valor devuelto y...
output_low(GLCD_E); // ...pongo en bajo el pin enable.
// Vuelvo a poner en bajo las lineas CS1 y CS2.
output_low(GLCD_CS1);
output_low(GLCD_CS2);
return dato;
}
//-----------------------------------------------------------------------
// Limpia el GLCD (pinta toda la pantalla de un color)
//-----------------------------------------------------------------------
void GLCD_limpiar(int1 color)
{
int8 i, j;
// Recorre las 8 paginas (vertical)
for(i = 0; i < 8; ++i)
{
output_low(GLCD_DI); // Modo instruccion
//Comienzo, en cada página, desde la dirección 0
GLCD_enviaBYTE(GLCD_lado_CS1, 0b01000000);
GLCD_enviaBYTE(GLCD_lado_CS2, 0b01000000);
//Selecciono la direccion dentro de la pagina
GLCD_enviaBYTE(GLCD_lado_CS1, i | 0b10111000);
GLCD_enviaBYTE(GLCD_lado_CS2, i | 0b10111000);
output_high(GLCD_DI); // Modo datos
// Recorre las dos mitades (horizontales)
for(j = 0; j < 64; ++j)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0xFF * color); // Enciende/apaga pixeles
GLCD_enviaBYTE(GLCD_lado_CS2, 0xFF * color); // Enciende/apaga pixeles
}
}
}
//-----------------------------------------------------------------------
//Esta funcion inicializa el LCD.
//-----------------------------------------------------------------------
void GLCD_inicializa(int1 modo)
{
// Pone los pines de control en el estado correcto.
output_high(GLCD_RESET);
output_low(GLCD_E);
output_low(GLCD_CS1);
output_low(GLCD_CS2);
output_low(GLCD_DI); // Modo instruccion
// Envio datos de inicialización -----------------------
GLCD_enviaBYTE(GLCD_lado_CS1, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xC0);
GLCD_enviaBYTE(GLCD_lado_CS1, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS2, 0x40);
GLCD_enviaBYTE(GLCD_lado_CS1, 0xB8);
GLCD_enviaBYTE(GLCD_lado_CS2, 0xB8);
// Si modo = 1 inicializa encendido. Sino, apagado.
if(modo == 1)
{ GLCD_enviaBYTE(GLCD_lado_CS1, 0x3F); // Enciendo el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3F); }
else {
GLCD_enviaBYTE(GLCD_lado_CS1, 0x3E); // Apago el GLCD
GLCD_enviaBYTE(GLCD_lado_CS2, 0x3E); }
// Borro la pantalla
GLCD_limpiar(0);
}
//-----------------------------------------------------------------------
// Dibuja un pixel
//-----------------------------------------------------------------------
void GLCD_punto(int8 x, int8 y, int1 color)
{
BYTE dato;
int1 lado = GLCD_lado_CS1; // Lado en que voy a dibujar.
if(x > 63) // Veo si cae del otro lado
{ x -= 64;
lado = GLCD_lado_CS2;}
output_low(GLCD_DI); // Modo instruccion
bit_clear(x,7); // Limpio bit MSB...
bit_set(x,6); // ...y pongo el bit 6 en 1
GLCD_enviaBYTE(lado, x); //Envio la dirección de la coordenada X
// Calculo en que pagina de las 8 cae...
GLCD_enviaBYTE(lado, (y/8 & 0xBF) | 0xB8);
output_high(GLCD_DI); // ...y paso a Modo datos
//Se necesitan dos lecturas para que devuelva el dato en la nueva direccion
GLCD_leeBYTE(lado);
dato = GLCD_leeBYTE(lado);
//De acuerdo al valor de color...
if(color == 1) bit_set(dato, y%8); // Enciendo el pixel
else bit_clear(dato, y%8); // apago el pixel
output_low(GLCD_DI); // Modo instruccion
GLCD_enviaBYTE(lado, x); // Fijo el lado a escribir,
output_high(GLCD_DI); // pongo en Modo Datos y....
GLCD_enviaBYTE(lado, dato); // dibujo el pixel
}
//-----------------------------------------------------------------------
// Dibuja una linea desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_linea(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
signed int x, y, incremento_x, incremento_y, distancia_x, distancia_y;
signed long P;
int i;
//Calculo las diferencias entre las coordenadas de origen y destino
distancia_x = abs((signed int)(x2 - x1));
distancia_y = abs((signed int)(y2 - y1));
//Inicializo x e y con las coordenadas de origen
x = x1;
y = y1;
//Calculo el sentido de los incrementos (positivos o negativos)
//en funcion de la posicion del origen y el destino
if(x1 > x2) incremento_x = -1; else incremento_x = 1;
if(y1 > y2) incremento_y = -1; else incremento_y = 1;
//Si la distancia horizontal es mayor a la vertical...
if(distancia_x >= distancia_y)
{ P = 2 * distancia_y - distancia_x;
for(i=0; i<=distancia_x; ++i)
{
GLCD_punto(x, y, color);
if(P < 0)
{ P += 2 * distancia_y;
x += incremento_x; }
else
{ P += 2*distancia_y - 2*distancia_x;
x += incremento_x;
y += incremento_y;}
}
}
//Si la distancia vertical es mayor a la horizontal...
else
{ P = 2 * distancia_x - distancia_y;
for(i=0; i<=distancia_y; ++i)
{ GLCD_punto(x, y, color);
if(P < 0)
{ P += 2 * distancia_x;
y += incremento_y; }
else
{ P += 2 * distancia_x - 2 * distancia_y;
x += incremento_x;
y += incremento_y; }
}
}
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un rectángulo desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_rectangulo(int x1, int y1, int x2, int y2, int1 color)
{
GLCD_linea(x1,y1,x2,y1,color);
GLCD_linea(x1,y1,x1,y2,color);
GLCD_linea(x1,y2,x2,y2,color);
GLCD_linea(x2,y1,x2,y2,color);
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un rectángulo PINTADO desde (x1,y1) a (x2,y2) de color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_caja(int x1, int y1, int x2, int y2, int1 color)
{
//Declaro variables-------------------
int i;
for(i=y1;i<=y2;i++) {
GLCD_linea(x1,i,x2,i,color); }
}
//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
// Dibuja un circulo con centro en (x1,y1), radio y color (0 o 1)
//-----------------------------------------------------------------------
void GLCD_circulo(int x1, int y1, int radio, int1 color)
{
signed int d, x, y;
//Inicializo las variables.
d = 1 - radio;
x = 0;
y = radio;
//Dibujo los cuatro pixeles que "caen" sobre los ejes cartesianos.
GLCD_punto(x1, y1 + radio, color);
GLCD_punto(x1, y1 - radio, color);
GLCD_punto(x1 + radio, y1, color);
GLCD_punto(x1 - radio, y1, color);
//Este es el bucle que pinta los octavos de la circunferencia.
while(x < y) {
if(d < 0) {d = d + 2 * x + 3;}
else {d = d + 2 * (x - y ) + 5;
y = y - 1 ;}
x = x + 1;
//Pone el punto en cada uno de los "octantes".
GLCD_punto(x1 + x, y1 + y, color);
GLCD_punto(x1 - x, y1 + y, color);
GLCD_punto(x1 + x, y1 - y, color);
GLCD_punto(x1 - x, y1 - y, color);
GLCD_punto(x1 + y, y1 + x, color);
GLCD_punto(x1 - y, y1 + x, color);
GLCD_punto(x1 + y, y1 - x, color);
GLCD_punto(x1 - y, y1 - x, color);
}
}
#include <fuentes.c> //Incluyo la libreria gráfica
//Comienza el programa principal-------------------------------------//
main() {
char *texto1;
GLCD_inicializa(1);
strcpy (texto1,'-0123.45678912');
glcd_texto_grande(0 ,17, texto1, 1);
texto1 = "ABCDEFABCDEFAB";
glcd_texto_grande(0 ,30, texto1, 1);
//char texto1[] = "-0123.45678912";
//char texto2[] = "ABCDEFABCDEFAB";
//char texto3[] = "ABCDEFGHIJKLMNOPQRSTU";
//char texto4[] = "VWXYZ01234567890abcde";
//char texto5[] = "ABCDEFGHIJKLMNOPQRSTU";
//char texto6[] = " www.ucontrol.com.ar ";
// glcd_texto_chico(0, 0, texto3, 1);
// glcd_texto_chico(0, 8, texto4, 1);
// glcd_texto_grande(0 ,17, texto2, 1);
// glcd_texto_grande(0 ,30, texto1, 1);
//glcd_texto_chico(0, 49, texto5, 1);
//glcd_texto_chico(0, 57, texto6, 1);
} //Fin del programa principal
//-------------------------------------------------------------------//
// fuentes.c Tipos de letra //
//-------------------------------------------------------------------//
#ifndef GRAPHICS_DRAWING_FUNCTIONS
#define GRAPHICS_DRAWING_FUNCTIONS
#ifndef ON
#define ON 1
#endif
#ifndef OFF
#define OFF 0
#endif
#ifndef YES
#define YES 1
#endif
#ifndef NO
#define NO 0
#endif
//-------------------------------------------------------------------//
//-------------------------------------------------------------------//
// DefinO fuente de 7x12 pixeles
//-------------------------------------------------------------------//
const int8 FONT_G[19][12] =
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,// SPACE (0)
0x7C, 0xFE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0xFE, 0x7C,// 0 (1)
0x0C, 0x3C, 0x7C, 0x7C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C, 0x1C,// 1 (2)
0x38, 0x7C, 0xFE, 0xEE, 0xEE, 0x0C, 0x1C, 0x38, 0x70, 0x70, 0xFE, 0xFE,// 2 (3)
0x7C, 0xFE, 0xEE, 0xEE, 0x0E, 0x3C, 0x3E, 0x0E, 0xEE, 0xEE, 0xFE, 0x7C,// 3 (4)
0x1C, 0x1C, 0x3C, 0x2C, 0x6C, 0x6C, 0xCC, 0xFE, 0xFE, 0xFE, 0x1C, 0x1C,// 4 (5)
0xFE, 0xFE, 0xE0, 0xE0, 0xFC, 0xFE, 0xEE, 0x0E, 0xEE, 0xEE, 0xFE, 0x7C,// 5 (6)
0x7C, 0xFE, 0xEE, 0xE0, 0xEC, 0xFE, 0xEE, 0xEE, 0xEE, 0xEE, 0xFE, 0x7C,// 6 (7)
0xFE, 0xFE, 0x0E, 0x0E, 0x0C, 0x1C, 0x1C, 0x18, 0x38, 0x38, 0x70, 0x70,// 7 (8)
0x7C, 0xFE, 0xEE, 0xEE, 0xEE, 0x7C, 0xEE, 0xEE, 0xEE, 0xEE, 0xFE, 0x7C,// 8 (9)
0x7C, 0xFE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE, 0x7E, 0x0E, 0xEE, 0xFE, 0x7C,// 9 (10)
0x00, 0x00, 0x00, 0x00, 0x00, 0x7C, 0x7C, 0x00, 0x00, 0x00, 0x00, 0x00,// - (11)
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0x38,// . (12)
0x7C, 0xFE, 0xEE, 0xEE, 0xEE, 0xFE, 0xFE, 0xEE, 0xEE, 0xEE, 0xEE, 0xEE,// A (13)
0xFC, 0xFE, 0xEE, 0xE6, 0xEE, 0xFC, 0xFC, 0xEE, 0xE6, 0xEE, 0xFE, 0xFC,// B (14)
0x7C, 0xFE, 0xEE, 0xE6, 0xE0, 0xE0, 0xE0, 0xE0, 0xE6, 0xEE, 0xFE, 0x7C,// C (15)
0xFC, 0xFE, 0xEE, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xE6, 0xEE, 0xFE, 0xFC,// D (16)
0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE,// E (17)
0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xFE, 0xFE, 0xE0, 0xE0, 0xE0, 0xE0, 0xE0,// F (18)
//0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x, 0x,// i
};
//-------------------------------------------------------------------//
// glcd_texto_grande(columna, fila, cadena, color)
//
// Escribe caracteres de 12x7. Solo 0..9, A..F, -, i, e, simbolo PI
//-------------------------------------------------------------------//
void glcd_texto_grande(int8 x, int8 y, char* textptr, int1 color)
{
int8 j, k; // variables auxiliares
int8 contenido_linea[12]; // datos de las 12 filas del caracter
x = x + 7; //Corrijo desplazamiento horizontal
for(; *textptr != '\0'; ++textptr, ++x)// Recorro la cadena a imprimir
{
//Copio los 12 bytes que definen al caracter (por tramos).
if (*textptr >= '0' & *textptr <= '9' ) {
memcpy(contenido_linea, FONT_G[*textptr -'/' ] , 12); }
if (*textptr == '-' ) {
memcpy(contenido_linea, FONT_G[11] , 12); }
if (*textptr == '.' ) {
memcpy(contenido_linea, FONT_G[12] , 12); }
if (*textptr >= 'A' & *textptr <= 'F') {
memcpy(contenido_linea, FONT_G[*textptr -52] , 12); }
//Recorro las 12 filas con un bucle...
for(j=0; j<12; ++j, y+=1)
{
//...y dentro de cada byte analizo cada bit.
for(k=7; k > 0 ; --k)
{
//Si corresponde, dibujo un punto.
if(bit_test(contenido_linea[j], k))
{
glcd_punto( x-k,y, color);
}
}
}
//Seteo x,y para el próximo caracter de la cadena.
y = y - 12;
x = x+ 8;
}
}
//-------------------------------------------------------------------//
// DefinO fuente de 5x7
//-------------------------------------------------------------------//
const int8 FONT1[51][5] ={0x00, 0x00, 0x00, 0x00, 0x00, // SPACE
0x00, 0x00, 0x5F, 0x00, 0x00, // !
0x00, 0x03, 0x00, 0x03, 0x00, // "
0x14, 0x3E, 0x14, 0x3E, 0x14, // #
0x24, 0x2A, 0x7F, 0x2A, 0x12, // $
0x43, 0x33, 0x08, 0x66, 0x61, // %
0x36, 0x49, 0x55, 0x22, 0x50, // &
0x00, 0x05, 0x03, 0x00, 0x00, // '
0x00, 0x1C, 0x22, 0x41, 0x00, // (
0x00, 0x41, 0x22, 0x1C, 0x00, // )
0x14, 0x08, 0x3E, 0x08, 0x14, // *
0x08, 0x08, 0x3E, 0x08, 0x08, // +
0x00, 0x50, 0x30, 0x00, 0x00, // ,
0x08, 0x08, 0x08, 0x08, 0x08, // -
0x00, 0x60, 0x60, 0x00, 0x00, // .
0x20, 0x10, 0x08, 0x04, 0x02, // /
0x3E, 0x51, 0x49, 0x45, 0x3E, // 0
0x00, 0x04, 0x02, 0x7F, 0x00, // 1
0x42, 0x61, 0x51, 0x49, 0x46, // 2
0x22, 0x41, 0x49, 0x49, 0x36, // 3
0x18, 0x14, 0x12, 0x7F, 0x10, // 4
0x27, 0x45, 0x45, 0x45, 0x39, // 5
0x3E, 0x49, 0x49, 0x49, 0x32, // 6
0x01, 0x01, 0x71, 0x09, 0x07, // 7
0x36, 0x49, 0x49, 0x49, 0x36, // 8
0x26, 0x49, 0x49, 0x49, 0x3E, // 9
0x00, 0x36, 0x36, 0x00, 0x00, // :
0x00, 0x56, 0x36, 0x00, 0x00, // ;
0x08, 0x14, 0x22, 0x41, 0x00, // <
0x14, 0x14, 0x14, 0x14, 0x14, // =
0x00, 0x41, 0x22, 0x14, 0x08, // >
0x02, 0x01, 0x51, 0x09, 0x06, // ?
0x3E, 0x41, 0x59, 0x55, 0x5E, // @
0x7E, 0x09, 0x09, 0x09, 0x7E, // A
0x7F, 0x49, 0x49, 0x49, 0x36, // B
0x3E, 0x41, 0x41, 0x41, 0x22, // C
0x7F, 0x41, 0x41, 0x41, 0x3E, // D
0x7F, 0x49, 0x49, 0x49, 0x41, // E
0x7F, 0x09, 0x09, 0x09, 0x01, // F
0x3E, 0x41, 0x41, 0x49, 0x3A, // G
0x7F, 0x08, 0x08, 0x08, 0x7F, // H
0x00, 0x41, 0x7F, 0x41, 0x00, // I
0x30, 0x40, 0x40, 0x40, 0x3F, // J
0x7F, 0x08, 0x14, 0x22, 0x41, // K
0x7F, 0x40, 0x40, 0x40, 0x40, // L
0x7F, 0x02, 0x0C, 0x02, 0x7F, // M
0x7F, 0x02, 0x04, 0x08, 0x7F, // N
0x3E, 0x41, 0x41, 0x41, 0x3E, // O
0x7F, 0x09, 0x09, 0x09, 0x06, // P
0x1E, 0x21, 0x21, 0x21, 0x5E, // Q
0x7F, 0x09, 0x09, 0x09, 0x76};// R
const int8 FONT2[44][5]={0x26, 0x49, 0x49, 0x49, 0x32, // S
0x01, 0x01, 0x7F, 0x01, 0x01, // T
0x3F, 0x40, 0x40, 0x40, 0x3F, // U
0x1F, 0x20, 0x40, 0x20, 0x1F, // V
0x7F, 0x20, 0x10, 0x20, 0x7F, // W
0x41, 0x22, 0x1C, 0x22, 0x41, // X
0x07, 0x08, 0x70, 0x08, 0x07, // Y
0x61, 0x51, 0x49, 0x45, 0x43, // Z
0x00, 0x7F, 0x41, 0x00, 0x00, // [
0x02, 0x04, 0x08, 0x10, 0x20, // \
0x00, 0x00, 0x41, 0x7F, 0x00, // ]
0x04, 0x02, 0x01, 0x02, 0x04, // ^
0x40, 0x40, 0x40, 0x40, 0x40, // _
0x00, 0x01, 0x02, 0x04, 0x00, // `
0x20, 0x54, 0x54, 0x54, 0x78, // a
0x7F, 0x44, 0x44, 0x44, 0x38, // b
0x38, 0x44, 0x44, 0x44, 0x44, // c
0x38, 0x44, 0x44, 0x44, 0x7F, // d
0x38, 0x54, 0x54, 0x54, 0x18, // e
0x04, 0x04, 0x7E, 0x05, 0x05, // f
0x08, 0x54, 0x54, 0x54, 0x3C, // g
0x7F, 0x08, 0x04, 0x04, 0x78, // h
0x00, 0x44, 0x7D, 0x40, 0x00, // i
0x20, 0x40, 0x44, 0x3D, 0x00, // j
0x7F, 0x10, 0x28, 0x44, 0x00, // k
0x00, 0x41, 0x7F, 0x40, 0x00, // l
0x7C, 0x04, 0x78, 0x04, 0x78, // m
0x7C, 0x08, 0x04, 0x04, 0x78, // n
0x38, 0x44, 0x44, 0x44, 0x38, // o
0x7C, 0x14, 0x14, 0x14, 0x08, // p
0x08, 0x14, 0x14, 0x14, 0x7C, // q
0x00, 0x7C, 0x08, 0x04, 0x04, // r
0x48, 0x54, 0x54, 0x54, 0x20, // s
0x04, 0x04, 0x3F, 0x44, 0x44, // t
0x3C, 0x40, 0x40, 0x20, 0x7C, // u
0x1C, 0x20, 0x40, 0x20, 0x1C, // v
0x3C, 0x40, 0x30, 0x40, 0x3C, // w
0x44, 0x28, 0x10, 0x28, 0x44, // x
0x0C, 0x50, 0x50, 0x50, 0x3C, // y
0x44, 0x64, 0x54, 0x4C, 0x44, // z
0x00, 0x08, 0x36, 0x41, 0x41, // {
0x00, 0x00, 0x7F, 0x00, 0x00, // |
0x41, 0x41, 0x36, 0x08, 0x00, // }
0x02, 0x01, 0x02, 0x04, 0x02};// ~
//-------------------------------------------------------------------//
// glcd_texto_chico(columna, fila, cadena, color)
//
// Escribe caracteres de 5x7.
//-------------------------------------------------------------------//
void glcd_texto_chico(int8 x, int8 y, char* textptr, int1 color)
{
int8 j, k, l, m; // variables auxiliares
int8 pixelData[5]; // datos de las 12 filas del caracter
for(; *textptr != '\0'; ++textptr, ++x) // Recorro la cadena a imprimir
{
if(*textptr < 'S') // Veo en que mitad del FONT estoy...
memcpy(pixelData, FONT1[*textptr - ' '], 5);
else if(*textptr <= '~')
memcpy(pixelData, FONT2[*textptr - 'S'], 5);
else
memcpy(pixelData, FONT1[0], 5); //En caso de error, tomo el espacio en blanco.
for(j=0; j<5; ++j, x+=1) // Recorro las cinco columnas...
{
for(k=0; k < 7; ++k) //...y cada uno de los pixeles
{
if(bit_test(pixelData[j], k)) // Si corresponde...
{
glcd_punto(x, y+k, color); // ..dibujo el pixel.
}
}
}
}
}
la cadena va entre comillas (") y no con (')