Medida de distancias con SRF04

En realidad en este proyecto se emplea un sensor de distancias por ultrasonidos SRF05 pero funcionando en modo SRF04 con pulso trigger y eco por pines separados. El sensor SRF05 es una versión mejorada del clásico SRF04 con el que es compatible.

El PIC manda un pulso de al menos 10us por la linea “Pulso trigger” para comenzar el proceso de medida. El srf04 responde con un tren de 8 impulsos ultrasónicos a 40Khz. Pone su “Pulso eco” en estado alto hasta recibir el eco ultrasónico de los impulsos. La distancia al objeto estará en función del tiempo del pulso eco en un rango de 100us (mínima distancia medible) hasta 25 ms (máxima distancia medible). Si el sensor no recibe el eco ultrasónico pasa su salida eco a estado bajo a los 30ms.

Para calcular la distancia es necesario por tanto saber la duración del pulso eco mediante el modo captura del CCP2 del PIC configurandolo para que detecte los flancos de subida y bajada de la señal. Cada vez que esto ocurre el valor del timer1 pasa al registro del módulo CCP.

El valor numérico del pulso será el valor del timer1 en el pulso de bajada menos su valor en el flanco de subida del pulso:

TF=(TFB-TFS);

El valor numérico del registro se pasa a uS según la expresión:

tiempo = TF*1.0;

Y finalmente para pasar este valor de uS a su equivalente en cm:

distancia = tiempo/58;

Aquí se puede ver el programa completo en lenguaje c para el PIC.

[+/-] Ver / Ocultar programa en C

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

//                                                                            //

//                   MEDIDA DE DISTANCIAS CON SRF04                           //

//                                                                            //

//                        (c) RobotyPic 2010                                  //

//                                                                            //

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

#include <16F876A.h>

#fuses XT, NOWDT, NOPROTECT                   

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

#byte PIR1=0x0C

#byte trisa=0x85

#byte porta=0x05

#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>                 //Incluye uso del archivo para control del lcd

#define BIT_TEST_ON     output_high(PIN_C0)

#define BIT_TEST_OFF    output_low(PIN_C0)

/********************** 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 nuevopulso=0;            //Entra otro pulso de lectura

int16 TFB=0,TFS=0,TF=0;       //Tiempo flancos

float distancia=0.0;          //Valor distancia al obstáculo

int1 cambio=0;                //Control flanco subida o bajada del impulso leido

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

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

void pulso_test(){

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

   BIT_TEST_ON;                  //salida de pulso test durante 10us por Bit 0 puerto C

   delay_us(10);               

   BIT_TEST_OFF;

  

   while(nuevopulso==0)          //Espera a finalizar el pulso eco

      {}

     

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

      TF=(TFB-TFS);              //Valor entre pulso de subida y bajada.

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

      distancia = distancia/58;  //Distancia del obstáculo en cm

      nuevopulso=0;              //Listo para recibir nuevo pulso

      }

     

   disable_interrupts(INT_CCP2);

   }

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

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

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

void ccp2_int(){

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

      TFS=CCP_2;                   //Carga  en valor flanco subida valor registro ccpr1

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

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

   }

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

      TFB=CCP_2;                   //Carga  en valor flanco bajada valor registro ccpr2

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

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

     

      if(nuevopulso==0)             //Fin de pulso...

         nuevopulso=1;              //Pulso finalizado.

   }

}

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

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

void main(){

   trisb=0x00;                   //Puerto B todo salidas

   trisc=0b00000010;             //Puerto C definición de entradas y 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 srf04   ");

   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

   }

}

Según las especificaciones del sensor, el mínimo tiempo entre pulsos eco para la ejecución de la medida es de 50ms para evitar la lectura de ecos de medidas anteriores. En este proyecto se ha especificado 500ms, es decir, el refresco de la medida se ejecuta y muestra en el lcd cada medio segundo.

En este video se puede ver el funcionamiento.

Los archivos tanto del codigo fuente como del programa para cargar en el PIC así como el video demostrativo se pueden descargar del siguiente enlace:

Descargar medida de distancias con SRF04


A continuación se muestra una simulación utilizando el proyecto del SRF04 bajo proteus. Hay que dejar claro que se trata de una simulación, quiero decir, para simular los valores de distancia se emplean valores analógicos de tensión, pero puede ser de ayuda para verificar que nuestros diseños basados en el SRF04 funcionan.

En este enlace, la descarga de archivos para demostrar la simulación:

Descargar Simulacion medida distancias con SRF04