DHT11 온도 및 습도 센서를 라즈베리파이 Pico 및 SSD1306 OLED와 인터페이스하기
목차
소개
필요한 자료
라즈베리파이 피코 개요
DHT11 센서 이해
SSD1306 OLED 디스플레이
라즈베리 파이 파이코 핀 다이어그램:
회로 연결
프로그래밍:
ssd1306.py:
dht.py:
main.py:
코드 설명:
결론
관련 문서:
소개
DHT11 온도 및 습도 센서를 라즈베리파이 파이 파이코 및 SSD1306 OLED와 인터페이스하기 - DHT11 온도 및 습도 센서는 경제성과 사용 편의성으로 인해 많은 DIY 프로젝트에서 인기 있는 선택입니다. 이 글에서는 DHT11 온도 센서를 라즈베리 파이 파이 파이코 및 SSD1306 OLED 디스플레이와 인터페이스하는 방법을 살펴봅니다. 이 조합을 통해 작고 사용자 친화적인 방식으로 실시간 온도 및 습도 판독값을 모니터링하고 표시할 수 있습니다.
필수 준비 재료
라즈베리 파이 피코
DHT11 온도 및 습도 센서
SSD1306 OLED 디스플레이(일반적으로 0.96")
브레드보드
점퍼 와이어
*참고: 제휴 링크입니다. 이 링크를 통해 부품을 구매하면 수수료를 받을 수 있습니다. 이런 식으로 후원해주시면 감사하겠습니다!
라즈베리파이 피코 개요
RP2040으로 구동되는 다용도 마이크로컨트롤러 보드로, 듀얼 코어 ARM Cortex-M0+ 프로세서를 탑재하고 있어 다양한 전자 프로젝트에 적합합니다.
프로세서
최대 133MHz까지 실행할 수 있는 듀얼 코어 ARM Cortex-M0+ 프로세서.
메모리
264KB의 SRAM.
2MB의 온보드 플래시 메모리.
GPIO 핀
3개의 아날로그 입력을 포함한 26개의 다기능 GPIO 핀.
인터페이스
2 × SPI, 2 × I2C, 2 × UART, 3 × 12비트 ADC, 16 × 제어 가능한 PWM 채널.
USB 1.1 컨트롤러 및 PHY 1개, 호스트 및 장치 지원.
전원 공급 장치
1.8V ~ 5.5V DC 작동 전압.
추가 기능
온보드 LED: GPIO 핀에 연결된 프로그래밍 가능한 LED.
지원 언어: 마이크로파이썬 및 C/C++.
디버깅: 디버깅을 위한 SWD 포트.
크기: 21mm × 51mm.
온도 범위: 작동 온도: -20°C ~ +85°C.
DHT11 센서 이해
온도와 습도를 측정하는 데 널리 사용되는 저비용 디지털 센서로, 대부분의 취미용 애플리케이션에 사용하기에 인터페이스가 간편하고 정확도가 높은 것으로 알려져 있습니다.
습도 측정
습도 범위: 20~80% RH(상대 습도).
습도 정확도: ±5% RH.
습도 분해능: 1% RH.
온도 측정
온도 범위: 0-50°C.
온도 정확도: ±2°C.
온도 분해능: 1°C.
기타 사양
작동 전압: 3 ~ 5.5V.
출력: 디지털 신호.
샘플링 속도: 매초마다 측정할 수 있습니다.
장기적인 안정성: <±1% RH/년.
크기 및 치수: 작고 시스템 및 장치에 쉽게 통합할 수 있습니다.
사용 용이성: 간단한 디지털 제어 및 출력, 아두이노 및 라즈베리 파이와 같은 마이크로컨트롤러와의 간단한 인터페이스.
전력 소비: 배터리로 작동하는 애플리케이션에 적합한 낮은 전력 소비.
응답 시간: 습도 - 5초, 온도 - 1초.
SSD1306 OLED 디스플레이
온도 및 습도와 같은 데이터를 표시하는 데 적합한 소형 흑백 OLED 디스플레이입니다. 높은 명암비, 넓은 시야각, 낮은 전력 소비로 유명합니다.
디스플레이 특성
디스플레이 유형: 흑백 OLED(유기 발광 다이오드).
해상도: 일반적으로 128×64픽셀, 변형에 따라 다를 수 있습니다.
색상: 단색(보통 파란색 또는 흰색).
커뮤니케이션 인터페이스
I2C(집적 회로) 또는 SPI(직렬 주변 장치 인터페이스) 옵션.
드라이버 IC: 디스플레이 구동을 담당하는 SSD1306.
기술 사양
작동 전압: 3.3V ~ 5V.
시야각: 약 160도.
픽셀 크기: 고해상도 디스플레이에 적합하도록 작습니다.
디스플레이 크기: 일반적으로 대각선 0.96인치, 다른 크기도 사용 가능.
밝기: 높음, 소프트웨어를 통해 조정 가능.
낮은 전력 소비: 배터리로 구동되는 애플리케이션에 이상적입니다.
작동 온도: 일반적으로 -20°C ~ 70°C.
치수: 화면 크기 - 0.96인치(대각선), 활성 디스플레이 영역 - 약 21.74mm x 10.86mm, 모듈 크기 - 약 27mm x 27mm x 4mm(WxHxD).
라즈베리파이 피코 핀 다이어그램:
회로 연결도
DHT11 센서와 SSD1306 OLED 디스플레이를 라즈베리파이 Pico에 연결하는 것은 간단한 과정으로, 실시간 환경 데이터를 표시하는 Pico의 기능을 향상시킬 수 있습니다. 먼저 DHT11 센서의 VCC 핀을 Pico의 3.3V 핀에 연결하여 안정적인 전원 공급을 보장합니다. 전원 회로를 완성하려면 DHT11의 접지(GND) 핀을 Pico의 접지 핀 중 하나에 연결해야 합니다. 데이터 전송을 위해서는 DHT11의 데이터 출력 핀을 GP15와 같은 Pico의 범용 입력/출력(GPIO) 핀에 연결해야 합니다. 이 설정을 통해 Pico는 DHT11에서 온도 및 습도 판독값을 수신할 수 있습니다.
SSD1306 OLED 디스플레이를 통합할 때도 비슷한 연결이 필요합니다. 먼저 디스플레이의 VCC 핀을 라즈베리 파이 Pico의 3.3V 핀에 연결하여 디스플레이에 전원을 공급합니다. OLED 디스플레이의 GND 핀을 Pico의 접지 핀에 연결하여 공통 접지를 설정합니다. 데이터 통신을 위해 디스플레이의 SCL(직렬 클럭 라인) 핀을 Pico의 SCL 핀에 연결해야 하며, 이 경우 GP17과 연결합니다. 마찬가지로 OLED 디스플레이의 SDA(직렬 데이터 라인) 핀을 Pico의 SDA 핀(이 경우 GP16과 연결됨)에 연결합니다. 이 구성을 통해 Pico는 명령과 데이터를 OLED 디스플레이로 전송하여 텍스트, 그래픽 또는 DHT11 센서에서 수신한 센서 데이터를 표시할 수 있습니다.
더 쉬운 설정을 위해 브레드보드를 사용하는 등 모든 연결이 안전한지 확인합니다.
프로그래밍:
이 프로젝트를 실행하려면 Thonny IDE 또는 원하는 다른 IDE가 설치되어 있는지 확인하세요. 이 프로젝트에서는 세 가지 스크립트, 즉 ssd1306.py, dht.py 및 main.py를 사용합니다. ssd1306.py 파일은 이전 글에서 설명한 SSD1306 OLED 디스플레이 모듈의 드라이버 코드에 사용됩니다. dht.py 파일에는 DHT11 온도 및 습도 센서에 대한 라이브러리 코드가 포함됩니다. 아시다시피 DHT11 온도 및 습도 센서는 라이브러리 없이는 작동하지 않습니다. 마지막으로, main.py 파일에서 SSD1306 OLED 디스플레이 모듈에 온도와 습도를 표시할 프로젝트의 실제 코드를 작성합니다.
ssd1306.py:
먼저 Thonny IDE를 열고 새 파일을 생성한 다음 아래에 제공된 코드를 복사하여 붙여넣은 다음 이 코드를 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)
dht.py:
이제 새 파일을 다시 생성하고 이번에는 아래에 제공된 코드를 복사하여 붙여넣습니다. 그런 다음 이 코드를 라즈베리파이 Pico에 dht.py로 저장합니다.
import array
import micropython
import utime
from machine import Pin
from micropython import const
class InvalidChecksum(Exception):
pass
class InvalidPulseCount(Exception):
pass
MAX_UNCHANGED = const(100)
MIN_INTERVAL_US = const(200000)
HIGH_LEVEL = const(50)
EXPECTED_PULSES = const(84)
class DHT11:
_temperature: float
_humidity: float
def __init__(self, pin):
self._pin = pin
self._last_measure = utime.ticks_us()
self._temperature = -1
self._humidity = -1
def measure(self):
current_ticks = utime.ticks_us()
if utime.ticks_diff(current_ticks, self._last_measure) < MIN_INTERVAL_US and (
self._temperature > -1 or self._humidity > -1
):
# Less than a second since last read, which is too soon according
# to the datasheet
return
self._send_init_signal()
pulses = self._capture_pulses()
buffer = self._convert_pulses_to_buffer(pulses)
self._verify_checksum(buffer)
self._humidity = buffer[0] + buffer[1] / 10
self._temperature = buffer[2] + buffer[3] / 10
self._last_measure = utime.ticks_us()
@property
def humidity(self):
self.measure()
return self._humidity
@property
def temperature(self):
self.measure()
return self._temperature
def _send_init_signal(self):
self._pin.init(Pin.OUT, Pin.PULL_DOWN)
self._pin.value(1)
utime.sleep_ms(50)
self._pin.value(0)
utime.sleep_ms(18)
@micropython.native
def _capture_pulses(self):
pin = self._pin
pin.init(Pin.IN, Pin.PULL_UP)
val = 1
idx = 0
transitions = bytearray(EXPECTED_PULSES)
unchanged = 0
timestamp = utime.ticks_us()
while unchanged < MAX_UNCHANGED:
if val != pin.value():
if idx >= EXPECTED_PULSES:
raise InvalidPulseCount(
"Got more than {} pulses".format(EXPECTED_PULSES)
)
now = utime.ticks_us()
transitions[idx] = now - timestamp
timestamp = now
idx += 1
val = 1 - val
unchanged = 0
else:
unchanged += 1
pin.init(Pin.OUT, Pin.PULL_DOWN)
if idx != EXPECTED_PULSES:
raise InvalidPulseCount(
"Expected {} but got {} pulses".format(EXPECTED_PULSES, idx)
)
return transitions[4:]
def _convert_pulses_to_buffer(self, pulses):
"""Convert a list of 80 pulses into a 5 byte buffer
The resulting 5 bytes in the buffer will be:
0: Integral relative humidity data
1: Decimal relative humidity data
2: Integral temperature data
3: Decimal temperature data
4: Checksum
"""
# Convert the pulses to 40 bits
binary = 0
for idx in range(0, len(pulses), 2):
binary = binary << 1 | int(pulses[idx] > HIGH_LEVEL)
# Split into 5 bytes
buffer = array.array("B")
for shift in range(4, -1, -1):
buffer.append(binary >> shift * 8 & 0xFF)
return buffer
def _verify_checksum(self, buffer):
# Calculate checksum
checksum = 0
for buf in buffer[0:4]:
checksum += buf
if checksum & 0xFF != buffer[4]:
raise InvalidChecksum()
main.py:
마지막으로 세 번째이자 마지막 스크립트 파일을 만들고 프로젝트의 실제 코드를 여기에 붙여넣은 다음, 이 파일을 main.py라는 이름으로 저장합니다.
from machine import Pin, I2C
import ssd1306
from dht import DHT11
import time
# Initialize I2C for SSD1306
i2c = I2C(0, scl=Pin(17), sda=Pin(16))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
# Initialize DHT11
pin = Pin(15, Pin.OUT, Pin.PULL_DOWN)
dht_sensor = DHT11(pin)
while True:
try:
# Read data from DHT11
dht_sensor.measure()
temp = (dht_sensor.temperature)
hum = (dht_sensor.humidity)
# Clear the OLED display
oled.fill(0)
# Display the temperature and humidity
oled.text('Temp: {} *C'.format(temp), 0, 0)
oled.text('Humidity:{} %'.format(hum), 0, 10)
# Show the data on the display
oled.show()
# Wait for a while before reading again
time.sleep(2)
except OSError as e:
# Error handling
print('Failed to read sensor.')
세 개의 스크립트 파일을 모두 저장한 후 '실행' 버튼 또는 키보드의 'F5' 버튼을 누르기만 하면 됩니다.
실행 버튼을 클릭하면 SSD1306 OLED 디스플레이 모듈의 온도와 습도를 확인할 수 있습니다.
보시다시피 라이터를 이용해 열을 가하자 온도와 습도가 달라졌습니다.
장황한 코드 설명:
from machine import Pin, I2C
import ssd1306
from dht import DHT11
import time
이는 머신 모듈에서 핀 및 I2C 클래스를 가져오는 데 중요한 머신 임포트 핀, I2C의 문으로 시작됩니다. 이 모듈은 마이크로컨트롤러 프로그래밍의 표준으로, 하드웨어 컴포넌트와의 직접적인 상호 작용을 용이하게 합니다. 다음으로 스크립트에는 ssd1306 모듈을 가져오는 import ssd1306이 포함되어 있습니다. 이 모듈은 I2C 통신 프로토콜을 사용하여 SSD1306 기반 OLED 디스플레이를 제어하도록 특별히 설계되어 디스플레이 기능을 처리하는 데 있어 그 중요성이 강조됩니다. 이어서 dht import DHT11은 dht 모듈에서 DHT11 클래스를 가져오는 데 사용됩니다. 이 클래스는 온도와 습도를 측정하는 데 일반적으로 사용되는 DHT11 센서와 인터페이스하는 데 필수적입니다. 마지막으로 스크립트는 가져오기 시간과 함께 시간 모듈을 가져옵니다. 시간 모듈은 지연 구현과 같은 다양한 시간 관련 기능을 제공하는 파이썬 표준 라이브러리의 기본 부분입니다.
i2c = I2C(0, scl=Pin(17), sda=Pin(16))
oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)
i2c = I2C(0, scl=Pin(17), sda=Pin(16)) 라인은 I2C 통신 프로토콜을 초기화하기 때문에 매우 중요합니다. 이는 GPIO 핀 17과 16을 각각 SCL(클록) 및 SDA(데이터) 라인으로 지정하여 수행됩니다. 이 핀은 마이크로컨트롤러와 I2C 호환 장치 간의 양방향 통신을 활성화하는 데 매우 중요합니다. 그 다음에는 OLED 디스플레이의 크기(이 경우 128×64픽셀)를 정의하는 oled_width 및 oled_height 변수가 설정됩니다. 이 사양은 디스플레이에서 그래픽과 텍스트가 올바르게 렌더링되도록 하는 데 필수적입니다. 마지막으로 oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c) 문으로 SSD1306 OLED 디스플레이의 인스턴스를 생성합니다. 이 코드 줄은 디스플레이를 인스턴스화할 뿐만 아니라 이전에 설정한 치수와 초기화된 I2C 인스턴스를 디스플레이에 전달하므로 매우 중요합니다. 이 구성은 디스플레이가 제대로 작동하는 데 필수적이며, 디스플레이가 I2C 프로토콜을 통해 데이터와 명령을 수신할 수 있도록 해줍니다.
pin = Pin(15, Pin.OUT, Pin.PULL_DOWN)
dht_sensor = DHT11(pin)
이 과정에서 핀 = 핀(15, 핀.OUT, 핀.풀다운) 문은 범용 입력/출력(GPIO) 핀, 특히 핀 15를 DHT11 센서에 맞게 구성하는 데 중요한 역할을 합니다. 이 구성에는 핀을 출력으로 설정하고 풀다운 저항을 활성화하는 작업이 포함됩니다. 풀다운 저항은 핀이 활발하게 높게 구동되지 않을 때 안정적인 낮은 로직 레벨을 보장하여 센서 작동을 위한 보다 안정적인 신호를 제공하기 때문에 매우 중요합니다. 이어서 dht_sensor = DHT11(pin) 코드는 DHT11 센서의 인스턴스를 생성하는 데 중요한 역할을 합니다. 이 줄은 구성된 핀을 DHT11 클래스에 전달함으로써 센서를 효과적으로 초기화하여 온도와 습도를 측정할 수 있도록 준비합니다. 이 초기화는 마이크로컨트롤러가 DHT11 센서와 상호 작용하고 환경 데이터를 검색할 수 있도록 하는 핵심 단계입니다.
while True:
try:
# Read data from DHT11
dht_sensor.measure()
temp = (dht_sensor.temperature)
hum = (dht_sensor.humidity)
# Clear the OLED display
oled.fill(0)
# Display the temperature and humidity
oled.text('Temp: {} *C'.format(temp), 0, 0)
oled.text('Humidity:{} %'.format(hum), 0, 10)
# Show the data on the display
oled.show()
# Wait for a while before reading again
time.sleep(2)
True 실행: 문을 사용하여 무한 루프를 시작하면 DHT11 센서의 데이터를 지속적으로 읽고 OLED 디스플레이에 표시하는 데 중요한 역할을 하는 무한 루프가 시작됩니다. 이 루프 내에서 몇 가지 작업이 순차적으로 수행됩니다. 먼저 dht_sensor.measure()가 호출되어 DHT11 센서를 활성화하여 새로운 온도 및 습도 측정 세트를 수행합니다. 그런 다음 온도 판독값을 검색하여 temp = dht_sensor.temperature를 사용하여 temp 변수에 저장하고, 마찬가지로 습도 판독값을 획득하여 hum = dht_sensor.humidity를 사용하여 hum에 저장합니다. 이러한 판독값을 얻은 후에는 이전 데이터가 새 판독값과 섞이지 않도록 oled.fill(0)으로 OLED 디스플레이를 지웁니다. 그런 다음 oled.text(...)를 사용하여 OLED 화면에 현재 온도 및 습도 값을 표시합니다. 이 함수는 디스플레이에서 텍스트의 서식을 지정하고 위치를 지정합니다. 텍스트가 설정되면 oled.show()가 호출되어 디스플레이를 새로 고쳐서 새 데이터가 표시되도록 합니다. 마지막으로 time.sleep(2)는 루프 실행을 2초 동안 일시 중지합니다. 이 지연은 데이터 홍수 및 잠재적인 센서 과열로 이어질 수 있는 빠르고 지속적인 센서 판독을 방지하여 시스템이 안정적으로 작동하고 센서 판독값이 관리 가능한 속도로 업데이트되도록 하는 데 필수적입니다.
except OSError as e:
# Error handling
print('Failed to read sensor.')
예외 처리 블록에서 OSError를 e:로 처리하는 것을 제외하면, 이는 OSError 예외를 포착하도록 특별히 설계되었습니다. 이러한 예외는 일반적으로 센서와 통신하는 데 문제가 있는 시나리오에서 발생합니다. 배선 문제, 센서 오작동, 통신 프로토콜 오류 등 다양한 원인으로 인해 발생할 수 있습니다. OSError를 포착하면 프로그램이 충돌하거나 예측할 수 없는 동작을 하는 대신 이러한 예기치 못한 오류를 우아하게 처리할 수 있습니다. 이러한 예외가 발생하면 print('Failed to read sensor.') 코드가 실행됩니다. 이 문은 사용자나 개발자에게 센서 판독 실패를 알리는 데 중요한 역할을 합니다. 이 함수는 콘솔 또는 지정된 출력 스트림에 '센서를 읽지 못했습니다'라는 오류 메시지를 출력합니다. 이러한 종류의 피드백은 센서 판독 프로세스의 실패 지점을 명확하게 표시하여 적시에 목표에 맞는 문제 해결을 가능하게 하므로 디버깅 및 유지 관리 목적에 매우 유용합니다.
결론
DHT11 온도 및 습도 센서를 라즈베리파이 피코 및 SSD1306 OLED 디스플레이와 연동하는 것은 보람 있는 프로젝트가 될 수 있습니다. 환경 조건을 모니터링할 수 있을 뿐만 아니라 인기 있는 구성 요소와 Python 프로그래밍 언어에 대한 실습 경험도 제공합니다. 취미로 하는 사람이든, 학생이든, 전문가든 이 프로젝트는 마이크로컨트롤러와 센서의 세계에 대한 귀중한 통찰력을 제공합니다.