MicroPython ESP32 Tutorial - Interfacing DHT11 Sensor

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

2. Sensor de temperatura de humedad DHT11

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

4. Código MicroPython para ESP32 con sensor DHT11

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')

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

6. ESP32 DHT11 OLED Display MicroPython Code

6.1 SSD1306.py

• 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()

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()

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.