from machine import Pin, SoftI2C, Timer
from ssd1306 import SSD1306_I2C
from dht import DHT22  # Importing DHT22 module

sda_pin = Pin(0)
scl_pin = Pin(1)
button_pin = Pin(10, Pin.IN, Pin.PULL_DOWN)
dht_pin = Pin(28, Pin.OPEN_DRAIN)

WIDTH = 128
HEIGHT = 64
OLED_ADDR = 0x3d
display_enabled = True

i2c = SoftI2C(scl=scl_pin, sda=sda_pin, freq=400000)
oled = SSD1306_I2C(WIDTH, HEIGHT, i2c) 

dht = DHT22(dht_pin)

def display(pin):

    global display_enabled
    if display_enabled == True:  
        display_enabled = False  

    elif display_enabled == False:  
        display_enabled = "temperature"  
        
    elif display_enabled == "temperature":  
        display_enabled = "humidity"  

    elif display_enabled == "humidity":  
        display_enabled = True  

def read_values(timer):
    global display_enabled

    if display_enabled == True:
        dht.measure() 
        temperature = dht.temperature()
        oled.fill(0)
        oled.text("Temp. = {:.2f}C".format(temperature), 0, 0, 1)
        oled.show()

    elif display_enabled == "temperature":
        dht.measure()
        temperature = dht.temperature()
        oled.fill(0)
        oled.text("Temp. = {:.2f}C".format(temperature), 0, 0, 1)
        oled.show()

    elif display_enabled == "humidity":
        dht.measure()
        humidity = dht.humidity()
        oled.fill(0)
        oled.text("Humidity = {:.2f}%".format(humidity), 0, 0, 1)
        oled.show()

    else:
        oled.fill(0)
        oled.text("Display Off", 0, 0, 1)
        oled.show()

button_pin.irq(trigger=Pin.IRQ_RISING | Pin.IRQ_FALLING, handler=display)
timer = Timer()
timer.init(period=100, mode=Timer.PERIODIC, callback=read_values)


main.py

diagram.json

# MicroPython SSD1327 OLED driver, I2C interface

import framebuf
import time

class OLED_1inch5(framebuf.FrameBuffer):
    def __init__(self, olde_addr, i2c):
        
        self.width  = 128
        self.height = 128
        
        self.rotate = 180 #only 0 and 180

        self.olde_addr = olde_addr

        self.i2c = i2c
        
        self.temp = bytearray(2)
        self.buffer = bytearray(self.height * self.width//2)

        super().__init__(self.buffer, self.width, self.height, framebuf.GS4_HMSB)
        self.init_display()
        
        self.white =   0xf
        self.balck =   0x0000
        
    def write_cmd(self, cmd):
        self.temp[0] = 0x00 
        self.temp[1] = cmd
        self.i2c.writeto(self.olde_addr, self.temp)

    def write_data(self, buf):
        self.i2c.writeto(self.olde_addr, b'\x40'+buf)
        
    def init_display(self):
        """Initialize dispaly"""  
        
        self.write_cmd(0xae)     #--turn off oled panel

        self.write_cmd(0x15)     #  set column address
        self.write_cmd(0x00)     #  start column   0
        self.write_cmd(0x7f)     #  end column   127

        self.write_cmd(0x75)     #   set row address
        self.write_cmd(0x00)     #  start row   0
        self.write_cmd(0x7f)     #  end row   127

        self.write_cmd(0x81)     # set contrast control
        self.write_cmd(0x80) 

        self.write_cmd(0xa0)     # gment remap
        self.write_cmd(0x51)     #51

        self.write_cmd(0xa1)     # start line
        self.write_cmd(0x00) 

        self.write_cmd(0xa2)     # display offset
        self.write_cmd(0x00) 

        self.write_cmd(0xa4)     # rmal display
        self.write_cmd(0xa8)     # set multiplex ratio
        self.write_cmd(0x7f) 

        self.write_cmd(0xb1)     # set phase leghth
        self.write_cmd(0xf1) 

        self.write_cmd(0xb3)     # set dclk
        self.write_cmd(0x00)     #80Hz:0xc1 90Hz:0xe1   100Hz:0x00   110Hz:0x30 120Hz:0x50   130Hz:0x70     01
 
        self.write_cmd(0xab)     #
        self.write_cmd(0x01)     #

        self.write_cmd(0xb6)     # set phase leghth
        self.write_cmd(0x0f) 

        self.write_cmd(0xbe) 
        self.write_cmd(0x0f) 

        self.write_cmd(0xbc) 
        self.write_cmd(0x08) 

        self.write_cmd(0xd5) 
        self.write_cmd(0x62) 

        self.write_cmd(0xfd) 
        self.write_cmd(0x12) 

        time.sleep(0.1)
        self.write_cmd(0xAF)    #--turn on oled panel
        
    def setwindows(self, Xstart, Ystart, Xend, Yend):
        if((Xstart > self.width) or (Ystart > self.height) or (Xend > self.width) or (Yend > self.height)):
            return
        self.write_cmd(0x15)
        self.write_cmd(Xstart//2)
        self.write_cmd(Xend//2 - 1)

        self.write_cmd(0x75)
        self.write_cmd(Ystart)
        self.write_cmd(Yend - 1)
        
    def show(self):
        self.setwindows(0, 0, 128, 128)
        self.write_data(self.buffer)
        # for i in range(0, self.height):
        #     for j in range(0, self.width//2):
        #             self.write_data(self.buffer[j+self.width//2*i])
        return

OLED_1inch5.py

# MicroPython SSD1306 OLED driver, I2C and SPI interfaces
#
# library taken from repository at:
# https://github.com/micropython/micropython/blob/master/drivers/display/ssd1306.py
#
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)

# only required for SPI version (not covered in this project)
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)

ssd1306.py

from machine import Pin,I2C
from struct import unpack_from
import time

SHTC3_REG_SLEEP                 = 0xB098    # Enter sleep mode
SHTC3_REG_WAKEUP                = 0x3517    # Wakeup mode
SHTC3_REG_SOFTRESET             = 0x805D    # Soft Reset
SHTC3_REG_READID                = 0xEFC8    # Read Out of ID Register

SHTC3_REG_NORMAL_T_F            = 0x7866    # Read T First And Clock Stretching Disabled In Normal Mode
SHTC3_REG_NORMAL_H_F            = 0x58E0    # Read H First And Clock Stretching Disabled In Normal Mode

SHTC3_REG_NORMAL_T_F_STRETCH    = 0x7CA2    # Read T First And Clock Stretching Enabled In Normal Mode
SHTC3_REG_NORMAL_H_F_STRETCH    = 0x5C24    # Read H First And Clock Stretching Enabled In Normal Mode

SHTC3_REG_LOWPOWER_T_F          = 0x609C    # Read T First And Clock Stretching Disabled In Lowpower Mode
SHTC3_REG_LOWPOWER_H_F          = 0x401A    # Read T First And Clock Stretching Disabled In Lowpower Mode

SHTC3_REG_LOWPOWER_T_F_STRETCH  = 0x6458    # Read T First And Clock Stretching Enabled In Lowpower Mode
SHTC3_REG_LOWPOWER_H_F_STRETCH  = 0x44DE    # Read T First And Clock Stretching Enabled In Lowpower Mode

SHTC3_NORMAL_MEAS               = [SHTC3_REG_NORMAL_T_F,SHTC3_REG_NORMAL_H_F]
SHTC3_NORMAL_MEAS_STRETCH       = [SHTC3_REG_NORMAL_T_F_STRETCH,SHTC3_REG_NORMAL_H_F_STRETCH]
SHTC3_LOWPOWER_MEAS             = [SHTC3_REG_LOWPOWER_T_F,SHTC3_REG_LOWPOWER_H_F]
SHTC3_LOWPOWER_MEAS_STRETCH     = [SHTC3_REG_LOWPOWER_T_F_STRETCH,SHTC3_REG_LOWPOWER_H_F_STRETCH]

SHTC3_MEAS                      = [SHTC3_NORMAL_MEAS,SHTC3_LOWPOWER_MEAS]
SHTC3_MEAS_STRETCH              = [SHTC3_NORMAL_MEAS_STRETCH,SHTC3_LOWPOWER_MEAS_STRETCH]

SHTC3_MEAS_ALL                  = [SHTC3_MEAS,SHTC3_MEAS_STRETCH]
class  SHTC3(object):    
    def __init__(self,i2c ,address):
        self._address = address
        self.cmd = bytearray(2)
        self.buffer = bytearray(6)
        self.i2c = i2c
        
        #Avoid Distractions
        self.i2c.writeto(self._address,bytes([0,0,0]))
        print("SHTC3 ID = {:x}".format(self.read_id()))


    @staticmethod
    def crc8(buffer: bytearray) -> int:
        """verify the crc8 checksum"""
        crc = 0xFF
        for byte in buffer:
            crc ^= byte
            for _ in range(8):
                if crc & 0x80:
                    crc = (crc << 1) ^ 0x31
                    
                else:
                    crc = crc << 1
                #print(crc)
        return crc & 0xFF  # return the bottom 8 bits
    
    def write_command(self,command:int):
        self.cmd[0] = command>>8
        self.cmd[1] = command & 0xff
        self.i2c.writeto(self._address,self.cmd)

    def sleep(self):
        self.write_command(SHTC3_REG_SLEEP)
        time.sleep_us(300)
    def wakeup(self):
        self.write_command(SHTC3_REG_WAKEUP)
        time.sleep_us(300)
    def soft_reset(self):
        self.write_command(SHTC3_REG_SOFTRESET)
        time.sleep_us(300)

    def read_id(self):
        self.write_command(SHTC3_REG_READID)
        self.buffer=self.i2c.readfrom(self._address,3)
        #id_crc = self.buffer[2]
        #id_buffer =self.buffer[0:2]
        #id_crc_checksum = self.crc8(id_buffer)
        id = (self.buffer[0]<<8)+self.buffer[1]
        #print(self.buffer)
        #print("id = 0x{:x}, crc = {:x}, crc_checksum = {:x}".format(id,id_crc,id_crc_checksum))
        
        return id

    def measurement(self,hum_frist=False,low_power_meas=False,stretch =False):
        # ultra-low power consumption comes at the cost of reduced repeatability of the sensor signals
        # while the impact on the relative humidity signal is negligible and does not affect accuracy
        # it has an effect on temperature accuracy
        command = SHTC3_MEAS_ALL[stretch][low_power_meas][hum_frist]
        self.write_command(command)
        if low_power_meas :
            time.sleep_ms(2)
        else:
            time.sleep_ms(14)
        self.buffer=self.i2c.readfrom(self._address,6)
        temp_data = self.buffer[hum_frist*3:hum_frist*3+2]
        temp_data_crc = self.buffer[hum_frist*3+2]
        hum_data = self.buffer[(not hum_frist)*3:(not hum_frist)*3+2]
        hum_data_crc = self.buffer[(not hum_frist)*3+2]

        if temp_data_crc != self.crc8(temp_data) or hum_data_crc != self.crc8(hum_data):
            print("crc error")
            print("buffer ={}".format(self.buffer))
            print("temp_data ={}".format(temp_data))
            print("temp_data_crc ={}".format(temp_data_crc))
            print("temp_data crc8 ={}".format(self.crc8(temp_data)))
            print("")
            return (0,0)
        else :
            T_RAW   =(temp_data[1]+(temp_data[0]<<8))
            RH_RAW  =(hum_data[1]+(hum_data[0]<<8))
            T  =(T_RAW  *175.0)/(1<<16)-45
            RH =(RH_RAW *100.0)/(1<<16)
            return (T,RH)