404 lines
14 KiB
Python
404 lines
14 KiB
Python
# The MIT License (MIT)
|
|
#
|
|
# Copyright (c) 2020 Bryan Siepert for Adafruit Industries
|
|
#
|
|
# 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.
|
|
"""
|
|
`adafruit_dps310`
|
|
================================================================================
|
|
|
|
Library for the DPS310 Precision Barometric Pressure Sensor
|
|
|
|
* Author(s): Bryan Siepert
|
|
|
|
Implementation Notes
|
|
--------------------
|
|
|
|
**Hardware:**
|
|
|
|
* Adafruit's DPS310 Breakout: https://www.adafruit.com/product/4494
|
|
|
|
**Software and Dependencies:**
|
|
|
|
* Adafruit CircuitPython firmware for the supported boards:
|
|
https://circuitpython.org/downloads
|
|
* Adafruit's Bus Device library: https://github.com/adafruit/Adafruit_CircuitPython_BusDevice
|
|
* Adafruit's Register library: https://github.com/adafruit/Adafruit_CircuitPython_Register"""
|
|
|
|
__version__ = "0.0.0-auto.0"
|
|
__repo__ = "https://github.com/adafruit/Adafruit_CircuitPython_DPS310.git"
|
|
|
|
# Common imports; remove if unused or pylint will complain
|
|
from time import sleep
|
|
import adafruit_bus_device.i2c_device as i2c_device
|
|
from adafruit_register.i2c_struct import UnaryStruct, ROUnaryStruct
|
|
from adafruit_register.i2c_bit import RWBit, ROBit
|
|
from adafruit_register.i2c_bits import RWBits, ROBits
|
|
|
|
_DPS310_DEFAULT_ADDRESS = 0x77 # DPS310 default i2c address
|
|
_DPS310_DEVICE_ID = 0x10 # DPS310 device identifier
|
|
|
|
_DPS310_PRSB2 = 0x00 # Highest byte of pressure data
|
|
_DPS310_TMPB2 = 0x03 # Highest byte of temperature data
|
|
_DPS310_PRSCFG = 0x06 # Pressure configuration
|
|
_DPS310_TMPCFG = 0x07 # Temperature configuration
|
|
_DPS310_MEASCFG = 0x08 # Sensor configuration
|
|
_DPS310_CFGREG = 0x09 # Interrupt/FIFO configuration
|
|
_DPS310_RESET = 0x0C # Soft reset
|
|
_DPS310_PRODREVID = 0x0D # Register that contains the part ID
|
|
_DPS310_TMPCOEFSRCE = 0x28 # Temperature calibration src
|
|
|
|
# pylint: disable=no-member,unnecessary-pass
|
|
|
|
|
|
class CV:
|
|
"""struct helper"""
|
|
|
|
@classmethod
|
|
def add_values(cls, value_tuples):
|
|
"""Add CV values to the class"""
|
|
cls.string = {}
|
|
cls.lsb = {}
|
|
|
|
for value_tuple in value_tuples:
|
|
name, value, string, lsb = value_tuple
|
|
setattr(cls, name, value)
|
|
cls.string[value] = string
|
|
cls.lsb[value] = lsb
|
|
|
|
@classmethod
|
|
def is_valid(cls, value):
|
|
"""Validate that a given value is a member"""
|
|
return value in cls.string
|
|
|
|
|
|
class Mode(CV):
|
|
"""Options for ``mode``
|
|
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| Mode | Description |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.IDLE`` | Puts the sensor into a shutdown state |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.ONE_PRESSURE`` | Setting `mode` to ``Mode.ONE_PRESSURE`` takes a single pressure |
|
|
| | measurement then switches to ``Mode.IDLE`` |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.ONE_TEMPERATURE`` | Setting `mode` to ``Mode.ONE_TEMPERATURE`` takes a single |
|
|
| | temperature measurement then switches to ``Mode.IDLE`` |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.CONT_PRESSURE`` | Take pressure measurements at the current `pressure_rate`. |
|
|
| | `temperature` will not be updated |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.CONT_TEMP`` | Take temperature measurements at the current `temperature_rate`. |
|
|
| | `pressure` will not be updated |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
| ``Mode.CONT_PRESTEMP`` | Take temperature and pressure measurements at the current |
|
|
| | `pressure_rate` and `temperature_rate` |
|
|
+--------------------------+------------------------------------------------------------------+
|
|
|
|
"""
|
|
|
|
pass # pylint: disable=unnecessary-pass
|
|
|
|
|
|
Mode.add_values(
|
|
(
|
|
("IDLE", 0, "Idle", None),
|
|
("ONE_PRESSURE", 1, "One-Shot Pressure", None),
|
|
("ONE_TEMPERATURE", 2, "One-Shot Temperature", None),
|
|
("CONT_PRESSURE", 5, "Continuous Pressure", None),
|
|
("CONT_TEMP", 6, "Continuous Temperature", None),
|
|
("CONT_PRESTEMP", 7, "Continuous Pressure & Temperature", None),
|
|
)
|
|
)
|
|
|
|
|
|
class Rate(CV):
|
|
"""Options for `pressure_rate` and `temperature_rate`"""
|
|
|
|
pass
|
|
|
|
|
|
Rate.add_values(
|
|
(
|
|
("RATE_1_HZ", 0, 1, None),
|
|
("RATE_2_HZ", 1, 2, None),
|
|
("RATE_4_HZ", 2, 4, None),
|
|
("RATE_8_HZ", 3, 8, None),
|
|
("RATE_16_HZ", 4, 16, None),
|
|
("RATE_32_HZ", 5, 32, None),
|
|
("RATE_64_HZ", 6, 64, None),
|
|
("RATE_128_HZ", 7, 128, None),
|
|
)
|
|
)
|
|
|
|
|
|
class SampleCount(CV):
|
|
"""Options for `temperature_oversample_count` and `pressure_oversample_count`"""
|
|
|
|
pass
|
|
|
|
|
|
SampleCount.add_values(
|
|
(
|
|
("COUNT_1", 0, 1, None),
|
|
("COUNT_2", 1, 2, None),
|
|
("COUNT_4", 2, 4, None),
|
|
("COUNT_8", 3, 8, None),
|
|
("COUNT_16", 4, 16, None),
|
|
("COUNT_32", 5, 32, None),
|
|
("COUNT_64", 6, 64, None),
|
|
("COUNT_128", 7, 128, None),
|
|
)
|
|
)
|
|
# pylint: enable=unnecessary-pass
|
|
class DPS310:
|
|
# pylint: disable=too-many-instance-attributes
|
|
"""Library for the DPS310 Precision Barometric Pressure Sensor.
|
|
|
|
:param ~busio.I2C i2c_bus: The I2C bus the DPS310 is connected to.
|
|
:param address: The I2C slave address of the sensor
|
|
|
|
"""
|
|
# Register definitions
|
|
_device_id = ROUnaryStruct(_DPS310_PRODREVID, ">B")
|
|
_reset_register = UnaryStruct(_DPS310_RESET, ">B")
|
|
_mode_bits = RWBits(3, _DPS310_MEASCFG, 0)
|
|
|
|
_pressure_ratebits = RWBits(3, _DPS310_PRSCFG, 4)
|
|
_pressure_osbits = RWBits(4, _DPS310_PRSCFG, 0)
|
|
|
|
_temp_ratebits = RWBits(3, _DPS310_TMPCFG, 4)
|
|
_temp_osbits = RWBits(4, _DPS310_TMPCFG, 0)
|
|
|
|
_temp_measurement_src_bit = RWBit(_DPS310_TMPCFG, 7)
|
|
|
|
_pressure_shiftbit = RWBit(_DPS310_CFGREG, 2)
|
|
_temp_shiftbit = RWBit(_DPS310_CFGREG, 3)
|
|
|
|
_coefficients_ready = RWBit(_DPS310_MEASCFG, 7)
|
|
_sensor_ready = RWBit(_DPS310_MEASCFG, 6)
|
|
_temp_ready = RWBit(_DPS310_MEASCFG, 5)
|
|
_pressure_ready = RWBit(_DPS310_MEASCFG, 4)
|
|
|
|
_raw_pressure = ROBits(24, _DPS310_PRSB2, 0, 3, lsb_first=False)
|
|
_raw_temperature = ROBits(24, _DPS310_TMPB2, 0, 3, lsb_first=False)
|
|
|
|
_calib_coeff_temp_src_bit = ROBit(_DPS310_TMPCOEFSRCE, 7)
|
|
|
|
def __init__(self, i2c_bus, address=_DPS310_DEFAULT_ADDRESS):
|
|
self.i2c_device = i2c_device.I2CDevice(i2c_bus, address)
|
|
|
|
if self._device_id != _DPS310_DEVICE_ID:
|
|
raise RuntimeError("Failed to find DPS310 - check your wiring!")
|
|
self._pressure_scale = None
|
|
self._temp_scale = None
|
|
self._c0 = None
|
|
self._c1 = None
|
|
self._c00 = None
|
|
self._c00 = None
|
|
self._c10 = None
|
|
self._c10 = None
|
|
self._c01 = None
|
|
self._c11 = None
|
|
self._c20 = None
|
|
self._c21 = None
|
|
self._c30 = None
|
|
self._oversample_scalefactor = (
|
|
524288,
|
|
1572864,
|
|
3670016,
|
|
7864320,
|
|
253952,
|
|
516096,
|
|
1040384,
|
|
2088960,
|
|
)
|
|
self.initialize()
|
|
|
|
def initialize(self):
|
|
"""Reset the sensor to the default state"""
|
|
|
|
self._reset()
|
|
self._read_calibration()
|
|
|
|
# make sure we're using the temperature source used for calibration
|
|
self._temp_measurement_src_bit = self._calib_coeff_temp_src_bit
|
|
|
|
self.pressure_rate = Rate.RATE_64_HZ
|
|
self.pressure_oversample_count = SampleCount.COUNT_64
|
|
self.temperature_rate = Rate.RATE_64_HZ
|
|
self.temperature_oversample_count = SampleCount.COUNT_64
|
|
self.mode = Mode.CONT_PRESTEMP
|
|
|
|
# wait until we have at least one good measurement
|
|
|
|
while (self._temp_ready is False) or (self._pressure_ready is False):
|
|
sleep(0.001)
|
|
|
|
def _reset(self):
|
|
"""Perform a soft-reset on the sensor"""
|
|
self._reset_register = 0x89
|
|
# wait for hardware reset to finish
|
|
sleep(0.010)
|
|
while not self._sensor_ready:
|
|
sleep(0.001)
|
|
|
|
@property
|
|
def pressure(self):
|
|
"""Returns the current pressure reading in kPA"""
|
|
|
|
temp_reading = self._raw_temperature
|
|
raw_temperature = self._twos_complement(temp_reading, 24)
|
|
pressure_reading = self._raw_pressure
|
|
raw_pressure = self._twos_complement(pressure_reading, 24)
|
|
_scaled_rawtemp = raw_temperature / self._temp_scale
|
|
|
|
_temperature = _scaled_rawtemp * self._c1 + self._c0 / 2.0
|
|
|
|
p_red = raw_pressure / self._pressure_scale
|
|
|
|
pres_calc = (
|
|
self._c00
|
|
+ p_red * (self._c10 + p_red * (self._c20 + p_red * self._c30))
|
|
+ _scaled_rawtemp * (self._c01 + p_red * (self._c11 + p_red * self._c21))
|
|
)
|
|
|
|
final_pressure = pres_calc / 100
|
|
return final_pressure
|
|
|
|
@property
|
|
def temperature(self):
|
|
"""The current temperature reading in degrees C"""
|
|
_scaled_rawtemp = self._raw_temperature / self._temp_scale
|
|
_temperature = _scaled_rawtemp * self._c1 + self._c0 / 2.0
|
|
return _temperature
|
|
|
|
@property
|
|
def temperature_ready(self):
|
|
"""Returns true if there is a temperature reading ready"""
|
|
return self._temp_ready
|
|
|
|
@property
|
|
def pressure_ready(self):
|
|
"""Returns true if pressure readings are ready"""
|
|
return self._pressure_ready
|
|
|
|
@property
|
|
def mode(self):
|
|
"""The measurement mode. Must be a `Mode`. See the `Mode` documentation for details"""
|
|
return self._mode_bits
|
|
|
|
@mode.setter
|
|
def mode(self, value):
|
|
if not Mode.is_valid(value):
|
|
raise AttributeError("mode must be an `Mode`")
|
|
|
|
self._mode_bits = value
|
|
|
|
@property
|
|
def pressure_rate(self):
|
|
"""Configure the pressure measurement rate. Must be a `Rate`"""
|
|
return self._pressure_ratebits
|
|
|
|
@pressure_rate.setter
|
|
def pressure_rate(self, value):
|
|
if not Rate.is_valid(value):
|
|
raise AttributeError("pressure_rate must be a Rate")
|
|
self._pressure_ratebits = value
|
|
|
|
@property
|
|
def pressure_oversample_count(self):
|
|
"""The number of samples taken per pressure measurement. Must be a `SampleCount`"""
|
|
return self._pressure_osbits
|
|
|
|
@pressure_oversample_count.setter
|
|
def pressure_oversample_count(self, value):
|
|
if not SampleCount.is_valid(value):
|
|
raise AttributeError("pressure_oversample_count must be a SampleCount")
|
|
|
|
self._pressure_osbits = value
|
|
self._pressure_shiftbit = value > SampleCount.COUNT_8
|
|
self._pressure_scale = self._oversample_scalefactor[value]
|
|
|
|
@property
|
|
def temperature_rate(self):
|
|
"""Configure the temperature measurement rate. Must be a `Rate`"""
|
|
return self._temp_ratebits
|
|
|
|
@temperature_rate.setter
|
|
def temperature_rate(self, value):
|
|
if not Rate.is_valid(value):
|
|
raise AttributeError("temperature_rate must be a Rate")
|
|
self._temp_ratebits = value
|
|
|
|
@property
|
|
def temperature_oversample_count(self):
|
|
"""The number of samples taken per temperature measurement. Must be a `SampleCount`"""
|
|
return self._temp_osbits
|
|
|
|
@temperature_oversample_count.setter
|
|
def temperature_oversample_count(self, value):
|
|
if not SampleCount.is_valid(value):
|
|
raise AttributeError("temperature_oversample_count must be a SampleCount")
|
|
|
|
self._temp_osbits = value
|
|
self._temp_scale = self._oversample_scalefactor[value]
|
|
self._temp_shiftbit = value > SampleCount.COUNT_8
|
|
|
|
@staticmethod
|
|
def _twos_complement(val, bits):
|
|
if val & (1 << (bits - 1)):
|
|
val -= 1 << bits
|
|
|
|
return val
|
|
|
|
def _read_calibration(self):
|
|
|
|
while not self._coefficients_ready:
|
|
sleep(0.001)
|
|
|
|
buffer = bytearray(19)
|
|
coeffs = [None] * 18
|
|
for offset in range(18):
|
|
buffer = bytearray(2)
|
|
buffer[0] = 0x10 + offset
|
|
|
|
with self.i2c_device as i2c:
|
|
|
|
i2c.write_then_readinto(buffer, buffer, out_end=1, in_start=1)
|
|
|
|
coeffs[offset] = buffer[1]
|
|
|
|
self._c0 = (coeffs[0] << 4) | ((coeffs[1] >> 4) & 0x0F)
|
|
self._c0 = self._twos_complement(self._c0, 12)
|
|
|
|
self._c1 = self._twos_complement(((coeffs[1] & 0x0F) << 8) | coeffs[2], 12)
|
|
|
|
self._c00 = (coeffs[3] << 12) | (coeffs[4] << 4) | ((coeffs[5] >> 4) & 0x0F)
|
|
self._c00 = self._twos_complement(self._c00, 20)
|
|
|
|
self._c10 = ((coeffs[5] & 0x0F) << 16) | (coeffs[6] << 8) | coeffs[7]
|
|
self._c10 = self._twos_complement(self._c10, 20)
|
|
|
|
self._c01 = self._twos_complement((coeffs[8] << 8) | coeffs[9], 16)
|
|
self._c11 = self._twos_complement((coeffs[10] << 8) | coeffs[11], 16)
|
|
self._c20 = self._twos_complement((coeffs[12] << 8) | coeffs[13], 16)
|
|
self._c21 = self._twos_complement((coeffs[14] << 8) | coeffs[15], 16)
|
|
self._c30 = self._twos_complement((coeffs[16] << 8) | coeffs[17], 16)
|