Medida de distancias con SRF05

A diferencia del artículo referente a la medida de distancias con el  SRF04 o SRF05 en modo de funcionamiento 1, en esta ocasión se va a emplear el sensor  de ultrasonidos SRF05 en el modo de funcionamiento 2, es decir, empleando el mismo pin como entrada del pulso de test y como salida para el pulso eco que nos dará la información de la distancia en función de su duración en tiempo.

Para conectar el sensor de ultrasonidos en este modo de funcionamiento,  el pin de “modo” (sin conectar en SRF04 o SRF05 modo 1) debe llevarse a 0v. De esta forma, el pin empleado para dar el pulso de test será el que nos ofrezca igualmente el pulso ECO.

El proceso consiste en un ciclo que se repite cada vez que se toma una nueva medida.

Traducido al código de programación del PIC, primero damos el pulso trigger o de disparo (mínimo 10 uS) con el pin RC1 (CCP2) como salida y deshabilitada la interrupción...

disable_interrupts(INT_CCP2); //Deshabilitación interrupción

                                modo comparación

trisc=0x00;                   //Puerto C todos los pines todo salidas

BIT_TEST_ON;                  //Comienzo del pulso de disparo

delay_us(10);                 //Tiempo del pulso de disparo   

BIT_TEST_OFF;                 //Fin del pulso de disparo

...e inmediatamente después se vuelve a configurar dicho pin como entrada y a habilitar la interrupción para detección de flanco...

trisc=0b00000010;            //Pin RC1 como entrada para lectura eco

PIR2=0;                      //Reset del flag de la interrupción

enable_interrupts(INT_CCP2); //Habilitación interrupción para medida de pulso eco

.. y se espera la lectura del pulso eco...

while(NuevoEco==0) {}

Como se ve, es imprescindible resetear el flag de interrupción mediante su puesta a cero (PIR2=0). Sino se hace, nos detectará interrupción por flanco de subida desde el mismo momento de habilitar la interrupción.

Cuando, esperando el flanco de subida del eco, se activa la interrupción, deberemos guardar el valor que en ese momento se carga en el registro CCP2, y memorizar que el próximo flanco será de bajada.

if(TipoFlanco==0){              //Si es flanco de subida...

    Contador_FS=CCP_2;          //Guarda el valor del registro CCP2

    setup_ccp2(CCP_CAPTURE_FE); //Modo captura en flanco de bajada

    TipoFlanco=1;               //Próximo flanco debe ser de bajada

}

Ahora, el programa continua esperando en la misma instrucción (While) en la que aguardaba a recibir el comienzo del pulso eco, hasta activarse de nuevo la interrupción, pero esta vez por la recepción del flanco de bajada. En ese mismo momento, volveremos a tomar el valor del registro CCP2. Además, memorizaremos que el pulso eco en curso ha finalizado y que por tanto, el próximo flanco será de subida por tratarse de un nuevo pulso eco.

 Contador_FB=CCP_2;                //Guarda el valor del registro CCP2

 setup_ccp2(CCP_CAPTURE_RE);       //Modo captura en flanco de subida

 TipoFlanco=0;                     //Próximo flanco debe ser de subida

 NuevoEco=1;                       //Pulso eco actual finalizado.

Al indicar que el pulso eco ha finalizado, salimos del bucle while y se continúa con la ejecución del programa para calcular, a partir de los valores leídos del registro CCP, el valor de la distancia al objeto. Primero obteniendo los incrementos totales producidos en el contador del registro CCP2 (Timer 1) desde el flanco de subida hasta el de bajada.

Contador_FT=(Contador_FB-Contador_FS); //Valor entre flanco de subida y bajada.

Ahora, si multiplicamos este numero de incrementos por el tiempo (en microsegundos) que tarda en producirse cada uno de ellos, obtendremos el tiempo total del pulso eco. En este caso, al emplearse un oscilador para el PIC de 4 MHz, el tiempo de cada incremento es de 1uS, por lo que se multiplicará por 1.0

T_PulsoEco=Contador_FT*1.0;   //Valor pulso leido en us de 100u a 25ms

Para saber el tiempo de cada incremento del contador en función del oscilador empleado, partimos de esta expresión:

T = Tcm * Preescaler 

Tcm es el ciclo máquina y que corresponde con 4 ciclos del oscilador (4/Frec.Reloj)

Preescaler es la escala empleada para el Timer1. En este caso Preescaler=1

T = (4/4.000.000) * 1 

De donde obtenemos que el tiempo T es de 1uS para una frecuencia de reloj de 4MHz.

Para obtener la distancia en centímetros en función del tiempo del eco, lo dividimos por 58.3

Distancia = T_PulsoEco/58.3;    //Distancia del obstáculo en cm

Esta constante es siempre fija y nos da el resultado en cm. La proporciona el fabricante del sensor en la hoja de características pero se podría obtener considerando la velocidad del sonido en el aire (340m/s) y que éste recorre el doble del espacio medido, puesto que dicho trayecto es de ida  y vuelta.

Finalizado el cálculo, volvemos a dejar el pin RC2 como salida y deshabilitamos temporalmente la interrupción para que no nos detecte el propio pulso de disparo. Y avisamos de que queda listo para una nueva media.

NuevoEco=0;                 //Listo para recibir nuevo pulso eco

disable_interrupts(INT_CCP2);

trisc=0b00000000;           //Pin RC1 como salida para nuevo disparo

[+/-] Ver / Ocultar programa completo en C

////////////////////////////////////////////////////////////////////////////////

//                                                                            //

//                   MEDIDA DE DISTANCIAS CON SRF05                           //

//                                                                            //

//                        (c) RobotyPic 2013                                  //

//                                                                            //

////////////////////////////////////////////////////////////////////////////////

#include <16F876A.h>          //Libreria C del PIC a emplear

#fuses XT, NOWDT, NOPROTECT   //Configuraciones                    

#use delay(clock=4000000)     //Frecuencia del cristal oscilador 4MHz

#byte PIR2=0x0D               //Configuración del flag de la interrupción

#byte trisb=0x86

#byte portb=0x06

#byte trisc=0x87

#byte portc=0x07

#define use_portb_lcd TRUE       //Configuración del puerto b para uso del lcd

#include <lcd.c>                 //Libreria C para control del lcd

#define BIT_TEST_ON     output_high(PIN_C1)

#define BIT_TEST_OFF    output_low(PIN_C1)

/********************** Prototipos de las funciones ***************************/

void main (void);             //función principal

void pulso_test (void);       //da pulso y calcula distancia al objeto

void ccp2_int(void);          //captura del pulso de eco

/******************** Variables para lectura distancia ************************/

int1 NuevoEco;                //Entra otro eco para lectura

int16 Contador_FB;            //Contador hasta flanco de bajada

int16 Contador_FS;            //Contador hasta flanco de subida

int16 Contador_FT;            //Cuenta entre flancos

float T_PulsoEco;             //Tiempo de duración del pulso eco

float Distancia;              //Valor distancia al obstáculo

int1 TipoFlanco=0;            //Control flanco subida (0) o bajada (1) del eco 

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

/*********************** FUNCIÓN PULSO DE TEST ********************************/

void pulso_test(){

   

   /** salida de pulso de disparo durante 10us por el pin RC1 **/

   BIT_TEST_ON;                  //Comienzo del pulso de disparo

   delay_us(10);                 //Duración del pulso               

   BIT_TEST_OFF;                 //Fin del pulso de disparo

   

   /** cambio al modo de detección del pulso eco **/

   trisc=0b00000010;             //Pin RC1 como entrada para lectura eco

   PIR2=0;                       //Reset del flag de la interrupción

   enable_interrupts(INT_CCP2);  //Habilitación interrupción para medida de pulso eco

   

   /** espera hasta que finalice el pulso eco **/

   while(NuevoEco==0) {}

      

  /** cálculo de la distancia en función del tiempo de pulso eco medido **/

   if(NuevoEco==1){            //Finalizado el pulso eco se calcula su valor.

      Contador_FT=(Contador_FB-Contador_FS); //Valor entre flanco de subida y bajada.

      T_PulsoEco=Contador_FT*1.0;           //Valor pulso leido en us de 100u a 25ms

      Distancia = T_PulsoEco/58.3;          //Distancia del obstáculo en cm

      disable_interrupts(INT_CCP2);

      trisc=0b00000000;                     //Pin RC1 como salida para nuevo disparo

      NuevoEco=0;                           //Listo para recibir nuevo pulso eco

   }

} 

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

/************************ FUNCIÓN LECTURA OBSTÁCULO ***************************/

#int_ccp2                           //LLamada por interrupción flanco en RC1

void ccp2_int(){

   if(TipoFlanco==0){               //Si es flanco de subida...

      Contador_FS=CCP_2;            //Guarda el valor del registro CCP2

      setup_ccp2(CCP_CAPTURE_FE);   //Configuración modo captura en flanco de bajada

      TipoFlanco=1;                 //Próximo flanco debe ser de bajada

   }

   else {                           //Si es flanco de bajada...

      Contador_FB=CCP_2;            //Guarda el valor del registro CCP2

      setup_ccp2(CCP_CAPTURE_RE);   //Configuración modo captura en flanco de subida

      TipoFlanco=0;                 //Próximo flanco debe ser de subida

      NuevoEco=1;                   //Pulso eco actual finalizado.

   }

}

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

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

void main(){

   trisb=0x00;                   //Puerto B todo salidas

   trisc=0x00;                   //Puerto C todo salidas

   setup_timer_1(T1_INTERNAL);      //Configuración timer1 para lectura objeto

   setup_ccp2(CCP_CAPTURE_RE);  //Configuración modo captura en flanco de subida

   

   disable_interrupts(INT_TIMER1);

   disable_interrupts(INT_CCP2); //Deshabilitación interrupción modo comparación

   enable_interrupts (GLOBAL);

   

   lcd_init();                       //Inicialización de la pantalla lcd

   printf(lcd_putc, "\fMedida distancia");

   printf(lcd_putc,"\n   con srf05   "); 

   delay_ms(2000);               

   printf(lcd_putc,"\f (c) RobotyPic ");

   delay_ms(2000);

      

   while (1){

      pulso_test();                                //Envío del pulso ultrasónico

      printf(lcd_putc,"\fDistancia=%5.2f", Distancia);

      delay_ms(500);                               //Refresco de la medida

   }

}

    

En la animación se mestra el funcionamiento empleando el simulador del SRF05 para proteus.

Todos los archivos del proyecto en este enlace de descarga:

Descargar Medida de distancias con SRF05

El proyecto contenido en el artículo ha sido diseñado con la versión v4.084 de CCS PIC C COMPILER

Si necesitas comprar el sensor SRF05, puedes hacerlo online pulsando aquí.

Última revisión del artículo: Agosto 2013