Merge branch 'dev' into badusb-ble

2026-06-11 19:33:30 -07:00 · 2023-01-31 11:47:34 +01:00
parent f384872449 2354b51d30
commit f99309b9bc
55 changed files with 2228 additions and 218 deletions
@@ -4,7 +4,7 @@
  <img src="https://user-images.githubusercontent.com/55334727/215170306-051eeb8f-8f72-437f-8c2d-0e4be009bdad.png">
 </p>

-[Intro](https://github.com/ClaraCrazy/Flipper-Xtreme#What-makes-it-special) | [Animations](https://github.com/ClaraCrazy/Flipper-Xtreme#Animations--Asset-Packs) | [Docs](https://github.com/ClaraCrazy/Flipper-Xtreme/wiki) | [Changelog](https://github.com/ClaraCrazy/Flipper-Xtreme#list-of-changes) | [Known bugs](https://github.com/ClaraCrazy/Flipper-Xtreme#Known-bugs) | [Install](https://github.com/ClaraCrazy/Flipper-Xtreme#Install) | [Build](https://github.com/ClaraCrazy/Flipper-Xtreme#build-it-yourself) | [Discord](https://discord.gg/flipper-xtreme)
+[Intro](https://github.com/ClaraCrazy/Flipper-Xtreme#What-makes-it-special) | [Animations](https://github.com/ClaraCrazy/Flipper-Xtreme#Animations--Asset-Packs) | [Docs](https://github.com/ClaraCrazy/Flipper-Xtreme/wiki) | [Changelog](https://github.com/ClaraCrazy/Flipper-Xtreme#list-of-changes) | [Known bugs](https://github.com/ClaraCrazy/Flipper-Xtreme/issues?q=is%3Aissue+is%3Aopen+label%3Arelease-pending) | [Install](https://github.com/ClaraCrazy/Flipper-Xtreme#Install) | [Build](https://github.com/ClaraCrazy/Flipper-Xtreme#build-it-yourself) | [Discord](https://discord.gg/flipper-xtreme)
 -----

 This firmware is a complete overhaul of the [Official Firmware](https://github.com/flipperdevices/flipperzero-firmware), it also features lots of awesome code-bits from [Unleashed](https://github.com/DarkFlippers/unleashed-firmware).
@@ -147,14 +147,6 @@ Note: This repo is always updated with OFW & Unleashed. No need to mention all t
 - Tons of unused code from FAPs and system calls
 ```

----
-<br>
-<h2 align="center">Known Bugs:</h2>
-
-```txt
- Nothing rn. Hopefully that wont change
-```
-
 ----
 <br>
 <h2 align="center">Install:</h2>
@@ -83,6 +83,7 @@ static const DuckyKey ducky_keys[] = {
    {"ALT-SHIFT", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_SHIFT},
    {"ALT-GUI", KEY_MOD_LEFT_ALT | KEY_MOD_LEFT_GUI},
    {"GUI-SHIFT", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_SHIFT},
+    {"GUI-CTRL", KEY_MOD_LEFT_GUI | KEY_MOD_LEFT_CTRL},

    {"CTRL", KEY_MOD_LEFT_CTRL},
    {"CONTROL", KEY_MOD_LEFT_CTRL},
@@ -1,10 +1,24 @@
-![Flipper usage](https://user-images.githubusercontent.com/10090793/206618263-c1e212e4-58dc-432e-87a8-5c19fd835b35.png)  
+![Flipper usage](https://user-images.githubusercontent.com/10090793/211182642-e41919c5-3091-4125-815a-2d6a77a859f6.png)
 # Unitemp - Universal temperature sensor reader
 [![GitHub release](https://img.shields.io/github/release/quen0n/unitemp-flipperzero?include_prereleases=&sort=semver&color=blue)](https://github.com/quen0n/unitemp-flipperzero/releases/)
-[![GitHub all releases](https://img.shields.io/github/downloads/quen0n/unitemp-flipperzero/total)]()
-[![GitHub](https://img.shields.io/github/license/quen0n/unitemp-flipperzero)](https://github.com/quen0n/unitemp-flipperzero/blob/dev/LICENSE.md)  
-[Flipper Zero](https://flipperzero.one/) application for reading temperature, humidity and pressure sensors using Onewire, Singlewire, I2C protocols.   
-## List of supported sensors (supplemented)
-![image](https://user-images.githubusercontent.com/10090793/208480561-e98a6192-d44d-4ad9-8692-a91ccaae47c7.png)
+[![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
+![image](https://user-images.githubusercontent.com/10090793/215605424-54b1c08c-e41b-4fb4-b966-dd959507200b.png)
+
 ## Installation
-Copy the contents of the repository to the `applications/plugins/unitemp` folder and build the project. Flash FZ along with resources. [More...](https://github.com/flipperdevices/flipperzero-firmware/blob/dev/documentation/fbt.md)
+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
+## 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)
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -17,7 +17,6 @@
 */
 #include "Sensors.h"
 #include <furi_hal_power.h>
-#include <m-string.h>

 //Порты ввода/вывода, которые не были обозначены в общем списке
 const GpioPin SWC_10 = {.pin = LL_GPIO_PIN_14, .port = GPIOA};
@@ -67,12 +66,36 @@ const Interface ONE_WIRE = {
    .allocator = unitemp_onewire_sensor_alloc,
    .mem_releaser = unitemp_onewire_sensor_free,
    .updater = unitemp_onewire_sensor_update};
+const Interface SPI = {
+    .name = "SPI",
+    .allocator = unitemp_spi_sensor_alloc,
+    .mem_releaser = unitemp_spi_sensor_free,
+    .updater = unitemp_spi_sensor_update};

 //Перечень интерфейсов подключения
-//static const Interface* interfaces[] = {&SINGLE_WIRE, &I2C, &ONE_WIRE};
+//static const Interface* interfaces[] = {&SINGLE_WIRE, &I2C, &ONE_WIRE, &SPI};
 //Перечень датчиков
-static const SensorType* sensorTypes[] =
-    {&DHT11, &DHT12_SW, &DHT21, &DHT22, &AM2320_SW, &AM2320_I2C, &LM75, &BMP280, &BME280, &Dallas};
+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;
@@ -151,7 +174,7 @@ uint8_t unitemp_gpio_getAviablePortsCount(const Interface* interface, const GPIO
        }

        //Проверка для single wire
-        if(interface == &SINGLE_WIRE) {
+        if(interface == &SINGLE_WIRE || interface == &SPI) {
            if(gpio_interfaces_list[i] == NULL || (unitemp_gpio_getFromIndex(i) == extraport)) {
                aviable_ports_count++;
            }
@@ -190,6 +213,13 @@ const GPIO*
            return NULL;
        }
    }
+    if(interface == &SPI) {
+        if(!((gpio_interfaces_list[0] == NULL || gpio_interfaces_list[0] == &SPI) &&
+             (gpio_interfaces_list[1] == NULL || gpio_interfaces_list[1] == &SPI) &&
+             (gpio_interfaces_list[3] == NULL || gpio_interfaces_list[3] == &SPI))) {
+            return NULL;
+        }
+    }

    uint8_t aviable_index = 0;
    for(uint8_t i = 0; i < GPIO_ITEMS; i++) {
@@ -207,7 +237,7 @@ const GPIO*
            }
        }
        //Проверка для single wire
-        if(interface == &SINGLE_WIRE) {
+        if(interface == &SINGLE_WIRE || interface == &SPI) {
            if(gpio_interfaces_list[i] == NULL || unitemp_gpio_getFromIndex(i) == extraport) {
                if(aviable_index == index) {
                    return unitemp_gpio_getFromIndex(i);
@@ -268,9 +298,7 @@ void unitemp_sensors_add(Sensor* sensor) {
 }

 bool unitemp_sensors_load(void) {
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(APP_NAME, "Loading sensors...");
-#endif
+    UNITEMP_DEBUG("Loading sensors...");

    //Выделение памяти на поток
    app->file_stream = file_stream_alloc(app->storage);
@@ -331,7 +359,7 @@ bool unitemp_sensors_load(void) {
    //Сколько байт до конца строки
    size_t line_end = 0;

-    while(line_end != STRING_FAILURE && line_end != (size_t)(file_size - 1)) {
+    while(line_end != ((size_t)-1) && line_end != (size_t)(file_size - 1)) {
        //Имя датчика
        char name[11] = {0};
        //Тип датчика
@@ -379,9 +407,7 @@ bool unitemp_sensors_load(void) {
 }

 bool unitemp_sensors_save(void) {
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(APP_NAME, "Saving sensors...");
-#endif
+    UNITEMP_DEBUG("Saving sensors...");

    //Выделение памяти для потока
    app->file_stream = file_stream_alloc(app->storage);
@@ -424,6 +450,11 @@ bool unitemp_sensors_save(void) {
            stream_write_format(
                app->file_stream, "%d\n", unitemp_singlewire_sensorGetGPIO(sensor)->num);
        }
+        if(sensor->type->interface == &SPI) {
+            uint8_t gpio_num = ((SPISensor*)sensor->instance)->CS_pin->num;
+            stream_write_format(app->file_stream, "%d\n", gpio_num);
+        }
+
        if(sensor->type->interface == &I2C) {
            stream_write_format(
                app->file_stream, "%X\n", ((I2CSensor*)sensor->instance)->currentI2CAdr);
@@ -501,7 +532,7 @@ Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, char* args) {

    //Выход если датчик успешно развёрнут
    if(status) {
-        FURI_LOG_I(APP_NAME, "Sensor %s allocated", name);
+        UNITEMP_DEBUG("Sensor %s allocated", name);
        return sensor;
    }
    //Выход с очисткой если память для датчика не была выделена
@@ -527,17 +558,13 @@ void unitemp_sensor_free(Sensor* sensor) {
    bool status = false;
    //Высвобождение памяти под инстанс
    status = sensor->type->interface->mem_releaser(sensor);
-    UNUSED(status);
-#ifdef UNITEMP_DEBUG

    if(status) {
-        FURI_LOG_D(APP_NAME, "Sensor %s memory successfully released", sensor->name);
+        UNITEMP_DEBUG("Sensor %s memory successfully released", sensor->name);
    } else {
        FURI_LOG_E(APP_NAME, "Sensor %s memory is not released", sensor->name);
    }
-#endif
    free(sensor->name);
-    //free(sensor);
 }

 void unitemp_sensors_free(void) {
@@ -556,9 +583,7 @@ bool unitemp_sensors_init(void) {
        //Может пропасть при отключении USB
        if(furi_hal_power_is_otg_enabled() != true) {
            furi_hal_power_enable_otg();
-#ifdef UNITEMP_DEBUG
-            FURI_LOG_D(APP_NAME, "OTG enabled");
-#endif
+            UNITEMP_DEBUG("OTG enabled");
        }
        if(!(*app->sensors[i]->type->initializer)(app->sensors[i])) {
            FURI_LOG_E(
@@ -567,9 +592,7 @@ bool unitemp_sensors_init(void) {
                app->sensors[i]->name);
            result = false;
        }
-#ifdef UNITEMP_DEBUG
-        FURI_LOG_D(APP_NAME, "Sensor %s successfully initialized", app->sensors[i]->name);
-#endif
+        FURI_LOG_I(APP_NAME, "Sensor %s successfully initialized", app->sensors[i]->name);
    }
    app->sensors_ready = true;
    return result;
@@ -580,9 +603,7 @@ bool unitemp_sensors_deInit(void) {
    //Выключение 5 В если до этого оно не было включено
    if(app->settings.lastOTGState != true) {
        furi_hal_power_disable_otg();
-#ifdef UNITEMP_DEBUG
-        FURI_LOG_D(APP_NAME, "OTG disabled");
-#endif
+        UNITEMP_DEBUG("OTG disabled");
    }

    //Перебор датчиков из списка
@@ -618,13 +639,14 @@ UnitempStatus unitemp_sensor_updateData(Sensor* sensor) {

    sensor->status = sensor->type->interface->updater(sensor);

-#ifdef UNITEMP_DEBUG
-    if(sensor->status != UT_SENSORSTATUS_OK && sensor->status != UT_SENSORSTATUS_POLLING)
-        FURI_LOG_D(APP_NAME, "Sensor %s update status %d", sensor->name, sensor->status);
-#endif
+    if(sensor->status != UT_SENSORSTATUS_OK && sensor->status != UT_SENSORSTATUS_POLLING) {
+        UNITEMP_DEBUG("Sensor %s update status %d", sensor->name, sensor->status);
+    }

-    if(app->settings.temp_unit == UT_TEMP_FAHRENHEIT && sensor->status == UT_SENSORSTATUS_OK)
+    if(app->settings.temp_unit == UT_TEMP_FAHRENHEIT && sensor->status == UT_SENSORSTATUS_OK) {
        uintemp_celsiumToFarengate(sensor);
+    }
+
    if(sensor->status == UT_SENSORSTATUS_OK) {
        sensor->temp += sensor->temp_offset / 10.f;
        if(app->settings.pressure_unit == UT_PRESSURE_MM_HG) {
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -136,7 +136,7 @@ typedef struct Sensor {
 extern const Interface SINGLE_WIRE; //Собственный однопроводной протокол датчиков DHTXX и AM23XX
 extern const Interface ONE_WIRE; //Однопроводной протокол Dallas
 extern const Interface I2C; //I2C_2 (PC0, PC1)
-//extern const Interface SPI;
+extern const Interface SPI; //SPI_1 (MOSI - 2, MISO - 3, CS - 4, SCK - 5)

 /* ============================= Датчик(и) ============================= */
 /**
@@ -318,7 +318,15 @@ 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"
+#include "./sensors/BMP180.h"
+#include "./sensors/HTU21x.h"
+#include "./sensors/HDC1080.h"
+#include "./sensors/MAX31855.h"
+#include "./sensors/MAX6675.h"
 #endif
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -58,9 +58,7 @@ OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio) {
    bus->device_count = 0;
    bus->gpio = gpio;
    bus->powerMode = PWR_PASSIVE;
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(APP_NAME, "one wire bus (port %d) allocated", gpio->num);
-#endif
+    UNITEMP_DEBUG("one wire bus (port %d) allocated", gpio->num);

    return bus;
 }
@@ -84,9 +82,7 @@ bool unitemp_onewire_bus_init(OneWireBus* bus) {
    return true;
 }
 bool unitemp_onewire_bus_deinit(OneWireBus* bus) {
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(APP_NAME, "devices on wire %d: %d", bus->gpio->num, bus->device_count);
-#endif
+    UNITEMP_DEBUG("devices on wire %d: %d", bus->gpio->num, bus->device_count);
    bus->device_count--;
    if(bus->device_count <= 0) {
        bus->device_count = 0;
@@ -236,15 +232,11 @@ void unitemp_onewire_bus_enum_init(void) {
 uint8_t* unitemp_onewire_bus_enum_next(OneWireBus* bus) {
    furi_delay_ms(10);
    if(!onewire_enum_fork_bit) { // Если на предыдущем шаге уже не было разногласий
-#ifdef UNITEMP_DEBUG
-        FURI_LOG_D(APP_NAME, "All devices on wire %d is found", unitemp_gpio_toInt(bus->gpio));
-#endif
+        UNITEMP_DEBUG("All devices on wire %d is found", unitemp_gpio_toInt(bus->gpio));
        return 0; // то просто выходим ничего не возвращая
    }
    if(!unitemp_onewire_bus_start(bus)) {
-#ifdef UNITEMP_DEBUG
-        FURI_LOG_D(APP_NAME, "Wire %d is empty", unitemp_gpio_toInt(bus->gpio));
-#endif
+        UNITEMP_DEBUG("Wire %d is empty", unitemp_gpio_toInt(bus->gpio));
        return 0;
    }
    uint8_t bp = 8;
@@ -278,9 +270,8 @@ uint8_t* unitemp_onewire_bus_enum_next(OneWireBus* bus) {
            if(!not1) { // Присутствует единица
                next |= 0x80;
            } else { // Нет ни нулей ни единиц - ошибочная ситуация
-#ifdef UNITEMP_DEBUG
-                FURI_LOG_D(APP_NAME, "Wrong wire %d situation", unitemp_gpio_toInt(bus->gpio));
-#endif
+
+                UNITEMP_DEBUG("Wrong wire %d situation", unitemp_gpio_toInt(bus->gpio));
                return 0;
            }
        }
@@ -421,9 +412,7 @@ UnitempStatus unitemp_onewire_sensor_update(Sensor* sensor) {
            unitemp_onewire_bus_send_byte(instance->bus, 0xBE); // Read Scratch-pad
            unitemp_onewire_bus_read_byteArray(instance->bus, buff, 9);
            if(!unitemp_onewire_CRC_check(buff, 9)) {
-#ifdef UNITEMP_DEBUG
-                FURI_LOG_D(APP_NAME, "Sensor %s is not found", sensor->name);
-#endif
+                UNITEMP_DEBUG("Sensor %s is not found", sensor->name);
                return UT_SENSORSTATUS_TIMEOUT;
            }
        }
@@ -462,9 +451,7 @@ UnitempStatus unitemp_onewire_sensor_update(Sensor* sensor) {
        unitemp_onewire_bus_send_byte(instance->bus, 0xBE); // Read Scratch-pad
        unitemp_onewire_bus_read_byteArray(instance->bus, buff, 9);
        if(!unitemp_onewire_CRC_check(buff, 9)) {
-#ifdef UNITEMP_DEBUG
-            FURI_LOG_D(APP_NAME, "Failed CRC check: %s", sensor->name);
-#endif
+            UNITEMP_DEBUG("Failed CRC check: %s", sensor->name);
            return UT_SENSORSTATUS_BADCRC;
        }
        int16_t raw = buff[0] | ((int16_t)buff[1] << 8);
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -0,0 +1,89 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+
+#include <furi.h>
+#include <furi_hal.h>
+#include "SPISensor.h"
+
+static uint8_t sensors_count = 0;
+
+bool unitemp_spi_sensor_alloc(Sensor* sensor, char* args) {
+    if(args == NULL) return false;
+
+    //Создание инстанса датчика SPI
+    SPISensor* instance = malloc(sizeof(SPISensor));
+    if(instance == NULL) {
+        FURI_LOG_E(APP_NAME, "Sensor %s instance allocation error", sensor->name);
+        return false;
+    }
+    sensor->instance = instance;
+
+    //Определение GPIO chip select
+    int gpio = 255;
+    sscanf(args, "%d", &gpio);
+    instance->CS_pin = unitemp_gpio_getFromInt(gpio);
+    if(instance->CS_pin == NULL) {
+        FURI_LOG_E(APP_NAME, "Sensor %s GPIO setting error", sensor->name);
+        free(instance);
+        return false;
+    }
+
+    instance->spi = malloc(sizeof(FuriHalSpiBusHandle));
+    memcpy(instance->spi, &furi_hal_spi_bus_handle_external, sizeof(FuriHalSpiBusHandle));
+
+    instance->spi->cs = instance->CS_pin->pin;
+
+    bool status = sensor->type->allocator(sensor, args);
+
+    //Блокировка портов GPIO
+    sensors_count++;
+    unitemp_gpio_lock(unitemp_gpio_getFromInt(2), &SPI);
+    unitemp_gpio_lock(unitemp_gpio_getFromInt(3), &SPI);
+    unitemp_gpio_lock(unitemp_gpio_getFromInt(5), &SPI);
+    unitemp_gpio_lock(instance->CS_pin, &SPI);
+    return status;
+}
+
+bool unitemp_spi_sensor_free(Sensor* sensor) {
+    bool status = sensor->type->mem_releaser(sensor);
+    unitemp_gpio_unlock(((SPISensor*)sensor->instance)->CS_pin);
+    free(((SPISensor*)(sensor->instance))->spi);
+    free(sensor->instance);
+
+    if(--sensors_count == 0) {
+        unitemp_gpio_unlock(unitemp_gpio_getFromInt(2));
+        unitemp_gpio_unlock(unitemp_gpio_getFromInt(3));
+        unitemp_gpio_unlock(unitemp_gpio_getFromInt(5));
+    }
+
+    return status;
+}
+
+bool unitemp_spi_sensor_init(Sensor* sensor) {
+    return sensor->type->initializer(sensor);
+}
+
+bool unitemp_spi_sensor_deinit(Sensor* sensor) {
+    UNUSED(sensor);
+
+    return true;
+}
+
+UnitempStatus unitemp_spi_sensor_update(Sensor* sensor) {
+    return sensor->type->updater(sensor);
+}
@@ -0,0 +1,66 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_SPI
+#define UNITEMP_SPI
+
+#include "../unitemp.h"
+#include <furi_hal_spi.h>
+
+//Структура SPI датчика
+typedef struct SPISensor {
+    //Указатель на интерфейс SPI
+    FuriHalSpiBusHandle* spi;
+    //Порт подключения CS
+    const GPIO* CS_pin;
+} SPISensor;
+
+/**
+ * @brief Выделение памяти для датчика с интерфейсом SPI
+ * @param sensor Указатель на датчик
+ * @param args Указатель на массив аргументов с параметрами датчика
+ * @return Истина если всё ок
+ */
+bool unitemp_spi_sensor_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Высвобождение памяти инстанса датчика
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_spi_sensor_free(Sensor* sensor);
+
+/**
+ * @brief Инициализации датчика с интерфейсом one wire
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_spi_sensor_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_spi_sensor_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновить значение с датчка
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_spi_sensor_update(Sensor* sensor);
+
+#endif
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -43,7 +43,7 @@ const SensorType DHT12_SW = {
    .updater = unitemp_singlewire_update};
 const SensorType DHT21 = {
    .typename = "DHT21",
-    .altname = "DHT21 (AM2301)",
+    .altname = "DHT21/AM2301",
    .interface = &SINGLE_WIRE,
    .datatype = UT_DATA_TYPE_TEMP_HUM,
    .pollingInterval = 1000,
@@ -54,7 +54,7 @@ const SensorType DHT21 = {
    .updater = unitemp_singlewire_update};
 const SensorType DHT22 = {
    .typename = "DHT22",
-    .altname = "DHT22 (AM2302)",
+    .altname = "DHT22/AM2302",
    .interface = &SINGLE_WIRE,
    .datatype = UT_DATA_TYPE_TEMP_HUM,
    .pollingInterval = 2000,
@@ -262,7 +262,7 @@ UnitempStatus unitemp_singlewire_update(Sensor* sensor) {
        //Проверка на отрицательность температуры
        if(READ_BIT(raw, 1 << 15)) {
            //Проверка на способ кодирования данных
-            if(READ_BIT(raw, 0x60)) {
+            if(READ_BIT(raw, 0x6000)) {
                //Не оригинал
                sensor->temp = (float)((int16_t)raw) / 10;
            } else {
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -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 <https://www.gnu.org/licenses/>.
+*/
+#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;
+}
@@ -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 <https://www.gnu.org/licenses/>.
+*/
+#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
@@ -0,0 +1,172 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#include "BMP180.h"
+#include "../interfaces/I2CSensor.h"
+
+typedef struct {
+    int16_t AC1;
+    int16_t AC2;
+    int16_t AC3;
+    uint16_t AC4;
+    uint16_t AC5;
+    uint16_t AC6;
+    int16_t B1;
+    int16_t B2;
+    int16_t MB;
+    int16_t MC;
+    int16_t MD;
+} BMP180_cal;
+
+typedef struct {
+    //Калибровочные значения
+    BMP180_cal bmp180_cal;
+} BMP180_instance;
+
+const SensorType BMP180 = {
+    .typename = "BMP180",
+    .interface = &I2C,
+    .datatype = UT_TEMPERATURE | UT_PRESSURE,
+    .pollingInterval = 1000,
+    .allocator = unitemp_BMP180_I2C_alloc,
+    .mem_releaser = unitemp_BMP180_I2C_free,
+    .initializer = unitemp_BMP180_init,
+    .deinitializer = unitemp_BMP180_I2C_deinit,
+    .updater = unitemp_BMP180_I2C_update};
+
+bool unitemp_BMP180_I2C_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Адреса на шине I2C (7 бит)
+    i2c_sensor->minI2CAdr = 0x77 << 1;
+    i2c_sensor->maxI2CAdr = 0x77 << 1;
+
+    BMP180_instance* bmx280_instance = malloc(sizeof(BMP180_instance));
+    i2c_sensor->sensorInstance = bmx280_instance;
+    return true;
+}
+
+bool unitemp_BMP180_I2C_free(Sensor* sensor) {
+    UNUSED(sensor);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    free(i2c_sensor->sensorInstance);
+    return true;
+}
+
+bool unitemp_BMP180_init(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Перезагрузка
+    if(!unitemp_i2c_writeReg(i2c_sensor, 0xE0, 0xB6)) return false;
+    furi_delay_ms(100);
+
+    //Проверка ID
+    uint8_t id = unitemp_i2c_readReg(i2c_sensor, 0xD0);
+    if(id != 0x55) {
+        FURI_LOG_E(
+            APP_NAME, "Sensor %s returned wrong ID 0x%02X, expected 0x55", sensor->name, id);
+        return false;
+    }
+
+    BMP180_instance* bmp180_instance = i2c_sensor->sensorInstance;
+
+    uint8_t buff[22] = {0};
+
+    //Чтение калибровочных значений
+    if(!unitemp_i2c_readRegArray(i2c_sensor, 0xAA, 22, buff)) return false;
+    bmp180_instance->bmp180_cal.AC1 = (buff[0] << 8) | buff[1];
+    bmp180_instance->bmp180_cal.AC2 = (buff[2] << 8) | buff[3];
+    bmp180_instance->bmp180_cal.AC3 = (buff[4] << 8) | buff[5];
+    bmp180_instance->bmp180_cal.AC4 = (buff[6] << 8) | buff[7];
+    bmp180_instance->bmp180_cal.AC5 = (buff[8] << 8) | buff[9];
+    bmp180_instance->bmp180_cal.AC6 = (buff[10] << 8) | buff[11];
+    bmp180_instance->bmp180_cal.B1 = (buff[12] << 8) | buff[13];
+    bmp180_instance->bmp180_cal.B2 = (buff[14] << 8) | buff[15];
+    bmp180_instance->bmp180_cal.MB = (buff[16] << 8) | buff[17];
+    bmp180_instance->bmp180_cal.MC = (buff[18] << 8) | buff[19];
+    bmp180_instance->bmp180_cal.MD = (buff[20] << 8) | buff[21];
+
+
+UNITEMP_DEBUG(
+        "Sensor BMP180 (0x%02X) calibration values: %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d",
+        i2c_sensor->currentI2CAdr,
+        bmp180_instance->bmp180_cal.AC1,
+        bmp180_instance->bmp180_cal.AC2,
+        bmp180_instance->bmp180_cal.AC3,
+        bmp180_instance->bmp180_cal.AC4,
+        bmp180_instance->bmp180_cal.AC5,
+        bmp180_instance->bmp180_cal.AC6,
+        bmp180_instance->bmp180_cal.B1,
+        bmp180_instance->bmp180_cal.B2,
+        bmp180_instance->bmp180_cal.MB,
+        bmp180_instance->bmp180_cal.MC,
+        bmp180_instance->bmp180_cal.MD);
+    return true;
+}
+
+bool unitemp_BMP180_I2C_deinit(Sensor* sensor) {
+    //Нечего деинициализировать
+    UNUSED(sensor);
+    return true;
+}
+
+UnitempStatus unitemp_BMP180_I2C_update(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    BMP180_instance* bmp180_instance = i2c_sensor->sensorInstance;
+
+    //Чтение температуры
+    if(!unitemp_i2c_writeReg(i2c_sensor, 0xF4, 0x2E)) return UT_SENSORSTATUS_TIMEOUT;
+    furi_delay_ms(5);
+    uint8_t buff[3] = {0};
+    if(!unitemp_i2c_readRegArray(i2c_sensor, 0xF6, 2, buff)) return UT_SENSORSTATUS_TIMEOUT;
+    int32_t UT = ((uint16_t)buff[0] << 8) + buff[1];
+    int32_t X1 = (UT - bmp180_instance->bmp180_cal.AC6) * bmp180_instance->bmp180_cal.AC5 >> 15;
+    int32_t X2 = (bmp180_instance->bmp180_cal.MC << 11) / (X1 + bmp180_instance->bmp180_cal.MD);
+    int32_t B5 = X1 + X2;
+    sensor->temp = ((B5 + 8) / 16) * 0.1f;
+
+    //Чтение давления
+    if(!unitemp_i2c_writeReg(i2c_sensor, 0xF4, 0x34 + (0b11 << 6))) return UT_SENSORSTATUS_TIMEOUT;
+    furi_delay_ms(26);
+    if(!unitemp_i2c_readRegArray(i2c_sensor, 0xF6, 3, buff)) return UT_SENSORSTATUS_TIMEOUT;
+    uint32_t UP = ((buff[0] << 16) + (buff[1] << 8) + buff[2]) >> (8 - 0b11);
+
+    int32_t B6, X3, B3, P;
+    uint32_t B4, B7;
+    B6 = B5 - 4000;
+    X1 = (bmp180_instance->bmp180_cal.B2 * ((B6 * B6) >> 12)) >> 11;
+    X2 = (bmp180_instance->bmp180_cal.AC2 * B6) >> 11;
+    X3 = X1 + X2;
+    B3 = (((bmp180_instance->bmp180_cal.AC1 * 4 + X3) << 0b11) + 2) >> 2;
+    X1 = (bmp180_instance->bmp180_cal.AC3 * B6) >> 13;
+    X2 = (bmp180_instance->bmp180_cal.B1 * ((B6 * B6) >> 12)) >> 16;
+    X3 = ((X1 + X2) + 2) >> 2;
+    B4 = (bmp180_instance->bmp180_cal.AC4 * (unsigned long)(X3 + 32768)) >> 15;
+    B7 = ((unsigned long)UP - B3) * (50000 >> 0b11);
+    if(B7 < 0x80000000)
+        P = (B7 * 2) / B4;
+    else
+        P = (B7 / B4) * 2;
+    X1 = (P >> 8) * (P >> 8);
+    X1 = (X1 * 3038) >> 16;
+    X2 = (-7357 * (P)) >> 16;
+    P = P + ((X1 + X2 + 3791) >> 4);
+    sensor->pressure = P;
+
+    return UT_SENSORSTATUS_OK;
+}
@@ -0,0 +1,62 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_BMP180
+#define UNITEMP_BMP180
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+extern const SensorType BMP180;
+/**
+ * @brief Выделение памяти и установка начальных значений датчика BMP180
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_BMP180_I2C_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика BMP180
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_BMP180_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_BMP180_I2C_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_BMP180_I2C_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_BMP180_I2C_free(Sensor* sensor);
+
+#endif
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -180,22 +180,19 @@ static bool bmx280_readCalValues(I2CSensor* i2c_sensor) {
    if(!unitemp_i2c_readRegArray(
           i2c_sensor, TEMP_CAL_START_ADDR, 6, (uint8_t*)&bmx280_instance->temp_cal))
        return false;
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(
-        APP_NAME,
+
+    UNITEMP_DEBUG(
        "Sensor BMx280 (0x%02X) T1-T3: %d, %d, %d",
        i2c_sensor->currentI2CAdr,
        bmx280_instance->temp_cal.dig_T1,
        bmx280_instance->temp_cal.dig_T2,
        bmx280_instance->temp_cal.dig_T3);
-#endif

    if(!unitemp_i2c_readRegArray(
           i2c_sensor, PRESS_CAL_START_ADDR, 18, (uint8_t*)&bmx280_instance->press_cal))
        return false;
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(
-        APP_NAME,
+
+    UNITEMP_DEBUG(
        "Sensor BMx280 (0x%02X): P1-P9: %d, %d, %d, %d, %d, %d, %d, %d, %d",
        i2c_sensor->currentI2CAdr,
        bmx280_instance->press_cal.dig_P1,
@@ -207,7 +204,6 @@ static bool bmx280_readCalValues(I2CSensor* i2c_sensor) {
        bmx280_instance->press_cal.dig_P7,
        bmx280_instance->press_cal.dig_P8,
        bmx280_instance->press_cal.dig_P9);
-#endif

    if(bmx280_instance->chip_id == BME280_ID) {
        uint8_t buff[7] = {0};
@@ -221,9 +217,7 @@ static bool bmx280_readCalValues(I2CSensor* i2c_sensor) {
        bmx280_instance->hum_cal.dig_H5 = (buff[4] & 0x0F) | ((int16_t)buff[5] << 4);
        bmx280_instance->hum_cal.dig_H6 = buff[6];

-#ifdef UNITEMP_DEBUG
-        FURI_LOG_D(
-            APP_NAME,
+        UNITEMP_DEBUG(
            "Sensor BMx280 (0x%02X): H1-H6: %d, %d, %d, %d, %d, %d",
            i2c_sensor->currentI2CAdr,
            bmx280_instance->hum_cal.dig_H1,
@@ -232,7 +226,6 @@ static bool bmx280_readCalValues(I2CSensor* i2c_sensor) {
            bmx280_instance->hum_cal.dig_H4,
            bmx280_instance->hum_cal.dig_H5,
            bmx280_instance->hum_cal.dig_H6);
-#endif
    }

    bmx280_instance->last_cal_update_time = furi_get_tick();
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -0,0 +1,154 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#include "DHT20.h"
+#include "../interfaces/I2CSensor.h"
+
+const SensorType DHT20 = {
+    .typename = "DHT20",
+    .altname = "DHT20/AM2108/AHT20",
+    .interface = &I2C,
+    .datatype = UT_TEMPERATURE | UT_HUMIDITY,
+    .pollingInterval = 1000,
+    .allocator = unitemp_DHT20_I2C_alloc,
+    .mem_releaser = unitemp_DHT20_I2C_free,
+    .initializer = unitemp_DHT20_init,
+    .deinitializer = unitemp_DHT20_I2C_deinit,
+    .updater = unitemp_DHT20_I2C_update};
+const SensorType AHT10 = {
+    .typename = "AHT10",
+    .interface = &I2C,
+    .datatype = UT_TEMPERATURE | UT_HUMIDITY,
+    .pollingInterval = 1000,
+    .allocator = unitemp_DHT20_I2C_alloc,
+    .mem_releaser = unitemp_DHT20_I2C_free,
+    .initializer = unitemp_DHT20_init,
+    .deinitializer = unitemp_DHT20_I2C_deinit,
+    .updater = unitemp_DHT20_I2C_update};
+
+static uint8_t DHT20_get_status(I2CSensor* i2c_sensor) {
+    uint8_t status[1] = {0};
+    unitemp_i2c_readArray(i2c_sensor, 1, status);
+    return status[0];
+}
+
+static uint8_t DHT20_calc_CRC8(uint8_t* message, uint8_t Num) {
+    uint8_t i;
+    uint8_t byte;
+    uint8_t crc = 0xFF;
+    for(byte = 0; byte < Num; byte++) {
+        crc ^= (message[byte]);
+        for(i = 8; i > 0; --i) {
+            if(crc & 0x80)
+                crc = (crc << 1) ^ 0x31;
+            else
+                crc = (crc << 1);
+        }
+    }
+    return crc;
+}
+
+static void DHT20_reset_reg(I2CSensor* i2c_sensor, uint8_t addr) {
+    uint8_t data[3] = {addr, 0x00, 0x00};
+
+    unitemp_i2c_writeArray(i2c_sensor, 3, data);
+
+    furi_delay_ms(5);
+
+    unitemp_i2c_readArray(i2c_sensor, 3, data);
+
+    furi_delay_ms(10);
+
+    data[0] = 0xB0 | addr;
+    unitemp_i2c_writeArray(i2c_sensor, 3, data);
+}
+
+bool unitemp_DHT20_I2C_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Адреса на шине I2C (7 бит)
+    i2c_sensor->minI2CAdr = 0x38 << 1;
+    i2c_sensor->maxI2CAdr = (sensor->type == &DHT20) ? (0x38 << 1) : (0x39 << 1);
+    return true;
+}
+
+bool unitemp_DHT20_I2C_free(Sensor* sensor) {
+    //Нечего высвобождать, так как ничего не было выделено
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_DHT20_init(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    uint8_t data[3] = {0xA8, 0x00, 0x00};
+    if(!unitemp_i2c_writeArray(i2c_sensor, 3, data)) return false;
+    furi_delay_ms(10);
+    data[0] = (sensor->type == &DHT20) ? 0xBE : 0xE1;
+    data[1] = 0x08;
+    if(!unitemp_i2c_writeArray(i2c_sensor, 3, data)) return false;
+    furi_delay_ms(10);
+
+    return true;
+}
+
+bool unitemp_DHT20_I2C_deinit(Sensor* sensor) {
+    //Нечего деинициализировать
+    UNUSED(sensor);
+    return true;
+}
+
+UnitempStatus unitemp_DHT20_I2C_update(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    if(DHT20_get_status(i2c_sensor) != 0x18) {
+        DHT20_reset_reg(i2c_sensor, 0x1B);
+        DHT20_reset_reg(i2c_sensor, 0x1C);
+        DHT20_reset_reg(i2c_sensor, 0x1E);
+    }
+    furi_delay_ms(10);
+
+    uint8_t data[7] = {0xAC, 0x33, 0x00};
+    if(!unitemp_i2c_writeArray(i2c_sensor, 3, data)) return UT_SENSORSTATUS_TIMEOUT;
+    furi_delay_ms(80);
+    uint32_t t = furi_get_tick();
+    while(DHT20_get_status(i2c_sensor) == 0x80) {
+        if(furi_get_tick() - t > 10) return UT_SENSORSTATUS_TIMEOUT;
+    }
+
+    if(!unitemp_i2c_readArray(i2c_sensor, 7, data)) return UT_SENSORSTATUS_TIMEOUT;
+
+    if(DHT20_calc_CRC8(data, 6) != data[6]) {
+        return UT_SENSORSTATUS_BADCRC;
+    }
+    uint32_t RetuData = 0;
+    RetuData = (RetuData | data[1]) << 8;
+    RetuData = (RetuData | data[2]) << 8;
+    RetuData = (RetuData | data[3]);
+    RetuData = RetuData >> 4;
+    sensor->hum = RetuData * 100 * 10 / 1024.0f / 1024.0f / 10.0f;
+
+    RetuData = 0;
+    RetuData = (RetuData | data[3]) << 8;
+    RetuData = (RetuData | data[4]) << 8;
+    RetuData = (RetuData | data[5]);
+    RetuData = RetuData & 0xfffff;
+    sensor->temp = (RetuData * 200 * 10.0f / 1024.0f / 1024.0f - 500) / 10.0f;
+
+    return UT_SENSORSTATUS_OK;
+}
@@ -0,0 +1,63 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_DHT20
+#define UNITEMP_DHT20
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+extern const SensorType DHT20;
+extern const SensorType AHT10;
+/**
+ * @brief Выделение памяти и установка начальных значений датчика DHT20
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_DHT20_I2C_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика DHT20
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_DHT20_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_DHT20_I2C_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_DHT20_I2C_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_DHT20_I2C_free(Sensor* sensor);
+
+#endif
@@ -0,0 +1,94 @@
+/*
+    Unitemp - Universal temperature reader
+    Copyright (C) 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 <https://www.gnu.org/licenses/>.
+*/
+#include "HDC1080.h"
+#include "../interfaces/I2CSensor.h"
+
+const SensorType HDC1080 = {
+    .typename = "HDC1080",
+    .interface = &I2C,
+    .datatype = UT_DATA_TYPE_TEMP_HUM,
+    .pollingInterval = 250,
+    .allocator = unitemp_HDC1080_alloc,
+    .mem_releaser = unitemp_HDC1080_free,
+    .initializer = unitemp_HDC1080_init,
+    .deinitializer = unitemp_HDC1080_deinit,
+    .updater = unitemp_HDC1080_update};
+
+bool unitemp_HDC1080_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Адреса на шине I2C (7 бит)
+    i2c_sensor->minI2CAdr = 0x40 << 1;
+    i2c_sensor->maxI2CAdr = 0x40 << 1;
+    return true;
+}
+
+bool unitemp_HDC1080_free(Sensor* sensor) {
+    //Нечего высвобождать, так как ничего не было выделено
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_HDC1080_init(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    uint8_t data[2];
+    if(!unitemp_i2c_readRegArray(i2c_sensor, 0xFF, 2, data)) return UT_SENSORSTATUS_TIMEOUT;
+    uint16_t device_id = ((uint16_t)data[0] << 8) | data[1];
+    if(device_id != 0x1050) {
+        FURI_LOG_E(
+            APP_NAME,
+            "Sensor %s returned wrong ID 0x%02X, expected 0x1050",
+            sensor->name,
+            device_id);
+        return false;
+    }
+    data[0] = 0b0001000;
+    data[1] = 0;
+    //Установка режима работы и разрядности измерений
+    if(!unitemp_i2c_writeRegArray(i2c_sensor, 0x02, 2, data)) return UT_SENSORSTATUS_TIMEOUT;
+
+    return true;
+}
+
+bool unitemp_HDC1080_deinit(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    UNUSED(i2c_sensor);
+    return true;
+}
+
+UnitempStatus unitemp_HDC1080_update(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    uint8_t data[2] = {0};
+    //Запуск измерения
+    if(!unitemp_i2c_writeArray(i2c_sensor, 1, data)) return UT_SENSORSTATUS_TIMEOUT;
+    furi_delay_ms(10);
+    if(!unitemp_i2c_readArray(i2c_sensor, 2, data)) return UT_SENSORSTATUS_TIMEOUT;
+
+    sensor->temp = ((float)(((uint16_t)data[0] << 8) | data[1]) / 65536) * 165 - 40;
+
+    data[0] = 1;
+    if(!unitemp_i2c_writeArray(i2c_sensor, 1, data)) return UT_SENSORSTATUS_TIMEOUT;
+    furi_delay_ms(10);
+    if(!unitemp_i2c_readArray(i2c_sensor, 2, data)) return UT_SENSORSTATUS_TIMEOUT;
+    sensor->hum = ((float)(((uint16_t)data[0] << 8) | data[1]) / 65536) * 100;
+
+    return UT_SENSORSTATUS_OK;
+}
@@ -0,0 +1,62 @@
+/*
+    Unitemp - Universal temperature reader
+    Copyright (C) 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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_HDC1080
+#define UNITEMP_HDC1080
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+extern const SensorType HDC1080;
+/**
+ * @brief Выделение памяти и установка начальных значений датчика HDC1080
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_HDC1080_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика HDC1080
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_HDC1080_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_HDC1080_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_HDC1080_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_HDC1080_free(Sensor* sensor);
+
+#endif
@@ -0,0 +1,107 @@
+/*
+    Unitemp - Universal temperature reader
+    Copyright (C) 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 <https://www.gnu.org/licenses/>.
+*/
+#include "HTU21x.h"
+#include "../interfaces/I2CSensor.h"
+
+const SensorType HTU21x = {
+    .typename = "HTU21x",
+    .altname = "HTU21x/SI70xx/SHT2x",
+    .interface = &I2C,
+    .datatype = UT_DATA_TYPE_TEMP_HUM,
+    .pollingInterval = 250,
+    .allocator = unitemp_HTU21x_alloc,
+    .mem_releaser = unitemp_HTU21x_free,
+    .initializer = unitemp_HTU21x_init,
+    .deinitializer = unitemp_HTU21x_deinit,
+    .updater = unitemp_HTU21x_update};
+
+static uint8_t checkCRC(uint16_t data) {
+    for(uint8_t i = 0; i < 16; i++) {
+        if(data & 0x8000)
+            data = (data << 1) ^ 0x13100;
+        else
+            data <<= 1;
+    }
+    return (data >> 8);
+}
+
+bool unitemp_HTU21x_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Адреса на шине I2C (7 бит)
+    i2c_sensor->minI2CAdr = 0x40 << 1;
+    i2c_sensor->maxI2CAdr = 0x41 << 1;
+    return true;
+}
+
+bool unitemp_HTU21x_free(Sensor* sensor) {
+    //Нечего высвобождать, так как ничего не было выделено
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_HTU21x_init(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    UNUSED(i2c_sensor);
+    return true;
+}
+
+bool unitemp_HTU21x_deinit(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    UNUSED(i2c_sensor);
+    return true;
+}
+
+UnitempStatus unitemp_HTU21x_update(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Датчик может быть всего один, так что норм
+    static bool temp_hum = false;
+
+    uint8_t data[3];
+
+    if(sensor->status == UT_SENSORSTATUS_POLLING) {
+        if(!unitemp_i2c_readArray(i2c_sensor, 3, data)) return UT_SENSORSTATUS_TIMEOUT;
+
+        uint16_t raw = ((uint16_t)data[0] << 8) | data[1];
+        if(checkCRC(raw) != data[2]) return UT_SENSORSTATUS_BADCRC;
+
+        if(temp_hum) {
+            sensor->temp = (0.002681f * raw - 46.85f);
+        } else {
+            sensor->hum = ((0.001907 * (raw ^ 0x02)) - 6);
+        }
+        temp_hum = !temp_hum;
+        if(temp_hum) return UT_SENSORSTATUS_EARLYPOOL;
+        return UT_SENSORSTATUS_OK;
+    }
+
+    if(temp_hum) {
+        //Запрос температуры
+        data[0] = 0xF3;
+        if(!unitemp_i2c_writeArray(i2c_sensor, 1, data)) return UT_SENSORSTATUS_TIMEOUT;
+    } else {
+        //Запрос влажности
+        data[0] = 0xF5;
+        if(!unitemp_i2c_writeArray(i2c_sensor, 1, data)) return UT_SENSORSTATUS_TIMEOUT;
+    }
+
+    return UT_SENSORSTATUS_POLLING;
+}
@@ -0,0 +1,62 @@
+/*
+    Unitemp - Universal temperature reader
+    Copyright (C) 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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_HTU21x
+#define UNITEMP_HTU21x
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+extern const SensorType HTU21x;
+/**
+ * @brief Выделение памяти и установка начальных значений датчика HTU21x
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_HTU21x_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика HTU21x
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_HTU21x_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_HTU21x_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_HTU21x_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_HTU21x_free(Sensor* sensor);
+
+#endif
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -0,0 +1,93 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#include "MAX31855.h"
+
+const SensorType MAX31855 = {
+    .typename = "MAX31855",
+    .altname = "MAX31855 (Thermocouple)",
+    .interface = &SPI,
+    .datatype = UT_TEMPERATURE,
+    .pollingInterval = 500,
+    .allocator = unitemp_MAX31855_alloc,
+    .mem_releaser = unitemp_MAX31855_free,
+    .initializer = unitemp_MAX31855_init,
+    .deinitializer = unitemp_MAX31855_deinit,
+    .updater = unitemp_MAX31855_update};
+
+bool unitemp_MAX31855_alloc(Sensor* sensor, char* args) {
+    UNUSED(sensor);
+    UNUSED(args);
+    return true;
+}
+
+bool unitemp_MAX31855_free(Sensor* sensor) {
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_MAX31855_init(Sensor* sensor) {
+    SPISensor* instance = sensor->instance;
+    furi_hal_spi_bus_handle_init(instance->spi);
+    UNUSED(instance);
+    return true;
+}
+
+bool unitemp_MAX31855_deinit(Sensor* sensor) {
+    UNUSED(sensor);
+    return true;
+}
+
+UnitempStatus unitemp_MAX31855_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[4] = {0};
+
+    furi_hal_spi_bus_rx(instance->spi, buff, 4, 0xFF);
+    furi_hal_spi_release(instance->spi);
+
+    uint32_t raw = (buff[0] << 24) | (buff[1] << 16) | (buff[2] << 8) | buff[3];
+
+    if(raw == 0xFFFFFFFF || raw == 0) return UT_SENSORSTATUS_TIMEOUT;
+
+    //Определение состояния термопары
+    uint8_t state = raw & 0b111;
+    //Обрыв
+    if(state == 0x01) {
+        UNITEMP_DEBUG("%s has thermocouple open circuit", sensor->name);
+        return UT_SENSORSTATUS_ERROR;
+    }
+    //Короткое замыкание к земле
+    if(state == 0x02) {
+        UNITEMP_DEBUG("%s has thermocouple short to GND", sensor->name);
+        return UT_SENSORSTATUS_ERROR;
+    }
+    //Короткое замыкание к питанию
+    if(state == 0x04) {
+        UNITEMP_DEBUG("%s has thermocouple short to VCC", sensor->name);
+        return UT_SENSORSTATUS_ERROR;
+    }
+
+    raw = (raw >> 16) & 0xFFFC;
+
+    sensor->temp = (int16_t)(raw) / 16.0f;
+
+    return UT_SENSORSTATUS_OK;
+}
@@ -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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_MAX31855
+#define UNITEMP_MAX31855
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+#include "../interfaces/SPISensor.h"
+
+extern const SensorType MAX31855;
+
+/**
+ * @brief Выделение памяти и установка начальных значений датчика MAX31855
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_MAX31855_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика MAX31855
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_MAX31855_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_MAX31855_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_MAX31855_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_MAX31855_free(Sensor* sensor);
+
+#endif
@@ -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 <https://www.gnu.org/licenses/>.
+*/
+#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;
+}
@@ -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 <https://www.gnu.org/licenses/>.
+*/
+#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
@@ -0,0 +1,90 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#include "SHT30.h"
+#include "../interfaces/I2CSensor.h"
+
+const SensorType SHT30 = {
+    .typename = "SHT30",
+    .altname = "SHT30/31/35",
+    .interface = &I2C,
+    .datatype = UT_TEMPERATURE | UT_HUMIDITY,
+    .pollingInterval = 1000,
+    .allocator = unitemp_SHT30_I2C_alloc,
+    .mem_releaser = unitemp_SHT30_I2C_free,
+    .initializer = unitemp_SHT30_init,
+    .deinitializer = unitemp_SHT30_I2C_deinit,
+    .updater = unitemp_SHT30_I2C_update};
+const SensorType GXHT30 = {
+    .typename = "GXHT30",
+    .altname = "GXHT30/31/35",
+    .interface = &I2C,
+    .datatype = UT_TEMPERATURE | UT_HUMIDITY,
+    .pollingInterval = 1000,
+    .allocator = unitemp_SHT30_I2C_alloc,
+    .mem_releaser = unitemp_SHT30_I2C_free,
+    .initializer = unitemp_GXHT30_init,
+    .deinitializer = unitemp_SHT30_I2C_deinit,
+    .updater = unitemp_SHT30_I2C_update};
+
+bool unitemp_SHT30_I2C_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+
+    //Адреса на шине I2C (7 бит)
+    i2c_sensor->minI2CAdr = 0x44 << 1;
+    i2c_sensor->maxI2CAdr = 0x45 << 1;
+    return true;
+}
+
+bool unitemp_SHT30_I2C_free(Sensor* sensor) {
+    //Нечего высвобождать, так как ничего не было выделено
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_SHT30_init(Sensor* sensor) {
+    UNUSED(sensor);
+    return true;
+}
+
+bool unitemp_GXHT30_init(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    //Включение режима автоматического преобразования 2 раза в сек
+    uint8_t data[2] = {0x22, 0x36};
+    if(!unitemp_i2c_writeArray(i2c_sensor, 2, data)) return false;
+    return true;
+}
+
+bool unitemp_SHT30_I2C_deinit(Sensor* sensor) {
+    //Нечего деинициализировать
+    UNUSED(sensor);
+    return true;
+}
+
+UnitempStatus unitemp_SHT30_I2C_update(Sensor* sensor) {
+    I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
+    //Получение данных
+    uint8_t data[6] = {0xE0, 0x00};
+    if(!unitemp_i2c_writeArray(i2c_sensor, 2, data)) return UT_SENSORSTATUS_TIMEOUT;
+    if(!unitemp_i2c_readArray(i2c_sensor, 6, data)) return UT_SENSORSTATUS_TIMEOUT;
+
+    sensor->temp = -45 + 175 * (((uint16_t)(data[0] << 8) | data[1]) / 65535.0f);
+    sensor->hum = 100 * (((uint16_t)(data[3] << 8) | data[4]) / 65535.0f);
+
+    return UT_SENSORSTATUS_OK;
+}
@@ -0,0 +1,70 @@
+/*
+    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 <https://www.gnu.org/licenses/>.
+*/
+#ifndef UNITEMP_SHT30
+#define UNITEMP_SHT30
+
+#include "../unitemp.h"
+#include "../Sensors.h"
+extern const SensorType SHT30;
+extern const SensorType GXHT30;
+/**
+ * @brief Выделение памяти и установка начальных значений датчика SHT30
+ *
+ * @param sensor Указатель на создаваемый датчик
+ * @return Истина при успехе
+ */
+bool unitemp_SHT30_I2C_alloc(Sensor* sensor, char* args);
+
+/**
+ * @brief Инициализации датчика SHT30
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_SHT30_init(Sensor* sensor);
+/**
+ * @brief Инициализации датчика GXHT30
+ *
+ * @param sensor Указатель на датчик
+ * @return Истина если инициализация упспешная
+ */
+bool unitemp_GXHT30_init(Sensor* sensor);
+
+/**
+ * @brief Деинициализация датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_SHT30_I2C_deinit(Sensor* sensor);
+
+/**
+ * @brief Обновление значений из датчика
+ *
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
+ */
+UnitempStatus unitemp_SHT30_I2C_update(Sensor* sensor);
+
+/**
+ * @brief Высвободить память датчика
+ *
+ * @param sensor Указатель на датчик
+ */
+bool unitemp_SHT30_I2C_free(Sensor* sensor);
+
+#endif
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -21,7 +21,6 @@
 #include "./views/UnitempViews.h"

 #include <furi_hal_power.h>
-#include <m-string.h>

 /* Переменные */
 //Данные приложения
@@ -79,9 +78,7 @@ bool unitemp_saveSettings(void) {
 }

 bool unitemp_loadSettings(void) {
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(APP_NAME, "Loading settings...");
-#endif
+    UNITEMP_DEBUG("Loading settings...");

    //Выделение памяти на поток
    app->file_stream = file_stream_alloc(app->storage);
@@ -147,7 +144,7 @@ bool unitemp_loadSettings(void) {
    //Сколько байт до конца строки
    size_t line_end = 0;

-    while(line_end != STRING_FAILURE && line_end != (size_t)(file_size - 1)) {
+    while(line_end != ((size_t)-1) && line_end != (size_t)(file_size - 1)) {
        char buff[20] = {0};
        sscanf(((char*)(file_buf + line_end)), "%s", buff);

@@ -236,6 +233,8 @@ static bool unitemp_alloc(void) {
 */
 static void unitemp_free(void) {
    popup_free(app->popup);
+    //Удаление вида после обработки
+    view_dispatcher_remove_view(app->view_dispatcher, UnitempViewPopup);
    unitemp_widgets_free();

    unitemp_SensorActions_free();
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -39,19 +39,25 @@
 /* Объявление макроподстановок */
 //Имя приложения
 #define APP_NAME "Unitemp"
+//Версия приложения
+#define UNITEMP_APP_VER "1.2"
 //Путь хранения файлов плагина
 #define APP_PATH_FOLDER "/ext/unitemp"
 //Имя файла с настройками
 #define APP_FILENAME_SETTINGS "settings.cfg"
 //Имя файла с датчиками
 #define APP_FILENAME_SENSORS "sensors.cfg"
-//Версия приложения
-#define UNITEMP_APP_VER "1.0"

 //Размер буффера текста
 #define BUFF_SIZE 32

-#define UNITEMP_DEBUG
+#define UNITEMP_D
+
+#ifdef FURI_DEBUG
+#define UNITEMP_DEBUG(msg, ...) FURI_LOG_D(APP_NAME, msg, ##__VA_ARGS__)
+#else
+#define UNITEMP_DEBUG(msg, ...)
+#endif

 /* Объявление перечислений */
 //Единицы измерения температуры
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -18,7 +18,9 @@
 #include "UnitempViews.h"
 #include "unitemp_icons.h"

-#include <assets_icons.h>
+extern const Icon I_ButtonRight_4x7;
+extern const Icon I_ButtonLeft_4x7;
+extern const Icon I_Ok_btn_9x9;

 static View* view;

@@ -74,7 +76,7 @@ static void _draw_temperature(Canvas* canvas, Sensor* sensor, uint8_t x, uint8_t
        app->buff[0] = '-';
        offset = 1;
    }
-    snprintf((char*)(app->buff + offset), BUFF_SIZE, "%d", (int8_t)sensor->temp);
+    snprintf((char*)(app->buff + offset), BUFF_SIZE, "%d", (int16_t)sensor->temp);
    canvas_set_font(canvas, FontBigNumbers);
    canvas_draw_str_aligned(
        canvas,
@@ -235,6 +237,7 @@ static void _draw_carousel_values(Canvas* canvas) {
        canvas_draw_icon(canvas, 34, 23, frames[furi_get_tick() % 2250 / 750]);

        canvas_set_font(canvas, FontSecondary);
+        //TODO: Оптимизировать эту срань
        if(unitemp_sensor_getActive(generalview_sensor_index)->type->interface == &SINGLE_WIRE) {
            snprintf(
                app->buff,
@@ -254,6 +257,9 @@ static void _draw_carousel_values(Canvas* canvas) {
        if(unitemp_sensor_getActive(generalview_sensor_index)->type->interface == &I2C) {
            snprintf(app->buff, BUFF_SIZE, "Waiting for module on I2C pins");
        }
+        if(unitemp_sensor_getActive(generalview_sensor_index)->type->interface == &SPI) {
+            snprintf(app->buff, BUFF_SIZE, "Waiting for module on SPI pins");
+        }
        canvas_draw_str_aligned(canvas, 64, 19, AlignCenter, AlignCenter, app->buff);
        return;
    }
@@ -302,6 +308,8 @@ static void _draw_carousel_values(Canvas* canvas) {
        break;
    }
 }
+
+//TODO: Оптимизировать вывод информации
 static void _draw_carousel_info(Canvas* canvas) {
    canvas_set_font(canvas, FontPrimary);
    canvas_draw_str(canvas, 10, 23, "Type:");
@@ -349,6 +357,25 @@ static void _draw_carousel_info(Canvas* canvas) {
                ->gpio->name);
    }

+    if(unitemp_sensor_getActive(generalview_sensor_index)->type->interface == &SPI) {
+        canvas_set_font(canvas, FontPrimary);
+        canvas_draw_str(canvas, 10, 35, "MISO pin:");
+        canvas_draw_str(canvas, 10, 46, "CS pin:");
+        canvas_draw_str(canvas, 10, 58, "SCK pin:");
+
+        canvas_set_font(canvas, FontSecondary);
+        canvas_draw_str(
+            canvas, 41, 23, unitemp_sensor_getActive(generalview_sensor_index)->type->typename);
+        canvas_draw_str(canvas, 60, 35, unitemp_gpio_getFromInt(3)->name);
+        canvas_draw_str(
+            canvas,
+            47,
+            46,
+            ((SPISensor*)unitemp_sensor_getActive(generalview_sensor_index)->instance)
+                ->CS_pin->name);
+        canvas_draw_str(canvas, 54, 58, unitemp_gpio_getFromInt(5)->name);
+    }
+
    if(unitemp_sensor_getActive(generalview_sensor_index)->type->interface == &I2C) {
        canvas_set_font(canvas, FontPrimary);
        canvas_draw_str(canvas, 10, 35, "I2C addr:");
@@ -362,7 +389,8 @@ static void _draw_carousel_info(Canvas* canvas) {
            BUFF_SIZE,
            "0x%02X",
            ((I2CSensor*)unitemp_sensor_getActive(generalview_sensor_index)->instance)
-                ->currentI2CAdr);
+                    ->currentI2CAdr >>
+                1);
        canvas_draw_str(canvas, 57, 35, app->buff);
        canvas_draw_str(canvas, 54, 46, "15 (C0)");
        canvas_draw_str(canvas, 54, 58, "16 (C1)");
@@ -539,6 +567,10 @@ static bool _input_callback(InputEvent* event, void* context) {
            return true;
        }
    }
+    //Обработка длинного нажатия "Ок"
+    if(event->key == InputKeyOk && event->type == InputTypeLong) {
+        app->settings.temp_unit = !app->settings.temp_unit;
+    }

    return true;
 }
@@ -558,5 +590,6 @@ void unitemp_General_switch(void) {
 }

 void unitemp_General_free(void) {
+    view_dispatcher_remove_view(app->view_dispatcher, UnitempViewGeneral);
    view_free(view);
 }
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -18,7 +18,6 @@
 #include "UnitempViews.h"
 #include <gui/modules/variable_item_list.h>
 #include <stdio.h>
-#include <assets_icons.h>

 uint32_t _prev_view_id;

@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -63,13 +63,9 @@ bool _onewire_id_exist(uint8_t* id) {

 static void _onewire_scan(void) {
    OneWireSensor* ow_sensor = editable_sensor->instance;
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(
-        APP_NAME,
-        "devices on wire %d: %d",
-        ow_sensor->bus->gpio->num,
-        ow_sensor->bus->device_count);
-#endif
+
+    UNITEMP_DEBUG(
+        "devices on wire %d: %d", ow_sensor->bus->gpio->num, ow_sensor->bus->device_count);

    //Сканирование шины one wire
    unitemp_onewire_bus_init(ow_sensor->bus);
@@ -101,9 +97,8 @@ static void _onewire_scan(void) {

    memcpy(ow_sensor->deviceID, id, 8);
    ow_sensor->familyCode = id[0];
-#ifdef UNITEMP_DEBUG
-    FURI_LOG_D(
-        APP_NAME,
+
+    UNITEMP_DEBUG(
        "Found sensor's ID: %02X%02X%02X%02X%02X%02X%02X%02X",
        id[0],
        id[1],
@@ -113,7 +108,6 @@ static void _onewire_scan(void) {
        id[5],
        id[6],
        id[7]);
-#endif

    if(ow_sensor->familyCode != 0) {
        char id_buff[10];
@@ -199,6 +193,12 @@ static void _gpio_change_callback(VariableItem* item) {
            unitemp_gpio_getAviablePort(editable_sensor->type->interface, index, initial_gpio);
        variable_item_set_current_value_text(item, instance->gpio->name);
    }
+    if(editable_sensor->type->interface == &SPI) {
+        SPISensor* instance = editable_sensor->instance;
+        instance->CS_pin =
+            unitemp_gpio_getAviablePort(editable_sensor->type->interface, index, initial_gpio);
+        variable_item_set_current_value_text(item, instance->CS_pin->name);
+    }
    if(editable_sensor->type->interface == &ONE_WIRE) {
        OneWireSensor* instance = editable_sensor->instance;
        instance->bus->gpio =
@@ -214,9 +214,9 @@ static void _gpio_change_callback(VariableItem* item) {
 static void _i2caddr_change_callback(VariableItem* item) {
    uint8_t index = variable_item_get_current_value_index(item);
    ((I2CSensor*)editable_sensor->instance)->currentI2CAdr =
-        ((I2CSensor*)editable_sensor->instance)->minI2CAdr + index;
+        ((I2CSensor*)editable_sensor->instance)->minI2CAdr + index * 2;
    char buff[5];
-    snprintf(buff, 5, "0x%2X", ((I2CSensor*)editable_sensor->instance)->currentI2CAdr);
+    snprintf(buff, 5, "0x%2X", ((I2CSensor*)editable_sensor->instance)->currentI2CAdr >> 1);
    variable_item_set_current_value_text(item, buff);
 }
 /**
@@ -302,12 +302,15 @@ void unitemp_SensorEdit_switch(Sensor* sensor) {
        offset_buff, OFFSET_BUFF_SIZE, "%+1.1f", (double)(editable_sensor->temp_offset / 10.0));
    variable_item_set_current_value_text(temp_offset_item, offset_buff);

-    //Порт подключения датчка (для one wire и single wire)
-    if(sensor->type->interface == &ONE_WIRE || sensor->type->interface == &SINGLE_WIRE) {
+    //Порт подключения датчка (для one wire, SPI и single wire)
+    if(sensor->type->interface == &ONE_WIRE || sensor->type->interface == &SINGLE_WIRE ||
+       sensor->type->interface == &SPI) {
        if(sensor->type->interface == &ONE_WIRE) {
            initial_gpio = ((OneWireSensor*)editable_sensor->instance)->bus->gpio;
-        } else {
+        } else if(sensor->type->interface == &SINGLE_WIRE) {
            initial_gpio = ((SingleWireSensor*)editable_sensor->instance)->gpio;
+        } else if(sensor->type->interface == &SPI) {
+            initial_gpio = ((SPISensor*)editable_sensor->instance)->CS_pin;
        }

        uint8_t aviable_gpio_count =
@@ -335,11 +338,15 @@ void unitemp_SensorEdit_switch(Sensor* sensor) {
        VariableItem* item = variable_item_list_add(
            variable_item_list,
            "I2C address",
-            ((I2CSensor*)sensor->instance)->maxI2CAdr - ((I2CSensor*)sensor->instance)->minI2CAdr +
-                1,
+            (((I2CSensor*)sensor->instance)->maxI2CAdr >> 1) -
+                (((I2CSensor*)sensor->instance)->minI2CAdr >> 1) + 1,
            _i2caddr_change_callback,
            app);
-        snprintf(app->buff, 5, "0x%2X", ((I2CSensor*)sensor->instance)->currentI2CAdr);
+        snprintf(app->buff, 5, "0x%2X", ((I2CSensor*)sensor->instance)->currentI2CAdr >> 1);
+        variable_item_set_current_value_index(
+            item,
+            (((I2CSensor*)sensor->instance)->currentI2CAdr >> 1) -
+                (((I2CSensor*)sensor->instance)->minI2CAdr >> 1));
        variable_item_set_current_value_text(item, app->buff);
    }

@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -42,5 +42,6 @@ void unitemp_SensorNameEdit_switch(Sensor* sensor) {
    view_dispatcher_switch_to_view(app->view_dispatcher, VIEW_ID);
 }
 void unitemp_SensorNameEdit_free(void) {
+    view_dispatcher_remove_view(app->view_dispatcher, VIEW_ID);
    text_input_free(text_input);
 }
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -18,7 +18,8 @@
 #include "UnitempViews.h"
 #include <gui/modules/variable_item_list.h>
 #include <stdio.h>
-#include <assets_icons.h>
+
+extern const Icon I_Cry_dolph_55x52;

 //Текущий вид
 static View* view;
@@ -85,8 +86,8 @@ static void _enter_callback(void* context, uint32_t index) {
        return;
    }

-    //Выбор первого доступного порта для датчика single wire
-    if(type->interface == &SINGLE_WIRE) {
+    //Выбор первого доступного порта для датчика single wire и SPI
+    if(type->interface == &SINGLE_WIRE || type->interface == &SPI) {
        snprintf(
            args,
            4,
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -1,6 +1,6 @@
 /*
    Unitemp - Universal temperature reader
-    Copyright (C) 2022  Victor Nikitchuk (https://github.com/quen0n)
+    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
@@ -18,7 +18,7 @@
 #include "UnitempViews.h"
 #include "unitemp_icons.h"

-#include <assets_icons.h>
+extern const Icon I_DolphinCommon_56x48;

 void unitemp_widgets_alloc(void) {
    app->widget = widget_alloc();
@@ -27,6 +27,7 @@ void unitemp_widgets_alloc(void) {
 }

 void unitemp_widgets_free(void) {
+    view_dispatcher_remove_view(app->view_dispatcher, UnitempViewWidget);
    widget_free(app->widget);
 }

@@ -132,7 +133,7 @@ void unitemp_widget_delete_switch(Sensor* sensor) {
            app->buff,
            BUFF_SIZE,
            "\e#I2C addr:\e# 0x%02X",
-            ((I2CSensor*)current_sensor->instance)->currentI2CAdr);
+            ((I2CSensor*)current_sensor->instance)->currentI2CAdr >> 1);
        widget_add_text_box_element(
            app->widget, 0, 28, 128, 23, AlignLeft, AlignTop, app->buff, false);
    }
@@ -1,5 +1,6 @@
 #include <furi.h>
 #include <furi_hal.h>
+#include <stm32_adafruit_sd.h>

 #include <cli/cli.h>
 #include <lib/toolbox/args.h>
@@ -60,17 +61,28 @@ static void storage_cli_info(Cli* cli, FuriString* path) {
        }
    } else if(furi_string_cmp_str(path, STORAGE_EXT_PATH_PREFIX) == 0) {
        SDInfo sd_info;
+        SD_CID sd_cid;
        FS_Error error = storage_sd_info(api, &sd_info);
+        BSP_SD_GetCIDRegister(&sd_cid);

        if(error != FSE_OK) {
            storage_cli_print_error(error);
        } else {
            printf(
-                "Label: %s\r\nType: %s\r\n%luKiB total\r\n%luKiB free\r\n",
+                "Label: %s\r\nType: %s\r\n%luKiB total\r\n%luKiB free\r\n"
+                "%02x%2.2s %5.5s %i.%i\r\nSN:%04lx %02i/%i\r\n",
                sd_info.label,
                sd_api_get_fs_type_text(sd_info.fs_type),
                sd_info.kb_total,
-                sd_info.kb_free);
+                sd_info.kb_free,
+                sd_cid.ManufacturerID,
+                sd_cid.OEM_AppliID,
+                sd_cid.ProdName,
+                sd_cid.ProdRev >> 4,
+                sd_cid.ProdRev & 0xf,
+                sd_cid.ProdSN,
+                sd_cid.ManufactMonth,
+                sd_cid.ManufactYear + 2000);
        }
    } else {
        storage_cli_print_usage();
@@ -1,4 +1,5 @@
 #include "../storage_settings.h"
+#include <stm32_adafruit_sd.h>

 static void storage_settings_scene_sd_info_dialog_callback(DialogExResult result, void* context) {
    StorageSettings* app = context;
@@ -11,7 +12,10 @@ void storage_settings_scene_sd_info_on_enter(void* context) {
    DialogEx* dialog_ex = app->dialog_ex;

    SDInfo sd_info;
+    SD_CID sd_cid;
    FS_Error sd_status = storage_sd_info(app->fs_api, &sd_info);
+    BSP_SD_GetCIDRegister(&sd_cid);
+
    scene_manager_set_scene_state(app->scene_manager, StorageSettingsSDInfo, sd_status);

    dialog_ex_set_context(dialog_ex, app);
@@ -24,47 +28,24 @@ void storage_settings_scene_sd_info_on_enter(void* context) {
            dialog_ex, "Try to reinsert\nor format SD\ncard.", 3, 19, AlignLeft, AlignTop);
        dialog_ex_set_center_button_text(dialog_ex, "Ok");
    } else {
-        char unit_kb[] = "KB";
-        char unit_mb[] = "MB";
-        char unit_gb[] = "GB";
-
-        double sd_total_val = (double)sd_info.kb_total;
-        char* sd_total_unit = unit_kb;
-        double sd_free_val = (double)sd_info.kb_free;
-        char* sd_free_unit = unit_kb;
-
-        if(sd_total_val > 1024) {
-            sd_total_val /= 1024;
-            sd_total_unit = unit_mb;
-        }
-        if(sd_total_val > 1024) {
-            sd_total_val /= 1024;
-            sd_total_unit = unit_gb;
-        }
-
-        if(sd_free_val > 1024) {
-            sd_free_val /= 1024;
-            sd_free_unit = unit_mb;
-        }
-        if(sd_free_val > 1024) {
-            sd_free_val /= 1024;
-            sd_free_unit = unit_gb;
-        }
-
        furi_string_printf(
            app->text_string,
-            "Label: %s\nType: %s\n%.2f %s total\n%.2f %s free\n%.2f%% free",
-
+            "Label: %s\nType: %s\n%lu KiB total\n%lu KiB free\n"
+            "%02X%2.2s %5.5s %i.%i\nSN:%04lX %02i/%i",
            sd_info.label,
            sd_api_get_fs_type_text(sd_info.fs_type),
-            sd_total_val,
-            sd_total_unit,
-            sd_free_val,
-            sd_free_unit,
-            (double)(((int)sd_info.kb_free * 100.0) / (int)sd_info.kb_total));
-
+            sd_info.kb_total,
+            sd_info.kb_free,
+            sd_cid.ManufacturerID,
+            sd_cid.OEM_AppliID,
+            sd_cid.ProdName,
+            sd_cid.ProdRev >> 4,
+            sd_cid.ProdRev & 0xf,
+            sd_cid.ProdSN,
+            sd_cid.ManufactMonth,
+            sd_cid.ManufactYear + 2000);
        dialog_ex_set_text(
-            dialog_ex, furi_string_get_cstr(app->text_string), 4, 4, AlignLeft, AlignTop);
+            dialog_ex, furi_string_get_cstr(app->text_string), 4, 1, AlignLeft, AlignTop);
    }

    view_dispatcher_switch_to_view(app->view_dispatcher, StorageSettingsViewDialogEx);
@@ -101,4 +82,4 @@ void storage_settings_scene_sd_info_on_exit(void* context) {
    dialog_ex_reset(dialog_ex);

    furi_string_reset(app->text_string);
-}
+}
@@ -1557,6 +1557,7 @@ Function,+,furi_thread_get_name,const char*,FuriThreadId
 Function,+,furi_thread_get_return_code,int32_t,FuriThread*
 Function,+,furi_thread_get_stack_space,uint32_t,FuriThreadId
 Function,+,furi_thread_get_state,FuriThreadState,FuriThread*
+Function,+,furi_thread_get_stdout_callback,FuriThreadStdoutWriteCallback,
 Function,+,furi_thread_is_suspended,_Bool,FuriThreadId
 Function,+,furi_thread_join,_Bool,FuriThread*
 Function,+,furi_thread_mark_as_service,void,FuriThread*
@@ -779,25 +779,10 @@ uint8_t SD_GetCIDRegister(SD_CID* Cid) {
            Cid->ManufacturerID = CID_Tab[0];

            /* Byte 1 */
-            Cid->OEM_AppliID = CID_Tab[1] << 8;
-
-            /* Byte 2 */
-            Cid->OEM_AppliID |= CID_Tab[2];
+            memcpy(Cid->OEM_AppliID, CID_Tab + 1, 2);

            /* Byte 3 */
-            Cid->ProdName1 = CID_Tab[3] << 24;
-
-            /* Byte 4 */
-            Cid->ProdName1 |= CID_Tab[4] << 16;
-
-            /* Byte 5 */
-            Cid->ProdName1 |= CID_Tab[5] << 8;
-
-            /* Byte 6 */
-            Cid->ProdName1 |= CID_Tab[6];
-
-            /* Byte 7 */
-            Cid->ProdName2 = CID_Tab[7];
+            memcpy(Cid->ProdName, CID_Tab + 3, 5);

            /* Byte 8 */
            Cid->ProdRev = CID_Tab[8];
@@ -815,11 +800,12 @@ uint8_t SD_GetCIDRegister(SD_CID* Cid) {
            Cid->ProdSN |= CID_Tab[12];

            /* Byte 13 */
-            Cid->Reserved1 |= (CID_Tab[13] & 0xF0) >> 4;
-            Cid->ManufactDate = (CID_Tab[13] & 0x0F) << 8;
+            Cid->Reserved1 = (CID_Tab[13] & 0xF0) >> 4;
+            Cid->ManufactYear = (CID_Tab[13] & 0x0F) << 4;

            /* Byte 14 */
-            Cid->ManufactDate |= CID_Tab[14];
+            Cid->ManufactYear |= (CID_Tab[14] & 0xF0) >> 4;
+            Cid->ManufactMonth = (CID_Tab[14] & 0x0F);

            /* Byte 15 */
            Cid->CID_CRC = (CID_Tab[15] & 0xFE) >> 1;
@@ -837,6 +823,21 @@ uint8_t SD_GetCIDRegister(SD_CID* Cid) {
    return retr;
 }

+uint8_t BSP_SD_GetCIDRegister(SD_CID* Cid) {
+    uint8_t retr = BSP_SD_ERROR;
+
+    /* Slow speed init */
+    furi_hal_spi_acquire(&furi_hal_spi_bus_handle_sd_slow);
+    furi_hal_sd_spi_handle = &furi_hal_spi_bus_handle_sd_slow;
+
+    memset(Cid, 0, sizeof(SD_CID));
+    retr = SD_GetCIDRegister(Cid);
+
+    furi_hal_sd_spi_handle = NULL;
+    furi_hal_spi_release(&furi_hal_spi_bus_handle_sd_slow);
+    return retr;
+}
+
 /**
  * @brief  Sends 5 bytes command to the SD card and get response
  * @param  Cmd: The user expected command to send to SD card.
@@ -133,16 +133,16 @@ typedef struct {
  * @brief  Card Identification Data: CID Register   
  */
 typedef struct {
-    __IO uint8_t ManufacturerID; /* ManufacturerID */
-    __IO uint16_t OEM_AppliID; /* OEM/Application ID */
-    __IO uint32_t ProdName1; /* Product Name part1 */
-    __IO uint8_t ProdName2; /* Product Name part2*/
-    __IO uint8_t ProdRev; /* Product Revision */
-    __IO uint32_t ProdSN; /* Product Serial Number */
-    __IO uint8_t Reserved1; /* Reserved1 */
-    __IO uint16_t ManufactDate; /* Manufacturing Date */
-    __IO uint8_t CID_CRC; /* CID CRC */
-    __IO uint8_t Reserved2; /* always 1 */
+    uint8_t ManufacturerID; /* ManufacturerID */
+    char OEM_AppliID[2]; /* OEM/Application ID */
+    char ProdName[5]; /* Product Name */
+    uint8_t ProdRev; /* Product Revision */
+    uint32_t ProdSN; /* Product Serial Number */
+    uint8_t Reserved1; /* Reserved1 */
+    uint8_t ManufactYear; /* Manufacturing Year */
+    uint8_t ManufactMonth; /* Manufacturing Month */
+    uint8_t CID_CRC; /* CID CRC */
+    uint8_t Reserved2; /* always 1 */
 } SD_CID;

 /** 
@@ -207,6 +207,7 @@ uint8_t
 uint8_t BSP_SD_Erase(uint32_t StartAddr, uint32_t EndAddr);
 uint8_t BSP_SD_GetCardState(void);
 uint8_t BSP_SD_GetCardInfo(SD_CardInfo* pCardInfo);
+uint8_t BSP_SD_GetCIDRegister(SD_CID* Cid);

 /* Link functions for SD Card peripheral*/
 void SD_SPI_Slow_Init(void);
@@ -530,6 +530,12 @@ bool furi_thread_set_stdout_callback(FuriThreadStdoutWriteCallback callback) {
    return true;
 }

+FuriThreadStdoutWriteCallback furi_thread_get_stdout_callback() {
+    FuriThread* thread = furi_thread_get_current();
+
+    return thread->output.write_callback;
+}
+
 size_t furi_thread_stdout_write(const char* data, size_t size) {
    FuriThread* thread = furi_thread_get_current();

@@ -227,6 +227,12 @@ const char* furi_thread_get_name(FuriThreadId thread_id);

 uint32_t furi_thread_get_stack_space(FuriThreadId thread_id);

+/** Get STDOUT callback for thead
+ *
+ * @return STDOUT callback
+ */
+FuriThreadStdoutWriteCallback furi_thread_get_stdout_callback();
+
 /** Set STDOUT callback for thread
 * 
 * @param      callback  callback or NULL to clear