Escribir frase en LCD ( compilador SDCC )

[arcachofo]

Hola a todos...
Trato de escribir una frase en un LCD 2x20, pero solo aparece la primera letra de cada frase, a ver si alguien sabe porqué es esto, uso el siguiente método:

Código: [Seleccionar]

void lprintf( const char * frase )
{
while ( *frase )
{

send_dato( *frase ) ;

frase++ ;
}
}


Gracias...

[Cryn]

  mmm

pues se entiende tu codigo, porque no adjuntas tb las funciones o la libreria que estas utilizando? que tipo de lcd tienes osea, que controlador tiene, que micro usas?

necesitamos algunos detalles más para poder ayudarte

[cerebro]

hola arcachofo siempre acordate de indicarnos con que estas programa estas trabajando, mire tu codigo y esta bien..... pero por ejemplo en CCS no me permite definir por ejemplo
const char *a;
 te digo que probe en siguiente codigo y funciono

Código: [Seleccionar]

#include........


void lprintf(char * frase )
{
   while ( *frase )
   {

    lcd_putc(*frase);
 
      frase++ ;
     
    delay_ms(100);   
   }
}





void main()
{
 
 char a[5]={'a','b','c','d','e'};

 .......

 delay_ms(100);   
 
 lcd_init();

 lprintf(a);
 
}

Fijate bien como la estas llamando a la función,  si quieres el codigo completo y la simulacion que hice para un 18f2550 avisame.
Saludos

[gera]

hola arcachofo!
Por que no usas la libreria lcd.h? o si no la de redpic, creo q es flexlcd. Para escribir una frase basta con un simple printf.
saludos!

[arcachofo]

Gracias atodos por las respuestas...

El LCD es 2x20 compatible con... bueno no me acuerdo del controlador, pero el que usa todo el mundo, me ha funcionado bién con otras librerías en otros compiladores.
Estoy usando el compilador SDCC en linux, y precisamente lo que trato es crear un driver o librería para el LCD a 4 bits para usar con PIC16F876A y que quiza pueda servir para otros 16F, más o menos la tengo encaminada, aunque me encuentro con un par de pegas, todavía estoy en ello, así que hay varias cosa provisionales; el código que tengo por ahora es este:

Código: [Seleccionar]


//lcd-sdcc.h


//--------------------------- DEFINICIONES -------------------------------
//------------------------------------------------------------------------
#define write  RW = 0; pausa(); DATOT &= 0x0F; pausa()
#define read   DATOT |= 0xF0; pausa(); RW = 1; pausa()
#define EN0 EN = 0; pausa()
#define EN1 EN = 1; pausa()

#define clear          0x01 // Clear Display
#define home        0x02 // Cursor a Home
#define normal 0x06 // Normal

#define d4_bit 0x28 // 4 bit 2 lineas ( 5x7 font )
#define reset 0x30 // Reset
#define dis_on        0x0C // Display on modo 2 lineas
#define dis_off        0x08 // Display off
#define linea1      0x80 // Linea 1 posicion 1
#define linea2      0xC0 // Line 2 posicion 1

#define FREQ 8000 // 8 Mhz

//----------------------- CONFIGURAR VARIABLES ---------------------------
//------------------------------------------------------------------------
unsigned char d;
unsigned int loop;
unsigned int coms;
unsigned int co;
//------------------------------------------------------------------------
//------------------------------------------------------------------------

void tiempo()
{
coms = FREQ / 4000;
coms = coms * 1000 / 7;
}

void pausa( void )
{
_asm
nop
nop
nop
nop
nop
nop
nop
nop
nop
nop
_endasm;
}

void delay_1ms( unsigned int co )
{
while (co > 0 ){ co--; }
}

void delay_ms( unsigned int ms )
{
while (ms > 0 )
{
co = coms;
delay_1ms(co);
ms--;
}
}

char lcd_read()
{
read;
pausa();
EN = 1;
pausa();
d = DATOP & 0xF0;
EN = 0;
pausa();
EN = 1;
pausa();
d |= DATOP >> 4;
EN = 0;
pausa();
return d;
}

char lcd_busy( void )
{
pausa();
RS = 0;
lcd_read();
d = d & 0x80;
if(d == 0x80){
return(1);
}
else
{
return(0);
}
}

void write_n( char dat )
{
write;
pausa();
DATOP &= 0x0F;
DATOP |= dat & 0xF0;
EN = 1;
pausa();
EN = 0;
pausa();
pausa();

dat <<= 4;

DATOP &= 0x0F;
DATOP |= dat & 0xF0;
EN = 1;
pausa();
EN = 0;
pausa();
pausa();
}

void send_dato( char dato )
{
while( lcd_busy() == 1 );
RS = 1;
write_n( dato );
}

void send_comand( char comand )
{
loop = 0;
while(loop < 100){ loop++; }              //AQUI NO ME FUNCIONA delay_ms()... no se porqué.
RS = 0;
write_n( comand );
}

void lcd_clear()
{
send_comand( clear );
send_comand( home);
}

void lcd_init( void )
{
tiempo();
DATOT = 0;
DATOP = 0;
delay_ms(20);
write_n( reset );
delay_ms(5);
write_n( reset );
delay_ms(1);
write_n( reset );
pausa();
send_comand( d4_bit );
send_comand( normal );
send_comand( dis_on );
send_comand( linea1 );
}

void lprintf( const char *frase )
{
while ( *frase )
{
send_dato( *frase );
frase++;
}
}


Otra cosa que me tiene extrañado es que en send_comand no me funciona con un delay_ms(), que es otra subrutina del programa, solo me funciona con un loop con casi cualquier valor que le ponga, he probado desde 10 a 9000 y funciona con el loop, pero con delay_ms() no me funciona con ningún valor, y eso que el delay no es más que otro loop que escribí más arriba y sí me funcina en lcd_init...

Y el programa test que estoy usando es este:

Código: [Seleccionar]


/* ----------------------------------------------------------------------- */
/* Template source file generated by piklab */
#include <pic16f876a.h>

/* ----------------------------------------------------------------------- */
/* Bits de configuración: adapte los parámetros a su necesidad */
typedef unsigned int word;
word at 0x2007 CONFIG = _HS_OSC & _WDT_OFF & _PWRTE_ON & _BODEN_OFF & _LVP_OFF & _CPD_OFF & _WRT_OFF & _DEBUG_OFF & _CP_OFF;

//--------------------------- DEFINICIONES -------------------------------
//------------------------------------------------------------------------
#define RS RC1                //definiciones de pines de control y puerto para conectar el LCD
#define RW RC2                 //todo por el mismo puerto
#define EN RC3
#define DATOT TRISC
#define DATOP PORTC

//#define FREQ 8000 // 8 Mhz

#include <lcd-sdcc.h>

void main()
{
lcd_init();
while(1)
{
lcd_clear();
lprintf("H");
lprintf("o");
lprintf("l");
lprintf("a");
delay_ms(1000);
lcd_clear();
lprintf("estas");
delay_ms(1000);

// me imprime: "Hola" , se borra y luego me imprime solo "e"
}

}


Todo compila bién y lo del puntero a cadena (const char * frase) lo he visto en otro driver LCD para SDCC, voy a probar lo que dice cerebro a ver que pasa, aunque lo suyo es que imprima directamente una cadena.

Estoy empezando con el C y casi todo lo he adaptado de otros programas... así que cualquier mejora o sujerencia es bienvenida.

[Cryn]

Código: [Seleccionar]

while(1)
{
lcd_clear();
lprintf("H");
lprintf("o");
lprintf("l");
lprintf("a");
delay_ms(1000);
//lcd_clear(); si usas esto quiere decir que vas a borrar el hola
                // me parece que solo deberás utilizar un retorno de carro y nueva linea, que en la libreria de CC que yo uso es "\n"
                // pero en este caso parece qeu debes mandar la instruccion: #define linea2  0xC0 // Line 2 posicion 1
                //que esta arriba en tus defines
lprintf("estas");
delay_ms(1000);

// me imprime: "Hola" , se borra y luego me imprime solo "e"
}
Me parece tb que tu función lprintf(""), solo sirve para mostrar un carácter y no una cadena, por eso solo escribe la "e"

[cerebro]

para mi  ......... que ese "estas" no te lo esta tomando como un vector de char..... estas seguro que eso no es otra cosa como un string por ejemplo?  

Me parece tb que tu función lprintf(""), solo sirve para mostrar un carácter y no una cadena, por eso solo escribe la "e"

La rutina muestra todo un vector pero va dibujando caracter por caracter..
 saludos

[arcachofo]

Pues yo pienso que me lo está tomando como un vector a una cadena... no? y el vector debería ir avanzando posiciones en la cadena e imprimiéndolas, al menos esa es la idea, pero se vé que se queda solo con el primer valor.

También he probado con esta rutina y hace lo mismo:

Código: [Seleccionar]


void lprintf( const char *frase )
{
char pi = 0, c;

while( 1 )

{

c = frase[pi++];

if ( !c ){
return;
}
if ( c == '\n' ){
send_comand( linea2 );

}
else{
send_dato( c );
}
}
}


Donde puedo conseguir la librería de redpic?.... aver como lo hace el...

Nada nada... ya encontré la flexpic...

[cerebro]

te cuento a mi lo que no me permite mi compilador es

Código: [Seleccionar]

lprintf("estas");porque me dice que no puede crear un puntero de una constante, si yo lo fuerzo a que sea un vector char asi

Código: [Seleccionar]

char a[ ]="abcdefg";
lprintf(a);
anda de 10, el tema es que son compiladores distintos y cada uno hay que agarrarle la mano igual supongo que las otras funciones send_dato( char dato )
funcionan correctamente yo utilizo otra..... por eso
saludos

la libreria seguro esta en su pagina www...

[gera]

una duda, no se si tendra algo q ver. La funcion write incrementa automaticamente el puntero a donde se va a escribir el dato? Porq quizas los caracteres se estan pisando ya que no avanza el cursor.
saludos!

[arcachofo]

Gracias de nuevo a todos por la ayuda.

gera:
pues he probado por si acaso a incrementar el cursor cada vez que escribe una letra, pero sigue haciendo lo mismo pero separando las letras, osea "hola" como lo escribo letra a letra se escribe bien pero con espacios entre las letras y "estas" solo escribe la "e". La librería flexlcd no tiene función para escribir frase, solo letra a letra, o yo al menos no la veo...

cerebro:
he probado lo de: char a[ ]="abcdefg"; pero el SDCC no me lo acepta. Tambien he probado: c = frase[pi++]; y si me lo acepta pero hace lo mismo, solo escribe la primera letra.

cryn:
pues sí... solo escribe una letra, pero en teoría debería escribir todas las letras de la cadena... no?
El caso es que el compilador me acepta la función, compila perfecto y todo va bién, pero se olvida de escribir todas las letras...

Puede que el problema esté en otra parte... voy a revisarlo bién a ver que veo.


EDITO:

Otra variante que he probado con los mismos resultados.. osea solo escribe la primera letra:

Código: [Seleccionar]


void lprintf( char *frase )
{
char *c;
  for (c=frase; *c; c++) {
send_dato(*c);
}
}



[cerebro]

Que lio esta generando esta rutina! jajajaja. A ver si me explico un poco mejor, a mi entender lo que te esta pasando es que la rutina lprintf() siempre esta recibiendo un solo caracter como la estas llamando por eso siempre te muestra la e. En mi caso el compilador ni siquiera lo permite pero en tu caso puede ser eso. La rutina original que planteaste andaba sin problemas, asi que yo no la modificaria. Pero si vos me aseguras que le envias verdaderamente un vector de char, creo que se me viene abajo la teoria y te recomendaria revisar todo el codigo.
 que tal si probas enviar un vector char inicializado como sea.
 saludos espero que tu problema se resuelva 

[arcachofo]

Je je je... os estoy liando de mala manera...

Perdona por mi ignorancia, pero ya te digo que de C no controlo mucho

Pero.... voy por buen camino, por ejemplo si le pongo esto:

Código: [Seleccionar]


void lprintf( const char *frase )
{
c = frase[3];

send_dato( c );
}



Me escribe la cuarta letra, osea que esto tiene que funcionar...

Pero si lo hago así:

Código: [Seleccionar]


void lprintf( const char *frase )
{
char c, n = 0;

while(*frase)
{
c = frase[n];
send_dato( c );
n++;
}
}



Pues me escribe la primera letra y se queda bloqueado, normalmente se enciende y se apaga ya que tengo unos delays y lcd_clear.

Ya lo tengo acorralado pero con mis pocos conocimientos de C solo doy palos de ciego... quizás ahora si me podais ayudar a hacer una rutina que funcione.

[cerebro]

  me convenci que no era lo que pensaba....... con gusto te ayudaria pero parece que el compilador que utilizas no se maneja muy similar al ccs y vamos a estar hablando dos idiomas distintos.
  El SDCC corre bajo windows? estaria bueno conocerlo.
  Probaste la flex_lcd? porque capas se podria modificar esa....
saludos

[arcachofo]

Hola cerebro...

Pues SDCC es un proyecto de código abierto que corre bajo LInux, Windows y Mac, pero no es un compilador específico para PIC, se desarrolló en principio para Z80, 8051 y alguno más, aunque se puede adaptar a casi cualquier uc, ultimamente se está publicando soporte para PIC, ya está bastante completo para PIC18F con librerías y demás, pero para PIC de 14 bits todavía está en camino, tiene soporte básico para muchos PIC16F y algunos PIC12, pero hay muy pocas librerías oficiales publicadas, por eso trato de escribir las rutinas básicas para manejar un LCD.

La función "lprintf" es lo que trato de crear, no existe previamente en este compilador y es posible que cualquiera de las que he probado funcione y que el fallo esté en no incluir alguna librería de manejo de cadenas o algo así, porque puedo escribir cualquier caracter de la cadena mandando el vector a la posición que sea, pero si hago un bucle y voy aumentando la posición del vector entonces solo me devuelve una letra la primera vez, sea cual sea la posición de inicio... si empiezo por la tercera letra, me la imprime bién, pero si aumento la posición dentro de la cadena ya no me devuelve nada más sino un caracter vacio.

Saludos.