Error al comparar dos strings con strcmp

[edu1989]

He encontrado una definicion para leer una cadena de longitud fija. No hay la funcion implementada pero si los parametros que se le pasan.

Código: [Seleccionar]

void getsUSART(unsigned char * buffer,unsigned char length );


Código: [Seleccionar]

Return Value: None
Remarks: This function only works in 8-bit transmit/receive mode. This function waits
for and reads len number of characters out of the specified USART. There is
no time out when waiting for characters to arrive. getsUSART should be used
on parts with a single USART peripheral. gets1USART and gets2USART
should be used on parts with multiple USART peripherals.

Filename: ugets.c
Code Example: char string[10];
getsUSART(string, 5);

Voy a mirar si funciona...

[AngelGris]

  En el caso del programa que mostraste en el mensaje anterior (en el que hacés uso de cgets) dicha función te da error porque le estás pasando un puntero como parámetro. Si mirás el ejemplo que mostraste primero (sacado el manual de HiTech) hay que pasarle un arrary a caracteres.

  Osea que tendrías que hacer algo como lo que había hecho yo.... básicamente sería...

Código: C

1. char buffer[10];  // esto es lo que va para cgets
2. char * ComandoRecibido; // este es el puntero y lo voy a usar para strcmp
3.  
4. ComandoRecibido = buffer; // el puntero apunta al valor almacenado por buffer
5.  
6. cgets (buffer);
7.  
8. strcmp (ComandoRecibido, "OK");

[edu1989]

Gracias de nuevo. He hecho esto y sigue sin funcionar: Pongo la parte de declaracion de las variables tambien:
Me dice que la variable comandorecibido esta dos veces declarada si apunto la variable al buffer. Para probar el proyecto podria usar el VTERM no? mirar si recibo un comando at y contestarle yo mismo el "OK" no? Cuando salga para un comando ya solo es cambiarlo para los otros. Pongo el codigo:

Código: [Seleccionar]


#include <htc.h>
#include <stdlib.h>  // para poder usar la funcion itoa
#include <conio.h>
#include <string.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;

char buffer[10];  // esto es lo que va para cgets
char * ComandoRecibido; // este es el puntero y lo voy a usar para strcmp
char resultado;
//ComandoRecibido = buffer;

/* =================================================================================
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);
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;
  LED0 = 0;
  LED1 = 0;
  LED2 = 0;
  LED3 = 0;
 ComandoRecibido = buffer;

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


//Primer comando AT

putst ("AT/n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);

resultado = strcmp (ComandoRecibido, "OK");
if(resultado==0){ // Iguales
error_comando=0;

}
else
    error_comando=1;
}
}


[AngelGris]

  Hice la prueba de compilar un programita (para pic16f876a) con la función cgets() y me salió el siguiente error "Error[499] 0 : undefined symbol: _getche(PruebaCadenas.obj)".

  Por lo que entiendo, la función cgets hace uso de getche() pero ésta otra función no está implementada por el compilador sino que la tendría que hacer uno mismo.

  De hecho, lo mismo me ocurrió cuando quise hacer uso de cputs() (que es una función que tiene el compilador). Ésta función hace uso de putch, pero si yo no incluía mi propia función putch me daba el mismo error.

  Voy a probar de implementar una función y llamar getche a ver que pasa.

[edu1989]

Si, a mi tambien me salia este error. Yo voy a probar de usar la otra funcion o a ver si encuentro alguna otra.

[AngelGris]

  Hice la prueba de implementar una función llamada getche y funcionó bien simulándolo en Proteus. Use el VirtualTerminal para ser yo quien genere la supuesta respuesta del dispositivo

  Así quedó definida la función...

Código: C

1. unsigned char getche (void)
2.   {
3.     while (RCIF != 1)
4.     {
5.        clear_error;
6.        CLRWDT();
7.     }
8.     return RCREG;
9.   }

  Este es el programita de prueba que use en un PIC16F876A

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"  // estas son unas definiciones que hice para el manejo del PIC
10.  
11. #define PIC_CLK 10000000
12. #define BAUD 9600
13. #define BRGH_VALUE 1
14.  
15. #include "HardUart16.c"  // mis rutina de comunicacion RS232
16.  
17.  
18. void main(void)
19. {
20.   char entrada[10];
21.   char * ComandoRecibido;
22.  
23.   TRISC = 255;
24.   InitHardUart (TRANSMIT | RECEIVE);
25.   ComandoRecibido = entrada;  
26.   while (1)
27.   {
28.     putst ("ATS=0\n");
29.     cgets (entrada);
30.     if (strcmp(ComandoRecibido,"OK") == 0) putst ("Respuesta correcta");
31.     else
32.       putst ("Respuesta incorrecta");
33.     putch ('\r');
34.   }
35. }

  Te adjunto una captura de pantalla en donde se ve que a un ok en minúscula responde en forma incorrecta y a un OK en mayúscula responde en forma correcta.

[edu1989]

Muchas gracias

Una pregunta, la variable clear_error que pinta en la funcion? no esta declarada ni es ninguna funcion porque no tiene los "()". He mirado en mi codigo y habia una funcion igual a esta getche que se llama getch. Sigue sin funcionarme.. lo del clear_error lo he sustituido por el equivalente en mi programa cleart_usart_errors_inline. Lo que me extraña es que no reciba ni el "AT" correspondiente ni se enciendan los leds..

Seguire investigando, dejo el codigo:

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;

char buffer[10];  // esto es lo que va para cgets
char * ComandoRecibido; // este es el puntero y lo voy a usar para strcmp
char resultado;


/* =================================================================================
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);
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;
  LED0 = 0;
  LED1 = 0;
  LED2 = 0;
  LED3 = 0;
 ComandoRecibido = buffer;

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



//Primer comando AT

putst ("AT\n");
LED0=1;
LED1=1;

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}


/*

//Segundo comando AT
if (error_comando==0)
{

error_comando=1;
putst ("ATS0=1\n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}


//Tercer comando AT
if (error_comando==0)
{
error_comando=1;
putst ("ATS512=4\n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}


//Quarto comando AT
if (error_comando==0)
{
error_comando=1;
putst ("ATS502=1/n");
LED0=1;
LED1=1;
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}



//Quinto comando AT
if (error_comando==0)
{
error_comando=1;
putst ("ATS536=1/n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}


//Sexto comando AT
if (error_comando==0)
{
error_comando=1;
putst ("AT+BTK=1234/n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}

//Septimo comando AT
if (error_comando==0)
{
error_comando=1;
putst ("AT&W/n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}



//Octavo comando AT
if (error_comando==0)
{
error_comando=1;
putst ("ATZ/n");
LED0=1;
LED1=1;

//Comprovar que reciba  "OK"
 while (getch_available() != false){ // Este while hay que ponerlo? Puede ser que haya un pequeño tiempo donde aun no haya recibido el caracer?

if(getch_available()==true)
{
LED0=0;
LED1=0;
LED2=1;
LED3=1;

cgets(buffer);
if (strcmp(ComandoRecibido,"OK") == 0)
error_comando=0;
else
    error_comando=1;
}
}


*/







 


 


 


 








/*
// El otro dispositivo se quiere connectar con nosotros
 
// Mensaje de aparejamiento : PAIR 0 008098E6A5F4 (19 caracteres)
 
if((getch_available()==true)&&(error_comando==0))
{   
   cgets(Palabra1_real);
  resultado = strcmp (Palabra1_ideal, Palabra1_real);
  if(resultado==0)
error_comando=0;
  else
    error_comando=1;
 
}
}

// Mensaje de llamada: RING 008098E6A5F4 (17 caracteres)

if((getch_available()==true)&&(error_comando==0))
{   
   cgets(Palabra2_real);
  resultado = strcmp (Palabra2_ideal, Palabra2_real);
  if(resultado==0)
error_comando=0;
  else
    error_comando=1;
 
}
}

// Mensaje de connexion: CONNECT 008098E6A5F4,1101 A  (27 caracteres)

if((getch_available()==true)&&(error_comando==0))
{   
   cgets(Palabra3_real);
  resultado = strcmp (Palabra3_ideal, Palabra3_real);
  if(resultado==0)
error_comando=0;
  else
    error_comando=1;
 
}
}





*/








  init_system();
  setup_sensor();
  setup_adc();
  serial_setup();
 
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_error;
clear_usart_errors_inline;
       CLRWDT();
    }
    return RCREG;
}


 





Muchas gracias de antemano

[AngelGris]

  Yo hice la función getche idéntica a mi rutina getch. Ese "clear_error" es para borrar los bits OERR y FERR.
  No veo que inicialices el uart.

[edu1989]

Hay que volver a inicializar el uart? Antes de hacer ese cambio ya estaba inicializado con la funcion serial_setup y en la funcion de inicializacion habia el TRISC correspondiente.
Ya me diras algo

Muchas gracias.

[AngelGris]

Hay que volver a inicializar el uart? Antes de hacer ese cambio ya estaba inicializado con la funcion serial_setup y en la funcion de inicializacion habia el TRISC correspondiente.
Ya me diras algo

Muchas gracias.

  Había mirado mal, si llamás a serial_setup(); pero tenés que llamar a dicha función antes de querer usar los comando AT y todo eso. Vos estás llamándola después.

   Recordá que con los dispositivos te estás comunicando vía RS232, así que entes de hacer uso de cualquier función que trabaje con dicho puerto y/o periférico, hay que inicializarlo en el PIC.

[edu1989]

Muchas gracias. Que fallo tan tonto..

Ahora mismo ya me funciona todo. Hasta los tres ultimos mensajes ( el PAIR 0.., RING.. y CONNECT). Mñana probrare en el PIC pero esta vez dudo que no funcione a la primera. Me da buena espina.
Cuando lo tenga funcionando en el PIC colgare el codigo.

En fin, muchas gracias Angel. Mañana sigo informandote de la situacion

[edu1989]

Hola de nuevo, estoy probando esto y no funciona. He estado probando con LEDS para saber donde esta el error y esta en la linea:
cgets(buffer1). Creo que lo hacemos mal porque con esta funcion leemos las respuestas del modulo Bluetooth y como bien dije en un post anterior

"Todas las respuestas van con retorno de carro y caracteres de salto de linea ANTES  y DESPUES  de la respuesta"

All responses from ezurio device have carriage return and linefeed characters preceding and appending the response. These dual character sequences have the values 0x0D and 0x0A respectively and shall be represented by the string <cr,if>

Pongo el codigo:

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 ESTOY.

char buffer1[10];  // esto es lo que va para cgets
char * ComandoRecibido1; // este es el puntero y lo voy a usar para strcmp
char buffer2[10]; 
char * ComandoRecibido2;
char buffer3[10]; 
char * ComandoRecibido3;
char buffer4[10]; 
char * ComandoRecibido4;
char buffer5[10]; 
char * ComandoRecibido5;
char buffer6[10]; 
char * ComandoRecibido6;
char buffer7[10]; 
char * ComandoRecibido7;
char buffer8[10]; 
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);
 
/* =================================================================================
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;
putst ("AT\n");
LED0=0;
//if(getch_available()==true){

if(prueba==1) // Prueba para saber si llega hasta aqui.
LED1=1;
else
LED2=1;


cgets(buffer1);
LED1=1;

if (strcmp(ComandoRecibido1,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0=0;
LED1=0;
LED2=0;
LED3=0;
putst ("AT\n");
cgets(buffer1);
if (strcmp(ComandoRecibido1,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}




//Segundo comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido2=buffer2;
putst ("ATS0=1\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer2);

if (strcmp(ComandoRecibido2,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("ATS0=1\n");
cgets(buffer2);
if (strcmp(ComandoRecibido2,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}


//Tercer comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido3=buffer3;
putst ("ATS512=4\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer3);

if (strcmp(ComandoRecibido3,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("ATS512=4\n");
cgets(buffer3);
if (strcmp(ComandoRecibido3,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}


//Quarto comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido4=buffer4;
putst ("ATS502=1\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer4);

if (strcmp(ComandoRecibido4,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("ATS502=1\n");
cgets(buffer4);
if (strcmp(ComandoRecibido4,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}


//Quinto comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido5=buffer5;
putst ("ATS536=1\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer5);

if (strcmp(ComandoRecibido5,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("ATS536=1\n");
cgets(buffer5);
if (strcmp(ComandoRecibido5,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}


//Sexto comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido6=buffer6;
putst ("AT+BTK=1234\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer6);

if (strcmp(ComandoRecibido6,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("AT+BTK=1234\n");
cgets(buffer6);
if (strcmp(ComandoRecibido6,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}



//Septimo comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido7=buffer7;
putst ("AT&W\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer7);

if (strcmp(ComandoRecibido7,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("AT&W\n");
cgets(buffer7);
if (strcmp(ComandoRecibido7,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}


//Octavo comando AT
LED0=0;
LED1=0;
LED2=0;
LED3=0;
ComandoRecibido8=buffer8;
putst ("ATZ\n");
LED0=1;
//if(getch_available()==true)

cgets(buffer8);

if (strcmp(ComandoRecibido8,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
LED0=1;
LED1=1;
LED2=1;
LED3=1;
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
LED0 = 0;
  LED1 = 0;
  LED2 = 0;
LED3 = 0;
putst ("ATZ\n");
cgets(buffer8);
if (strcmp(ComandoRecibido8,"OK") == 0){
error_comando=0;
putst ("respuesta correcta");
LED3=1;
putst ("\n");  //cambio de linea
}
}
}







// El otro dispositivo se quiere connectar con nosotros.

//Mensaje de aparejamiento : PAIR 0 008098E6A5F4 (19 caracteres)
ComandoRecibido9=buffer9;
cgets(buffer9);

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

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)
ComandoRecibido10=buffer10; 
cgets(buffer10);

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);
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
ComandoRecibido11=buffer11; 
cgets(buffer11);

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

cgets(buffer11);
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;
}


 





Voy a seguir mirando.. ayudenme por favor

[edu1989]

Da la sensacion como si no entrara dentro de buffer1. Que puede succeder para que no entre en dicha funcion? Tendria que entrar almenos.. si lee el caracter bien o mal ya es otra cosa pero entrar creo que deberia.

Es como si no la terminara y estuviera dentro suyo. He leido que la funcion se acaba cuando encuentra una combinacion de retorno de carro y salto de linea ( como en nuestro caso) o cuando el tamaño del buffer termina. Puede ser un programa de longitud del buffeR? no creo.. porque esta declarado como buffer1[10]

P.D: Me gustaria ver los carácteres que recibo.. de esta forma podria detectar donde esta el error.

Muchas gracias de antemano.

[AngelGris]

  Para poder ver los caracteres que recibís se puede hacer lo siguiente. Creas tu propia función para recibir las respuestas, pero haciendo uso de llamadas sucesivas a getch, en teoría deberían ser 6 llamadas, y almacenás todo eso en una variable. Luego basta con visualizar los datos almacenados en dicha variable y ya sabés como es que te responde el módulo.

[edu1989]

En principio cual crees que podria ser el error?
Ahora miro de crear una funcion.. Esta funcion tiene que hacer 6 llamadas a la getchar y almacenar cada caracter en una variable no? tendre que ir cogiendo cada caracter del buffer no?

Edito: tambien podria hacer un while no?

Edito1: El problema esta en que el programa no avanza de la sentencia cgets.. entonces no podre leerlo..
Es eso lo que me extraña, que no siga aunque lo haga mal