Tutorial de MicroPython ESP32 - Sensor ultrasónico de interfaz

En este tutorial de MicroPython ESP32, interconectaremos el sensor ultrasónico HC-SR04 con MakePython ESP32 usando código MicroPython.

1. Descripción general: MicroPython en ESP32 con sensor ultrasónico

En este proyecto, interconectaremos el sensor ultrasónico HC-SR04 con ESP32 utilizando código MicroPython. Utilizaremos el sensor ultrasónico con placa ESP32 y pantalla OLED I2C de 0.96 ". Luego escribiremos unMicroPythonCódigo en uPyCraft IDE. Uso de laIDE uPyCraft, podemos cargar directamente el firmware a la placa ESP32.

HC-SR04 es un sensor ultrasónico utilizado principalmente para determinar la distancia del objeto objetivo. Mide la distancia precisa utilizando una tecnología sin contacto: una tecnología que no implica contacto físico entre el sensor y el objeto.

Antes de continuar, puede consultar esta Guía:Tutorial de MicroPython ESP32 - Primeros pasos. Le recomiendo encarecidamente que siga esta guía, ya que cubre todos los conceptos básicos, incluida la configuración del IDE para escribir el código y cargarlo también.

2. Placa de desarrollo MakePython ESP32

La placa contiene un chip ESP32 combinado + pantalla OLED I2C de 1.3 "que admite MicroPython. Para obtener más información sobre este tablero y comprarlo en línea, puede visitar este enlace:Placa MakePython ESP32. Esta placa de desarrollo MakePython ESP32 es más barata con una pantalla OLED adicional de 1.3 "y está especialmente diseñada para el soporte de MicroPython. Con 2 versiones para elegir, WROOM(No PSRAM) y WROVER((8MB PSRAM).

3. Sensor ultrasónico HC-SR04

4. Interfaz del sensor ultrasónico HC-SR04 con ESP32 usando MicroPython

5. Código fuente/Programa

El código MicroPython para usar el sensor ultrasónico con ESP32 tiene tres partes. Esto se debe a que necesitamos una biblioteca para el sensor ultrasónico HC-SR04 y la pantalla OLED.

Las tres partes incluyen:
1. SSD1306.py
2. HC_SR04.py
3. Main.py

5.1 SSD1306.py

# MicroPython SSD1306 OLED driver, I2C e interfaces SPI
Desde Micropython Import Const
Tiempo de importación
Importar framebuf
Importar sys

currentBoard=""
if(sys.platform=="esp8266"):
  currentBoard="esp8266"
elif(sys.platform=="esp32"):
  currentBoard="esp32"
elif(sys.platform=="pyboard"):
  currentBoard="pyboard"
  Importar pyb
# Definiciones de registro
SET_CONTRAST = const(0x81)
SET_ENTIRE_ON = const(0xa4)
SET_NORM_INV = const(0xa6)
SET_DISP = const(0xae)
SET_MEM_ADDR = const(0x20)
SET_COL_ADDR = const(0x21)
SET_PAGE_ADDR = const(0x22)
SET_DISP_START_LINE = const(0x40)
SET_SEG_REMAP = const(0xa0)
SET_MUX_RATIO = const(0xa8)
SET_COM_OUT_DIR = const(0xc0)
SET_DISP_OFFSET = const(0xd3)
SET_COM_PIN_CFG = const(0xda)
SET_DISP_CLK_DIV = const(0xd5)
SET_PRECHARGE = const(0xd9)
SET_VCOM_DESEL = const(0xdb)
SET_CHARGE_PUMP = const(0x8d)
clase SSD1306:
  def __init__(propio, ancho, alto, external_vcc):
    self.width = ancho
    self.height = altura
    self.external_vcc = external_vcc
    self.pages = self.height // 8
    self.buffer = bytearray(self.pages * self.width)
    self.framebuf = framebuf. FrameBuffer(self.buffer, self.width, self.height, framebuf. MVLSB)
    self.poweron()
    self.init_display()
  def init_display(self):
    para cmd en (
      SET_DISP | 0x00, # desactivado
      Configuración de dirección #
      SET_MEM_ADDR, 0x00, # horizontal
      Resolución y diseño de #
      SET_DISP_START_LINE | 0x00,
      SET_SEG_REMAP | 0x01, # column addr 127 asignado a SEG0
      SET_MUX_RATIO, self.height - 1,
      SET_COM_OUT_DIR | 0x08, # escanear de COM[N] a COM0
      SET_DISP_OFFSET, 0x00,
      SET_COM_PIN_CFG, 0x02 si self.height == 32 más 0x12,
      # cronometraje y esquema de conducción
      SET_DISP_CLK_DIV, 0x80,
      SET_PRECHARGE, 0x22 si self.external_vcc más 0xf1,
      SET_VCOM_DESEL, 0x30, # 0.83*Vcc
      # pantalla
      SET_CONTRAST, 0xff, # máximo
      SET_ENTIRE_ON, la salida # sigue el contenido de RAM
      SET_NORM_INV, # no invertido
      # bomba de carga
      SET_CHARGE_PUMP, 0x10 si self.external_vcc más 0x14,
      SET_DISP | 0x01): # activado
      self.write_cmd(cmd)
    self.fill(0)
    self.show()
  def poweroff (self):
    self.write_cmd(SET_DISP | 0x00)
  Contraste def (propio, contraste):
    self.write_cmd(SET_CONTRAST)
    self.write_cmd(contraste)
  def invert(self, invert):
    self.write_cmd(SET_NORM_INV | (invertir & 1))
  def show (self):
    x0 = 0
    x1 = self.width - 1
    if self.width == 64:
      # pantallas con un ancho de 64 píxeles se desplazan en 32
      x0 += 32
      x1 += 32
    self.write_cmd(SET_COL_ADDR)
    self.write_cmd(x0)
    self.write_cmd(x1)
    self.write_cmd(SET_PAGE_ADDR)
    self.write_cmd(0)
    self.write_cmd(self.pages - 1)
    self.write_data(self.buffer)
  def fill(self, col):
    self.framebuf.fill(col)
  Píxel de definición (propio, x, y, col):
    self.framebuf.pixel(x, y, col)
  Def scroll (self, dx, dy):
    self.framebuf.scroll(dx, dy)
  def text(self, string, x, y, col=1):
    self.framebuf.text(string, x, y, col)
  def hline(self, x, y, w, col):
    self.framebuf.hline(x, y, w, col)
  def vline(self, x, y, h, col):
    self.framebuf.vline(x, y, h, col)
  Línea def (self, x1, y1, x2, y2, col):
    self.framebuf.line(x1, y1, x2, y2, col)
  def rect(self, x, y, w, h, col):
    self.framebuf.rect(x, y, w, h, col)
  def fill_rect(self, x, y, w, h, col):
    self.framebuf.fill_rect(x, y, w, h, col)
  def blit(self, fbuf, x, y):
    self.framebuf.blit(fbuf, x, y)

clase SSD1306_I2C(SSD1306):
  def __init__(self, width, height, i2c, addr=0x3c, external_vcc=False):
    self.i2c = i2c
    self.addr = addr
    self.temp = bytearray(2)
    super().__init__(ancho, alto, external_vcc)
  def write_cmd(self, cmd):
    self.temp[0] = 0x80 # Co=1, D/C#=0
    self.temp[1] = cmd
    #IF SYS :
    currentBoard global
    if currentBoard=="esp8266" o currentBoard=="esp32":
      self.i2c.writeto(self.addr, self.temp)
    elif currentBoard=="pyboard":
      self.i2c.send(self.temp,self.addr)
    #ELSE:

def write_data(self, buf):
    self.temp[0] = self.addr 
                                

Primero, abra un nuevo archivo en uPyCraft IDE y pegue el código anterior. Guarde el archivo como un nombre "SSD1306.py". Haga clic en el botón "Descargar y ejecutar" icono. Esto cargará el archivo en la placa ESP32.
  
                                
La ventana de la consola de uPyCraft debe aparecer en el siguiente mensaje.
                                

                                


Ahora puede importar la biblioteca SSD1306 y usarla en la parte de código.

                                
5.2 HC_SR04.py
                                
Ahora abra una nueva pestaña y cargue el siguiente código. El código cargará la biblioteca de HC_SR04 del sensor ultrasónico en la placa ESP32.
 
importar máquina, hora
desde el Pin de importación de la máquina

clase HCSR04:
    """
    Driver para utilizar el sensor untrasónico HC-SR04.
    El rango del sensor es de entre 2 cm y 4 m.
    Los tiempos de espera recibidos escuchando el pin de eco se convierten a OSError ('Fuera de rango')
    """
    # echo_timeout_us se basa en el límite de rango de chip (400cm)
    def __init__(self, trigger_pin, echo_pin, echo_timeout_us=500*2*30):
        """
        trigger_pin: Pin de salida para enviar pulsos
        echo_pin: Pin de solo lectura para medir la distancia. El pin debe protegerse con una resistencia de 1k
        echo_timeout_us: Tiempo de espera en microsegundos para escuchar el pin de eco.
        Por defecto se basa en el rango límite del sensor (4m)
        """
        self.echo_timeout_us = echo_timeout_us
        # Pin de activación de inicio (salida)
        self.trigger = Pin(trigger_pin, mode=Pin.OUT, pull=None)
        self.trigger.value(0)

# Pin de eco de inicio (entrada)
        self.echo = Pin(echo_pin, mode=Pin.IN, pull=None)

def _send_pulse_and_wait(self):
        """
        Envía el pulso para que se active y escucha en el pin de eco.
        Usamos el método 'machine.time_pulse_us()' para obtener los microsegundos hasta que se recibe el eco.
        """
        self.trigger.value(0) # Estabilizar el sensor
        time.sleep_us(5)
        self.trigger.value(1)
        # Enviar un pulso de 10us.
        time.sleep_us(10)
        self.trigger.value(0)
        probar:
            pulse_time = machine.time_pulse_us(self.echo, 1, self.echo_timeout_us)
            Volver pulse_time
        excepto OSError como ex:
            if ex.args[0] == 110: # 110 = ETIMEDOUT
                raise OSError('Fuera de rango')
            Criar ex

def distance_mm(self):
        """
        Obtenga la distancia en milímetros sin operaciones de coma flotante.
        """
        pulse_time = self._send_pulse_and_wait()

# Para calcular la distancia obtenemos el pulse_time y lo dividimos por 2
        # (el pulso camina la distancia dos veces) y por 29.1 porque
        # la velocidad del sonido en el aire (343,2 m/s), que es equivalente a
        # 0.34320 mm/us que es 1mm cada 2.91us
        # pulse_time // 2 // 2,91 -> pulse_time // 5,82 -> pulse_time * 100 // 582
        mm = pulse_time * 100 // 582
        Devolver mm

def distance_cm(self):
        """
        Obtenga la distancia en centímetros con operaciones de coma flotante.
        Devuelve un flotador
        """
        pulse_time = self._send_pulse_and_wait()

# Para calcular la distancia obtenemos el pulse_time y lo dividimos por 2
        # (el pulso camina la distancia dos veces) y por 29.1 porque
        # la velocidad del sonido en el aire (343,2 m/s), que es equivalente a
        # 0.034320 cm/us que es 1cm cada 29.1us
        cms = (pulse_time / 2) / 29.1
        CMS de retorno
                                
5.3 Main.py
                                
Después de descargar el archivo SSD1306.py & HC_SR04.py a la placa ESP32, ahora puede cargar el código principal. Para hacer eso, abra otro archivo y pegue el siguiente código. Guárdelo como un nombre "main.py".
 
desde HCSR04 importación HCSR04
de la importación de la máquina Pin, I2C
Importar SSD1306
 
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000) #Init i2c
lcd=ssd1306. SSD1306_I2C(128,64,i2c)
 
sensor = HCSR04(trigger_pin=13, echo_pin=12,echo_timeout_us=1000000)
 
probar:
  mientras que Verdadero:
    distancia = sensor.distance_cm()
    imprimir(distancia)
    lcd.fill(0)
    lcd.text("Distancia:",30,20)
    lcd.text(str(distancia),30,40)
    lcd.show()
excepto KeyboardInterrupt:
       pasar
                                
6. Prueba del telémetro ultrasónico
                                
Una vez que el código MicroPython se carga en la placa ESP32, el sensor ultrasónico comenzará a mostrar la distancia en cm. Puede comprobar el funcionamiento del sensor colocando algo delante del sensor.
                                

                                


Los telémetros ultrasónicos son pequeños sensores divertidos que pueden medir la distancia. Puede usarlos para encontrar la distancia a un objeto o para detectar cuando algo está cerca del sensor como un detector de movimiento. Debido a que usan el sonido para medir la distancia, funcionan tan bien en la oscuridad como en la luz. Puede medir distancias desde 2 cm hasta 400 cm con una precisión de ±3 mm.

                                
Este artículo está publicado originalmente enHow2electronics. Si tiene más preguntas o necesita algunas personalizaciones de PCBA basadas en esas placas MakePython IoT, no dude en ponerse en contacto conservice@makerfabs.com.