Circuito simulador SRF04 y SRF05 para Proteus

Muchas veces tenemos necesidad de simular circuitos bajo proteus pero hay componentes que no están disponibles. En este artículo se muestra como realizar un pequeño circuito gráfico para sustituirlo en los diseños como componente SRF04 o SRF05 mediante un procesador PIC16f876a programado con el compilador CCS. El objetivo es poder insertarlo en los diseños con Proteus para poder simular circuitos.

Mediante la variación de un potenciómetro se simula la distancia. Y se obtiene un ancho de pulso proporcional, siempre tras recibir un pulso de test tal y como lo haría el componente SRF04 o SRF05 en la realidad.

El componente SRF05 es un versión mejorada del SRF04 que permite la opción de utilizar el mismo pin para las señales de test y pulso de eco. En primer lugar consideraremos el SRF04 o SRF05 en modo 1, es decir, ambos pines independientes.

En el esquema de la simulación mostrado la entrada de generador de pulsos se sustituiría por la salida en el PIC que pediría la medida de distancia al SRF04. Y la señal de salida se llevaría a una entrada del PIC para medir el ancho de pulso y en consecuencia la distancia.

Aquí se puede ver las señales obtenidas en la simulación.

Y el esquema en Proteus.

Pulsa en la imagen para ampliarla

Este sería el programa del PIC para el compilador CCS.

[+/-] Ver / Ocultar programa en C

#include <16F876a.h>                     //Driver del pic


#device adc=10                           //Configuración conversor AD a 10 bits
#fuses XT, NOWDT
#use delay (clock=4000000)


#byte trisb=0x86
#byte portb=0x06


#use standard_io(a)
#use standard_io(c)


#bit triger = PORTB.0                 //Bit 0 puerto B entrada petición distancia
#bit bit_eco = portb.1                //Bit 1 puerto B salida señal eco


#priority rtcc


/******************** Variables para lectura valor analógico ******************/


float val_dig;                //Guardará el valor digital de tensión entrada
float val_ana;                //Guardará el valor de la tensión entrada analógico


/********************** Variables para generación eco *************************/


int8 eco=0;         //Guardará valores de las señales eco en función de distancia
int8 Ancho_pulso=0;                      //Anchura pulso eco
int1 i=0;


/******************************************************************************/
/************************ FUNCIÓN GENERACIÓN PULSOS ***************************/

#int_Timer0
void Generacion_eco()
      {
      Ancho_pulso++;


      if (Ancho_pulso==1)
                bit_eco=1;


     if (Ancho_pulso==eco)
                bit_eco=0;


      set_timer0(0);
      }


/*******************************************************************************/
/****************** LECTURA PULSO DE CONTROL ***********************************/


#int_ext
void entrada_pulso ()
     {
     i=1;
     delay_ms(20);
     bit_eco=1;
     }


/*******************************************************************************/
/**** FUNCIÓN LECTURA ENTRADA CONVERSION AD (Simulación distancia) *************/

#int_timer1
void timer0_int()
     {
     val_dig=read_adc();            //Lectura canal analógico
     val_ana=(5.0*val_dig/1024.0);
     eco=((val_dig*255)/1024);      //valor de 10 bits conversor lo paso a 8 bits
     }


/*******************************************************************************/
/*************************** FUNCIÓN PRINCIPAL *********************************/


void main()
    {
    trisb=0x01;       //Configuración puerto B como salida y bit RB0 como entrada
    port_b_pullups(true);


/*********************** Configuración Interrupciones *************************/


    setup_adc_ports(AN0);                        //Canal de entrada analógico AN0
    setup_adc(ADC_CLOCK_INTERNAL);               //Fuente de reloj RC
    set_adc_channel(0);
    setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); //Config. timer1 para conversión AD
    setup_timer_0(RTCC_INTERNAL | RTCC_DIV_8);  //Configuración timer0 para eco


/*********************** Habilitación Interrupciones *************************/


    enable_interrupts(int_ext);     //habilitar Rb0 para lectura pulso triger...
    ext_int_edge(H_TO_L);           //...por flanco de bajada
    enable_interrupts(INT_TIMER1);//Habilitar interrupción timer1 para lectura AD
    enable_interrupts(global);


/****************************************************************************/


     while(true)
        {
        if(i==1)
           {
           Ancho_pulso=0;
           enable_interrupts(INT_TIMER0);


           do
              { }
           while (bit_eco==1);
           disable_interrupts(INT_TIMER0);
           i=0;
           }
        }
/****************************************************************************/
     }

Y esta una animación que muestra la simulación.

El otro de los casos sería el SRF05 en modo 2, es decir, un único pin para la señal de disparo o pulso de test y el pulso de eco proporcional a la distancia medida.

Pulsa en la imagen para ampliarla

En la simulación se puede comprobar como la señal de test y eco comparten el mismo pin.

[+/-] Ver / Ocultar programa en C

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
//                 SIMULADOR SRF05 CON PIC PARA PROTEUS                       //
//                                                                            //
//                        (c) RobotyPic 2011                                  //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////

#include <16F876a.h>    //Driver del pic
#device adc=8          //Configuración conversor AD a 8 bits
#fuses XT, NOWDT
#use delay (clock=4000000)

#byte trisb=0x86
#byte portb=0x06

#use standard_io(a)
#use standard_io(c)
#bit  bit_eco = portb.0    //Bit 0 puerto B salida señal eco
#priority rtcc

/******************** Variables para lectura valor analógico ******************/

float val_dig;             //Guardará el valor digital de tensión entrada
float val_ana;             //Guardará el valor de la tensión entrada analógico

/********************** Variables para generación eco *************************/

int8 eco=0;    //Guardará los valores de las señales eco en función de distancia
int8 Ancho_pulso=0;  //Anchura pulso eco
int1 i=0;

/******************************************************************************/
/******************* FUNCIÓN GENERACIÓN PULSOS ********************************/

#int_Timer0

void Generacion_eco() {
   Ancho_pulso++;
   if (Ancho_pulso==eco){
      bit_eco=0;
      disable_interrupts(INT_TIMER0);
   }
     
   set_timer0(0);       
}
  
/******************************************************************************/
/************************* LECTURA PULSO DE CONTROL ***************************/

#int_ext

void entrada_pulso (){
   i=1;
   delay_ms(10);
   disable_interrupts(int_ext);
   trisb=0x00;       //Configuración RB como salida
   bit_eco=1;
   enable_interrupts(INT_TIMER0);
}
  
/******************************************************************************/
/****  FUNCIÓN LECTURA ENTRADA CONVERSION AD (Simulación distancia) ***********/

#int_timer1            

void timer0_int() {
   val_dig=read_adc();                    //Lectura canal analógico
   val_ana=(5.0*val_dig/1024.0);
   eco=val_dig;
   }
  
/******************************************************************************/   
/*************************** FUNCIÓN PRINCIPAL ********************************/

void main(){
  
   trisb=0b00000001;       //Configuración puerto B como entrada

/*********************** Configuración Interrupciones *************************/

   setup_adc_ports(AN0);                        //Canal de entrada analógico AN0
   setup_adc(ADC_CLOCK_INTERNAL);               //Fuente de reloj RC
   set_adc_channel(0);
   setup_timer_1(T1_INTERNAL|T1_DIV_BY_8); //Configuración timer1 para conver. AD
   setup_timer_0(RTCC_INTERNAL|RTCC_DIV_2);     //Configuración timer0 para eco
  
/***********************  Habilitación Interrupciones *************************/
     
   enable_interrupts(int_ext);  //habilitar Rb0 para lectura pulso triger...
   ext_int_edge(H_TO_L);           //...por flanco de bajada
   enable_interrupts(INT_TIMER1); //Habilitar interrupción timer1 para lectura AD
   enable_interrupts(global);

/******************************************************************************/

   while(true){  
        if(i==1)
            {
            Ancho_pulso=0;

            do
               {}
            while (bit_eco==1);
            enable_interrupts(int_ext);
            trisb=0xff;   //Configuración bit RB0 como entrada
            i=0;
            }
   }
    
/******************************************************************************/     
 }   

Todos los archivos; fuente para ccs, esquemas para proteus y animaciones demostrativas se pueden descargar del siguiente enlace:

Simulacion-SRF04-SRF05

El proyecto contenido en el artículo ha sido diseñado y probado con éxito utilizando las siguientes versiones de software:
Windows xp y windows 7
Proteus V7.7 SP2
CCS PIC C COMPILER v4.084

TUTORIAL BÁSICO PIC C COMPILER

Compilar los archivos fuente

Una vez creado el archivo y guardado en una ubicación para compilarlo deberemos, desde la pantalla de edición del archivo fuente clicar sobre el símbolo que representa a una carpeta de la esquina superior izquierda. Posteriormente sobre <New> y <Project Manual>.

Se nos abrirá una nueva ventana donde deberemos ir a la ubicación del archivo fuente previamente guardado. Una vez seleccionado se clica <Abrir>.

Aparece otra ventana. En el lado izquierdo aparecen varias pestañas. Clicando en la pestaña “Include Files” nos deberá aparecer las ubicaciones de las carpetas “Devices” y “Drivers” del directorio de instalación del compilador. Estas carpetas se añaden automáticamente al instalar el programa pero si no aparecen o la ubicación es errónea, habrá que indicar las rutas correctas. Hay que tener en cuenta que un archivo fuente creado con un sistema operativo Windows xp por ejemplo, al volver a compilarlo en otro sistema operativo, Windows 7 por ejemplo, las rutas de dichas carpetas indicadas pueden no ser las mismas.

Verificadas dichas rutas a sendas carpetas si hacemos algún cambio lo confirmaremos con  <Apply>. Se nos cerrará esta ventana por lo que deberemos realizar el mismo proceso para volver a acceder a este mismo punto y continuar con el proceso de compilación. Una vez alcanzado de nuevo, accederemos a la pestaña <Files>. Indicaremos la ubicación del archivo fuente guardado. Y desde el desplegable de la zona superior elegimos el PIC utilizado. Con <Apply> confirmamos y se nos cerrará la ventana.

Ahora accedemos a la pestaña “Compile” del menú superior del compilador y clicamos la opción <Build All>.  El código comenzará a compilarse. Cuando desaparece la ventana del proceso de compilación, si el programa no tiene errores de programación aparecerá en el margen inferior  la indicación “0 errors”. Si es así, el programa se habrá compilado correctamente  aunque aparezcan advertencias “Warnings”. Estas últimas no impiden la correcta ejecución del programa, son solo eso, advertencias o avisos. Por el contrario, si aparecen errores, el programa no se habrá compilado.

Se añade esta animación donde se muestra todo el proceso: