MicroPython ESP32 Tutorial - Interfacing DHT11 Sensor

MicroPython ESP32 Tutorial - Interfacing DHT11 Sensor

05 de diciembre de 2020

MicroPython-ESP32-Tutoria-ESP32-y-DHT11-Sensor-1
En este micropython ESP32 Tutoria - Interfacing DHT11 Sensor, utilizaremos el código MicroPython en MakePython ESP32 y DHT11 sensor de temperatura de humedad.

1. Visión general

En este proyecto, interconectaremos el sensor de temperatura de humedad DHT11 con ESP32 utilizando el código MicroPython. Primero interconectaremos el sensor solo con ESP32 y comprobaremos la lectura de temperatura y humedad en Shell Window. Del mismo modo, añadiremos una pantalla OLED I2C adicional de 0,96"/1,3" al mismo circuito y mostraremos la lectura de temperatura de humedad en la pantalla OLED.
 
Pero antes de comenzar, le recomendaré encarecidamente que siga el siguiente tutorial para aumentar suMicroPythonHabilidad. He explicado cómo se puede instalar MicroPython y utilizar uPyCraft IDE. Si usted es consciente de todo esto, entonces usted puede saltar este paso:Introducción a MicroPython en ESP32 con PyCraft IDE.

2. Sensor de temperatura de humedad DHT11

El DHT11 es un sensor de temperatura y humedad digital básico y de bajo costo. Utiliza un sensor de humedad capacitiva y un termistor para medir el aire circundante, y escupe una señal digital en el pin de datos (no se necesitan pines de entrada analógicos). Puedes encontrarlo desde:https://www.makerfabs.com/dht11-temperature-humidity-module.html.
DHT11-Sensor

El sensor viene con un NTC dedicado para medir la temperatura y un microcontrolador de 8 bits para generar los valores de temperatura y humedad como datos serie. El sensor también está calibrado de fábrica y por lo tanto fácil de interactuar con otros microcontroladores. El sensor puede medir la temperatura de 0 oC a 50 oC y la humedad del 20% al 90% con una precisión de ±1 oC y ±1%.

3. Sensor DHT11 de interfaz con ESP32 usando el código MicroPython

Ahora vamos a montar DHT11 Sensor & ESP32 y comenzar con el código MicroPython para medir la humedad y la temperatura. La conexión es bastante simple. Conecte el pin DHT11 VCC & GND al pin ESP32 3.3V Pin & GND. Conecte el pin de salida digital al pin ESP32 GPIO5.
Diagram-ESP32-Módulo-y-DHT11-Sensor

En mi caso estoy usandoJunta MakePython ESP32. La conexión para esta placa es tal y como se muestra en de la imagen abajo.
Diagram-MakePython-ESP32-y-DHT11-Sensor

4. Código MicroPython para ESP32 con sensor DHT11

El código MiroPython para la interconexión de DHT11 con ESP32 se indica a continuación.
 
Abra uPyCraft IDE y abra una nueva pestaña. Pegar el código siguiente y guardarlo con un nombre "main.py". Ahora puede conectar el ESP32 Board & Upload the Code haciendo clic en el botón Descargar.
de la importación de la máquina Pin
desde el tiempo importar sueño
importar dht
 
sensor de dht. DHT11(Pin(5))
 
mientras que True:
  Tratar:
    sueño(2)
    sensor.measure()
    t - sensor.temperatura()
    h • sensor.humedad()
    impresión ('Temperatura: %3.1f C' %t)
    impresión ('Humedad: %3.1f %%' %h)
  excepto OSError como e:
    print('Error en la lectura del sensor')
Tan pronto como se carga el código, puede ver el resultado en la ventana de la consola ouPyCraft Shell.
Resultado-uPyCraft-Shell

5. Monitoree los datos de temperatura de humedad DHT11 en OLED con el código MicroPython

Ahora vamos a añadir una pantalla OLED adicional al circuito. Ahora mostraremos los datos de temperatura de humedad en OLED Display en lugar de uPyCrfat Window Shell.
 
Aquí está el diagrama de conexión. La pantalla OLED es un módulo I2C. Así que conecte el pin SDA & SCL de OLED Display a ESP32 D21 & D22 Pin respectivamente.
Diagram-ESP32-Module-OLED-y-DHT11-Sensor

En caso de que esté utilizando la placa MicroPython ESP32, no hay necesidad de conectar una pantalla OLED, ya que ya tiene 1.3" I2C OLED Display conectado a ella. Su pin SDA & SCL está conectado a GPIO5 & GPIO4 respectivamente.

6. ESP32 DHT11 OLED Display MicroPython Code

El código MicroPython para interconectar la pantalla OLED con ESP32 tiene dos partes.
1. Biblioteca SSD1306
2. Código principal

 
La biblioteca que se va a escribir en la pantalla OLED no forma parte de la biblioteca micropython estándar de forma predeterminada. Por lo tanto, primero tenemos que subir la biblioteca a la placa ESP32.
Subir-Biblioteca-a-ESP32-Board

6.1 SSD1306.py

Primero abre una Nueva Pestaña en uPyCraft IDE y pega el siguiente código. A continuación, guarde el archivo con el nombre "SSD1306.py". Ahora puede cargar el código.
• Controlador OLED MicroPython SSD1306, interfaces I2C y SPI
de micropython import const
tiempo de importación
import framebuf
importar sys

currentBoard""
if(sys.platform-"esp8266"):
  currentBoard"esp8266"
elif(sys.platform-"esp32"):
  currentBoard"esp32"
elif(sys.platform-"pyboard"):
  currentBoard "pyboard"
  importación pyb
• Definiciones de registro
SET_CONTRAST de const(0x81)
SET_ENTIRE_ON const(0xa4)
SET_NORM_INV const(0xa6)
SET_DISP const(0xae)
SET_MEM_ADDR const(0x20)
SET_COL_ADDR de 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 de const(0xc0)
SET_DISP_OFFSET de const(0xd3)
SET_COM_PIN_CFG de const(0xda)
SET_DISP_CLK_DIV const(0xd5)
SET_PRECHARGE de const(0xd9)
SET_VCOM_DESEL de la const(0xdb)
SET_CHARGE_PUMP de const(0x8d)
clase SSD1306:
  def __init__ (auto, anchura, altura, 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 (yo):
    para cmd en (
      SET_DISP de la SET_DISP 0x00, apagado
      • Ajuste de la dirección
      SET_MEM_ADDR, 0x00, horizontal
      • resolución y maquetación
      SET_DISP_START_LINE ? 0x00,
      SET_SEG_REMAP de la SET_SEG_REMAP 0x01, á añadidor de columna 127 asignado a SEG0
      SET_MUX_RATIO, self.height - 1,
      SET_COM_OUT_DIR de la SET_COM_OUT_DIR 0x08, escaneo de COM[N] a COM0
      SET_DISP_OFFSET, 0x00,
      SET_COM_PIN_CFG, 0x02 si self.height 32 más 0x12,
      • Esquema de cronometraje y conducción
      SET_DISP_CLK_DIV, 0x80,
      SET_PRECHARGE, 0x22 si self.external_vcc otra 0xf1,
      SET_VCOM_DESEL, 0x30, 0,83*Vcc
      • Pantalla
      SET_CONTRAST, 0xff, máximo
      SET_ENTIRE_ON, la salida de la salida sigue el contenido de la RAM
      SET_NORM_INV, no invertido
      • Bomba de carga
      SET_CHARGE_PUMP, 0x10 si self.external_vcc más 0x14,
      SET_DISP de la SET_DISP 0x01): ? encendido
      self.write_cmd(cmd)
    self.fill(0)
    self.show()
  def poweroff (yo):
    self.write_cmd(SET_DISP a 0x00)
  def contraste (auto, contraste):
    self.write_cmd(SET_CONTRAST)
    self.write_cmd (contraste)
  def invert (sí mismo, invertir):
    self.write_cmd(SET_NORM_INV(SET_NORM_INV) (invertir & 1))
  def show(self):
    x0 a 0
    x1 - self.width - 1
    si self.width 64:
      • Las pantallas con una anchura de 64 píxeles se desplazan en 32
      x0 +x 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 (auto.pages - 1)
    self.write_data(self.buffer)
  def fill(self, col):
    self.framebuf.fill(col)
  def pixel(self, 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)
  def line(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 (yo, 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__ (auto, anchura, altura, i2c, addr-0x3c, external_vcc-Falso):
    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 :
    corriente globalBoard
    si 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 (yo, buf):
    self.temp[0] - self.addr < 1
    self.temp[1] = 0x40 # Co=0, D/C#=1
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.i2c.start()
      self.i2c.write(self.temp)
      self.i2c.write(buf)
      self.i2c.stop()
    elif currentBoard=="pyboard":
      #self.i2c.send(self.temp,self.addr)
      #self.i2c.send(buf,self.addr)
      self.i2c.mem_write(buf,self.addr,0x40)
  def poweron(self):
    pass

class SSD1306_SPI(SSD1306):
  def __init__(self, width, height, spi, dc, res, cs, external_vcc=False):
    self.rate = 10 * 1024 * 1024
    dc.init(dc.OUT, value=0)
    res.init(res.OUT, value=0)
    cs.init(cs.OUT, value=1)
    self.spi = spi
    self.dc = dc
    self.res = res
    self.cs = cs
    super().__init__(width, height, external_vcc)
  def write_cmd(self, cmd):
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    elif currentBoard=="pyboard":
      self.spi.init(mode = pyb.SPI.MASTER,baudrate=self.rate, polarity=0, phase=0)
    self.cs.high()
    self.dc.low()
    self.cs.low()
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.write(bytearray([cmd]))
    elif currentBoard=="pyboard":
      self.spi.send(bytearray([cmd]))
    self.cs.high()
  def write_data(self, buf):
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.init(baudrate=self.rate, polarity=0, phase=0)
    elif currentBoard=="pyboard":
      self.spi.init(mode = pyb.SPI.MASTER,baudrate=self.rate, polarity=0, phase=0)
    self.cs.high()
    self.dc.high()
    self.cs.low()
    global currentBoard
    if currentBoard=="esp8266" or currentBoard=="esp32":
      self.spi.write(buf)
    elif currentBoard=="pyboard":
      self.spi.send(buf)
    self.cs.high()
  def poweron(self):
    self.res.high()
    time.sleep_ms(1)
    self.res.low()
    time.sleep_ms(10)
    self.res.high()

6.2 main.py

Ahora, después de cargar el código para SSD1306, puede abrir una nueva pestaña y pegar el siguiente código a continuación. Asegúrese de definir el Pin SCL & SDA en el código de acuerdo con su placa ESP32.
 
Ahora puede cargar el código.
de la importación de la máquina Pin
de la importación de la máquina Pin,I2C
máquina de importación
importación ssd1306
importar dht
tiempo de importación

i2c - I2C(scl-Pin(5), sda-Pin(4)) #Init i2c
oled-ssd1306. SSD1306_I2C(128,64,i2c,0x3c)

p15-Pin(22, Pin.IN)
d'dht. DHT11(p15)

mientras que True:
    d.measure() #Measurement de temperatura y humedad
    temperatura() #Read centígrados
    h.humedad() #Read humedad relativa
    print('Temperatura', t, 'C', 'Humedad', h, '%')
    time.sleep(1) #Delay de 1 segundo
    oled.fill(0)
    oled.text("Temperatura",20,10)
    oled.text(str(t),40,20)
    oled.text("*C", 60,20)
    oled.text("Humidity",30,40)
    oled.text(str(h),40,55)
    oled.text("%", 60,55)
    oled.show()
Una vez cargado el código, la pantalla OLED comenzará a mostrar el valor de humedad y temperatura en la pantalla OLED.
Resultado-Interfacing-DHT11-Sensor-on-ESP32

Este artículo se publica originalmente enHow2electronics. Si tiene más preguntas o necesita algunas personalizaciones de PCBA basadas en esas placas MakePython IoT, no dude en ponerse en contactoservice@makerfabs.com.Guiño

contáctenos