pic18f2550 ejecuta bien la simulacion pero no en el hardware

[begoña1966]

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  , 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

[kain589]

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

[pirata88]

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

[begoña1966]

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 . Y digo que el problema lo tengo con el micro, por que si lo simulo con proteus funciona como deberia.

Pongo los fuentes.

Código: [Seleccionar]

/////////////////////////////////////////////////////////////////////////
////                                                                 ////
////                                                                 ////
//// 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

Código: [Seleccionar]

///////////////////////////////////////////////////////////////////////////////
////                        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, &param[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.

[pirata88]

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