Modo de funcionamiento:

Para hacer una lectura con el HC-SR04 basta con seguir estos pasos:

1) enviar un pulso de mínimo 10us por el pin TRIG (disparo) para iniciar la lectura.

2) el sensor enviara 8 pulsos de ultrasonido y colocara su salida ECHO a alto,

debes detectar este evento e iniciar un "conteo de tiempo"

3) la salida ECHO se mantendrá en alto hasta recibir el eco reflejado por el

obstáculo a lo cual el sensor pondrá su pin ECHO a bajo, es decir, terminas de
"contar el tiempo"

4) La distancia es proporcional a la duración del pulso y puedes calcularla con las

siguientes formulas:

Distancia en CM = tiempo medido en us * 0.0167

Distancia en PULGADAS = tiempo medido en us * 0.00675

Nota: si la duración del pulso es mayor a 30ms entonces asumes que no hay
obstáculo.

Este es el diagrama de tiempos:

EJEMPLO

Naturalmente usaremos un PIC para manejar el sensor, el compilador que utilizaremos es PICC
Compiler de CCS, el PIC utilizado puede ser cualquiera de tu preferencia, la cabecera del programa
no la pondré porque puedes usar el PIC que tú quieras, esa es la ventaja de PICC, la portabilidad de
código.

Empezamos, lo mejor desde mi punto de vista es diseñar una función que se encargara de la
lectura del sensor, esta función deberá ir fuera y antes de la función MAIN. Lo primero es definir
los pines de nuestro sensor

#define trig pin_c6

#define echo input(pin_c7)

Renombrar pines facilita el entendimiento posterior del código y además permite que cambies los
pines que vas a usar con simplemente modificar las lineas de codigo anteriores en lugar de
buscarlas y modificarlas dentro del codigo.

Muy bien, sabemos que el sensor puede llegar a medir hasta 500cm, por lo cual nuestra
funcion tendra un DATO DE SALIDA del tipo long unsigned ya que sobrepasa los 255 de
una variable unsigned normal, asi que nuestra funcion comienza con un int16:

int16 mide_distancia(void){
int16 centimetros; // creamos una variable local para los centimetros medidos
//codigo para medicion de distancia...

ahora comienza la secuencia, si recuerdas habremos de enviar un pulso de almenos 10us

por el pin TRIG, yo le puse 50us para no fallar:

output_high(trig); // pulso de disparo

delay_us(50);
output_low(trig);

luego hay que esperar el pulso del pin echo que de inicio esta en cero, asi que usaremos un while
que espera mientras el pin echo este en cero y continuara cuando el pin este en 1:

while(echo==0); //espera flanco de subida

Muy facil verdad, ahora comienza la medicion de la distancia, usaremos un ciclo while que
incrementa cada 60us la variable centimetros mientras el pin echo sea = uno. Los 60us es el
tiempo aproximado que tarda en viajar el sonido 2cm osea 1cm ida y vuelta:

while(echo==1){
centimetros++;
delay_us(58);
}

Este while termina cuando el pin echo a ido a cero, es decir ya termino la lectura, asi que
terminamos con una demora de 50ms, tiempo sugerido por el datasheet del sensor y
retornaremos con el valor de los centimetros medidos:

delay_ms(50);
return(centimetros);
}// fin de la funcion "mide_distancia"

Nuestra funcion completa queda entonces de la siguiente manera:

#define trig pin_c6

#define echo input(pin_c7)

int16 mide_distancia(void){
int16 centimetros=0;
//pulso de disparo:
output_high(trig);
delay_us(50);
output_low(trig);
//espera flanco de subida por el pin echo
while(echo==0);
//comienza a contar centimetros hasta que pin echo sea cero
while(echo==1){
centimetros++;
delay_us(58);
}
//demora de seguridad y retorna con el valor de centimetros contados
delay_ms(50);
return(centimetros);
}

Recuerda que esta funcion habra de ir afuera y antes de la funcion MAIN, un ejemplo de uso seria
asi: Hacer un medidor de distancia con sensor ultrasonico y un lcd que marque la distancia en CM
y tenga un led que enciende cuando hay una lectura valida y apaga cuando no hay una lectura
valida o no haya objeto:

//********************************************************************
// Cabecera del programa, depende del pic que uses
//********************************************************************

//********************************************************************
// Funcion de mide distancia de sensor ultrasonico#define trig pin_c6
#define echo input(pin_c7)

int16 mide_distancia(void){
int16 centimetros=0;
//pulso de disparo:
output_high(trig);
delay_us(50);
output_low(trig);
//espera flanco de subida por el pin echo
while(echo==0);
//comienza a contar centimetros hasta que pin echo sea cero
while(echo==1){
centimetros++;
delay_us(58);
}
//demora de seguridad y retorna con el valor de centimetros contados
delay_ms(50);
return(centimetros);
}
//********************************************************************

//********************************************************************
// Funcion principal del programavoid main( void ){
int16 distancia;
int8 i;
lcd_init(); // inicializa lcd

while (true){ // lazo infinito

distancia=mide_distancia(); // AQUI USAMOS NUESTRA PODEROSA FUNCION!!!

lcd_gotoxy(1,1);
if(distancia>500){ // si lectura > 500cm entonces no es valida, osea no hay objeto
lcd_putc('\f'); // Borra LCD
printf(lcd_putc,"NO DETECTED!");
output_low(pin_c0);
}
else{ // si distancia fue < 500cm es una distancia valida y la imprime en LCD
printf(lcd_putc,"%03lucm ",distancia);
output_high(pin_c0);
}
}// cierra lazo infinito

}// cierra main

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

*************************************************************
COMENARIOS SOBRE EL PROGRAMA DE EJEMPLO:
Este codigo de ejemplo tiene sus ventajas y sus desventajas, la gran ventaja es que es todo por
software por lo que no consume recursos de TIMERS del PIC.

La desventaja es que el tiempo de medicion de centimetros puede variar ya que depende de la

velocidad del PIC que estas trabajando, esto se refleja en que mide cm mas grandes, esto se
resuelve disminuyendo el valor del DELAY_US(58); hasta el valor que se ajuste a los cm reales.
**************************************************************

Información sacada de: http://campos-inventronica.blogspot.com/2012/04/como-usar-sensor-

ultrasonico-hc-sr04.html
La variable t, tiene el tiempo que dura en llegar el eco del ultrasonido, el siguiente paso es
calcular la distancia entre el sensor ultrasónico y el objeto

Partimos de la siguiente formula:

Donde Velocidad es la velocidad del sonido 340m/s, pero usaremos las unidades en cm/us
pues trabajaremos en centímetros y microsegundos, tiempo es el tiempo que demora en llegar
el ultrasonido al objeto y regresar al sensor, y la distancia recorrida es dos veces la distancia
hacia el objeto, reemplazando en la formula tenemos:

Finalmente enviamos serialmente el valor de la distancia y terminamos poniendo una pausa

de 100ms, que es superior a los 60ms recomendado por los datos técnicos del sensor