MicroPython: แสดงอุณหภูมิจาก DHT22 ที่จอ OLED ด้วย ESP32

บทความนี้นี้แสดงวิธีใช้เซ็นเซอร์อุณหภูมิและความชื้น DHT22 กับบอร์ดพัฒนา ESP32 ให้แสดงผลที่ Python shell และ แสดงผลที่จอแสดงผล OLED โดยใช้เฟิร์มแวร์ MicroPython

เซ็นเซอร์ DHT22 เมื่อเปรียบเทียบกับ DHT11 จะมีความละเอียดที่ดีกว่าและช่วงการวัดอุณหภูมิและความชื้นที่กว้างขึ้น อย่างไรก็ตามมันมีราคาแพงกว่า เล็กน้อยและคุณสามารถขออ่านได้ด้วยช่วงเวลา 2 วินาทีเท่านั้น



### อุปกรณ์ที่ใช้ ###


1. PICO KIT V4 ESP32 Development Board WiFi + Bluetooth

2. Micro USB Cable Wire 1m for NodeMCU

3. Breadboard 830 Point MB-102

4. Jumper (M2M) 20cm Male to Male

5. Blue OLED Display 0.96 inch 128X64 Module

6. DHT22/AM2302 เซ็นเซอร์วัดอุณหภูมิและความชื้น

7. รีซิสเตอร์ 10K Ohm 1/4W 5%



โดยขั้นตอนการทำงานมีดังนี้


1. เริ่มต้นใช้งาน MicroPython กับ ESP32 ด้วย uPyCraft IDE


2. การใช้งานจอแสดงผล OLED ด้วย ESP32




3. แสดงอุณหภูมิจาก DHT22 บน Python shell



DHT Pinout

เซ็นเซอร์ DHT มีสี่ขาดังแสดงในรูปต่อไปนี้

ตารางต่อไปนี้แสดง Pinout DHT22 เมื่อเซ็นเซอร์หันหน้าเข้าหาคุณการกำหนดหมายเลขเริ่มต้นที่ 1 จากซ้ายไปขวา

DHT pin	Connect to
1	3.3V
2	GPIO 14  , 10k Ohm pull-up resistor
3	Don’t connect
4	GND

ต่อเซ็นเซอร์ DHT22 เข้ากับบอร์ด ESP32 ดังที่แสดงในแผนผังไดอะแกรมต่อไปนี้

ในตัวอย่างนี้เรากำลังเชื่อมต่อสายข้อมูล DHT22 กับ GPIO 14 อย่างไรก็ตามคุณสามารถใช้พินดิจิทัลที่เหมาะสมอื่น ๆ ได้


3.1 อัพโหลดโค้ด ไฟล์ main.py


แก้ไขไฟล์ main.py ที่เคยสร้างไว้แล้ว (อยู่ที่คอมพิวเตอร์เรา workSpace) ตามโค้ดด้านล่าง โดยโค้ดนี้จะรับอุณหภูมิจากเซ็นเซอร์อุณหภูมิ DHT22 และแสดงการอ่านที่ Python shell

from machine import Pin
from time import sleep
import dht 

sensor = dht.DHT22(Pin(14))

while True:
  try:
    sleep(2)
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    temp_f = temp * (9/5) + 32.0
    print('Temperature: %3.1f C' %temp)
    print('Temperature: %3.1f F' %temp_f)
    print('Humidity: %3.1f %%' %hum)
  except OSError as e:
    print('Failed to read sensor.')

อัพโหลดโค้ด main.py ไปยัง บอร์ด ESP32 หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า download ok ที่ Python shell แถบด้านล่าง

และที่ Python shell จะแสดงอุณหภูมิที่วัดได้จาก DHT22 เป็นองศาเซลเซียส , องศาฟาเรนไฮต์ และ ความชื้น (แสดงว่าประสบความสำเร็จแล้ว)

โค้ดทำงานอย่างไร

นำเข้าคลาส Pin จากโมดูล machine เพื่อกำหนดพิน นำเข้า sleep จากโมดูล time ใช่สำหรับการหน่วงเวลา และก็นำเข้าโมดูล dht เพื่อนำเข้าฟังก์ชั่นเพื่ออ่านจากเซ็นเซอร์ DHT

from machine import Pin
from time import sleep
import dht 

กำหนดวัตถุ dht ที่เรียกว่าเซ็นเซอร์บนพินข้อมูลที่ระบุ ในกรณีนี้เรากำลังเชื่อมต่อ data pin กับ GPIO 14

sensor = dht.DHT22(Pin(14))

เพิ่มการหน่วงเวลา 2 วินาที เนื่องจากอัตราการสุ่มตัวอย่างสูงสุดของ DHT22 คือ 2 วินาที

sleep(2)

ก่อนที่จะขออุณหภูมิและความชื้น คุณต้องใช้เมธอด measure()  บนวัตถุเซ็นเซอร์

sensor.measure()

จากนั้นอ่านอุณหภูมิด้วย sensor.temperature() และความชื้นด้วย sensor.humidity() บันทึกการอ่านเหล่านั้นในตัวแปร temp และ hum

temp = sensor.temperature()
hum = sensor.humidity()

คำสั่งต่อไปนี้แปลงอุณหภูมิเป็นองศาฟาเรนไฮต์

temp_f = temp * (9/5) + 32.0

แสดงการอ่านทั้งหมดที่ Python shell โดยใช้ฟังก์ชั่น print ():

print('Temperature: %3.1f C' %temp)
print('Temperature: %3.1f F' %temp_f)
print('Humidity: %3.1f %%' %hum)

ในกรณีที่มีข้อผิดพลาดในการอ่านค่า ให้แสดงข้อผิดพลาด : Failed to read sensor.

except OSError as e:
  print('Failed to read sensor.')

4. แสดงอุณหภูมิจาก DHT22 ที่จอ OLED

4.1 อัพโหลดโค้ด ไฟล์ main.py (อีกครั้ง)

แก้ไขไฟล์ main.py ที่เคยสร้างไว้แล้ว (อยู่ที่คอมพิวเตอร์เรา workSpace) ตามโค้ดด้านล่าง โดยโค้ดนี้จะรับอุณหภูมิจากเซ็นเซอร์อุณหภูมิ DHT22 และแสดงการอ่านที่จอ OLED

from machine import Pin, I2C
import ssd1306
from time import sleep
import dht 

i2c = I2C(-1, scl=Pin(22), sda=Pin(21))
sensor = dht.DHT22(Pin(14))

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

while True:
  try:
    sleep(2)
    sensor.measure()
    temp = sensor.temperature()
    hum = sensor.humidity()
    temp_f = temp * (9/5) + 32.0
    oled.text('T: %3.1f C' %temp, 0, 0)
    oled.text('T: %3.1f F' %temp_f, 0, 10)
    oled.text('H: %3.1f %%' %hum, 0, 20)
    oled.show()
  except OSError as e:
    oled.text('Failed to read sensor.', 0, 0)
    oled.show()

อัพโหลดโค้ด main.py ไปยัง บอร์ด ESP32 หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า download ok ที่ Python shell แถบด้านล่าง

และที่จอ OLED จะแสดงอุณหภูมิที่วัดได้จาก DHT22 เป็นองศาเซลเซียส , องศาฟาเรนไฮต์ และ ความชื้น (แสดงว่าประสบความสำเร็จแล้ว)

credit : https://randomnerdtutorials.com/esp32-esp8266-dht11-dht22-micropython-temperature-humidity-sensor/

MicroPython : การใช้งานจอแสดงผล OLED ด้วย ESP32

บทความนี้คุณจะได้เรียนรู้วิธีใช้จอแสดงผล OLED แบบ SSD1306 ขนาด 0.96 นิ้ว ด้วย ESP32 โดยใช้ MicroPython ตัวอย่างเช่นเราจะแสดงวิธีการแสดงข้อความ 'Hello, World!'  ต่อมาเราจะแสดงวิธีใช้ฟังก์ชันที่มีประโยชน์อื่น ๆ เพื่อโต้ตอบกับจอแสดงผล OLED


### อุปกรณ์ที่ใช้ ###


1. PICO KIT V4 ESP32 Development Board WiFi + Bluetooth

2. Micro USB Cable Wire 1m for NodeMCU

3. Breadboard 830 Point MB-102

4. Jumper (M2M) 20cm Male to Male

5. Blue OLED Display 0.96 inch 128X64 Module



โดยขั้นตอนการทำงานมีดังนี้


1. เริ่มต้นใช้งาน MicroPython กับ ESP32 ด้วย uPyCraft IDE



2. การใช้งานจอแสดงผล OLED ด้วย ESP32



เชื่อมต่อ ESP32 กับ จอแสดงผล OLED

OLED	ESP32
VCC	3.3V
GND	GND
SCL	GPIO 22
SDA	GPIO 21

3. อัพโหลดโค้ด


3.1 อัพโหลดโค้ด ไลบรารี OLED ไฟล์ ssd1306.py

สร้างไฟล์ ssd1306.py ซึ่งเป็นไลบรารีที่จะเขียนเพิ่มขึ้นสำหรับจอแสดงผล OLED โดยจะสร้างไว้ที่ workSpace ซึ่งส่วนนี้จะเก็บอยู่ที่ คอมพิวเตอร์ของเรา


3.1.2 คลิกที่ New file

3.1.3 เขียนโค้ดดังนี้

import time
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)


class SSD1306:
    def __init__(self, width, height, external_vcc):
        self.width = width
        self.height = height
        self.external_vcc = external_vcc
        self.pages = self.height // 8
        # Note the subclass must initialize self.framebuf to a framebuffer.
        # This is necessary because the underlying data buffer is different
        # between I2C and SPI implementations (I2C needs an extra byte).
        self.poweron()
        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.height == 32 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 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_framebuf()

    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)


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)
        # Add an extra byte to the data buffer to hold an I2C data/command byte
        # to use hardware-compatible I2C transactions.  A memoryview of the
        # buffer is used to mask this byte from the framebuffer operations
        # (without a major memory hit as memoryview doesn't copy to a separate
        # buffer).
        self.buffer = bytearray(((height // 8) * width) + 1)
        self.buffer[0] = 0x40  # Set first byte of data buffer to Co=0, D/C=1
        self.framebuf = framebuf.FrameBuffer1(memoryview(self.buffer)[1:], width, height)
        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_framebuf(self):
        # Blast out the frame buffer using a single I2C transaction to support
        # hardware I2C interfaces.
        self.i2c.writeto(self.addr, self.buffer)

    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
        self.buffer = bytearray((height // 8) * width)
        self.framebuf = framebuf.FrameBuffer1(self.buffer, width, height)
        super().__init__(width, height, external_vcc)

    def write_cmd(self, cmd):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.low()
        self.cs.low()
        self.spi.write(bytearray([cmd]))
        self.cs.high()

    def write_framebuf(self):
        self.spi.init(baudrate=self.rate, polarity=0, phase=0)
        self.cs.high()
        self.dc.high()
        self.cs.low()
        self.spi.write(self.buffer)
        self.cs.high()

    def poweron(self):
        self.res.high()
        time.sleep_ms(1)
        self.res.low()
        time.sleep_ms(10)
        self.res.high()

3.1.4 คลิกที่ Save file

3.1.5 ตั้งชื่อไฟล์ เป็น ssd1306.py -> ok

3.1.6 อัพโหลดโค้ด ไปที่ ESP32

หากสามารถอัพโหลดโปรแกรมลงบอร์ดได้สำเร็จ จะแสดงคำว่า download ok ที่แถบด้านล่าง

3.1.7 ไปที่ device จะพบไฟล์ ssd1306.py ที่เราอัพโหลดเข้าไปที่ บอร์ด ESP32

3.2 อัพโหลดโค้ด ไฟล์ main.py


3.2.1  แก้ไขไฟล์ main.py ที่เคยสร้างไว้แล้ว (อยู่ที่คอมพิวเตอร์เรา workSpace) ตามโค้ดด้านล่าง

# Complete project details at https://RandomNerdTutorials.com

from machine import Pin, I2C
import ssd1306
from time import sleep

# ESP32 Pin assignment 
i2c = I2C(-1, scl=Pin(22), sda=Pin(21))

oled_width = 128
oled_height = 64
oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
        
oled.show()

โค้ดทำงานอย่างไร

เริ่มต้นด้วยการนำเข้าโมดูลที่จำเป็นเพื่อทำงานกับ GPIO และส่งข้อมูลไปยัง OLED ผ่านการสื่อสาร I2C คุณต้องนำเข้าคลาส Pin และ I2C จากโมดูล machine

from machine import Pin, I2C

คุณต้องนำเข้าไลบรารี OLED ที่คุณอัปโหลดไปยังบอร์ด ESP32 ชื่อไฟล์ ssd1306.py ก่อนหน้านี้

import ssd1306

I2C เป็นการสื่อสารอนุกรม แบบซิงโครนัส (Synchronous) เพื่อใช้ ติดต่อสื่อสาร ระหว่าง ไมโครคอนโทรลเลอร์ (MCU) กับอุปกรณ์ภายนอก โดยใช้สายสัญญาณเพียง 2 เส้นเท่านั้น คือ serial data (SDA) และสาย serial clock (SCL) 

พิน I2C เริ่มต้นของ ESP32 คือ GPIO 22 (SCL) และ GPIO 21 (SDA)

#ESP32 Pin assignment
i2c = I2C(-1, scl=Pin(22), sda=Pin(21))

กำหนดความกว้างและความสูง OLED ของตัวแปรต่อไปนี้: 

oled_width = 128
oled_height = 64

หลังจากนั้นสร้างออบเจ็กต์ SSD1306_I2C ชื่อ oled ออบเจ็กต์นี้เรียกใช้ความกว้าง OLED ความสูงและพิน I2C ที่คุณกำหนดไว้ก่อนหน้านี้

oled = ssd1306.SSD1306_I2C(oled_width, oled_height, i2c)

หลังจากเริ่มต้นการแสดงผล OLED คุณเพียงแค่ต้องใช้ฟังก์ชัน text () ของ ออบเจ็กต์ oled เพื่อเขียนข้อความ หลังจากฟังก์ชั่น text () คุณต้องเรียกใช้เมธอด show () เพื่ออัปเดต OLED

oled.text('Hello, World 1!', 0, 0)
oled.text('Hello, World 2!', 0, 10)
oled.text('Hello, World 3!', 0, 20)
oled.show()

การใช้งาน ฟังก์ชั่น text() ต้องการตามลำดับนี้

ข้อความ: ต้องเป็นประเภทสตริง
ตำแหน่ง X: ตำแหน่งที่ข้อความเริ่มต้น
ตำแหน่ง Y: ตำแหน่งที่ข้อความจะปรากฏในแนวตั้ง
สีข้อความ: มันอาจเป็นสีดำหรือสีขาว แต่สีเริ่มต้นจะเป็นสีขาว (จึงไม่ต้องเขียนโค้ด)
และถ้าจะกำหนดพารามิเตอร์นี้คือ 0 = สีดำ และ 1 = สีขาว

ตัวอย่างเช่นบรรทัดต่อไปนี้เขียนข้อความ ‘Hello, World 1!’ เป็นสีขาว ข้อความเริ่มต้นที่ x = 0 และ y = 0

oled.text('Hello, World 1!', 0, 0)

จากนั้นเขียนข้อความในบรรทัดถัดไป (x = 0 และ y = 10)

oled.text('Hello, World 2!', 0, 10)

ท้ายที่สุดเพื่อให้การเปลี่ยนแปลงมีผล ต้องเรียกใช้ใช้เมธอด show () ของ ออบเจ็กต์ oled

oled.show()

4. ทดสอบการทำงาน


4.2 อัพโหลดโค้ด main.py ไปยัง บอร์ด ESP32

5. ผลลัพธ์การแสดงผลของ จอแสดงผล OLED

credit : https://randomnerdtutorials.com/micropython-oled-display-esp32-esp8266/