Tutorial de MicroPython ESP32 - Interfaz DS18B20

Aquí hay unDiagrama del circuitopara la interfaz del sensor de temperatura DS18B20 con ESP32 utilizando código MicroPython. El pin de salida digital está conectado al pin ESP32 GPIO22. Una resistencia de 4.7K se utiliza como resistencia pull-up y está conectada entre el pin de salida digital y el pin VCC.
En caso de que esté utilizandoPlaca MakePython ESP32, puede realizar la siguiente conexión como se muestra en el diagrama de conexión siguiente. Este tablero tiene unPantalla OLED de 1.3".

ElCódigo MicroPythonse indica a continuación. Usando este código MicroPython puedesInterfaz DS18B20 con placa ESP32y verifique la salida en uPyCraft IDE Python Shell.
 

Simplemente copie el código a continuación y cree un nuevo archivo en uPyCraft IDE y guárdelo con un nombre "main.py".

Máquina de importación, OneWire, DS18x20, Tiempo
 
ds_pin = máquina. Pin(22)
ds_sensor = DS18x20. DS18X20(un cable. OneWire(ds_pin))
 
roms = ds_sensor.scan()
print('Dispositivos DS encontrados: ', roms)
 
mientras que Verdadero:
  ds_sensor.convert_temp()
  time.sleep_ms(750)
  Para ROM en ROMS:
    Imprimir (ROM)
    print(ds_sensor.read_temp(rom))
  tiempo.sueño(5)

Para cargar el código, utilice el botón "Descargar y ejecutar" en uPyCraft IDE. Tan pronto como se cargue el código, la ventana del shell comenzará a mostrar la temperatura.

6. Interfaz DS18B20 con ESP32 y pantalla OLED usando MicroPython

6.1 Diagrama de circuito y conexiones

6.2 Biblioteca SSD1306

# 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. Guardar el archivo como nombre"SSD1306.py". Haga clic en el botón"Descargar y ejecutar"Icono. Esto cargará el archivo en la placa ESP32.
  
 EluPyCraftVentana de consola que muestra el siguiente mensaje:
                                        
 
Ahora puede importar la biblioteca SSD1306 y usarla en la parte de código.
                                        
6.3 Código principal
                                        

Después de descargar elSSD1306.pyen 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 nombre"main.py".
  
 
de la importación de la máquina Pin, I2C
Importar SSD1306
Tiempo de importación
Importar máquina
Importar OneWire
 
dat = máquina. Pin(22) # el dispositivo está en GPIO0
i2c = I2C(scl=Pin(5), sda=Pin(4), freq=100000) #Init i2c
lcd=ssd1306. SSD1306_I2C(128,64,i2c) #create objeto LCD,Especificar col y fila
 
ds = DS18x20. DS18X20(un cable. OneWire(dat)) # crear el objeto onewire
roms = ds.scan() # buscar dispositivos en el bus
 
probar:
  mientras que Verdadero:
      ds.convert_temp()
      time.sleep_ms(750) #La temperatura de lectura necesita al menos 750ms
      Para ROM en ROMS:
          lcd.fill(0)
          lcd.text("Temperatura:",10,16)
          lcd.text(str(ds.read_temp(rom)),24,40)
          lcd.show()  
excepto KeyboardInterrupt:
          pasar
                                        


Nota:Cambie el PIN OLED en el código de acuerdo con los pines I2C de su placa ESP32.
  
                                        
Tan pronto como se cargue el código, la pantalla OLED comenzará a mostrar la temperatura como se muestra en la foto de abajo.
                                        
 
Si tiene más preguntas o tiene un requisito especial basado en esas placas MakePython IoT, no dude en ponerse en contacto conservice@makerfabs.com.
                                        
Este artículo está publicado originalmente enHow2electronics.

También puedes aprender de este video tutorial hecho porHow2electronics: