Merge pull request #1019 from pimoroni/feature/picovector2-and-layers

PicoVector Enhancements & PicoGraphics Layers

Author: Gadgetoid

.github/workflows/micropython.yml

@@ -7,7 +7,7 @@ on:
     types: [created]
 
 env:
-  MICROPYTHON_VERSION: v1.24.0
+  MICROPYTHON_VERSION: v1.25.0
   MICROPYTHON_FLAVOUR: micropython
 
 jobs:
@@ -36,12 +36,6 @@ jobs:
           board: PIMORONI_TUFTY2040
         - name: enviro
           board: PICO_W_ENVIRO
-        - name: galactic_unicorn
-          board: RPI_PICO_W
-        - name: cosmic_unicorn
-          board: RPI_PICO_W
-        - name: stellar_unicorn
-          board: RPI_PICO_W
 
     env:
       # MicroPython version will be contained in github.event.release.tag_name for releases

.gitmodules

@@ -25,3 +25,6 @@
 [submodule "drivers/mlx90640/src"]
 	path = drivers/mlx90640/src
 	url = https://github.com/melexis/mlx90640-library
+[submodule "drivers/bme69x/src"]
+	path = drivers/bme69x/src
+	url = https://github.com/boschsensortec/BME690_SensorAPI

drivers/CMakeLists.txt

@@ -44,4 +44,5 @@ add_subdirectory(st7567)
 add_subdirectory(psram_display)
 add_subdirectory(shiftregister)
 add_subdirectory(inky73)
-add_subdirectory(mlx90640)
+add_subdirectory(mlx90640)
+add_subdirectory(bme69x)

drivers/bme69x/CMakeLists.txt

@@ -0,0 +1 @@
+include(bme69x.cmake)

drivers/bme69x/bme69x.cmake

@@ -0,0 +1,15 @@
+set(DRIVER_NAME bme69x)
+add_library(${DRIVER_NAME} INTERFACE)
+
+target_sources(${DRIVER_NAME} INTERFACE
+  ${CMAKE_CURRENT_LIST_DIR}/src/bme69x.c
+  ${CMAKE_CURRENT_LIST_DIR}/bme69x.cpp
+)
+
+target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
+target_include_directories(${DRIVER_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR}/src)
+
+
+# We can't control the uninitialized result variables in the BME68X API
+# so demote unitialized to a warning for this target.
+target_compile_options(${DRIVER_NAME} INTERFACE -Wno-error=uninitialized)

drivers/bme69x/bme69x.cpp

@@ -0,0 +1,121 @@
+#include "bme69x.hpp"
+#include "pico/stdlib.h"
+
+namespace pimoroni {
+    bool BME69X::init() {
+        int8_t result = 0;
+
+        if(interrupt != PIN_UNUSED) {
+            gpio_set_function(interrupt, GPIO_FUNC_SIO);
+            gpio_set_dir(interrupt, GPIO_IN);
+            gpio_pull_up(interrupt);
+        }
+
+        i2c_interface.i2c = i2c;
+        i2c_interface.address = address;
+
+        device.intf_ptr = &i2c_interface;
+        device.intf = bme69x_intf::BME69X_I2C_INTF;
+        device.read = (bme69x_read_fptr_t)&read_bytes;
+        device.write = (bme69x_write_fptr_t)&write_bytes;
+        device.delay_us = (bme69x_delay_us_fptr_t)&delay_us;
+        device.amb_temp = 20;
+
+        result = bme69x_init(&device);
+        bme69x_check_rslt("bme69x_init", result);
+        if(result != BME69X_OK) return false;
+
+        result = bme69x_get_conf(&conf, &device);
+        bme69x_check_rslt("bme69x_get_conf", result);
+        if(result != BME69X_OK) return false;
+
+        configure(BME69X_FILTER_OFF, BME69X_ODR_NONE, BME69X_OS_16X, BME69X_OS_1X, BME69X_OS_2X);
+
+        return true;
+    }
+
+    bool BME69X::configure(uint8_t filter, uint8_t odr, uint8_t os_humidity, uint8_t os_pressure, uint8_t os_temp) {
+        int8_t result = 0;
+
+        conf.filter = filter;
+        conf.odr = odr;
+        conf.os_hum = os_humidity;
+        conf.os_pres = os_pressure;
+        conf.os_temp = os_temp;
+
+        bme69x_set_conf(&conf, &device);
+        bme69x_check_rslt("bme69x_set_conf", result);
+        if(result != BME69X_OK) return false;
+
+        return true;
+    }
+
+    bool BME69X::read_forced(bme69x_data *data, uint16_t heater_temp, uint16_t heater_duration) {
+        int8_t result = 0;
+        uint8_t n_fields;
+        uint32_t delay_period;
+
+        heatr_conf.enable = BME69X_ENABLE;
+        heatr_conf.heatr_temp = heater_temp;
+        heatr_conf.heatr_dur = heater_duration;
+        result = bme69x_set_heatr_conf(BME69X_FORCED_MODE, &heatr_conf, &device);
+        bme69x_check_rslt("bme69x_set_heatr_conf", result);
+        if(result != BME69X_OK) return false;
+
+        result = bme69x_set_op_mode(BME69X_FORCED_MODE, &device);
+        bme69x_check_rslt("bme69x_set_op_mode", result);
+        if(result != BME69X_OK) return false;
+
+        delay_period = bme69x_get_meas_dur(BME69X_FORCED_MODE, &conf, &device) + (heatr_conf.heatr_dur * 1000);
+        // Could probably just call sleep_us here directly, I guess the API uses this internally
+        device.delay_us(delay_period, device.intf_ptr);
+
+        result = bme69x_get_data(BME69X_FORCED_MODE, data, &n_fields, &device);
+        bme69x_check_rslt("bme69x_get_data", result);
+        if(result != BME69X_OK) return false;
+
+        return true;
+    }
+
+    /*
+    Will read profile_length results with the given temperatures and duration multipliers into the results array.
+    Blocks until it has a valid result for each temp/duration, and returns the entire set in the given order.
+    */
+    bool BME69X::read_parallel(bme69x_data *results, uint16_t *profile_temps, uint16_t *profile_durations, size_t profile_length) {
+        int8_t result;
+        bme69x_data data[3]; // Parallel & Sequential mode read 3 simultaneous fields
+        uint8_t n_fields;
+        uint32_t delay_period;
+
+        heatr_conf.enable = BME69X_ENABLE;
+        heatr_conf.heatr_temp_prof = profile_temps;
+        heatr_conf.heatr_dur_prof = profile_durations;
+        heatr_conf.profile_len = profile_length;
+        heatr_conf.shared_heatr_dur = 140 - (bme69x_get_meas_dur(BME69X_PARALLEL_MODE, &conf, &device) / 1000);
+        result = bme69x_set_heatr_conf(BME69X_PARALLEL_MODE, &heatr_conf, &device);
+        bme69x_check_rslt("bme69x_set_heatr_conf", result);
+        if(result != BME69X_OK) return false;
+
+        result = bme69x_set_op_mode(BME69X_PARALLEL_MODE, &device);
+        bme69x_check_rslt("bme69x_set_op_mode", result);
+        if(result != BME69X_OK) return false;
+
+        while (1) {
+            delay_period = bme69x_get_meas_dur(BME69X_PARALLEL_MODE, &conf, &device) + (heatr_conf.shared_heatr_dur * 1000);
+            device.delay_us(delay_period, device.intf_ptr);
+
+            result = bme69x_get_data(BME69X_PARALLEL_MODE, data, &n_fields, &device);
+            if(result == BME69X_W_NO_NEW_DATA) continue;
+            bme69x_check_rslt("bme69x_get_data", result);
+            if(result != BME69X_OK) return false;
+
+            for(auto i = 0u; i < n_fields; i++) {
+                results[data[i].gas_index] = data[i];
+
+                if(data[i].gas_index == profile_length - 1) return true;
+            }
+        }
+
+        return true;
+    }
+}

drivers/bme69x/bme69x.hpp

@@ -0,0 +1,108 @@
+#pragma once
+
+#include "hardware/i2c.h"
+#include "hardware/gpio.h"
+#include "bme69x.h"
+#include "bme69x_defs.h"
+#include "common/pimoroni_i2c.hpp"
+#include "stdio.h"
+
+namespace pimoroni {
+    class BME69X {
+        public:
+            static const uint8_t DEFAULT_I2C_ADDRESS    = 0x76;
+            static const uint8_t ALTERNATE_I2C_ADDRESS  = 0x77;
+            
+            struct i2c_intf_ptr {
+                I2C *i2c;
+                int8_t address;
+            };
+
+            i2c_intf_ptr i2c_interface;
+
+            bool debug = true;
+
+            bool init();
+            bool configure(uint8_t filter, uint8_t odr, uint8_t os_humidity, uint8_t os_pressure, uint8_t os_temp);
+            bool read_forced(bme69x_data *data, uint16_t heater_temp=300, uint16_t heater_duration=100);
+            bool read_parallel(bme69x_data *results, uint16_t *profile_temps, uint16_t *profile_durations, size_t profile_length);
+
+            BME69X() : BME69X(new I2C()) {}
+            BME69X(uint8_t address, uint interrupt = PIN_UNUSED) : BME69X(new I2C(), address, interrupt) {}
+            BME69X(I2C *i2c, uint8_t address = DEFAULT_I2C_ADDRESS, uint interrupt = PIN_UNUSED) : i2c(i2c), address(address), interrupt(interrupt) {}
+
+            I2C *get_i2c() {return i2c;}
+            uint get_int() {return PIN_UNUSED;}
+
+            // Bindings for bme69x_dev 
+            static int write_bytes(uint8_t reg_addr, uint8_t *reg_data, uint32_t length, void *intf_ptr) {
+                BME69X::i2c_intf_ptr* i2c = (BME69X::i2c_intf_ptr *)intf_ptr;
+
+                uint8_t buffer[length + 1];
+                buffer[0] = reg_addr;
+                for(auto x = 0u; x < length; x++) {
+                    buffer[x + 1] = reg_data[x];
+                }
+
+                int result = i2c->i2c->write_blocking(i2c->address, buffer, length + 1, false);
+
+                return result == PICO_ERROR_GENERIC ? 1 : 0;
+            };
+
+            static int read_bytes(uint8_t reg_addr, uint8_t *reg_data, uint32_t length, void *intf_ptr) {
+                BME69X::i2c_intf_ptr* i2c = (BME69X::i2c_intf_ptr *)intf_ptr;
+
+                int result = i2c->i2c->write_blocking(i2c->address, &reg_addr, 1, true);
+                result = i2c->i2c->read_blocking(i2c->address, reg_data, length, false);
+
+                return result == PICO_ERROR_GENERIC ? 1 : 0;
+            };
+
+            static void delay_us(uint32_t period, void *intf_ptr) {
+                sleep_us(period);
+            }
+
+            /* From BME69X API examples/common/common.c */
+            void bme69x_check_rslt(const char api_name[], int8_t rslt)
+            {
+                if(!debug) return;
+                switch (rslt)
+                {
+                    case BME69X_OK:
+                        /* Do nothing */
+                        break;
+                    case BME69X_E_NULL_PTR:
+                        printf("%s: Error [%d] : Null pointer\r\n", api_name, rslt);
+                        break;
+                    case BME69X_E_COM_FAIL:
+                        printf("%s: Error [%d] : Communication failure\r\n", api_name, rslt);
+                        break;
+                    case BME69X_E_INVALID_LENGTH:
+                        printf("%s: Error [%d] : Incorrect length parameter\r\n", api_name, rslt);
+                        break;
+                    case BME69X_E_DEV_NOT_FOUND:
+                        printf("%s: Error [%d] : Device not found\r\n", api_name, rslt);
+                        break;
+                    case BME69X_E_SELF_TEST:
+                        printf("%s: Error [%d] : Self test error\r\n", api_name, rslt);
+                        break;
+                    case BME69X_W_NO_NEW_DATA:
+                        printf("%s: Warning [%d] : No new data found\r\n", api_name, rslt);
+                        break;
+                    default:
+                        printf("%s: Error [%d] : Unknown error code\r\n", api_name, rslt);
+                        break;
+                }
+            }
+
+        private:
+            bme69x_dev device;
+            bme69x_conf conf;
+            bme69x_heatr_conf heatr_conf;
+
+            I2C *i2c;
+
+            int8_t address    = DEFAULT_I2C_ADDRESS;
+            uint interrupt    = I2C_DEFAULT_INT;
+    };
+}