Sensor ultrasónico de Micrypthon HC 10 - Esptop 10 y Thonny IDE

Micrypthon se usa ampliamente con microcontroladores y sistemas integrados. Podemos escribir código y bibliotecas dentro de Micopython IDE e interfaz múltiples sensores. Este artículo lo guiará en la distancia de medición utilizando el ESP32 con el sensor HC-SR04.

ESP32 con sensor ultrasónico HC-SR04 con micryphon

La interfaz ESP32 con ultrasonic solo requiere dos cables para conectarse. Usando sensores ultrasónicos, podemos medir la distancia del objeto y podemos activar respuestas basadas en este sistema, como los sistemas de evitación de la colisión del vehículo.

Uso de MicryPthon que es un lenguaje diseñado para ESP32 y otros microcontroladores podemos interactuar múltiples sensores como el HC-SR04. Se escribirá el código de Micrypthon que calcula el tiempo tomado por la onda del sonar para llegar de un sensor a otro y volver a objeto. Más tarde usando la fórmula de distancia, podemos calcular la distancia del objeto.

Aquí hay algunos aspectos destacados principales del sensor HC-SR04:

Características	Valor
Tensión de funcionamiento	5V DC
Corriente operativa	15 mA
Frecuencia de operación	40 kHz
Rango mínimo	2 cm/ 1 pulgada
Rango máximo	400 cm/ 13 pies
Exactitud	3 mm
Ángulo de medición	<15 degree

HC-SR04 PINOUTHC-SR04 contiene seguidores cuatro patas:

• VCC: Conectarse al pin de Vin ESP32
• GND: Conectarse a GND
• Trigonometría: Pin para recibir la señal de control de la placa ESP32
• Eco: Enviar señal. La placa de microcontrolador recibe esta señal para calcular la distancia utilizando el tiempo

Cómo funciona ultrasónico

Después de que el sensor HC-SR04 se conecte con la señal ESP32 A en el Trigonometría Pin será generado por el tablero. Una vez que se recibe la señal en el pin trig del sensor HC-SR04, se generará una onda ultrasónica que deja el sensor y golpea el objeto u cuerpo de obstáculos. Después de golpear, se recuperará a la superficie del objeto.

Una vez que la onda reflejada regrese al extremo receptor del sensor, se generará un pulso de señal en el pasador de eco. ESP32 recibe la señal del pin de eco y calcula la distancia entre el objeto y el sensor usando Formula de distancia.

La distancia total calculada debe dividirse por dos dentro del código ESP32, ya que la distancia que obtenemos originalmente es igual a la distancia total de un sensor a otro y de regreso al extremo receptor del sensor. Entonces la distancia real es la señal que equivale a la mitad de esa distancia.

Esquemático

El siguiente es el esquema para interfactar ESP32 con sensor ultrasónico:

Conecte el disparador y el pin de eco del sensor con GPIO 5 y GPIO 18 de ESP32 respectivamente. También conecte ESP32 GND y VIN PIN con pasadores de sensor.

Sensor ultrasónico HC-SR04	Alfiler
Trigonometría	GPIO 5
Eco	GPIO 18
Gnd	Gnd
VCC	Empuje

Hardware

Se requieren los siguientes componentes para programar el sensor ultrasónico:

• ESP32
• HC-SR04
• Tablero de circuitos
• Cables de jersey

Cómo configurar HC-SR04 ultrasónico con ESP32 usando Micrypthon

Antes de que podamos programar ESP32 con un sensor ultrasónico, necesitamos instalar una biblioteca en él. Conecte la placa ESP32 a la PC. Siga los pasos para completar la configuración ESP32 con sensor ultrasónico en Thonny IDE usando MicryTthon.

Paso 1: Ahora abre thonny ide. Cree un archivo nuevo en la ventana del editor, vaya a: Archivo> nuevo o presionar Ctrl + N.

Una vez que se abre el nuevo archivo, pegue el siguiente código en la ventana del editor de Thonny IDE.

máquina de importación, tiempo
desde el pin de importación de la máquina
Clase HCSR04:
# echo_timeout_us se basa en el límite de rango de chips (400 cm)
def __init __ (self, trigger_pin, echo_pin, echo_timeout_us = 500*2*30):
ser.echo_timeout_us = echo_timeout_us
# Pin de activación init (fuera)
ser.trigger = pin (trigger_pin, mode = pin.Fuera, tirar = ninguno)
ser.desencadenar.valor (0)
# Init Echo Pin (IN)
ser.echo = pin (echo_pin, mode = pin.En, tirar = ninguno)
def _send_pulse_and_wait (self):
ser.desencadenar.valor (0) # estabilizar el sensor
tiempo.Sleep_us (5)
ser.desencadenar.valor (1)
# Enviar un pulso de 10us.
tiempo.Sleep_us (10)
ser.desencadenar.valor (0)
intentar:
pulse_time = máquina.Time_pulse_us (yo.Echo, 1, yo.echo_timeout_us)
return pulse_time
Excepto Oserror como ex:
Si ex.Args [0] == 110: # 110 = Etimedout
elevar Oserror ('fuera de rango')
criar ex
Def Distance_mm (self):
pulse_time = self._send_pulse_and_wait ()
mm = pulse_time * 100 // 582
regreso mm
Def Distance_CM (self):
pulse_time = self._send_pulse_and_wait ()
cms = (pulse_time / 2) / 29.1
Devolver CMS

Paso 2: Después de escribir el biblioteca Código dentro de la ventana del editor Ahora tenemos que guardarlo dentro del dispositivo Micropython.

Paso 3: Ir a: Archivo> guardar o presionar Ctrl + S.

Etapa 4: Una ventana nueva aparecerá. Asegúrese de que ESP32 esté conectado con la PC. Seleccione el dispositivo Micopython para guardar el archivo de la biblioteca.

Paso 5: Guarde el archivo de la biblioteca ultrasónica con el nombre HCSR04.py y hacer clic DE ACUERDO.

Ahora la biblioteca ultrasónica de sensores HCSR04 se agrega con éxito a la placa ESP32. Ahora podemos llamar a las funciones de la biblioteca dentro del código para medir la distancia de diferentes objetos.

Código para sensor ultrasónico usando micrypthon

Para el código del sensor ultrasónico, cree un nuevo archivo (Ctrl + N). En la ventana del editor, ingrese el código que se proporciona a continuación y guárdelo dentro del principal.py o bota.py archivo. Este código imprimirá la distancia de cualquier objeto que vaya frente a HC-SR04.

Código iniciado llamando a bibliotecas importantes como HCSR04 y tiempo biblioteca junto con dormir Para dar retrasos.

A continuación, creamos un nuevo objeto con un nombre sensor. Este objeto está tomando tres argumentos diferentes: disparador, eco y tiempo de espera. Aquí el tiempo de espera se define como el tiempo máximo después de que el sensor sale de alcance.

sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)

Para medir y guardar la distancia un nuevo objeto llamado distancia es creado. Este objeto guardará la distancia en CM.

distancia = sensor.Distance_cm ()

Escriba el siguiente código para obtener datos en MM.

distancia = sensor.Distance_mm ()

A continuación, imprimimos el resultado en la carcasa IDE de Micopython.

Imprimir ('Distancia:', Distancia, 'CM')

Al final se da un retraso de 1 segundo.

dormir (1)

El código completo se proporciona a continuación:

de hcsr04 import hcsr04
Desde el tiempo de sueño
# ESP32
sensor = hcsr04 (trigger_pin = 5, echo_pin = 18, echo_timeout_us = 10000)
# ESP8266
#sensor = hcsr04 (trigger_pin = 12, echo_pin = 14, echo_timeout_us = 10000)
Mientras que es cierto:
distancia = sensor.Distance_cm ()
Imprimir ('Distancia:', Distancia, 'CM')
dormir (1)

Después de escribir y guardar código dentro del dispositivo Micopython, ahora ejecuto el sensor Ultrasonic principal.py código de archivo. Haga clic en el botón Reproducir o presione F5.

Salida del sensor ultrasónico cuando el objeto está cerca

Ahora coloque un objeto cerca del sensor ultrasónico y verifique la distancia medida en la ventana del monitor en serie de Arduino IDE.

La distancia del objeto se muestra en el terminal de la carcasa. Ahora el objeto se coloca a 5 cm del sensor ultrasónico.

Salida del sensor ultrasónico Cuando el objeto está lejos

Ahora, para verificar nuestro resultado, colocaremos objetos lejos del sensor y verificaremos el funcionamiento del sensor ultrasónico. Coloque los objetos como se muestran en la imagen a continuación:

La ventana de salida nos dará una nueva distancia y, como podemos ver, ese objeto está lejos del sensor, por lo que la distancia medida es aprox. 15 cm del sensor ultrasónico.

Conclusión

Medir la distancia tiene una gran aplicación cuando se trata de robótica y otros proyectos, hay diferentes formas de medir la distancia. HC-SR04 con ESP32 puede medir la distancia de diferentes objetos. Aquí este artículo cubrirá todos los pasos que uno necesita para integrar y comenzar a medir la distancia con ESP32.