TODOPIC

Microcontroladores PIC => Lenguaje C para microcontroladores PIC => Mensaje iniciado por: japifer_22 en 22 de Abril de 2011, 22:48:14

Título: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 22 de Abril de 2011, 22:48:14
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}
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: AngelGris en 22 de Abril de 2011, 23:04:34
  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  :)
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: japifer_22 en 23 de Abril de 2011, 00:53:55
hola angelgris, te comento que he intendato lo que du dices pero no resulta, osea por lo menos ami  :mrgreen:

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;
}
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: japifer_22 en 23 de Abril de 2011, 01:10:06
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***************************************/
////////////////////////////////////////////////////////////////////////////////
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: Suky en 23 de Abril de 2011, 01:26:13
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!
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: japifer_22 en 23 de Abril de 2011, 12:42:02
hola suky, pregunta a que te refieres a que el string tiene que  tener el caracter nulo como corresponde ?¿ :shock:
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: AngelGris en 23 de Abril de 2011, 12:47:49
  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';
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit
Publicado por: japifer_22 en 23 de Abril de 2011, 13:45:57
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 :D :D
gracias
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (SOLUCIONADO)
Publicado por: Suky en 23 de Abril de 2011, 13:54:38
No entendes bien lo que dice AngelGris, o sea definiendo char string_recepcion_serial, donde colocas el caracter nulo  :shock:

Se debe definir un arreglo con el espacio suficiente.


Saludos!
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 10:55:35
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;
}
/******************************************************************************/
////////////////////////////////////////////////////////////////////////////////
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 25 de Abril de 2011, 11:15:00
  ¿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.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 12:34:47
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);
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 25 de Abril de 2011, 13:26:15
  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.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 15:00:55
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
Citar
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
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 18:07:08
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 ?¿?¿
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 25 de Abril de 2011, 18:25:25
  Para utilizar el conversor AD hay que configurar correctamente los tiempos del mismo porque sino se pueden generar lecturas erróneas.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: Suky en 25 de Abril de 2011, 18:57:22
Exactamente... Además la impedancia de entrada es aproximadamente 7k, mucho mayor a al recomendada así que hay que adjustar los tiempos de adquisición  :?


Saludos!
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 19:08:00
aver si entiendo, para poder tomar correctamente la señal del ADC tengo que:

Código: [Seleccionar]
set_adc_channel(1);
valor2=read_adc();
aqui tendria que poner un delay de aproximado de 20ms ?¿?¿eso o me equivoco.

o tengo que configurar de otra manera los:

Código: [Seleccionar]
setup_adc_ports(ALL_ANALOG|VREF_VREF); 
setup_adc(ADC_CLOCK_INTERNAL);
o no ?¿?¿

y por ultimo suky, cuando dices:
Citar
Además la impedancia de entrada es aproximadamente 7k, mucho mayor a al recomendada así que hay que adjustar los tiempos de adquisición
a que te refieres, me puedes dar una clase de esto que, o no te entiendo o no lo se.
eso pos  :mrgreen:
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: Suky en 25 de Abril de 2011, 19:12:02
Para leer: http://www.todopic.com.ar/foros/index.php?topic=27929.0


Saludos!
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 25 de Abril de 2011, 19:16:07
oka de cavezaa a leer tu publicacion gracias, aver que saco de estas, cualquier duda no duden en que se las are saber :mrgreen: :mrgreen: :mrgreen: :mrgreen:
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 09:45:53
suky... nunca dejas de sorprenderme y siempre haces que.... cuando yo pienso que voy entendiendo algo.... pa drama.... en realidad NO, y tengo que empezar dese cero.... jijiji.. pero en fin estas cosas son las que hace que me guste este buen hobby de programar..... ya que nunca se termina de aprender.....

Y también gracias ANGELGRIS por tus valiosos aportes..... Siempre preciso...
en fin..

me he dado cuenta que lo que pretendía hacer esta totalmente malo, y para peor mande a hacer una plaquita, la cual me debería llegar hoy.... que es para colocar mi súper pic 18f6025...... en fin son cosas que pasan, y mejor pecar de ignorante una vez que por toda la vida :mrgreen: :mrgreen:, bueno en mi caso son varias veces pero no quiero que sea toda la vidaaaaaaaa noooooooooooooooooooooo :? :? :? :mrgreen: :mrgreen: :mrgreen: :mrgreen:

el cuento ahora es adaptar impedancias, y pensaba en hacerlo con un op amp, en modo de comparador, o seguidor... que dicen?¿?¿

mmmmmmm tendría que poner un divisor de tención en la entrada no inversora de este op amp,  mandando un cable de la entrada no inversora a la salida y la patilla inversora a gnd, y por ultimo en la parte de la salida poner una resistencia para adaptar impedancia, ya que el op amp tiene esta impedancia muy baja
.

la pregunta es estare correcto con esto  o no ?¿?¿

Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 26 de Abril de 2011, 10:15:38
  A ver... la impedancia estimada por Suky creo que surge de hacer R1//R2 (R1 en paralelo a R2), suponiendo que R1 es de la de 20K y R2 la de 10K el resultado de dicho cálculo es 6.666K.

  Mas allá de eso, creo que podrías emplear resistencias de 2K y 1K en lugar de 20K y 10K, con lo cual estarías manteniendo la relación 2 a 1.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 11:23:11
entonces albajar la impedancia al valor de 666.6666 ohm estaria en el rango aceptable del pic, sierto?. y con solo este juego resistivo tendre presicion o no ?¿?¿
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 26 de Abril de 2011, 11:28:11
  La teoría dice que debería funcionar, pero a veces la práctica no concuerda con la teoría. ¿Qué PIC estás utilizando?
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 11:29:35
el 18f6520
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 26 de Abril de 2011, 11:51:17
  En el datasheet de dicho PIC dice que la máxima resistencia debe ser de 2.5K así que con los valores de 2K y  1K debería funcionar bien.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 12:55:39
AngelGris, tienes rason mejoro la presicion como en un 98%, gracias.... voy a seguir haciendo pruebas, para ver como anda.

por otro lado otra pregunta. tambien estoy midiendo corriente con un sensor, el cual me entrega la proporcion en voltaje de la corriente que sensa, este sensor mide un maximo de 5Amp, por medio de una Rshun, el asunto es que a los 5 amp , me entrega 5 V, pero el punto que a esto igual le tengo una resistencia para que me de los 5V que es de 20K, en este caso como tendria que hacerlo para no pasarme de los 2k5 ?¿? en esto tendre que poner el op amp o no ?¿?¿
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: Suky en 26 de Abril de 2011, 13:26:10
Cita de: AngelGris en 26 de Abril de 2011, 10:15:38
  A ver... la impedancia estimada por Suky creo que surge de hacer R1//R2 (R1 en paralelo a R2), suponiendo que R1 es de la de 20K y R2 la de 10K el resultado de dicho cálculo es 6.666K.

  Mas allá de eso, creo que podrías emplear resistencias de 2K y 1K en lugar de 20K y 10K, con lo cual estarías manteniendo la relación 2 a 1.
Exacto, teorema de Thevenin  ;-)

Cita de: japifer_22 en 26 de Abril de 2011, 12:55:39
AngelGris, tienes rason mejoro la presicion como en un 98%, gracias.... voy a seguir haciendo pruebas, para ver como anda.

por otro lado otra pregunta. tambien estoy midiendo corriente con un sensor, el cual me entrega la proporcion en voltaje de la corriente que sensa, este sensor mide un maximo de 5Amp, por medio de una Rshun, el asunto es que a los 5 amp , me entrega 5 V, pero el punto que a esto igual le tengo una resistencia para que me de los 5V que es de 20K, en este caso como tendria que hacerlo para no pasarme de los 2k5 ?¿? en esto tendre que poner el op amp o no ?¿?¿




La resistencia de 20k es el shunt?
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 26 de Abril de 2011, 13:53:38
Cita de: Suky en 26 de Abril de 2011, 13:26:10

Exacto, teorema de Thevenin  ;-)


  No me acuerdo nada de eso  :?  Apenas se me acuerdo de la ley de ohm y 1 de las de Kirchhoff  (la suma de las corrientes entrantes a un nodo es igual a la suma de las corrientes salientes). Sí recuerdo que se utilizaba Thevenin para calcular polarización cuando trabajábamos con transistores.... tendré que volver a leer al respecto  :5]

japifer_22 sería bueno que subas un esquema de como tenés conectado el circuito en el cual hacés la medición de corriente, porque así en el aire me es bastante difícil imaginármelo.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 17:29:34
hola, tienen razon, dejo un dibujo del sensor, la resistencia shunt es de 0.05ohm y la Rout es de 20K

(http://s2.subirimagenes.com/otros/previo/thump_6314008sensor-de-corriente.jpg)
donde Vout lo mando directo al la entrada ADC del pic
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: AngelGris en 26 de Abril de 2011, 17:59:21
Cita de: japifer_22 en 26 de Abril de 2011, 17:29:34
hola, tienen razon, dejo un dibujo del sensor, la resistencia shunt es de 0.05ohm y la Rout es de 20K


donde Vout lo mando directo al la entrada ADC del pic

  Todo depende de la impedancia de salida del sensor.
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: Suky en 26 de Abril de 2011, 18:03:38
Cita de: AngelGris en 26 de Abril de 2011, 17:59:21
Cita de: japifer_22 en 26 de Abril de 2011, 17:29:34
hola, tienen razon, dejo un dibujo del sensor, la resistencia shunt es de 0.05ohm y la Rout es de 20K


donde Vout lo mando directo al la entrada ADC del pic

  Todo depende de la impedancia de salida del sensor.

Es una fuente de corriente, así que la impedancia que ve el ADC del microcontrolador es 20k  :tongue: Probá primero directo y si no, no queda otra que adecuar impedancias.

Acuérdate además que al cambiar de canal hay que esperar el tiempo adecuado para la adquisición y además la selección del reloj del ADC también influye.


Saludos!
Título: Re: enviar 2 datos por xbee de 8bit y pasarlo a uno de 16bit (otra pregunta XD)
Publicado por: japifer_22 en 26 de Abril de 2011, 18:17:18
oka, en cuanto al adquisicion de datos del ADC, nunca veo mas de uno a la vez, siempre mido de a uno y visualizo.
el punto es que por lo que me an dicho y lo que me temia voy a tener que modificar esta parte de mi circuito para adaptar impedancias.

ahora viene el otro tema de, cual sera mejor forma para adaptar impedancias ?¿?, por lo que he podido concluir y como mencione mas arriba, tendre que usar un op-amp. en este punto tengo en mis manos el LM324, y lo configurare como seguidor. tara bien?