Error al comparar dos strings con strcmp

[edu1989]

En el caso que solucionasemos el tema de que el programa se queda parado en esa sentencia..
Podria hacer algo asi..

char c;
while((c = getche()) != ’\n’)
continue;

Con eso bastaria? Despues imagino que habria que usar la pusts..

[AngelGris]

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?

  No tengo idea cual pueda ser el error.
  No es necesario que almacene cada caracter en una variable distinta, podés declararla así "char arreglo[10]" y cada caracter que vas leyendo lo almacenás en arreglo[indice];

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

  Sí, sería conveniente usar un while para la función.
  No importa lo que está sucediendo con cgets ya que no se utilizaría más dicha función sino que vas a usar la tuya propia.

  Básicamente la función sería algo así...

Código: C

1. {
2.   char indice = 0;
3.   do
4.   {
5.     arreglo[indice] = getch();
6.     indice++;
7.   }
8.   while (indice < 6);
9. }

[edu1989]

Perdon,me he equivocado en una cosa. Ahora ya sale bien.
Pongo ese codigo como una funcion y llamo a la funcion o lo dejo asi?

Código: [Seleccionar]

//Primer comando AT

ComandoRecibido1=buffer1;
putst ("AT\n");
LED0=0;

do
{
buffer1[indice]=getch();
indice++;
}
while(indice < 6);


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


[edu1989]

He solucionado el error haciendo un return 0 pero ahora no funciona... Creo que debo retornar el buffer porque sino cuando pongo el caracter "O" antes de que ponga el otro caracter me da error.  Hago el return del buffer? ( ahora es como si solo leyera un caracter).

En la funcion he puesto indice <2 ya que tiene que leer el OK. Mirate a vr si esta bien... imagino que debo dejar algun espacio mas para el retorno de carro y el salto de linea..

dejo el codigo entero.

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;

char buffer1[100];  // 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);
 
unsigned leer_palabra(char * buffer);
/* =================================================================================
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;

leer_palabra(buffer1);
//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");
leer_palabra(buffer1);
//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;
}

unsigned leer_palabra(char * buffer)
{
do
{
buffer[indice]=getch();
indice++;
}
while(indice < 2);
return 0;
}





[AngelGris]

..........

Código: [Seleccionar]


..........

unsigned leer_palabra(char * buffer)
{
do
{
buffer[indice]=getch();
indice++;
}
while(indice < 2);
return 0;
}


  El problema con hacer "while (indice < 2)" es que sólo va a tomar los dos primeros caracteres. Como vos bien dijeste, el módulo responde precediendo "CarrierReturn" y "LineFed" que son dos caracteres con lo cual ya saldrías de la función y sin almacenar la respuesta que te interesa.

  En todo caso se podría modificar la función para que evalue (con un if) si el caracter leído es distinto a "CarrierReturn" y distinto a "LineFed" y recién en ese caso almacenarlo en la variable.

[edu1989]

Ahora mismo lo estaba probando tal y como has puesto. Sigue sin funcionar.. te dejo el codigo, a lo mejor es una tonteria pero no se que pasa.

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;

char buffer1[100];  // 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);
 
unsigned leer_palabra(char * buffer);
/* =================================================================================
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;

leer_palabra(buffer1);

LED1=1;


if (strcmp(ComandoRecibido1,"OK") == 0){ // Todo a ido bien
error_comando=0;
putst ("respuesta correcta");
putst ("\n");  //cambio de linea
LED0=1;
LED1=1;
LED2=1;
LED3=1;

}
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");
leer_palabra(buffer1);
//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;
}

unsigned leer_palabra(char * buffer)
{
do
{
buffer[indice]=getch();
indice++;
}
while(indice < 10);
return 0;
}




[edu1989]

Ahora lo que pasa es que no detecta el final de la palabra. Tengo que acabar con un retorno de salto y un salto de linea.

Lo que pasa ahora es:
me pone el AT
contesto ok ( y no pone nada porque no ha llegado a los 10 caracteres)
contesto ok
.
.
.

Hasta que pone incorrecto.

[AngelGris]

  Claro! porque hiciste "while (indice < 10)" entonces te quedás a la espera que el dispositivo te mande sí o sí 10 caracteres y es un error.

[edu1989]

Si este while es de 2, 3,4 tambien falla.. ese es el problema..

[AngelGris]

  Fijate que en una de mis respuesta sugerí que había que utilizar un if para determinar si el caracter que llegaba era distinto de "retorno de carro" y distinto de "salto de linea" recién entonces almacenarlo en la variable.

  Seguramente otra de las cosas que está pasando es que, como se almacena todo en la variable (incluyendo los saltos de linea y retorno de carro), por ello falla la comparación. Osea, el valor que toma la variable es algo así "\r\fOK\r\f"

[edu1989]

Si porque si pongo:
if (strcmp(ComandoRecibido1,"OK") == 0){ // Todo a ido bien

Y pongo un buffer de 2 y en la funcion el indice < 2 me pone al lado respuesta correcta pero si lo pongo de 3 me pone respuesta incorrecta ( porque coge alguno de estos caracteres raros).

Que propones? hacer hasta que se encuentre un retorno de carro?

Como son el retorno de carro y el salto de linea: El retorno de carro es \n no? es que veo tu \r y \f en el anterior post...

[edu1989]

Si pongo el buffer y el indice a 3 y en el terminal pongo OK + enter
En la condicion pongo OK\r y funciona!!

Lo que no funciona es que si fallo y pongo ok por ejemplo, pone respuesta incorrecta y solo me deja poner un caracter... sabes que puede ser?

Muchas gracias por la ayuda amigo. Te dejo q me contestes estas preguntas que sino voy demasiado rapido jej
Gracias

[edu1989]

Creo que sera mas facil que nos centremos con la funcion cgets. Podemos seguir con esto para ver lo que se recibe.
En teoria dices que se recibe algo como "\r\fOK\r\f" entonces que tendria que poner el la condicion del strcmp?

Es que no se por donde tirar la verdad... se esta complicando una cosa que pensaba que ya tenia..

[AngelGris]

Código: [Seleccionar]

All responses from the 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,lf>.


  Sito un mensaje tuyo en el cual queda bien claro cuales son los valores que representan el "Salto de linea" y el "Retorno de carro". Esto por un lado.

Si pongo el buffer y el indice a 3 y en el terminal pongo OK + enter
En la condicion pongo OK\r y funciona!!

Lo que no funciona es que si fallo y pongo ok por ejemplo, pone respuesta incorrecta y solo me deja poner un caracter... sabes que puede ser?

Muchas gracias por la ayuda amigo. Te dejo q me contestes estas preguntas que sino voy demasiado rapido jej
Gracias

  Me imagino que ya sólo te deja meter un caracter porque como la variable "indice" la tenés definida como global, sigue manteniendo el valor con el que se quedó anteriormente. Por lo tanto, en tu función "leer_palabra" y antes del ciclo do-while deberías poner "indice = 0".

  En el caso de la simulación con proteus o el uso de algún terminal (emulando el módulo) está bien que el while evalúe un índice < 3 -Por que en el terminal typeas O K Enter que son tres caracteres- pero tu dispositivo te envía 6 caracteres y estos serían 0x0D 0x0A O K 0x0D 0x0A

[edu1989]

Gracias de nuevo. He puesto el indice a 0 y ahora voy enviando los comandos y poniendo a OK. Cuando llego al 4arto le doy a OK y me pone respuesta incorrecta. Mi sorpresa ha sido cuando he comentado los anteriores y he hecho como si solo estuviera este y ha funcionado.. Creo que se le mete algun caracter raro entre medias..

Que puede ser?

Creo que la otra funcion es mejor que esta.. esta creo que petara mas de una vez.. Depende mucho del valor exacto del buffer.. sino ya falla.
Dejo el codigo por si puede servir de algo:

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[3];  // esto es lo que va para cgets.
char * ComandoRecibido1; // este es el puntero y lo voy a usar para strcmp
char buffer2[3]; 
char * ComandoRecibido2;
char buffer3[3]; 
char * ComandoRecibido3;
char buffer4[3]; 
char * ComandoRecibido4;
char buffer5[3]; 
char * ComandoRecibido5;
char buffer6[3]; 
char * ComandoRecibido6;
char buffer7[3]; 
char * ComandoRecibido7;
char buffer8[3]; 
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);
 
unsigned leer_palabra(char * buffer);
/* =================================================================================
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=1;

leer_palabra(buffer1);

LED1=1;


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

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





//Segundo comando AT

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

leer_palabra(buffer2);

LED1=1;


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

}
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");
leer_palabra(buffer2);
//cgets(buffer1);
if (strcmp(ComandoRecibido2,"OK\r") == 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);
leer_palabra(buffer3);
if (strcmp(ComandoRecibido3,"OK\r") == 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);
leer_palabra(buffer3);
if (strcmp(ComandoRecibido3,"OK\r") == 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(buffer3);
leer_palabra(buffer4);
if (strcmp(ComandoRecibido4,"OK\r") == 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(buffer3);
leer_palabra(buffer4);
if (strcmp(ComandoRecibido4,"OK\r") == 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);
leer_palabra(buffer5);
if (strcmp(ComandoRecibido5,"OK\r") == 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);
leer_palabra(buffer5);
if (strcmp(ComandoRecibido5,"OK\r") == 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)

leer_palabra(buffer6);
//cgets(buffer6);

if (strcmp(ComandoRecibido6,"OK\r") == 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);
leer_palabra(buffer6);
if (strcmp(ComandoRecibido6,"OK\r") == 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);
leer_palabra(buffer7);

if (strcmp(ComandoRecibido7,"OK\r") == 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);
leer_palabra(buffer7);
if (strcmp(ComandoRecibido7,"OK\r") == 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)
leer_palabra(buffer8);
//cgets(buffer8);

if (strcmp(ComandoRecibido8,"OK\r") == 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);
leer_palabra(buffer8);
if (strcmp(ComandoRecibido8,"OK\r") == 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+4)
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;
}

unsigned leer_palabra(char * buffer)
{
indice = 0;
do
{
buffer[indice]=getch();
indice++;
}
while(indice < 3); // Cambiar a 6 para el dispositivo
return 0;
}