Problema: aparecen caracteres raros PIC18f4550 [Hi-tech PICC-18]

[edu1989]

Hola amigos,

Como muchos sabeis estoy haciendo un programa que envia datos de un sensor de temperatura y el valor del potenciometro de la placa PICDEM FS USB que incorpora el PIC18f4550.

He hecho pruebas con la herramienta COMPIM de proteus haciendo una connexion entre dos PCs y los datos los recibo perfectamente. Ahora he grabado ese programa al PIC y en el terminal de mi PC recibo caracteres raros.

Que puede estar succediendo?

Adjunto el codigo a continuacion ( trabajo con un cristal de 5MHz seleccionado a partir de las palabras de configuracion y del registro OSCCON  

Código: [Seleccionar]


#include <stdlib.h>  // para poder usar la funcion itoa
#include <htc.h>


__CONFIG(1, 0x0018);
__CONFIG(2, 0x0039);
__CONFIG(3, 0x01FF );
__CONFIG(4, 0x29FF);
__CONFIG(5, 0xC00F);
__CONFIG(6, 0xE00F);
__CONFIG(7, 0x000F);



/* =================================================================================
Definitions
   ================================================================================= */
#define PORTBIT(adr, bit) ( (unsigned)(&adr)*8 + (bit) )
 
#define Idle_Low 1 // No envia datos
#define Idle_High 2 // Envia datos
 
#define true 1
#define false 0
 
#define BAUD  4800 // Configuramos la velocidad, tanto puede ser 19200 o de 9600 kbaud/s pero hay q cambiarlo tb en la simulacion de proteus
#define PIC_CLK 5000000 // Clock de 5MHz (Cristal)

 
#define CS RB2
 


/* =================================================================================
Global variables  
  ================================================================================= */
//static bit potenciometro @ PORTBIT(PORTA, 0); // Declaración del potenciometro
//static bit sensor_temperatura @ PORTBIT(PORTB, 0);
//static bit sensor_datos_salida @ PORTBIT(PORTC, 7);  // SD0 disabled in master mode (configuración como entrada)
 
static bit LED @ PORTBIT(PORTD, 0);
char present_state = Idle_Low; // state variable
char future_state = Idle_Low; // state variable
unsigned int  valor_potenciometro;
unsigned int  valor_sensor_temperatura;
unsigned char pote_buf[6];
unsigned char sensor_buf[10];
char * valor_pote_en_texto;           // un puntero para almacenar el numero en texto
char * valor_sensor_en_texto;         // un puntero para almacenar el numero en texto
char byte_alto, byte_bajo;

unsigned char caracter_recibido;
unsigned char dummy;
 



/* =================================================================================
Function prototypes
   ================================================================================= */
//static void interrupt service_routine (void); // This is the interrupt service routine
 
void init_system (void);
void time_delay (unsigned int );
char output_logic(void);
char future_state_logic(void);

void setup_sensor(void);
void setup_adc(void);
void serial_setup(void);
 
void putst(const char *str);
void putch(unsigned char c);

unsigned char getch(void);
unsigned char UsartReadChar_nonstop(void);
unsigned char getch_available(void);
void clear_usart_errors(void);

unsigned char read_spi (void);
unsigned int read_adc(void);

 
 
/* =================================================================================
Main function
   ================================================================================= */
void main(void)
{
  valor_potenciometro = 0;
  valor_sensor_temperatura = 0;
  LED = 0;
  init_system();
  setup_sensor();
  setup_adc();
  serial_setup();
  
time_delay(30000);
while(1)
  {
    CS = 0;
    byte_alto = read_spi();
    byte_bajo = read_spi();
    CS = 1;
    valor_sensor_temperatura = (byte_alto << 8) + byte_bajo;
    valor_sensor_temperatura = valor_sensor_temperatura >> 7;
    //valor_sensor_temperatura = read_spi();  // Las pongo aqui porque es donde hago la lectura de los datos.
    valor_potenciometro = read_adc();
    
    valor_pote_en_texto = itoa (pote_buf, valor_potenciometro, 10);
    valor_sensor_en_texto = itoa (sensor_buf, valor_sensor_temperatura, 10);
    
output_logic();
    future_state_logic();
  
}
}

/* =================================================================================
Function definitions
   ================================================================================= */

//*****************************************************************************
//Future_state_logic routine
//*****************************************************************************
char future_state_logic(void)
{
  char error = 0;
  switch (present_state)
  {
    case Idle_Low:
                
                  if ((valor_sensor_temperatura < 5) || (valor_potenciometro <=0))
                 { // Menor de 20ºC o la resistencia menos a 25Kohms
                    //future_state = Idle_High;
                    present_state = Idle_High;
                 }
                  else
                  if (getch_available() == true) //Si hay un caracter disponible recibido por el puerto serie
                  {
                    caracter_recibido = getch();
                    if (caracter_recibido == 'a')
                    {
                      present_state = Idle_High;
                    }
                    else
                    {
                    
                      present_state = Idle_Low;
                      error = 1;
                    }
                 }
                  break;
    case Idle_High:
                   if (TXIF == 0)
                   { // Buffer de transmision vacio
                     //future_state = Idle_Low;
                     present_state = Idle_Low;
                   }
                   else
                   {
                     error = 1;
                   }
                   break;
    default:
 error = 1;
  }
  return (error);
}

//*****************************************************************************
//Output logic routine
//*****************************************************************************
char output_logic(void)
{
  unsigned char error = 1;
  switch (present_state)
  {
    case Idle_Low:
                   LED = 0;
                   error = 0;
                   break;
    case Idle_High:
                   putst ("\n");
  putst ("Valor del pote: ");
                   putst (valor_pote_en_texto);
                   putst ("\n");  //cambio de linea
                   putst ("Valor del sensor: ");
                   putst (valor_sensor_en_texto);
                   //putst ("Suponemos un valor de 25 grados");
                   putst ("\n");
                   LED = 1;
                   error = 0;
                   break;
    default:
                   error = 1;
                   LED = 0;
                   break;
  }
  return (error);
}

//*****************************************************************************
//Init operations  
//*****************************************************************************
void init_system (void)
{
//Primary oscillator
SCS1=0;
SCS0=0;
  
  TRISA = 255;
  CS = 1;
  TRISB = 1; // SDI. El bit 0 a 1.Configurado en master mode (bit 1 cleared, en mode slave bit 1 set)
  TRISC = 192; // RC7 i RC6 a 1
  TRISD=0;
}

  
//*****************************************************************************
//Time delay routine.  
//*****************************************************************************
void time_delay(unsigned int delay)
{
  unsigned int i;

  for (i = 0; i <= delay; i++)
  {
    NOP();
  }
}
 
//*****************************************************************************
// SERIAL SETUP  
//*****************************************************************************
void serial_setup(void)
{
  #define SPBRG_VALUE ((PIC_CLK/(16UL*BAUD)) -1)
  BRGH = 1;
  BRG16 = 0;
  SPBRG = SPBRG_VALUE;
  SPEN = 1; // Enable serial port
  SYNC = 0; // Asincrono
  TXIE = 0; // Desactivar interrupciones en tx
  TXEN = 1; // Enable the transmitter
  TX9 = 0; // 8 bits transmission
  RCIE = 1; // Activar interrupciones en rx
  RX9 = 0; // 8 bits reception
  CREN = 1; //Enable reception
  #define clear_usart_errors_inline if (OERR)\
                                   {\
                                      TXEN = 0;\
                                      TXEN = 1;\
                                      CREN = 0;\
                                      CREN = 1;\
                                    }\
                                   if (FERR)\
                                  {\
                                     dummy = RCREG;\
                                      TXEN = 0;\
                                      TXEN = 1;\
                                    }
}
 
 
//*****************************************************************************
// Enviar datos ( un caracter)
//*****************************************************************************
 
void putch(unsigned char c)
{
  while (!TXIF)
  {
    clear_usart_errors_inline;
    CLRWDT();
  }
  TXREG = c;
}
//*****************************************************************************
// Enviar datos (un buffer)
//*****************************************************************************
void putst(register const char *str)
{
  while ((*str) != 0)
  {
    putch (*str);
    if (*str == 13) putch (10);
    if (*str == 10) putch (13);
    str++;
  }
}


//*****************************************************************************
//Leer datos ( un caracter)
//*****************************************************************************
 
unsigned char getch(void)
{
  while (RCIF != 1)
 { //1 = The EUSART receive buffer, RCREG, is full
    CLRWDT();
    clear_usart_errors_inline;
  }
  return RCREG;
}
 
//*****************************************************************************
//Leer datos (un buffer)
//*****************************************************************************
unsigned char UsartReadChar_nonstop(void)
{
  if (!RCIF)
    return 0;  
 return RCREG;
}
 
 
//*****************************************************************************
//Comprueba si aun faltan datos o no
//*****************************************************************************
unsigned char getch_available(void)
{
  if (RCIF)
    return true;
  else
    return false;
}
 
 
//*****************************************************************************
//Errores USART
//*****************************************************************************
void clear_usart_errors(void)
{
  clear_usart_errors_inline;
}
 

//*****************************************************************************
//Leer entradas.
//*****************************************************************************
 
//*****************************************************************************
//Leer bytes recibidos del bus del modulo SPI
//*****************************************************************************
 
void setup_sensor(void)  // SPI Master mode:
{
  SSPEN = 1; //Enables serial port and configures SCK, SDO, SDI and SS as serial port pins
  BF = 0;       //Receive not complete, SSPBUF is empty
  //SCK is the clock output (Master Mode)
  //Clock Polarity(Idle state of SCK)
  SMP = 0;     //Input data sampled at end of data output time
  CKE = 0;      //Transmit occurs on transition from Idle to active clock state
  SSPM3 = 0;
  SSPM2 = 0; //SPI Master mode, clock = FOSC/4
  SSPM1 = 0;
  SSPM0 = 0;
  CKP = 0; //Idle state for clock is a low level
  SSPIF = 0;  
}
 
void setup_adc(void)
{
  ADFM = 1;
  ADCON1 = 14; // PCFG3=1,PCFG2=1,PCFG1=1,PCFG0=0. Todas las entradas digitales
  // Seleccionamos el canal 0 (AN0) que es donde esta conectado el potenciometro
  CHS3 = 0;
  CHS2 = 0;
  CHS1 = 0;
  CHS0 = 0;
  //Tiempo de adquisicion
  ACQT2 = 0;
  ACQT1 = 1;  
  ACQT0 = 0;
  // Tiempo de conversion
  ADCS2 = 1;
  ADCS1 = 0;    //                         Idem a 4Tosc. 4*Tosc(1/5Mhz = 0.2us) es el primer valor que hace que sea superior a 0.7us( el minimo) (100)
  ADCS0 = 0;
  
  ADON = 1; // A/D converter module is enabled
  /* Configure A/D interrupt*/
  ADIF = 0;
}
 
//*****************************************************************************
//Leer entradas.
//*****************************************************************************
 
//*****************************************************************************
//LEER DATOS SENSOR
//*****************************************************************************
unsigned char read_spi (void)
{
/*
  if ((BF == 1) && (SSPIF == 1))
  { //Receive complete, SSPBUF is full && The transmission/reception is complete (must be cleared in software)
    SSPIF = 0; ////Waiting to transmit/receive
    BF = 0;
    return SSPBUF;
 }
*/
  TRISC7 = 1; // así pongo en alta impedancia el pin SDO
  SSPBUF = 16;
  while (SSPIF == 0);
  SSPIF = 0;
  return SSPBUF;
}
 
//*****************************************************************************
//LEER DATOS POTENCIOMETRO
//*****************************************************************************
unsigned int read_adc(void)
{
  //Empezar a leer
  GODONE = 1; // A/D conversion in progress
  while (GODONE == 1);
  ADIF = 0;
  return ((ADRESH << 8) + (ADRESL));
}
Gracias de antemano. Cualquier pequeña idea es bienvenida!

[AngelGris]

  No entiendo porque ponés la configuración de la palabra 1 en 0x0018.
  Basado en éso me da la siguiente configuración....

  00 El byte alto --> quiere decir que está en modo XT
  18 El byte bajo --> oscilador primario dividido 4 y el PLLDIV queda en 0, como está en 0 el bit 5 --> el clock para USB es directo del cristal.

  Pero el modo XT sólo permite como máximo una frecuencia de 4MHz, y en tu placa PICDEM hay un cristal de 20MHz así que abría que cambiar eso para que el modo sea HS.

  Como en el Datasheet dice que los bits no implementados hay que mantenerlos en "1", yo estaba pensando en la siguiente configuración...  0x3CFC

  Explayo el porque: byte alto bits 7 y 6 en 0, bits 5 y 4 en 1 bits 3..0 1100 para que quede en modo HS. Por lo tanto el byte alto queda 0011 1100 --> 3C

  byte bajo: bits 7 y 6 en 1, bit 5 en 1, bits 4 y 3 en 1 para que el clock del sistema sea el oscilador dividido 4 (que serían los 20MHz/4) bits 2..0 en 100 para que el ingreso al PLL del USB sea el oscilador primario dividido 5 (20MHz/5 = 4MHz, que sería la entrada que acepta el bloque PLL del usb). Por lo tanto el byte bajo quedaría 1111 1100 --> FC

  Pero eso es todo en teoría, ya que como nunca use este PIC, todavía no termino de entender bien porque se producen los fallos en tu programa.
 

[edu1989]

Gracias! He probado de cambiar la palabra de configuracion 1 tal y como has dicho y sigue sin funcionar. Ahora en el proteus cuando le pongo el .hex con las palabras de configuracion, ya no se queja pero siguen saliendo los errores del adc:

ADC conversion clock period(2,0832e-08) violates the minimum required TAD time
ADC conversion clock period(2e-07) violates the minimum required TAD time
Simulation is not running in real time due to excessive CPU load

Eso es lo que sale...

Gracias de antemano, a ver si encontramos la solucion.. yo seguire probando cosas.
P.D: Adjunto el archivo del hyperterminal.

[AngelGris]

Gracias! He probado de cambiar la palabra de configuracion 1 tal y como has dicho y sigue sin funcionar. Ahora en el proteus cuando le pongo el .hex con las palabras de configuracion, ya no se queja pero siguen saliendo los errores del adc:

ADC conversion clock period(2,0832e-08) violates the minimum required TAD time
ADC conversion clock period(2e-07) violates the minimum required TAD time
Simulation is not running in real time due to excessive CPU load

Eso es lo que sale...

Gracias de antemano, a ver si encontramos la solucion.. yo seguire probando cosas.
P.D: Adjunto el archivo del hyperterminal.

  Con respecto al que dice "ADC conversion clock period(2e-07) violates the minimum required TAD time", ese número es 200ns. Si suponemos que ese tiempo sería (en teoría 4/FOSC), hago 200ns/4 y me da 50ns, ahora hago 1/50ns y me da una frecuencia de 20MHz.
  No se porque, pero parecería que el proteus multiplica la frecuencia que uno le pone por el valor de CPUDIV, recorda que CPUDIV está en 4. Entonces si hacemos 5MHZ * 4 me da los 20MHz que despejé en el párrafo anterior.

  Con respecto al error "Simulation is not running in real time due to excessive CPU load", eso es porque la PC se está sobrecargando para la simulación. Sí se simula cualquier circuito demasiado complejo o con muchas operaciones salta ese mensaje.

  Respecto a los caracteres raros también me pasaba en la simulación de proteus cuando me tiraba ese error del TAD porque aparentemente leia mal el ADC y generaba despelotes.

[edu1989]

Creo que tienes razon en lo que dices.. entonces.. hago los calculos de los tiempos del adc para 20MHz? o que hago?

Muchas gracias, a ver si funciona pronto

[AngelGris]

  Y sí, sería cuestión de probar a ver si haciendo los cálculos del ADC para 20MHz empieza a trabajar bien.

[AngelGris]

 ¿Qué pasa si grabás el programa como lo tenés pero con la configuración que yo te puse, en el PIC real?
 Porque yo acabo de simularlo en el Proteus dejando los 20MHz como directo y haciendo el cálculo para el TAD basado en los 20MHz pero sigue tirando el error que se viola el tiempo mínimo de TAD. Con lo cual me imagino que hay algún problema en la simulación respecto a como interpreta los bits de configuración.

[edu1989]

Sigue sin funcionar pero es que ahora mismo en el proteus tambien me da error ( en el compim se marca la opcion de error). Dejo aqui el programa de nuevo, pruebalo a ver si a ti te funciona. He vuelto a calcular los tiempos tanto el tad como el tacq, y he cambiado el reloj por un 20MHz HS ( quitando todos los postscalers y prescalers). Lo del registro OSCCON lo tengo comentado porque no se si esta bien..

Dejo el codigo y la simulacion. Gracias de antemano, seguire mirando..

Código: [Seleccionar]


#include <stdlib.h>  // para poder usar la funcion itoa
#include <htc.h>


__CONFIG(1, 0x3CE0);  // Cambiar
__CONFIG(2, 0x0039);
__CONFIG(3, 0x01FF );
__CONFIG(4, 0x29FF);
__CONFIG(5, 0xC00F);
__CONFIG(6, 0xE00F);
__CONFIG(7, 0x000F);



/* =================================================================================
Definitions
   ================================================================================= */
#define PORTBIT(adr, bit) ( (unsigned)(&adr)*8 + (bit) )
 
#define Idle_Low 1 // No envia datos
#define Idle_High 2 // Envia datos
 
#define true 1
#define false 0
 
#define BAUD  9600 // Configuramos la velocidad, tanto puede ser 19200 o de 9600 kbaud/s pero hay q cambiarlo tb en la simulacion de proteus
#define PIC_CLK 20000000 // Clock de 20MHz

 
#define CS RB2
 


/* =================================================================================
Global variables  
  ================================================================================= */
//static bit potenciometro @ PORTBIT(PORTA, 0); // Declaración del potenciometro
//static bit sensor_temperatura @ PORTBIT(PORTB, 0);
//static bit sensor_datos_salida @ PORTBIT(PORTC, 7);  // SD0 disabled in master mode (configuración como entrada)
 
static bit LED @ PORTBIT(PORTD, 0);
char present_state = Idle_Low; // state variable
char future_state = Idle_Low; // state variable
unsigned int  valor_potenciometro;
unsigned int  valor_sensor_temperatura;
unsigned char pote_buf[6];
unsigned char sensor_buf[10];
char * valor_pote_en_texto;           // un puntero para almacenar el numero en texto
char * valor_sensor_en_texto;         // un puntero para almacenar el numero en texto
char byte_alto, byte_bajo;

unsigned char caracter_recibido;
unsigned char dummy;
 



/* =================================================================================
Function prototypes
   ================================================================================= */
//static void interrupt service_routine (void); // This is the interrupt service routine
 
void init_system (void);
void time_delay (unsigned int );
char output_logic(void);
char future_state_logic(void);

void setup_sensor(void);
void setup_adc(void);
void serial_setup(void);
 
void putst(const char *str);
void putch(unsigned char c);

unsigned char getch(void);
unsigned char UsartReadChar_nonstop(void);
unsigned char getch_available(void);
void clear_usart_errors(void);

unsigned char read_spi (void);
unsigned int read_adc(void);

 
 
/* =================================================================================
Main function
   ================================================================================= */
void main(void)
{
  valor_potenciometro = 0;
  valor_sensor_temperatura = 0;
  LED = 0;
  init_system();
  setup_sensor();
  setup_adc();
  serial_setup();
  
time_delay(30000);
while(1)
  {
    CS = 0;
    byte_alto = read_spi();
    byte_bajo = read_spi();
    CS = 1;
    valor_sensor_temperatura = (byte_alto << 8) + byte_bajo;
    valor_sensor_temperatura = valor_sensor_temperatura >> 7;
    //valor_sensor_temperatura = read_spi();  // Las pongo aqui porque es donde hago la lectura de los datos.
    valor_potenciometro = read_adc();
    
    valor_pote_en_texto = itoa (pote_buf, valor_potenciometro, 10);
    valor_sensor_en_texto = itoa (sensor_buf, valor_sensor_temperatura, 10);
    
output_logic();
    future_state_logic();
  
}
}

/* =================================================================================
Function definitions
   ================================================================================= */

//*****************************************************************************
//Future_state_logic routine
//*****************************************************************************
char future_state_logic(void)
{
  char error = 0;
  switch (present_state)
  {
    case Idle_Low:
                
                  if ((valor_sensor_temperatura < 10) || (valor_potenciometro < 1))
                 { // Menor de 20ºC o la resistencia menos a 25Kohms
                    //future_state = Idle_High;
                    present_state = Idle_High;
                 }
                  else
                  if (getch_available() == true) //Si hay un caracter disponible recibido por el puerto serie
                  {
                    caracter_recibido = getch();
                    if (caracter_recibido == 'a')
                    {
                      present_state = Idle_High;
                    }
                    else
                    {
                    
                      present_state = Idle_Low;
                      error = 1;
                    }
                 }
                  break;
    case Idle_High:
                   if (TXIF == 0)
                   { // Buffer de transmision vacio
                     //future_state = Idle_Low;
                     present_state = Idle_Low;
                   }
                   else
                   {
                     error = 1;
                   }
                   break;
    default:
 error = 1;
  }
  return (error);
}

//*****************************************************************************
//Output logic routine
//*****************************************************************************
char output_logic(void)
{
  unsigned char error = 1;
  switch (present_state)
  {
    case Idle_Low:
                   LED = 0;
                   error = 0;
                   break;
    case Idle_High:
                   putst ("\n");
  putst ("Valor del pote: ");
                   putst (valor_pote_en_texto);
                   putst ("\n");  //cambio de linea
                   putst ("Valor del sensor: ");
                   putst (valor_sensor_en_texto);
                   //putst ("Suponemos un valor de 25 grados");
                   putst ("\n");
                   LED = 1;
                   error = 0;
                   break;
    default:
                   error = 1;
                   LED = 0;
                   break;
  }
  return (error);
}

//*****************************************************************************
//Init operations  
//*****************************************************************************
void init_system (void)
{
//Primary oscillator
// SCS1=0;
// SCS0=0;
  
  TRISA = 255;
  CS = 1;
  TRISB = 1; // SDI. El bit 0 a 1.Configurado en master mode (bit 1 cleared, en mode slave bit 1 set)
  TRISC = 192; // RC7 i RC6 a 1
  TRISD=0;
}

  
//*****************************************************************************
//Time delay routine.  
//*****************************************************************************
void time_delay(unsigned int delay)
{
  unsigned int i;

  for (i = 0; i <= delay; i++)
  {
    NOP();
  }
}
 
//*****************************************************************************
// SERIAL SETUP  
//*****************************************************************************
void serial_setup(void)
{
  #define SPBRG_VALUE ((PIC_CLK/(16UL*BAUD)) -1)
  BRGH = 1;
  BRG16 = 0;
  SPBRG = SPBRG_VALUE;
  SPEN = 1; // Enable serial port
  SYNC = 0; // Asincrono
  TXIE = 0; // Desactivar interrupciones en tx
  TXEN = 1; // Enable the transmitter
  TX9 = 0; // 8 bits transmission
  RCIE = 1; // Activar interrupciones en rx
  RX9 = 0; // 8 bits reception
  CREN = 1; //Enable reception
  #define clear_usart_errors_inline if (OERR)\
                                   {\
                                      TXEN = 0;\
                                      TXEN = 1;\
                                      CREN = 0;\
                                      CREN = 1;\
                                    }\
                                   if (FERR)\
                                  {\
                                     dummy = RCREG;\
                                      TXEN = 0;\
                                      TXEN = 1;\
                                    }
}
 
 
//*****************************************************************************
// Enviar datos ( un caracter)
//*****************************************************************************
 
void putch(unsigned char c)
{
  while (!TXIF)
  {
    clear_usart_errors_inline;
    CLRWDT();
  }
  TXREG = c;
}
//*****************************************************************************
// Enviar datos (un buffer)
//*****************************************************************************
void putst(register const char *str)
{
  while ((*str) != 0)
  {
    putch (*str);
    if (*str == 13) putch (10);
    if (*str == 10) putch (13);
    str++;
  }
}


//*****************************************************************************
//Leer datos ( un caracter)
//*****************************************************************************
 
unsigned char getch(void)
{
  while (RCIF != 1)
 { //1 = The EUSART receive buffer, RCREG, is full
    CLRWDT();
    clear_usart_errors_inline;
  }
  return RCREG;
}
 
//*****************************************************************************
//Leer datos (un buffer)
//*****************************************************************************
unsigned char UsartReadChar_nonstop(void)
{
  if (!RCIF)
    return 0;  
 return RCREG;
}
 
 
//*****************************************************************************
//Comprueba si aun faltan datos o no
//*****************************************************************************
unsigned char getch_available(void)
{
  if (RCIF)
    return true;
  else
    return false;
}
 
 
//*****************************************************************************
//Errores USART
//*****************************************************************************
void clear_usart_errors(void)
{
  clear_usart_errors_inline;
}
 

//*****************************************************************************
//Leer entradas.
//*****************************************************************************
 
//*****************************************************************************
//Leer bytes recibidos del bus del modulo SPI
//*****************************************************************************
 
void setup_sensor(void)  // SPI Master mode:
{
  SSPEN = 1; //Enables serial port and configures SCK, SDO, SDI and SS as serial port pins
  BF = 0;       //Receive not complete, SSPBUF is empty
  //SCK is the clock output (Master Mode)
  //Clock Polarity(Idle state of SCK)
  SMP = 0;     //Input data sampled at end of data output time
  CKE = 0;      //Transmit occurs on transition from Idle to active clock state
  SSPM3 = 0;
  SSPM2 = 0; //SPI Master mode, clock = FOSC/4
  SSPM1 = 0;
  SSPM0 = 0;
  CKP = 0; //Idle state for clock is a low level
  SSPIF = 0;  
}
 
void setup_adc(void)
{
  ADFM = 1;
  ADCON1 = 14; // PCFG3=1,PCFG2=1,PCFG1=1,PCFG0=0. Todas las entradas digitales
  // Seleccionamos el canal 0 (AN0) que es donde esta conectado el potenciometro
  CHS3 = 0;
  CHS2 = 0;
  CHS1 = 0;
  CHS0 = 0;
  //Tiempo de adquisicion 010
  ACQT2 = 0;
  ACQT1 = 1;   //4Tad
  ACQT0 = 0;
  // Tiempo de conversion
  ADCS2 = 1;
  ADCS1 = 1;    // 16Tosc                        Idem a 4Tosc. 4*Tosc(1/5Mhz = 0.2us) es el primer valor que hace que sea superior a 0.7us( el minimo) (100)
  ADCS0 = 0;
  
  ADON = 1; // A/D converter module is enabled
  /* Configure A/D interrupt*/
  ADIF = 0;
}
 
//*****************************************************************************
//Leer entradas.
//*****************************************************************************
 
//*****************************************************************************
//LEER DATOS SENSOR
//*****************************************************************************
unsigned char read_spi (void)
{
/*
  if ((BF == 1) && (SSPIF == 1))
  { //Receive complete, SSPBUF is full && The transmission/reception is complete (must be cleared in software)
    SSPIF = 0; ////Waiting to transmit/receive
    BF = 0;
    return SSPBUF;
 }
*/
  TRISC7 = 1; // así pongo en alta impedancia el pin SDO
  SSPBUF = 16;
  while (SSPIF == 0);
  SSPIF = 0;
  return SSPBUF;
}
 
//*****************************************************************************
//LEER DATOS POTENCIOMETRO
//*****************************************************************************
unsigned int read_adc(void)
{
  //Empezar a leer
  GODONE = 1; // A/D conversion in progress
  while (GODONE == 1);
  ADIF = 0;
  return ((ADRESH << 8) + (ADRESL));
}


[edu1989]

Sigue fallando... en el "PIC real" siguen saliendo caracteres extraños... y ahora como te he comentado da el error en el compim tambien. Envia datos sin tener que enviarlos..

[AngelGris]

  Pro lo que veo en tu programa, lo dejaste como igual al que yo use para probar en el Proteus. Lo único que se me ocurre es comentar la parte de manejo de ADC, tanto la inicialización como la lectura del pote, y probar si al menos se transmiten bien los datos correspondientes al TC77. Como para ir descartando cosas.

[edu1989]

No se porque no funciona nada ahora.. he probado lo que dices ( estoy con el sensor solo) y no funciona.
Explico exactamente que es lo que ocurre ( estoy sin palabra de configuracion).

El led se enciende y sale todo el rato como si estuviera tx pero cuando abro el vterm envia una serie de 0 ( imagino que es el tiempo que tarda en coger los datos) y para. Se puede leer bien y cuando tecleo "a" sale el valor correcto y actual del sensor.
El led no para de parpadear.. no se el porque pero esta como enviando cosas...

Edito1: Acabo de volver a poner la parte del adc y no lee bien el dato. Todo el rato sale 0...

Estoy alucinando.. el programa esta tal cual lo teniamos, he quitado la palabra d configuracion y tendria que funcionar. Solo hemos tocado los tiempos del adc y hemos seguido lo que dice en el manual...

Estas seguro que los bits no implementados se asignan como "1" y no es un "0"?

[AngelGris]

No se porque no funciona nada ahora.. he probado lo que dices ( estoy con el sensor solo) y no funciona.
Explico exactamente que es lo que ocurre ( estoy sin palabra de configuracion).

El led se enciende y sale todo el rato como si estuviera tx pero cuando abro el vterm envia una serie de 0 ( imagino que es el tiempo que tarda en coger los datos) y para. Se puede leer bien y cuando tecleo "a" sale el valor correcto y actual del sensor.
El led no para de parpadear.. no se el porque pero esta como enviando cosas...

Edito1: Acabo de volver a poner la parte del adc y no lee bien el dato. Todo el rato sale 0...

Estoy alucinando.. el programa esta tal cual lo teniamos, he quitado la palabra d configuracion y tendria que funcionar. Solo hemos tocado los tiempos del adc y hemos seguido lo que dice en el manual...

Estas seguro que los bits no implementados se asignan como "1" y no es un "0"?

  Se me ocurre que lo que puede estar pasando es que como no hacés lectura del pote (pero sí la variable "valor_potenciometro" tiene el valor 0 por inicialización) está entrando en los if ya que dicha variable es menor a 25 y por ello ves que te envía siempre 0. Podés probar de inicializarla con un valor superior a 25.

  En cuanto a los bits no implementados, así he visto que están definidos en los .h de HiTech para el 16F876 y funciona bien. También en el datasheet del 18F4550 dice en una de las notas "Unimplemented in PIC18FX455 devices; maintain this bit set.
"

[edu1989]

Sigue sin funcionar, ya habia pensado eso pero como el if tambien depende del sensor, estaba forzando para que entrara y cambiara el valor...
A mi me ha parecido ver en el datasheet que los bits no implementados hay que dejarlos a 0

Mira por ejemplo la TABLE 25-1: CONFIGURATION BITS AND DEVICE IDs (pag 292).

Esta claro que no llega a leer el dato que hay en el pote, la funcion de lectura esta bien y la funcion para pasarlo al valor en texto tambien. Tiene que ser que no guarda bien los datos en el buffer..

[AngelGris]

  Dice que los bits no implementados, si yo leo el registro va a aparecer un 0 en dicho lugar, pero en realidad no especifica mucho si es que hay que dejarlos en 0 o en 1.

  Mirando bien el programa, veo que no se está inicializando la variable específicamente, quizá convenga inicializarla en 128, por decir algo. Para evitar que cuando se lo quiera convertir a texto se generen despelotes.

[edu1989]

Arriba del todo justo cuando la declaro o donde lo estamos haciendo ahora le pongo 128?

Acabo de probar las dos opciones y nada.. sigue sin funcionar..