bme680: use userspace library

.gitmodules

@@ -53,3 +53,6 @@
 [submodule "apps/yellow/DataHub-Buzzer"]
 	path = apps/yellow/DataHub-Buzzer
 	url = https://github.com/mangOH/DataHub-Buzzer.git
+[submodule "components/boschBme680Driver/Bosch_BME680_Driver"]
+	path = components/boschBme680Driver/Bosch_BME680_Driver
+	url = https://github.com/mangOH/Bosch_BME680_Driver.git

apps/Bme680EnvironmentalSensor/README.md

+# BME680 Environmental Sensor
+
+The environment variable `$BME680_I2C_BUS` needs to be defined to an interger (e.g. `6` for wp76)
+which is the I2C bus that the BME680 environmental sensor is on.

apps/Bme680EnvironmentalSensor/bme680EnvironmentalSensor.adef

+sandboxed: true
+version: 1.0.0
+start: auto
+
+executables:
+{
+    bme680EnvironmentalSensor = ( bsecIntegrationComponent )
+}
+
+processes:
+{
+    envVars:
+    {
+        LE_LOG_LEVEL = DEBUG
+    }
+    run:
+    {
+        ( bme680EnvironmentalSensor )
+    }
+    faultAction: restart
+}
+
+extern:
+{
+    bme680EnvironmentalSensor.bsecIntegrationComponent.mangOH_bme680
+}
+
+requires:
+{
+    device:
+    {
+        [rw] /dev/i2c-${BME680_I2C_BUS} /dev/
+    }
+}
+
+bindings:
+{
+    bme680EnvironmentalSensor.bsecIntegrationComponent.ambient -> mcp9700aTemperatureSensor.mangOH_ambientTemperature
+}

apps/Bme680EnvironmentalSensor/bsecIntegrationComponent/Component.cdef

+sources:
+{
+    bsecIntegration.c
+    bme680ApiImpl.c
+}
+
+cflags:
+{
+    -std=c99
+    -DBME680_I2C_BUS=${BME680_I2C_BUS}
+}
+
+provides:
+{
+    api:
+    {
+        mangOH_bme680.api
+    }
+}
+
+requires:
+{
+    api:
+    {
+        ambient = mangOH_ambientTemperature.api
+    }
+    component:
+    {
+        boschBme680Driver
+        boschBsec
+    }
+}

apps/Bme680EnvironmentalSensor/bsecIntegrationComponent/bme680ApiImpl.c

+#include "legato.h"
+#include "interfaces.h"
+#include "bsec_interface.h"
+#include "bsecIntegration.h"
+
+extern struct Bme680State _s;
+
+le_result_t mangOH_bme680_Configure(
+    mangOH_bme680_SamplingRate_t samplingRate,
+    bool enableIaq,
+    bool enableCo2Equivalent,
+    bool enableBreathVoc,
+    bool enablePressure,
+    bool enableTemperature,
+    bool enableHumidity)
+{
+
+    float sr;
+    switch (samplingRate)
+    {
+    case MANGOH_BME680_SAMPLING_RATE_DISABLED:
+        sr = BSEC_SAMPLE_RATE_DISABLED;
+        break;
+    case MANGOH_BME680_SAMPLING_RATE_LP:
+        sr = BSEC_SAMPLE_RATE_LP;
+        break;
+    case MANGOH_BME680_SAMPLING_RATE_ULP:
+        sr = BSEC_SAMPLE_RATE_ULP;
+        break;
+    default:
+        return LE_BAD_PARAMETER;
+    }
+
+    _s.enableIaq = enableIaq;
+    _s.enableCo2Equivalent = enableCo2Equivalent;
+    _s.enableBreathVoc = enableBreathVoc;
+    _s.enablePressure = enablePressure;
+    _s.enableTemperature = enableTemperature;
+    _s.enableHumidity = enableHumidity;
+
+    bsec_sensor_configuration_t virtualOutputs[] = {
+        {
+            .sensor_id = BSEC_OUTPUT_IAQ,
+            .sample_rate = enableIaq ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+        {
+            .sensor_id = BSEC_OUTPUT_CO2_EQUIVALENT,
+            .sample_rate = enableCo2Equivalent ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+        {
+            .sensor_id = BSEC_OUTPUT_BREATH_VOC_EQUIVALENT,
+            .sample_rate = enableBreathVoc ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+        {
+            .sensor_id = BSEC_OUTPUT_RAW_PRESSURE,
+            .sample_rate = enablePressure ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+        {
+            .sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_TEMPERATURE,
+            .sample_rate = enableTemperature ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+        {
+            .sensor_id = BSEC_OUTPUT_SENSOR_HEAT_COMPENSATED_HUMIDITY,
+            .sample_rate = enableHumidity ? sr : BSEC_SAMPLE_RATE_DISABLED,
+        },
+    };
+
+    bsec_sensor_configuration_t requiredSensorSettings[BSEC_MAX_PHYSICAL_SENSOR];
+    uint8_t numRequiredSensorSettings = BSEC_MAX_PHYSICAL_SENSOR;
+    bsec_library_return_t status = bsec_update_subscription(
+        virtualOutputs,
+        NUM_ARRAY_MEMBERS(virtualOutputs),
+        requiredSensorSettings,
+        &numRequiredSensorSettings);
+
+    if (samplingRate != _s.samplingRate)
+    {
+        _s.samplingRate = samplingRate;
+        LE_ASSERT_OK(le_timer_SetMsInterval(_s.timer, (uint32_t)(1000.0 / sr)));
+        if (!le_timer_IsRunning(_s.timer))
+        {
+            LE_ASSERT_OK(le_timer_Start(_s.timer));
+        }
+    }
+
+    return status == BSEC_OK ? LE_OK : LE_FAULT;
+}
+
+mangOH_bme680_SensorReadingHandlerRef_t mangOH_bme680_AddSensorReadingHandler
+(
+    mangOH_bme680_SensorReadingHandlerFunc_t handlerFunc,
+    void* contextPtr
+)
+{
+    struct Bme680HandlerMapping *hm = le_mem_ForceAlloc(_s.HandlerPool);
+    hm->owningSession = mangOH_bme680_GetClientSessionRef();
+    hm->handlerFunc = handlerFunc;
+    hm->context = contextPtr;
+
+    return le_ref_CreateRef(_s.HandlerRefMap, hm);
+}
+
+void mangOH_bme680_RemoveSensorReadingHandler
+(
+    mangOH_bme680_SensorReadingHandlerRef_t handlerRef
+)
+{
+    struct Bme680HandlerMapping *hm = le_ref_Lookup(_s.HandlerRefMap, handlerRef);
+    if (!hm)
+    {
+        LE_WARN("No handler found for the given reference");
+        return;
+    }
+
+    if (mangOH_bme680_GetClientSessionRef() != hm->owningSession)
+    {
+        LE_WARN("Cannot delete handler that isn't owned");
+        return;
+    }
+
+    le_ref_DeleteRef(_s.HandlerRefMap, handlerRef);
+    le_mem_Release(hm);
+}

apps/Bme680EnvironmentalSensor/bsecIntegrationComponent/bsecIntegration.h

+#ifndef _BSEC_INTEGRATION_H_
+#define _BSEC_INTEGRATION_H_
+
+struct Bme680HandlerMapping
+{
+    le_msg_SessionRef_t owningSession;
+    mangOH_bme680_SensorReadingHandlerFunc_t handlerFunc;
+    void *context;
+};
+
+struct Bme680State
+{
+    struct bme680_linux *bme680;
+    le_timer_Ref_t timer;
+    mangOH_bme680_SamplingRate_t samplingRate;
+    bool enableIaq;
+    bool enableCo2Equivalent;
+    bool enableBreathVoc;
+    bool enablePressure;
+    bool enableTemperature;
+    bool enableHumidity;
+    le_mem_PoolRef_t HandlerPool;
+    le_ref_MapRef_t HandlerRefMap;
+};
+
+#endif // _BSEC_INTEGRATION_H_

apps/Bme680EnvironmentalSensor/mangOH_bme680.api

+ENUM SamplingRate
+{
+    SAMPLING_RATE_DISABLED,
+    SAMPLING_RATE_LP, // every 3 seconds
+    SAMPLING_RATE_ULP, // every 300 seconds (5 minutes)
+};
+
+FUNCTION le_result_t Configure
+(
+    SamplingRate samplingRate IN,
+    bool enableIaq IN,
+    bool enableCo2Equivalent IN,
+    bool enableBreathVoc IN,
+    bool enablePressure IN,
+    bool enableTemperature IN,
+    bool enableHumidity IN
+);
+
+STRUCT ReadingIaq
+{
+    bool valid;
+    double value;
+    uint8 accuracy;
+};
+
+STRUCT ReadingCo2Equivalent
+{
+    bool valid;
+    double value;
+    uint8 accuracy;
+};
+
+STRUCT ReadingBreathVoc
+{
+    bool valid;
+    double value;
+    uint8 accuracy;
+};
+
+STRUCT ReadingPressure
+{
+    bool valid;
+    double value;
+};
+
+STRUCT ReadingTemperature
+{
+    bool valid;
+    double value;
+};
+
+STRUCT ReadingHumidity
+{
+    bool valid;
+    double value;
+};
+
+STRUCT Reading
+{
+    int64 timestamp;
+    ReadingIaq iaq;
+    ReadingCo2Equivalent co2Equivalent;
+    ReadingBreathVoc breathVoc;
+    ReadingPressure pressure;
+    ReadingTemperature temperature;
+    ReadingHumidity humidity;
+};
+
+HANDLER SensorReadingHandler
+(
+    Reading reading
+);
+
+EVENT SensorReading
+(
+    SensorReadingHandler handler
+);

apps/Mcp9700aTemperatureSensor/Mcp9700aAppComponent/Component.cdef

+sources:
+{
+    mcp9700aOnWp.c
+}
+
+cflags:
+{
+    -std=c99
+}
+
+requires:
+{
+    api:
+    {
+        modemServices/le_adc.api
+    }
+    component:
+    {
+        ${CURDIR}/../Mcp970xComponent
+    }
+}
+
+provides:
+{
+    api:
+    {
+        mangOH_ambientTemperature.api
+    }
+}
\ No newline at end of file

apps/Mcp9700aTemperatureSensor/Mcp9700aAppComponent/mcp9700aOnWp.c

+#include "legato.h"
+#include "interfaces.h"
+#include "mcp970x.h"
+
+static int WpAdcFunction(int32_t *valueUv)
+{
+    return le_adc_ReadValue("EXT_ADC0", valueUv);
+}
+
+le_result_t mangOH_ambientTemperature_Read(double *temperature)
+{
+    int32_t tempInt;
+    int res = mcp970x_read_temperature(MCP970X_CHIP_9700A, WpAdcFunction, &tempInt);
+    if (res != 0)
+    {
+        return LE_FAULT;
+    }
+
+    *temperature = tempInt / 1000.0;
+    return LE_OK;
+}
+
+
+COMPONENT_INIT
+{
+}

apps/Mcp9700aTemperatureSensor/Mcp970xComponent/Component.cdef

+sources:
+{
+    component.c
+    mcp970x/mcp970x.c
+}
+
+cflags:
+{
+    -std=c99
+    -fvisibility=default
+}
+
+provides:
+{
+    headerDir:
+    {
+        ${CURDIR}/mcp970x
+    }
+}
\ No newline at end of file

apps/Mcp9700aTemperatureSensor/Mcp970xComponent/component.c

+#include "legato.h"
+
+// Requird to make this code a Legato component
+COMPONENT_INIT
+{
+}

apps/Mcp9700aTemperatureSensor/Mcp970xComponent/mcp970x/mcp970x.c

+#include "mcp970x.h"
+#include <errno.h>
+
+struct mcp970x_chip_spec
+{
+    uint32_t uv_at_zero_celcius;
+    // uV/degree celcius
+    uint32_t temperature_coefficient;
+};
+
+static const struct mcp970x_chip_spec chip_specs[] =
+{
+    [MCP970X_CHIP_9700] = {
+        .uv_at_zero_celcius = 500000,
+        .temperature_coefficient = 10000,
+    },
+    [MCP970X_CHIP_9701] = {
+        .uv_at_zero_celcius = 400000,
+        .temperature_coefficient = 19500,
+    },
+};
+
+/*
+ * Calculate the temperature in milli-degrees celcius.  Divide by 1000 to get degrees celcius.
+ *
+ * Datasheet equation 4-1:
+ * Vout = (Tc * Ta) + V0c
+ * So:
+ * Ta = (Vout - V0c) / Tc
+ */
+static int32_t calculate_temperature(const struct mcp970x_chip_spec *chip_spec, uint32_t voltage_uv)
+{
+    return (1000L * (voltage_uv - chip_spec->uv_at_zero_celcius)) / chip_spec->temperature_coefficient;
+}
+
+int mcp970x_read_temperature(enum mcp970x_chip chip, mcp970x_adc_function adc, int32_t *temperature)
+{
+    if (chip < 0 || chip >= MCP970X_CHIP_NUM_OF)
+    {
+        return -EINVAL;
+    }
+
+    const struct mcp970x_chip_spec *spec = &chip_specs[chip];
+    int32_t adc_uv;
+    int res = adc(&adc_uv);
+    if (res)
+    {
+        return res;
+    }
+
+    *temperature = calculate_temperature(spec, adc_uv);
+    return 0;
+}

apps/Mcp9700aTemperatureSensor/Mcp970xComponent/mcp970x/mcp970x.h

+#ifndef _MCP970X_H_
+#define _MCP970X_H_
+
+#include <stdint.h>
+
+/*
+ * "A" versions are the same except with better accuracy
+ */
+enum mcp970x_chip
+{
+    MCP970X_CHIP_9700,
+    MCP970X_CHIP_9700A = MCP970X_CHIP_9700,
+    MCP970X_CHIP_9701,
+    MCP970X_CHIP_9701A = MCP970X_CHIP_9701,
+
+    MCP970X_CHIP_NUM_OF,
+};
+
+typedef int (*mcp970x_adc_function)(int32_t *val_uv);
+int mcp970x_read_temperature(
+    enum mcp970x_chip chip, mcp970x_adc_function adc, int32_t *temperature);
+
+#endif // _MCP970X_H_

apps/Mcp9700aTemperatureSensor/mangOH_ambientTemperature.api

+FUNCTION le_result_t Read
+(
+    double temperature OUT
+);

apps/Mcp9700aTemperatureSensor/mcp9700aTemperatureSensor.adef

+sandboxed: true
+version: 1.0.0
+start: auto
+
+executables:
+{
+    mcp9700aTemperatureSensor = ( Mcp9700aAppComponent )
+}
+
+processes:
+{
+    envVars:
+    {
+        LE_LOG_LEVEL = DEBUG
+    }
+    run:
+    {
+        ( mcp9700aTemperatureSensor )
+    }
+    faultAction: restart
+}
+
+bindings:
+{
+    mcp9700aTemperatureSensor.Mcp9700aAppComponent.le_adc -> modemService.le_adc
+}
+
+extern:
+{
+    mcp9700aTemperatureSensor.Mcp9700aAppComponent.mangOH_ambientTemperature
+}
\ No newline at end of file

Bosch_BME680_Driver @ b79dcfd1

+Subproject commit b79dcfd1968a127400e9d6bf4b422cff4df90f01

components/boschBme680Driver/Component.cdef

+sources:
+{
+    bme680_linux_i2c.c
+    Bosch_BME680_Driver/bme680.c
+}
+
+cflags:
+{
+    -I${CURDIR}/Bosch_BME680_Driver
+    -fvisibility=default
+}
+
+provides:
+{
+    headerDir:
+    {
+        ${CURDIR}
+        ${CURDIR}/Bosch_BME680_Driver
+    }
+}
\ No newline at end of file

components/boschBme680Driver/bme680_linux_i2c.c

+#include "legato.h"
+#include "interfaces.h"
+#include "bme680_linux_i2c.h"
+
+#include <fcntl.h>
+#include <linux/i2c-dev.h>
+#include <linux/i2c.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/ioctl.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <time.h>
+#include <unistd.h>
+
+
+/*
+ * Private data that is opaque to clients.
+ */
+struct bme680_linux_priv
+{
+    int i2c_bus_fd;
+    uint16_t i2c_bus_num;
+    uint16_t i2c_addr;
+};
+
+static void bme680_linux_delay_ms(uint32_t period_ms, void *context)
+{
+    const struct timespec delay = {
+        .tv_sec = period_ms / 1000,
+        .tv_nsec = (period_ms % 1000) * 1000 * 1000,
+    };
+    int ret = nanosleep(&delay, NULL);
+    if (ret) {
+        LE_ERROR("nanosleep failed with error: %s\n", strerror(errno));
+    }
+}
+
+static int8_t bme680_linux_i2c_read(uint8_t reg_addr, uint8_t *reg_data, uint16_t len, void *context)
+{
+    int8_t res = 0; /* Return 0 for Success, non-zero for failure */
+    struct bme680_linux *bme680 = context;
+
+    struct i2c_msg i2c_msgs[] = {
+        {
+            .addr = bme680->priv->i2c_addr,
+            .flags = 0,
+            .buf = &reg_addr,
+            .len = 1,
+        },
+        {
+            .addr = bme680->priv->i2c_addr,
+            .flags = I2C_M_RD,
+            .buf = reg_data,
+            .len = len,
+        },
+    };
+    struct i2c_rdwr_ioctl_data i2c_xfer = {
+        .msgs = i2c_msgs,
+        .nmsgs = NUM_ARRAY_MEMBERS(i2c_msgs),
+    };
+    if (ioctl(bme680->priv->i2c_bus_fd, I2C_RDWR, &i2c_xfer) < 0) {
+        LE_WARN(
+            "I2C read on bus %u, address %u to register %u of length %u failed - %s\n",
+            bme680->priv->i2c_bus_num, bme680->priv->i2c_addr, reg_addr, len, strerror(errno));
+        res = BME680_E_COM_FAIL;
+    }
+
+    return res;
+}
+
+static int8_t bme680_linux_i2c_write(uint8_t reg_addr, const uint8_t *reg_data, uint16_t len, void *context)
+{
+    uint8_t buffer[64];
+    int8_t res = 0; /* Return 0 for Success, non-zero for failure */
+    struct bme680_linux *bme680 = context;
+
+    if (len >= sizeof(buffer)) {
+        LE_ERROR("I2C write buffer is too small (%u)\n", sizeof(buffer));
+        return BME680_E_INVALID_LENGTH;
+    }
+    buffer[0] = reg_addr;
+    memcpy(&buffer[1], reg_data, len);
+
+    struct i2c_msg i2c_msgs[] = {
+        {
+            .addr = bme680->priv->i2c_addr,
+            .flags = 0,
+            .buf = buffer,
+            .len = len + 1,
+        },
+    };
+    struct i2c_rdwr_ioctl_data i2c_xfer = {
+        .msgs = i2c_msgs,
+        .nmsgs = NUM_ARRAY_MEMBERS(i2c_msgs),
+    };
+    if (ioctl(bme680->priv->i2c_bus_fd, I2C_RDWR, &i2c_xfer) < 0) {
+        LE_WARN(
+            "I2C write on bus %u, address %u to register %u of length %u failed - %s\n",
+            bme680->priv->i2c_bus_num, bme680->priv->i2c_addr, reg_addr, len, strerror(errno));
+        res = BME680_E_COM_FAIL;
+    }
+
+    return res;
+}
+
+struct bme680_linux* bme680_linux_i2c_create(unsigned i2c_bus_num, uint8_t i2c_addr, int8_t ambient_temperature)
+{
+    struct bme680_linux *bme680 = calloc(sizeof(*bme680), 1);
+    if (!bme680)
+        return NULL;
+    bme680->priv = calloc(sizeof(*(bme680->priv)), 1);
+    if (!bme680->priv)
+        goto fail;
+
+    // Initialize Bosch driver struct
+    bme680->dev.context = bme680;
+    bme680->dev.intf = BME680_I2C_INTF;
+    bme680->dev.read = bme680_linux_i2c_read;
+    bme680->dev.write = bme680_linux_i2c_write;
+    bme680->dev.delay_ms = bme680_linux_delay_ms;
+    bme680->dev.amb_temp = ambient_temperature;
+
+    // Initialize private data required for read/write/delay_ms
+    bme680->priv->i2c_bus_num = i2c_bus_num;
+    bme680->priv->i2c_addr = i2c_addr;
+    char bus_filename[100];
+    int needed_len = snprintf(bus_filename, sizeof(bus_filename) - 1, "/dev/i2c-%u", i2c_bus_num);
+    LE_ASSERT(needed_len < sizeof(bus_filename));
+    bme680->priv->i2c_bus_fd = open(bus_filename, O_RDWR);
+    if (bme680->priv->i2c_bus_fd < 0) {
+        LE_ERROR("Couldn't open I2C bus %u - %s\n", i2c_bus_num, strerror(errno));
+        goto fail;
+    }
+
+    return bme680;
+
+fail:
+    if (bme680->priv)
+        free(bme680->priv);
+    free(bme680);
+    return NULL;
+}
+
+void bme680_linux_i2c_destroy(struct bme680_linux* bme680)
+{
+    int close_res = close(bme680->priv->i2c_bus_fd);
+    if (close_res != 0) {
+        LE_ERROR("Couldn't close I2C bus file descriptor - %s\n", strerror(errno));
+    }
+    free(bme680->priv);
+    free(bme680);
+}
+
+COMPONENT_INIT
+{
+}

components/boschBme680Driver/bme680_linux_i2c.h

+#ifndef _BME680_LINUX_I2C_H_
+#define _BME680_LINUX_I2C_H_
+
+#include "legato.h"
+#include "bme680_defs.h"
+#include <stdint.h>
+
+typedef struct bme680_linux_priv bme680_linux_priv;
+
+struct bme680_linux
+{
+    struct bme680_dev dev;
+    bme680_linux_priv* priv;
+};
+
+struct bme680_linux* bme680_linux_i2c_create(unsigned i2c_bus_num, uint8_t i2c_addr, int8_t ambient_temperature);
+void bme680_linux_i2c_destroy(struct bme680_linux* bme680);
+
+#endif // _BME680_LINUX_I2C_H_

components/boschBsec/Component.cdef

+sources:
+{
+    component.c
+}
+
+cflags:
+{
+}
+
+ldflags:
+{
+    -lm
+    -L ${BSEC_DIR}
+}
+
+requires:
+{
+    lib:
+    {
+        libalgobsec.a
+    }
+}
+
+provides:
+{
+    headerDir:
+    {
+        ${BSEC_DIR}
+    }
+}
\ No newline at end of file

components/boschBsec/README.md

+# Bosch BSEC Component
+
+[BSEC](https://www.bosch-sensortec.com/bst/products/all_products/bsec) (Bosch Sensortec
+Environmental Cluster) is a proprietary library which is used to process the data provided by a
+BME680 environmental sensor to derive more useful results.
+
+The library published at the URL above cannot be used in a Legato component because the code is not
+relocatable and Legato components are built as shared libraries.  This issue was raised with Bosch
+in a [forum post](https://community.bosch-sensortec.com/t5/MEMS-sensors-forum/BSEC-integration-problem-on-gcc-Cortex-A7/m-p/5995)
+in which Bosch provides an alternative download compiled with the options necessary to make the
+library relocatable.
+
+To build this component, download and extract the zip file from the forum post and then create an
+enironment variable `$BSEC_DIR` which points to the directory containing the `.a` file.  For
+example: `export BSEC_DIR=~/BSEC_1.4.7.2_GCC_CortexA7_20190225/algo/bin/Normal_version/Cortex_A7`

components/boschBsec/component.c

+#include "legato.h"
+
+COMPONENT_INIT
+{
+    // Required to implement a component
+}

linux_kernel_modules/bme680/bitfield.h

-/*
- * Copyright (C) 2014 Felix Fietkau <nbd@nbd.name>
- * Copyright (C) 2004 - 2009 Ivo van Doorn <IvDoorn@gmail.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2
- * as published by the Free Software Foundation
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#ifndef _LINUX_BITFIELD_H
-#define _LINUX_BITFIELD_H
-
-#include <asm/byteorder.h>
-
-/*
- * Bitfield access macros
- *
- * FIELD_{GET,PREP} macros take as first parameter shifted mask
- * from which they extract the base mask and shift amount.
- * Mask must be a compilation time constant.
- *
- * Example:
- *
- *  #define REG_FIELD_A  GENMASK(6, 0)
- *  #define REG_FIELD_B  BIT(7)
- *  #define REG_FIELD_C  GENMASK(15, 8)
- *  #define REG_FIELD_D  GENMASK(31, 16)
- *
- * Get:
- *  a = FIELD_GET(REG_FIELD_A, reg);
- *  b = FIELD_GET(REG_FIELD_B, reg);
- *
- * Set:
- *  reg = FIELD_PREP(REG_FIELD_A, 1) |
- *	  FIELD_PREP(REG_FIELD_B, 0) |
- *	  FIELD_PREP(REG_FIELD_C, c) |
- *	  FIELD_PREP(REG_FIELD_D, 0x40);
- *
- * Modify:
- *  reg &= ~REG_FIELD_C;
- *  reg |= FIELD_PREP(REG_FIELD_C, c);
- */
-
-#define __bf_shf(x) (__builtin_ffsll(x) - 1)
-
-/**
- * FIELD_PREP() - prepare a bitfield element
- * @_mask: shifted mask defining the field's length and position
- * @_val:  value to put in the field
- *
- * FIELD_PREP() masks and shifts up the value.  The result should
- * be combined with other fields of the bitfield using logical OR.
- */
-#define FIELD_PREP(_mask, _val)						\
-	({								\
-		((typeof(_mask))(_val) << __bf_shf(_mask)) & (_mask);	\
-	})
-
-/**
- * FIELD_GET() - extract a bitfield element
- * @_mask: shifted mask defining the field's length and position
- * @_reg:  value of entire bitfield
- *
- * FIELD_GET() extracts the field specified by @_mask from the
- * bitfield passed in as @_reg by masking and shifting it down.
- */
-#define FIELD_GET(_mask, _reg)						\
-	({								\
-		(typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask));	\
-	})
-
-#endif

linux_kernel_modules/bme680/bme680.h

-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef BME680_H_
-#define BME680_H_
-
-#define BME680_REG_CHIP_I2C_ID			0xD0
-#define BME680_REG_CHIP_SPI_ID			0x50
-#define   BME680_CHIP_ID_VAL			0x61
-#define BME680_REG_SOFT_RESET_I2C		0xE0
-#define BME680_REG_SOFT_RESET_SPI		0x60
-#define   BME680_CMD_SOFTRESET			0xB6
-#define BME680_REG_STATUS			0x73
-#define   BME680_SPI_MEM_PAGE_BIT		BIT(4)
-#define     BME680_SPI_MEM_PAGE_1_VAL		1
-
-#define BME680_REG_TEMP_MSB			0x22
-#define BME680_REG_PRESS_MSB			0x1F
-#define BM6880_REG_HUMIDITY_MSB			0x25
-#define BME680_REG_GAS_MSB			0x2A
-#define BME680_REG_GAS_R_LSB			0x2B
-#define   BME680_GAS_STAB_BIT			BIT(4)
-#define   BME680_GAS_RANGE_MASK			GENMASK(3, 0)
-
-#define BME680_REG_CTRL_HUMIDITY		0x72
-#define   BME680_OSRS_HUMIDITY_MASK		GENMASK(2, 0)
-
-#define BME680_REG_CTRL_MEAS			0x74
-#define   BME680_OSRS_TEMP_MASK			GENMASK(7, 5)
-#define   BME680_OSRS_PRESS_MASK		GENMASK(4, 2)
-#define   BME680_MODE_MASK			GENMASK(1, 0)
-#define     BME680_MODE_FORCED			1
-#define     BME680_MODE_SLEEP			0
-
-#define BME680_REG_CONFIG			0x75
-#define   BME680_FILTER_MASK			GENMASK(4, 2)
-#define     BME680_FILTER_COEFF_VAL		BIT(1)
-
-/* TEMP/PRESS/HUMID reading skipped */
-#define BME680_MEAS_SKIPPED			0x8000
-
-#define BME680_MAX_OVERFLOW_VAL			0x40000000
-#define BME680_HUM_REG_SHIFT_VAL		4
-#define BME680_BIT_H1_DATA_MASK			GENMASK(3, 0)
-
-#define BME680_REG_RES_HEAT_RANGE		0x02
-#define   BME680_RHRANGE_MASK			GENMASK(5, 4)
-#define BME680_REG_RES_HEAT_VAL			0x00
-#define BME680_REG_RANGE_SW_ERR			0x04
-#define   BME680_RSERROR_MASK			GENMASK(7, 4)
-#define BME680_REG_RES_HEAT_0			0x5A
-#define BME680_REG_GAS_WAIT_0			0x64
-#define BME680_ADC_GAS_RES_SHIFT		6
-#define BME680_AMB_TEMP				25
-
-#define BME680_REG_CTRL_GAS_1			0x71
-#define   BME680_RUN_GAS_MASK			BIT(4)
-#define   BME680_NB_CONV_MASK			GENMASK(3, 0)
-
-#define BME680_REG_MEAS_STAT_0			0x1D
-#define   BME680_GAS_MEAS_BIT			BIT(6)
-
-/* Calibration Parameters */
-#define BME680_T2_LSB_REG	0x8A
-#define BME680_T3_REG		0x8C
-#define BME680_P1_LSB_REG	0x8E
-#define BME680_P2_LSB_REG	0x90
-#define BME680_P3_REG		0x92
-#define BME680_P4_LSB_REG	0x94
-#define BME680_P5_LSB_REG	0x96
-#define BME680_P7_REG		0x98
-#define BME680_P6_REG		0x99
-#define BME680_P8_LSB_REG	0x9C
-#define BME680_P9_LSB_REG	0x9E
-#define BME680_P10_REG		0xA0
-#define BME680_H2_LSB_REG	0xE2
-#define BME680_H2_MSB_REG	0xE1
-#define BME680_H1_MSB_REG	0xE3
-#define BME680_H1_LSB_REG	0xE2
-#define BME680_H3_REG		0xE4
-#define BME680_H4_REG		0xE5
-#define BME680_H5_REG		0xE6
-#define BME680_H6_REG		0xE7
-#define BME680_H7_REG		0xE8
-#define BME680_T1_LSB_REG	0xE9
-#define BME680_GH2_LSB_REG	0xEB
-#define BME680_GH1_REG		0xED
-#define BME680_GH3_REG		0xEE
-
-extern const struct regmap_config bme680_regmap_config;
-
-int bme680_core_probe(struct device *dev, struct regmap *regmap,
-		      const char *name);
-
-#endif  /* BME680_H_ */

linux_kernel_modules/bme680/bme680_i2c.c

-// SPDX-License-Identifier: GPL-2.0
-/*
- * BME680 - I2C Driver
- *
- * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com>
- *
- * 7-Bit I2C slave address is:
- *	- 0x76 if SDO is pulled to GND
- *	- 0x77 if SDO is pulled to VDDIO
- *
- * Note: SDO pin cannot be left floating otherwise I2C address
- *	 will be undefined.
- */
-#include <linux/acpi.h>
-#include <linux/i2c.h>
-#include <linux/module.h>
-#include <linux/regmap.h>
-
-#include "bme680.h"
-
-static int bme680_i2c_probe(struct i2c_client *client,
-			    const struct i2c_device_id *id)
-{
-	struct regmap *regmap;
-	const char *name = NULL;
-	unsigned int val;
-	int ret;
-
-	regmap = devm_regmap_init_i2c(client, &bme680_regmap_config);
-	if (IS_ERR(regmap)) {
-		dev_err(&client->dev, "Failed to register i2c regmap %d\n",
-				(int)PTR_ERR(regmap));
-		return PTR_ERR(regmap);
-	}
-
-	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_I2C,
-			   BME680_CMD_SOFTRESET);
-	if (ret < 0) {
-		dev_err(&client->dev, "Failed to reset chip\n");
-		return ret;
-	}
-
-	ret = regmap_read(regmap, BME680_REG_CHIP_I2C_ID, &val);
-	if (ret < 0) {
-		dev_err(&client->dev, "Error reading I2C chip ID\n");
-		return ret;
-	}
-
-	if (val != BME680_CHIP_ID_VAL) {
-		dev_err(&client->dev, "Wrong chip ID, got %x expected %x\n",
-				val, BME680_CHIP_ID_VAL);
-		return -ENODEV;
-	}
-
-	if (id)
-		name = id->name;
-
-	return bme680_core_probe(&client->dev, regmap, name);
-}
-
-static const struct i2c_device_id bme680_i2c_id[] = {
-	{"bme680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(i2c, bme680_i2c_id);
-
-static const struct acpi_device_id bme680_acpi_match[] = {
-	{"BME0680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(acpi, bme680_acpi_match);
-
-static struct i2c_driver bme680_i2c_driver = {
-	.driver = {
-		.name			= "bme680_i2c",
-		.acpi_match_table       = ACPI_PTR(bme680_acpi_match),
-	},
-	.probe = bme680_i2c_probe,
-	.id_table = bme680_i2c_id,
-};
-module_i2c_driver(bme680_i2c_driver);
-
-MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
-MODULE_DESCRIPTION("BME680 I2C driver");
-MODULE_LICENSE("GPL v2");

linux_kernel_modules/bme680/bme680_spi.c

-// SPDX-License-Identifier: GPL-2.0
-/*
- * BME680 - SPI Driver
- *
- * Copyright (C) 2018 Himanshu Jha <himanshujha199640@gmail.com>
- */
-#include <linux/acpi.h>
-#include <linux/module.h>
-#include <linux/regmap.h>
-#include <linux/spi/spi.h>
-
-#include "bme680.h"
-
-static int bme680_regmap_spi_write(void *context, const void *data,
-				   size_t count)
-{
-	struct spi_device *spi = context;
-	u8 buf[2];
-
-	memcpy(buf, data, 2);
-	/*
-	 * The SPI register address (= full register address without bit 7)
-	 * and the write command (bit7 = RW = '0')
-	 */
-	buf[0] &= ~0x80;
-
-	return spi_write_then_read(spi, buf, 2, NULL, 0);
-}
-
-static int bme680_regmap_spi_read(void *context, const void *reg,
-				  size_t reg_size, void *val, size_t val_size)
-{
-	struct spi_device *spi = context;
-
-	return spi_write_then_read(spi, reg, reg_size, val, val_size);
-}
-
-static struct regmap_bus bme680_regmap_bus = {
-	.write = bme680_regmap_spi_write,
-	.read = bme680_regmap_spi_read,
-	.reg_format_endian_default = REGMAP_ENDIAN_BIG,
-	.val_format_endian_default = REGMAP_ENDIAN_BIG,
-};
-
-static int bme680_spi_probe(struct spi_device *spi)
-{
-	const struct spi_device_id *id = spi_get_device_id(spi);
-	struct regmap *regmap;
-	unsigned int val;
-	int ret;
-
-	spi->bits_per_word = 8;
-	ret = spi_setup(spi);
-	if (ret < 0) {
-		dev_err(&spi->dev, "spi_setup failed!\n");
-		return ret;
-	}
-
-	regmap = devm_regmap_init(&spi->dev, &bme680_regmap_bus,
-				  &spi->dev, &bme680_regmap_config);
-	if (IS_ERR(regmap)) {
-		dev_err(&spi->dev, "Failed to register spi regmap %d\n",
-				(int)PTR_ERR(regmap));
-		return PTR_ERR(regmap);
-	}
-
-	ret = regmap_write(regmap, BME680_REG_SOFT_RESET_SPI,
-			   BME680_CMD_SOFTRESET);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Failed to reset chip\n");
-		return ret;
-	}
-
-	/* after power-on reset, Page 0(0x80-0xFF) of spi_mem_page is active */
-	ret = regmap_read(regmap, BME680_REG_CHIP_SPI_ID, &val);
-	if (ret < 0) {
-		dev_err(&spi->dev, "Error reading SPI chip ID\n");
-		return ret;
-	}
-
-	if (val != BME680_CHIP_ID_VAL) {
-		dev_err(&spi->dev, "Wrong chip ID, got %x expected %x\n",
-				val, BME680_CHIP_ID_VAL);
-		return -ENODEV;
-	}
-	/*
-	 * select Page 1 of spi_mem_page to enable access to
-	 * to registers from address 0x00 to 0x7F.
-	 */
-	ret = regmap_write_bits(regmap, BME680_REG_STATUS,
-				BME680_SPI_MEM_PAGE_BIT,
-				BME680_SPI_MEM_PAGE_1_VAL);
-	if (ret < 0) {
-		dev_err(&spi->dev, "failed to set page 1 of spi_mem_page\n");
-		return ret;
-	}
-
-	return bme680_core_probe(&spi->dev, regmap, id->name);
-}
-
-static const struct spi_device_id bme680_spi_id[] = {
-	{"bme680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(spi, bme680_spi_id);
-
-static const struct acpi_device_id bme680_acpi_match[] = {
-	{"BME0680", 0},
-	{},
-};
-MODULE_DEVICE_TABLE(acpi, bme680_acpi_match);
-
-static struct spi_driver bme680_spi_driver = {
-	.driver = {
-		.name			= "bme680_spi",
-		.acpi_match_table	= ACPI_PTR(bme680_acpi_match),
-	},
-	.probe = bme680_spi_probe,
-	.id_table = bme680_spi_id,
-};
-module_spi_driver(bme680_spi_driver);
-
-MODULE_AUTHOR("Himanshu Jha <himanshujha199640@gmail.com>");
-MODULE_DESCRIPTION("Bosch BME680 SPI driver");
-MODULE_LICENSE("GPL v2");

linux_kernel_modules/mangoh/mangoh_yellow_dev.mdef

@@ -25,7 +25,6 @@ requires:
     {
 
         $CURDIR/../bmi160/bmi160-i2c
-        $CURDIR/../bme680/bme680-i2c
         $CURDIR/../rtc-pcf85063/rtc-pcf85063
         $CURDIR/../bq25601/bq25601
         $CURDIR/../bq27xxx/bq27xxx_battery

mangOH.sdef

@@ -57,6 +57,10 @@ apps:
    // $MANGOH_ROOT/apps/YellowSensorToCloud/yellowSensor
     $LEGATO_ROOT/apps/sample/dataHub/dataHub
 
+    $MANGOH_ROOT/apps/Mcp9700aTemperatureSensor/mcp9700aTemperatureSensor
+    $MANGOH_ROOT/apps/Bme680EnvironmentalSensor/bme680EnvironmentalSensor
+    $MANGOH_ROOT/samples/BsecTest/bsecTest
+
 #endif // MANGOH_BOARD
 
     $MANGOH_ROOT/apps/MqttClient/mqttClient
@@ -65,7 +69,6 @@ apps:
     $MANGOH_ROOT/apps/SocialService/socialService
     $LEGATO_ROOT/apps/tools/devMode
 
-
 }
 
 commands:
@@ -92,6 +95,8 @@ interfaceSearch:
 
 #elif ${MANGOH_BOARD} = yellow
     $LEGATO_ROOT/apps/sample/dataHub
+    $MANGOH_ROOT/apps/Mcp9700aTemperatureSensor
+    $MANGOH_ROOT/apps/Bme680EnvironmentalSensor
 
 #endif // MANGOH_BOARD
     $MANGOH_ROOT/apps/DataRouter
@@ -121,6 +126,7 @@ componentSearch:
 
 kernelModules:
 {
+
 #if ${MANGOH_BOARD} = red
     $CURDIR/linux_kernel_modules/mangoh/mangoh_red
     $CURDIR/linux_kernel_modules/mt7697wifi/mt7697wifi_core
@@ -164,7 +170,6 @@ kernelModules:
     $CURDIR/linux_kernel_modules/iio/iio-kfifo-buf
     $CURDIR/linux_kernel_modules/iio/iio
 #endif // MANGOH_KERNEL_LACKS_IIO
-    $CURDIR/linux_kernel_modules/bme680/bme680-i2c
     $CURDIR/linux_kernel_modules/bmi160/bmi160-i2c
     $CURDIR/linux_kernel_modules/bmi160/bmi160
     $CURDIR/linux_kernel_modules/bmm150/bmc150_magn_i2c

samples/BsecTest/bsecTest.adef

+sandboxed: true
+version: 1.0.0
+start: auto
+
+executables:
+{
+    bsecTest = ( bsecTestComponent )
+}
+
+processes:
+{
+    run:
+    {
+        ( bsecTest )
+    }
+    faultAction: restart
+}
+
+bindings:
+{
+    bsecTest.bsecTestComponent.mangOH_bme680 -> bme680EnvironmentalSensor.mangOH_bme680
+}
\ No newline at end of file

linux_kernel_modules/bme680/bme680-i2c.mdef → samples/BsecTest/bsecTestComponent/Component.cdef

-cflags:
+sources:
 {
-    // This driver depends on IIO
-    -DCONFIG_IIO
-    -DCONFIG_IIO_BUFFER
-    -DCONFIG_IIO_TRIGGERRED_BUFFER
-    -DDEBUG
-    -DREGMAP
-    -DREGMAP_I2C
+    component.c
 }
 
-sources:
+cflags:
 {
-    bme680_i2c.c
-    bme680_core.c
+    -std=c99
 }
 
 requires:
 {
-    kernelModules:
+    api:
     {
-#if ${MANGOH_KERNEL_LACKS_IIO} = 1
-        $CURDIR/../iio/iio
-#endif // MANGOH_KERNEL_LACKS_IIO
+        mangOH_bme680.api
     }
 }

samples/BsecTest/bsecTestComponent/component.c

+#include "legato.h"
+#include "interfaces.h"
+
+static void SensorReadingHandler(
+    const mangOH_bme680_Reading_t *reading,
+    void* context
+)
+{
+    LE_INFO("bme680 reading received with ts=%llu", reading->timestamp);
+    LE_INFO("  iaq_valid=%d, iaq=%f, iaq_accuracy=%d",
+            reading->iaq.valid, reading->iaq.value, reading->iaq.accuracy);
+    LE_INFO("  co2_equivalent_valid=%d, co2_equivalent=%f, co2_equivalent_accuracy=%d",
+            reading->co2Equivalent.valid, reading->co2Equivalent.value, reading->co2Equivalent.accuracy);
+    LE_INFO("  breath_voc_valid=%d, breath_voc=%f, breath_voc_accuracy=%d",
+            reading->breathVoc.valid, reading->breathVoc.value, reading->breathVoc.accuracy);
+    LE_INFO("  pressure_valid=%d, pressure=%f", reading->pressure.valid, reading->pressure.value);
+    LE_INFO("  temperature_valid=%d, temperature=%f", reading->temperature.valid, reading->temperature.value);
+    LE_INFO("  humidity_valid=%d, humidity=%f", reading->humidity.valid, reading->humidity.value);
+}
+
+COMPONENT_INIT
+{
+    mangOH_bme680_AddSensorReadingHandler(SensorReadingHandler, NULL);
+
+    const bool enableIaq = true;
+    const bool enableCo2Equivalent = true;
+    const bool enableBreathVoc = true;
+    const bool enablePressure = true;
+    const bool enableTemperature = true;
+    const bool enableHumidity = true;
+    le_result_t configRes = mangOH_bme680_Configure(
+        MANGOH_BME680_SAMPLING_RATE_LP,
+        enableIaq,
+        enableCo2Equivalent,
+        enableBreathVoc,
+        enablePressure,
+        enableTemperature,
+        enableHumidity);
+    LE_ASSERT_OK(configRes);
+}