From b05cba931bfc46a5392b121deaa6eecae4b5f8c4 Mon Sep 17 00:00:00 2001 From: MX <10697207+xMasterX@users.noreply.github.com> Date: Thu, 2 Feb 2023 14:01:23 +0300 Subject: [PATCH] Update UniTemp https://github.com/quen0n/unitemp-flipperzero/tree/master --- applications/plugins/unitemp/README.md | 13 +- applications/plugins/unitemp/Sensors.c | 23 +- applications/plugins/unitemp/Sensors.h | 4 +- applications/plugins/unitemp/sensors/BME680.c | 431 ++++++++++++++++++ applications/plugins/unitemp/sensors/BME680.h | 112 +++++ .../plugins/unitemp/sensors/MAX6675.c | 81 ++++ .../plugins/unitemp/sensors/MAX6675.h | 65 +++ .../plugins/unitemp/sensors/Sensors.xlsx | Bin 12455 -> 12642 bytes applications/plugins/unitemp/unitemp.h | 2 +- 9 files changed, 707 insertions(+), 24 deletions(-) create mode 100644 applications/plugins/unitemp/sensors/BME680.c create mode 100644 applications/plugins/unitemp/sensors/BME680.h create mode 100644 applications/plugins/unitemp/sensors/MAX6675.c create mode 100644 applications/plugins/unitemp/sensors/MAX6675.h diff --git a/applications/plugins/unitemp/README.md b/applications/plugins/unitemp/README.md index 668aae40a..436f3600e 100644 --- a/applications/plugins/unitemp/README.md +++ b/applications/plugins/unitemp/README.md @@ -4,14 +4,21 @@ [![GitHub](https://img.shields.io/github/license/quen0n/unitemp-flipperzero)](https://github.com/quen0n/unitemp-flipperzero/blob/dev/LICENSE.md) [![Build dev](https://github.com/quen0n/unitemp-flipperzero/actions/workflows/build_dev.yml/badge.svg?branch=dev)](https://github.com/quen0n/unitemp-flipperzero/actions/workflows/build_dev.yml) [Flipper Zero](https://flipperzero.one/) application for reading temperature, humidity and pressure sensors like a DHT11/22, DS18B20, BMP280, HTU21 and more. -## List of supported sensors (supplemented) -![image](https://user-images.githubusercontent.com/10090793/211131502-c1560eb5-f59c-4cfa-86f7-27f037490a35.png) +## List of supported sensors +![image](https://user-images.githubusercontent.com/10090793/215605424-54b1c08c-e41b-4fb4-b966-dd959507200b.png) + ## Installation 1) Download [latest version](https://cloud.quenon.ru/index.php/s/h98rT9UnaOL4wxR/download?path=%2F&files=unitemp-latest.fap) 2) Copy `unitemp-latest.fap` to `SD card/apps/GPIO` with qFlipper or mobile application 3) Open application on your Flipper: `Applications->GPIO->Temp sensors reader` -Note: If you get the message "API version mismatch" after updating the firmware, download and install Unitemp again +Note: If you get the message "API version mismatch" after updating the firmware, download and install Unitemp again +## Need help? Discussions? +Join the discussion, ask a question or just send a photo of the flipper with sensors to [Discord](https://discord.com/channels/740930220399525928/1056727938747351060) +## Gratitudes +Thanks to [@Svaarich](https://github.com/Svaarich) for the UI design and to the Unleashed firmware community for sensors testing and feedbacks. + ## Some community photos ![image](https://user-images.githubusercontent.com/10090793/210120132-7ddbc937-0a6b-4472-bd1c-7fbc3ecdf2ad.png) ![image](https://user-images.githubusercontent.com/10090793/210120135-12fc5810-77ff-49db-b799-e9479e1f57a7.png) ![image](https://user-images.githubusercontent.com/10090793/210120143-a2bae3ce-4190-421f-8c4f-c7c744903bd6.png) +![image](https://user-images.githubusercontent.com/10090793/215224085-8099408e-b3de-4a0c-854e-fe4e4faa8ea3.png) \ No newline at end of file diff --git a/applications/plugins/unitemp/Sensors.c b/applications/plugins/unitemp/Sensors.c index 2b1eaf6bf..d9304ab32 100644 --- a/applications/plugins/unitemp/Sensors.c +++ b/applications/plugins/unitemp/Sensors.c @@ -75,25 +75,10 @@ const Interface SPI = { //Перечень интерфейсов подключения //static const Interface* interfaces[] = {&SINGLE_WIRE, &I2C, &ONE_WIRE, &SPI}; //Перечень датчиков -static const SensorType* sensorTypes[] = { - &DHT11, - &DHT12_SW, - &DHT20, - &DHT21, - &DHT22, - &Dallas, - &AM2320_SW, - &AM2320_I2C, - &HTU21x, - &AHT10, - &SHT30, - &GXHT30, - &LM75, - &HDC1080, - &BMP180, - &BMP280, - &BME280, - &MAX31855}; +static const SensorType* sensorTypes[] = {&DHT11, &DHT12_SW, &DHT20, &DHT21, &DHT22, + &Dallas, &AM2320_SW, &AM2320_I2C, &HTU21x, &AHT10, + &SHT30, &GXHT30, &LM75, &HDC1080, &BMP180, + &BMP280, &BME280, &BME680, &MAX31855, &MAX6675}; const SensorType* unitemp_sensors_getTypeFromInt(uint8_t index) { if(index > SENSOR_TYPES_COUNT) return NULL; diff --git a/applications/plugins/unitemp/Sensors.h b/applications/plugins/unitemp/Sensors.h index 3e4152e33..d2b7c07af 100644 --- a/applications/plugins/unitemp/Sensors.h +++ b/applications/plugins/unitemp/Sensors.h @@ -318,8 +318,9 @@ const GPIO* //DS18x2x #include "./interfaces/OneWireSensor.h" #include "./sensors/LM75.h" -//BMP280, BME280 +//BMP280, BME280, BME680 #include "./sensors/BMx280.h" +#include "./sensors/BME680.h" #include "./sensors/AM2320.h" #include "./sensors/DHT20.h" #include "./sensors/SHT30.h" @@ -327,4 +328,5 @@ const GPIO* #include "./sensors/HTU21x.h" #include "./sensors/HDC1080.h" #include "./sensors/MAX31855.h" +#include "./sensors/MAX6675.h" #endif diff --git a/applications/plugins/unitemp/sensors/BME680.c b/applications/plugins/unitemp/sensors/BME680.c new file mode 100644 index 000000000..397e702cb --- /dev/null +++ b/applications/plugins/unitemp/sensors/BME680.c @@ -0,0 +1,431 @@ +/* + Unitemp - Universal temperature reader + Copyright (C) 2022-2023 Victor Nikitchuk (https://github.com/quen0n) + Contributed by g0gg0 (https://github.com/g3gg0) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#include "BME680.h" + +const SensorType BME680 = { + .typename = "BME680", + .interface = &I2C, + .datatype = UT_TEMPERATURE | UT_HUMIDITY | UT_PRESSURE, + .pollingInterval = 500, + .allocator = unitemp_BME680_alloc, + .mem_releaser = unitemp_BME680_free, + .initializer = unitemp_BME680_init, + .deinitializer = unitemp_BME680_deinit, + .updater = unitemp_BME680_update}; + +//Интервал обновления калибровочных значений +#define BOSCH_CAL_UPDATE_INTERVAL 60000 + +#define BME680_ID 0x61 + +#define BME680_I2C_ADDR_MIN (0x76 << 1) +#define BME680_I2C_ADDR_MAX (0x77 << 1) + +#define BME680_REG_STATUS 0x1D +#define BME680_REG_CTRL_MEAS 0x74 +#define BME680_REG_CONFIG 0x75 +#define BME680_REG_CTRL_HUM 0x72 +//Преддескретизация температуры +#define BME680_TEMP_OVERSAMPLING_SKIP 0b00000000 +#define BME680_TEMP_OVERSAMPLING_1 0b00100000 +#define BME680_TEMP_OVERSAMPLING_2 0b01000000 +#define BME680_TEMP_OVERSAMPLING_4 0b01100000 +#define BME680_TEMP_OVERSAMPLING_8 0b10000000 +#define BME680_TEMP_OVERSAMPLING_16 0b10100000 +//Преддескретизация давления +#define BME680_PRESS_OVERSAMPLING_SKIP 0b00000000 +#define BME680_PRESS_OVERSAMPLING_1 0b00000100 +#define BME680_PRESS_OVERSAMPLING_2 0b00001000 +#define BME680_PRESS_OVERSAMPLING_4 0b00001100 +#define BME680_PRESS_OVERSAMPLING_8 0b00010000 +#define BME680_PRESS_OVERSAMPLING_16 0b00010100 +//Преддескретизация влажности +#define BME680_HUM_OVERSAMPLING_SKIP 0b00000000 +#define BME680_HUM_OVERSAMPLING_1 0b00000001 +#define BME680_HUM_OVERSAMPLING_2 0b00000010 +#define BME680_HUM_OVERSAMPLING_4 0b00000011 +#define BME680_HUM_OVERSAMPLING_8 0b00000100 +#define BME680_HUM_OVERSAMPLING_16 0b00000101 +//Режимы работы датчика +#define BME680_MODE_SLEEP 0b00000000 //Наелся и спит +#define BME680_MODE_FORCED 0b00000001 //Обновляет значения 1 раз, после чего уходит в сон +//Коэффициент фильтрации значений +#define BME680_FILTER_COEFF_1 0b00000000 +#define BME680_FILTER_COEFF_2 0b00000100 +#define BME680_FILTER_COEFF_4 0b00001000 +#define BME680_FILTER_COEFF_8 0b00001100 +#define BME680_FILTER_COEFF_16 0b00010000 +//Разрешить работу по SPI +#define BME680_SPI_3W_ENABLE 0b00000001 +#define BME680_SPI_3W_DISABLE 0b00000000 + +/* https://github.com/boschsensortec/BME680_driver/blob/master/bme680.c or + https://github.com/boschsensortec/BME68x-Sensor-API */ +static float BME680_compensate_temperature(I2CSensor* i2c_sensor, int32_t temp_adc) { + BME680_instance* bme680_instance = (BME680_instance*)i2c_sensor->sensorInstance; + float var1 = 0; + float var2 = 0; + float calc_temp = 0; + + /* calculate var1 data */ + var1 = + ((((float)temp_adc / 16384.0f) - ((float)bme680_instance->temp_cal.dig_T1 / 1024.0f)) * + ((float)bme680_instance->temp_cal.dig_T2)); + + /* calculate var2 data */ + var2 = + (((((float)temp_adc / 131072.0f) - ((float)bme680_instance->temp_cal.dig_T1 / 8192.0f)) * + (((float)temp_adc / 131072.0f) - ((float)bme680_instance->temp_cal.dig_T1 / 8192.0f))) * + ((float)bme680_instance->temp_cal.dig_T3 * 16.0f)); + + /* t_fine value*/ + bme680_instance->t_fine = (var1 + var2); + + /* compensated temperature data*/ + calc_temp = ((bme680_instance->t_fine) / 5120.0f); + + return calc_temp; +} + +static float BME680_compensate_pressure(I2CSensor* i2c_sensor, int32_t pres_adc) { + BME680_instance* bme680_instance = (BME680_instance*)i2c_sensor->sensorInstance; + + float var1; + float var2; + float var3; + float calc_pres; + + var1 = (((float)bme680_instance->t_fine / 2.0f) - 64000.0f); + var2 = var1 * var1 * (((float)bme680_instance->press_cal.dig_P6) / (131072.0f)); + var2 = var2 + (var1 * ((float)bme680_instance->press_cal.dig_P5) * 2.0f); + var2 = (var2 / 4.0f) + (((float)bme680_instance->press_cal.dig_P4) * 65536.0f); + var1 = + (((((float)bme680_instance->press_cal.dig_P3 * var1 * var1) / 16384.0f) + + ((float)bme680_instance->press_cal.dig_P2 * var1)) / + 524288.0f); + var1 = ((1.0f + (var1 / 32768.0f)) * ((float)bme680_instance->press_cal.dig_P1)); + calc_pres = (1048576.0f - ((float)pres_adc)); + + /* Avoid exception caused by division by zero */ + if((int)var1 != 0) { + calc_pres = (((calc_pres - (var2 / 4096.0f)) * 6250.0f) / var1); + var1 = + (((float)bme680_instance->press_cal.dig_P9) * calc_pres * calc_pres) / 2147483648.0f; + var2 = calc_pres * (((float)bme680_instance->press_cal.dig_P8) / 32768.0f); + var3 = + ((calc_pres / 256.0f) * (calc_pres / 256.0f) * (calc_pres / 256.0f) * + (bme680_instance->press_cal.dig_P10 / 131072.0f)); + calc_pres = + (calc_pres + + (var1 + var2 + var3 + ((float)bme680_instance->press_cal.dig_P7 * 128.0f)) / 16.0f); + } else { + calc_pres = 0; + } + + return calc_pres; +} + +static float BME680_compensate_humidity(I2CSensor* i2c_sensor, int32_t hum_adc) { + BME680_instance* bme680_instance = (BME680_instance*)i2c_sensor->sensorInstance; + float calc_hum; + float var1; + float var2; + float var3; + float var4; + float temp_comp; + + /* compensated temperature data*/ + temp_comp = ((bme680_instance->t_fine) / 5120.0f); + var1 = + (float)((float)hum_adc) - (((float)bme680_instance->hum_cal.dig_H1 * 16.0f) + + (((float)bme680_instance->hum_cal.dig_H3 / 2.0f) * temp_comp)); + var2 = var1 * + ((float)(((float)bme680_instance->hum_cal.dig_H2 / 262144.0f) * + (1.0f + (((float)bme680_instance->hum_cal.dig_H4 / 16384.0f) * temp_comp) + + (((float)bme680_instance->hum_cal.dig_H5 / 1048576.0f) * temp_comp * temp_comp)))); + var3 = (float)bme680_instance->hum_cal.dig_H6 / 16384.0f; + var4 = (float)bme680_instance->hum_cal.dig_H7 / 2097152.0f; + calc_hum = var2 + ((var3 + (var4 * temp_comp)) * var2 * var2); + if(calc_hum > 100.0f) { + calc_hum = 100.0f; + } else if(calc_hum < 0.0f) { + calc_hum = 0.0f; + } + + return calc_hum; +} + +/* https://github.com/boschsensortec/BME680_driver/blob/master/bme680_defs.h */ +#define BME680_COEFF_SIZE UINT8_C(41) +#define BME680_COEFF_ADDR1_LEN UINT8_C(25) +#define BME680_COEFF_ADDR2_LEN UINT8_C(16) +#define BME680_COEFF_ADDR1 UINT8_C(0x89) +#define BME680_COEFF_ADDR2 UINT8_C(0xe1) +#define BME680_CONCAT_BYTES(msb, lsb) (((uint16_t)msb << 8) | (uint16_t)lsb) +#define BME680_T2_LSB_REG (1) +#define BME680_T2_MSB_REG (2) +#define BME680_T3_REG (3) +#define BME680_P1_LSB_REG (5) +#define BME680_P1_MSB_REG (6) +#define BME680_P2_LSB_REG (7) +#define BME680_P2_MSB_REG (8) +#define BME680_P3_REG (9) +#define BME680_P4_LSB_REG (11) +#define BME680_P4_MSB_REG (12) +#define BME680_P5_LSB_REG (13) +#define BME680_P5_MSB_REG (14) +#define BME680_P7_REG (15) +#define BME680_P6_REG (16) +#define BME680_P8_LSB_REG (19) +#define BME680_P8_MSB_REG (20) +#define BME680_P9_LSB_REG (21) +#define BME680_P9_MSB_REG (22) +#define BME680_P10_REG (23) +#define BME680_H2_MSB_REG (25) +#define BME680_H2_LSB_REG (26) +#define BME680_H1_LSB_REG (26) +#define BME680_H1_MSB_REG (27) +#define BME680_H3_REG (28) +#define BME680_H4_REG (29) +#define BME680_H5_REG (30) +#define BME680_H6_REG (31) +#define BME680_H7_REG (32) +#define BME680_T1_LSB_REG (33) +#define BME680_T1_MSB_REG (34) +#define BME680_GH2_LSB_REG (35) +#define BME680_GH2_MSB_REG (36) +#define BME680_GH1_REG (37) +#define BME680_GH3_REG (38) +#define BME680_HUM_REG_SHIFT_VAL UINT8_C(4) +#define BME680_BIT_H1_DATA_MSK UINT8_C(0x0F) + +static bool BME680_readCalValues(I2CSensor* i2c_sensor) { + BME680_instance* bme680_instance = (BME680_instance*)i2c_sensor->sensorInstance; + uint8_t coeff_array[BME680_COEFF_SIZE] = {0}; + + if(!unitemp_i2c_readRegArray( + i2c_sensor, BME680_COEFF_ADDR1, BME680_COEFF_ADDR1_LEN, &coeff_array[0])) + return false; + if(!unitemp_i2c_readRegArray( + i2c_sensor, + BME680_COEFF_ADDR2, + BME680_COEFF_ADDR2_LEN, + &coeff_array[BME680_COEFF_ADDR1_LEN])) + return false; + + /* Temperature related coefficients */ + bme680_instance->temp_cal.dig_T1 = (uint16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_T1_MSB_REG], coeff_array[BME680_T1_LSB_REG])); + bme680_instance->temp_cal.dig_T2 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_T2_MSB_REG], coeff_array[BME680_T2_LSB_REG])); + bme680_instance->temp_cal.dig_T3 = (int8_t)(coeff_array[BME680_T3_REG]); + + /* Pressure related coefficients */ + bme680_instance->press_cal.dig_P1 = (uint16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P1_MSB_REG], coeff_array[BME680_P1_LSB_REG])); + bme680_instance->press_cal.dig_P2 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P2_MSB_REG], coeff_array[BME680_P2_LSB_REG])); + bme680_instance->press_cal.dig_P3 = (int8_t)coeff_array[BME680_P3_REG]; + bme680_instance->press_cal.dig_P4 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P4_MSB_REG], coeff_array[BME680_P4_LSB_REG])); + bme680_instance->press_cal.dig_P5 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P5_MSB_REG], coeff_array[BME680_P5_LSB_REG])); + bme680_instance->press_cal.dig_P6 = (int8_t)(coeff_array[BME680_P6_REG]); + bme680_instance->press_cal.dig_P7 = (int8_t)(coeff_array[BME680_P7_REG]); + bme680_instance->press_cal.dig_P8 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P8_MSB_REG], coeff_array[BME680_P8_LSB_REG])); + bme680_instance->press_cal.dig_P9 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_P9_MSB_REG], coeff_array[BME680_P9_LSB_REG])); + bme680_instance->press_cal.dig_P10 = (uint8_t)(coeff_array[BME680_P10_REG]); + + /* Humidity related coefficients */ + bme680_instance->hum_cal.dig_H1 = + (uint16_t)(((uint16_t)coeff_array[BME680_H1_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) | (coeff_array[BME680_H1_LSB_REG] & BME680_BIT_H1_DATA_MSK)); + bme680_instance->hum_cal.dig_H2 = + (uint16_t)(((uint16_t)coeff_array[BME680_H2_MSB_REG] << BME680_HUM_REG_SHIFT_VAL) | ((coeff_array[BME680_H2_LSB_REG]) >> BME680_HUM_REG_SHIFT_VAL)); + bme680_instance->hum_cal.dig_H3 = (int8_t)coeff_array[BME680_H3_REG]; + bme680_instance->hum_cal.dig_H4 = (int8_t)coeff_array[BME680_H4_REG]; + bme680_instance->hum_cal.dig_H5 = (int8_t)coeff_array[BME680_H5_REG]; + bme680_instance->hum_cal.dig_H6 = (uint8_t)coeff_array[BME680_H6_REG]; + bme680_instance->hum_cal.dig_H7 = (int8_t)coeff_array[BME680_H7_REG]; + + /* Gas heater related coefficients */ + bme680_instance->gas_cal.dig_GH1 = (int8_t)coeff_array[BME680_GH1_REG]; + bme680_instance->gas_cal.dig_GH2 = (int16_t)(BME680_CONCAT_BYTES( + coeff_array[BME680_GH2_MSB_REG], coeff_array[BME680_GH2_LSB_REG])); + bme680_instance->gas_cal.dig_GH3 = (int8_t)coeff_array[BME680_GH3_REG]; + +#ifdef UNITEMP_DEBUG + FURI_LOG_D( + APP_NAME, + "Sensor BME680 T1-T3: %d, %d, %d", + bme680_instance->temp_cal.dig_T1, + bme680_instance->temp_cal.dig_T2, + bme680_instance->temp_cal.dig_T3); + + FURI_LOG_D( + APP_NAME, + "Sensor BME680: P1-P10: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d", + bme680_instance->press_cal.dig_P1, + bme680_instance->press_cal.dig_P2, + bme680_instance->press_cal.dig_P3, + bme680_instance->press_cal.dig_P4, + bme680_instance->press_cal.dig_P5, + bme680_instance->press_cal.dig_P6, + bme680_instance->press_cal.dig_P7, + bme680_instance->press_cal.dig_P8, + bme680_instance->press_cal.dig_P9, + bme680_instance->press_cal.dig_P10); + + FURI_LOG_D( + APP_NAME, + "Sensor BME680: H1-H7: %d, %d, %d, %d, %d, %d, %d", + bme680_instance->hum_cal.dig_H1, + bme680_instance->hum_cal.dig_H2, + bme680_instance->hum_cal.dig_H3, + bme680_instance->hum_cal.dig_H4, + bme680_instance->hum_cal.dig_H5, + bme680_instance->hum_cal.dig_H6, + bme680_instance->hum_cal.dig_H7); + + FURI_LOG_D( + APP_NAME, + "Sensor BME680 GH1-GH3: %d, %d, %d", + bme680_instance->gas_cal.dig_GH1, + bme680_instance->gas_cal.dig_GH2, + bme680_instance->gas_cal.dig_GH3); + +#endif + + bme680_instance->last_cal_update_time = furi_get_tick(); + return true; +} +static bool BME680_isMeasuring(Sensor* sensor) { + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + return (bool)(unitemp_i2c_readReg(i2c_sensor, BME680_REG_STATUS) & 0x20); +} + +bool unitemp_BME680_alloc(Sensor* sensor, char* args) { + UNUSED(args); + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + BME680_instance* bme680_instance = malloc(sizeof(BME680_instance)); + if(bme680_instance == NULL) { + FURI_LOG_E(APP_NAME, "Failed to allocation sensor %s instance", sensor->name); + return false; + } + + if(sensor->type == &BME680) bme680_instance->chip_id = BME680_ID; + + i2c_sensor->sensorInstance = bme680_instance; + + i2c_sensor->minI2CAdr = BME680_I2C_ADDR_MIN; + i2c_sensor->maxI2CAdr = BME680_I2C_ADDR_MAX; + return true; +} + +bool unitemp_BME680_init(Sensor* sensor) { + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + //Перезагрузка + unitemp_i2c_writeReg(i2c_sensor, 0xE0, 0xB6); + //Чтение ID датчика + uint8_t id = unitemp_i2c_readReg(i2c_sensor, 0xD0); + if(id != BME680_ID) { + FURI_LOG_E( + APP_NAME, + "Sensor %s returned wrong ID 0x%02X, expected 0x%02X", + sensor->name, + id, + BME680_ID); + return false; + } + + unitemp_i2c_writeReg( + i2c_sensor, + BME680_REG_CTRL_HUM, + (unitemp_i2c_readReg(i2c_sensor, BME680_REG_CTRL_HUM) & ~7) | BME680_HUM_OVERSAMPLING_1); + unitemp_i2c_writeReg( + i2c_sensor, + BME680_REG_CTRL_MEAS, + BME680_TEMP_OVERSAMPLING_2 | BME680_PRESS_OVERSAMPLING_4 | BME680_MODE_FORCED); + //Настройка периода опроса и фильтрации значений + unitemp_i2c_writeReg( + i2c_sensor, BME680_REG_CONFIG, BME680_FILTER_COEFF_16 | BME680_SPI_3W_DISABLE); + //Чтение калибровочных значений + if(!BME680_readCalValues(i2c_sensor)) { + FURI_LOG_E(APP_NAME, "Failed to read calibration values sensor %s", sensor->name); + return false; + } + return true; +} + +bool unitemp_BME680_deinit(Sensor* sensor) { + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + //Перевод в сон + unitemp_i2c_writeReg(i2c_sensor, BME680_REG_CTRL_MEAS, BME680_MODE_SLEEP); + return true; +} + +UnitempStatus unitemp_BME680_update(Sensor* sensor) { + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + BME680_instance* instance = i2c_sensor->sensorInstance; + + uint32_t t = furi_get_tick(); + + uint8_t buff[3]; + //Проверка инициализированности датчика + unitemp_i2c_readRegArray(i2c_sensor, 0xF4, 2, buff); + if(buff[0] == 0) { + FURI_LOG_W(APP_NAME, "Sensor %s is not initialized!", sensor->name); + return UT_SENSORSTATUS_ERROR; + } + + unitemp_i2c_writeReg( + i2c_sensor, + BME680_REG_CTRL_MEAS, + unitemp_i2c_readReg(i2c_sensor, BME680_REG_CTRL_MEAS) | 1); + + while(BME680_isMeasuring(sensor)) { + if(furi_get_tick() - t > 100) { + return UT_SENSORSTATUS_TIMEOUT; + } + } + + if(furi_get_tick() - instance->last_cal_update_time > BOSCH_CAL_UPDATE_INTERVAL) { + BME680_readCalValues(i2c_sensor); + } + + if(!unitemp_i2c_readRegArray(i2c_sensor, 0x1F, 3, buff)) return UT_SENSORSTATUS_TIMEOUT; + int32_t adc_P = ((int32_t)buff[0] << 12) | ((int32_t)buff[1] << 4) | ((int32_t)buff[2] >> 4); + if(!unitemp_i2c_readRegArray(i2c_sensor, 0x22, 3, buff)) return UT_SENSORSTATUS_TIMEOUT; + int32_t adc_T = ((int32_t)buff[0] << 12) | ((int32_t)buff[1] << 4) | ((int32_t)buff[2] >> 4); + if(!unitemp_i2c_readRegArray(i2c_sensor, 0x25, 2, buff)) return UT_SENSORSTATUS_TIMEOUT; + int32_t adc_H = ((uint16_t)buff[0] << 8) | buff[1]; + + sensor->temp = BME680_compensate_temperature(i2c_sensor, adc_T); + sensor->pressure = BME680_compensate_pressure(i2c_sensor, adc_P); + sensor->hum = BME680_compensate_humidity(i2c_sensor, adc_H); + + return UT_SENSORSTATUS_OK; +} + +bool unitemp_BME680_free(Sensor* sensor) { + I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance; + free(i2c_sensor->sensorInstance); + return true; +} \ No newline at end of file diff --git a/applications/plugins/unitemp/sensors/BME680.h b/applications/plugins/unitemp/sensors/BME680.h new file mode 100644 index 000000000..b126c7c84 --- /dev/null +++ b/applications/plugins/unitemp/sensors/BME680.h @@ -0,0 +1,112 @@ +/* + Unitemp - Universal temperature reader + Copyright (C) 2022-2023 Victor Nikitchuk (https://github.com/quen0n) + Contributed by g0gg0 (https://github.com/g3gg0) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#ifndef UNITEMP_BME680 +#define UNITEMP_BME680 + +#include "../unitemp.h" +#include "../Sensors.h" +#include "../interfaces/I2CSensor.h" + +typedef struct { + uint16_t dig_T1; + int16_t dig_T2; + int16_t dig_T3; +} BME680_temp_cal; + +typedef struct { + uint16_t dig_GH1; + int16_t dig_GH2; + int16_t dig_GH3; +} BME680_gas_cal; + +typedef struct { + uint16_t dig_P1; + int16_t dig_P2; + int16_t dig_P3; + int16_t dig_P4; + int16_t dig_P5; + int16_t dig_P6; + int16_t dig_P7; + int16_t dig_P8; + int16_t dig_P9; + int16_t dig_P10; +} BME680_press_cal; + +typedef struct { + uint16_t dig_H1; + uint16_t dig_H2; + int8_t dig_H3; + int8_t dig_H4; + int8_t dig_H5; + uint8_t dig_H6; + int8_t dig_H7; +} BME680_hum_cal; + +typedef struct { + //Калибровочные значения температуры + BME680_temp_cal temp_cal; + //Калибровочные значения давления + BME680_press_cal press_cal; + //Калибровочные значения влажности воздуха + BME680_hum_cal hum_cal; + BME680_gas_cal gas_cal; + //Время последнего обновления калибровочных значений + uint32_t last_cal_update_time; + //Индификатор датчика + uint8_t chip_id; + //Корректировочное значение температуры + int32_t t_fine; +} BME680_instance; + +extern const SensorType BMP280; +extern const SensorType BME680; +/** + * @brief Выделение памяти и установка начальных значений датчика BMP280 + * @param sensor Указатель на создаваемый датчик + * @return Истина при успехе + */ +bool unitemp_BME680_alloc(Sensor* sensor, char* args); + +/** + * @brief Инициализации датчика BMP280 + * @param sensor Указатель на датчик + * @return Истина если инициализация упспешная + */ +bool unitemp_BME680_init(Sensor* sensor); + +/** + * @brief Деинициализация датчика + * @param sensor Указатель на датчик + */ +bool unitemp_BME680_deinit(Sensor* sensor); + +/** + * @brief Обновление значений из датчика + * @param sensor Указатель на датчик + * @return Статус опроса датчика + */ +UnitempStatus unitemp_BME680_update(Sensor* sensor); + +/** + * @brief Высвободить память датчика + * @param sensor Указатель на датчик + */ +bool unitemp_BME680_free(Sensor* sensor); + +#endif \ No newline at end of file diff --git a/applications/plugins/unitemp/sensors/MAX6675.c b/applications/plugins/unitemp/sensors/MAX6675.c new file mode 100644 index 000000000..e97a96eb5 --- /dev/null +++ b/applications/plugins/unitemp/sensors/MAX6675.c @@ -0,0 +1,81 @@ +/* + Unitemp - Universal temperature reader + Copyright (C) 2022-2023 Victor Nikitchuk (https://github.com/quen0n) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#include "MAX6675.h" + +const SensorType MAX6675 = { + .typename = "MAX6675", + .altname = "MAX6675 (Thermocouple)", + .interface = &SPI, + .datatype = UT_TEMPERATURE, + .pollingInterval = 500, + .allocator = unitemp_MAX6675_alloc, + .mem_releaser = unitemp_MAX6675_free, + .initializer = unitemp_MAX6675_init, + .deinitializer = unitemp_MAX6675_deinit, + .updater = unitemp_MAX6675_update}; + +bool unitemp_MAX6675_alloc(Sensor* sensor, char* args) { + UNUSED(sensor); + UNUSED(args); + return true; +} + +bool unitemp_MAX6675_free(Sensor* sensor) { + UNUSED(sensor); + return true; +} + +bool unitemp_MAX6675_init(Sensor* sensor) { + SPISensor* instance = sensor->instance; + furi_hal_spi_bus_handle_init(instance->spi); + UNUSED(instance); + return true; +} + +bool unitemp_MAX6675_deinit(Sensor* sensor) { + UNUSED(sensor); + return true; +} + +UnitempStatus unitemp_MAX6675_update(Sensor* sensor) { + SPISensor* instance = sensor->instance; + + furi_hal_spi_acquire(instance->spi); + furi_hal_gpio_write(instance->CS_pin->pin, false); + + uint8_t buff[2] = {0}; + + furi_hal_spi_bus_rx(instance->spi, buff, 2, 0xFF); + furi_hal_spi_release(instance->spi); + + uint32_t raw = (buff[0] << 8) | buff[1]; + + if(raw == 0xFFFFFFFF || raw == 0) return UT_SENSORSTATUS_TIMEOUT; + + //Определение состояния термопары + uint8_t state = raw & 0b100; + //Обрыв + if(state == 0b100) { + UNITEMP_DEBUG("%s has thermocouple open circuit", sensor->name); + return UT_SENSORSTATUS_ERROR; + } + + sensor->temp = (int16_t)(raw) / 32.0f; + + return UT_SENSORSTATUS_OK; +} diff --git a/applications/plugins/unitemp/sensors/MAX6675.h b/applications/plugins/unitemp/sensors/MAX6675.h new file mode 100644 index 000000000..cce346590 --- /dev/null +++ b/applications/plugins/unitemp/sensors/MAX6675.h @@ -0,0 +1,65 @@ +/* + Unitemp - Universal temperature reader + Copyright (C) 2022-2023 Victor Nikitchuk (https://github.com/quen0n) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + 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. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . +*/ +#ifndef UNITEMP_MAX6675 +#define UNITEMP_MAX6675 + +#include "../unitemp.h" +#include "../Sensors.h" +#include "../interfaces/SPISensor.h" + +extern const SensorType MAX6675; + +/** + * @brief Выделение памяти и установка начальных значений датчика MAX6675 + * + * @param sensor Указатель на создаваемый датчик + * @return Истина при успехе + */ +bool unitemp_MAX6675_alloc(Sensor* sensor, char* args); + +/** + * @brief Инициализации датчика MAX6675 + * + * @param sensor Указатель на датчик + * @return Истина если инициализация упспешная + */ +bool unitemp_MAX6675_init(Sensor* sensor); + +/** + * @brief Деинициализация датчика + * + * @param sensor Указатель на датчик + */ +bool unitemp_MAX6675_deinit(Sensor* sensor); + +/** + * @brief Обновление значений из датчика + * + * @param sensor Указатель на датчик + * @return Статус обновления + */ +UnitempStatus unitemp_MAX6675_update(Sensor* sensor); + +/** + * @brief Высвободить память датчика + * + * @param sensor Указатель на датчик + */ +bool unitemp_MAX6675_free(Sensor* sensor); + +#endif \ No newline at end of file diff --git a/applications/plugins/unitemp/sensors/Sensors.xlsx b/applications/plugins/unitemp/sensors/Sensors.xlsx index bd47d4948316b9b3797bc4a39106149a3724db2a..c314098a88c2bbc3d75fcc900815cfbdf5bb4772 100644 GIT binary patch delta 7420 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 Z|39$~xESX<1S1wWl#}`uJ^Mej{{v~c{Luga delta 7243 zcmZ8`byOU@v-V=eZE-1!7I*go3v6*OE{nUnELNQ2TA)zewYU^0t}RY+hb`_D`TD-+ ze)o6p&6z(YCz(8xoXjM7vIQ+Qt6P2rOE7Ia&O-tKywLyvTmS&z}C&jcDCp6 zadfEC-gGLI!+SO#8zH%CAwQFk?uoo&E)z&B}7IxI^(bUpuI4p_Sy& ze5Fg>y4Ne&UAwJK-zQ_0OrksM-by&I#nx^+1nr&hr_6)z+}M3?#%j$unV=dNFDoB* zITx$T1X)&Q0yz70GU##BV`AVa?=lSmprkUcP%hBynDxG>_aeL{JfwK%OD{$`)OJh< z&u};fZ*I03E)=qAIy#O(Lp)@9)=(t;&UcMJyc_|XNY0wi$+|rHT0aGZv|w6)q|dsq zjEQ&KRB}|0${+tGVJagIGr$BUvq-T+L4oid0NeStak7S7684^-kHqjoBNxylo+uFo z5*CoI)uH9yYqT86`P1!;)nsF$g(DbDQr=U1u}}FpZ|eEv60Y>efpZ_GXhvA{-Ke@o zYFO0gAdWi9(8NEKtK=(fsF|!)4)gS;K+Wl#VS;$25YtL4ZI8DWo((ZCPpTY-HNMpODOdTh*M_U*~n58?U` zk>p!`Dc*tRrKti#8;>D3{KAe>+w9^zxV%pChwfcVDVq;j`???Z<%2Se=iU2|n%2?yogaf#bFQ8JJb%yhk{vtgc-7@=-OQL|u8c3EYdNw&CVmIf=o1jb~y8Hu6 zrbaPBVPcD!#z#Jid-K%L9G>dZkSd&>fNe73<)<0sN}LA?gBGuzkJp)w-nXB2>+0F( zDsN(IHF9r{XI}O)S1AvDxO=)gCO&%Rb*uh7oL_$)qW�`h7Q>{P-1Mi7uvfJE3R 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 diff --git a/applications/plugins/unitemp/unitemp.h b/applications/plugins/unitemp/unitemp.h index bcb2e4ac9..bde8b0c17 100644 --- a/applications/plugins/unitemp/unitemp.h +++ b/applications/plugins/unitemp/unitemp.h @@ -40,7 +40,7 @@ //Имя приложения #define APP_NAME "Unitemp" //Версия приложения -#define UNITEMP_APP_VER "1.1.2-dev" +#define UNITEMP_APP_VER "1.2" //Путь хранения файлов плагина #define APP_PATH_FOLDER "/ext/unitemp" //Имя файла с настройками