Подключение датчика DS18B20 к Raspberry Pi Pico: схема и программа

В этой статье мы рассмотрим подключение датчика температуры DS18B20 к плате Raspberry Pi Pico с помощью MicroPython. Ранее мы считывали данные встроенного температурного датчика с Raspberry Pi Pico. Но в этом случае мы подключим к плате внешний датчик температуры, такой как DS18B20.

DS18B20 — это 1-проводной программируемый датчик температуры от компании Maxim Integrated, которому требуется только одна линия данных для связи с центральным микропроцессором. Поскольку протокол связи цифровой, вы можете использовать любой цифровой контакт микроконтроллера RP2040.

Код micropython требует несколько библиотек DS18B20, таких как onewire и ds18x20. В первом примере мы просто прочитаем значение температуры с DS18B20 и Raspberry Pi Pico в оболочке Thonny IDE. Во втором примере мы будем использовать 0,96″ I2C OLED-дисплей для отображения показаний температуры.

Также ранее на нашем сайте мы рассматривали подключение датчика температуры DS18B20 к другим микроконтроллерам и платам:

Необходимые компоненты

Плата Raspberry Pi Pico (купить на AliExpress).
Maxim Integrated DS18B20 Programmable Resolution (цифровой датчик температуры DS18B20) (купить на AliExpress).
Модуль OLED дисплея SSD1306 128×64 с диагональю 0.96 дюйма и интерфейсом I2C (купить на AliExpress).
Резистор 4,7 кОм (купить на AliExpress).
Макетная плата.
Соединительные провода.

Реклама: ООО «АЛИБАБА.КОМ (РУ)» ИНН: 7703380158

Водонепроницаемый цифровой датчик температуры DS18B20

Это предварительно подключенная и водонепроницаемая версия датчика DS18B20. Удобно, когда вам нужно измерить что-то на большом расстоянии или во влажных условиях. Датчик может измерять температуру в диапазоне от -55 до 125 °C (от -67 °F до +257 °F). Кабель покрыт оболочкой из ПВХ.

Поскольку он цифровой, нет ухудшения сигнала даже на больших расстояниях. Эти 1-проводные цифровые датчики температуры довольно точны, т. е. обеспечивают точность измерения температуры ±0,5°C в большей части диапазона. Он может выдавать до 12 бит точности от встроенного цифро-аналогового преобразователя. Они отлично работают с любым микроконтроллером, использующим один цифровой вывод.

Единственный их недостаток в том, что они используют протокол Dallas 1-Wire, который довольно сложен и требует кучу кода для разбора коммуникации. Мы добавляем резистор 4,7 кОм, который требуется в качестве подтягивающего от линии DATA к линии VCC при использовании датчика.

Дополнительную информацию об этом датчике можно найти в техническом описании датчика DS18B20.

Схема подключения

Схема подключения датчика температуры DS18B20 к плате Raspberry Pi Pico представлена на следующем рисунке.

Датчик питается от контакта 3,3 В Raspberry Pi Pico, а GND датчика подключен к GND платы. Аналогично цифровой контакт датчика подключен к GPIO22 Raspberry Pi Pico. Цифровой контакт подключен через резистор 4,7 кОм.

Исходный код программы

Я использовал thonny IDE, которая поддерживает Micropython на Raspberry Pi Pico. Вам нужно импортировать библиотеки для работы с датчиком DS18B20. Для этого требуются библиотеки OneWire и DS18X20. Загрузите библиотеки по следующим ссылкам.
Библиотека DS18B20 MicroPython
Библиотека OneWire MicroPython

Щелкните по файлу, находящемуся внутри загруженной папки, а затем скопируйте содержимое всего файла.

Нажмите кнопку New («Новый») в Thonny IDE, чтобы открыть пустой скрипт, и вставьте следующий код.

import machine, onewire, ds18x20, time
 
ds_pin = machine.Pin(22)
 
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
 
roms = ds_sensor.scan()
 
print('Found DS devices: ', roms)
 
while True:
 
  ds_sensor.convert_temp()
 
  time.sleep_ms(750)
 
  for rom in roms:
 
    print(rom)
 
    print(ds_sensor.read_temp(rom))
 
  time.sleep(5)

import machine, onewire, ds18x20, time

ds_pin = machine.Pin(22)

ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

roms = ds_sensor.scan()

print('Found DS devices: ', roms)

while True:

ds_sensor.convert_temp()

time.sleep_ms(750)

for rom in roms:

print(rom)

print(ds_sensor.read_temp(rom))

time.sleep(5)

Мы использовали контакт GP22 платы Raspberry Pi Pico для подключения цифрового контакта датчика DS18B20. Сохраните указанный выше файл с расширением .py. Затем вы можете запустить код. После этого вы должны увидеть вывод в Thonny Shell.

Вы должны выполнить функцию convert_temp(), чтобы инициировать считывание температуры, затем подождать не менее 750 мс перед считыванием значения. Вы используете функцию read_temp, чтобы вернуть значение, а затем мы делаем паузу на 5 секунд и запускаем это снова.

Отображение температуры на OLED дисплее

Теперь давайте напишем дополнительный код для отображения считанного значения температуры на OLED-экране. Схема подключения для этого варианта представлена ниже. Подключите выводы SDA и SCL OLED-дисплея к выводам PICO GP8 и GP9 соответственно. Подключите выводы VCC и GND OLED-дисплея к выводам 3,3 В и GND Pico. Вы можете использовать макетную плату для сборки всей схемы.

Для этого нам нужно сначала написать код драйвера для OLED дисплея, так как драйвер SSD1306 недоступен. Весь код разделен на 2 части:
1. ssd1306.py
2. Main.py

ssd1306.py

Откройте новую вкладку и скопируйте следующий код. Сохраните файл под именем SSD1306.py .

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
 
from micropython import const
import framebuf
 
 
# register definitions
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)
 
# Subclassing FrameBuffer provides support for graphics primitives
# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html
class SSD1306(framebuf.FrameBuffer):
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        self.buffer = bytearray(self.pages * self.width)
        super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)
        self.init_display()
 
    def init_display(self):
        for cmd in (
            SET_DISP | 0x00,  # off
            # address setting
            SET_MEM_ADDR,
            0x00,  # horizontal
            # resolution and layout
            SET_DISP_START_LINE | 0x00,
            SET_SEG_REMAP | 0x01,  # column addr 127 mapped to SEG0
            SET_MUX_RATIO,
            self.height - 1,
            SET_COM_OUT_DIR | 0x08,  # scan from COM[N] to COM0
            SET_DISP_OFFSET,
            0x00,
            SET_COM_PIN_CFG,
            0x02 if self.width > 2 * self.height else 0x12,
            # timing and driving scheme
            SET_DISP_CLK_DIV,
            0x80,
            SET_PRECHARGE,
            0x22 if self.external_vcc else 0xF1,
            SET_VCOM_DESEL,
            0x30,  # 0.83*Vcc
            # display
            SET_CONTRAST,
            0xFF,  # maximum
            SET_ENTIRE_ON,  # output follows RAM contents
            SET_NORM_INV,  # not inverted
            # charge pump
            SET_CHARGE_PUMP,
            0x10 if self.external_vcc else 0x14,
            SET_DISP | 0x01,
        ):  # on
            self.write_cmd(cmd)
        self.fill(0)
        self.show()
 
    def poweroff(self):
        self.write_cmd(SET_DISP | 0x00)
 
    def poweron(self):
        self.write_cmd(SET_DISP | 0x01)
 
    def contrast(self, contrast):
        self.write_cmd(SET_CONTRAST)
        self.write_cmd(contrast)
 
    def invert(self, invert):
        self.write_cmd(SET_NORM_INV | (invert & 1))
 
    def show(self):
        x0 = 0
        x1 = self.width - 1
        if self.width == 64:
            # displays with width of 64 pixels are shifted by 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)
 
 
class SSD1306_I2C(SSD1306):
    def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):
        self.i2c = i2c
        self.addr = addr
        self.temp = bytearray(2)
        self.write_list = [b"\x40", None]  # Co=0, D/C#=1
        super().__init__(width, height, external_vcc)
 
    def write_cmd(self, cmd):
        self.temp[0] = 0x80  # Co=1, D/C#=0
        self.temp[1] = cmd
        self.i2c.writeto(self.addr, self.temp)
 
    def write_data(self, buf):
        self.write_list[1] = buf
        self.i2c.writevto(self.addr, self.write_list)
 
 
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
        import time
 
        self.res(1)
        time.sleep_ms(1)
        self.res(0)
        time.sleep_ms(10)
        self.res(1)
        super().__init__(width, height, external_vcc)
 
    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(0)
        self.cs(0)
        self.spi.write(bytearray([cmd]))
        self.cs(1)
 
    def write_data(self, buf):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs(1)
        self.dc(1)
        self.cs(0)
        self.spi.write(buf)
        self.cs(1)

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces

from micropython import const

import framebuf

# register definitions

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)

# Subclassing FrameBuffer provides support for graphics primitives

# http://docs.micropython.org/en/latest/pyboard/library/framebuf.html

class SSD1306(framebuf.FrameBuffer):

def __init__(self, width, height, external_vcc):

self.width = width

self.height = height

self.external_vcc = external_vcc

self.pages = self.height // 8

self.buffer = bytearray(self.pages * self.width)

super().__init__(self.buffer, self.width, self.height, framebuf.MONO_VLSB)

self.init_display()

def init_display(self):

for cmd in (

SET_DISP | 0x00, # off

# address setting

SET_MEM_ADDR,

0x00, # horizontal

# resolution and layout

SET_DISP_START_LINE | 0x00,

SET_SEG_REMAP | 0x01, # column addr 127 mapped to SEG0

SET_MUX_RATIO,

self.height - 1,

SET_COM_OUT_DIR | 0x08, # scan from COM[N] to COM0

SET_DISP_OFFSET,

0x00,

SET_COM_PIN_CFG,

0x02 if self.width > 2 * self.height else 0x12,

# timing and driving scheme

SET_DISP_CLK_DIV,

0x80,

SET_PRECHARGE,

0x22 if self.external_vcc else 0xF1,

SET_VCOM_DESEL,

0x30, # 0.83*Vcc

# display

SET_CONTRAST,

0xFF, # maximum

SET_ENTIRE_ON, # output follows RAM contents

SET_NORM_INV, # not inverted

# charge pump

SET_CHARGE_PUMP,

0x10 if self.external_vcc else 0x14,

SET_DISP | 0x01,

): # on

self.write_cmd(cmd)

self.fill(0)

self.show()

def poweroff(self):

self.write_cmd(SET_DISP | 0x00)

def poweron(self):

self.write_cmd(SET_DISP | 0x01)

def contrast(self, contrast):

self.write_cmd(SET_CONTRAST)

self.write_cmd(contrast)

def invert(self, invert):

self.write_cmd(SET_NORM_INV | (invert & 1))

def show(self):

x0 = 0

x1 = self.width - 1

if self.width == 64:

# displays with width of 64 pixels are shifted by 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)

class SSD1306_I2C(SSD1306):

def __init__(self, width, height, i2c, addr=0x3C, external_vcc=False):

self.i2c = i2c

self.addr = addr

self.temp = bytearray(2)

self.write_list = [b"\x40", None] # Co=0, D/C#=1

super().__init__(width, height, external_vcc)

def write_cmd(self, cmd):

self.temp[0] = 0x80 # Co=1, D/C#=0

self.temp[1] = cmd

self.i2c.writeto(self.addr, self.temp)

def write_data(self, buf):

self.write_list[1] = buf

self.i2c.writevto(self.addr, self.write_list)

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

import time

self.res(1)

time.sleep_ms(1)

self.res(0)

time.sleep_ms(10)

self.res(1)

super().__init__(width, height, external_vcc)

def write_cmd(self, cmd):

self.spi.init(baudrate=self.rate, polarity=0, phase=0)

self.cs(1)

self.dc(0)

self.cs(0)

self.spi.write(bytearray([cmd]))

self.cs(1)

def write_data(self, buf):

self.spi.init(baudrate=self.rate, polarity=0, phase=0)

self.cs(1)

self.dc(1)

self.cs(0)

self.spi.write(buf)

self.cs(1)

main.py

После загрузки SSD1306.py снова создайте новую вкладку и скопируйте следующий код. Сохраните этот код под именем main.py.

# Display Image & text on I2C driven ssd1306 OLED display 
from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import machine
import utime
import onewire, ds18x20, time
 
ds_pin = machine.Pin(22)
 
ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))
 
roms = ds_sensor.scan()
 
print('Found DS devices: ', roms)
 
WIDTH  = 128                                            # oled display width
HEIGHT = 64                                             # oled display height
 
i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000)       # Init I2C using pins GP8 & GP9 (default I2C0 pins)
print("I2C Address      : "+hex(i2c.scan()[0]).upper()) # Display device address
print("I2C Configuration: "+str(i2c))                   # Display I2C config
 
 
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c)                  # Init oled display
 
 
while True:
 
  ds_sensor.convert_temp()
 
  time.sleep_ms(750)
 
  for rom in roms:
 
    print(rom)
 
    print(ds_sensor.read_temp(rom))
 
  # Clear the oled display in case it has junk on it.
    oled.fill(0)       
    
    # Add some text
    oled.text("Temperature: ",12,8)
    oled.text(str(round(ds_sensor.read_temp(rom),2)),30,30)
    oled.text("*C",75,30)
    utime.sleep(2)
 
 
    # Finally update the oled display so the image & text is displayed
    oled.show()

# Display Image & text on I2C driven ssd1306 OLED display

from machine import Pin, I2C

from ssd1306 import SSD1306_I2C

import machine

import utime

import onewire, ds18x20, time

ds_pin = machine.Pin(22)

ds_sensor = ds18x20.DS18X20(onewire.OneWire(ds_pin))

roms = ds_sensor.scan()

print('Found DS devices: ', roms)

WIDTH = 128 # oled display width

HEIGHT = 64 # oled display height

i2c = I2C(0, scl=Pin(9), sda=Pin(8), freq=200000) # Init I2C using pins GP8 & GP9 (default I2C0 pins)

print("I2C Address : "+hex(i2c.scan()[0]).upper()) # Display device address

print("I2C Configuration: "+str(i2c)) # Display I2C config

oled = SSD1306_I2C(WIDTH, HEIGHT, i2c) # Init oled display

while True:

ds_sensor.convert_temp()

time.sleep_ms(750)

for rom in roms:

print(rom)

print(ds_sensor.read_temp(rom))

# Clear the oled display in case it has junk on it.

oled.fill(0)

# Add some text

oled.text("Temperature: ",12,8)

oled.text(str(round(ds_sensor.read_temp(rom),2)),30,30)

oled.text("*C",75,30)

utime.sleep(2)

# Finally update the oled display so the image & text is displayed

oled.show()

После запуска кода на OLED-дисплее начнет отображаться значение температуры.

Вот таким вот образом можно считывать данные о температуре с датчика температуры DS18B20 для платы Raspberry Pi Pico с помощью кода на MicroPython.

Необходимые компоненты

Водонепроницаемый цифровой датчик температуры DS18B20

Схема подключения

Исходный код программы

Отображение температуры на OLED дисплее

ssd1306.py

main.py

Похожие статьи

Добавить комментарий Отменить ответ

Добавить комментарий