kopia lustrzana https://github.com/peterhinch/mpy_bme280_esp8266
114 wiersze
4.5 KiB
Python
114 wiersze
4.5 KiB
Python
# Author: Paul Cunnane 2016
|
|
#
|
|
# This module borrows heavily from the Adafruit BME280 Python library
|
|
# and the Adafruit GPIO/I2C 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.
|
|
|
|
class Device:
|
|
"""Class for communicating with an I2C device.
|
|
|
|
Allows reading and writing 8-bit, 16-bit, and byte array values to
|
|
registers on the device."""
|
|
|
|
def __init__(self, address, i2c):
|
|
"""Create an instance of the I2C device at the specified address using
|
|
the specified I2C interface object."""
|
|
self._address = address
|
|
self._i2c = i2c
|
|
|
|
def writeRaw8(self, value):
|
|
"""Write an 8-bit value on the bus (without register)."""
|
|
buf = bytearray(1)
|
|
buf[0] = value & 0xFF
|
|
self._i2c.writeto(self._address, buf)
|
|
|
|
def write8(self, register, value):
|
|
"""Write an 8-bit value to the specified register."""
|
|
buf = bytearray(1)
|
|
buf[0] = value & 0xFF
|
|
self._i2c.writeto_mem(self._address, register, buf)
|
|
|
|
def readRaw8(self):
|
|
"""Read an 8-bit value on the bus (without register)."""
|
|
return int.from_bytes(self._i2c.readfrom(self._address, 1)) & 0xFF
|
|
|
|
def readU8(self, register):
|
|
"""Read an unsigned byte from the specified register."""
|
|
return int.from_bytes(
|
|
self._i2c.readfrom_mem(self._address, register, 1)) & 0xFF
|
|
|
|
def readS8(self, register):
|
|
"""Read a signed byte from the specified register."""
|
|
result = self.readU8(register)
|
|
if result > 127:
|
|
result -= 256
|
|
return result
|
|
|
|
def readU16(self, register, little_endian=True):
|
|
"""Read an unsigned 16-bit value from the specified register, with the
|
|
specified endianness (default little endian, or least significant byte
|
|
first)."""
|
|
result = int.from_bytes(
|
|
self._i2c.readfrom_mem(self._address, register, 2)) & 0xFFFF
|
|
if not little_endian:
|
|
result = ((result << 8) & 0xFF00) + (result >> 8)
|
|
return result
|
|
|
|
def readS16(self, register, little_endian=True):
|
|
"""Read a signed 16-bit value from the specified register, with the
|
|
specified endianness (default little endian, or least significant byte
|
|
first)."""
|
|
result = self.readU16(register, little_endian)
|
|
if result > 32767:
|
|
result -= 65536
|
|
return result
|
|
|
|
def readU16LE(self, register):
|
|
"""Read an unsigned 16-bit value from the specified register, in little
|
|
endian byte order."""
|
|
return self.readU16(register, little_endian=True)
|
|
|
|
def readU16BE(self, register):
|
|
"""Read an unsigned 16-bit value from the specified register, in big
|
|
endian byte order."""
|
|
return self.readU16(register, little_endian=False)
|
|
|
|
def readS16LE(self, register):
|
|
"""Read a signed 16-bit value from the specified register, in little
|
|
endian byte order."""
|
|
return self.readS16(register, little_endian=True)
|
|
|
|
def readS16BE(self, register):
|
|
"""Read a signed 16-bit value from the specified register, in big
|
|
endian byte order."""
|
|
return self.readS16(register, little_endian=False)
|