Práctica 11 con Miuva. Sensor ultrasónico con PIC C

Los sensores ultrasónicos son utilizados para calcular la distancia a la que se encuentra un objeto, su funcionamiento es muy sencillo, envían una onda ultrasónica y espera hasta que esta rebote con el objeto y regrese al sensor.

En esta práctica entenderemos como utilizar Miuva para obtener información de un sensor ultrasónico y mostrar en la LCD la distancia a la que se encuentra un objeto.

El sensor tiene dos pines para su funcionamiento: Echo y Trigger

El trigger será un pin donde nosotros enviaremos un pulso para activar el sensor, esto quiere decir que al recibir en ese pin nuestro pulso el sensor enviará la onda ultrasónica y el echo se encargará de avisarnos cuando la onda haya regresado el sensor, será nuestra responsabilidad medir el tiempo que tardó la onda en ir y regresar. Posteriormente utilizaremos una fórmula muy sencilla:

v = d/t

Dónde v es velocidad, d es distancia y t es tiempo.

Como queremos calcular la distancia a la que se encuentra el objeto tendremos que despejar:

d  = t * v

Sin embargo cabe resaltar que el tiempo que tarda en avisarnos el sensor es el tiempo que tarda la onda en ir y regresar al objeto, por lo tanto la información que nos interesa será la mitad de ese tiempo para solo considerar el tiempo de ida. Entonces la fórmula que utilizaremos será:

d = (1/2) * t * v

La velocidad será igual a la velocidad del sonido (360 m/s = 34 cm/ms) por que es una onda ultrasónica.

Ya sabemos como convertiremos el tiempo que recibamos en la distancia a la que está el objeto, pero ahora queda una pregunta ¿cómo calcularemos ese tiempo?

Calcular el tiempo

Primero es importante como será el funcionamiento un poco más a detalle del sensor, en las especificaciones nos indica que para que envíe la onda tenemos que enviar un pulso que dure 10 microsegundos al pin Trigger. Posteriormente a esto el Echo se pondrá en “Alto” al momento de enviar el pulso y se pondrá en “Bajo” al momento de que el pulso haya regresado. Por lo tanto tendremos que basarnos en el flanco de subida y de bajada respectivamente del Echo. Con esto ya sabremos cuando envío el pulso y cuando lo recibió, pero falta lo importante, ¿cuánto tiempo tardó?, si recordamos los recursos que tiene nuestro PIC sabemos que tenemos timers que lo que hacen es estar contando, entonces si sabemos a que velocidad cuentan y sabemos hasta que número contaron, podremos saber cuanto tiempo ha pasado.

Para esto podemos seguir los siguientes pasos.

1. Enviar el pulso de 10 microsegundos

output_high(Trigger);
delay_us(10);
output_low(Trigger);

2. Esperar el flanco de subida y activar el timer

while(!input_state(Echo)){
   } //espera flanco de subida
   set_timer1(0);

3. Esperar el flanco de bajada y leer el valor del timer

while(input_state(Echo)){
} //esperamos flanco de bajada
tiempo_eco = get_timer1();

4. Convertirlo a distancia

Para esta conversión es importante conocer la configuración que estamos utilizando para nuestro timer y el oscilador con el que estamos trabajando, por ejemplo, si la velocidad del oscilador es de 48MHz y el timer tiene un prescaler de 8. El tiempo que tarda en avanzar el timer será dado por:

tiempo = (4/Fosc)*prescaler = (4/48M)*8 = 0.000666 ms

Entonces si tenemos en cuenta la fórmula dada anteriormente, tendremos que:

d = (1/2) * (tiempo [ms] * timer) * 34 [cm/ms]

distancia = (tiempo_eco/2)*.000666*34;

#include <18f4550.h>
#Fuses HSPLL, NOWDT, NOPROTECT, NOLVP, NODEBUG, USBDIV, PLL2, CPUDIV1, VREGEN
#use delay (clock=48M)         //Seleccionamos la frecuencia de reloj de 48MHz
#include  <MLCD.c> 
#include <math.h>       //LIBRERÍA DE MATEMÁTICAS
#use standard_io(B)     //PRECONFIGURACIÓN DEL PUERTO B
#define Echo PIN_B7
#define Trigger PIN_B6
//PROTOTIPO DE FUNCIÓN PARA MEDIR DISTANCIA
void mide_distancia(void);    
long tiempo_eco=0;  //tiempo que dura el eco
float  distancia=0;   //distancia en cm
void main(void){  
   //TICK=(4/Fosc)*Prescaler---->TICK=(4/48000000)*8=0.000666ms
   setup_timer_1(T1_INTERNAL | T1_DIV_BY_8); //Config del timer1
   lcd_init();                   //Inicializa LCD
   delay_ms(50);                 //Esperamos 50ms
   lcd_putc("f");               //Borra la pantalla
   lcd_gotoxy(1,1);              //Cursor en la posicion columna 1 fila 1
   lcd_putc("Sens Ultrasonico"); //Escribimos en la lcd
   while(true){                  //Ciclo infinito
      mide_distancia();          //Llamamos la función mide_distancia()
      delay_ms(30);              //Esperamos 30ms
   }  
}   
void mide_distancia(void){       //Función mide_distancia
   output_high(Trigger);         // pulso de disparo
   delay_us(10);                 //Esperamos 10 us
   output_low(Trigger);          //Apagamos el pulso
   while(!input_state(Echo)){
   }                             //espera flanco de subida
   set_timer1(0);                //Iniciamos el timer1
   while(input_state(Echo)){
   }                             //esperamos flanco de bajada
   tiempo_eco = get_timer1();    //Leemos el valor del timer1
   distancia = (tiempo_eco/2)*.000666*34; //Convertimos a distancia
   lcd_gotoxy(1,2);              //Cursor en la posicion columna 1 fila 2
   printf(lcd_putc,"nDist: %1.2f cm", distancia); //Imprimimos la distancia
   delay_ms(200);                //Esperamos 200ms
}

Funcionamiento