ADC del PIC: ¿es normal esto?

Hola,

Estoy usando un canal AD del pic 16f877 configurado para resolucion de 8 bits y como prueba estoy visualizando el valor de la conversion en un LCD 16x2, lo muestro en formato decimal, pero lo que sucede es que nunca se queda estatico el resultado, digo estoy midiendo un voltaje de una bateria el cual no varia en absoluto, pero el resultado del convertidor AD si lo hace. Por ejemplo se la pasa oscilando del 133,134,135,138 a veces hasta el 140 y vuelve al 133 y asi.

Asi que me pregunto: ¿Es normal esto? y si no lo es: ¿como lo soluciono?

Hasta el momento no he usado niguna entrada para voltaje de referencia y se supone que la referencia la toma de la alimentacion 5v del PIC. No se si pueda ser ese el problema. Por que la verdad si me interesa que el resultado sea lo mas estable posible, presisamente para poder notar en caso de que haya verdaderas variaciones en el voltaje que estoy midiendo.

Saludos,

Pone un capacitor de 100 nF. Una patita de este en la entrada de la señal analógica y la otra a masa. Si no me equivoco, esto soluciona estos problemas.

Saludos

Hola Loktar,

Pues ya le coloque el condensador como me indicas, y la variación sigue, nunca se queda estable. Otra cosa que probé es poner la entrada a masa, se supone que debería ponerse en 0, pero no, aun así se mantiene variando: 0, 1, 2, 4, etc.

De momento todo esto lo tengo montado en protoboard, no creo que ese sea el problema, pero pienso que es como una interferencia o algo así. Cualquier idea es bienvenida.

Saludos y gracias,

Mmm, a mi entonces me parece que se debe a un error en el mismo PIC. Pienso que puede ser el programa. Estás seguro que esperas todos los tiempos necesarios provisto por Microchip? Osea el tiempo de adquisición y eso. Y también comprobando que la conversión está lista?

Capaz sería bueno que nos pases el programa en ASM.

Hola, y cuales son los tiempos mas adecuados ¿?, yo le hago así: Primero configuro las entradas que van a ser análogas, luego elijo el canal a leer y espero 5 ms, leo el valor del ADC, espero otros 5 ms, hago uso del valor y finalmente tengo un retardo de 100 ms entre cada conversión, esto en un ciclo infinito.

Eso de si la conversion esta lista, la verdad no estoy seguro, ya que no lo hago en ASM sino en C y pues no se si eso lo haga la funcion read_adc() por automatico.

¿Tendría que esperar más en algun punto?

Saludos,

Perdón, no había visto tu segundo mensaje, pues no lo tengo en ASM pero igual pongo el C, para que lo chequen:

Código: Seleccionar todo


#include <16F877.h>
#device ADC=8
#fuses   HS,NOWDT,NOPROTECT,PUT,NOLVP,BROWNOUT
#use delay (clock=20000000)
#use standard_io(b)
#use standard_io(d)
#use standard_io(e)

int valor_bateria=0x00;
int valor_alimentacion=0x00;

/* Mandar un comando al LCD */
void lcd_comando(int comando)
{
   output_low(PIN_E0);     /* Modo registro en el LCD */
   output_b(comando);      /* Manda el comando por el puerto B */
   output_high(PIN_E2);    /* Habilita el LCD */
   delay_us(5);            /* 5 us */
   output_low(PIN_E2);     /* Deshabilita el LCD */
   delay_ms(1);            /* 1 ms */
}

/* Mandar un caracter al LCD */
void lcd_caracter(char caracter)
{
   output_high(PIN_E0);    /* Modo caracter en el LCD */
   output_b(caracter);     /* Manda el caracter por el puerto B */
   output_high(PIN_E2);    /* Habilita el LCD */
   delay_us(5);            /* 5 us */
   output_low(PIN_E2);     /* Deshabilita el LCD */
   delay_ms(1);            /* 1 ms */
}

/* Funcion para mandar el cursor a posicion reuqerida */
void lcd_posicion(int linea, int posicion)
{
   switch (linea)
   {
      case 1:
         lcd_comando(0x80+(posicion-1));  /* Linea 1 posicion requerida -1 */
      break;

      case 2:
         lcd_comando(0xC0+(posicion-1));  /* Linea 2 posicion requerida -1 */
      break;
   }
}

/* Iniciar el LCD 16x2 JHD */
void lcd_iniciar(void)
{
   set_tris_b(0x00);       /* Salidas en el puerto B */
   set_tris_e(0x00);       /* Salidas en el puerto E */
   output_e(0x00);         /* Puerto e bajo */

   lcd_comando(0x38);      /* LCD Linea 1 */
   lcd_comando(0x38);      /* LCD Linea 2 */
   lcd_comando(0x0C);      /* Cursor apagado */
   lcd_comando(0x80);      /* LCD linea 1 */
   lcd_comando(0x06);      /* Desplazamiento del cursor a la derecha */
}

/* Funcion para leer el ADC */
void medir_entradas(void)
{
   /* ADC0 */
   set_adc_channel(0);              /* Lectura del canal 0 */
   delay_ms(5);                     /* 5 ms */
   valor_alimentacion=read_adc();   /* Se lee el canal 0 y pasa a valor_alimentacion */
   delay_ms(5);                     /* 5 ms */

   /* ADC1 */
   set_adc_channel(1);              /* Lectura del canal 1 */
   delay_ms(5);                     /* 5 ms */
   valor_bateria=read_adc();        /* Se lee el canal 1 y pasa a valor_bateria */
   delay_ms(5);             /* 5 ms */   
}

/* Principal */
void main(void)
{
   setup_adc(ADC_CLOCK_INTERNAL);         /* Configuracion del convertidor */
   setup_adc_ports(RA0_RA1_RA3_ANALOG);   /* RA0 como entrada analogica */

   lcd_iniciar();                         /* Iniciar el LCD 16 x 2 */

   do
   {
      medir_entradas();          /* Manda medir */

      lcd_comando(0x01);      /* Limpiamos pantalla   */
      lcd_comando(0x02);      /* Cursor a casa*/

      printf(lcd_caracter,"AD0=%U AD1=%U",valor_alimentacion,valor_bateria);

      delay_ms(100);

   }while(true);
}


Saludos,

Hola. En C nunca programe. Los tiempos de adquisición parecen suficientes. Cuando empiezas la conversión, tienes que verificar que el bit GO/DONE se ponga a cero. Eso te dirá que la conversión está lista. Lo que no sé es si la función en C te hace eso automáticamente. Prueba hacer esto: Luego de que empieces la conversión, haz un ciclo que verifique que el bit GO/DONE (bit 2 de la dirección 1FH), Si el bit está a cero es que la conversión está lista, si no, el bucle continúa hasta que el bit se ponga a cero.

También sugiero la opinión de alguien más experimentado.

Saludos.

Hola,

Esa idea me gusta, de verificar el bit GO/DONE del ADCON0, solo que no veo en que punto meter tal verificación, esto por que la función read_adc() me deja sin control de esa parte. Ya que es ella quien me devuelve el valor de la conversión, pero como tu bien dices yo igualmente ignoro la estructura de esa función como para poder determinar si verifica el estado del bit GO/DONE o no.

Hasta ahorita no me he encontrado la referencia de esa función, así que si alguien sabe donde se puede checar esto pues no se quede callado.

Saludos,

Hola de nuevo, pues no se pero creo que el problema es el montaje, pues muevo o pongo la mano sobre algunos de los alambres del protoboard y casi se queda quieto, digo casi por que la variación es mínima, de estar en 139 se mueve a 140, o sea muy poco e inclusive se llega a quedar estático. Debo decir que tiendo a dejar un poco largos los puentes, a tal grado que al final me queda como una araña de colores alrededor y sobre el PIC, pero no se si esto es una causa real del problema o ya me sugestione ¿?.

Saludos,