El sensor de ultrasonido funciona como un sonar, emite un pulso de ultrasonido por un tiempo de disparo, y luego mide el tiempo de retorno del eco.

El diagrama muestra el concepto a ser aplicado:

Conversión de tiempor dt_Echo a distancias

La velocidad del sonido en el aire es de 343.2 m/s a 20°C y 50% de Humedad.

Referencia:  https://es.wikipedia.org/wiki/Velocidad_del_sonido

Usando la fórmula básica de velocidad se tiene que:

\text{velocidad del sonido} = \frac{\delta x}{\delta t} = 343.2\text{ }m/s \delta x = 343.2\text{ }\delta t

Para convertir los tiempos a distancias, considere que el recorrido del pulso es de ida y vuelta, por lo que la distancia del dispositivo al objeto será la mitad.
Considere además que la fórmula está dada en convertirla a segundos y los datos estan en μs

\delta t = \frac{Echo}{2} \frac{1\text{ }s}{1000000\text{ }\mu s}

aplicando lo anterior, y convirtiendo a cm

\delta x = \Big[ 343.2 \frac{m}{s} \frac{100\text{ }cm}{1\text{ }m} \Big] \Big[ \frac{Echo}{2} \frac{1\text{ }s}{1000000\text{ }\mu s} \Big]

se obtiene la fórmula a usar en cm:

distancia = 0,01716 \text{ } Echo

Desarrollo del concepto

Se desarrolla el concepto en dos partes:

• En arduino se realizan las lecturas de echo del sensor de ultrasonido, los datos se envian al computador por puerto serial (USB)
• Los dados se procesa en la computadora con Python, fórmulas, conversión de unidades, gráficas, etc.

 Lecturas de datos en Arduino

En la parte de Arduino se usan los siguientes componentes:

• Arduino UNO con cable USB
• Sensor de ultrasonido HC-SR04
• Cables de Conexión (4 hembra macho)

El arduino envía al computador los tiempos de recorrido del PULSO en μs.

La recepción de datos en la computadora en forma Serial se detallan las secciones con Python:

Serial – Envia y Recibe texto
http://blog.espol.edu.ec/edelros/serial-envia-y-recibe-texto/
Serial – Lectura datos
http://blog.espol.edu.ec/edelros/serial-lectura-datos/

Sensor  HC-SR04

El dispositivo HC-SR04 se opera como un dispositivo que requiere alimentación (Vcc y GND), una señal de disparo del pulso (Trigger) y una señal para la lectura del eco (Echo).

La duración del pulso se controla con tpulsoON, y el tiempo de apagado con tpulsoOFF, se usa un tiempo adicional dt_apaga, para asegurarse que no exista interferencia entre el apagado del pulso y la lectula del retorno del eco.

La conexión del dispositivo con el Arduino como controlador, se realiza por medio de los pines indicados en el script.

/* Sensor de ultrasonido HC-SR04
 *  Válido con objetos distantes entre 2 y 400 cm (aproximado)
usado para medir tiempo de returno de un pulso
            __________ 
____________| PULSO  |___
tpulsoOFF   tpulsoON  dt_apaga

dt_Echo e el tiempo de retorno del PULSO
los tiempos son en microsegundos
Los datos se envian por Serial para procesar en Python
 * http://blog.espol.edu.ec/edelros/sensor-ultrasonido-hc-sr04/
 */

// Disparo del PULSO, Trigger
int TriggerPin = 12;
int tpulsoON = 15;
int tpulsoOFF = 2000;

// Sensor del Retorno del PULSO, Echo
int EchoPin = 11;
int dt_apaga = 10;

// tiempo de retorno Echo
float dt_Echo;

void setup() {
  Serial.begin(9600);
  pinMode(TriggerPin, OUTPUT);
  pinMode(EchoPin, INPUT);
}
 
void loop(){
    // tiempo entre PULSOs: tpulsoOFF
    digitalWrite(TriggerPin, LOW);
    delayMicroseconds(tpulsoOFF);
    // Dispara PULSO de duración: tpulsoON  
    digitalWrite(TriggerPin, HIGH);
    delayMicroseconds(tpulsoON); 
    digitalWrite(TriggerPin, LOW); 
    delayMicroseconds(dt_apaga);  
    
    // Lectura sensor pulso: tiempo de echo 
    dt_Echo = pulseIn(EchoPin, HIGH);  
    Serial.println(dt_Echo);
    delay(10);
}

Referencia

https://www.arduino.cc/en/tutorial/ping

https://create.arduino.cc/projecthub/FunguyPro/how-to-use-an-hc-sr04-ultrasonic-sensor-with-arduino-8d646f

---

Procesamiento de datos en Python

El arduino envía al computador los tiempos de recorrido del PULSO en μs, se usa la fórmula para encontrar la distancia en cm:

distancia = 0,01716 \text{ } dtEcho

La lectura y aplicación de fórmula en Python tiene como resultado por ejemplo de 12 cm:

12.149280000000001
11.72028
12.13212
11.806080000000001
12.13212
11.703120000000002
11.703120000000002
12.217920000000001
11.788920000000001
11.685960000000001
11.668800000000001

Nota: La medición se realizó sosteniendo con la mano el sensor apuntando al una superficie plana, por lo que se muestran variaciones en la lectura. Realizar sus propias mediciones al respecto en superficies fijas, y con el sensor fijo a un soporte.

En caso de realizar una gráfica de los datos recibidos, se crea un vector datos, con tamaño "ventana" para graficar los puntos.

# Datos desde puerto Serial
# generados desde arduino

import serial, time

# INGRESO
puerto = 'com10'
baudios = 9600
ventana = 20 # tamaño ventana datos
datos=[] # vector para graficar

# PROCEDIMIENTO
arduino = serial.Serial(puerto, baudios)
arduino.setDTR(False)
time.sleep(0.3)

# limpia buffer de datos anteriores
arduino.flushInput()  
arduino.setDTR()  
time.sleep(0.3)
print('\nEstado del puerto: ',arduino.isOpen())
print('Nombre del dispositivo conectado: ', arduino.name)
print('Dump de la configuración:\n ',arduino)
print('\n###############################################\n')

# Lectura de datos
while True:
    #esperar hasta recibir un dato
    while (arduino.inWaiting()==0):
        pass
    
    # leer linea desde puerto serial
    lectura = arduino.readline()
    # binario a texto, elimina /r/n
    texto = lectura.decode().strip()
    valor = float(texto)

    # Aplica fórmula
    valor = 0.01716 *valor

    datos.append(valor)
    
    # mantiene el tamaño "ventana" de datos 
    if (len(datos)>=ventana):
        datos.pop(0)
    print(valor)
    
# Cerrar el puerto serial.
serial.Serial.close

El barrido del radar se realiza usando un motor servo controlando el ángulo de posición. Luego de un tiempo dt, se avanza un poco el ángulo entre un rango [a,b], al llegar a los límites se invierte el sentido del movimiento.

Los componentes para implementar el barrido son:

• Arduino UNO con cable USB para PC
• Servo
• cables de conexión

Los dispositivos se pueden conectar para pruebas directamente al arduino, se puede usar un proto, o usar las conexiones de los pines de la parte central para alimentación del motor.

Para el caso de motores, servos, se prefiere alimentar al motor con una fuente externa. Se dió el caso que usando un arduino uno genérico, al usar juntos el ultrasonido y el servo, se obtenían lecturas erroneas del ultrasonido, al desconectar el motor, las lecturas volvían a la normalidad. En consecuencia, hacía falta energía para alimentar los dos dispositivos. Recuerde las limitaciones de corriente en el arduino.

Instrucciones Arduino

Las instrucciones en Arduino para controlar el servo propuestas son:

/* Servo - Barrido entre[a,b]
* Se usa un tiempo de espera entre cada ángulo
* http://blog.espol.edu.ec/edelros/servo-barrido/
* edelros@espol.edu.ec
 */

#include <Servo.h>

// Servo Pin y Objeto
int servoPin = 3; 
Servo Servo1; 

int avance = 20;
int angulo = avance;
int espera = 1000; //ms

int a = angulo;
int b = 180 - avance;

void setup(){
    Serial.begin(9600);
    Servo1.attach(servoPin); 
}
void loop(){
    Servo1.write(angulo);
    delay(espera);
    angulo = angulo + avance;
    
    // Sentido de rotación
    if (angulo>=b or angulo<=a){
        avance = -avance;
    }
    
    // Salida a Serial
    Serial.print(angulo);
    Serial.print(",");
    Serial.println(avance);
}

El siguiente paso es combinar el movimiento del servo con el sensor de ultrasonido.

---

Referencia

https://www.arduino.cc/en/Tutorial/Sweep

 

Para que el radar realice el barrido de lo que se encuentra al frente, se integran  las partes del sensor de ultrasonido y el Servo-Barrido para el radar.

Integrando las partes (Hardware)

Un ejemplo de ensamble del hardware se muestra en las imágenes. Se requiere un poco de trabajo para la integración mecánica usando  envases plásticos por facilidad de corte y/o reemplazo.

Vista lateral

El esquema de conexión para las partes integradas es:

---

Integrando las Instrucciones Arduino

Para integrar las instrucciones de cada componente, por simplicidad se convierte una de ellas en una función. Por ejemplo, se realiza la lectura del sensor ultrasonido como una función, se mueve el servo, se envian los resultados por puerto serial.

Para revisar la declaración de una función se adjunta la referencia al final del documento.

/* Radar Ultrasonido
 *  integrando: Servo - Barrido
 *  y Sensor Ultrasonido HC-SR04
 *  http://blog.espol.edu.ec/edelros/category/arduino/radar-ultrasonido/
 *  La lectura del ultrasonido se convierte en una función UnPulso()
 *  Los datos de las lecturas se envian por Serial
 *  Tarea: Desarrollar el procesamiento de los datos en Python
 */

#include <Servo.h> 

// Servo Pin y Objeto
int servoPin = 3; 
Servo Servo1; 

int avance = 20;
int angulo = avance;
int espera = 1000; //ms

int a = angulo;
int b = 180 - avance;

// Disparo del PULSO, Sensor del Retorno de pulso
int TriggerPin = 12;
int EchoPin = 11;

// tiempos: pulso, sin pulso, eco
int tpulsoON = 15;
int tpulsoOFF = 2000;
int dt_apaga = 10;
float dt_Echo;

void setup(){
    Serial.begin(9600);

    Servo1.attach(servoPin); 

    pinMode(TriggerPin, OUTPUT);
    pinMode(EchoPin, INPUT);
}
void loop(){
    Servo1.write(angulo);
    dt_Echo = UnPulso();
    
    delay(espera);
    angulo = angulo + avance;
    
    // Sentido de rotación
    if (angulo>=b or angulo<=a){
        avance = -avance;
    }
    
    // Salida a Serial
    Serial.print(angulo);
    Serial.print(",");
    Serial.println(dt_Echo);
}
 
float UnPulso(){
    // tiempo entre PULSOs: tpulsoOFF
    digitalWrite(TriggerPin, LOW);
    delayMicroseconds(tpulsoOFF);
    // Dispara PULSO de duración: tpulsoON  
    digitalWrite(TriggerPin, HIGH);
    delayMicroseconds(tpulsoON); 
    digitalWrite(TriggerPin, LOW); 
    delayMicroseconds(dt_apaga);  
    
    // Lectura sensor pulso: tiempo de echo 
    dt_Echo = pulseIn(EchoPin, HIGH);
    return dt_Echo;
}

Tarea: Continuar con el procesamiento de los datos en Python, usando como base la Gráfica de Radar

Referencia

https://www.arduino.cc/en/Reference/FunctionDeclaration

Terminados los pasos anteriores, se usan los datos enviados por el arduino al puerto serial para realizar el grafico.

La gráfica se presenta en formato de coordenadas polares, que en la librería matplotlib se requieren en radianes. Antes de graficar se realiza una conversión.

Del ejemplo se  muestra que se crean tres elementos:

• Pulso Punto, que marca el punto de la lectura "actual", la última recibida.
• Pulso Linea, que traza la distancia entre el punto de origen y lectura "actual"
• barrido, que grafica una linea de barrido del radar usando un grupo de puntos recibidos y almacenados en un vector.

Dado que los datos llegan "en vivo", la gráfica es animada, y se actualizan los datos de los tres elementos generando una nueva imagen en la función unatrama() de la animación. En la animación, se usa la opción 'blit' en la para actualizar solo los elementos del gráfico, manteniendo los ejes, títulos, etc sin cambios.

En las instrucciones en Python se usan números aleatorios para realizar la presentación.

Tarea

Integrar con la entrega de datos del experimento arduino. Observe que se debe sincronizar los tiempos de lectura del sensor, servo, datos Serial, gráfico, junto a los rangos de distancia del gráfico.

Use como referencia, Grafica animada:

http://blog.espol.edu.ec/edelros/grafica-animada-datos-serial/

Intrucciones en Python

# Grafica "en vivo" para actualizar datos
# recibidos por puerto serial
# Plantilla para proyecto, datos de prueba aleatorios
# http://blog.espol.edu.ec/edelros/category/arduino/radar-ultrasonido/
# Tarea: Actualizar los datos en la función una trama para ri,yi
#        Con los obtenidos desde el puerto Serial

import matplotlib.pyplot as plt
import matplotlib.animation as animation
import numpy as np
import random as rnd

# PARAMETROS DE LA GRAFICA
# angulo
avance = 20
angulo = avance
a = avance
b = 180-avance
# alcance del radar
alcance = 50

# Datos a graficar
xi = [avance]
yi = [0]

# GRAFICA figura
# tiempo entre tramas
retraso = 1000
figura = plt.figure()
grafica = figura.add_subplot(111, projection='polar')
grafica.set_xlim(0,np.pi)
grafica.set_ylim(0,alcance)
grafica.set_title('Radar de Ultradonido')

# Linea de barrido y ventana de datos a graficar
tamano = (180//avance)//2
# El gráfico usa radianes
ri = np.array(xi[-tamano:])/180*np.pi
di = yi[-tamano:]
barrido, = grafica.plot(ri, di, 'y')

# linea del pulso y puntoreferencia:
pulsox = [0,ri[-1]]
pulsoy = [0,di[-1]]
PulsoLinea, = grafica.plot(pulsox,pulsoy,'g')
PulsoPunto, = grafica.plot(ri[-1],yi[-1],'go')

# Nueva Trama
def unatrama(i, xi, yi,angulo,avance):

    # ---DATOS EJEMPLO|INICIO

    # Posición en ángulo
    if len(xi)>0:
        angulo = xi[-1]
    else:
        angulo = 0
    # Dirección de barrido
    direccion = 1
    if (len(xi)>=2):
        sentido = xi[-1]-xi[-2]
        direccion = np.sign(sentido)
        if angulo>=(180-avance) and sentido>0:
            direccion = -1
        if angulo<=avance and sentido<0:
            direccion = 1

    angulo = angulo + direccion*avance
   
    # alcance del radar
    alcance = 50
    # Recibe un dato nuevo| ejemplo usa aleatorio
    undato = int(rnd.random()*alcance)+1
    # ---DATOS EJEMPLO|INICIO

    # actualiza datos xi, yi
    xi.append(angulo) 
    yi.append(undato)# numero del dato ejemplo

    # ventana de datos a graficar
    tamano = (180//avance)//2

    # Linea de radar, el gráfico usa radianes
    ri = np.array(xi[-tamano:])/180*np.pi
    di = yi[-tamano:]
    barrido.set_xdata(ri)
    barrido.set_ydata(di)
    
    # Linea y punto del Pulso
    pulsox = [0,ri[-1]]
    pulsoy = [0,yi[-1]]
    
    PulsoLinea.set_xdata(pulsox)
    PulsoLinea.set_ydata(pulsoy)

    PulsoPunto.set_xdata(pulsox[1])
    PulsoPunto.set_ydata(pulsoy[1])  

    # Presenta valores últimos valores en pantalla
    print(xi[-1],yi[-1])

    # Si los datos son más de 1000
    # Elimina el más antiguo del historial
    if len(xi)>1000:
        xi.pop(0)
        yi.pop(0)
    
    return()

# Animación
ani = animation.FuncAnimation(figura,
                              unatrama,
                              fargs=(xi, yi,angulo,avance),
                              interval=retraso,
                              blit=True)

plt.show()

---

Referencias

https://matplotlib.org/examples/pylab_examples/polar_demo.html

https://learn.sparkfun.com/tutorials/graph-sensor-data-with-python-and-matplotlib/speeding-up-the-plot-animation