summaryrefslogtreecommitdiff
path: root/nrfdemo/src
diff options
context:
space:
mode:
Diffstat (limited to 'nrfdemo/src')
-rw-r--r--nrfdemo/src/bme680/CMakeLists.txt9
-rw-r--r--nrfdemo/src/bme680/Kconfig118
-rw-r--r--nrfdemo/src/bme680/bme680.c477
-rw-r--r--nrfdemo/src/bme680/bme680.h220
-rw-r--r--nrfdemo/src/bme680/bme680_i2c.c43
-rw-r--r--nrfdemo/src/bme680/bme680_spi.c146
-rw-r--r--nrfdemo/src/main.c296
-rw-r--r--nrfdemo/src/mqtt_connection.c365
-rw-r--r--nrfdemo/src/mqtt_connection.h21
9 files changed, 1695 insertions, 0 deletions
diff --git a/nrfdemo/src/bme680/CMakeLists.txt b/nrfdemo/src/bme680/CMakeLists.txt
new file mode 100644
index 0000000..e7d6f89
--- /dev/null
+++ b/nrfdemo/src/bme680/CMakeLists.txt
@@ -0,0 +1,9 @@
+# Copyright (c) 2018 Bosch Sensortec GmbH
+# Copyright (c) 2022, Leonard Pollak
+#
+# SPDX-License-Identifier: Apache-2.0
+#
+
+zephyr_library()
+
+zephyr_library_sources(bme680.c bme680_i2c.c bme680_spi.c)
diff --git a/nrfdemo/src/bme680/Kconfig b/nrfdemo/src/bme680/Kconfig
new file mode 100644
index 0000000..6f3343d
--- /dev/null
+++ b/nrfdemo/src/bme680/Kconfig
@@ -0,0 +1,118 @@
+# BME680 temperature, pressure, humidity and gas sensor configuration options
+
+# Copyright (c) 2018 Bosch Sensortec GmbH
+# Copyright (c) 2022, Leonard Pollak
+#
+# SPDX-License-Identifier: Apache-2.0
+
+menuconfig BME680
+ bool "BME680 sensor"
+ default y
+ depends on DT_HAS_BOSCH_BME680_ENABLED
+ select I2C if $(dt_compat_on_bus,$(DT_COMPAT_BOSCH_BME680),i2c)
+ select SPI if $(dt_compat_on_bus,$(DT_COMPAT_BOSCH_BME680),spi)
+ help
+ Enable driver for BME680 I2C- or SPI- based temperature, pressure, humidity and gas sensor.
+
+if BME680
+
+choice
+ prompt "BME680 temperature oversampling"
+ default BME680_TEMP_OVER_2X
+ help
+ Select temperature oversampling for the BME680 sensor. Higher values
+ lead to more accurate readings, but higher power consumption.
+config BME680_TEMP_OVER_1X
+ bool "x1"
+config BME680_TEMP_OVER_2X
+ bool "x2"
+config BME680_TEMP_OVER_4X
+ bool "x4"
+config BME680_TEMP_OVER_8X
+ bool "x8"
+config BME680_TEMP_OVER_16X
+ bool "x16"
+endchoice
+
+choice
+ prompt "BME680 pressure oversampling"
+ default BME680_PRESS_OVER_16X
+ help
+ Select pressure oversampling for the BME680 sensor. Higher values
+ lead to more accurate readings, but higher power consumption.
+config BME680_PRESS_OVER_1X
+ bool "x1"
+config BME680_PRESS_OVER_2X
+ bool "x2"
+config BME680_PRESS_OVER_4X
+ bool "x4"
+config BME680_PRESS_OVER_8X
+ bool "x8"
+config BME680_PRESS_OVER_16X
+ bool "x16"
+endchoice
+
+choice
+ prompt "BME680 humidity oversampling"
+ default BME680_HUMIDITY_OVER_1X
+ help
+ Select humidity oversampling for the BME680 sensor. Higher values
+ lead to more accurate readings, but higher power consumption.
+config BME680_HUMIDITY_OVER_1X
+ bool "x1"
+config BME680_HUMIDITY_OVER_2X
+ bool "x2"
+config BME680_HUMIDITY_OVER_4X
+ bool "x4"
+config BME680_HUMIDITY_OVER_8X
+ bool "x8"
+config BME680_HUMIDITY_OVER_16X
+ bool "x16"
+endchoice
+
+choice
+ prompt "BME680 IIR low-pass filter coefficient"
+ default BME680_FILTER_OFF
+ help
+ Select the filter coefficient for the BME680 sensor.
+config BME680_FILTER_OFF
+ bool "filter off"
+config BME680_FILTER_2
+ bool "2"
+config BME680_FILTER_4
+ bool "4"
+config BME680_FILTER_8
+ bool "8"
+config BME680_FILTER_16
+ bool "16"
+config BME680_FILTER_32
+ bool "32"
+config BME680_FILTER_64
+ bool "64"
+config BME680_FILTER_128
+ bool "128"
+endchoice
+
+choice
+ prompt "BME680 gas sensor's heater temperature in degree Celsius"
+ default BME680_HEATR_TEMP_LP
+ help
+ Select the gas sensor's heater temperature for the BME680 sensor.
+config BME680_HEATR_TEMP_LP
+ bool "320"
+config BME680_HEATR_TEMP_ULP
+ bool "400"
+endchoice
+
+choice
+ prompt "BME680 gas sensor's heating duration in milliseconds"
+ default BME680_HEATR_DUR_LP
+ help
+ Select the gas sensor's heating duration for the BME680 sensor.
+config BME680_HEATR_DUR_LP
+ bool "197"
+config BME680_HEATR_DUR_ULP
+ bool "1943"
+endchoice
+
+endif # BME680
diff --git a/nrfdemo/src/bme680/bme680.c b/nrfdemo/src/bme680/bme680.c
new file mode 100644
index 0000000..2a9a21d
--- /dev/null
+++ b/nrfdemo/src/bme680/bme680.c
@@ -0,0 +1,477 @@
+/* bme680.c - Driver for Bosch Sensortec's BME680 temperature, pressure,
+ * humidity and gas sensor
+ *
+ * https://www.bosch-sensortec.com/bst/products/all_products/bme680
+ */
+
+/*
+ * Copyright (c) 2018 Bosch Sensortec GmbH
+ * Copyright (c) 2022, Leonard Pollak
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#include <zephyr/drivers/gpio.h>
+#include <zephyr/init.h>
+#include <zephyr/kernel.h>
+#include <zephyr/sys/byteorder.h>
+#include <zephyr/sys/__assert.h>
+#include <zephyr/drivers/sensor.h>
+#include <zephyr/logging/log.h>
+
+#include "bme680.h"
+
+LOG_MODULE_REGISTER(bme680, CONFIG_SENSOR_LOG_LEVEL);
+
+
+#if BME680_BUS_SPI
+static inline bool bme680_is_on_spi(const struct device *dev)
+{
+ const struct bme680_config *config = dev->config;
+
+ return config->bus_io == &bme680_bus_io_spi;
+}
+#endif
+
+static inline int bme680_bus_check(const struct device *dev)
+{
+ const struct bme680_config *config = dev->config;
+
+ return config->bus_io->check(&config->bus);
+}
+
+static inline int bme680_reg_read(const struct device *dev,
+ uint8_t start, uint8_t *buf, int size)
+{
+ const struct bme680_config *config = dev->config;
+
+ return config->bus_io->read(dev, start, buf, size);
+}
+
+static inline int bme680_reg_write(const struct device *dev, uint8_t reg,
+ uint8_t val)
+{
+ const struct bme680_config *config = dev->config;
+
+ return config->bus_io->write(dev, reg, val);
+}
+
+static void bme680_calc_temp(struct bme680_data *data, uint32_t adc_temp)
+{
+ int64_t var1, var2, var3;
+
+ var1 = ((int32_t)adc_temp >> 3) - ((int32_t)data->par_t1 << 1);
+ var2 = (var1 * (int32_t)data->par_t2) >> 11;
+ var3 = ((var1 >> 1) * (var1 >> 1)) >> 12;
+ var3 = ((var3) * ((int32_t)data->par_t3 << 4)) >> 14;
+ data->t_fine = var2 + var3;
+ data->calc_temp = ((data->t_fine * 5) + 128) >> 8;
+}
+
+static void bme680_calc_press(struct bme680_data *data, uint32_t adc_press)
+{
+ int32_t var1, var2, var3, calc_press;
+
+ var1 = (((int32_t)data->t_fine) >> 1) - 64000;
+ var2 = ((((var1 >> 2) * (var1 >> 2)) >> 11) *
+ (int32_t)data->par_p6) >> 2;
+ var2 = var2 + ((var1 * (int32_t)data->par_p5) << 1);
+ var2 = (var2 >> 2) + ((int32_t)data->par_p4 << 16);
+ var1 = (((((var1 >> 2) * (var1 >> 2)) >> 13) *
+ ((int32_t)data->par_p3 << 5)) >> 3)
+ + (((int32_t)data->par_p2 * var1) >> 1);
+ var1 = var1 >> 18;
+ var1 = ((32768 + var1) * (int32_t)data->par_p1) >> 15;
+ calc_press = 1048576 - adc_press;
+ calc_press = (calc_press - (var2 >> 12)) * ((uint32_t)3125);
+ /* This max value is used to provide precedence to multiplication or
+ * division in the pressure calculation equation to achieve least
+ * loss of precision and avoiding overflows.
+ * i.e Comparing value, signed int 32bit (1 << 30)
+ */
+ if (calc_press >= (int32_t)0x40000000) {
+ calc_press = ((calc_press / var1) << 1);
+ } else {
+ calc_press = ((calc_press << 1) / var1);
+ }
+ var1 = ((int32_t)data->par_p9 *
+ (int32_t)(((calc_press >> 3)
+ * (calc_press >> 3)) >> 13)) >> 12;
+ var2 = ((int32_t)(calc_press >> 2) * (int32_t)data->par_p8) >> 13;
+ var3 = ((int32_t)(calc_press >> 8) * (int32_t)(calc_press >> 8)
+ * (int32_t)(calc_press >> 8)
+ * (int32_t)data->par_p10) >> 17;
+
+ data->calc_press = calc_press
+ + ((var1 + var2 + var3
+ + ((int32_t)data->par_p7 << 7)) >> 4);
+}
+
+static void bme680_calc_humidity(struct bme680_data *data, uint16_t adc_humidity)
+{
+ int32_t var1, var2_1, var2_2, var2, var3, var4, var5, var6;
+ int32_t temp_scaled, calc_hum;
+
+ temp_scaled = (((int32_t)data->t_fine * 5) + 128) >> 8;
+ var1 = (int32_t)(adc_humidity - ((int32_t)((int32_t)data->par_h1 * 16))) -
+ (((temp_scaled * (int32_t)data->par_h3)
+ / ((int32_t)100)) >> 1);
+ var2_1 = (int32_t)data->par_h2;
+ var2_2 = ((temp_scaled * (int32_t)data->par_h4) / (int32_t)100)
+ + (((temp_scaled * ((temp_scaled * (int32_t)data->par_h5)
+ / ((int32_t)100))) >> 6) / ((int32_t)100))
+ + (int32_t)(1 << 14);
+ var2 = (var2_1 * var2_2) >> 10;
+ var3 = var1 * var2;
+ var4 = (int32_t)data->par_h6 << 7;
+ var4 = ((var4) + ((temp_scaled * (int32_t)data->par_h7) /
+ ((int32_t)100))) >> 4;
+ var5 = ((var3 >> 14) * (var3 >> 14)) >> 10;
+ var6 = (var4 * var5) >> 1;
+ calc_hum = (((var3 + var6) >> 10) * ((int32_t)1000)) >> 12;
+
+ if (calc_hum > 100000) { /* Cap at 100%rH */
+ calc_hum = 100000;
+ } else if (calc_hum < 0) {
+ calc_hum = 0;
+ }
+
+ data->calc_humidity = calc_hum;
+}
+
+static void bme680_calc_gas_resistance(struct bme680_data *data, uint8_t gas_range,
+ uint16_t adc_gas_res)
+{
+ int64_t var1, var3;
+ uint64_t var2;
+
+ static const uint32_t look_up1[16] = { 2147483647, 2147483647, 2147483647,
+ 2147483647, 2147483647, 2126008810, 2147483647,
+ 2130303777, 2147483647, 2147483647, 2143188679,
+ 2136746228, 2147483647, 2126008810, 2147483647,
+ 2147483647 };
+
+ static const uint32_t look_up2[16] = { 4096000000, 2048000000, 1024000000,
+ 512000000, 255744255, 127110228, 64000000,
+ 32258064, 16016016, 8000000, 4000000, 2000000,
+ 1000000, 500000, 250000, 125000 };
+
+ var1 = (int64_t)((1340 + (5 * (int64_t)data->range_sw_err)) *
+ ((int64_t)look_up1[gas_range])) >> 16;
+ var2 = (((int64_t)((int64_t)adc_gas_res << 15) - (int64_t)(16777216)) + var1);
+ var3 = (((int64_t)look_up2[gas_range] * (int64_t)var1) >> 9);
+ data->calc_gas_resistance = (uint32_t)((var3 + ((int64_t)var2 >> 1))
+ / (int64_t)var2);
+}
+
+static uint8_t bme680_calc_res_heat(struct bme680_data *data, uint16_t heatr_temp)
+{
+ uint8_t heatr_res;
+ int32_t var1, var2, var3, var4, var5;
+ int32_t heatr_res_x100;
+ int32_t amb_temp = 25; /* Assume ambient temperature to be 25 deg C */
+
+ if (heatr_temp > 400) { /* Cap temperature */
+ heatr_temp = 400;
+ }
+
+ var1 = ((amb_temp * data->par_gh3) / 1000) * 256;
+ var2 = (data->par_gh1 + 784) * (((((data->par_gh2 + 154009)
+ * heatr_temp * 5) / 100)
+ + 3276800) / 10);
+ var3 = var1 + (var2 / 2);
+ var4 = (var3 / (data->res_heat_range + 4));
+ var5 = (131 * data->res_heat_val) + 65536;
+ heatr_res_x100 = ((var4 / var5) - 250) * 34;
+ heatr_res = (heatr_res_x100 + 50) / 100;
+
+ return heatr_res;
+}
+
+static uint8_t bme680_calc_gas_wait(uint16_t dur)
+{
+ uint8_t factor = 0, durval;
+
+ if (dur >= 0xfc0) {
+ durval = 0xff; /* Max duration*/
+ } else {
+ while (dur > 0x3F) {
+ dur = dur / 4;
+ factor += 1;
+ }
+ durval = dur + (factor * 64);
+ }
+
+ return durval;
+}
+
+static int bme680_sample_fetch(const struct device *dev,
+ enum sensor_channel chan)
+{
+ struct bme680_data *data = dev->data;
+ uint8_t buff[BME680_LEN_FIELD] = { 0 };
+ uint8_t gas_range;
+ uint32_t adc_temp, adc_press;
+ uint16_t adc_hum, adc_gas_res;
+ int size = BME680_LEN_FIELD;
+ int ret;
+
+ __ASSERT_NO_MSG(chan == SENSOR_CHAN_ALL);
+
+ ret = bme680_reg_read(dev, BME680_REG_FIELD0, buff, size);
+ if (ret < 0) {
+ return ret;
+ }
+
+ data->new_data = buff[0] & BME680_MSK_NEW_DATA;
+ data->heatr_stab = buff[14] & BME680_MSK_HEATR_STAB;
+
+ adc_press = (uint32_t)(((uint32_t)buff[2] << 12) | ((uint32_t)buff[3] << 4)
+ | ((uint32_t)buff[4] >> 4));
+ adc_temp = (uint32_t)(((uint32_t)buff[5] << 12) | ((uint32_t)buff[6] << 4)
+ | ((uint32_t)buff[7] >> 4));
+ adc_hum = (uint16_t)(((uint32_t)buff[8] << 8) | (uint32_t)buff[9]);
+ adc_gas_res = (uint16_t)((uint32_t)buff[13] << 2 | (((uint32_t)buff[14]) >> 6));
+ gas_range = buff[14] & BME680_MSK_GAS_RANGE;
+
+ if (data->new_data) {
+ bme680_calc_temp(data, adc_temp);
+ bme680_calc_press(data, adc_press);
+ bme680_calc_humidity(data, adc_hum);
+ bme680_calc_gas_resistance(data, gas_range, adc_gas_res);
+ }
+
+ /* Trigger the next measurement */
+ ret = bme680_reg_write(dev, BME680_REG_CTRL_MEAS,
+ BME680_CTRL_MEAS_VAL);
+ if (ret < 0) {
+ return ret;
+ }
+
+ return 0;
+}
+
+static int bme680_channel_get(const struct device *dev,
+ enum sensor_channel chan,
+ struct sensor_value *val)
+{
+ struct bme680_data *data = dev->data;
+
+ switch (chan) {
+ case SENSOR_CHAN_AMBIENT_TEMP:
+ /*
+ * data->calc_temp has a resolution of 0.01 degC.
+ * So 5123 equals 51.23 degC.
+ */
+ val->val1 = data->calc_temp / 100;
+ val->val2 = data->calc_temp % 100 * 10000;
+ break;
+ case SENSOR_CHAN_PRESS:
+ /*
+ * data->calc_press has a resolution of 1 Pa.
+ * So 96321 equals 96.321 kPa.
+ */
+ val->val1 = data->calc_press / 1000;
+ val->val2 = (data->calc_press % 1000) * 1000;
+ break;
+ case SENSOR_CHAN_HUMIDITY:
+ /*
+ * data->calc_humidity has a resolution of 0.001 %RH.
+ * So 46333 equals 46.333 %RH.
+ */
+ val->val1 = data->calc_humidity / 1000;
+ val->val2 = (data->calc_humidity % 1000) * 1000;
+ break;
+ case SENSOR_CHAN_GAS_RES:
+ /*
+ * data->calc_gas_resistance has a resolution of 1 ohm.
+ * So 100000 equals 100000 ohms.
+ */
+ val->val1 = data->calc_gas_resistance;
+ val->val2 = 0;
+ break;
+ default:
+ return -ENOTSUP;
+ }
+
+ return 0;
+}
+
+static int bme680_read_compensation(const struct device *dev)
+{
+ struct bme680_data *data = dev->data;
+ uint8_t buff[BME680_LEN_COEFF_ALL];
+ int err = 0;
+
+ err = bme680_reg_read(dev, BME680_REG_COEFF1, buff, BME680_LEN_COEFF1);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_read(dev, BME680_REG_COEFF2, &buff[BME680_LEN_COEFF1],
+ BME680_LEN_COEFF2);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_read(dev, BME680_REG_COEFF3,
+ &buff[BME680_LEN_COEFF1 + BME680_LEN_COEFF2],
+ BME680_LEN_COEFF3);
+ if (err < 0) {
+ return err;
+ }
+
+ /* Temperature related coefficients */
+ data->par_t1 = (uint16_t)(BME680_CONCAT_BYTES(buff[32], buff[31]));
+ data->par_t2 = (int16_t)(BME680_CONCAT_BYTES(buff[1], buff[0]));
+ data->par_t3 = (uint8_t)(buff[2]);
+
+ /* Pressure related coefficients */
+ data->par_p1 = (uint16_t)(BME680_CONCAT_BYTES(buff[5], buff[4]));
+ data->par_p2 = (int16_t)(BME680_CONCAT_BYTES(buff[7], buff[6]));
+ data->par_p3 = (int8_t)buff[8];
+ data->par_p4 = (int16_t)(BME680_CONCAT_BYTES(buff[11], buff[10]));
+ data->par_p5 = (int16_t)(BME680_CONCAT_BYTES(buff[13], buff[12]));
+ data->par_p6 = (int8_t)(buff[15]);
+ data->par_p7 = (int8_t)(buff[14]);
+ data->par_p8 = (int16_t)(BME680_CONCAT_BYTES(buff[19], buff[18]));
+ data->par_p9 = (int16_t)(BME680_CONCAT_BYTES(buff[21], buff[20]));
+ data->par_p10 = (uint8_t)(buff[22]);
+
+ /* Humidity related coefficients */
+ data->par_h1 = (uint16_t)(((uint16_t)buff[25] << 4) | (buff[24] & 0x0f));
+ data->par_h2 = (uint16_t)(((uint16_t)buff[23] << 4) | ((buff[24]) >> 4));
+ data->par_h3 = (int8_t)buff[26];
+ data->par_h4 = (int8_t)buff[27];
+ data->par_h5 = (int8_t)buff[28];
+ data->par_h6 = (uint8_t)buff[29];
+ data->par_h7 = (int8_t)buff[30];
+
+ /* Gas heater related coefficients */
+ data->par_gh1 = (int8_t)buff[35];
+ data->par_gh2 = (int16_t)(BME680_CONCAT_BYTES(buff[34], buff[33]));
+ data->par_gh3 = (int8_t)buff[36];
+
+ data->res_heat_val = (int8_t)buff[37];
+ data->res_heat_range = ((buff[39] & BME680_MSK_RH_RANGE) >> 4);
+ data->range_sw_err = ((int8_t)(buff[41] & BME680_MSK_RANGE_SW_ERR)) / 16;
+
+ return 0;
+}
+
+static int bme680_init(const struct device *dev)
+{
+ struct bme680_data *data = dev->data;
+ int err;
+
+ err = bme680_bus_check(dev);
+ if (err < 0) {
+ LOG_ERR("Bus not ready for '%s'", dev->name);
+ return err;
+ }
+
+#if BME680_BUS_SPI
+ if (bme680_is_on_spi(dev)) {
+ uint8_t mem_page;
+
+ err = bme680_reg_read(dev, BME680_REG_STATUS, &mem_page, 1);
+ if (err < 0) {
+ return err;
+ }
+
+ data->mem_page = (mem_page & BME680_SPI_MEM_PAGE_MSK) >> BME680_SPI_MEM_PAGE_POS;
+ }
+#endif
+
+ err = bme680_reg_read(dev, BME680_REG_CHIP_ID, &data->chip_id, 1);
+ if (err < 0) {
+ return err;
+ }
+
+ if (data->chip_id == BME680_CHIP_ID) {
+ LOG_DBG("BME680 chip detected");
+ } else {
+ LOG_ERR("Bad BME680 chip id: 0x%x", data->chip_id);
+ return -ENOTSUP;
+ }
+
+ err = bme680_read_compensation(dev);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_CTRL_HUM, BME680_HUMIDITY_OVER);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_CONFIG, BME680_CONFIG_VAL);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_CTRL_GAS_1,
+ BME680_CTRL_GAS_1_VAL);
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_RES_HEAT0,
+ bme680_calc_res_heat(data, BME680_HEATR_TEMP));
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_GAS_WAIT0,
+ bme680_calc_gas_wait(BME680_HEATR_DUR_MS));
+ if (err < 0) {
+ return err;
+ }
+
+ err = bme680_reg_write(dev, BME680_REG_CTRL_MEAS,
+ BME680_CTRL_MEAS_VAL);
+
+ return err;
+}
+
+static const struct sensor_driver_api bme680_api_funcs = {
+ .sample_fetch = bme680_sample_fetch,
+ .channel_get = bme680_channel_get,
+};
+
+/* Initializes a struct bme680_config for an instance on a SPI bus. */
+#define BME680_CONFIG_SPI(inst) \
+ { \
+ .bus.spi = SPI_DT_SPEC_INST_GET( \
+ inst, BME680_SPI_OPERATION, 0), \
+ .bus_io = &bme680_bus_io_spi, \
+ }
+
+/* Initializes a struct bme680_config for an instance on an I2C bus. */
+#define BME680_CONFIG_I2C(inst) \
+ { \
+ .bus.i2c = I2C_DT_SPEC_INST_GET(inst), \
+ .bus_io = &bme680_bus_io_i2c, \
+ }
+
+/*
+ * Main instantiation macro, which selects the correct bus-specific
+ * instantiation macros for the instance.
+ */
+#define BME680_DEFINE(inst) \
+ static struct bme680_data bme680_data_##inst; \
+ static const struct bme680_config bme680_config_##inst = \
+ COND_CODE_1(DT_INST_ON_BUS(inst, spi), \
+ (BME680_CONFIG_SPI(inst)), \
+ (BME680_CONFIG_I2C(inst))); \
+ SENSOR_DEVICE_DT_INST_DEFINE(inst, \
+ bme680_init, \
+ NULL, \
+ &bme680_data_##inst, \
+ &bme680_config_##inst, \
+ POST_KERNEL, \
+ CONFIG_SENSOR_INIT_PRIORITY, \
+ &bme680_api_funcs);
+
+/* Create the struct device for every status "okay" node in the devicetree. */
+DT_INST_FOREACH_STATUS_OKAY(BME680_DEFINE)
diff --git a/nrfdemo/src/bme680/bme680.h b/nrfdemo/src/bme680/bme680.h
new file mode 100644
index 0000000..125aea1
--- /dev/null
+++ b/nrfdemo/src/bme680/bme680.h
@@ -0,0 +1,220 @@
+/*
+ * Copyright (c) 2018 Bosch Sensortec GmbH
+ * Copyright (c) 2022, Leonard Pollak
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+#ifndef __ZEPHYR_DRIVERS_SENSOR_BME680_H__
+#define __ZEPHYR_DRIVERS_SENSOR_BME680_H__
+
+#include <zephyr/types.h>
+#include <zephyr/device.h>
+#include <zephyr/devicetree.h>
+#include <zephyr/drivers/spi.h>
+#include <zephyr/drivers/i2c.h>
+
+#define DT_DRV_COMPAT bosch_bme680
+
+#define BME680_BUS_SPI DT_ANY_INST_ON_BUS_STATUS_OKAY(spi)
+#define BME680_BUS_I2C DT_ANY_INST_ON_BUS_STATUS_OKAY(i2c)
+
+union bme680_bus {
+#if BME680_BUS_SPI
+ struct spi_dt_spec spi;
+#endif
+#if BME680_BUS_I2C
+ struct i2c_dt_spec i2c;
+#endif
+};
+
+typedef int (*bme680_bus_check_fn)(const union bme680_bus *bus);
+typedef int (*bme680_reg_read_fn)(const struct device *dev,
+ uint8_t start, uint8_t *buf, int size);
+typedef int (*bme680_reg_write_fn)(const struct device *dev,
+ uint8_t reg, uint8_t val);
+
+struct bme680_bus_io {
+ bme680_bus_check_fn check;
+ bme680_reg_read_fn read;
+ bme680_reg_write_fn write;
+};
+
+#if BME680_BUS_SPI
+#define BME680_SPI_OPERATION (SPI_WORD_SET(8) | SPI_TRANSFER_MSB | SPI_MODE_CPOL \
+ | SPI_MODE_CPHA | SPI_OP_MODE_MASTER)
+extern const struct bme680_bus_io bme680_bus_io_spi;
+#endif
+
+#if BME680_BUS_I2C
+extern const struct bme680_bus_io bme680_bus_io_i2c;
+#endif
+
+struct bme680_config {
+ union bme680_bus bus;
+ const struct bme680_bus_io *bus_io;
+};
+
+#define BME680_CHIP_ID 0x61
+
+#define BME680_LEN_FIELD 15
+#define BME680_LEN_COEFF_ALL 42
+#define BME680_LEN_COEFF1 23
+#define BME680_LEN_COEFF2 14
+#define BME680_LEN_COEFF3 5
+
+#define BME680_REG_COEFF3 0x00
+#define BME680_REG_FIELD0 0x1d
+#define BME680_REG_IDAC_HEAT0 0x50
+#define BME680_REG_RES_HEAT0 0x5A
+#define BME680_REG_GAS_WAIT0 0x64
+#define BME680_REG_SHD_HEATR_DUR 0x6E
+#define BME680_REG_CTRL_GAS_0 0x70
+#define BME680_REG_CTRL_GAS_1 0x71
+#define BME680_REG_CTRL_HUM 0x72
+#define BME680_REG_CTRL_MEAS 0x74
+#define BME680_REG_CONFIG 0x75
+#define BME680_REG_STATUS 0x73
+#define BME680_REG_UNIQUE_ID 0x83
+#define BME680_REG_COEFF1 0x8a
+#define BME680_REG_COEFF2 0xe1
+#define BME680_REG_CHIP_ID 0xd0
+#define BME680_REG_SOFT_RESET 0xe0
+
+#define BME680_MSK_NEW_DATA 0x80
+#define BME680_MSK_GAS_RANGE 0x0f
+#define BME680_MSK_RH_RANGE 0x30
+#define BME680_MSK_RANGE_SW_ERR 0xf0
+#define BME680_MSK_HEATR_STAB 0x10
+
+#define BME680_SPI_MEM_PAGE_MSK 0x10
+#define BME680_SPI_MEM_PAGE_POS 4
+#define BME680_SPI_READ_BIT 0x80
+#define BME680_SPI_WRITE_MSK 0x7f
+
+#if defined CONFIG_BME680_TEMP_OVER_1X
+#define BME680_TEMP_OVER (1 << 5)
+#elif defined CONFIG_BME680_TEMP_OVER_2X
+#define BME680_TEMP_OVER (2 << 5)
+#elif defined CONFIG_BME680_TEMP_OVER_4X
+#define BME680_TEMP_OVER (3 << 5)
+#elif defined CONFIG_BME680_TEMP_OVER_8X
+#define BME680_TEMP_OVER (4 << 5)
+#elif defined CONFIG_BME680_TEMP_OVER_16X
+#define BME680_TEMP_OVER (5 << 5)
+#endif
+
+#if defined CONFIG_BME680_PRESS_OVER_1X
+#define BME680_PRESS_OVER (1 << 2)
+#elif defined CONFIG_BME680_PRESS_OVER_2X
+#define BME680_PRESS_OVER (2 << 2)
+#elif defined CONFIG_BME680_PRESS_OVER_4X
+#define BME680_PRESS_OVER (3 << 2)
+#elif defined CONFIG_BME680_PRESS_OVER_8X
+#define BME680_PRESS_OVER (4 << 2)
+#elif defined CONFIG_BME680_PRESS_OVER_16X
+#define BME680_PRESS_OVER (5 << 2)
+#endif
+
+#if defined CONFIG_BME680_HUMIDITY_OVER_1X
+#define BME680_HUMIDITY_OVER 1
+#elif defined CONFIG_BME680_HUMIDITY_OVER_2X
+#define BME680_HUMIDITY_OVER 2
+#elif defined CONFIG_BME680_HUMIDITY_OVER_4X
+#define BME680_HUMIDITY_OVER 3
+#elif defined CONFIG_BME680_HUMIDITY_OVER_8X
+#define BME680_HUMIDITY_OVER 4
+#elif defined CONFIG_BME680_HUMIDITY_OVER_16X
+#define BME680_HUMIDITY_OVER 5
+#endif
+
+#if defined CONFIG_BME680_HEATR_TEMP_LP
+#define BME680_HEATR_TEMP 320
+#elif defined CONFIG_BME680_HEATR_TEMP_ULP
+#define BME680_HEATR_TEMP 400
+#endif
+
+#if defined CONFIG_BME680_HEATR_DUR_LP
+#define BME680_HEATR_DUR_MS 197
+#elif defined CONFIG_BME680_HEATR_DUR_ULP
+#define BME680_HEATR_DUR_MS 1943
+#endif
+
+#if defined CONFIG_BME680_FILTER_OFF
+#define BME680_FILTER 0
+#elif defined CONFIG_BME680_FILTER_2
+#define BME680_FILTER (1 << 2)
+#elif defined CONFIG_BME680_FILTER_4
+#define BME680_FILTER (2 << 2)
+#elif defined CONFIG_BME680_FILTER_8
+#define BME680_FILTER (3 << 2)
+#elif defined CONFIG_BME680_FILTER_16
+#define BME680_FILTER (4 << 2)
+#elif defined CONFIG_BME680_FILTER_32
+#define BME680_FILTER (5 << 2)
+#elif defined CONFIG_BME680_FILTER_64
+#define BME680_FILTER (6 << 2)
+#elif defined CONFIG_BME680_FILTER_128
+#define BME680_FILTER (7 << 2)
+#endif
+
+#define BME680_MODE_SLEEP 0
+#define BME680_MODE_FORCED 1
+
+#define BME680_CTRL_MEAS_VAL (BME680_PRESS_OVER | BME680_TEMP_OVER \
+ | BME680_MODE_FORCED)
+#define BME680_CONFIG_VAL BME680_FILTER
+#define BME680_CTRL_GAS_1_VAL 0x10
+
+#define BME680_CONCAT_BYTES(msb, lsb) (((uint16_t)msb << 8) | (uint16_t)lsb)
+
+struct bme680_data {
+ /* Compensation parameters. */
+ uint16_t par_h1;
+ uint16_t par_h2;
+ int8_t par_h3;
+ int8_t par_h4;
+ int8_t par_h5;
+ uint8_t par_h6;
+ int8_t par_h7;
+ int8_t par_gh1;
+ int16_t par_gh2;
+ int8_t par_gh3;
+ uint16_t par_t1;
+ int16_t par_t2;
+ int8_t par_t3;
+ uint16_t par_p1;
+ int16_t par_p2;
+ int8_t par_p3;
+ int16_t par_p4;
+ int16_t par_p5;
+ int8_t par_p6;
+ int8_t par_p7;
+ int16_t par_p8;
+ int16_t par_p9;
+ uint8_t par_p10;
+ uint8_t res_heat_range;
+ int8_t res_heat_val;
+ int8_t range_sw_err;
+
+ /* Calculated sensor values. */
+ int32_t calc_temp;
+ uint32_t calc_press;
+ uint32_t calc_humidity;
+ uint32_t calc_gas_resistance;
+
+ /* Additional information */
+ uint8_t new_data;
+ uint8_t heatr_stab;
+
+ /* Carryover between temperature and pressure/humidity compensation. */
+ int32_t t_fine;
+
+ uint8_t chip_id;
+
+#if BME680_BUS_SPI
+ uint8_t mem_page;
+#endif
+};
+
+#endif /* __ZEPHYR_DRIVERS_SENSOR_BME680_H__ */
diff --git a/nrfdemo/src/bme680/bme680_i2c.c b/nrfdemo/src/bme680/bme680_i2c.c
new file mode 100644
index 0000000..faa8cea
--- /dev/null
+++ b/nrfdemo/src/bme680/bme680_i2c.c
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2016, 2017 Intel Corporation
+ * Copyright (c) 2017 IpTronix S.r.l.
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ * Copyright (c) 2022, Leonard Pollak
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Bus-specific functionality for BME680s accessed via I2C.
+ */
+
+#include "bme680.h"
+
+#if BME680_BUS_I2C
+static int bme680_bus_check_i2c(const union bme680_bus *bus)
+{
+ return device_is_ready(bus->i2c.bus) ? 0 : -ENODEV;
+}
+
+static int bme680_reg_read_i2c(const struct device *dev,
+ uint8_t start, uint8_t *buf, int size)
+{
+ const struct bme680_config *config = dev->config;
+
+ return i2c_burst_read_dt(&config->bus.i2c, start, buf, size);
+}
+
+static int bme680_reg_write_i2c(const struct device *dev,
+ uint8_t reg, uint8_t val)
+{
+ const struct bme680_config *config = dev->config;
+
+ return i2c_reg_write_byte_dt(&config->bus.i2c, reg, val);
+}
+
+const struct bme680_bus_io bme680_bus_io_i2c = {
+ .check = bme680_bus_check_i2c,
+ .read = bme680_reg_read_i2c,
+ .write = bme680_reg_write_i2c,
+};
+#endif /* BME680_BUS_I2C */
diff --git a/nrfdemo/src/bme680/bme680_spi.c b/nrfdemo/src/bme680/bme680_spi.c
new file mode 100644
index 0000000..54840a7
--- /dev/null
+++ b/nrfdemo/src/bme680/bme680_spi.c
@@ -0,0 +1,146 @@
+/*
+ * Copyright (c) 2016, 2017 Intel Corporation
+ * Copyright (c) 2017 IpTronix S.r.l.
+ * Copyright (c) 2021 Nordic Semiconductor ASA
+ * Copyright (c) 2022, Leonard Pollak
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/*
+ * Bus-specific functionality for BME680s accessed via SPI.
+ */
+
+#include <zephyr/logging/log.h>
+#include "bme680.h"
+
+#if BME680_BUS_SPI
+
+LOG_MODULE_DECLARE(bme680, CONFIG_SENSOR_LOG_LEVEL);
+
+static int bme680_bus_check_spi(const union bme680_bus *bus)
+{
+ return spi_is_ready_dt(&bus->spi) ? 0 : -ENODEV;
+}
+
+static inline int bme680_set_mem_page(const struct device *dev, uint8_t addr)
+{
+ const struct bme680_config *config = dev->config;
+ struct bme680_data *data = dev->data;
+ uint8_t page = (addr > 0x7f) ? 0U : 1U;
+ int err = 0;
+
+ if (data->mem_page != page) {
+ uint8_t buf[2];
+
+ struct spi_buf tx_buf = {
+ .buf = &buf[0],
+ .len = 1,
+ };
+ const struct spi_buf_set tx = {
+ .buffers = &tx_buf,
+ .count = 1,
+ };
+
+ const struct spi_buf rx_buf[] = {
+ { .buf = NULL, .len = 1 },
+ { .buf = &buf[1], .len = 1 },
+ };
+ const struct spi_buf_set rx = {
+ .buffers = rx_buf,
+ .count = ARRAY_SIZE(rx_buf),
+ };
+
+ buf[0] = BME680_REG_STATUS | BME680_SPI_READ_BIT;
+ err = spi_transceive_dt(&config->bus.spi, &tx, &rx);
+ if (err < 0) {
+ return err;
+ }
+
+ if (data->mem_page == 1U) {
+ buf[1] &= ~BME680_SPI_MEM_PAGE_MSK;
+ } else {
+ buf[1] |= BME680_SPI_MEM_PAGE_MSK;
+ }
+
+ buf[0] = BME680_REG_STATUS & BME680_SPI_WRITE_MSK;
+ tx_buf.len = 2;
+ err = spi_write_dt(&config->bus.spi, &tx);
+ if (err < 0) {
+ return err;
+ }
+
+ data->mem_page = page;
+ }
+
+ return err;
+}
+
+static int bme680_reg_write_spi(const struct device *dev,
+ uint8_t reg, uint8_t val)
+{
+ const struct bme680_config *config = dev->config;
+ int err;
+ uint8_t cmd[] = { reg & BME680_SPI_WRITE_MSK, val };
+ const struct spi_buf tx_buf = {
+ .buf = cmd,
+ .len = sizeof(cmd)
+ };
+ const struct spi_buf_set tx = {
+ .buffers = &tx_buf,
+ .count = 1
+ };
+
+ err = bme680_set_mem_page(dev, reg);
+ if (err) {
+ return err;
+ }
+
+ err = spi_write_dt(&config->bus.spi, &tx);
+
+ return err;
+}
+
+static int bme680_reg_read_spi(const struct device *dev,
+ uint8_t start, uint8_t *buf, int size)
+{
+ const struct bme680_config *config = dev->config;
+ int err;
+ uint8_t addr;
+ const struct spi_buf tx_buf = {
+ .buf = &addr,
+ .len = 1
+ };
+ const struct spi_buf_set tx = {
+ .buffers = &tx_buf,
+ .count = 1
+ };
+ struct spi_buf rx_buf[2];
+ const struct spi_buf_set rx = {
+ .buffers = rx_buf,
+ .count = ARRAY_SIZE(rx_buf)
+ };
+
+ rx_buf[0].buf = NULL;
+ rx_buf[0].len = 1;
+
+ addr = start | BME680_SPI_READ_BIT;
+ rx_buf[1].buf = buf;
+ rx_buf[1].len = size;
+
+ err = bme680_set_mem_page(dev, start);
+ if (err) {
+ return err;
+ }
+
+ err = spi_transceive_dt(&config->bus.spi, &tx, &rx);
+
+ return err;
+}
+
+const struct bme680_bus_io bme680_bus_io_spi = {
+ .check = bme680_bus_check_spi,
+ .read = bme680_reg_read_spi,
+ .write = bme680_reg_write_spi,
+};
+#endif /* BME680_BUS_SPI */
diff --git a/nrfdemo/src/main.c b/nrfdemo/src/main.c
new file mode 100644
index 0000000..770b178
--- /dev/null
+++ b/nrfdemo/src/main.c
@@ -0,0 +1,296 @@
+/*
+ * Copyright (c) 2018 Nordic Semiconductor ASA
+ * Copyright (c) 2024 Conexio Technologies, Inc
+ *
+ * SPDX-License-Identifier: LicenseRef-Nordic-5-Clause
+ */
+
+#include <stdio.h>
+#include <ncs_version.h>
+#include <zephyr/kernel.h>
+#include <zephyr/net/socket.h>
+
+#include <zephyr/logging/log.h>
+#include <dk_buttons_and_leds.h>
+#include <modem/nrf_modem_lib.h>
+#include <modem/lte_lc.h>
+/* Header file for the MQTT Library*/
+#include <zephyr/net/mqtt.h>
+#include <nrf_modem_gnss.h>
+#include "mqtt_connection.h"
+
+#include "bme680/bme680.h"
+
+/* The mqtt client struct */
+static struct mqtt_client client;
+/* File descriptor */
+static struct pollfd fds;
+
+/* Define the PVT data frame variable */
+static struct nrf_modem_gnss_pvt_data_frame pvt_data;
+
+/* Declare helper variables to find the TTFF */
+static int64_t gnss_start_time;
+static bool first_fix = false;
+
+static void gnss_event_handler(int event);
+static void print_fix_data(struct nrf_modem_gnss_pvt_data_frame *pvt_data);
+
+static K_SEM_DEFINE(lte_connected, 0, 1);
+
+LOG_MODULE_REGISTER(mqtt_app, LOG_LEVEL_INF);
+
+static void lte_handler(const struct lte_lc_evt *const evt)
+{
+ switch (evt->type) {
+ case LTE_LC_EVT_NW_REG_STATUS:
+ if ((evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_HOME) &&
+ (evt->nw_reg_status != LTE_LC_NW_REG_REGISTERED_ROAMING)) {
+ break;
+ }
+ LOG_INF("Network registration status: %s",
+ evt->nw_reg_status == LTE_LC_NW_REG_REGISTERED_HOME ?
+ "Connected - home network" : "Connected - roaming");
+ k_sem_give(&lte_connected);
+ break;
+ case LTE_LC_EVT_RRC_UPDATE:
+ LOG_INF("RRC mode: %s", evt->rrc_mode == LTE_LC_RRC_MODE_CONNECTED ?
+ "Connected" : "Idle");
+ break;
+ default:
+ break;
+ }
+}
+
+static int modem_configure(void)
+{
+ int err;
+
+ LOG_INF("Initializing modem library");
+ err = nrf_modem_lib_init();
+ if (err) {
+ LOG_ERR("Failed to initialize the modem library, error: %d", err);
+ return err;
+ }
+
+ LOG_INF("Connecting to LTE network");
+ err = lte_lc_connect_async(lte_handler);
+ if (err) {
+ LOG_ERR("Error in lte_lc_connect_async, error: %d", err);
+ return err;
+ }
+
+ k_sem_take(&lte_connected, K_FOREVER);
+ LOG_INF("Connected to LTE network");
+
+
+ // Blink LED to indicate we connected to MQTT broker
+ dk_set_led_on(DK_LED1);
+ k_msleep(2000);
+ dk_set_led_off(DK_LED1);
+
+ return 0;
+}
+
+static void button_handler(uint32_t button_state, uint32_t has_changed)
+{
+ switch (has_changed) {
+ case DK_BTN1_MSK:
+ /* When button 1/Mode is pressed, call data_publish() to publish a message */
+ if (button_state & DK_BTN1_MSK){
+ int err = data_publish(&client, MQTT_QOS_1_AT_LEAST_ONCE,
+ CONFIG_BUTTON_EVENT_PUBLISH_MSG, sizeof(CONFIG_BUTTON_EVENT_PUBLISH_MSG)-1);
+ if (err) {
+ LOG_INF("Failed to send message, %d", err);
+ return;
+ }
+ }
+ break;
+ }
+}
+
+#if 1
+/* Define a function to log fix data in a readable format */
+static void print_fix_data(struct nrf_modem_gnss_pvt_data_frame *pvt_data)
+{
+ LOG_INF("Latitude: %.06f", pvt_data->latitude);
+ LOG_INF("Longitude: %.06f", pvt_data->longitude);
+ LOG_INF("Altitude: %.01f m", pvt_data->altitude);
+ LOG_INF("Time (UTC): %02u:%02u:%02u.%03u",
+ pvt_data->datetime.hour,
+ pvt_data->datetime.minute,
+ pvt_data->datetime.seconds,
+ pvt_data->datetime.ms);
+}
+
+
+static void gnss_event_handler(int event)
+{
+ int err;
+
+ switch (event) {
+ /* On a PVT event, confirm if PVT data is a valid fix */
+ case NRF_MODEM_GNSS_EVT_PVT:
+ LOG_INF("Searching...");
+ /* Print satellite information */
+ int num_satellites = 0;
+ for (int i = 0; i < 12 ; i++) {
+ if (pvt_data.sv[i].signal != 0) {
+ LOG_INF("sv: %d, cn0: %d", pvt_data.sv[i].sv, pvt_data.sv[i].cn0);
+ num_satellites++;
+ }
+ }
+ LOG_INF("Number of current satellites: %d", num_satellites);
+ err = nrf_modem_gnss_read(&pvt_data, sizeof(pvt_data), NRF_MODEM_GNSS_DATA_PVT);
+ if (err) {
+ LOG_ERR("nrf_modem_gnss_read failed, err %d", err);
+ return;
+ }
+ if (pvt_data.flags & NRF_MODEM_GNSS_PVT_FLAG_FIX_VALID) {
+ dk_set_led_on(DK_LED1);
+ print_fix_data(&pvt_data);
+ /* Print the time to first fix */
+ if (!first_fix) {
+ LOG_INF("Time to first fix: %2.1lld s", (k_uptime_get() - gnss_start_time)/1000);
+ first_fix = true;
+ }
+ return;
+ }
+ break;
+ /* Log when the GNSS sleeps and wakes up */
+ case NRF_MODEM_GNSS_EVT_PERIODIC_WAKEUP:
+ LOG_INF("GNSS has woken up");
+ break;
+ case NRF_MODEM_GNSS_EVT_SLEEP_AFTER_FIX:
+ LOG_INF("GNSS enter sleep after fix");
+ break;
+ default:
+ break;
+ }
+}
+#endif
+
+int main(void)
+{
+ int err;
+ uint32_t connect_attempt = 0;
+
+ LOG_INF("Starting MQTT sample on %s\n", CONFIG_BOARD);
+
+ if (dk_leds_init() != 0) {
+ LOG_ERR("Failed to initialize the LED library");
+ }
+
+ err = modem_configure();
+ if (err) {
+ LOG_ERR("Failed to configure the modem");
+ return 0;
+ }
+
+ if (dk_buttons_init(button_handler) != 0) {
+ LOG_ERR("Failed to initialize the buttons library");
+ }
+
+
+ /* Activate only the GNSS stack */
+ if (lte_lc_func_mode_set(LTE_LC_FUNC_MODE_ACTIVATE_GNSS) != 0) {
+ LOG_ERR("Failed to activate GNSS functional mode");
+ return 0;
+ }
+
+ /* Register the GNSS event handler */
+ if (nrf_modem_gnss_event_handler_set(gnss_event_handler) != 0) {
+ LOG_ERR("Failed to set GNSS event handler");
+ return 0;
+ }
+
+ /* Set the GNSS fix interval and GNSS fix retry period */
+ if (nrf_modem_gnss_fix_interval_set(1) != 0) {
+ LOG_ERR("Failed to set GNSS fix interval");
+ return 0;
+ }
+
+ if (nrf_modem_gnss_fix_retry_set(60) != 0) {
+ LOG_ERR("Failed to set GNSS fix retry");
+ return 0;
+ }
+
+ /* Start the GNSS receiver */
+ LOG_INF("Starting GNSS");
+ if (nrf_modem_gnss_start() != 0) {
+ LOG_ERR("Failed to start GNSS");
+ return 0;
+ }
+
+ err = client_init(&client);
+ if (err) {
+ LOG_ERR("Failed to initialize MQTT client: %d", err);
+ return 0;
+ }
+
+ /* Log the current system uptime */
+ gnss_start_time = k_uptime_get();
+
+do_connect:
+ if (connect_attempt++ > 0) {
+ LOG_INF("Reconnecting in %d seconds...",
+ CONFIG_MQTT_RECONNECT_DELAY_S);
+ k_sleep(K_SECONDS(CONFIG_MQTT_RECONNECT_DELAY_S));
+ }
+
+ LOG_INF("Connection to broker using mqtt_connect");
+ err = mqtt_connect(&client);
+ if (err) {
+ LOG_ERR("Error in mqtt_connect: %d", err);
+ goto do_connect;
+ }
+
+ err = fds_init(&client,&fds);
+ if (err) {
+ LOG_ERR("Error in fds_init: %d", err);
+ return 0;
+ }
+
+ while (1) {
+ err = poll(&fds, 1, mqtt_keepalive_time_left(&client));
+ if (err < 0) {
+ LOG_ERR("Error in poll(): %d", errno);
+ break;
+ }
+
+ err = mqtt_live(&client);
+ if ((err != 0) && (err != -EAGAIN)) {
+ LOG_ERR("Error in mqtt_live: %d", err);
+ break;
+ }
+
+ if ((fds.revents & POLLIN) == POLLIN) {
+ err = mqtt_input(&client);
+ if (err != 0) {
+ LOG_ERR("Error in mqtt_input: %d", err);
+ break;
+ }
+ }
+
+ if ((fds.revents & POLLERR) == POLLERR) {
+ LOG_ERR("POLLERR");
+ break;
+ }
+
+ if ((fds.revents & POLLNVAL) == POLLNVAL) {
+ LOG_ERR("POLLNVAL");
+ break;
+ }
+ }
+
+ LOG_INF("Disconnecting MQTT client");
+
+ err = mqtt_disconnect(&client);
+ if (err) {
+ LOG_ERR("Could not disconnect MQTT client: %d", err);
+ }
+ goto do_connect;
+
+ /* This is never reached */
+ return 0;
+}
diff --git a/nrfdemo/src/mqtt_connection.c b/nrfdemo/src/mqtt_connection.c
new file mode 100644
index 0000000..ef4e69f
--- /dev/null
+++ b/nrfdemo/src/mqtt_connection.c
@@ -0,0 +1,365 @@
+#include <stdio.h>
+#include <string.h>
+#include <ncs_version.h>
+
+#include <zephyr/logging/log.h>
+#include <zephyr/kernel.h>
+#include <zephyr/net/socket.h>
+#include <zephyr/net/mqtt.h>
+#include <nrf_modem_at.h>
+
+#include <dk_buttons_and_leds.h>
+#include "mqtt_connection.h"
+
+#if NCS_VERSION_NUMBER < 0x20600
+#include <zephyr/random/rand32.h>
+#else
+#include <zephyr/random/random.h>
+#endif
+
+/* Buffers for MQTT client. */
+static uint8_t rx_buffer[CONFIG_MQTT_MESSAGE_BUFFER_SIZE];
+static uint8_t tx_buffer[CONFIG_MQTT_MESSAGE_BUFFER_SIZE];
+static uint8_t payload_buf[CONFIG_MQTT_PAYLOAD_BUFFER_SIZE];
+
+/* MQTT Broker details. */
+static struct sockaddr_storage broker;
+
+LOG_MODULE_DECLARE(mqtt_app);
+
+/**@brief Function to get the payload of recived data.
+ */
+static int get_received_payload(struct mqtt_client *c, size_t length)
+{
+ int ret;
+ int err = 0;
+
+ /* Return an error if the payload is larger than the payload buffer.
+ * Note: To allow new messages, we have to read the payload before returning.
+ */
+ if (length > sizeof(payload_buf)) {
+ err = -EMSGSIZE;
+ }
+
+ /* Truncate payload until it fits in the payload buffer. */
+ while (length > sizeof(payload_buf)) {
+ ret = mqtt_read_publish_payload_blocking(
+ c, payload_buf, (length - sizeof(payload_buf)));
+ if (ret == 0) {
+ return -EIO;
+ } else if (ret < 0) {
+ return ret;
+ }
+
+ length -= ret;
+ }
+
+ ret = mqtt_readall_publish_payload(c, payload_buf, length);
+ if (ret) {
+ return ret;
+ }
+
+ return err;
+}
+
+/**@brief Function to subscribe to the configured topic
+ */
+/* Define the function subscribe() to subscribe to a specific topic. */
+static int subscribe(struct mqtt_client *const c)
+{
+ struct mqtt_topic subscribe_topic = {
+ .topic = {
+ .utf8 = CONFIG_MQTT_SUB_TOPIC,
+ .size = strlen(CONFIG_MQTT_SUB_TOPIC)
+ },
+ .qos = MQTT_QOS_1_AT_LEAST_ONCE
+ };
+
+ const struct mqtt_subscription_list subscription_list = {
+ .list = &subscribe_topic,
+ .list_count = 1,
+ .message_id = 1234
+ };
+
+ LOG_INF("Subscribing to: %s len %u", CONFIG_MQTT_SUB_TOPIC,
+ (unsigned int)strlen(CONFIG_MQTT_SUB_TOPIC));
+
+ return mqtt_subscribe(c, &subscription_list);
+}
+
+/**@brief Function to print strings without null-termination
+ */
+static void data_print(uint8_t *prefix, uint8_t *data, size_t len)
+{
+ char buf[len + 1];
+
+ memcpy(buf, data, len);
+ buf[len] = 0;
+ LOG_INF("%s%s", (char *)prefix, (char *)buf);
+}
+
+/**@brief Function to publish data on the configured topic
+ */
+/* Define the function data_publish() to publish data */
+int data_publish(struct mqtt_client *c, enum mqtt_qos qos,
+ uint8_t *data, size_t len)
+{
+ struct mqtt_publish_param param;
+
+ param.message.topic.qos = qos;
+ param.message.topic.topic.utf8 = CONFIG_MQTT_PUB_TOPIC;
+ param.message.topic.topic.size = strlen(CONFIG_MQTT_PUB_TOPIC);
+ param.message.payload.data = data;
+ param.message.payload.len = len;
+ param.message_id = sys_rand32_get();
+ param.dup_flag = 0;
+ param.retain_flag = 0;
+
+ data_print("Publishing: ", data, len);
+ LOG_INF("to topic: %s len: %u",
+ CONFIG_MQTT_PUB_TOPIC,
+ (unsigned int)strlen(CONFIG_MQTT_PUB_TOPIC));
+
+ return mqtt_publish(c, &param);
+}
+/**@brief MQTT client event handler
+ */
+void mqtt_evt_handler(struct mqtt_client *const c,
+ const struct mqtt_evt *evt)
+{
+ int err;
+
+ switch (evt->type) {
+ case MQTT_EVT_CONNACK:
+ /* Subscribe to the topic CONFIG_MQTT_SUB_TOPIC when we have a successful connection */
+ if (evt->result != 0) {
+ LOG_ERR("MQTT connect failed: %d", evt->result);
+ break;
+ }
+
+ LOG_INF("MQTT client connected");
+ subscribe(c);
+ break;
+
+ case MQTT_EVT_DISCONNECT:
+ LOG_INF("MQTT client disconnected: %d", evt->result);
+ break;
+
+ case MQTT_EVT_PUBLISH:
+ /* Listen to published messages received from the broker and extract the message */
+ {
+ /* Extract the payload */
+ const struct mqtt_publish_param *p = &evt->param.publish;
+ //Print the length of the recived message
+ LOG_INF("MQTT PUBLISH result=%d len=%d",
+ evt->result, p->message.payload.len);
+
+ //Extract the data of the recived message
+ err = get_received_payload(c, p->message.payload.len);
+
+ //Send acknowledgment to the broker on receiving QoS1 publish message
+ if (p->message.topic.qos == MQTT_QOS_1_AT_LEAST_ONCE) {
+ const struct mqtt_puback_param ack = {
+ .message_id = p->message_id
+ };
+
+ /* Send acknowledgment. */
+ mqtt_publish_qos1_ack(c, &ack);
+ }
+
+ /* On successful extraction of data */
+ if (err >= 0) {
+ data_print("Received: ", payload_buf, p->message.payload.len);
+ // Control the LED
+ if(strncmp(payload_buf,CONFIG_TURN_LED_ON_CMD,sizeof(CONFIG_TURN_LED_ON_CMD)-1) == 0){
+ dk_set_led_on(LED_CONTROL_OVER_MQTT);
+ }
+ else if(strncmp(payload_buf,CONFIG_TURN_LED_OFF_CMD,sizeof(CONFIG_TURN_LED_OFF_CMD)-1) == 0){
+ dk_set_led_off(LED_CONTROL_OVER_MQTT);
+ }
+ /* On failed extraction of data */
+ // Payload buffer is smaller than the received data
+ } else if (err == -EMSGSIZE) {
+ LOG_ERR("Received payload (%d bytes) is larger than the payload buffer size (%d bytes).",
+ p->message.payload.len, sizeof(payload_buf));
+ // Failed to extract data, disconnect
+ } else {
+ LOG_ERR("get_received_payload failed: %d", err);
+ LOG_INF("Disconnecting MQTT client...");
+
+ err = mqtt_disconnect(c);
+ if (err) {
+ LOG_ERR("Could not disconnect: %d", err);
+ }
+ }
+ } break;
+
+ case MQTT_EVT_PUBACK:
+ if (evt->result != 0) {
+ LOG_ERR("MQTT PUBACK error: %d", evt->result);
+ break;
+ }
+
+ LOG_INF("PUBACK packet id: %u", evt->param.puback.message_id);
+ break;
+
+ case MQTT_EVT_SUBACK:
+ if (evt->result != 0) {
+ LOG_ERR("MQTT SUBACK error: %d", evt->result);
+ break;
+ }
+
+ LOG_INF("SUBACK packet id: %u", evt->param.suback.message_id);
+ break;
+
+ case MQTT_EVT_PINGRESP:
+ if (evt->result != 0) {
+ LOG_ERR("MQTT PINGRESP error: %d", evt->result);
+ }
+ break;
+
+ default:
+ LOG_INF("Unhandled MQTT event type: %d", evt->type);
+ break;
+ }
+}
+
+/**@brief Resolves the configured hostname and
+ * initializes the MQTT broker structure
+ */
+static int broker_init(void)
+{
+ int err;
+ struct addrinfo *result;
+ struct addrinfo *addr;
+ struct addrinfo hints = {
+ .ai_family = AF_INET,
+ .ai_socktype = SOCK_STREAM
+ };
+
+ err = getaddrinfo(CONFIG_MQTT_BROKER_HOSTNAME, NULL, &hints, &result);
+ if (err) {
+ LOG_ERR("getaddrinfo failed: %d", err);
+ return -ECHILD;
+ }
+
+ addr = result;
+
+ /* Look for address of the broker. */
+ while (addr != NULL) {
+ /* IPv4 Address. */
+ if (addr->ai_addrlen == sizeof(struct sockaddr_in)) {
+ struct sockaddr_in *broker4 =
+ ((struct sockaddr_in *)&broker);
+ char ipv4_addr[NET_IPV4_ADDR_LEN];
+
+ broker4->sin_addr.s_addr =
+ ((struct sockaddr_in *)addr->ai_addr)
+ ->sin_addr.s_addr;
+ broker4->sin_family = AF_INET;
+ broker4->sin_port = htons(CONFIG_MQTT_BROKER_PORT);
+
+ inet_ntop(AF_INET, &broker4->sin_addr.s_addr,
+ ipv4_addr, sizeof(ipv4_addr));
+ LOG_INF("IPv4 Address found %s", (char *)(ipv4_addr));
+
+ break;
+ } else {
+ LOG_ERR("ai_addrlen = %u should be %u or %u",
+ (unsigned int)addr->ai_addrlen,
+ (unsigned int)sizeof(struct sockaddr_in),
+ (unsigned int)sizeof(struct sockaddr_in6));
+ }
+
+ addr = addr->ai_next;
+ }
+
+ /* Free the address. */
+ freeaddrinfo(result);
+
+ return err;
+}
+
+/* Function to get the client id */
+static const uint8_t* client_id_get(void)
+{
+ static uint8_t client_id[MAX(sizeof(CONFIG_MQTT_CLIENT_ID),
+ CLIENT_ID_LEN)];
+
+ if (strlen(CONFIG_MQTT_CLIENT_ID) > 0) {
+ snprintf(client_id, sizeof(client_id), "%s",
+ CONFIG_MQTT_CLIENT_ID);
+ goto exit;
+ }
+
+ char imei_buf[CGSN_RESPONSE_LENGTH + 1];
+ int err;
+
+ err = nrf_modem_at_cmd(imei_buf, sizeof(imei_buf), "AT+CGSN");
+ if (err) {
+ LOG_ERR("Failed to obtain IMEI, error: %d", err);
+ goto exit;
+ }
+
+ imei_buf[IMEI_LEN] = '\0';
+
+ snprintf(client_id, sizeof(client_id), "nrf-%.*s", IMEI_LEN, imei_buf);
+
+exit:
+ LOG_DBG("client_id = %s", (char *)(client_id));
+
+ return client_id;
+}
+
+
+/**@brief Initialize the MQTT client structure
+ */
+/* Define the function client_init() to initialize the MQTT client instance. */
+int client_init(struct mqtt_client *client)
+{
+ int err;
+ /* Initializes the client instance. */
+ mqtt_client_init(client);
+
+ /* Resolves the configured hostname and initializes the MQTT broker structure */
+ err = broker_init();
+ if (err) {
+ LOG_ERR("Failed to initialize broker connection");
+ return err;
+ }
+
+ /* MQTT client configuration */
+ client->broker = &broker;
+ client->evt_cb = mqtt_evt_handler;
+ client->client_id.utf8 = client_id_get();
+ client->client_id.size = strlen(client->client_id.utf8);
+ client->password = NULL;
+ client->user_name = NULL;
+ client->protocol_version = MQTT_VERSION_3_1_1;
+
+ /* MQTT buffers configuration */
+ client->rx_buf = rx_buffer;
+ client->rx_buf_size = sizeof(rx_buffer);
+ client->tx_buf = tx_buffer;
+ client->tx_buf_size = sizeof(tx_buffer);
+
+ /* We are not using TLS */
+ client->transport.type = MQTT_TRANSPORT_NON_SECURE;
+
+ return err;
+}
+
+/**@brief Initialize the file descriptor structure used by poll.
+ */
+int fds_init(struct mqtt_client *c, struct pollfd *fds)
+{
+ if (c->transport.type == MQTT_TRANSPORT_NON_SECURE) {
+ fds->fd = c->transport.tcp.sock;
+ } else {
+ return -ENOTSUP;
+ }
+
+ fds->events = POLLIN;
+
+ return 0;
+} \ No newline at end of file
diff --git a/nrfdemo/src/mqtt_connection.h b/nrfdemo/src/mqtt_connection.h
new file mode 100644
index 0000000..51765e8
--- /dev/null
+++ b/nrfdemo/src/mqtt_connection.h
@@ -0,0 +1,21 @@
+#ifndef _MQTTCONNECTION_H_
+#define _MQTTCONNECTION_H_
+#define LED_CONTROL_OVER_MQTT DK_LED1 /* Stratus LED to control over MQTT */
+#define IMEI_LEN 15
+#define CGSN_RESPONSE_LENGTH (IMEI_LEN + 6 + 1) /* Add 6 for \r\nOK\r\n and 1 for \0 */
+#define CLIENT_ID_LEN sizeof("nrf-") + IMEI_LEN
+
+/**@brief Initialize the MQTT client structure
+ */
+int client_init(struct mqtt_client *client);
+
+/**@brief Initialize the file descriptor structure used by poll.
+ */
+int fds_init(struct mqtt_client *c, struct pollfd *fds);
+
+/**@brief Function to publish data on the configured topic
+ */
+int data_publish(struct mqtt_client *c, enum mqtt_qos qos,
+ uint8_t *data, size_t len);
+
+#endif /* _CONNECTION_H_ */
generated by cgit v1.2.3 (git 2.46.0) at 2026-09-22 18:43:22 +0000