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: http://pic-linux.foroactivo.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 http://pic-linux.foroactivo.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.