Publicado por: juanelete en 27 de Octubre de 2004, 04:10:00
Tengo un GPS Garmin 95, y quiero leer los datos por medio de un PIC. Los datos estan en formato NMA0183, y consiste en una tramas de datos parecidos a esto:
$GPRMC,182047,A,3745.76,N,00129.28,W,015.0,125.7,231003,002.6,W*78
Baudios=4800, Paridad=None, Bits=8
Probe primero con PIC Basic, y todo fue muy bien, conseguia leer los datos perfectamente, pero conforme fue creciendo el programa, se hacia muy lenta la ejecucion...
Ahora estoy haciendolo con C, concretamente con CCS C Compiler, pero lo unico que sale por la pantalla LCD son caracteres extraños...
Que estoy haciendo mal...
#INCLUDE <16F876.H>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=16000000)
#use RS232(BAUD=4800,RCV=PIN_A4,PARITY=N,BITS=8)
#include "miLCD.c"
void main()
{
char c;
lcd_init();
lcd_putc("fPreparado...
");
while(TRUE)
{
if (kbhit())
{
c=getc();
lcd_putc(c);
delay_ms(200);
}
};
}
Gracias anticipadas.
Saludos.:-)
Publicado por: T0ni0 en 27 de Octubre de 2004, 04:34:00
Por cierto solo te envia el RMC o todos los comandos?
Publicado por: juanelete en 27 de Octubre de 2004, 06:02:00
Lo del retardo es simplemente para poder ver lo que saca por el LCD, ahora mismo me da igual que se pierdan caracteres, lo que quiero ver es que lee algo.
Efectivamente va enviando varios comandos secuencialmente...
Ahora mismo lo unico que me preocupa es que lea caracteres correctos, luego ya implementare cargar en variables los datos que necesite.
Saludos
Publicado por: Modulay en 27 de Octubre de 2004, 08:01:00
#int_rda
void recepcion_serie() // Rutina de interrupción por recepción serie
{
buffer[j] = getc();
j++;
}
void main()
{
int j;
char cadena[17];
char *buffer = cadena;
j = 0;
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
while( j < 15 ) // No salimos hasta que tengamos 16 caracteres en el buffer
{
if (j == 15)
{
disable_interrupts(INT_RDA);
}
}
printf(lcd_putc,"%s",buffer); // Sacamos todo por el lcd
}
Con esto se supone que capturarás los primeros 16 caracteres que mande el gps y después te saldrán por el lcd.Suerte
Publicado por: juanelete en 28 de Octubre de 2004, 06:30:00
Tu ejemplo no lo puedo compilar, me da error, dice que la variable buffer de recepcion_serie() no esta declarada.
Mi a ver si lo puedes solucionar, y despues lo pruebo.
De todas formas ahora mismo no me preocupa tanto el que se pierdan caracteres en recepcion (ya lo arreglare despues), lo que realmente me preocupa es poder leer caracteres correctos, hasta ahora solo saco caracteres extraños por el LCD, y no se si el problema esta en el GPS, en la lectura o en la visualizacion.
Me gustaria que alguno de los "master" de por aqui me confirmara si el programa que he utilizado es correcto para visualizar en el LCD caracteres leidos del GPS (los que sean) o tiene algun fallo. Si el programa es correcto tendre que centrarme en la config. del GPS o en las conexiones...etc.
Gracias a todos.
Saludos
Publicado por: pacalaconcurso en 28 de Octubre de 2004, 11:17:00
saludos
Publicado por: juanelete en 28 de Octubre de 2004, 12:02:00
Me parece genial lo visto en tu pagina, sin duda lo utilizare mas adelante.
Pero mi problema ahora es que no consigo visualizar ningun caracter normal (letras, numeros, comas, ....) por el modulo LCD, solo salen caracteres raros, y no se si el problema es de la recepcion, de la visualizacion...etc.
Me gustaria que me comentarais si el programa que he hecho tiene algun problema o es correcto (lo suficiente para leer algunos caracteres) y mostrarlos en el LCD. Con ver letras y numeros en el LCD me doy por contento, ya implementare despues todo lo demas...
Gracias por tu interes.
Saludos
Publicado por: Modulay en 28 de Octubre de 2004, 12:09:00
Lo que tienes que hacer es declarar "cadena" y "*buffer" de forma global para que sean visibles desde cualquier parte del código.
Las puedes declarar justo después de las directivas de preprocesado.
Mediante interrupción es la forma más segura y eficaz.Prueba y nos cuentas.
Un saludo
Publicado por: pacalaconcurso en 28 de Octubre de 2004, 12:41:00
siendo caracteres tipo int8 y datos [] un array de char
lcd_putc("f"
for(aux=0;aux<caracteres ;aux++)
{
printf(lcd_putc,"%C",datos[aux]);
}
saludos
Publicado por: peddrorolo en 29 de Octubre de 2004, 01:26:00
No estoy seguro de que la respuesta sea la correcta, pero por si acaso, verificalo.
¿es posible que lo que estás leyendo sea codigo hexadecimal y lo que estás envando al LCD no sea código ascii sino hexadecimal? si esto es correcto, lo que ves es el código ascii correspondiente a la entrada hexadecimal, coje un tabla de ascii en la red y como sabes lo que estas recibiendo, que debe ser la trama que pusistes al principio del foro, compruebala en la tabla.
Espero haberte sido de ayuda.
Saludos al foro
Publicado por: Abago en 29 de Octubre de 2004, 04:24:00
Yo ya hice mis pinitos con las comunicaciones serie en PBP, y me encontré con este mismo problema...
creo recordar que lo que recibes del GPS o de una consola, es el valor ascii del caracter...
intenta mirarlo, guardando lo que recibes en la eeprom interna del pic.
hay encontrarás la solución
Publicado por: pocher en 29 de Octubre de 2004, 13:26:00
Escrito originalmente por pacalaconcurso
quizas te interese el ejemplo que colgue en mi web respecto a la recepcion por el puerto serie con CCS
saludos
Hombre Félix, por fin te decidiste a explicar lo de la recepción con una estructura ... era una promesa pendiente, te acuerdas?
He estado estudiando el programita y me gusta. Tiene muchas posibilidades.
Una observación, creo que te falta definir en la estructura: trama[MAX]
Una curiosidad: ¿qué números sueles poner en MAX para el tamaño del buffer?
Publicado por: pacalaconcurso en 29 de Octubre de 2004, 17:53:00
me alegro que te guste pocher, la verdad es que es la mejor forma de tratar la comunicacion cuando se hace en modo binario, donde no se puede (o no es cómodo) usar un determinado carqacter como fin de la cadena... y aunque se use siempre es necesario implementar un timeout.
el tamaño de buffer depende de la aplicacion, suelo poner [50] como partida.
la verdad es que esta forma optimiza mucho la comunicacion, sobre todo cuando usas un micro con dos usart... ahi te das cuenta de la necesidad de optimizar las interrupciones.
por cierto, a ver si os animais y cuelgas algo de lo que guardas en la manga
saludos
Publicado por: juanelete en 04 de Noviembre de 2004, 06:30:00
Llevo varios dias de pruebas... y nada...
He conseguido hacer funcionar el ejemplo de "Modulay", pero no se activa la interrupcion, osea que no recibe nada por el pin correspondiente. He probado cambiando a otros pines, he probado con otras velocidades...pero no se activa la interrupcion.
Estoy desesperado....
He vuelto a probar con PicBasic PLus y funciona perfectamente. Por lo tanto, el GPS transmite bien, el PIC lee bien, el circuito esta bien diseñado y conectado...etc.
Donde esta el problema?
Me falta alguna intruccion en el programa?
Me falta algun parametro en la instruccion #use RS232 ?
Para que sirve la instruccion USE_IO_FAST ?
Veis algun motivo para que no se active la interrupcion #int_rda ?
Ayuda please.
Gracias a todos por vuestra ayuda.
Saludos
Publicado por: T0ni0 en 04 de Noviembre de 2004, 07:27:00
Publicado por: juanelete en 06 de Noviembre de 2004, 11:16:00
Este el codigo
#INCLUDE <16F876.H>
#fuses HS,NOWDT,NOPROTECT,NOLVP
#use delay(clock=16000000)
#use RS232(BAUD=4800,RCV=PIN_A0,PARITY=N,BITS=8)
#include "miLCD.c"
int j=0;
char cadena[17];
char *buffer = cadena;
#int_rda
void recepcion_serie() // Rutina de interrupción por recepción serie
{
lcd_putc("fRecibido1
");
buffer[j] = getc();
j++;
delay_ms(200);
}
void main()
{
int n;
lcd_init();
lcd_putc("fPreparado...
");
delay_ms(1000);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
while( j < 15 ) // No salimos hasta que tengamos 16 caracteres en el buffer
{
if (j == 15)
{
disable_interrupts(INT_RDA);
}
}
printf(lcd_putc,"DAT=%s",buffer); // Sacamos todo por el lcd
delay_ms(500);
}
Cuando lo ejecuto, en el LCD aparece "Preparado..." y no hace nada mas, la int no llega nunca a activarse.
Que quiere decir que no esta alimentado...
El GPS es un Garmin 95, es de mano y va a pilas, simplemente lo enciendo y lo pongo en modo simulador. Tiene una salida con varios cables, conecto el cable negro de masa a la masa del circuito y el cable marron de señal al PIN_A0 del PIC.
Con un programa hecho con PIcbasic Plus funciona correctamente.
Gracias anticipadas.
Saludos
Publicado por: Modulay en 07 de Noviembre de 2004, 12:45:00
Codigo:
#INCLUDE <16F876.H>
#use delay(clock=16000000)
#use RS232(BAUD=4800,RCV=PIN_A0,PARITY=N,BITS=8)
#fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT,NOCPD,NODEBUG
#include "miLCD.c"
int j;
char cadena[17];
char *buffer = cadena;
#int_rda
void recepcion_serie() // Rutina de interrupción por recepción serie
{
// lcd_putc("fRecibido1
"); // Esto lo escribiría cada vez q se interrumpiese
buffer[j] = getc();
j++;
// delay_ms(200); // Si pones aquí un retardo perderás datos
}
void main()
{
j = 0;
lcd_init();
lcd_putc("fPreparado...
");
delay_ms(1000);
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
while( j < 15 ) // No salimos hasta que tengamos 16 caracteres en el buffer
{
if(j == 15)
{
disable_interrupts(INT_RDA);
}
}
printf(lcd_putc,"DAT=%s",buffer); // Sacamos todo por el lcd
delay_ms(500);
for(;;) {}
}
Publicado por: juanelete en 13 de Noviembre de 2004, 06:52:00
LLevo varias semanas liado con esto y nada...
Voy a dejar el GPS aparcado y voy a empezar desde el principio, voy a aprender todo lo que pueda acerca de las comunicaciones via RS232, utilizando un PC (mayor control) y un PIC.
Una vez consiga comunicarlos entre si, ya volvere al tema del GPS.
Gracias a todos por vuestro interes.
Saludos
Publicado por: Modulay en 13 de Noviembre de 2004, 11:48:00
Prueba a conectar el gps a estos dos pines y verás como te funciona.
No se yo si se podrán usar otros pines de la misma forma para comunicaciones serie,pero la cuestión es que lo he simulado en proteus y no hay manera.
Codigo:
#INCLUDE <16F876.H>
#use delay(clock=16000000)
#use RS232(BAUD=4800,RCV=PIN_C7,XMIT=PIN_C6,PARITY=N,BITS=8)
#fuses HS,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT,NOCPD,NODEBUG
#include "miLCD.c"
int j;
char cadena[16];
char *buffer = cadena;
#int_rda
void recepcion_serie() // Rutina de interrupción por recepción serie
{
// lcd_putc("fRecibido1
"); // Esto lo escribiría cada vez q se interrumpiese
buffer[j] = getc();
j++;
// delay_ms(200); // Si pones aquí un retardo perderás datos
}
void main()
{
j = 0;
lcd_init();
lcd_putc("fPreparado...
");
enable_interrupts(INT_RDA);
enable_interrupts(GLOBAL);
while( j < 15 ) // No salimos hasta que tengamos 16 caracteres en el buffer
{
if(j == 15)
{
disable_interrupts(INT_RDA);
}
}
printf(lcd_putc,"%s",buffer); // Sacamos todo por el lcd
delay_ms(500);
for(;;) {}
}
También he quitado un retardo que había en el main pq no servía de nada.
Ya nos cuentas.
Un saludo
Publicado por: Nocturno en 20 de Noviembre de 2004, 10:46:00
Publicado por: juanelete en 20 de Noviembre de 2004, 11:58:00
Creo que no, porque la tension oscila entre 0 y 3.5v.
Saludos