TODOPIC
Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: begoña1966 en 01 de Abril de 2009, 03:06:08
-
Saludos a todos.
He escrito un programa para un PIC18F2550 y me ocurre lo siguiente: cuando lo simulo con Proteus hace exactamente lo que se le pide, pero cuando lo descargo en la micro los resultados son completamente distintos :shock:, es mas si vario el orden en el que defino las variables tambien cambia la ejecucion del programa.
El compilador que utilizo es pcwh 4.058.
Gracias por su atencion
-
Saludos! A veces proteus funciona, y en la practica real el circuito no funciona, pero otras muchas veces es que al montar el circuito nos equivocamos.
Das pocos datos para poder ayudarte, si quieres que la gente pueda ayudarte deberias mostar el circuito, explicar que quieres que haga el programa del micro y poner todo el codigo, sino es muy complicado poder ayudarte
-
ami m pasa algo parecido, cuando pones un if comparas mas de dos veces? ami m pasa eso, y cuando anido if...kreo k es problema del ccs, q no admite mas de dos comparaciones o algo...xk no es normal, podias escribir tu codigo o en parte, para ver que ocurre como he hecho yo
-
Muchas gracias a todos por adelantado.
He montado una placa de prototipo con un Pic 18F2550 conectado a un modulo GPS que transmite unas tramas via serie.
Lo que pretendo hacer es un equipo que capture las tramas procedentes del modulo GPS, las almacene en una memoria externa y cuando la placa se conecte a un PC a traves del puerto USB le descargue todas las posiciones leidas.
El problema que tengo con el micro es que los datos leidos del GPS se pierden :shock:. Y digo que el problema lo tengo con el micro, por que si lo simulo con proteus funciona como deberia.
Pongo los fuentes.
/////////////////////////////////////////////////////////////////////////
//// ////
//// ////
//// Realizado con el compilador CCS PCWH 4.058 ////
//// ////
//// ////
/////////////////////////////////////////////////////////////////////////
/*
+5
|
20
----------
MCLR ------1-| |-28------PGD
| |-27------PGC
ADC0_VBAT ------2-| |-26------
LED_V ------3-| 18F2550 |-25------
ADC2 ------5-| |-24------
MEM_SCL ------5-| |-23------
MEM_SDA ------6-| |-22------
USB_CON_SENSE ------7-| |-21------
| |
| |
XTAL--9-| |
XTAL-10-| |
| |
-----11-| |-18------RX
-----12-| |-17------TX
-----13-| |-16------D+
-----14-| |-15------D-
----------
8 19
| |
Gnd Gnd
*/
/*Configurar dicha linea en el archivo usb_cdc.h para el protocolo de transmisión
void usb_cdc_init(void) {
//usb_cdc_line_coding.dwDTERrate=9600;//ORIGINAL
usb_cdc_line_coding.dwDTERrate=19200;
*/
/*
usb_desc_cdc.h contiene el VID e ID además del descriptor de nuestro dispositivo
*/
#include <18F2550.h>
#fuses HSPLL,NOWDT,NOPROTECT,NOLVP,NODEBUG,USBDIV,PLL1,CPUDIV1,VREGEN
// Configuracion para depuracion con proteus
//#define debug // Comment line out for no debug
#ifdef debug
#use delay(clock=4000000)
#else
#use delay(clock=48000000)
#endif
// Prepara la comunicacion para el GPS
// 4800 Baudios
// 8 Bits
//#USE RS232(BAUD=4800, XMIT=PIN_C6, RCV=PIN_C7, PARITY=N,BITS=8,ERRORS,stream=RF,disable_ints)//Mediante HW
#USE RS232(BAUD=4800, XMIT=PIN_C6, RCV=PIN_C7, stream=RF)//Mediante HW
///////////////////////////////////////////////////////////////////////////////
// //
// DEFINICION DE HARDWARE //
// //
///////////////////////////////////////////////////////////////////////////////
#define LEDV PIN_A1
#define LED_ON output_high
#define LED_OFF output_low
///////////////////////////////////////////////////////////////////////////////
// //
// CONSTANTES //
// //
///////////////////////////////////////////////////////////////////////////////
// buffer de entrada RS-232
// Constantes para el tratamiento de los datos del GPS
int const lenbuff=128; // Longitud máxima del buffer
char const delimiter = ','; // Delimitador de parametros
char const disabler = '"'; // Deshabilitador de parametros
int const lenparam = 11; // Máxima longitud por parámetro.
// muy importante dejar espacio para los caracteres
// de cada parametro (max 10) mas uno para el
// fin de cadena
///////////////////////////////////////////////////////////////////////////////
// //
// VARIABLES EN RAM //
// //
///////////////////////////////////////////////////////////////////////////////
// Variables que se utilizan para el control de la entrada serie
int xbuff=0x00; // Índice: siguiente char en cbuff
char cbuff[lenbuff]; // Buffer de recepción
int flagcommand=0; // Flag para comando disponible
int flag_start_command=0; // ha llegado el caracter de comienzo de comando
// el dato
// Datos definidos...
int Bandera=0; // Indicador de lectura por el RS232.
char compara[10]; // Variable necesaria para la comparacion de primer campo. ($GPGGA)
// variables que contienen los datos que se extraen del GPS
char hora[11];
char latitude[10];
char ns_indicator; // N = Norte, S = Sur
char longitude[11];
char ew_indicator; // E = Este, W = Oeste
char validador; // indica la validez del dato leido por el GPS
/////////////////////////////////////////////////////////////////////////////
#include ".\include\usb_cdc.h" //Siempre va antes del include usb_desc_cdc.h
#include ".\include\rr2_USB_Cdc_Monitor.h"
#include <string.h>
#include ".\include\Comando.c"
void inicbuff(void); // Borra buffer
void addcbuff(char c); // añade caracter recibido al buffer
////////////////////////////////////////////////////////////////////////////
#int_rda
void serial_isr()
{ // Interrupción USART
char rcvchar=0x00; // último caracter recibido
if(kbhit()){ // Si hay algo pendiente de recibir ...
rcvchar=getc(); // lo descargo y ...
add_2_cbuff(rcvchar); // lo añado al buffer y ...
}
}
void main() {
char temp_char;
flagcommand=0;
LED_OFF(LEDV); // encendemos led rojo
strcpy(compara, "$GPGGA"); // Cadena inicial de transmision GPS
init_cbuff(); // Borra buffer al inicio
enable_interrupts(int_rda); // Habilita Interrupción RDA
#ifndef debug
usb_cdc_init();
usb_init(); // inicializamos el USB
#endif
enable_interrupts(global); // Habilita interrupciones
#ifndef debug
delay_ms(10000); // espera un tiempo
#endif
#ifndef debug
usb_task();
//usb_wait_for_enumeration();//Esta linea espera hasta que el usb esté conectado
#endif
LED_ON(LEDV); // encendemos led verde
usb_cdc_putc('1');
usb_cdc_putc(13);
usb_cdc_putc(10);
while (true)
{
#ifndef debug
if(usb_enumerated()) // USB conectado
{
#endif
if(flagcommand==1) // Se ha recibido un comando ?
{
disable_interrupts(int_rda);
commad_process(); // Hay algo pendiente de procesar y lo procesa.
enable_interrupts(int_rda);
#ifndef debug
temp_char = hora[0];
usb_cdc_putc(temp_char);
temp_char = hora[1];
usb_cdc_putc(temp_char);
temp_char = hora[2];
usb_cdc_putc(temp_char);
temp_char = hora[3];
usb_cdc_putc(temp_char);
temp_char = hora[4];
usb_cdc_putc(13);
usb_cdc_putc(10);
#endif
#ifdef debug
printf("Hora: %s \r\n", hora);
printf("Latitud: %s %c\r\n", latitude, ns_indicator);
printf("Longitud: %s %c\r\n", longitude, ew_indicator);
#endif
Bandera = 0;
LED_OFF(LEDV); // encendemos led verde
// Habilita interrupciones para recibir de nuevo
// mas datos
flag_start_command = 0;
flagcommand = 0;
}
#ifndef debug
}
#endif
// }
}
}
y aqui estan las funciones que tratan las tramas del GPS
///////////////////////////////////////////////////////////////////////////////
//// Funciones de Buffer ////
//// --------------------- ////
//// ////
//// count_param_number(); Cuenta los parametros en el buffer ////
//// ////
//// get_param_by_order(0,lenparam,command); ////
//// Extrae un Parámetro del buffer ////
//// ////
//// init_cbuff(); Inicia a \0 cbuff ////
//// ////
//// add_2_cbuff(rcvchar); Añade a cbuff ////
//// ////
//// commad_process(); Procesador de comandos ////
//// ////
//// ////
///////////////////////////////////////////////////////////////////////////////
// Cuenta los parametros en el buffer --
int8 count_param_number(void){
int8 i, ret;
int1 active;
char c;
ret=0;
active=1;
// ¿Hay comando?
c = cbuff[0];
if(c != 0x00) ret=1;
// Cuenta parámetros
for(i=0; i<lenbuff,c!=0x00; i++){
c = cbuff[i];
if(c==disabler && active==1) {
active=0;
}
else if(c==disabler && active==0){
active=1;
}
if(active==1){
if(c==delimiter){
++ret;
}
}
}
return ret;
}
// Extrae un Parámetro del buffer ------
int1 get_param_by_order(int8 pos, int8 maxlen, char* pP){
int1 ret=0;
char tmp[lenparam];
int8 i,j;
int8 nDelimiter;
int1 active=1;
for(i=0,j=0,nDelimiter=0; i<lenbuff; i++){
tmp[j]=0x00;
if(nDelimiter==pos){
if(!(j==0 && cbuff[i]==disabler)){
tmp[j++]=cbuff[i];
}
}
if(cbuff[i]==disabler && active==1){
active=0;
}
else if(cbuff[i]==disabler && active==0){
active=1;
}
if(active==1){
if((cbuff[i]==Delimiter) || (cbuff[i]==0x00)){
++nDelimiter;
}
}
if(nDelimiter>pos){
j -= 1;
break;
}
}
if(tmp[j-1]==disabler){
--j;
}
tmp[j]='\0';
if(j>maxlen){
ret=1;
}else{
strcpy(pP,tmp);
}
return ret;
}
// Inicia a \0 cbuff -------------------
void init_cbuff(void){
int i;
for(i=0;i<lenbuff;i++){// Bucle que pone a 0 todos los
cbuff[i]=0x00; // caracteres en el buffer
}
xbuff=0x00; // Inicializo el indice de siguiente caracter
}
// Añade a cbuff -----------------------
void add_2_cbuff(char c){
switch(c){
case 0x0a: // LF -> Habilita Flag para procesar comando
// muy importante, el ultimo caracter a coger
// ya que si no no procesa los datos
if (flag_start_command==1){
flagcommand=1;
}
break;
case '$': // $ -> Comienzo de comando
flag_start_command = 1;
cbuff[xbuff++]=c;
break;
case 0x01B: // Esc -> Borra el Buffer completamente
init_cbuff();
break;
default: // Añade caracter recibido al Buffer
if (flag_start_command==1){
cbuff[xbuff++]=c;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// //
// GGA-Global Positioning System Fixed Data //
// //
// UTC Time - hhmmss.sss //
// Latitude - ddmm.mmmm //
// N/S Indicator - N=north or S=south //
// Longitude - dddmm.mmmm //
// E/W Indicator - E=east or W=west //
// Position Fix Indicator - 0 Fix not available or invalid //
// 1 GPS SPS Mode, fix valid //
// 2 Differential GPS, SPS Mode , fix valid //
// 3 GPS PPS Mode, fix valid //
// Satellites Used - Range 0 to 12 //
// HDOP - Horizontal Dilution of Precision //
// MSL Altitude - //
// Units - //
// Geoid Separation - Units //
// Age of Diff. Corr. - Null fields when DGPS is not used //
// Diff. Ref. Station ID - 0000 //
// Checksum - *18 //
// //
////////////////////////////////////////////////////////////////////////////////
void GGA_comand(int pos, char* pP){
switch(pos){
case 0x01: // UTC Time
strcpy(hora,pP);
hora[3] = 'b';
break;
case 0x02: // Latitude
strcpy(latitude,pP);
break;
case 0x03: // N/S Indicator
ns_indicator = *pP;
break;
case 0x04: // Longitude
strcpy(longitude,pP);
break;
case 0x05: // E/W Indicator
ew_indicator = *pP;
break;
case 0x06: // Position Fix Indicator
validador = *pP;
break;
}
}
///////////////////////////////////////
// Procesador de Comandos
///////////////////////////////////////
void commad_process(void){
int n,m;
char command[lenparam]; // Comando
char param[15][lenparam]; // Parámetros
flagcommand=0; // Desactivo flag de comando pendiente.
// Primera Parte: Cuantos
n = count_param_number(); // Cuento el número de parámetros
// Segunda Parte: Cuales
if(n>0){
get_param_by_order(0,lenparam,command);
if (!strncmp(command,compara,strlen(compara))){// Si el iniciador no es correcto
// GGA-Global Positioning System Fixed Data
if(n>1){
for(m=1;m<n;m++){
get_param_by_order(m, lenparam, ¶m[m][0]);
//GGA_comand(m, param[m]);
strcpy(hora,"Hora");
strcpy(latitude,"Latitud");
ns_indicator = 'N';
strcpy(longitude,"Longitud");
ew_indicator = 'E';
validador = '1';
#ifdef debug
printf("%s - ", param[m]);
#endif
}
}
}
}
init_cbuff(); // Borro buffer.
}
Adjunto dos pantallazos de lo que se recibe en el hiperterminal y lo que ocurre cuando se simula en Proteus.
-
he visto ahi if dentro de if...yo he comprobao q si hago eso no va...proteus si, en la realidad no, prueba a no hacer eso de alguna forma y si te va...sabemos que el ccs es una mierda, yo lo he probao y es asi, pero...alomjr es un problema en los fuses nada mas, intenta probar eso, porque yo he hecho ya 4 versiones de mi seguidor, y el problema no estaba en mi programa, sino en que no m dejaba hacer tantas comparaciones o anidaciones...miralo aver