Error al comparar dos strings con strcmp

[edu1989]

Y entonces.. para poder ver lo que estoy recibiendo puedo enviar  esto no?
putst(ComandoRecibido1);

Ya que a la funcion putst hay que pasarle el puntero...

Por otro lado, si uso la funcion cgets y como condicion pongo el "0x0D 0x0A O K 0x0D 0x0A"??? Creo que la mejor opcion es hacerlo con esta funcion.
Ayudame por favor


Gracias

[AngelGris]

  Te muestro un ejemplo de la implementación con los if que te proponía. Está todo el programita, lo que hace es un while donde envío una y otra vez el string "ATS=0" y voy contestando. Como no sé como envíar un "LineFeed" uso un "Enter" en el VirtualTerminal. Osea que mi respuesta -emulando el dispositivo- es Enter Enter O K Enter Enter, que son los 6 caracteres que enviaría tu dispositivo.

Código: C

1. #include <htc.h>
2. #include <stdlib.h>
3. #include <string.h>
4. #include <stdio.h>
5. #include <conio.h>
6.  
7. __CONFIG (HS & LVPDIS & WDTDIS);
8.  
9. #include "Def16f87xa.h"
10.  
11. #define PIC_CLK 10000000
12. #define BAUD 9600
13. #define BRGH_VALUE 1
14.  
15. #include "HardUart16.c"
16.  
17. void leer_respuesta (char * palabra)
18. {
19.   char indice = 0;
20.   char CaracterLeido;
21.  
22.   do
23.   {
24.     CaracterLeido = getch();
25.     if ((CaracterLeido != '\f') && (CaracterLeido != '\r'))
26.     {
27.       *palabra = CaracterLeido;
28.       *palabra++;
29.     }
30.     indice++;
31.   }
32.   while (indice < 6);
33. }
34.  
35.  
36. #pragma psect maintext=cuerpo
37. void main(void)
38. {
39.   char entrada[10];
40.   char * ComandoRecibido;
41.  
42.   TRISC = 255;
43.   InitHardUart (TRANSMIT | RECEIVE);
44.   ComandoRecibido = entrada;  
45.   while (1)
46.   {
47.     putst ("ATS=0");
48.     putch ('\r');
49.  
50.     leer_respuesta (ComandoRecibido);
51. //    cgets (entrada);
52.     if (strcmp(ComandoRecibido,"OK") == 0) putst ("Respuesta correcta");
53.     else
54.       putst ("Respuesta incorrecta");
55.     putch ('\r');
56.   }
57. }

  Acá una captura de la pantalla, como se ve, responde bien a sucesivos comandos.

[edu1989]

Ahora si que me sale. Muchas gracias!
Entonces.. en mi caso que es retorno de carro, linefeed "OK" retorno carro.. voy a intentar modificarlo.

No entiendo bien dos lineas del codigo:

   *palabra = CaracterLeido;
                *palabra++;

Osea guardas en "palabra" los caracteres tipo retorno de carro etc.. pero porque lo guardas y porque haces *palabra++? Perdona si es que estoy pregunto una tonteria.. pero no lo entiendo.

Por otro lado he visto esto:

   if ((CaracterLeido != '\f') && (CaracterLeido != '\r'))

El caracter \r se refiere a retorno de carro pero el \f? Yo tengo que el lineefeed es \n.. me equivoco?

Muchas muchas muchas gracias.

[edu1989]

Me gustaria hacer una prueba y ver que es lo que recibo con un OK, como podria hacerlo..? Antes te he comentado una posible opcion creo..
seria leer como ahora estoy leyendo el dato y enviarlo yo al puerto serie con una pusts. Seria una manera?

[edu1989]

Acabo de grabarlo al PIC y sigue sin funcionar... nunca ejecuta mas alla del leer_respuesta(buffer1). Estoy "debugando" a partir de los LEDS y se me encienden los dos primeros ( que los hago encender antes de esta sentencia). Despues de esta enciendo otro que ya no va...

La verdad es que no se que hacer...

[AngelGris]

Acabo de grabarlo al PIC y sigue sin funcionar... nunca ejecuta mas alla del leer_respuesta(buffer1). Estoy "debugando" a partir de los LEDS y se me encienden los dos primeros ( que los hago encender antes de esta sentencia). Despues de esta enciendo otro que ya no va...

La verdad es que no se que hacer...

  Según veo en el último programa que subiste, LED0 lo encendes antes de llamar a "leer_palabra" y LED1 lo encendes después, cuando salís de la función "leer_palabra". Por ende el problema podría estar después y no en la función.

[edu1989]

Muchas gracias. Si estuviera despues el Led se encendria o pasaria algo..
Dejo el codigo actual, es parecido al de antes pero he cambiado cosas de los leds.

No se me ocurre que puede pasar... pero con la funcion cgets esta mañana me pasaba lo mismo... a lo mejor no era que estuviera mal hecha sino que hay algo mal a continuacion.. El strcmp no tiene porque fallar.. entonces es que realmente no se q puede suceder

Código: [Seleccionar]


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


 
__CONFIG (1, HS & CPUDIV4 & USBPLL & PLLDIV5 & FCMDIS & IESODIS); // Con 20 CPUDIV1
__CONFIG (2, BORDIS & WDTDIS & PWRTDIS);
__CONFIG (3, MCLRDIS); // estoy deshabilitando el pin de MasterClear, tal vez haya que habilitarlo, eso hay que probarlo
__CONFIG (4, LVPDIS);
 
/* =================================================================================
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      5000000
 
#define CS RB2

/* =================================================================================
Global variables 
  ================================================================================= */


static bit LED0 @ PORTBIT(PORTD, 0);
static bit LED1 @ PORTBIT(PORTD, 1);
static bit LED2 @ PORTBIT(PORTD, 2);
static bit LED3 @ PORTBIT(PORTD, 3);
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;

int error_comando=1;
int error_connexion=1;
int comando_disponible=1; // No hay comando disponible
int final=1;
int prueba=1; // PRUEBA PARA SABER DONDE ESTO
char indice=0;

//CAMBIAR A 6 CON EL DISPOSITIVO
char buffer1[6];  // esto es lo que va para cgets.
char * ComandoRecibido1; // este es el puntero y lo voy a usar para strcmp
char buffer2[6]; 
char * ComandoRecibido2;
char buffer3[6]; 
char * ComandoRecibido3;
char buffer4[6]; 
char * ComandoRecibido4;
char buffer5[6]; 
char * ComandoRecibido5;
char buffer6[6]; 
char * ComandoRecibido6;
char buffer7[6]; 
char * ComandoRecibido7;
char buffer8[6]; 
char * ComandoRecibido8;
char buffer9[100]; 
char * ComandoRecibido9;
char buffer10[100]; 
char * ComandoRecibido10;
char buffer11[100]; 
char * ComandoRecibido11;


/* =================================================================================
Function prototypes
  ================================================================================= */
 
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);
unsigned char getche (void);
void clear_usart_errors(void);
 
unsigned char read_spi (void);
unsigned int read_adc(void);
 
void leer_respuesta(char * palabra);
/* =================================================================================
Main function
  ================================================================================= */
 
void main(void)
{
  valor_potenciometro = 0;
  valor_sensor_temperatura = 0;
  LED0 = 0;
  LED1 = 0;
  LED2 = 0;
  LED3 = 0;
 
  init_system();
  setup_sensor();
  setup_adc();
  serial_setup();
 

 
/* =================================================================================
Establecer connexion con comandos AT
  ================================================================================= */


//Primer comando AT

ComandoRecibido1=buffer1;
LED0=1;
putst ("AT\n");
time_delay(999999999);
LED1=1;


leer_respuesta(ComandoRecibido1);
LED0=0;
LED1=0;
LED2=1;

if (strcmp(ComandoRecibido1,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("AT\n");

leer_respuesta(ComandoRecibido1);

if (strcmp(ComandoRecibido1,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}


//Segundo comando AT

ComandoRecibido2=buffer2;
putst ("ATS0=1\n");
LED0=1;

leer_respuesta(ComandoRecibido2);
LED1=1;

if (strcmp(ComandoRecibido2,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("ATS0=1\n");

leer_respuesta(ComandoRecibido2);

if (strcmp(ComandoRecibido2,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}


//Tercer comando AT

ComandoRecibido3=buffer3;
putst ("ATS512=4\n");
LED0=1;

leer_respuesta(ComandoRecibido3);
LED1=1;

if (strcmp(ComandoRecibido3,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("ATS512=4\n");

leer_respuesta(ComandoRecibido3);

if (strcmp(ComandoRecibido3,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}


//Quarto comando AT

ComandoRecibido4=buffer4;
putst ("ATS502=1\n");
LED0=1;

leer_respuesta(ComandoRecibido4);
LED1=1;

if (strcmp(ComandoRecibido4,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("ATS502=1\n");

leer_respuesta(ComandoRecibido4);

if (strcmp(ComandoRecibido4,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}


//Quinto comando AT

ComandoRecibido5=buffer5;
putst ("ATS536=1\n");
LED0=1;

leer_respuesta(ComandoRecibido5);
LED1=1;

if (strcmp(ComandoRecibido5,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("ATS536=1\n");

leer_respuesta(ComandoRecibido5);

if (strcmp(ComandoRecibido5,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}



//Sexto comando AT

ComandoRecibido6=buffer6;
putst ("AT+BTK=1234\n");
LED0=1;

leer_respuesta(ComandoRecibido6);
LED1=1;

if (strcmp(ComandoRecibido6,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("AT+BTK=1234\n");

leer_respuesta(ComandoRecibido6);

if (strcmp(ComandoRecibido6,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}



//Septimo comando AT

ComandoRecibido7=buffer7;
putst ("AT&W\n");
LED0=1;

leer_respuesta(ComandoRecibido7);
LED1=1;

if (strcmp(ComandoRecibido7,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("AT&W\n");

leer_respuesta(ComandoRecibido7);

if (strcmp(ComandoRecibido7,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}




//Octavo comando AT

ComandoRecibido8=buffer8;
putst ("ATZ\n");
LED0=1;

leer_respuesta(ComandoRecibido8);
LED1=1;

if (strcmp(ComandoRecibido8,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("ATZ\n");

leer_respuesta(ComandoRecibido8);

if (strcmp(ComandoRecibido8,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
LED3=1;

}
}
}
















/*


// El otro dispositivo se quiere connectar con nosotros.

//Mensaje de aparejamiento : PAIR 0 008098E6A5F4 (19 caracteres) + 4 =23
ComandoRecibido9=buffer9;
//cgets(buffer9);
leer_palabra(buffer9,19);

if (strcmp(ComandoRecibido9,"PAIR 0 008098E6A5F4") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putst ("\n");  //cambio de linea

leer_palabra(buffer9,19);
//cgets(buffer9);
if (strcmp(ComandoRecibido9,"PAIR 0 008098E6A5F4") == 0){
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
}
}




// Mensaje de llamada: RING 008098E6A5F4 (17 caracteres) +4 =21
ComandoRecibido10=buffer10; 
//cgets(buffer10);
leer_palabra(buffer10,17);
if (strcmp(ComandoRecibido10,"RING 008098E6A5F4") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putst ("\n");  //cambio de linea

//cgets(buffer10);
leer_palabra(buffer10,17);
if (strcmp(ComandoRecibido10,"RING 008098E6A5F4") == 0){
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
}
}


// Mensaje de connexion establecida CONNECT 008098E6A5F4,1101 A (27 caracteres) + 4
ComandoRecibido11=buffer11; 
//cgets(buffer11);
leer_palabra(buffer11,27);

if (strcmp(ComandoRecibido11,"CONNECT 008098E6A5F4,1101 A") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
else{                                    // No es el comando bueno
    error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putst ("\n");  //cambio de linea

leer_palabra(buffer11,27);
if (strcmp(ComandoRecibido11,"CONNECT 008098E6A5F4,1101 A") == 0){
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
}
}
}
*/



while(1){
   
time_delay(10000000);
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_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();
//time_delay(1000000000);
}

}


 
/* =================================================================================
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 < 200))
                  {
                    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;
                    LED0 = 1;
LED1 = 1;
LED2 = 1;
LED3 = 1;
                    error = 0;
                    }
                    else
                    {
                      present_state = Idle_Low;
                    LED0 = 1;
LED1 = 1;
LED2 = 1;
LED3 = 1;
                    error = 1;
                    }
                  }
                  break;
    case Idle_High:
                   if (TXIF == 0) // Buffer de transmision vacio
                   {
                     present_state = Idle_Low;
                   }
                   else
                  {
                     error = 1; // Ojo, esto antes estaba y estaba funcionando
present_state=Idle_High;
                   }
                   break;
    default:
  error = 1;
  }
  return (error);
}
 
//*****************************************************************************
//Output logic routine
//*****************************************************************************
char output_logic(void)
{
  unsigned char error = 1;
  switch (present_state)
  {
    case Idle_Low:
                    LED0 = 0;
LED1 = 0;
LED2 = 0;
LED3 = 0;

                   error = 0;
                   break;
    case Idle_High:
                   putst ("\n");  //cambio de linea
   putst ("Valor del pot: ");
                   putst (valor_pote_en_texto);
                   putst ("\n");  //cambio de linea
                   putst ("Valor del sensor: ");
                  putst (valor_sensor_en_texto);
                   putst ("\n");
                    LED0 = 1;
LED1 = 1;
LED2 = 1;
LED3 = 1;
                   error = 0;
                   break;
    default:
                   error = 1;
                   

                   break;
  }
  return (error);
}
 
//*****************************************************************************
//Init operations 
//*****************************************************************************
void init_system (void)
{
  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; // SDO. Tots els bits a 1 menys la sortida 7
  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) // TRMT1 is set when TSR is empty // Cuando no es RCIF, cuando no es 1
    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
  CHS3 = 0;
  CHS2 = 0; // Seleccionamos el canal 0 (AN0) que es donde esta conectado el potenciometro
  CHS1 = 0;
  CHS0 = 0;
  //Tiempo de adquisicion
  ACQT2 = 0;
  ACQT1 = 1;  //Por tanto 2x1us =2us >= 1.65us( Tacq calculado teoricamente)
  ACQT0 = 0;
 
  ADCS2 = 1;
  ADCS1 = 0;    // valor que hace que sea superior a 0.7us( el minimo)
  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)
{
  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));
}
 
 
//*****************************************************************************
//FUNCION GETCHE ( SE USA EN LA FUNCION CGETS)
//*****************************************************************************
unsigned char getche (void)
{
    while (RCIF != 1)
    {
   
clear_usart_errors_inline;
       CLRWDT();
    }
    return RCREG;
}

//*****************************************************************************
//FUNCION Leer_palabra
//*****************************************************************************
void leer_respuesta(char * palabra)
{
char indice = 0;
char CaracterLeido;
do
{
CaracterLeido = getch();
if ((CaracterLeido != '\f') && (CaracterLeido != '\r'))
{
*palabra = CaracterLeido;
*palabra++;
}
indice++;
}
while(indice < 6); // Cambiar a 6 para el dispositivo
}


void leer_respuesta_dispositivo(char * palabra)
{
char indice = 0;
char CaracterLeido;
do
{
CaracterLeido = getch();
if ((CaracterLeido != '\f') && (CaracterLeido != '\r'))
{
*palabra = CaracterLeido;
*palabra++;

}
indice++;
}
while(indice < 6); // Cambiar a 6 para el dispositivo
}



[AngelGris]

  Si se queda trabado en la función "leer_palabra" tal vez se deba a que estás esperando a recibir 6 caracteres pero el dispositivo no envía dicha cantidad.
  Se me ocurre que en vez de hacer uso de dicha función, uses varios getch y vayas variando el estado de LEDS cada vez que pasas por un getch, en uno se te va a quedar colgado y según el estado de los LEDS vas a poder saber en cual, por ende vas a saber cuantos caracteres te envió el dispositivo.
  Algo asi...

Código: C

1. LED0 = 0;
2. LED1 = 0;
3. LED2 = 0;
4. LED3 = 0;
5. buffer[0] = getch();
6. LED0 = 1; // pase bien la lectura del primer caracter
7. buffer[1] = getch();
8. LED0 = 0;
9. LED1 = 1; // pase bien la lectura del segundo caracter
10. // y asi hasta llegar a los 6 caracteres a ver que pasa

[edu1989]

Hola de nuevo. Estoy probando eso que me dijiste con este codigo. He visto que entra en la funcion 2 veces por tanto he declarado el buffer y el indice a <2.
Dejo el codigo y sigo con la explicacion:

Código: [Seleccionar]

//Primer comando AT

ComandoRecibido1=buffer1;

putst ("AT\n");
LED0=1;
time_delay(999999999);

leer_respuesta(ComandoRecibido1);
LED1=1;
time_delay(999999999);

/*
LED0=0;
LED1=0;
LED2=0;
LED3=0;
time_delay(999999999);
buffer1[0]=getch();
LED0=1;
time_delay(999999999);
buffer1[1]=getch();
LED1=1;
time_delay(999999999);
buffer1[2]=getch();
LED2=1;
time_delay(999999999);
buffer1[3]=getch();
LED3=1;
time_delay(999999999);
buffer1[4]=getch();
LED0=0;
time_delay(999999999);
buffer1[5]=getch();
LED1=0;
time_delay(999999999);
*/

if (strcmp(ComandoRecibido1,"OK") == 0){ // Todo a ido bien
LED2=1;
error_comando=0;
putst ("respuesta correcta");
putch ('\r');


}
else{                                    // No es el comando bueno
    LED3=1;
error_comando=1;
while(error_comando==1){
putst ("respuesta incorrecta");
putch ('\r');

putst ("AT\n");

leer_respuesta(ComandoRecibido1);
/*
LED0=0;
LED1=0;
LED2=0;
LED3=0;
buffer1[0]=getch();
LED2=1;
buffer1[1]=getch();
LED3=1;
*/
if (strcmp(ComandoRecibido1,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
putch ('\r');


}
}
}

Se me enciende el led0, el led 1 y el led 3. Este led 3 se enciende si hay un error en la comparacion con el caracter. Por tanto ahora el error esta en que no se tiene que comparar con un OK sino con otra cosa... lo que no entiendo es como solo recibe 2 caracteres

Ayuda por favor!

Muchas gracias de antemano.

[edu1989]

Realmente lo que falla es la comparacion con el "OK"
Estoy aquí:

Código: [Seleccionar]

else{                                    // No es el comando bueno
   
time_delay(999999999);
error_comando=1;
time_delay(999999999);
while(error_comando==1){
time_delay(999999999);
putst ("respuesta incorrecta");
putch ('\r');
putst ("AT\n");

leer_respuesta(ComandoRecibido1);

/*
LED0=0;
LED1=0;
LED2=0;
LED3=0;
buffer1[0]=getch();
LED2=1;
buffer1[1]=getch();
LED3=1;
*/
if (strcmp(ComandoRecibido1,"OK") == 0){
LED3=1;
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
}
else
LED3=0;
}
}

Y nunca entre en la ultima parte..

Código: [Seleccionar]

if (strcmp(ComandoRecibido1,"OK") == 0){
LED3=1;
error_comando=0;
putst ("respuesta correcta");
putch ('\r');
}


A ver si pueden ayudarme..

[edu1989]

Por curiosidad he cambiando el comando AT por un pusts("Hola") y sigo recibiendo 2 caracteres.. ahora ya si que es el colmo! no tendria que recibir nada ahora...

Todo ha venido a raiz de que he vuelto a leer que mis comandos van con un retorno de carro y yo los comandos los tenia como pusts("AT\n"). He visto que el retorno de carro era \r y por eso lo he cambiando.

Tambien he probado si el buffer1[0] era alguno de los caracteres ( "O","K", "\f","\n","\r")... y nada..
Ya no me explico nada... de verdad que ya no se que probar..

[edu1989]

Ya se donde falla el programa. Cuando envio el AT!!. La explicacion al post anterior es que cuando recibe un comando erroneo devuelve "ERROR 05", por eso devolvia caracteres.

Estoy probando desde el puerto serie del PIC al hyperterminal enviando distintos comandos y recibo esto:

Enviando AT\r    41 54 0D 0A
Enviando AT\f    41 54 0C
Enviando AT\n  41 54 0A 0D

Por lo tanto ahi estara el error. Lo que no entiendo es que en el primer caso por ejemplo.. envie solo retorno de carro y se le "sume" 0A que es lo de linefeed...

[AngelGris]

Ya se donde falla el programa. Cuando envio el AT!!. La explicacion al post anterior es que cuando recibe un comando erroneo devuelve "ERROR 05", por eso devolvia caracteres.

Estoy probando desde el puerto serie del PIC al hyperterminal enviando distintos comandos y recibo esto:

Enviando AT\r    41 54 0D 0A
Enviando AT\f    41 54 0C
Enviando AT\n  41 54 0A 0D

Por lo tanto ahi estara el error. Lo que no entiendo es que en el primer caso por ejemplo.. envie solo retorno de carro y se le "sume" 0A que es lo de linefeed...

  Eso se debe a como es la implementación de la función putst(); Fijate....

Código: C

1. //*****************************************************************************
2. // Enviar datos (un buffer)
3. //*****************************************************************************
4. void putst(register const char *str)
5. {
6.   while ((*str) != 0)
7.   {
8.     putch (*str);
9.    if (*str == 13) putch (10);
10.     if (*str == 10) putch (13);
11.     str++;
12.   }
13. }

  Supongamos que yo hago putst("Hola\n");
  Entonces mi función va a enviar cada caracter con la línea que dice "putch (*str)". Pero fijate que también hay un par de if, por lo tanto si el caracter enviado era el 10 también agrega el caracter 13 y si el caracter enviado era el 13 agrega el 10.

  Quizá habría que sacar esos dos if de la implementación de putst().

  Y En tu programa probá de enviar los comandos de la siguiente manera...

Código: C

1. putst ("ATS=0");
2. putch ('\r');

  Digo de ponerlo así porque en uno de los mensajes donde detallabas como respondía el dispositivo también agregabas...

"All commands are terminated by the carriage return character 0x0d, which is represented by the string <cr> in descriptions below this cannot be changed"

  y justamente el caracter '\r' toma el valor 0x0d.

[edu1989]

Ya esta si, me he imagino que era eso y ya lo habia cambiado. Ahora voy a mirar bien los caracteres que recibo bien con el "OK" y te cuento.

Gracias de todas formas

[edu1989]

Ahora mismo no me entra en la funcion leer_palabra.. lo tengo declarado en 6..
Es posible que falle algo de la funcion o sera el buffer..?