Voltimetro de 0 a 50V, usando Pic 16f876 con SDCC

Hola a todos

Primero que nada agradecer a arcachofo por su libreria de ADC ,Bastante bueno su aporte.
Me tomado la libreria de ADC y la he probado en un PIc 16F876, y
monte un voltimetro digital de 0 a 50V. aunque estoy recien conociendo
SDCC, gracias a algunos conocimientos de C ( en la universidad ) he
podido adaptarme..

Se los dejo para que lo vean.

Código:


/*************************************************************************** */
/* Voltimetro_7seg_876.c      Enero 4 del  2009                            */
/*---------------------------------------------------------------------------*/
/* Ejemplo Voltimetro 0-50Vdc con Microcontolador Pic16F876A                */
/*  Con Display 7 Seg Multeplexado a traves de RA1,RA2,RA3                  */
/*---------------------------------------------------------------------------*/
/*  Ricardo Santibañez                                */
/*---------------------------------------------------------------------------*/
/* Desarrolado con SDCC.                                                    */
/*****************************************************************************/

#include <pic16f876a.h>
#include <delay.h>
#include <adc.h>    /*Funcion para uso ADC gracias arcachofo PIc Linux*/



typedef unsigned int word;
word at 0x2007 CONFIG = _XT_OSC & _WDT_OFF & _PWRTE_ON &
_BODEN_OFF & _LVP_OFF & _CPD_OFF & _WRT_OFF &
_DEBUG_OFF & _CP_OFF;


/* Declaracion de Variables */
char display[10]={0x01,0x4f,0x12,0x06,0x4c,0x24,0x60,0x0f,0x00,0x0c}; //Valores que representa numeros en display 7 seg.
char ingres=1;
long int digito1,digito2,digito3;
long int medida;
long int medida1;


/*Rutina de Interrupciones, en este caso por Desborde de Timer 0*/
void isr() interrupt 0 {

switch (ingres)        //Selecciono que Display Activar  y que valor cargar
{
    case 1:
        RA3=1;
        RA2=1;
        RA1=0;
        PORTB=display[digito1];
        ingres=2;
        break;
    case 2:
        RA3=1;
        RA1=1;
        RA2=0;
        PORTB=display[digito2];
        ingres=3;
        break;
    case 3:
        RA2=1;
        RA1=1;
        RA3=0;
        PORTB=display[digito3];
        ingres=1;
        break;
}
 T0IF=0; // Borro Bandera de Desborde
 TMR0=150;  // cargo valor en TMR0
}

void main() {
 
 TRISA=1;    // Puerta.0 como entrada  y el resto como salida
 TRISB=0;    // Todo el Puerto B como Salida
 TMR0=150;    // inicio Tmr0 =150
 OPTION_REG=5;    //Configuro preescaler de TMRO   
 T0IE=1;        // activo Int. por Tmr0
 GIE=1;        // Habilito Interrupciones   
 PORTB=0;    // inicio Portb
 adc_init(FOSC_2, A1_R0, INT_OFF); //Uso de Rutina ADC de PIC, iniciacion
while (1)
    {
        medida=adc_read(0);    // Leer canal 0
        medida1=((medida*500)/1023);//Escalar Variable de  0 a 500

    /*Determinar Valores para cada digito del Display*/
          digito1=(medida1/100);
          digito2=(medida1-(digito1*100))/10;
        digito3= medida1-(digito1*100+digito2*10);
        delay_ms(200);

    }

}



Ademas le dejo este video.




hay un pequeño error en el nombre del pic ... me equivoque .. jajaj es pic 16F876... pero dije pic 16F786 (upssss)

Ademas les dejo el esquema de este circuito





atte. Risanti

Muy bueno el ejemplo... buen aporte.

Se puede ver tanto el uso de la librería ADC, como el uso de displays de 7 segmentos con SDCC; además muy bién explicado, con código, esquema y video.... completito.

Por cierto, hay una nueva versión de la librería ADC escrita directamente en ASM, las funciones cambian un poco, pero todo con la idea de minimizar el tamaño del código generado: https://pic-linux.forosactivos.net/sdcc-f23/sdcc-driver-para-adc-pic16f87x-t43.htm

Si te animas a probarla y comprobar que funciona y de paso comprobar que el tamaño del .hex generado es menor que con la librería escrita en C seguro que arcachofo te lo agradece.

Felicitaciones por el proyecto y gracias por compartir.

Solo un comentario: ¿no podrías poner una captura del esquema un poco más grande? .

Oye... me alegro de que le hayas sacado probecho a las funciones para ADC, has hecho un buen trabajo con ellas.
Estoy deacuerdo con Geo en que es una pena que el esquema no se aprecie mejor, si me mandas el esquema por mail lo podría subir al box y poner un link para su descarga... si te parece bien.. claro.

Por cierto... con qué programa has hecho el esquema?

gracias por sus comentarios:

Estoy trabajando para terminar este proyecto, es para un amigo que esta armando una fuente de poder, pienso cambiar el PIc 16F876 por un PIC 16F88 ( es mas barato y quiero utilizar el oscilador interno),cuando tenga un avance lo publico.

además he subido el esquema mas grande, esta hecho en eagle 5.2, lo descargas desde la pagina ftp://ftp.cadsoft.de/eagle/program/




Cualquier observación es bien recibida.
atte.
Risanti

Gracias por el esquema .

Yo estuve haciendo unas pruebas con un 16f88, el cual conseguí en lugar de un 16f628 precisamente por el oscilador interno, aunque al momento de reprogramarlo, en ocasiones mi programador no reconoce al PIC .

Yo estuve haciendo unas pruebas con un 16f88, el cual conseguí en lugar
de un 16f628 precisamente por el oscilador interno, aunque al momento
de reprogramarlo, en ocasiones mi programador no reconoce al PIC .

Si... algunos programadores que no controlan Vpp independientemente tienen problemas con PICs con oscilador interno; también algunos softwares de grabación de PICs.
Estos PICs necesitan que Vpp suba antes de Vdd para entrar en modo programación, si el programador o el software no es capaz de hacer esto, entonces puede dar fallos.

El problema es sobre todo cuando se configura el pic con oscilador interno y mclr desactivado.

La programacion del pic 16f88 es dificil porque se debe borar antes de escribir, se bora 32 palabras de 14 bits y se programa 4 palabras cada vez

Con un programmador, se debe verificar que se borra toda la memoria del pic antes de grabar

Si quieres usar un monitor(bootloader) y grabar con el puerto serie , tengo un monitor aqui :
http://per.launay.free.fr/pik_digor/moniteur/monitor88A/
ver tambien https://pic-linux.forosactivos.net/programadores-f12/grabar-con-un-bootloader-a-traves-el-puerto-serie-o-el-usb-t55.htm#177

Per

Hola a todos..

continuando con mi proyecto del voltímetro de 0 a 50V (puede ser mas o menos solo hay que cambiar el divisor de tension y el escalamiento en el programa) lo he realizado con el PIC 16F88, utilizando oscilador interno y ademas probe las funciones adc. de arcachofo.

el programa original no le he realizado muchos cambios solo las palabras de configurarcion para este pic y ademas de seleccionar la velocidad del pic en el registro OSCCON (BIt : IRCF;IRCF1;IRCF2;) y como trabaja el porta con el registro ANSEL. ademas cambia un poco como se llama las banderas de desborde de TMR0 ya que para el 16F88 ,se llama TMR0IF.

se los dejo para que lo vean.

Código:


/*************************************************************************** */
/* Voltimetro_7seg_88.c      Enero 20 del  2009                            */
/*---------------------------------------------------------------------------*/
/* Ejemplo Voltimetro 0-50Vdc con Microcontolador Pic16F88A                */
/*  Con Display 7 Seg Multeplexado a traves de  RA1,RA2,RA·              */
/*---------------------------------------------------------------------------*/
/*  Ricardo Santibañez                                */
/*---------------------------------------------------------------------------*/
/* Desarrolado con SDCC.                                                    */
/*****************************************************************************/

#include
#include
#include   

typedef unsigned int word;
word at _CONFIG1 CONFIG1 = _WDT_OFF & _PWRTE_ON & [b]_INTRC_IO[/b] & _MCLR_OFF & _BODEN_OFF & _LVP_OFF & _CPD_OFF & _WRT_PROTECT_OFF & _DEBUG_OFF & _CCP1_RB0 & _CP_OFF;
word at _CONFIG2 CONFIG2 = _FCMEN_ON & _IESO_ON;

/* Declaracion de Variables */
char display[10]={0x01,0x4f,0x12,0x06,0x4c,0x24,0x60,0x0f,0x00,0x0c}; //Valores que representa numeros en display 7 seg.
char ingres=1;
long int digito1,digito2,digito3;
long int medida;
long int medida1;


/*Rutina de Interrupciones, en este caso por Desborde de Timer 0*/
void isr() interrupt 0 {

switch (ingres)        //Selecciono que Display Activar  y que valor cargar
{
    case 1:
        RA3=1;
        RA2=1;
        RA1=0;
        PORTB=display[digito1];
        ingres=2;
        break;
    case 2:
        RA3=1;
        RA1=1;
        RA2=0;
        PORTB=display[digito2];
        ingres=3;
        break;
    case 3:
        RA2=1;
        RA1=1;
        RA3=0;
        PORTB=display[digito3];
        ingres=1;
        break;
}
 [b]TMR0IF=0[/b]; // Borro Bandera de Desborde
 TMR0=150;  // cargo valor en TMR0
}

void main() {
IRCF0=0;
IRCF1=1;
IRCF2=1;
TRISA=1;    // Puerta.0 como entrada  y el resto como salida
[b]ANSEL=1[/b];
TRISB=0;    // Todo el Puerto B como Salida
TMR0=150;    // inicio Tmr0 =150
OPTION_REG=5;    //Configuro preescaler de TMRO   
[b]TMR0IE[/b]=1;        // activo Int. por Tmr0
GIE=1;        // Habilito Interrupciones   
PORTB=0;    // inicio Portb
adc_init(FOSC_2,A1_R0, INT_OFF); //Uso de Rutina ADC de PIC, iniciacion
while (1)
    {
        medida=adc_read(0);    // Leer canal 0
        Determinar_Display();
    }

}
void Determinar_Display ()
{
/*Determinar Valores para cada digito del Display*/
         
medida1=((medida*500)/1023)    ;//Escalar Variable de  0 a 500
digito1=(medida1/100);
digito2=(medida1-(digito1*100))/10;
digito3= medida1-(digito1*100+digito2*10);
delay_ms(200);

}


__________________________________________________________________________________________







atte.
Risanti.

Hola, he visto que usas la libreria delay.h.... como hiciste para usarla?,al ponerla me saca error cuando compilo gracias, disculpa si ya se hablo de esto pero busque y no encontre nada...

Que tal Ciber_hormaza?

No te he contestado antes por si aparecía alguien que supiera más del tema...
Y no te preocupes por preguntar lo que quieras.

El caso es que por ahora no creo que haya ninguna librería con delays para pic16f, quizás Risanti usara una librería propia.

Si quieres puedes probar las funciones de este driver LCD , tiene una función "pausa(ciclos)" con una duración variable según la velocidad de reloj y una funcion "espera_ms(ms)", osea un delay en milisegundos.
El delay en ms es independiente de la velocidad de reloj, pero tienes que defirla en el programa donde vayas a usar el delay:

#define FREQ 8000 // 8000 KHz = 8 Mhz, LA FRECUENCIA EN KHz.


Puedes incluirlas las funciones directamente en tu programa o mejor hacer una librería, para esto creas un archivo llamado delay.h (por ejemplo) y copias esto:

Código:


#define coms = FREQ / 4000;

void pausa( unsigned char ciclos )           
{    ciclos;                //tiempo = (4 * ciclos + 1)µs , para 4MHz ; ciclos debe ser >=2
    _asm                // "ciclos" ya está en w
    sublw 1   
    bucle:
    addlw 1
    btfss STATUS,0
    goto bucle
    _endasm;
}

void espera_ms( unsigned int ms )
{
    ms = ms * coms;
    while (ms > 0 )
    {
        pausa(247);
        ms--;
    }
}



En el programa donde vayas a usar el delay tienes que incluir estas dos lineas:

Código:


#define FREQ 8000        // 8000 KHz = 8 MHz, LA FRECUENCIA EN KHz.

#include "delay.h"



Logicamente tienes que pones la velocidad de reloj que tu estés usando, este ejemplo es para 8 MHz

El archivo delay.h tiene que estar en la misma carpeta del archivo que vayas a compilar o ponerlo en la carpeta de las cabeceras de SDCC: /usr/share/sdcc/include/pic

Estos delays no son exactos 100%... todo depende del uso que quieras darles, pero quizás te sean utiles.


Saludos.

Hola Risanti, tu proyecto es un buen proyecto y por lo tanto me gustaria saber si con compilar tu programa e introducirselo al PIC ya funcionaria en un protoboard. Es que lo compilé e intenté simularlo con el PIC Simulator IDE pero no he podido.
Gracias de antemano por tu tiempo y tu respuesta.

Hola Malenaar, mientras te responde Risanti te doy mi opinión.

Para que el programa te funcione debes tener las librerías que utiliza; no sé si será este el problema, pero he subido las librerías adc.h y delay.h que creo que funcionan con el programa del voltímetro, están en la seccion de DESCARGAS/PIC16F/Ejemplos en un tar.gz junto con todo el proyecto. Enlace directo: http://www.box.net/shared/3a3zbjrh94

No las he probado, así que se agradece cualquier reporte de error o lo que sea.


Saludos.

Mira Pikitin yo no se mucho sobre programacion de microcontroladores y lo que hice fue compilar el programa que estaba en el foro con CCs y no me salio ningun error de compilación ni nada. pero cuando lo meti en el PIC Simulator Ide no conseguí hacerlo funcionar, si fueras tan amable de decirme como lo tengo que hacer, te lo agradeceria muchisimo, pero esplicamelo con mucho detalle para que lo entienda bien y te prometo que si me funciona te lo hago saber. Lo siento pero no soy Linusero.

El tema es que este programa es para el compilador SDCC.
Entonces o te instalas el SDCC para Windows o adaptas el programa para que te funcione con CCS.
Quizás con adaptar las funciones del ADC y alguna cosilla más lo puedas hacer funcionar en CCS, pero ahí no te puedo ayudar ya que no conozco el CCS.

Lo curioso es que no te dé ningún error al compilar con CCS.



Saludos.

Muchisimas gracias Pikitin por tu atencion.
No encuentro el programa DSCC para Windows y no tengo conocimientos suficientes como para adaptar todo esto a CCS, asi que no podré seguir con este proyecto, cosa que laqmento pues en mi fuente de alimentacion se veria muy bonito el voltimetro.
De nuevo gracias por tu atencion y por tu tiempo.

Nota: El enlace que me pones en tu anterior mensaje no funciona.

Hola..
Espero que esto te sirva http://sourceforge.net/projects/sdcc/files/
Alli encontraras el instalador para Windows yo personalmente solo he trabajo SDCC en Linux, pruebalo y cuentanos. como te va.
La pagina del Sdcc es http://sdcc.sourceforge.net/ hay informacion que te puede servir.



atte.
Risanti

Hola

Podrias poner el esquema de este circuito con unpoco mas de resolucion asi se pueden ver los componenetes

Muchas Gracias
Saludos

hola a todos.

No hay problema, puedes encontrar una version desde proyecto en en Box del Foro. Lo Puedes descargar esto Aqui


Espero que te sirva.

Atte.
RiSanti

Hola A todos.

Continuando con este tema he fabricado el circuito impreso de este voltimetro utlizando PIC16F88, se los dejo para que me den sus opiniones.



el Codigo fuente es el que subi anteriormente. yo considero que es un buen ejemplo para empezar con Sdcc y desarrollar prototipos..


Aqui les dejo un video de este circuito.








Los Archivos lo pueden descargar en Box de este foro
http://www.box.net/shared/5eu8sxkrzv


Atte.
RiSanti.

Hola Risanti

lo que pasa es que yo soy estudiante de electronica, soy novato, y me pusieron de tarea elaborar un voltimetro digital, en internet encontre un monton pero ninguno como el tuyo yo estoy interesado en montarlo pero necesito la orientacion si me puedes ayudar te lo agradesco


cuando me refiero a ayudar es que me expliques como funciona a y un detalle la programacion que yo estoy aprendiendo es en asemble ASM muchas gracias

Hola jdhh, bienvenido al foro..

Mi no hay problema cualquier duda que tengas.. no dudes en preguntar.
Básicamente es es un circuito que sirve de ejemplo para ver la utilizacion del conversor analogo digital del PIc, para este circuito utilice el Pic16F88, basicamente porque posee oscilador interno y Conversor Analogo Digital de 10bit.


Este circuito lo puedes separar en dos parte una Que Corresponde Al Conversor Analogo a Digital y la otra la parte de Visualización.


El ADC.

Utilizo el la puerta RA0 del pic configurada para trabajar como conversor analogo digital de 10Bit con referencia desde Vcc del pic . es decir para transformar 0 a 50V en cuentas de 0 a 1023 las cuales representan, el voltaje aplicado en RA0, estas cuentas se alojan el el registro ADRESH y ADRESL. Para que se pueda trabajar con voltajes de entrada mas alto, se utiliza un simple divisor de tension compuesto por R1,R13 y R14. cuya mision es reducir el voltaje de entrara en una razon 10:1


Las resistencias R1=39K y R13 un pequeño pontenciometro de 10K, se deben ajustar para que ambas en serie midan 9 Veces lo que mide la R14.
Es decir.
Si R14= 4,7K , mide por ejemplo 4,65
Entonces R1+R13 debe medir =4,65*9 =41,85K
con estos se aseguras que cuando por ejemplo se ingresen 50V a la entrada del Multimetro hacia el RA0 del pic entrara 5V.

Cuando leas Los registro ADRESH y ADRESL del Pic y te de como resultado 1023, significa que en el RA0 hay 5V por lo tanto a la entrada del voltimetro hay 50V. y asi..

Para esto hay que transformar este numero 1023 en a un numero escalado de 0 a 500 el cual representa de 0 a 50v.
para lo cual y en lenguaje c es mas fácil.. se realiza lo siguiente.

void Determinar_Display ()
{
/*Determinar Valores para cada digito del Display*/

medida1=((medida*500)/1023) ;//Escalar Variable de 0 a 500
digito1=(medida1/100);
digito2=(medida1-(digito1*100))/10;
digito3= medida1-(digito1*100+digito2*10);
delay_ms(200);

}

Pero basicamente en 3 registros guardo el valor correpondiente a cada digito segun lo medido por el ADC.



La Visualización.

Esta formada por 3 display 7 seg. Anodo Común, multiplezados a través de tres transistores comandados desde RA1,RA2,RA3.. los cuales habilitan el display a mostras y todo el PuertoB para cargar el valor a mostrar en el display.

Básicamente lo que se hace aqui es engañar a la vista humana.. para hacer un efecto de que los 3 display estan encendidos al mismo tiempo, pero no enciende primero el display, luego el otro y luego el otro.. y asi sucesivamente, pero esto es bastante rapido..un par de milisegundos nada mas (cada 10ms si no me falla el calculo)...

Para poder Generar este tiempo se utiliza una interrupcion del Timer 0 del Pic configurado con un preescaler de 64 y un valor inicial de 150,y cada vez que se genera una interrupcion se muestra un digito.. habilitando el display correspondiente y cargado el valor en Portb segun el numero a Mostrar.



Este ejemplo lo hicen en Leguaje C. pero puede ser pasado en ASM, quiza la parte mas complicada es el tema de los calculos.
pero, cualquier cosa me avisas..

atte.
RiSanti

Risanti Hola, me gustó mucho de su voltímetro.
Hoy puedo dibujar el circuito impreso, porque la semana que viene llega la orden del PIC16F88 que hice.
Me pregunto si puedes leer la diatriba voltímetro.
En lugar de él puntuación 0 a 5,00 voltios.
Si sería posible sesgos puntuación de 500 voltios y la aplicación de voltaje a 5,00 que obtuvo 000.
Para montar el metro que es necesario que lo contrario, tendríamos una idea?
A través de hardware invertido ya en otro, pero genera una variación.
la inversión fue a través de software de foto sería más exacto.

cuando después mounting'll una foto aquí
silvanoservitec de Brasil

Risanti

Gracias por la orientacion ahora necesito que me orientes en cuanto la programacion del pic como ya lo dije antes la programacion que manejo es en ASM asemble si me puedes colaborar gracias

risanti necesito si no es mucha molesta que me aconsejes una pagina para aprender a programar en C ya que veo o pienso que te queda como dificil la programcion en ASM si me puedes colaborar con eso Gracias

Mi correo es jhonatanhernndez@iemontenegro.edu.co Gracias Y el Voltimetro no le hace si no falta la programacion ya lo monte y lo unico es eso Gracias de nuevo