circuitpython-fake-bme280 1.0.4__py3-none-any.whl → 1.2__py3-none-any.whl

{circuitpython_fake_bme280-1.0.4.dist-info → circuitpython_fake_bme280-1.2.dist-info}/METADATA

@@ -1,16 +1,15 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: circuitpython-fake-bme280
-Version: 1.0.4
+Version: 1.2
 Summary: BME280 Driver for CircuitPython used for testing functionality with no hardware attached
 Author-email: Adafruit Industries <circuitpython@adafruit.com>
-License: MIT
+License-Expression: MIT
 Project-URL: Homepage, https://github.com/brentru/CircuitPython_Fake_BME280
 Keywords: adafruit,blinka,circuitpython,micropython,fake_bme280,bme280,,test,,fake,,mock,,stub
 Classifier: Intended Audience :: Developers
 Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Embedded Systems
 Classifier: Topic :: System :: Hardware
-Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python :: 3
 Description-Content-Type: text/x-rst
 License-File: LICENSE
@@ -19,6 +18,8 @@ Requires-Dist: adafruit-circuitpython-busdevice
 Requires-Dist: adafruit-circuitpython-register
 Requires-Dist: toml
 Provides-Extra: optional
+Requires-Dist: python-dotenv; extra == "optional"
+Dynamic: license-file
 
 Introduction
 ============

circuitpython_fake_bme280-1.2.dist-info/RECORD

@@ -0,0 +1,9 @@
+circuitpython_fake_bme280-1.2.dist-info/licenses/LICENSE,sha256=tXgkGXjihZP5R0fW0-IyViyV_rB8TXrzKdiLP4crJn0,1103
+fake_bme280/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+fake_bme280/advanced.py,sha256=_Mx7ocLBxLe5OL80cYQDcyuKHLyQpPjUp01KEEFricw,8059
+fake_bme280/basic.py,sha256=uSEr5wkVnJ8X_4Eq5PmalavBXvgNWj7HsC31PW_Uc-0,12502
+fake_bme280/protocol.py,sha256=IeQ6cPpu9r7fvKwDkLHg2wLZ7QkOyCtyRjKGtIpW3ho,1017
+circuitpython_fake_bme280-1.2.dist-info/METADATA,sha256=9mLS7tTmILM-xQge59UHNpfqB7bdSWzHbZN5gnr60Cw,4640
+circuitpython_fake_bme280-1.2.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+circuitpython_fake_bme280-1.2.dist-info/top_level.txt,sha256=zYm6UwRd0tbyREvYLz0zQcP9NY4GvkMWQ19rZYbwO0Q,12
+circuitpython_fake_bme280-1.2.dist-info/RECORD,,

{circuitpython_fake_bme280-1.0.4.dist-info → circuitpython_fake_bme280-1.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.1.0)
+Generator: setuptools (82.0.1)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

fake_bme280/advanced.py

@@ -0,0 +1,269 @@
+# SPDX-FileCopyrightText: 2017 ladyada for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+"""
+`fake_bme280.advanced`
+=========================================================================================
+
+CircuitPython driver from BME280 Temperature, Humidity and Barometric
+Pressure sensor
+
+NOTE: This is a mock. The settings exposed here are simply stored and read back.
+
+* Author(s): ladyada, Jose David M.
+
+Implementation Notes
+--------------------
+
+**Hardware:**
+
+* `Adafruit BME280 Temperature, Humidity and Barometric Pressure sensor
+  <https://www.adafruit.com/product/2652>`_ (Product ID: 2652)
+
+
+**Software and Dependencies:**
+
+* Adafruit CircuitPython firmware for the supported boards:
+  https://circuitpython.org/downloads
+"""
+
+from micropython import const
+
+from fake_bme280.basic import Adafruit_BME280
+from fake_bme280.protocol import I2C_Impl
+
+try:
+    import typing  # pylint: disable=unused-import
+
+    from busio import I2C
+except ImportError:
+    pass
+
+__version__ = "1.2"
+__repo__ = "https://github.com/brentru/CircuitPython_Fake_BME280.git"
+
+#    I2C ADDRESS/BITS/SETTINGS
+#    -----------------------------------------------------------------------
+_BME280_ADDRESS = const(0x77)
+
+"""iir_filter values"""
+IIR_FILTER_DISABLE = const(0)
+IIR_FILTER_X2 = const(0x01)
+IIR_FILTER_X4 = const(0x02)
+IIR_FILTER_X8 = const(0x03)
+IIR_FILTER_X16 = const(0x04)
+
+_BME280_IIR_FILTERS = (
+    IIR_FILTER_DISABLE,
+    IIR_FILTER_X2,
+    IIR_FILTER_X4,
+    IIR_FILTER_X8,
+    IIR_FILTER_X16,
+)
+
+"""overscan values for temperature, pressure, and humidity"""
+OVERSCAN_DISABLE = const(0x00)
+OVERSCAN_X1 = const(0x01)
+OVERSCAN_X2 = const(0x02)
+OVERSCAN_X4 = const(0x03)
+OVERSCAN_X8 = const(0x04)
+OVERSCAN_X16 = const(0x05)
+
+_BME280_OVERSCANS = {
+    OVERSCAN_DISABLE: 0,
+    OVERSCAN_X1: 1,
+    OVERSCAN_X2: 2,
+    OVERSCAN_X4: 4,
+    OVERSCAN_X8: 8,
+    OVERSCAN_X16: 16,
+}
+
+"""mode values"""
+MODE_SLEEP = const(0x00)
+MODE_FORCE = const(0x01)
+MODE_NORMAL = const(0x03)
+
+_BME280_MODES = (MODE_SLEEP, MODE_FORCE, MODE_NORMAL)
+"""
+standby timeconstant values
+TC_X[_Y] where X=milliseconds and Y=tenths of a millisecond
+"""
+STANDBY_TC_0_5 = const(0x00)  # 0.5ms
+STANDBY_TC_10 = const(0x06)  # 10ms
+STANDBY_TC_20 = const(0x07)  # 20ms
+STANDBY_TC_62_5 = const(0x01)  # 62.5ms
+STANDBY_TC_125 = const(0x02)  # 125ms
+STANDBY_TC_250 = const(0x03)  # 250ms
+STANDBY_TC_500 = const(0x04)  # 500ms
+STANDBY_TC_1000 = const(0x05)  # 1000ms
+
+_BME280_STANDBY_TCS = (
+    STANDBY_TC_0_5,
+    STANDBY_TC_10,
+    STANDBY_TC_20,
+    STANDBY_TC_62_5,
+    STANDBY_TC_125,
+    STANDBY_TC_250,
+    STANDBY_TC_500,
+    STANDBY_TC_1000,
+)
+
+
+class Adafruit_BME280_Advanced(Adafruit_BME280):
+    """Driver from BME280 Temperature, Humidity and Barometric Pressure sensor
+
+    .. note::
+        This is a mock. The settings exposed here are simply stored and read
+        back - nothing is written to a real device.
+
+    """
+
+    @property
+    def standby_period(self) -> int:
+        """
+        Control the inactive period when in Normal mode
+        Allowed standby periods are the constants STANDBY_TC_*
+        """
+        return self._t_standby
+
+    @standby_period.setter
+    def standby_period(self, value: int) -> None:
+        if not value in _BME280_STANDBY_TCS:
+            raise ValueError(f"Standby Period '{value}' not supported")
+        self._t_standby = value
+
+    @property
+    def overscan_humidity(self) -> int:
+        """
+        Humidity Oversampling
+        Allowed values are the constants OVERSCAN_*
+        """
+        return self._overscan_humidity
+
+    @overscan_humidity.setter
+    def overscan_humidity(self, value: int) -> None:
+        if not value in _BME280_OVERSCANS:
+            raise ValueError(f"Overscan value '{value}' not supported")
+        self._overscan_humidity = value
+
+    @property
+    def overscan_temperature(self) -> int:
+        """
+        Temperature Oversampling
+        Allowed values are the constants OVERSCAN_*
+        """
+        return self._overscan_temperature
+
+    @overscan_temperature.setter
+    def overscan_temperature(self, value: int) -> None:
+        if not value in _BME280_OVERSCANS:
+            raise ValueError(f"Overscan value '{value}' not supported")
+        self._overscan_temperature = value
+
+    @property
+    def overscan_pressure(self) -> int:
+        """
+        Pressure Oversampling
+        Allowed values are the constants OVERSCAN_*
+        """
+        return self._overscan_pressure
+
+    @overscan_pressure.setter
+    def overscan_pressure(self, value: int) -> None:
+        if not value in _BME280_OVERSCANS:
+            raise ValueError(f"Overscan value '{value}' not supported")
+        self._overscan_pressure = value
+
+    @property
+    def iir_filter(self) -> int:
+        """
+        Controls the time constant of the IIR filter
+        Allowed values are the constants IIR_FILTER_*
+        """
+        return self._iir_filter
+
+    @iir_filter.setter
+    def iir_filter(self, value: int) -> None:
+        if not value in _BME280_IIR_FILTERS:
+            raise ValueError(f"IIR Filter '{value}' not supported")
+        self._iir_filter = value
+
+    @property
+    def measurement_time_typical(self) -> float:
+        """Typical time in milliseconds required to complete a measurement in normal mode"""
+        meas_time_ms = 1.0
+        if self.overscan_temperature != OVERSCAN_DISABLE:
+            meas_time_ms += 2 * _BME280_OVERSCANS.get(self.overscan_temperature)
+        if self.overscan_pressure != OVERSCAN_DISABLE:
+            meas_time_ms += 2 * _BME280_OVERSCANS.get(self.overscan_pressure) + 0.5
+        if self.overscan_humidity != OVERSCAN_DISABLE:
+            meas_time_ms += 2 * _BME280_OVERSCANS.get(self.overscan_humidity) + 0.5
+        return meas_time_ms
+
+    @property
+    def measurement_time_max(self) -> float:
+        """Maximum time in milliseconds required to complete a measurement in normal mode"""
+        meas_time_ms = 1.25
+        if self.overscan_temperature != OVERSCAN_DISABLE:
+            meas_time_ms += 2.3 * _BME280_OVERSCANS.get(self.overscan_temperature)
+        if self.overscan_pressure != OVERSCAN_DISABLE:
+            meas_time_ms += 2.3 * _BME280_OVERSCANS.get(self.overscan_pressure) + 0.575
+        if self.overscan_humidity != OVERSCAN_DISABLE:
+            meas_time_ms += 2.3 * _BME280_OVERSCANS.get(self.overscan_humidity) + 0.575
+        return meas_time_ms
+
+
+class Adafruit_BME280_I2C(Adafruit_BME280_Advanced):
+    """Driver for BME280 connected over I2C
+
+    :param ~busio.I2C i2c: The I2C bus the BME280 is connected to.
+    :param int address: I2C device address. Defaults to :const:`0x77`.
+                        but another address can be passed in as an argument
+
+    .. note::
+        The operational range of the BMP280 is 300-1100 hPa.
+        Pressure measurements outside this range may not be as accurate.
+
+    **Quickstart: Importing and using the BME280**
+
+    Here is an example of using the :class:`Adafruit_BME280_I2C`.
+    First you will need to import the libraries to use the sensor
+
+    .. code-block:: python
+
+        import board
+        import fake_bme280.advanced as adafruit_bme280
+
+    Once this is done you can define your `board.I2C` object and define your sensor object
+
+    .. code-block:: python
+
+        i2c = board.I2C()   # uses board.SCL and board.SDA
+        bme280 = adafruit_bme280.Adafruit_BME280_I2C(i2c)
+
+    You need to setup the pressure at sea level
+
+    .. code-block:: python
+
+        bme280.sea_level_pressure = 1013.25
+
+    Now you have access to the :attr:`temperature`, :attr:`relative_humidity`
+    :attr:`pressure` and :attr:`altitude` attributes
+
+    .. code-block:: python
+
+        temperature = bme280.temperature
+        relative_humidity = bme280.relative_humidity
+        pressure = bme280.pressure
+        altitude = bme280.altitude
+
+    """
+
+    def __init__(
+        self,
+        i2c: I2C,
+        address: int = _BME280_ADDRESS,
+        use_openweather: bool = True,
+    ) -> None:
+        super().__init__(I2C_Impl(i2c, address), use_openweather=use_openweather)

fake_bme280/basic.py

@@ -25,15 +25,27 @@ Implementation Notes
 * Adafruit CircuitPython firmware for the supported boards:
   https://circuitpython.org/downloads
 """
+
 import math
+import os
+import random
 import socket as pool
 import ssl
 import typing  # pylint: disable=unused-import
-import toml
 from micropython import const
 import adafruit_requests
 from fake_bme280.protocol import I2C_Impl, SPI_Impl
 
+try:
+    import toml
+except ImportError:
+    toml = None
+
+try:
+    import dotenv
+except ImportError:
+    dotenv = None
+
 try:
     from busio import I2C, SPI
     from digitalio import DigitalInOut
@@ -75,21 +87,62 @@ _BME280_REGISTER_CONFIG = const(0xF5)
 _BME280_REGISTER_TEMPDATA = const(0xFA)
 _BME280_REGISTER_HUMIDDATA = const(0xFD)
 
-# Load the settings.toml file
-toml_config = toml.load("settings.toml")
-
-# OpenWeatherMap API
-# GET weather data for a specific location
-DATA_SOURCE = (
-    "http://api.openweathermap.org/data/2.5/weather?q="
-    + toml_config["openweather_location"]
-    + "&units="
-    + toml_config["openweather_units"]
-    + "&mode=json"
-    + "&appid="
-    + toml_config["openweather_token"]
+_OPENWEATHER_KEYS = (
+    "openweather_location",
+    "openweather_units",
+    "openweather_token",
 )
 
+_SETTINGS_TOML_PATH = "settings.toml"
+
+
+def _load_openweather_settings() -> dict:
+    """Return OpenWeatherMap settings, trying settings.toml, then .env
+    (python-dotenv), then os.getenv, per key in that order. Raises
+    ``RuntimeError`` if settings.toml is malformed or any key is missing."""
+    toml_values = {}
+    if toml is not None:
+        try:
+            toml_values = toml.load(_SETTINGS_TOML_PATH)
+        except FileNotFoundError:
+            pass
+        except toml.TomlDecodeError as err:
+            raise RuntimeError(
+                "Could not parse %s: %s" % (_SETTINGS_TOML_PATH, err)
+            ) from err
+
+    dotenv_values = dotenv.dotenv_values() if dotenv is not None else {}
+
+    settings = {}
+    for key in _OPENWEATHER_KEYS:
+        value = toml_values.get(key) or dotenv_values.get(key) or os.getenv(key)
+        if value:
+            settings[key] = value
+
+    missing = [k for k in _OPENWEATHER_KEYS if k not in settings]
+    if missing:
+        raise RuntimeError(
+            "fake_bme280 is missing required OpenWeatherMap setting(s): "
+            + ", ".join(missing)
+            + ". Provide them via settings.toml, a .env file (python-dotenv), "
+            "or environment variables. Or construct the sensor with "
+            "use_openweather=False for random fake readings (no network)."
+        )
+    return settings
+
+
+def _build_openweather_url() -> str:
+    """Build the OpenWeatherMap API URL from the loaded settings."""
+    config = _load_openweather_settings()
+    return (
+        "http://api.openweathermap.org/data/2.5/weather?q="
+        + config["openweather_location"]
+        + "&units="
+        + config["openweather_units"]
+        + "&mode=json&appid="
+        + config["openweather_token"]
+    )
+
 
 class Adafruit_BME280:
     """Driver from BME280 Temperature, Humidity and Barometric Pressure sensor
@@ -101,11 +154,21 @@ class Adafruit_BME280:
     """
 
     # pylint: disable=too-many-instance-attributes
-    def __init__(self, bus_implementation: typing.Union[I2C_Impl, SPI_Impl]) -> None:
-        """Mock a BME280 sensor object that was found on an I2C bus."""
-        # Check device ID.
+    def __init__(
+        self,
+        bus_implementation: typing.Union[I2C_Impl, SPI_Impl],
+        use_openweather: bool = True,
+    ) -> None:
+        """Mock a BME280 sensor object that was found on an I2C bus.
+
+        :param bus_implementation: I2C or SPI implementation wrapper.
+        :param bool use_openweather: When ``True`` (default), read settings
+            from the environment (``settings.toml`` on CircuitPython,
+            environment variables on CPython) and fetch live data from the
+            OpenWeatherMap API. When ``False``, return random plausible
+            readings with no network access and no configuration required.
+        """
         self._bus_implementation = bus_implementation
-        # Set some reasonable defaults.
         self._iir_filter = IIR_FILTER_DISABLE
         self.overscan_humidity = OVERSCAN_X1
         self.overscan_temperature = OVERSCAN_X1
@@ -115,23 +178,42 @@ class Adafruit_BME280:
         self.sea_level_pressure = 1013.25
         """Pressure in hectoPascals at sea level. Used to calibrate `altitude`."""
         self._t_fine = None
-        # Configure a CPython adafruit_requests session
-        self.requests = adafruit_requests.Session(pool, ssl.create_default_context())
-        self._current_forcast = None
-        # Test call get_forecast
-        self.get_forecast()
+        self._use_openweather = use_openweather
+        self._current_forecast = None
+        self._data_source = None
+        self.requests = None
+        if use_openweather:
+            self._data_source = _build_openweather_url()
+            self.requests = adafruit_requests.Session(
+                pool, ssl.create_default_context()
+            )
+            self.get_forecast()
+        else:
+            self._current_forecast = self._random_forecast()
+
+    @staticmethod
+    def _random_forecast() -> dict:
+        """Generate a plausible BME280-shaped reading."""
+        return {
+            "main": {
+                "temp": round(random.uniform(18.0, 28.0), 2),
+                "pressure": round(random.uniform(1000.0, 1025.0), 2),
+                "humidity": round(random.uniform(30.0, 70.0), 2),
+            }
+        }
 
     def get_forecast(self):
-        """Fetch weather from OpenWeatherMap API"""
-        # print("Fetching json from", DATA_SOURCE)
-        response = self.requests.get(DATA_SOURCE)
-        self._current_forcast = response.json()
-        # print(self._current_forcast)
+        """Fetch weather from OpenWeatherMap (or generate fake data)."""
+        if not self._use_openweather:
+            self._current_forecast = self._random_forecast()
+            return
+        response = self.requests.get(self._data_source)
+        self._current_forecast = response.json()
 
     def _read_temperature(self) -> None:
         # Get the OpenWeather temperature and store it in _t_fine
         self.get_forecast()
-        self._t_fine = self._current_forcast["main"]["temp"]
+        self._t_fine = self._current_forecast["main"]["temp"]
 
     @property
     def mode(self) -> int:
@@ -177,7 +259,7 @@ class Adafruit_BME280:
         The compensated pressure in hectoPascals.
         """
         self._read_temperature()
-        return self._current_forcast["main"]["pressure"]
+        return self._current_forecast["main"]["pressure"]
 
     @property
     def relative_humidity(self) -> float:
@@ -192,7 +274,7 @@ class Adafruit_BME280:
         The relative humidity in RH %
         """
         self._read_temperature()
-        humidity = self._current_forcast["main"]["humidity"]
+        humidity = self._current_forecast["main"]["humidity"]
         if humidity > 100:
             return 100
         if humidity < 0:
@@ -253,8 +335,13 @@ class Adafruit_BME280_I2C(Adafruit_BME280):
 
     """
 
-    def __init__(self, i2c: I2C, address: int = 0x77) -> None:  # BME280_ADDRESS
-        super().__init__(I2C_Impl(i2c, address))
+    def __init__(
+        self,
+        i2c: I2C,
+        address: int = 0x77,  # BME280_ADDRESS
+        use_openweather: bool = True,
+    ) -> None:
+        super().__init__(I2C_Impl(i2c, address), use_openweather=use_openweather)
 
 
 class Adafruit_BME280_SPI(Adafruit_BME280):
@@ -305,5 +392,11 @@ class Adafruit_BME280_SPI(Adafruit_BME280):
 
     """
 
-    def __init__(self, spi: SPI, cs: DigitalInOut, baudrate: int = 100000) -> None:
-        super().__init__(SPI_Impl(spi, cs, baudrate))
+    def __init__(
+        self,
+        spi: SPI,
+        cs: DigitalInOut,
+        baudrate: int = 100000,
+        use_openweather: bool = True,
+    ) -> None:
+        super().__init__(SPI_Impl(spi, cs, baudrate), use_openweather=use_openweather)

circuitpython_fake_bme280-1.0.4.dist-info/RECORD

@@ -1,8 +0,0 @@
-fake_bme280/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-fake_bme280/basic.py,sha256=fmvOe6RBgJjfO4rG34Wdm0V9W3LKAymMbsLcwU1Z2JE,9578
-fake_bme280/protocol.py,sha256=IeQ6cPpu9r7fvKwDkLHg2wLZ7QkOyCtyRjKGtIpW3ho,1017
-circuitpython_fake_bme280-1.0.4.dist-info/LICENSE,sha256=tXgkGXjihZP5R0fW0-IyViyV_rB8TXrzKdiLP4crJn0,1103
-circuitpython_fake_bme280-1.0.4.dist-info/METADATA,sha256=Gss3h67gXetF0KN0bmP8sAzndjp0NsDOUZTYWmbPua4,4610
-circuitpython_fake_bme280-1.0.4.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
-circuitpython_fake_bme280-1.0.4.dist-info/top_level.txt,sha256=zYm6UwRd0tbyREvYLz0zQcP9NY4GvkMWQ19rZYbwO0Q,12
-circuitpython_fake_bme280-1.0.4.dist-info/RECORD,,