BME280 Sensor With Raspberry Pi Pico W Using MicroPython Code

Introduction

In this post we will show you how to use the BME280 sensor with Raspberry Pi Pico W. We will be using MicroPython code to do this. This sensor can measure temperature, humidity, and pressure, and is perfect for use with the Raspberry Pi Pico. The code for this sensor is available on GitHub and is easy to use with the Raspberry Pi Pico. Also See Introduction to Raspberry Pi Pico W – Getting Started: Tutorials, Pinout

You Also Like this

For our project, we will use a library from a MicroPython, to read the BME280 sensor. Our application will display the readings on the Thonny Shell. After this part, we will try to display BME280 sensor readings on an OLED display which will provide you with more details on the weather monitoring system and weather conditions.

The BME280 library has all the commands to quickly handle the sensor, and commands to Communication via protocol Code, and circuits Examples: console reading, 0.96 OLED display sensor readings Library import

Required Components

You need the following components for this tutorial:

BME280 Sensor

The BME280 sensor from Bosch Sensortec is a low-cost sensor with good accuracy for measuring humidity, barometric pressure and temperature. It is based on the Bosch BME280 humidity and temperature sensor. the BME280 sensor is a great choice for a wide range of applications. It is accurate, has low power consumption, and is very small. You can grab a document of the BME280 Datasheet here.

The BME280 sensor is the favourite and most continuously used for monitoring the weather in a given city, home and other places. BME280 sensors produce measurements for temperature, humidity and atmospheric pressure which are important for any weather monitoring system. Without these parameters, we cannot create a special weather monitoring system in a given city or house.

Supply Voltage: 1.8 – 5V DC
Interface: I2C (up to 3.4MHz),
SPI (up to 10 MHz)

Operational Ranges:

Temperature: -40°C to +85°C, +-1°C
Humidity: 0-100%, -3%
Pressure: 300-1100 hPa, +-1Pa

Schematic Diagram – BME280 Sensor With Raspberry Pi Pico W

As declared before, BME280 works with the I2C protocol. So we just need 4 connections. Refer to the connection Figure below:

BME280	Raspberry Pi Pico
VCC	3.3V
SDA	GP0 (I2C0 SDA)
SCL	GP1 (I2C0 SCL)
GND	GND

Micropython Code & Libraries

The code for interfacing the BME280 Sensor with Raspberry Pi Pico separates into two parts:

bme280.py
main.py

The main code requires a library for BME280. The library consists of details of required modules and registers to extract the data from the Sensor.

bme280.py

Open your Thonny IDE, then paste the following code to the Thonny Editor and save the file as “bme280.py” in your Raspberry Pi Pico.

# 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))

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

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

# 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.

# 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

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

main.py

Open another tab on Thonny IDE and paste the following code and save the file as main.py on Raspberry Pi Pico

from machine import Pin, I2C        #importing relevant modules & classes
from time import sleep
import bme280       #importing BME280 library
 
i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)    #initializing the I2C method 
 
 
while True:
  bme = bme280.BME280(i2c=i2c)          #BME280 object created
  print(bme.values)
  sleep(5)           #delay of 5s

from machine import Pin, I2C #importing relevant modules & classes

from time import sleep

import bme280 #importing BME280 library

i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000) #initializing the I2C method

while True:

bme = bme280.BME280(i2c=i2c) #BME280 object created

print(bme.values)

sleep(5) #delay of 5s

Upload the first line and then run the main.py program. In case everything is ok, the shell will display two alignment texts and two coded texts.

In thonny IDE, you can check the value of temperature, pressure, and humidity.

Interface BME280 Sensor with Raspberry Pi Pico & OLED Display

Let us explore how to connect a BME280 Sensor with a Raspberry Pi Pico & display the temperature, pressure, and humidity reading on a 0.96″ I2C OLED Display. The connection is pretty straightforward as shown below and does not require any third-party library.

Attach the VCC, GND, SCL & SDA pins of the OLED Display to 3.3V, GND, GP1 & GP0 of Raspberry Pi Pico respectively.

MicroPython Code & Library: BME280, OLED Display & Pi Pico

The code for the BME280 & PICO Project is divided into three parts:

bme280.py
ssd1306.py
main.py

The main code requires a library for BME280 & SSD1306 OLED Display. The library has all the required modules and registers to extract the data from the BME280 Sensor & display the reading on a 0.96″ OLED Display.

bme280.py

Save the file as bme280.py on Raspberry Pi Pico.

# 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))

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

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

# 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.

# 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

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

ssd1306.py

We need a library for the OLED Display. Open a tab on Thonny IDE and paste the following code. Save the file as ssd1306.py on Raspberry Pi Pico.

# 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

Open a new tab on Thonny IDE. The following code will be created and saved on a new tab. Save the file as main.py

from machine import Pin, I2C
from ssd1306 import SSD1306_I2C
import time
import bme280
 
i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000)    #initializing the I2C method 
 
WIDTH =128 
HEIGHT= 64
oled = SSD1306_I2C(WIDTH,HEIGHT,i2c)
 
while True:
    oled.fill(0)
    bme = bme280.BME280(i2c=i2c)
    
    print(bme.values)
    
    oled.text("Temp:", 0, 0)
    oled.text(str(bme.values[0]), 50, 0)
    oled.text("PA:", 0, 20)
    oled.text(str(bme.values[1]), 50, 20)
    oled.text("Hum:", 0, 40)
    oled.text(str(bme.values[2]), 50, 40)
    oled.show()
    time.sleep(1)

from machine import Pin, I2C

from ssd1306 import SSD1306_I2C

import time

import bme280

i2c=I2C(0,sda=Pin(0), scl=Pin(1), freq=400000) #initializing the I2C method

WIDTH =128

HEIGHT= 64

oled = SSD1306_I2C(WIDTH,HEIGHT,i2c)

while True:

oled.fill(0)

bme = bme280.BME280(i2c=i2c)

print(bme.values)

oled.text("Temp:", 0, 0)

oled.text(str(bme.values[0]), 50, 0)

oled.text("PA:", 0, 20)

oled.text(str(bme.values[1]), 50, 20)

oled.text("Hum:", 0, 40)

oled.text(str(bme.values[2]), 50, 40)

oled.show()

time.sleep(1)

Run the main.py code after you import all the dependent packages. The OLED will display the temperature, pressure, and humidity.

Conclusion

This MicroPython code shows how to use the BME280 sensor with the Raspberry Pi Pico W. The code first initializes the I2C bus and then creates a BME280 instance. The code then reads the temperature, humidity, and pressure data from the sensor and prints it to the OLED Display & console.

BME280 With Raspberry Pi Pico W Using MicroPython

Raspberry Pi Pico Based Energy Meter Using INA219 | MicroPython

Build Drone Flight Controller With Raspberry Pi Pico | Unlimited Range

Interfacing BME688 Environmental Gas Sensor with Raspberry Pi Pico

Raspberry Pi Pico Data Logger using SD card & DHT11 sensor

Interfacing Micro SD Card Module with Raspberry Pi Pico

Raspberry Pi Pico GPS Tracker Using NEO-6M & OLED Display

1 Comment

DIY ESP32 Thermal Camera with MLX90640 and TFT Display

IoT Based ESP32 Prepaid Energy Meter with PZEM-004T | Power Monitoring & Web Control

Step-by-Step: Build an IoT Energy Meter with ESP32 & PZEM-004T V3 (TFT + Web Dashboard)

IoT Air Quality & Weather Monitoring with ESP32 & BME688

Quick Links

Company

Services

Ads Blocker Detected!!!

Ads Blocker Detected!!!

BME280 With Raspberry Pi Pico W Using MicroPython

Introduction

Required Components

BME280 Sensor

Schematic Diagram – BME280 Sensor With Raspberry Pi Pico W

Micropython Code & Libraries

bme280.py

main.py

Interface BME280 Sensor with Raspberry Pi Pico & OLED Display

MicroPython Code & Library: BME280, OLED Display & Pi Pico

bme280.py

ssd1306.py

main.py

Conclusion

Related Posts

1 Comment

Quick Links

Company

Services

Subscribe to Updates

Ads Blocker Detected!!!

Ads Blocker Detected!!!