commit 85d4b4f2cb8085a0458f6c9c36ecb3510479f3a1
Author: Andrew nuark G <me@nuark.xyz>
Date:   Sun Mar 26 15:56:15 2023 +0700

    Everything was done before

diff --git a/.picowgo b/.picowgo
new file mode 100644
index 0000000..2b7291a
--- /dev/null
+++ b/.picowgo
@@ -0,0 +1 @@
+{'info': 'This file is just used to identify a project folder.'}
\ No newline at end of file
diff --git a/bme280.py b/bme280.py
new file mode 100644
index 0000000..2f4263c
--- /dev/null
+++ b/bme280.py
@@ -0,0 +1,236 @@
+# Authors: Paul Cunnane 2016, Peter Dahlebrg 2016
+#
+# This module borrows from the Adafruit BME280 Python library. Original
+# Copyright notices are reproduced below.
+#
+# Those libraries were written for the Raspberry Pi. This modification is
+# intended for the MicroPython and esp8266 boards.
+#
+# Copyright (c) 2014 Adafruit Industries
+# Author: Tony DiCola
+#
+# Based on the BMP280 driver with BME280 changes provided by
+# David J Taylor, Edinburgh (www.satsignal.eu)
+#
+# Based on Adafruit_I2C.py created by Kevin Townsend.
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+# THE SOFTWARE.
+
+import time
+from ustruct import unpack, unpack_from
+from array import array
+
+# BME280 default address.
+BME280_I2CADDR = 0x76
+
+# Operating Modes
+BME280_OSAMPLE_1 = 1
+BME280_OSAMPLE_2 = 2
+BME280_OSAMPLE_4 = 3
+BME280_OSAMPLE_8 = 4
+BME280_OSAMPLE_16 = 5
+
+BME280_REGISTER_CONTROL_HUM = 0xF2
+BME280_REGISTER_CONTROL = 0xF4
+
+
+class BME280:
+    def __init__(
+        self, mode=BME280_OSAMPLE_1, address=BME280_I2CADDR, i2c=None, **kwargs
+    ):
+        # Check that mode is valid.
+        if mode not in [
+            BME280_OSAMPLE_1,
+            BME280_OSAMPLE_2,
+            BME280_OSAMPLE_4,
+            BME280_OSAMPLE_8,
+            BME280_OSAMPLE_16,
+        ]:
+            raise ValueError(
+                "Unexpected mode value {0}. Set mode to one of "
+                "BME280_ULTRALOWPOWER, BME280_STANDARD, BME280_HIGHRES, or "
+                "BME280_ULTRAHIGHRES".format(mode)
+            )
+        self._mode = mode
+        self.address = address
+        if i2c is None:
+            raise ValueError("An I2C object is required.")
+        self.i2c = i2c
+
+        # load calibration data
+        dig_88_a1 = self.i2c.readfrom_mem(self.address, 0x88, 26)
+        dig_e1_e7 = self.i2c.readfrom_mem(self.address, 0xE1, 7)
+        (
+            self.dig_T1,
+            self.dig_T2,
+            self.dig_T3,
+            self.dig_P1,
+            self.dig_P2,
+            self.dig_P3,
+            self.dig_P4,
+            self.dig_P5,
+            self.dig_P6,
+            self.dig_P7,
+            self.dig_P8,
+            self.dig_P9,
+            _,
+            self.dig_H1,
+        ) = unpack("<HhhHhhhhhhhhBB", dig_88_a1)
+
+        self.dig_H2, self.dig_H3 = unpack("<hB", dig_e1_e7)
+        e4_sign = unpack_from("<b", dig_e1_e7, 3)[0]
+        self.dig_H4 = (e4_sign << 4) | (dig_e1_e7[4] & 0xF)
+
+        e6_sign = unpack_from("<b", dig_e1_e7, 5)[0]
+        self.dig_H5 = (e6_sign << 4) | (dig_e1_e7[4] >> 4)
+
+        self.dig_H6 = unpack_from("<b", dig_e1_e7, 6)[0]
+
+        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL, bytearray([0x3F]))
+        self.t_fine = 0
+
+        # temporary data holders which stay allocated
+        self._l1_barray = bytearray(1)
+        self._l8_barray = bytearray(8)
+        self._l3_resultarray = array("i", [0, 0, 0])
+
+    def read_raw_data(self, result):
+        """Reads the raw (uncompensated) data from the sensor.
+
+        Args:
+            result: array of length 3 or alike where the result will be
+            stored, in temperature, pressure, humidity order
+        Returns:
+            None
+        """
+
+        self._l1_barray[0] = self._mode
+        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL_HUM, self._l1_barray)
+        self._l1_barray[0] = self._mode << 5 | self._mode << 2 | 1
+        self.i2c.writeto_mem(self.address, BME280_REGISTER_CONTROL, self._l1_barray)
+
+        sleep_time = 1250 + 2300 * (1 << self._mode)
+        sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
+        sleep_time = sleep_time + 2300 * (1 << self._mode) + 575
+        time.sleep_us(sleep_time)  # Wait the required time
+
+        # burst readout from 0xF7 to 0xFE, recommended by datasheet
+        self.i2c.readfrom_mem_into(self.address, 0xF7, self._l8_barray)
+        readout = self._l8_barray
+        # pressure(0xF7): ((msb << 16) | (lsb << 8) | xlsb) >> 4
+        raw_press = ((readout[0] << 16) | (readout[1] << 8) | readout[2]) >> 4
+        # temperature(0xFA): ((msb << 16) | (lsb << 8) | xlsb) >> 4
+        raw_temp = ((readout[3] << 16) | (readout[4] << 8) | readout[5]) >> 4
+        # humidity(0xFD): (msb << 8) | lsb
+        raw_hum = (readout[6] << 8) | readout[7]
+
+        result[0] = raw_temp
+        result[1] = raw_press
+        result[2] = raw_hum
+
+    def read_compensated_data(self, result=None):
+        """Reads the data from the sensor and returns the compensated data.
+
+        Args:
+            result: array of length 3 or alike where the result will be
+            stored, in temperature, pressure, humidity order. You may use
+            this to read out the sensor without allocating heap memory
+
+        Returns:
+            array with temperature, pressure, humidity. Will be the one from
+            the result parameter if not None
+        """
+        self.read_raw_data(self._l3_resultarray)
+        raw_temp, raw_press, raw_hum = self._l3_resultarray
+        # temperature
+        var1 = ((raw_temp >> 3) - (self.dig_T1 << 1)) * (self.dig_T2 >> 11)
+        var2 = (
+            ((((raw_temp >> 4) - self.dig_T1) * ((raw_temp >> 4) - self.dig_T1)) >> 12)
+            * self.dig_T3
+        ) >> 14
+        self.t_fine = var1 + var2
+        temp = (self.t_fine * 5 + 128) >> 8
+
+        # pressure
+        var1 = self.t_fine - 128000
+        var2 = var1 * var1 * self.dig_P6
+        var2 = var2 + ((var1 * self.dig_P5) << 17)
+        var2 = var2 + (self.dig_P4 << 35)
+        var1 = ((var1 * var1 * self.dig_P3) >> 8) + ((var1 * self.dig_P2) << 12)
+        var1 = (((1 << 47) + var1) * self.dig_P1) >> 33
+        if var1 == 0:
+            pressure = 0
+        else:
+            p = 1048576 - raw_press
+            p = (((p << 31) - var2) * 3125) // var1
+            var1 = (self.dig_P9 * (p >> 13) * (p >> 13)) >> 25
+            var2 = (self.dig_P8 * p) >> 19
+            pressure = ((p + var1 + var2) >> 8) + (self.dig_P7 << 4)
+
+        # humidity
+        h = self.t_fine - 76800
+        h = (
+            (((raw_hum << 14) - (self.dig_H4 << 20) - (self.dig_H5 * h)) + 16384) >> 15
+        ) * (
+            (
+                (
+                    (
+                        (
+                            ((h * self.dig_H6) >> 10)
+                            * (((h * self.dig_H3) >> 11) + 32768)
+                        )
+                        >> 10
+                    )
+                    + 2097152
+                )
+                * self.dig_H2
+                + 8192
+            )
+            >> 14
+        )
+        h = h - (((((h >> 15) * (h >> 15)) >> 7) * self.dig_H1) >> 4)
+        h = 0 if h < 0 else h
+        h = 419430400 if h > 419430400 else h
+        humidity = h >> 12
+
+        if result:
+            result[0] = temp
+            result[1] = pressure
+            result[2] = humidity
+            return result
+
+        return array("i", (temp, pressure, humidity))
+
+    @property
+    def values(self):
+        """human readable values"""
+
+        t, p, h = self.read_compensated_data()
+
+        p = p // 256
+        pi = p // 100
+        pd = p - pi * 100
+
+        hi = h // 1024
+        hd = h * 100 // 1024 - hi * 100
+        return (
+            "{}C".format(t / 100),
+            "{}.{:02d}hPa".format(pi, pd),
+            "{}.{:02d}%".format(hi, hd),
+        )
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..987b49f
--- /dev/null
+++ b/main.py
@@ -0,0 +1,26 @@
+import sys
+import time
+from machine import Pin, I2C
+
+from ssd1306 import SSD1306_I2C
+from bme280 import BME280, BME280_OSAMPLE_16
+
+# OLED
+i2c0 = I2C(0, sda=Pin(0), scl=Pin(1), freq=100000)
+display = SSD1306_I2C(128, 64, i2c0)
+display.fill(0)
+display.text("Wait...", 0, 0)
+display.show()
+
+# BME280
+i2c1 = I2C(1, scl=Pin(15), sda=Pin(14))
+bme = BME280(i2c=i2c1, mode=BME280_OSAMPLE_16)
+
+while True:
+    display.fill(0)
+    display.text("T&P", 0, 0)
+    d = bme.values
+    display.text(d[0], 0, 9)
+    display.text(d[1], 0, 18)
+    display.show()
+    time.sleep(1)
diff --git a/ssd1306.py b/ssd1306.py
new file mode 100644
index 0000000..6359c85
--- /dev/null
+++ b/ssd1306.py
@@ -0,0 +1,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)