enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)

[japifer_22]

Hola, bueno el titulo del hilo lo explica todo.
Resulta que estoy trabajando con 2 dispositivos xbee. Donde en los dos les tengo un pic. y los estoy programando en ccs c.
El punto es que uno de mis pic está tomando señales análogas, y bueno quiero enviarla al otro pic por medio de los xbee , los datos que toma el pic de las señales análogas, son de 10bit, lo tengo que separar este dato en 2 para poder enviarlos al otro pic. asta aquí no tengo problema, ya que lo estoy asiendo con la función make8 y anda bien. Pero el punto es que no se cómo hacerlo para volver a unir estos datos, ya que los datos enviados los trabaja con mi programa de recepción de datos y esto lo deja en un string, en formato char. Es por esto que acudo a ustedes para ver si sabrán de alguna forma de poder volver a convertir este estos 2 datos de 8bit a uno solo de 10bit, y poder visualizarlo en una lcd.
Espero que me puedan ayudar en esto.

Saludos que estén bien.

PD:{he tratado de volver a unir estos datos con la función make16, pero tampoco me da resultado}

[AngelGris]

  En ansi C existe la función ATOI (AsciiToInteger), con eso convertirías cada uno de los string en un valor entero. Luego podrías emplear make16 para generar el valor completo, sino otra forma de hacer lo mismo es haciendo lo siguiente

  la variable que tiene almacenado lo que sería el byte alto de tu valor original, la multiplicas por 256, y luego le sumas la variable que tiene almacenado lo que sería el byte bajo.

Código: C

1. char ByteAltoTexto, ByteBajoTexto;
2. int ByteAlto, ByteBajo, ValorTotal;
3.  
4. ByteAltoTexto = getc(); // lee el valor desde RS232
5. ByteBajoTexto = getc(); // lee el valor desde RS232
6.  
7. ByteAlto = atoi (ByteAltoTexto);
8. ByteBajo = atoi (ByteBajoTexto);
9.  
10. ValorTotal = ByteAlto * 256 + ByteBajo;

  Los tipos de variables del ejemplo son de HiTech, el tipo char es de 8 bits y el int de 16. No se si será funcional el ejemplo en CCS, pero creo que se entiende mejor la idea con el ejemplo que con solo el texto 

[japifer_22]

hola angelgris, te comento que he intendato lo que du dices pero no resulta, osea por lo menos ami 

Código: [Seleccionar]

if(transformar_dato==2){
corriente1=atoi(comando_radio);
}
else if(transformar_dato==4){
corriente2=atoi(comando_radio);
}
else if(transformar_dato==6){
corriente=make16(corriente2,corriente1);
transformar_dato=0;
}


[japifer_22]

mmm interesante parece que es de seguro que soy yo, o es la hora, pero el punto es que lo que dices de sumar los valores tampoco resulta.

dejo el codigo para ver si me puedes desir que estoy haciendo mal.

y gracias por lo ya ayudado:

Código: [Seleccionar]


////////////////////////////////////////////////////////////////////////////////
/************************VARIABLES GLOVALES************************************/
////////////////////////////////////////////////////////////////////////////////
char lectura_radio=0x00;
char cadena_radio[30];
char comando_radio[30];
int identificadorIP=0;
int incremento_radio=0x00;
int1 procesar_radio=0;

char encendido1[]="encendido";
char apagado1[]="apagado";
char enviado1[]="enviado";

int x=0;
int menu=1,menu_rele=1,menu_voltaje=1,menu_corriente=1;
int a=4,b=4;
int1 ingreso_rele=0,ingreso_corriente=0;
int transmicion_erronea=0;
int transformar_dato;
float corriente;
int8 corriente1,corriente2;

/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/****************FUNCIONES DE MANEJO DE RECEPCION DE DATOS*********************/
////////////////////////////////////////////////////////////////////////////////

void proceso_radio(char a);
void borrar_cadena_radio(void);
void copia_cadena_radio(void);

/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////
void control_reles(void);
void sensor_de_voltaje(void);
void sensor_de_corriente(void);

////////////////////////////////////////////////////////////////////////////////
/********************INTERRUPCION DE RECEPCION SERIAL**************************/
////////////////////////////////////////////////////////////////////////////////

#int_RDA   //interrupcion para la resepcion del master
void rda_isr()
{
lectura_radio=0x00;

 if(kbhit()) {   //Esto es para que no se cuelgue el pic
             lectura_radio=GETC();  //guarda el valor enviado por el puerto serie
             proceso_radio(lectura_radio);
             }
}

/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/**************ALMACENAMIENTO DE DATO PROVENIENTES DEL RS232*******************/
////////////////////////////////////////////////////////////////////////////////

void proceso_radio (char a){
if(a==0x0D){
 procesar_radio=1;
}
else{
cadena_radio[incremento_radio++]=a;
}
}

/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/*****************************PROGRAMA PRINCIPAL*******************************/
////////////////////////////////////////////////////////////////////////////////

void main(){
  lcd_init();         //inicializa, o activa lcd
   setup_adc_ports(NO_ANALOGS);
   setup_adc(ADC_OFF);
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_1);
   setup_timer_1(T1_DISABLED);
   setup_timer_2(T2_DISABLED,0,1);
   setup_comparator(NC_NC_NC_NC);
   setup_vref(FALSE);
   enable_interrupts(INT_RDA);     //interrupcion INT_RDA activada. comunicacion RS-485
   enable_interrupts(GLOBAL);      //todas las interrupciones activadas

lcd_gotoxy(1,1);
printf(lcd_putc,"********************");
lcd_gotoxy(1,2);
printf(lcd_putc,"**control de corriente**");
lcd_gotoxy(1,4);
printf(lcd_putc,"********************");
delay_ms(2000);
printf(lcd_putc,"\f");


while(TRUE){
lcd_gotoxy(1,1);
printf(lcd_putc,"   MENU PRINCIPAL   ");

/*if(procesar_radio==1){
copia_cadena_radio();
}*/

if(!input(PIN_C0)){
                   do{
                   }while(!input(PIN_C0));
                   menu--;
                   if(menu<1){menu=3;
                    }
                   }
                  
if(!input(PIN_C1)){
                   do{
                   }while(!input(PIN_C1));
                   menu++;
                   if(menu>3){menu=1;
                    }
                   }
if(menu==1){
            lcd_gotoxy(1,3);
            printf(lcd_putc,"CONTROL DE RELES    ");
            if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));                                    
            control_reles();
            }
}
else if(menu==2){
            lcd_gotoxy(1,3);
            printf(lcd_putc,"SENSORES DE VOLTAJE ");
            if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));            
            sensor_de_voltaje();
            }
}
else if(menu==3){
            lcd_gotoxy(1,3);
            printf(lcd_putc,"SENSORES DE CORRIENT");
            if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));            
            sensor_de_corriente();
            }
}

}}

/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/***********************FUNCION DE CONTROL DE RELES****************************/
////////////////////////////////////////////////////////////////////////////////
void control_reles(void){
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc,"  MENU DE CONTROL   ");
lcd_gotoxy(1,2);
printf(lcd_putc,"     DE RELES       ");
while(true){

if(procesar_radio==1){
copia_cadena_radio();
}

if (strcmp (comando_radio,encendido1) == 0 && ingreso_rele==1){
    lcd_gotoxy(1,4);
    printf(lcd_putc,"Rele %i encendido",menu_rele);
    a=4;
    ingreso_rele=0;
    comando_radio[1]=1;
    delay_ms(1500);
    printf(lcd_putc,"\f");
    lcd_gotoxy(1,1);
    printf(lcd_putc,"  MENU DE CONTROL   ");
    lcd_gotoxy(1,2);
    printf(lcd_putc,"     DE RELES       ");
}
else if (strcmp (comando_radio,apagado1) == 0 && ingreso_rele==1){
    lcd_gotoxy(1,4);
    printf(lcd_putc,"Rele %i apagado",menu_rele);
    a=4;
    ingreso_rele=0;
    comando_radio[1]=1;
    delay_ms(1500);
    printf(lcd_putc,"\f");
    lcd_gotoxy(1,1);
    printf(lcd_putc,"  MENU DE CONTROL   ");
    lcd_gotoxy(1,2);
    printf(lcd_putc,"     DE RELES       ");
}

if(!input(PIN_C0)){
                   do{
                   }while(!input(PIN_C0));  
                   if(ingreso_rele==0){
                   menu_rele--;
                   if(menu_rele<1){menu_rele=8;
                   }
                   }
                   else if(ingreso_rele==1){
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"Enviando solisitud  ");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"                    ");                  
                   printf("1.2.3.4.5.6");
                   putc(0X0D);
                   delay_ms(20);
                   printf("rele%i on",menu_rele);
                   putc(0X0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   putc(0X0D);
                   delay_ms(20);
                   printf("rele%i on",menu_rele);
                   putc(0X0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   putc(0X0D);
                   delay_ms(20);
                   printf("rele%i on",menu_rele);
                   putc(0X0D);                                    
                   }
                   }
                  
if(!input(PIN_C1)){
                   do{
                   }while(!input(PIN_C1));
                   if(ingreso_rele==0){
                   menu_rele++;
                   if(menu_rele>8){menu_rele=1;
                    }
                   }
                   else if(ingreso_rele==1){
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"Enviando solisitud  ");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"                    ");                  
                   printf("1.2.3.4.5.6");
                   putc(0x0D);
                   delay_ms(20);
                   printf("rele%i off",menu_rele);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   putc(0x0D);
                   delay_ms(20);
                   printf("rele%i off",menu_rele);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   putc(0x0D);
                   delay_ms(20);
                   printf("rele%i off",menu_rele);
                   putc(0x0D);                  
                   }
                   }
                  
lcd_gotoxy(1,a);
printf(lcd_putc,"CONTROL RELE %i      ",menu_rele);
if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));
                   printf(lcd_putc,"\f");
                   a=1;
                   ingreso_rele=1;
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"a>Encender Rele     ");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"b>Apagar Rele       ");
                   }

if(!input(PIN_C3)){
                   do{
                   }while(!input(PIN_C3));
                   printf(lcd_putc,"\f");
                   break;
                  }
}
break;
}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/*********************FUNCION DE SENSORES DE VOLTAJE***************************/
////////////////////////////////////////////////////////////////////////////////
void sensor_de_voltaje(void){
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc," MENU DE CONTROL DE ");
lcd_gotoxy(1,2);
printf(lcd_putc,"SENSORES DE VOLTAJE ");
while(true){

}}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/*********************FUNCION DE SENSORES DE CORRIENTE*************************/
////////////////////////////////////////////////////////////////////////////////
void sensor_de_corriente(void){
transformar_dato=0;
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc," MENU DE CONTROL DE");
lcd_gotoxy(1,2);
printf(lcd_putc,"SENSORES DE CORRIENT");
while(true){

if(procesar_radio==1){
copia_cadena_radio();
}

if(transformar_dato==1){
corriente1=atoi(comando_radio);
}
else if(transformar_dato==2){
corriente2=atoi(comando_radio);
}

if (strcmp (comando_radio,enviado1) == 0 && ingreso_corriente==1){
    corriente=(corriente1*256)+corriente2; //<------------------------aqui lo que dices
    transformar_dato=0;
    lcd_gotoxy(1,4);
    printf(lcd_putc,"%f[Amp]",corriente);
    delay_ms(1500);
    ingreso_corriente=0;
}

if(!input(PIN_C0)){
                   do{
                   }while(!input(PIN_C0));  
                   if(ingreso_corriente==0){
                   menu_corriente--;
                   if(menu_corriente<1){
                   menu_corriente=5;
                   }                  
                   }
                  
}
                  
if(!input(PIN_C1)){
                   do{
                   }while(!input(PIN_C1));
                   if(ingreso_corriente==0){
                   menu_corriente++;
                   if(menu_corriente>5){
                   menu_corriente=1;
                    }
                   }
                  
}
                  
lcd_gotoxy(1,b);
printf(lcd_putc,"SENSOR DE CORRIENTE%i",menu_corriente);

if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));
                   printf(lcd_putc,"\f");
                   b=1;
                   ingreso_corriente=1;
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"Corriente sensor %i:"menu_corriente);
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"                    ");                  
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de corriente %i",menu_corriente);
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de corriente %i",menu_corriente);
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de corriente %i",menu_corriente);
                   delay_ms(2);
                   putc(0x0D);
                   }                  
if(!input(PIN_C3)){
                   do{
                   }while(!input(PIN_C3));
                   printf(lcd_putc,"\f");
                   break;
                  }
}
break;
}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
/*      TRASPASO DE DATOS DE LOS BUFFER DE RECEPCION A NUEVAS CADENAS         */
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

void copia_cadena_radio(void){
switch (cadena_radio){                 //selecciona las ip que comandaran el cto
                                       // de control....                                
case "1.2.3.4.5.6":                    //ip del control remoto
x=1;                                   //si IP es correcta entonces.... pongo vandera
identificadorIP=0;                     //reseteo identificadorIP...
//printf("oki doki");                    // mando confirmacion de comunicacion he ip
break;                                 // salgo del ip....
default:                               // en caso de ingresar una IP distinta, o algo distinto
identificadorIP++;                     // incremente identificador de ip como valores erroneos..
}
if(x==1 && identificadorIP==1){        //si.. la ip ingresada es correcta entonces.....
strcpy(comando_radio,cadena_radio);    // paso a controlar el cto de control...
transformar_dato++;
x=0;                                   //reseteo vandera de ip
identificadorIP=0;                     // reseteo vandera de datos de control de cto
}
borrar_cadena_radio();                 // borro todo lo que a quedado en el buffer de
}                                      //de recepción.....

////////////////////////////////////////////////////////////////////////////////
/************************************FIN***************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/******************************************************************************/
/*          BORRAN BUFFER DE RECEPCION SERIAL DE LA UART 1 Y UART2            */
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

void borrar_cadena_radio(void){
int c=0;
procesar_radio=0;
for(c=0;c<=incremento_radio;c++){
cadena_radio[c]=0;
}
incremento_radio=0x00;
}

////////////////////////////////////////////////////////////////////////////////
/************************************FIN***************************************/
////////////////////////////////////////////////////////////////////////////////

[Suky]

Para utilizar atoi se debe incluir <stdlib.h>, y además el string debe tener el carácter nulo como corresponde. El otro tema, prueba así:

ValorTotal =ByteAlto*256.0 + ByteBajo;


Saludos!

[japifer_22]

hola suky, pregunta a que te refieres a que el string tiene que  tener el caracter nulo como corresponde ?¿

[AngelGris]

  A que todo string en C, termina con el caracter '\0'. Por ejemplo, la palabra "Hola" no ocupa 4 bytes sino 5, y si la descompones en cada uno de sus elementos (como un array) quedaría así...

variable[0] = 'H';
variable[1] = 'o';
variable[2] = 'l';
variable[3] = 'a';
variable[4] = '\0';

[japifer_22]

hola angelgris, te comento que entiendo como es la composicion del string, pero me surge la duda con lo que a dicho suky, y por eso pregunto, si acaso estoy mal con el codigocon respecto a los manejo de string que conformo. eso.

lo otro es que logre lo que me dijiste sale de lo mas bien:

Código: [Seleccionar]

char string_recepcion_serial;
int8 recepcion_byte_alto;
int8 recepcion_byte_bajo;
float uniendo_los_byte_del_adc;

.
.
.
.
.

recepciono el primer byte:
recepcion_byte_alto=atoi(string_recepcion_serial);

recepciono el segundo byte:
recepcion_byte_bajo=atoi(string_recepcion_serial);

.
.
.
 hi por ultimo uno esto:

uniendo_los_byte_del_adc=(recepcion_byte_alto*256.0)+recepcion_byte_bajo

y listo tenemos de vuelta nuestro valor ADC del otro pic :mrgreen: :mrgreen: :mrgreen:
gracias AngelGris y SuKy, por estar siempre pendiente de los mas nesesitados
gracias

[Suky]

No entendes bien lo que dice AngelGris, o sea definiendo char string_recepcion_serial, donde colocas el caracter nulo 

Se debe definir un arreglo con el espacio suficiente.


Saludos!

[japifer_22]

hola otra vez, bueno resulta que al decir que andaba todo bien, era cierto pero era solo en proteus, ya que ahora que lo pruebo en la realidad no me anda de nada, ayer en la tarde hice unas pruebas de comunicación entre los pic y anda bien, he visualizado que el pic que toma los registros de los pines análogos anda de lo mas bien, en conjunto con su make8, pero el punto sucede en el receptor. Bueno en este punto entrega los datos pero no da datos coherentes, a que se deberá ¿?, me parece que se ve en la LCD los datos separados de 8 bit y no como supuestamente lo tengo yo, el conjunto de los 2 datos provenientes del 232 de 8bit cada uno que conforman la entrada análoga. Dejo esa parte del código para ver si me pueden ayudar pliss

Código: [Seleccionar]

////////////////////////////////////////////////////////////////////////////////
/*********************FUNCION DE SENSORES DE VOLTAJE***************************/
////////////////////////////////////////////////////////////////////////////////
void sensor_de_voltaje(void){
transformar_dato1=0;
c=4;
voltaje=0;
voltaje1=0;
voltaje2=0;
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc," MENU DE CONTROL DE ");
lcd_gotoxy(1,2);
printf(lcd_putc,"SENSORES DE VOLTAJE ");



salir_visor_voltaje=0;
comando_radio[1]=1;

while(true){

if(procesar_radio==1){
transformar_dato1++;
copia_cadena_radio();
}

if(transformar_dato1==2){
voltaje1=atoi(comando_radio);
}
else if(transformar_dato1==4){
voltaje2=atoi(comando_radio);
}

if (strcmp (comando_radio,enviado1) == 0 ){
    if(transformar_dato1>=4){
    voltaje=(voltaje1*256.0)+voltaje2;
    voltaje_muestra_lcd=(voltaje*voltaje_lcd)/1023;
    transformar_dato1=0;   
    lcd_gotoxy(1,4);
    printf(lcd_putc,"%f   [Vol]",voltaje_muestra_lcd,);   
}
}

if(!input(PIN_C0)){
                   do{
                   }while(!input(PIN_C0)); 
                   if(ingreso_voltaje==0){
                   menu_voltaje--;
                   delay_ms(150);
                   if(menu_voltaje<1){
                   menu_voltaje=5;
                   }                   
                   }
                   
}
                   
if(!input(PIN_C1)){
                   do{
                   }while(!input(PIN_C1));
                   if(ingreso_voltaje==0){
                   menu_voltaje++;
                   delay_ms(150);
                   if(menu_voltaje>5){
                   menu_voltaje=1;
                    }
                   }
                   
}

if(menu_voltaje==1){
voltaje_lcd=seleccion_voltaje1;
}else if(menu_voltaje==2){
voltaje_lcd=seleccion_voltaje2;
}else if(menu_voltaje==3){
voltaje_lcd=seleccion_voltaje3;
}else if(menu_voltaje==4){
voltaje_lcd=seleccion_voltaje4;
}else if(menu_voltaje==5){
voltaje_lcd=seleccion_voltaje5;
}
                   
lcd_gotoxy(1,c);
printf(lcd_putc,"SENSOR DE VOLTAJE %i",menu_voltaje);

if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));
                   printf(lcd_putc,"\f");
                   c=1;
                   ingreso_voltaje=1;
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"voltaje sensor %i:"menu_voltaje);
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"                    ");                   
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de voltaje %i",menu_voltaje);
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de voltaje %i",menu_voltaje);
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("sensor de voltaje %i",menu_voltaje);
                   delay_ms(2);
                   putc(0x0D);
                   salir_visor_voltaje=0;
                   }                   
if(!input(PIN_C3)){
                   do{
                   }while(!input(PIN_C3));
                   printf(lcd_putc,"\f");
                   if(salir_visor_voltaje==0){             
                   ingreso_voltaje=0;
                   printf("1.2.3.4.5.6");
                   delay_ms(2);
                   putc(0x0D);
                   delay_ms(20);
                   printf("salgo del switch");
                   salir_visor_voltaje++;
                   }else if(salir_visor_voltaje==1){
                   salir_visor_voltaje=0;
                   break;
                   }}
}
break;
}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
/****************FUNCION DE SELECCION DE VOLTAJE 12 O 24VCC********************/
////////////////////////////////////////////////////////////////////////////////
void seleccion_de_voltaje(void){
printf(lcd_putc,"\f");
lcd_gotoxy(1,1);
printf(lcd_putc,"      MENU DE       ");
lcd_gotoxy(1,2);
printf(lcd_putc,"SELECCION DE VOLTAJE");
while(true){
if(!input(PIN_C0)){
                   do{
                   }while(!input(PIN_C0)); 
                   if(bloqueo==0){
                   menu_seleccion--;
                   delay_ms(150);
                   if(menu_seleccion<1){
                   menu_seleccion=5;
                   }     }   
                   else if(bloqueo==1){
                                       if(menu_seleccion==1){
                                                             seleccion_voltaje1=15;
                                       }else if(menu_seleccion==2){
                                                             seleccion_voltaje2=15;
                                       }else if (menu_seleccion==3){
                                                             seleccion_voltaje3=15;
                                       }else if (menu_seleccion==4){
                                                             seleccion_voltaje4=15;
                                       }else if (menu_seleccion==5){
                                                             seleccion_voltaje5=15;
                                       }
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"Usted a seleccionado");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"rango de 0 a 12 Vdc "); 
                   delay_ms(1500);
                   bloqueo=0;                   
                   printf(lcd_putc,"\f");
                   e=4;
                   lcd_gotoxy(1,1);
                   printf(lcd_putc,"      MENU DE       ");
                   lcd_gotoxy(1,2);
                   printf(lcd_putc,"SELECCION DE VOLTAJE");
                   }                                   
}
                   
if(!input(PIN_C1)){
                   do{
                   }while(!input(PIN_C1));
                   if(bloqueo==0){
                   menu_seleccion++;
                   delay_ms(150);
                   if(menu_seleccion>5){
                   menu_seleccion=1;
                    }   }   
                   else if(bloqueo==1){
                                       if(menu_seleccion==1){
                                                             seleccion_voltaje1=26;
                                       }else if(menu_seleccion==2){
                                                             seleccion_voltaje2=26;
                                       }else if (menu_seleccion==3){
                                                             seleccion_voltaje3=26;
                                       }else if (menu_seleccion==4){
                                                             seleccion_voltaje4=26;
                                       }else if (menu_seleccion==5){
                                                             seleccion_voltaje5=26;
                                       }
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"Usted a seleccionado");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"rango de 0 a 24 Vdc "); 
                   delay_ms(1500);
                   bloqueo=0;                   
                   printf(lcd_putc,"\f");
                   e=4;
                   lcd_gotoxy(1,1);
                   printf(lcd_putc,"      MENU DE       ");
                   lcd_gotoxy(1,2);
                   printf(lcd_putc,"SELECCION DE VOLTAJE");                   
                   }
}

lcd_gotoxy(1,e);
printf(lcd_putc,"SENSOR DE VOLTAJE %i",menu_seleccion);

if(!input(PIN_C2)){
                   do{
                   }while(!input(PIN_C2));
                   printf(lcd_putc,"\f");
                   bloqueo=1;
                   e=1;
                   lcd_gotoxy(1,3);
                   printf(lcd_putc,"a>Sensor de 12 Vcc  ");
                   lcd_gotoxy(1,4);
                   printf(lcd_putc,"b>Sensor de 24 Vcc  ");                   
}
if(!input(PIN_C3)){
                   do{
                   }while(!input(PIN_C3));
                   printf(lcd_putc,"\f");
                   incremento_eeprom=0;
                   break;
                  }
}
printf(lcd_putc,"\f");
lcd_gotoxy(1,4);
printf(lcd_putc,"loading...");
write_eeprom(incremento_eeprom,seleccion_voltaje1);   //escritura
incremento_eeprom++;
delay_ms(20);
write_eeprom(incremento_eeprom,seleccion_voltaje2);   //escritura
incremento_eeprom++;
delay_ms(20);
write_eeprom(incremento_eeprom,seleccion_voltaje3);   //escritura
incremento_eeprom++;
delay_ms(20);
write_eeprom(incremento_eeprom,seleccion_voltaje4);   //escritura
incremento_eeprom++;
delay_ms(20);
write_eeprom(incremento_eeprom,seleccion_voltaje5);   //escritura
incremento_eeprom++;
delay_ms(20);
printf(lcd_putc,"\f");
break;
}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////


[AngelGris]

  ¿Cómo estás haciendo las pruebas?

  Yo haría algo muy sencillo, con un PIC transmitiría dos bytes (siempre los mismos) vía RS232 y en el PIC receptor trataría de convertir dichos bytes a una palabra de 16 bits y mostrarla en el LCD. Sin que intervengan lecturas AD, ni el XBEE. Algo bien directo. De esa manera sabrás si estás convirtiendo bien el número o no y sin pensar que tal vez pueda haber otro fallo.

[japifer_22]

hola AngelGris, te comento que acavo de realizar lo que me dices, ahora ande mejor, pero el punto es que derepente se pierde datos, el byte alto, sera la forma en que envio el dato ?¿ adjunot codigo que envia este dato, y el de recepcion es el que esta mas arriba.

Código: [Seleccionar]

                set_adc_channel(1);
                valor2=read_adc();
                if(refresco2<valor2 || refresco2>valor2){
                Data_H2=make8(valor2,1);
                Data_L2=make8(valor2,0);
                fprintf(radio,"1.2.3.4.5.6");  // esto es para axceder al otro pic
                putc(0x0D);                         //con esto forfirmo..... la clave de axceso o ip como le llamo yo  :mrgreen:
                delay_ms(10);                     // dejo un tiempo para que procese el otro pic
                fprintf(radio,"%u", data_H2 );       //aqui envio el primer byte 
                putc(0x0D);                                   //confirmo el envio
                delay_ms(10);                     // dejo pasar un tiempo para que el otro pic procese
                fprintf(radio,"1.2.3.4.5.6"); // ingreso clave para el sgte byte
                putc(0x0D);
                delay_ms(10);
                fprintf(radio,"%u", data_L2 );//segundo byte a enviar
                putc(0x0D);
                delay_ms(10);
                fprintf(radio,"1.2.3.4.5.6");
                putc(0x0D);
                delay_ms(10);
                fprintf(radio,"enviado"); // y con esto le digo al otro pic que se a enviado todo y que procesa a unir los 2 byte
                putc(0x0D);
                delay_ms(10);
                }   
                refresco2=valor2;
                delay_ms(20);

[AngelGris]

  Podrías hacer la prueba de no utilizar atoi pero si hacer la unión entre el byte alto y el bajo. Porque cuando recibís un dato, en tu variable de entrada va a quedar almacenado un número (entre 0 y 255, que va a representar un caracter ASCII), mas allá que el caracter sea imprimible o no, siempre tendrás el valor.

[japifer_22]

hola bueno te comento que lo solucione, nada que unos par de delay no puedan solucionar, tenia conflicto al momento de confirmar los datos con el caracter 0x0D, les puse unos delay como te digo y funciona de lo mas bien ahora, ta transformacion de datos esta ok.  aver si ahora marcha todo bien, siguente paso ahora es hacer la transformacion al valor que quiero.
te comento como me fue en esto igual, hi gracias por la ayuda otorgada, mesirvio para darme cuenta del problema

AngelGris

Yo haría algo muy sencillo, con un PIC transmitiría dos bytes (siempre los mismos) vía RS232 y en el PIC receptor trataría de convertir dichos bytes a una palabra de 16 bits y mostrarla en el LCD. Sin que intervengan lecturas AD, ni el XBEE. Algo bien directo. De esa manera sabrás si estás convirtiendo bien el número o no y sin pensar que tal vez pueda haber otro fallo.

gracias

[japifer_22]

pfff la convercion me resulto bien, pero ahora tengo problema de lectura, osea que en algunos de los pines analogos estoy midiendo voltaje de 0 a 15V.58dc, esto lo hago por medio de un divisor de tencion, donde Rarriba es de 20K y la Rabajo es de 10K, donde esto a tener 15.58Vdc entrega 5 Vdc, pero el punto es que estoy teniendo problemas en la medicion, ya que al medir 1 vol, el pic me dice que mide 1.64V y al medir 15.58V (que es mis 5V en mi entrada analoga del pic), el pic me mide 14.89V, a que se devera esto alguna idea ?¿?¿. lo que hago para convertir en voltaje es

voltios=((0-1023)*15.58)/1023;

o tendre que hacer otroa cosa ?¿?¿