Voltímetro de 4 dígitos

Este pequeño proyecto es un voltímetro básico y expandible, digo básico porque el funcionamiento es bastante primitivo dividiendo el código en tres partes: El control multiplexado de displays, La función de conversión para separar un numero entero en 4 dígitos y La lectura del ADC para leer el valor de tensión.
Por otro lado cuando digo Expandible quiere decir que podremos aumentar su representación, cantidad de dígitos, parámetros de medición, adaptación electrónica de señal, muestro, etc...
En este caso se trata de utilizar las funciones básicas ya que en la sencillez se comprende mejor el código y su principio de funcionamiento.
Hay que tener en cuenta que la tensión máxima para el ADC del microcontrolador es de 5V continuos, si queremos realizar una medición que supere este valor tendremos que utilizar un divisor de tensión. 

En nuestro caso mediremos hasta los 4,999V, nuestro voltímetro tendrá una resolución de 4.7mV y para garantizar la estabilidad realizara una toma de 500 muestras cada unos 5ms que luego procesara su promedio y lo mostrara en el display de 4 dígitos.
El ADC del microcontrolador estará funcionando a 10Bit, es decir a 1024 cuentas que funcionando con un máximo de tensión de 4,999V tendremos una representación de 4.7mV lo cual hace poco útil tener 3 dígitos decimales, ya que con 2 dígitos decimales seria útil. (esto quedara para la segunda versión donde pondremos un limite de unos 5V).

Por otro lado nos quedara el tratado de los displays que sera la técnica común de multiplexado, es decir, dato del display 1 y se activa el display 1, mientras el resto sigue desactivado, luego dato del display 2 y se activa el display 2 mientras el resto sigue desactivado, y asi para cada display de esa forma cada dígito muestra el valor que debe, al ser una acción repetitiva y rápida se genera una persistencia que al ojo humano parecen estar los cuatro dígitos encendidos a la vez pero en realidad se activan de uno en uno.

1. //Función que se ejecutara en paralelo al programa principal sobre el Timer0
2. void timer0_mux(int8 dig4, int8 dig3, int8 dig2, int8 dig1){
3.    output_c(0b00000001);               //Selección del display 1
4.    output_b(num[dig1]);                //Valor tratado del dígito 1 en la salida B
5.    output_high(PIN_B7);                //Prendemos el punto decimal
6.    delay_ms(2);                        //Delay de multiplexado de 2ms
7.    output_c(0b00000010);               //Selección del display 2
8.    output_b(num[dig2]);                //Valor tratado del dígito 1 en la salida B
9.    output_low(PIN_B7);                 //Apagamos el punto decimal
10.    delay_ms(2);                        //Delay de multiplexado de 2ms
11.    output_c(0b00000100);               //Selección del display 3
12.    output_b(num[dig3]);                //Valor tratado del dígito 1 en la salida B
13.    output_low(PIN_B7);                 //Apagamos el punto decimal
14.    delay_ms(2);                        //Delay de multiplexado de 2ms
15.    output_c(0b00001000);               //Selección del display 4
16.    output_b(num[dig4]);                //Valor tratado del dígito 1 en la salida B
17.    output_low(PIN_B7);                 //Apagamos el punto decimal
18.    delay_ms(2);                        //Delay de multiplexado de 2ms
19.    set_timer0(0);                      //Seteo del Timer0
20. }

Por ultimo la función encargada de tomar un numero entero y dividirlo en 4 se realiza en base a división y restos, con el símbolo "/" dividimos y con "%" tomamos el resto.

1. void convert(int16 valor){                  //Función para convertir entero en dígitos
2. int uno, diez, cien, mil;                   //Declaración de variables de los dígitos
3.    mil=valor/1000;                          //Operación para adquirir miles
4.    cien=(valor/100)%10;                     //Operación para adquirir cientos
5.    diez=(valor/10)%10;                      //Operación para adquirir decenas
6.    uno=valor%10;                            //Operación para adquirir unidades
7.    timer0_mux(uno,diez,cien,mil);           //Llamado a la función de multiplexado
8. }

La medicion se realiza en base a un canal ADC el cual se acondiciona multiplicando por los 5V del fondo de escala del ADC y se lo divide por la cantidad de muestras del ADC que seran 1024.

Luego para mejorar la estabilidad de la medición utilizaremos el calculo del promedio de la medición, es decir, mediremos 500 veces el valor, realizaremos la sumatoria de cada uno de ellos y al finalizar el lazo de iteracion dividiremos el valor final por 500 para que nos de el valor estable. De esta forma el bit menos significativo sera mas estable, pero como lo comentaba al principio del proyecto no es necesario tener 3 decimales con 10 bit de representación.

1.    while(true){                             //Lazo repetitivo principal
2.       set_adc_channel(0);                   //Selección del canal 0 del ADC
3.       delay_ms(5);                          //Delay para la conversión de 5ms
4.       tension=read_adc()*5.0/1023.0;        //Lee el ADC y convierte en valor de tensión
5.       for(i=0;i<500;i++){                   //Lazo de 500 iteraciones para sacar promedio
6.          tensionAnt=tension+tensionAnt;     //Suma del acumulado para sacar promedio
7.       }        
8.       convert((tensionAnt/500)*1000);       //Llama a la función que convierte a dígitos
9.       tensionAnt=0;                         //Inicializa variable de promedio
10.    }

Ahora dejare el código completo para poder observar las funciones del mismo de forma mas sencilla y la interacción entre ellas.

1. #include <16F883.h>                         //Microcontrolador a Elegir
2. #device adc=10                              //Resolución del ADC a 10Bit
3. #use delay(clock=4000000)                   //Oscilador Externo a 4MHz
4. //Vector que aloja los 10 valores numéricos para el display de 7 segmentos
5. int8 num[10]={0b00111111,0b00000110,0b01011011,0b01001111,0b01100110,
6.               0b01101101,0b01111101,0b00000111,0b01111111,0b01101111};
7. #int_timer0                                 //Función del Timer0
8. //Función que se ejecutara en paralelo al programa principal sobre el Timer0
9. void timer0_mux(int8 dig4, int8 dig3, int8 dig2, int8 dig1){
10.    output_c(0b00000001);                    //Selección del display 1
11.    output_b(num[dig1]);                     //Valor tratado del dígito 1 en la salida B
12.    output_high(PIN_B7);                     //Prendemos el punto decimal
13.    delay_ms(2);                             //Delay de multiplexado de 2ms
14.    output_c(0b00000010);                    //Selección del display 2
15.    output_b(num[dig2]);                     //Valor tratado del dígito 1 en la salida B
16.    output_low(PIN_B7);                      //Apagamos el punto decimal
17.    delay_ms(2);                             //Delay de multiplexado de 2ms
18.    output_c(0b00000100);                    //Selección del display 3
19.    output_b(num[dig3]);                     //Valor tratado del dígito 1 en la salida B
20.    output_low(PIN_B7);                      //Apagamos el punto decimal
21.    delay_ms(2);                             //Delay de multiplexado de 2ms
22.    output_c(0b00001000);                    //Selección del display 4
23.    output_b(num[dig4]);                     //Valor tratado del dígito 1 en la salida B
24.    output_low(PIN_B7);                      //Apagamos el punto decimal
25.    delay_ms(2);                             //Delay de multiplexado de 2ms
26.    set_timer0(0);                           //Seteo del Timer0
27. }
28. void convert(int16 valor){                  //Función para convertir entero en dígitos
29. int uno, diez, cien, mil;                   //Declaración de variables de los dígitos
30.    mil=valor/1000;                          //Operación para adquirir miles
31.    cien=(valor/100)%10;                     //Operación para adquirir cientos
32.    diez=(valor/10)%10;                      //Operación para adquirir decenas
33.    uno=valor%10;                            //Operación para adquirir unidades
34.    timer0_mux(uno,diez,cien,mil);           //Llamado a la función de multiplexado
35. }
36. void main(){                                //Función principal del programa
37.    setup_adc_ports(sAN0|VSS_VDD);           //Configuración del canal del ADC
38.    setup_adc(ADC_CLOCK_DIV_2);              //Configuración de velocidad del ADC
39.    setup_timer_0(RTCC_INTERNAL|RTCC_DIV_8); //Configuración del divisor del Timer0
40.    set_timer0(0);                           //Seteo del Timer0
41.    enable_interrupts(INT_TIMER0);           //Habilitación de interrupción Timer0
42.    enable_interrupts(GLOBAL);               //Habilitación de interrupciones
43.    float tension, tensionAnt=0;             //Definición de variables flotantes
44.    int16 i;                                 //Definición de entero de 16 bit
45.    while(true){                             //Lazo repetitivo principal
46.       set_adc_channel(0);                   //Selección del canal 0 del ADC
47.       delay_ms(5);                          //Delay para la conversión de 5ms
48.       tension=read_adc()*5.0/1023.0;        //Lee el ADC y convierte en valor de tensión
49.       for(i=0;i<500;i++){                   //Lazo de 500 iteraciones para sacar promedio
50.          tensionAnt=tension+tensionAnt;     //Suma del acumulado para sacar promedio
51.       }        
52.       convert((tensionAnt/500)*1000);       //Llama a la función que convierte a dígitos
53.       tensionAnt=0;                         //Inicializa variable de promedio
54.    }
55. }

De la misma manera hay que utilizar resistencias de 330R a 680R para los 7 segmentos que no esta en el diagrama de simulación pero si las he utilizado en la practica con un pack DIL de resistencias.