Big refactoring

Sensors.c

@@ -1,9 +1,4 @@
 #include "Sensors.h"
-#include "./interfaces/SingleWireSensor.h"
-#include "./interfaces/I2CSensor.h"
-#include "./sensors/SensorsDriver.h"
-#include "./interfaces/OneWireSensor.h"
-
 #include <furi_hal_power.h>
 
 //Порты ввода/вывода, которые не были обозначены в общем списке
@@ -41,9 +36,9 @@ static const Interface* gpio_interfaces_list[GPIO_ITEMS] = {0};
 
 const Interface SINGLE_WIRE = {
     .name = "Single wire",
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .updater = unitemp_singleWire_update};
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .updater = unitemp_singlewire_update};
 const Interface I2C = {
     .name = "I2C",
     .allocator = unitemp_I2C_sensor_alloc,
@@ -51,9 +46,9 @@ const Interface I2C = {
     .updater = unitemp_I2C_sensor_update};
 const Interface ONE_WIRE = {
     .name = "One wire",
-    .allocator = unitemp_OneWire_sensor_alloc,
-    .mem_releaser = unitemp_OneWire_sensor_free,
-    .updater = unitemp_OneWire_sensor_update};
+    .allocator = unitemp_onewire_sensor_alloc,
+    .mem_releaser = unitemp_onewire_sensor_free,
+    .updater = unitemp_onewire_sensor_update};
 
 //Перечень интерфейсов подключения
 //static const Interface* interfaces[] = {&SINGLE_WIRE, &I2C, &ONE_WIRE};
@@ -61,15 +56,15 @@ const Interface ONE_WIRE = {
 static const SensorType* sensorTypes[] =
     {&DHT11, &DHT12_SW, &DHT21, &DHT22, &AM2320_SW, &LM75, &BMP280, &DS18x2x};
 
-const SensorType* unitemp_getTypeFromInt(int type) {
-    if(type > SENSOR_TYPES_COUNT) return NULL;
-    return sensorTypes[type];
+const SensorType* unitemp_sensors_getTypeFromInt(uint8_t index) {
+    if(index > SENSOR_TYPES_COUNT) return NULL;
+    return sensorTypes[index];
 }
 
-uint8_t unitemp_getSensorsTypesCount(void) {
+uint8_t unitemp_sensors_getTypesCount(void) {
     return SENSOR_TYPES_COUNT;
 }
-const SensorType** unitemp_getSensorsTypes(void) {
+const SensorType** unitemp_sensors_getTypes(void) {
     return sensorTypes;
 }
 
@@ -81,7 +76,7 @@ int unitemp_getIntFromType(const SensorType* type) {
     }
     return 255;
 }
-const GPIO* unitemp_GPIO_getFromInt(uint8_t name) {
+const GPIO* unitemp_gpio_getFromInt(uint8_t name) {
     for(uint8_t i = 0; i < GPIO_ITEMS; i++) {
         if(GPIOList[i].num == name) {
             return &GPIOList[i];
@@ -94,10 +89,10 @@ const GPIO* unitemp_gpio_getFromIndex(uint8_t index) {
     return &GPIOList[index];
 }
 
-uint8_t unitemp_GPIO_toInt(const GpioPin* gpio) {
+uint8_t unitemp_gpio_toInt(const GPIO* gpio) {
     if(gpio == NULL) return 255;
     for(uint8_t i = 0; i < GPIO_ITEMS; i++) {
-        if(GPIOList[i].pin->pin == gpio->pin && GPIOList[i].pin->port == gpio->port) {
+        if(GPIOList[i].pin->pin == gpio->pin->pin && GPIOList[i].pin->port == gpio->pin->port) {
             return GPIOList[i].num;
         }
     }
@@ -248,16 +243,17 @@ bool unitemp_sensors_load() {
     char* line = strtok((char*)file_buf, "\n");
     while(line != NULL) {
         char name[11] = {0};
-        int type = 255, otherValue = 255;
-        sscanf(line, "%s %d %d", name, &type, &otherValue);
+        int type = 255, arg = 255;
+        sscanf(line, "%s %d %d", name, &type, &arg);
         //Ограничение длины имени
         name[10] = '\0';
-        FURI_LOG_D(APP_NAME, "%s %d %d", name, type, otherValue);
+        FURI_LOG_D(APP_NAME, "%s %d %d", name, type, arg);
 
-        uint8_t otherValues[] = {otherValue};
+        char args[] = {arg};
         //Проверка типа датчика
         if(type < SENSOR_TYPES_COUNT && sizeof(name) <= 11) {
-            Sensor* sensor = unitemp_sensor_alloc(name, unitemp_getTypeFromInt(type), otherValues);
+            Sensor* sensor =
+                unitemp_sensor_alloc(name, unitemp_sensors_getTypeFromInt(type), args);
             if(sensor != NULL) {
                 app->sensors[app->sensors_count++] = sensor;
             }
@@ -309,7 +305,7 @@ bool unitemp_sensors_save(void) {
                 "%s %d %d\n",
                 app->sensors[i]->name,
                 unitemp_getIntFromType(app->sensors[i]->type),
-                unitemp_GPIO_toInt(unitemp_singleWire_sensorGetGPIO(app->sensors[i])->pin));
+                unitemp_gpio_toInt(unitemp_singlewire_sensorGetGPIO(app->sensors[i])));
         }
         if(app->sensors[i]->type->interface == &I2C) {
             stream_write_format(
@@ -336,7 +332,7 @@ void unitemp_sensors_reload(void) {
     unitemp_sensors_init();
 }
 
-Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, uint8_t* anotherValues) {
+Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, char* args) {
     bool status = false;
     //Выделение памяти под датчик
     Sensor* sensor = malloc(sizeof(Sensor));
@@ -365,7 +361,7 @@ Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, uint8_t* anothe
     sensor->hum = -128.0f;
 
     //Выделение памяти под инстанс датчика в зависимости от его интерфейса
-    status = sensor->type->interface->allocator(sensor, anotherValues);
+    status = sensor->type->interface->allocator(sensor, args);
 
     //Выход если датчик успешно развёрнут
     if(status) {

Sensors.h

@@ -19,11 +19,13 @@ typedef struct GPIO {
     const char* name;
     const GpioPin* pin;
 } GPIO;
+
 typedef struct Sensor Sensor;
+
 /**
  * @brief Указатель функции выделения памяти и подготовки экземпляра датчика
  */
-typedef bool(SensorAllocator)(Sensor* sensor, uint8_t* anotherValues);
+typedef bool(SensorAllocator)(Sensor* sensor, char* args);
 /**
  * @brief Указатель на функцию высвобождении памяти датчика
  */
@@ -43,11 +45,13 @@ typedef UnitempStatus(SensorUpdater)(Sensor* sensor);
 
 //Типы подключения датчиков
 typedef struct Interface {
+    //Имя интерфейса
     const char* name;
+    //Функция выделения памяти интерфейса
     SensorAllocator* allocator;
-    //Функция высвыбождения памяти для датчика
+    //Функция высвыбождения памяти интерфейса
     SensorFree* mem_releaser;
-    //Функция обновления значения датчка
+    //Функция обновления значения датчика по интерфейсу
     SensorUpdater* updater;
 } Interface;
 
@@ -88,7 +92,6 @@ typedef struct Sensor {
     uint32_t lastPollingTime;
     //Экземпляр датчика
     void* instance;
-
 } Sensor;
 
 extern const Interface SINGLE_WIRE; //Собственный однопроводной протокол датчиков DHTXX и AM23XX
@@ -96,108 +99,134 @@ extern const Interface ONE_WIRE; //Однопроводной протокол D
 extern const Interface I2C; //I2C_2 (PC0, PC1)
 //extern const Interface SPI;
 
+/* ============================= Датчик(и) ============================= */
 /**
-* @brief Получить количество доступных типов датчиков
-* @return Количество доступных типов датчиков
-*/
-uint8_t unitemp_getSensorsTypesCount(void);
+ * @brief Выделение памяти под датчик
+ * 
+ * @param name Имя датчика
+ * @param type Тип датчика
+ * @param args Указатель на строку с парамерами датчика
+ * @return Указатель на датчик в случае успешного выделения памяти, NULL при ошибке
+ */
+Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, char* args);
 
 /**
-* @brief Получить списк доступных типов датчиков
-* @return Указатель на список датчиков
-*/
-const SensorType** unitemp_getSensorsTypes(void);
+ * @brief Высвыбождение памяти конкретного датчка
+ * @param sensor Указатель на датчик
+ */
+void unitemp_sensor_free(Sensor* sensor);
 
 /**
- * @brief Конвертация номера порта на корпусе FZ в GPIO 
- * 
- * @param name Номер порта на корпусе FZ
- * @return Указатель на GPIO при успехе, NULL при ошибке
+ * @brief Обновление данных указанного датчика
+ * @param sensor Указатель на датчик
+ * @return Статус опроса датчика
  */
-const GPIO* unitemp_GPIO_getFromInt(uint8_t name);
+UnitempStatus unitemp_sensor_updateData(Sensor* sensor);
 
 /**
- * @brief Конвертация GPIO в номер на корпусе FZ
- * 
- * @param gpio Указатель на порт
- * @return Номер порта на корпусе FZ
+ * @brief Загрузка датчиков с SD-карты
+ * @return Истина если загрузка прошла успешно
  */
-uint8_t unitemp_GPIO_toInt(const GpioPin* gpio);
+bool unitemp_sensors_load();
 
 /**
- * @brief Выделение памяти под датчик
- * 
- * @param name Имя датчика
- * @param st Тип датчика
- * @param anotherValues Массив других различных значений
- * @return Указатель на датчик
+ * @brief Функция перезагрузки датчиков с SD-карты
+*/
+void unitemp_sensors_reload(void);
+
+/**
+ * @brief Сохранение настроек на SD-карту
+ * @return Истина если сохранение прошло успешно
  */
-Sensor* unitemp_sensor_alloc(char* name, const SensorType* type, uint8_t* anotherValues);
+bool unitemp_sensors_save(void);
 
 /**
  * @brief Инициализация загруженных датчиков
- * 
  * @return Истина если всё прошло успешно
  */
 bool unitemp_sensors_init(void);
 
 /**
  * @brief Деинициализация загруженных датчиков
- * 
  * @return Истина если всё прошло успешно
  */
 bool unitemp_sensors_deInit(void);
 
 /**
- * @brief Получение данных указанного датчика
- * 
- * @param sensor Указатель на датчик
- * @return Статус опроса датчика
+ * @brief Высвыбождение памяти всех датчиков
  */
-UnitempStatus unitemp_sensor_updateData(Sensor* sensor);
+void unitemp_sensors_free(void);
 
 /**
- * @brief Функция загрузки датчиков с SD-карты
- * 
- * @return Истина если загрузка прошла успешно
+ * @brief Обновить данные всех датчиков
  */
-bool unitemp_sensors_load();
+void unitemp_sensors_updateValues(void);
 
 /**
- * @brief Функция перезагрузки датчиков с SD-карты
+* @brief Получить количество доступных типов датчиков
+* @return Количество доступных типов датчиков
 */
-void unitemp_sensors_reload(void);
+uint8_t unitemp_sensors_getTypesCount(void);
+
 /**
- * @brief Сохранение настроек на SD-карту
+ * @brief Получить тип сенсора по его индексу
  * 
- * @return Истина если сохранение прошло успешно
+ * @param index Индекс типа датчика (от 0 до SENSOR_TYPES_COUNT)
+ * @return const SensorType* 
  */
-bool unitemp_sensors_save(void);
+const SensorType* unitemp_sensors_getTypeFromInt(uint8_t index);
 
 /**
- * @brief Обновить данные со всех датчиков
- */
-void unitemp_sensors_updateValues(void);
+* @brief Получить списк доступных типов датчиков
+* @return Указатель на список датчиков
+*/
+const SensorType** unitemp_sensors_getTypes(void);
 
+/* ============================= GPIO ============================= */
 /**
- * @brief Высвыбождение памяти после датчиков
+ * @brief Конвертация номера порта на корпусе FZ в GPIO 
+ * @param name Номер порта на корпусе FZ
+ * @return Указатель на GPIO при успехе, NULL при ошибке
  */
-void unitemp_sensors_free(void);
-
+const GPIO* unitemp_gpio_getFromInt(uint8_t name);
 /**
- * @brief Высвыбождение памяти конкретного датчка
- * 
- * @param sensor Указатель на датчик
+ * @brief Конвертация GPIO в номер на корпусе FZ
+ * @param gpio Указатель на порт
+ * @return Номер порта на корпусе FZ
  */
-void unitemp_sensor_free(Sensor* sensor);
-
-const SensorType* unitemp_getTypeFromInt(int type);
-
-uint8_t unitemp_gpio_getAviablePortsCount(const Interface* interface);
+uint8_t unitemp_gpio_toInt(const GPIO* gpio);
 
+/**
+ * @brief Блокировка GPIO указанным интерфейсом
+ * @param gpio Указатель на порт
+ * @param interface Указатель на интерфейс, которым порт будет занят
+ */
 void unitemp_gpio_lock(const GPIO* gpio, const Interface* interface);
 
+/**
+ * @brief Разблокировка порта
+ * @param gpio Указатель на порт
+ */
 void unitemp_gpio_unlock(const GPIO* gpio);
-
+/**
+ * @brief Получить количество доступных портов для указанного интерфейса
+ * @param interface Указатель на интерфейс
+ * @return Количество доступных портов
+ */
+uint8_t unitemp_gpio_getAviablePortsCount(const Interface* interface);
+/**
+ * @brief Получить указатель на доступный для интерфейса порт по индексу 
+ * @param interface Указатель на интерфейс
+ * @param index Номер порта (от 0 до unitemp_gpio_getAviablePortsCount())
+ * @return Указатель на доступный порт
+ */
 const GPIO* unitemp_gpio_getAviablePort(const Interface* interface, uint8_t index);
-#endif
+
+/* Датчики */
+//DHTxx и их производные
+#include "./interfaces/SingleWireSensor.h"
+//DS18x2x
+#include "./interfaces/OneWireSensor.h"
+#include "./sensors/LM75.h"
+#include "./sensors/BMP280.h"
+#endif

interfaces/I2CSensor.c

@@ -1,9 +1,8 @@
 #include "I2CSensor.h"
-#include "../sensors/SensorsDriver.h"
 
 static uint8_t sensors_count = 0;
 
-uint8_t readReg(I2CSensor* i2c_sensor, uint8_t reg) {
+uint8_t unitemp_i2c_readReg(I2CSensor* i2c_sensor, uint8_t reg) {
     //Блокировка шины
     furi_hal_i2c_acquire(i2c_sensor->i2c);
     uint8_t buff[1];
@@ -12,14 +11,15 @@ uint8_t readReg(I2CSensor* i2c_sensor, uint8_t reg) {
     return buff[0];
 }
 
-bool readRegArray(I2CSensor* i2c_sensor, uint8_t startReg, uint8_t len, uint8_t* data) {
+bool unitemp_i2c_readRegArray(I2CSensor* i2c_sensor, uint8_t startReg, uint8_t len, uint8_t* data) {
     furi_hal_i2c_acquire(i2c_sensor->i2c);
     bool status = furi_hal_i2c_read_mem(
         i2c_sensor->i2c, i2c_sensor->currentI2CAdr << 1, startReg, data, len, 0xFF);
     furi_hal_i2c_release(i2c_sensor->i2c);
     return status;
 }
-bool writeReg(I2CSensor* i2c_sensor, uint8_t reg, uint8_t value) {
+
+bool unitemp_i2c_writeReg(I2CSensor* i2c_sensor, uint8_t reg, uint8_t value) {
     //Блокировка шины
     furi_hal_i2c_acquire(i2c_sensor->i2c);
     uint8_t buff[1] = {value};
@@ -29,7 +29,7 @@ bool writeReg(I2CSensor* i2c_sensor, uint8_t reg, uint8_t value) {
     return status;
 }
 
-bool unitemp_I2C_sensor_alloc(Sensor* sensor, uint8_t* anotherValues) {
+bool unitemp_I2C_sensor_alloc(Sensor* sensor, char* args) {
     bool status = false;
     I2CSensor* instance = malloc(sizeof(I2CSensor));
     if(instance == NULL) {
@@ -40,19 +40,19 @@ bool unitemp_I2C_sensor_alloc(Sensor* sensor, uint8_t* anotherValues) {
     sensor->instance = instance;
 
     //Указание функций инициализации, деинициализации и обновления данных, а так же адреса на шине I2C
-    status = sensor->type->allocator(sensor, anotherValues);
+    status = sensor->type->allocator(sensor, args);
 
     //Установка адреса шины I2C
-    if(anotherValues[0] >= instance->minI2CAdr && anotherValues[0] <= instance->maxI2CAdr) {
-        instance->currentI2CAdr = anotherValues[0];
+    if(args[0] >= instance->minI2CAdr && args[0] <= instance->maxI2CAdr) {
+        instance->currentI2CAdr = args[0];
     } else {
         instance->currentI2CAdr = instance->minI2CAdr;
     }
 
     //Блокировка портов GPIO
     sensors_count++;
-    unitemp_gpio_lock(unitemp_GPIO_getFromInt(15), &I2C);
-    unitemp_gpio_lock(unitemp_GPIO_getFromInt(16), &I2C);
+    unitemp_gpio_lock(unitemp_gpio_getFromInt(15), &I2C);
+    unitemp_gpio_lock(unitemp_gpio_getFromInt(16), &I2C);
 
     return status;
 }
@@ -61,8 +61,8 @@ bool unitemp_I2C_sensor_free(Sensor* sensor) {
     bool status = sensor->type->mem_releaser(sensor);
     free(sensor->instance);
     if(--sensors_count == 0) {
-        unitemp_gpio_unlock(unitemp_GPIO_getFromInt(15));
-        unitemp_gpio_unlock(unitemp_GPIO_getFromInt(16));
+        unitemp_gpio_unlock(unitemp_gpio_getFromInt(15));
+        unitemp_gpio_unlock(unitemp_gpio_getFromInt(16));
     }
 
     return status;

interfaces/I2CSensor.h

@@ -5,6 +5,7 @@
 
 #include <furi_hal_i2c.h>
 
+//Структура I2C датчика
 typedef struct I2CSensor {
     //Указатель на интерфейс I2C
     FuriHalI2cBusHandle* i2c;
@@ -16,60 +17,53 @@ typedef struct I2CSensor {
     uint8_t currentI2CAdr;
     //Указатель на собственный экземпляр датчика
     void* sensorInstance;
-
 } I2CSensor;
 
 /**
  * @brief Выделение памяти для датчика на шине I2C
- *
  * @param sensor Указатель на датчик
  * @param st Тип датчика
  * @return Истина если всё ок
  */
-bool unitemp_I2C_sensor_alloc(Sensor* sensor, uint8_t* anotherValues);
+bool unitemp_I2C_sensor_alloc(Sensor* sensor, char* args);
 
 /**
  * @brief Высвобождение памяти инстанса датчика
- * 
  * @param sensor Указатель на датчик
  */
 bool unitemp_I2C_sensor_free(Sensor* sensor);
 
 /**
  * @brief Обновить значение с датчка
- * 
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  * @return Статус обновления
  */
 UnitempStatus unitemp_I2C_sensor_update(Sensor* sensor);
 /**
  * @brief Прочитать значение регистра reg
- *
- * @param i2c_sensor Указатель на датчик
+ * @param i2c_sensor Указатель на инстанс датчика
  * @param reg Номер регистра
  * @return Значение регистра
  */
-uint8_t readReg(I2CSensor* i2c_sensor, uint8_t reg);
+uint8_t unitemp_i2c_readReg(I2CSensor* i2c_sensor, uint8_t reg);
 
 /**
  * @brief Прочитать масссив значений из памяти
- *
- * @param i2c_sensor
- * @param startReg
- * @param len
- * @param data
+ * @param i2c_sensor Указатель на инстанс датчика
+ * @param startReg Адрес регистра с которого начнётся чтение
+ * @param len Количество байт для считывания из регистра
+ * @param data Указатель на массив куда будут считаны данные
  * @return Истина если устройство вернуло данные
  */
-bool readRegArray(I2CSensor* i2c_sensor, uint8_t startReg, uint8_t len, uint8_t* data);
+bool unitemp_i2c_readRegArray(I2CSensor* i2c_sensor, uint8_t startReg, uint8_t len, uint8_t* data);
 
 /**
  * @brief Записать значение в регистр
- *
- * @param i2c_sensor Указатель на датчик
+ * @param i2c_sensor Указатель на инстанс датчика
  * @param reg Номер регистра
  * @param value Значение для записи
  * @return Истина если значение записано
  */
-bool writeReg(I2CSensor* i2c_sensor, uint8_t reg, uint8_t value);
+bool unitemp_i2c_writeReg(I2CSensor* i2c_sensor, uint8_t reg, uint8_t value);
 
 #endif

interfaces/OneWireSensor.c

@@ -1,4 +1,4 @@
-//Использован код Погребняка Дмитрия: https://aterlux.ru/article/1wire
+//Использован код Дмитрия Погребняка: https://aterlux.ru/article/1wire
 
 #include "OneWireSensor.h"
 #include <furi.h>
@@ -9,11 +9,15 @@ const SensorType DS18x2x = {
     .typename = "DS18x2x",
     .interface = &ONE_WIRE,
     .pollingInterval = 250,
-    .allocator = unitemp_OneWire_sensor_alloc,
-    .mem_releaser = unitemp_OneWire_sensor_free,
-    .initializer = unitemp_OneWire_sensor_init,
-    .deinitializer = unitemp_OneWire_sensor_deinit,
-    .updater = unitemp_OneWire_sensor_update};
+    .allocator = unitemp_onewire_sensor_alloc,
+    .mem_releaser = unitemp_onewire_sensor_free,
+    .initializer = unitemp_onewire_sensor_init,
+    .deinitializer = unitemp_onewire_sensor_deinit,
+    .updater = unitemp_onewire_sensor_update};
+
+// Переменные для хранения промежуточного результата поиска
+uint8_t onewire_enum[8]; // найденный восьмибайтовый адрес
+uint8_t onewire_enum_fork_bit; // последний нулевой бит, где была неоднозначность (нумеруя с единицы)
 
 OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio) {
     if(gpio == NULL) {
@@ -34,7 +38,7 @@ OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio) {
     bus->gpio = gpio;
     bus->powerMode = PWR_ACTIVE;
 
-    FURI_LOG_D(APP_NAME, "One wire bus (port %d) allocated", unitemp_GPIO_toInt(gpio->pin));
+    FURI_LOG_D(APP_NAME, "one wire bus (port %d) allocated", unitemp_gpio_toInt(gpio));
 
     return bus;
 }
@@ -93,7 +97,7 @@ bool unitemp_onewire_bus_start(OneWireBus* bus) {
     return status;
 }
 
-static void oneWire_send_bit(OneWireBus* bus, bool state) {
+void unitemp_onewire_send_bit(OneWireBus* bus, bool state) {
     if(state) {
         // write 1
         furi_hal_gpio_write(bus->gpio->pin, false);
@@ -108,30 +112,24 @@ static void oneWire_send_bit(OneWireBus* bus, bool state) {
         uint32_t t = furi_get_tick();
         while(!furi_hal_gpio_read(bus->gpio->pin)) {
             //Выход если шина не поднялась
-            if(furi_get_tick() - t > 100) return;
+            if(furi_get_tick() - t > 10) return;
         }
     }
 }
 
-/**
- * @brief Запись байта на шину One Wire
- * 
- * @param instance Указатель на инстанс датчика
- * @param data Записываемый байт
- */
-static void oneWire_write(OneWireBus* bus, uint8_t data) {
+void unitemp_onewire_send_byte(OneWireBus* bus, uint8_t data) {
     for(int i = 0; i < 8; i++) {
-        oneWire_send_bit(bus, (data & (1 << i)) != 0);
+        unitemp_onewire_send_bit(bus, (data & (1 << i)) != 0);
     }
 }
 
-/**
- * @brief Чтение бита на шине One Wire
- * 
- * @param bus Указатель на шину one wire
- * @return Логический уровень бита
- */
-static bool oneWire_read_bit(OneWireBus* bus) {
+void unitemp_onewire_send_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len) {
+    for(uint8_t i = 0; i < len; i++) {
+        unitemp_onewire_send_byte(bus, data[i]);
+    }
+}
+
+bool unitemp_onewire_read_bit(OneWireBus* bus) {
     furi_hal_gpio_write(bus->gpio->pin, false);
     furi_delay_us(2); // Длительность низкого уровня, минимум 1 мкс
     furi_hal_gpio_write(bus->gpio->pin, true);
@@ -141,34 +139,22 @@ static bool oneWire_read_bit(OneWireBus* bus) {
     return r;
 }
 
-/**
- * @brief Чтение байта с шины One Wire
- * 
- * @param bus Указатель на шину one wire
- * @return Байт информации
- */
-static uint8_t oneWire_read(OneWireBus* bus) {
+uint8_t unitemp_onewire_read_byte(OneWireBus* bus) {
     uint8_t r = 0;
     for(uint8_t p = 8; p; p--) {
         r >>= 1;
-        if(oneWire_read_bit(bus)) r |= 0x80;
+        if(unitemp_onewire_read_bit(bus)) r |= 0x80;
     }
     return r;
 }
-/**
- * @brief Чтение массива байт с шины One Wire
- * 
- * @param instance Указатель на инстанс датчика
- * @param data Указатель на массив, куда будут записаны данные
- * @param len Количество байт
- */
-static void oneWire_readBytes(OneWireBus* bus, uint8_t* data, uint8_t len) {
+
+void unitemp_onewire_read_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len) {
     for(uint8_t i = 0; i < len; i++) {
-        data[i] = oneWire_read(bus);
+        data[i] = unitemp_onewire_read_byte(bus);
     }
 }
 
-static uint8_t onewire_CRC_update(uint8_t crc, uint8_t b) {
+uint8_t onewire_CRC_update(uint8_t crc, uint8_t b) {
     for(uint8_t p = 8; p; p--) {
         crc = ((crc ^ b) & 1) ? (crc >> 1) ^ 0b10001100 : (crc >> 1);
         b >>= 1;
@@ -176,7 +162,7 @@ static uint8_t onewire_CRC_update(uint8_t crc, uint8_t b) {
     return crc;
 }
 
-static bool onewire_CRC_check(uint8_t* data, uint8_t len) {
+bool unitemp_onewire_CRC_check(uint8_t* data, uint8_t len) {
     uint8_t crc = 0;
     for(uint8_t i = 0; i < len; i++) {
         crc = onewire_CRC_update(crc, data[i]);
@@ -184,30 +170,11 @@ static bool onewire_CRC_check(uint8_t* data, uint8_t len) {
     return !crc;
 }
 
-/**
- * @brief Запись массива байт на шину One Wire
- * 
- * @param instance Указатель на инстанс датчика
- * @param data Указатель на массив, откуда будут записаны данные
- * @param len Количество байт
- */
-static void oneWire_writeBytes(OneWireBus* bus, uint8_t* data, uint8_t len) {
-    for(uint8_t i = 0; i < len; i++) {
-        oneWire_write(bus, data[i]);
-    }
-}
-
-/**
- * @brief Чтение индификатора единственного датчика. ID запишется в инстанс датчика
- * 
- * @param instance Указатель на инстанс датчика
- * @return Истина, если код успешно прочитан, ложь если устройство отсутствует или устройств на шине больше одного
- */
-bool oneWire_sensor_readID(OneWireSensor* instance) {
+bool unitemp_onewire_sensor_readID(OneWireSensor* instance) {
     if(!unitemp_onewire_bus_start(instance->bus)) return false;
-    oneWire_write(instance->bus, 0x33); // Чтение ПЗУ
-    oneWire_readBytes(instance->bus, instance->deviceID, 8);
-    if(!onewire_CRC_check(instance->deviceID, 8)) {
+    unitemp_onewire_send_byte(instance->bus, 0x33); // Чтение ПЗУ
+    unitemp_onewire_read_byteArray(instance->bus, instance->deviceID, 8);
+    if(!unitemp_onewire_CRC_check(instance->deviceID, 8)) {
         memset(instance->deviceID, 0, 8);
         return false;
     }
@@ -215,11 +182,6 @@ bool oneWire_sensor_readID(OneWireSensor* instance) {
     return true;
 }
 
-// Переменные для хранения промежуточного результата поиска
-uint8_t onewire_enum[8]; // найденный восьмибайтовый адрес
-uint8_t onewire_enum_fork_bit; // последний нулевой бит, где была неоднозначность (нумеруя с единицы)
-
-// Инициализирует процедуру поиска адресов устройств
 void unitemp_onewire_enum_init(void) {
     for(uint8_t p = 0; p < 8; p++) {
         onewire_enum[p] = 0;
@@ -230,12 +192,11 @@ void unitemp_onewire_enum_init(void) {
 uint8_t* unitemp_onewire_enum_next(OneWireBus* bus) {
     furi_delay_ms(10);
     if(!onewire_enum_fork_bit) { // Если на предыдущем шаге уже не было разногласий
-        FURI_LOG_D(
-            APP_NAME, "All devices on wire %d is found", unitemp_GPIO_toInt(bus->gpio->pin));
+        FURI_LOG_D(APP_NAME, "All devices on wire %d is found", unitemp_gpio_toInt(bus->gpio));
         return 0; // то просто выходим ничего не возвращая
     }
     if(!unitemp_onewire_bus_start(bus)) {
-        FURI_LOG_D(APP_NAME, "Wire %d is empty", unitemp_GPIO_toInt(bus->gpio->pin));
+        FURI_LOG_D(APP_NAME, "Wire %d is empty", unitemp_gpio_toInt(bus->gpio));
         return 0;
     }
     uint8_t bp = 8;
@@ -244,11 +205,11 @@ uint8_t* unitemp_onewire_enum_next(OneWireBus* bus) {
     uint8_t next = 0;
 
     uint8_t p = 1;
-    oneWire_write(bus, 0xF0);
+    unitemp_onewire_send_byte(bus, 0xF0);
     uint8_t newfork = 0;
     for(;;) {
-        uint8_t not0 = oneWire_read_bit(bus);
-        uint8_t not1 = oneWire_read_bit(bus);
+        uint8_t not0 = unitemp_onewire_read_bit(bus);
+        uint8_t not1 = unitemp_onewire_read_bit(bus);
         if(!not0) { // Если присутствует в адресах бит ноль
             if(!not1) { // Но также присустствует бит 1 (вилка)
                 if(p <
@@ -269,12 +230,11 @@ uint8_t* unitemp_onewire_enum_next(OneWireBus* bus) {
             if(!not1) { // Присутствует единица
                 next |= 0x80;
             } else { // Нет ни нулей ни единиц - ошибочная ситуация
-                FURI_LOG_D(
-                    APP_NAME, "Wrong wire %d situation", unitemp_GPIO_toInt(bus->gpio->pin));
+                FURI_LOG_D(APP_NAME, "Wrong wire %d situation", unitemp_gpio_toInt(bus->gpio));
                 return 0;
             }
         }
-        oneWire_send_bit(bus, next & 0x80);
+        unitemp_onewire_send_bit(bus, next & 0x80);
         bp--;
         if(!bp) {
             *pprev = next;
@@ -294,12 +254,12 @@ uint8_t* unitemp_onewire_enum_next(OneWireBus* bus) {
     return &onewire_enum[0];
 }
 
-void unitemp_OneWire_sensor_select(OneWireSensor* instance) {
-    oneWire_write(instance->bus, 0x55);
-    oneWire_writeBytes(instance->bus, instance->deviceID, 8);
+void unitemp_onewire_sensor_select(OneWireSensor* instance) {
+    unitemp_onewire_send_byte(instance->bus, 0x55);
+    unitemp_onewire_send_byteArray(instance->bus, instance->deviceID, 8);
 }
 
-bool unitemp_OneWire_sensor_alloc(Sensor* sensor, uint8_t* anotherValues) {
+bool unitemp_onewire_sensor_alloc(Sensor* sensor, char* args) {
     OneWireSensor* instance = malloc(sizeof(OneWireSensor));
     if(instance == NULL) {
         FURI_LOG_E(APP_NAME, "Sensor %s instance allocation error", sensor->name);
@@ -309,7 +269,7 @@ bool unitemp_OneWire_sensor_alloc(Sensor* sensor, uint8_t* anotherValues) {
     //Очистка адреса
     memset(instance->deviceID, 0, 8);
 
-    instance->bus = uintemp_onewire_bus_alloc(unitemp_GPIO_getFromInt(anotherValues[0]));
+    instance->bus = uintemp_onewire_bus_alloc(unitemp_gpio_getFromInt(args[0]));
     if(instance != NULL) {
         return true;
     }
@@ -318,7 +278,7 @@ bool unitemp_OneWire_sensor_alloc(Sensor* sensor, uint8_t* anotherValues) {
     return false;
 }
 
-bool unitemp_OneWire_sensor_free(Sensor* sensor) {
+bool unitemp_onewire_sensor_free(Sensor* sensor) {
     if(((OneWireSensor*)sensor->instance)->bus->device_count == 0) {
         unitemp_gpio_unlock(((OneWireSensor*)sensor->instance)->bus->gpio);
         free(((OneWireSensor*)sensor->instance)->bus);
@@ -328,7 +288,7 @@ bool unitemp_OneWire_sensor_free(Sensor* sensor) {
     return true;
 }
 
-bool unitemp_OneWire_sensor_init(Sensor* sensor) {
+bool unitemp_onewire_sensor_init(Sensor* sensor) {
     OneWireSensor* instance = sensor->instance;
     if(instance == NULL || instance->bus->gpio == NULL) {
         FURI_LOG_E(APP_NAME, "Sensor pointer is null!");
@@ -340,24 +300,24 @@ bool unitemp_OneWire_sensor_init(Sensor* sensor) {
     if(instance->familyCode == FC_DS18B20 || instance->familyCode == FC_DS1822) {
         //Установка разрядности в 10 бит
         if(!unitemp_onewire_bus_start(instance->bus)) return false;
-        unitemp_OneWire_sensor_select(instance);
-        oneWire_write(instance->bus, 0x4E); // Запись в память
+        unitemp_onewire_sensor_select(instance);
+        unitemp_onewire_send_byte(instance->bus, 0x4E); // Запись в память
         uint8_t buff[3];
         buff[0] = 0x4B; //Значение нижнего предела
         buff[1] = 0x46; //Значение высшего предела
         buff[2] = 0x3F; //10 бит разрядность преобразования
-        oneWire_writeBytes(instance->bus, buff, 3);
+        unitemp_onewire_send_byteArray(instance->bus, buff, 3);
 
         //Сохранение значений в EEPROM для автоматического восстановления после сбоев питания
         if(!unitemp_onewire_bus_start(instance->bus)) return false;
-        unitemp_OneWire_sensor_select(instance);
-        oneWire_write(instance->bus, 0x48); // Запись в EEPROM
+        unitemp_onewire_sensor_select(instance);
+        unitemp_onewire_send_byte(instance->bus, 0x48); // Запись в EEPROM
     }
 
     return true;
 }
 
-bool unitemp_OneWire_sensor_deinit(Sensor* sensor) {
+bool unitemp_onewire_sensor_deinit(Sensor* sensor) {
     OneWireSensor* instance = sensor->instance;
     if(instance == NULL || instance->bus->gpio == NULL) return false;
     unitemp_onewire_bus_deinit(instance->bus);
@@ -365,12 +325,12 @@ bool unitemp_OneWire_sensor_deinit(Sensor* sensor) {
     return true;
 }
 
-UnitempStatus unitemp_OneWire_sensor_update(Sensor* sensor) {
+UnitempStatus unitemp_onewire_sensor_update(Sensor* sensor) {
     OneWireSensor* instance = sensor->instance;
     if(sensor->status != UT_POLLING) {
         if(!unitemp_onewire_bus_start(instance->bus)) return UT_TIMEOUT;
-        unitemp_OneWire_sensor_select(instance);
-        oneWire_write(instance->bus, 0x44); // convert t
+        unitemp_onewire_sensor_select(instance);
+        unitemp_onewire_send_byte(instance->bus, 0x44); // convert t
         if(instance->bus->powerMode == PWR_PASSIVE) {
             furi_hal_gpio_write(instance->bus->gpio->pin, true);
             furi_hal_gpio_init(
@@ -384,11 +344,11 @@ UnitempStatus unitemp_OneWire_sensor_update(Sensor* sensor) {
                 instance->bus->gpio->pin, GpioModeOutputOpenDrain, GpioPullUp, GpioSpeedVeryHigh);
         }
         if(!unitemp_onewire_bus_start(instance->bus)) return UT_TIMEOUT;
-        unitemp_OneWire_sensor_select(instance);
-        oneWire_write(instance->bus, 0xBE); // Read Scratch-pad
+        unitemp_onewire_sensor_select(instance);
+        unitemp_onewire_send_byte(instance->bus, 0xBE); // Read Scratch-pad
         uint8_t buff[9];
-        oneWire_readBytes(instance->bus, buff, 9);
-        if(!onewire_CRC_check(buff, 9)) {
+        unitemp_onewire_read_byteArray(instance->bus, buff, 9);
+        if(!unitemp_onewire_CRC_check(buff, 9)) {
             FURI_LOG_D(APP_NAME, "Failed CRC check: %s", sensor->name);
             return UT_TIMEOUT;
         }

interfaces/OneWireSensor.h

@@ -16,6 +16,7 @@ typedef enum PowerMode {
     PWR_ACTIVE //Питание от источника питания
 } PowerMode;
 
+//Инстанс шины one wire
 typedef struct {
     //Порт подключения датчика
     const GPIO* gpio;
@@ -26,6 +27,7 @@ typedef struct {
     PowerMode powerMode;
 } OneWireBus;
 
+//Инстанс датчика one wire
 typedef struct OneWireSensor {
     //Указатель на шину OneWire
     OneWireBus* bus;
@@ -33,64 +35,57 @@ typedef struct OneWireSensor {
     uint8_t deviceID[8];
     //Код семейства устройств
     DallasFamilyCode familyCode;
-
 } OneWireSensor;
 
 /**
  * @brief Выделение памяти для датчика на шине OneWire
- *
  * @param sensor Указатель на датчик
- * @param st Тип датчика
+ * @param args Указатель на массив аргументов с параметрами датчика
  * @return Истина если всё ок
  */
-bool unitemp_OneWire_sensor_alloc(Sensor* sensor, uint8_t* anotherValues);
+bool unitemp_onewire_sensor_alloc(Sensor* sensor, char* args);
 
 /**
  * @brief Высвобождение памяти инстанса датчика
- * 
  * @param sensor Указатель на датчик
  */
-bool unitemp_OneWire_sensor_free(Sensor* sensor);
+bool unitemp_onewire_sensor_free(Sensor* sensor);
 
 /**
- * @brief Инициализации датчика на шине One Wire
- *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @brief Инициализации датчика на шине one wire
+ * @param sensor Указатель на датчик
  * @return Истина если инициализация упспешная
  */
-bool unitemp_OneWire_sensor_init(Sensor* sensor);
+bool unitemp_onewire_sensor_init(Sensor* sensor);
 
 /**
  * @brief Деинициализация датчика
- *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  */
-bool unitemp_OneWire_sensor_deinit(Sensor* sensor);
+bool unitemp_onewire_sensor_deinit(Sensor* sensor);
 
 /**
  * @brief Обновить значение с датчка
- * 
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  * @return Статус обновления
  */
-UnitempStatus unitemp_OneWire_sensor_update(Sensor* sensor);
-
-/**
- * @brief Запуск общения с датчиками на шине one wire
- * 
- * @param bus Указатель на шину 
- * @return Истина если хотя бы одно устройство отозвалось
- */
-bool unitemp_onewire_bus_start(OneWireBus* bus);
+UnitempStatus unitemp_onewire_sensor_update(Sensor* sensor);
 
 /**
  * @brief Выделение памяти для шины one wire и её инициализация
- * 
  * @param gpio Порт на котором необходимо создать шину
  * @return При успехе возвращает указатель на шину one wire
  */
 OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio);
 
+/**
+ * @brief Инициализация шины one wire
+ * 
+ * @param bus Указатель на шину
+ * @return Истина если инициализация успешна
+ */
+bool unitemp_onewire_bus_init(OneWireBus* bus);
+
 /**
  * @brief Деинициализация шины one wire
  * 
@@ -100,12 +95,83 @@ OneWireBus* uintemp_onewire_bus_alloc(const GPIO* gpio);
 bool unitemp_onewire_bus_deinit(OneWireBus* bus);
 
 /**
- * @brief Инициализация шины one wire
- * 
+ * @brief Запуск общения с датчиками на шине one wire
+ * @param bus Указатель на шину 
+ * @return Истина если хотя бы одно устройство отозвалось
+ */
+bool unitemp_onewire_bus_start(OneWireBus* bus);
+
+/**
+ * @brief Отправить 1 бит данных на шину one wire
  * @param bus Указатель на шину
- * @return Истина если инициализация успешна
+ * @param state Логический уровень
  */
-bool unitemp_onewire_bus_init(OneWireBus* bus);
+void unitemp_onewire_send_bit(OneWireBus* bus, bool state);
+
+/**
+ * @brief Запись байта на шину one wire
+ * 
+ * @param bus Указатель на шину one wire
+ * @param data Записываемый байт
+ */
+void unitemp_onewire_send_byte(OneWireBus* bus, uint8_t data);
+
+/**
+ * @brief Запись массива байт на шину one wire
+ * 
+ * @param bus Указатель на шину one wire
+ * @param data Указатель на массив, откуда будут записаны данные
+ * @param len Количество байт
+ */
+void unitemp_onewire_send_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len);
+
+/**
+ * @brief Чтение бита на шине one wire
+ * 
+ * @param bus Указатель на шину one wire
+ * @return Логический уровень бита
+ */
+bool unitemp_oneWire_read_bit(OneWireBus* bus);
+
+/**
+ * @brief Чтение байта с шины One Wire
+ * 
+ * @param bus Указатель на шину one wire
+ * @return Байт информации
+ */
+uint8_t unitemp_onewire_read_byte(OneWireBus* bus);
+
+/**
+ * @brief Чтение массива байт с шины One Wire
+ * 
+ * @param bus Указатель на шину one wire
+ * @param data Указатель на массив, куда будут записаны данные
+ * @param len Количество байт
+ */
+void unitemp_onewire_read_byteArray(OneWireBus* bus, uint8_t* data, uint8_t len);
+
+/**
+ * @brief Проверить контрольную сумму массива данных
+ * 
+ * @param data Указатель на массив данных
+ * @param len Длина массива (включая байт CRC)
+ * @return Истина если контрольная сумма корректная
+ */
+bool unitemp_onewire_CRC_check(uint8_t* data, uint8_t len);
+
+/**
+ * @brief Чтение индификатора единственного датчика. ID запишется в инстанс датчика
+ * 
+ * @param instance Указатель на инстанс датчика
+ * @return Истина, если код успешно прочитан, ложь если устройство отсутствует или устройств на шине больше одного
+ */
+bool unitemp_oneWire_sensor_readID(OneWireSensor* instance);
+
+/**
+ * @brief Команда выбора определённого датчка по его ID
+ * @param instance Указатель на датчик one wire
+ */
+void unitemp_onewire_sensor_select(OneWireSensor* instance);
 
 /**
  * @brief Инициализация процесса поиска адресов на шине one wire
@@ -114,8 +180,7 @@ void unitemp_onewire_enum_init(void);
 
 /**
  * @brief Перечисляет устройства на шине one wire и получает очередной адрес
- * 
- * @param instance 
+ * @param bus Указатель на шину one wire
  * @return Возвращает указатель на буфер, содержащий восьмибайтовое значение адреса, либо NULL, если поиск завешён
  */
 uint8_t* unitemp_onewire_enum_next(OneWireBus* bus);

interfaces/SingleWireSensor.c

@@ -1,8 +1,5 @@
 #include "SingleWireSensor.h"
-#include "../Sensors.h"
 
-//Интервал опроса датчиков (мс)
-#define POLLING_INTERVAL 2000
 //Максимальное количество попугаев ожидания датчика
 #define POLLING_TIMEOUT_TICKS 10000
 
@@ -11,50 +8,49 @@ const SensorType DHT11 = {
     .typename = "DHT11",
     .interface = &SINGLE_WIRE,
     .pollingInterval = 2000,
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .initializer = unitemp_singleWire_init,
-    .deinitializer = unitemp_singleWire_deinit,
-    .updater = unitemp_singleWire_update};
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .initializer = unitemp_singlewire_init,
+    .deinitializer = unitemp_singlewire_deinit,
+    .updater = unitemp_singlewire_update};
 const SensorType DHT12_SW = {
     .typename = "DHT12",
     .interface = &SINGLE_WIRE,
     .pollingInterval = 2000,
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .initializer = unitemp_singleWire_init,
-    .deinitializer = unitemp_singleWire_deinit,
-    .updater = unitemp_singleWire_update};
-
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .initializer = unitemp_singlewire_init,
+    .deinitializer = unitemp_singlewire_deinit,
+    .updater = unitemp_singlewire_update};
 const SensorType DHT21 = {
     .typename = "DHT21",
     .interface = &SINGLE_WIRE,
     .pollingInterval = 2000,
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .initializer = unitemp_singleWire_init,
-    .deinitializer = unitemp_singleWire_deinit,
-    .updater = unitemp_singleWire_update};
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .initializer = unitemp_singlewire_init,
+    .deinitializer = unitemp_singlewire_deinit,
+    .updater = unitemp_singlewire_update};
 const SensorType DHT22 = {
     .typename = "DHT22",
     .interface = &SINGLE_WIRE,
     .pollingInterval = 2000,
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .initializer = unitemp_singleWire_init,
-    .deinitializer = unitemp_singleWire_deinit,
-    .updater = unitemp_singleWire_update};
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .initializer = unitemp_singlewire_init,
+    .deinitializer = unitemp_singlewire_deinit,
+    .updater = unitemp_singlewire_update};
 const SensorType AM2320_SW = {
     .typename = "AM2320",
     .interface = &SINGLE_WIRE,
     .pollingInterval = 2000,
-    .allocator = unitemp_singleWire_alloc,
-    .mem_releaser = unitemp_singleWire_free,
-    .initializer = unitemp_singleWire_init,
-    .deinitializer = unitemp_singleWire_deinit,
-    .updater = unitemp_singleWire_update};
+    .allocator = unitemp_singlewire_alloc,
+    .mem_releaser = unitemp_singlewire_free,
+    .initializer = unitemp_singlewire_init,
+    .deinitializer = unitemp_singlewire_deinit,
+    .updater = unitemp_singlewire_update};
 
-bool unitemp_singleWire_alloc(Sensor* sensor, uint8_t* anotherValues) {
+bool unitemp_singlewire_alloc(Sensor* sensor, char* args) {
     SingleWireSensor* instance = malloc(sizeof(SingleWireSensor));
     if(instance == NULL) {
         FURI_LOG_E(APP_NAME, "Sensor %s instance allocation error", sensor->name);
@@ -62,20 +58,20 @@ bool unitemp_singleWire_alloc(Sensor* sensor, uint8_t* anotherValues) {
     }
     sensor->instance = instance;
 
-    if(unitemp_singleWire_sensorSetGPIO(sensor, unitemp_GPIO_getFromInt(anotherValues[0]))) {
+    if(unitemp_singlewire_sensorSetGPIO(sensor, unitemp_gpio_getFromInt(args[0]))) {
         return true;
     }
     FURI_LOG_E(APP_NAME, "Sensor %s GPIO setting error", sensor->name);
     free(instance);
     return false;
 }
-bool unitemp_singleWire_free(Sensor* sensor) {
+bool unitemp_singlewire_free(Sensor* sensor) {
     free(sensor->instance);
 
     return true;
 }
 
-bool unitemp_singleWire_init(Sensor* sensor) {
+bool unitemp_singlewire_init(Sensor* sensor) {
     SingleWireSensor* instance = ((Sensor*)sensor)->instance;
     if(instance == NULL || instance->gpio == NULL) {
         FURI_LOG_E(APP_NAME, "Sensor pointer is null!");
@@ -93,7 +89,7 @@ bool unitemp_singleWire_init(Sensor* sensor) {
     return true;
 }
 
-bool unitemp_singleWire_deinit(Sensor* sensor) {
+bool unitemp_singlewire_deinit(Sensor* sensor) {
     SingleWireSensor* instance = ((Sensor*)sensor)->instance;
     if(instance == NULL || instance->gpio == NULL) return false;
     unitemp_gpio_unlock(instance->gpio);
@@ -108,19 +104,19 @@ bool unitemp_singleWire_deinit(Sensor* sensor) {
     return true;
 }
 
-bool unitemp_singleWire_sensorSetGPIO(Sensor* sensor, const GPIO* gpio) {
+bool unitemp_singlewire_sensorSetGPIO(Sensor* sensor, const GPIO* gpio) {
     if(sensor == NULL || gpio == NULL) return false;
     SingleWireSensor* instance = sensor->instance;
     instance->gpio = gpio;
     return true;
 }
-const GPIO* unitemp_singleWire_sensorGetGPIO(Sensor* sensor) {
+const GPIO* unitemp_singlewire_sensorGetGPIO(Sensor* sensor) {
     if(sensor == NULL) return NULL;
     SingleWireSensor* instance = sensor->instance;
     return instance->gpio;
 }
 
-UnitempStatus unitemp_singleWire_update(Sensor* sensor) {
+UnitempStatus unitemp_singlewire_update(Sensor* sensor) {
     SingleWireSensor* instance = sensor->instance;
 
     //Массив для приёма данных

interfaces/SingleWireSensor.h

@@ -2,6 +2,7 @@
 #define UNITEMP_SINGLE_WIRE
 
 #include "../unitemp.h"
+#include "../Sensors.h"
 
 //Интерфейс Single Wire
 typedef struct {
@@ -22,7 +23,7 @@ extern const SensorType AM2320_SW;
  * @param sensor Указатель на инициализируемый датчик
  * @return Истина если всё прошло успешно
  */
-bool unitemp_singleWire_init(Sensor* sensor);
+bool unitemp_singlewire_init(Sensor* sensor);
 
 /**
  * @brief Деинициализация датчика
@@ -30,7 +31,7 @@ bool unitemp_singleWire_init(Sensor* sensor);
  * @param sensor Указатель на инициализируемый датчик
  * @return Истина если всё прошло успешно
  */
-bool unitemp_singleWire_deinit(Sensor* sensor);
+bool unitemp_singlewire_deinit(Sensor* sensor);
 
 /**
  * @brief Получение данных с датчика по однопроводному интерфейсу DHTxx и AM2xxx
@@ -38,7 +39,7 @@ bool unitemp_singleWire_deinit(Sensor* sensor);
  * @param sensor Указатель на датчик
  * @return Статус опроса
  */
-UnitempStatus unitemp_singleWire_update(Sensor* sensor);
+UnitempStatus unitemp_singlewire_update(Sensor* sensor);
 
 /**
  * @brief Установить порт датчика
@@ -47,7 +48,7 @@ UnitempStatus unitemp_singleWire_update(Sensor* sensor);
  * @param gpio Устанавливаемый порт
  * @return Истина если всё ок
  */
-bool unitemp_singleWire_sensorSetGPIO(Sensor* sensor, const GPIO* gpio);
+bool unitemp_singlewire_sensorSetGPIO(Sensor* sensor, const GPIO* gpio);
 
 /**
  * @brief Получить порт датчика
@@ -55,20 +56,20 @@ bool unitemp_singleWire_sensorSetGPIO(Sensor* sensor, const GPIO* gpio);
  * @param sensor Указатель на датчик
  * @return Указатель на GPIO
  */
-const GPIO* unitemp_singleWire_sensorGetGPIO(Sensor* sensor);
+const GPIO* unitemp_singlewire_sensorGetGPIO(Sensor* sensor);
 
 /**
  * @brief Выделение памяти под датчик на линии One Wire
  * 
  * @param sensor Указатель на датчик
- * @param st Тип датчика
+ * @param args Указатель на массив с аргументами параметров датчка
  */
-bool unitemp_singleWire_alloc(Sensor* sensor, uint8_t* anotherValues);
+bool unitemp_singlewire_alloc(Sensor* sensor, char* args);
 
 /**
  * @brief Высвобождение памяти инстанса датчика
  * 
  * @param sensor Указатель на датчик
  */
-bool unitemp_singleWire_free(Sensor* sensor);
+bool unitemp_singlewire_free(Sensor* sensor);
 #endif

sensors/BMP280.c

@@ -1,4 +1,3 @@
-#include "SensorsDriver.h"
 #include "BMP280.h"
 
 const SensorType BMP280 = {
@@ -65,7 +64,8 @@ static double bmp280_compensate_T_double(I2CSensor* i2c_sensor, int32_t adc_T) {
 
 static bool bmp280_readCalValues(I2CSensor* i2c_sensor) {
     BMP280_instance* bmp280_instance = (BMP280_instance*)i2c_sensor->sensorInstance;
-    if(!readRegArray(i2c_sensor, TEMP_CAL_START_ADDR, 6, (uint8_t*)&bmp280_instance->temp_cal))
+    if(!unitemp_i2c_readRegArray(
+           i2c_sensor, TEMP_CAL_START_ADDR, 6, (uint8_t*)&bmp280_instance->temp_cal))
         return false;
     FURI_LOG_D(
         APP_NAME,
@@ -74,7 +74,7 @@ static bool bmp280_readCalValues(I2CSensor* i2c_sensor) {
         bmp280_instance->temp_cal.dig_T1,
         bmp280_instance->temp_cal.dig_T2,
         bmp280_instance->temp_cal.dig_T3);
-    // if(!readRegArray(i2c_sensor, PRESS_CAL_START_ADDR, 18, (uint8_t*)&bmp280_instance->press_cal))
+    // if(!unitemp_i2c_readRegArray(i2c_sensor, PRESS_CAL_START_ADDR, 18, (uint8_t*)&bmp280_instance->press_cal))
     //     return false;
     // FURI_LOG_D(
     //     APP_NAME,
@@ -96,11 +96,11 @@ static bool bmp280_readCalValues(I2CSensor* i2c_sensor) {
 }
 static bool bmp280_isMeasuring(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
-    return (bool)((readReg(i2c_sensor, BMP280_REG_STATUS) & 0x08) >> 3);
+    return (bool)((unitemp_i2c_readReg(i2c_sensor, BMP280_REG_STATUS) & 0x08) >> 3);
 }
 
-bool unitemp_BMP280_alloc(Sensor* sensor, uint8_t* anotherValues) {
-    UNUSED(anotherValues);
+bool unitemp_BMP280_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
     BMP280_instance* bmp280_instance = malloc(sizeof(BMP280_instance));
     if(bmp280_instance == NULL) {
@@ -117,9 +117,9 @@ bool unitemp_BMP280_alloc(Sensor* sensor, uint8_t* anotherValues) {
 bool unitemp_BMP280_init(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
     //Перезагрузка
-    writeReg(i2c_sensor, 0xE0, 0xB6);
+    unitemp_i2c_writeReg(i2c_sensor, 0xE0, 0xB6);
     //Чтение ID датчика
-    uint8_t id = readReg(i2c_sensor, 0xD0);
+    uint8_t id = unitemp_i2c_readReg(i2c_sensor, 0xD0);
     if(id != BMP280_ID) {
         FURI_LOG_E(
             APP_NAME,
@@ -136,9 +136,10 @@ bool unitemp_BMP280_init(Sensor* sensor) {
         return false;
     }
     //Настройка режимов работы
-    writeReg(i2c_sensor, BMP280_REG_CTRL_MEAS, BMP280_TEMP_OVERSAMPLING_2 | BMP280_MODE_NORMAL);
+    unitemp_i2c_writeReg(
+        i2c_sensor, BMP280_REG_CTRL_MEAS, BMP280_TEMP_OVERSAMPLING_2 | BMP280_MODE_NORMAL);
     //Настройка периода опроса и фильтрации значений
-    writeReg(
+    unitemp_i2c_writeReg(
         i2c_sensor,
         BMP280_REG_CONFIG,
         BMP280_STANDBY_TIME_500 | BMP280_FILTER_COEFF_16 | BMP280_SPI_3W_DISABLE);
@@ -149,7 +150,7 @@ bool unitemp_BMP280_init(Sensor* sensor) {
 bool unitemp_BMP280_deinit(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
     //Перевод в сон
-    writeReg(i2c_sensor, BMP280_REG_CTRL_MEAS, BMP280_MODE_SLEEP);
+    unitemp_i2c_writeReg(i2c_sensor, BMP280_REG_CTRL_MEAS, BMP280_MODE_SLEEP);
     return true;
 }
 
@@ -163,7 +164,7 @@ UnitempStatus unitemp_BMP280_update(Sensor* sensor) {
         }
     }
     uint8_t buff[3];
-    if(!readRegArray(i2c_sensor, 0xFA, 3, buff)) return UT_TIMEOUT;
+    if(!unitemp_i2c_readRegArray(i2c_sensor, 0xFA, 3, buff)) return UT_TIMEOUT;
     int32_t adc_T = ((int32_t)buff[0] << 12) | ((int32_t)buff[1] << 4) | ((int32_t)buff[2] >> 4);
     sensor->temp = bmp280_compensate_T_double(i2c_sensor, adc_T);
     return UT_OK;

sensors/BMP280.h

@@ -3,7 +3,6 @@
 #include "../unitemp.h"
 #include "../Sensors.h"
 #include "../interfaces/I2CSensor.h"
-#include "SensorsDriver.h"
 
 typedef struct {
     uint16_t dig_T1;
@@ -31,39 +30,34 @@ typedef struct {
 extern const SensorType BMP280;
 /**
  * @brief Выделение памяти и установка начальных значений датчика BMP280
- *
  * @param sensor Указатель на создаваемый датчик
  * @return Истина при успехе
  */
-bool unitemp_BMP280_alloc(Sensor* sensor, uint8_t* anotherValues);
+bool unitemp_BMP280_alloc(Sensor* sensor, char* args);
 
 /**
  * @brief Инициализации датчика BMP280
- *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  * @return Истина если инициализация упспешная
  */
 bool unitemp_BMP280_init(Sensor* sensor);
 
 /**
  * @brief Деинициализация датчика
- *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  */
 bool unitemp_BMP280_deinit(Sensor* sensor);
 
 /**
  * @brief Обновление значений из датчика
- *
- * @param sensor Указатель на датчик (тип Sensor)
- * @return Истина если данныее были получены
+ * @param sensor Указатель на датчик
+ * @return Статус опроса датчика
  */
 UnitempStatus unitemp_BMP280_update(Sensor* sensor);
 
 /**
  * @brief Высвободить память датчика
- *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  */
 bool unitemp_BMP280_free(Sensor* sensor);
 

sensors/LM75.c

@@ -1,4 +1,5 @@
 #include "LM75.h"
+#include "../interfaces/I2CSensor.h"
 
 #define LM75_REG_TEMP 0x00
 #define LM75_REG_CONFIG 0x01
@@ -23,8 +24,8 @@ const SensorType LM75 = {
     .deinitializer = unitemp_LM75_deinit,
     .updater = unitemp_LM75_update};
 
-bool unitemp_LM75_alloc(Sensor* sensor, uint8_t* anotherValues) {
-    UNUSED(anotherValues);
+bool unitemp_LM75_alloc(Sensor* sensor, char* args) {
+    UNUSED(args);
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
 
     //Адреса на шине I2C (7 бит)
@@ -32,6 +33,7 @@ bool unitemp_LM75_alloc(Sensor* sensor, uint8_t* anotherValues) {
     i2c_sensor->maxI2CAdr = 0b1001111;
     return true;
 }
+
 bool unitemp_LM75_free(Sensor* sensor) {
     //Нечего высвобождать, так как ничего не было выделено
     UNUSED(sensor);
@@ -42,15 +44,15 @@ bool unitemp_LM75_init(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
 
     //Выход если не удалось записать значение в датчик
-    if(!writeReg(i2c_sensor, LM75_REG_CONFIG, LM75_CONFIG_FAULTQUEUE_1)) return false;
-    //TODO: Работа с прерываниями и компаратором
+    if(!unitemp_i2c_writeReg(i2c_sensor, LM75_REG_CONFIG, LM75_CONFIG_FAULTQUEUE_1)) return false;
 
     return true;
 }
 
 bool unitemp_LM75_deinit(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
-    if(!writeReg(i2c_sensor, LM75_REG_CONFIG, LM75_CONFIG_FAULTQUEUE_1 | LM75_CONFIG_SHUTDOWN))
+    if(!unitemp_i2c_writeReg(
+           i2c_sensor, LM75_REG_CONFIG, LM75_CONFIG_FAULTQUEUE_1 | LM75_CONFIG_SHUTDOWN))
         return false;
     return true;
 }
@@ -59,7 +61,7 @@ UnitempStatus unitemp_LM75_update(Sensor* sensor) {
     I2CSensor* i2c_sensor = (I2CSensor*)sensor->instance;
 
     uint8_t buff[2];
-    if(!readRegArray(i2c_sensor, LM75_REG_TEMP, 2, buff)) return UT_TIMEOUT;
+    if(!unitemp_i2c_readRegArray(i2c_sensor, LM75_REG_TEMP, 2, buff)) return UT_TIMEOUT;
     int16_t raw = ((((uint16_t)buff[0] << 8) | buff[1]) >> 7);
 
     if(FURI_BIT(raw, 8)) {

sensors/LM75.h

@@ -2,7 +2,6 @@
 #define UNITEMP_LM75
 
 #include "../unitemp.h"
-#include "SensorsDriver.h"
 #include "../Sensors.h"
 extern const SensorType LM75;
 /**
@@ -11,12 +10,12 @@ extern const SensorType LM75;
  * @param sensor Указатель на создаваемый датчик
  * @return Истина при успехе
  */
-bool unitemp_LM75_alloc(Sensor* sensor, uint8_t* anotherValues);
+bool unitemp_LM75_alloc(Sensor* sensor, char* args);
 
 /**
  * @brief Инициализации датчика LM75
  *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  * @return Истина если инициализация упспешная
  */
 bool unitemp_LM75_init(Sensor* sensor);
@@ -24,22 +23,22 @@ bool unitemp_LM75_init(Sensor* sensor);
 /**
  * @brief Деинициализация датчика
  *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  */
 bool unitemp_LM75_deinit(Sensor* sensor);
 
 /**
  * @brief Обновление значений из датчика
  *
- * @param sensor Указатель на датчик (тип Sensor)
- * @return Истина если данныее были получены
+ * @param sensor Указатель на датчик
+ * @return Статус обновления
  */
 UnitempStatus unitemp_LM75_update(Sensor* sensor);
 
 /**
  * @brief Высвободить память датчика
  *
- * @param sensor Указатель на датчик (тип Sensor)
+ * @param sensor Указатель на датчик
  */
 bool unitemp_LM75_free(Sensor* sensor);
 

sensors/SensorsDriver.h

@@ -1,9 +0,0 @@
-#ifndef UNITEMP_SENSORSDRIVER
-#define UNITEMP_SENSORSDRIVER
-#include "../unitemp.h"
-#include "../Sensors.h"
-#include "../interfaces/I2CSensor.h"
-#include "BMP280.h"
-#include "LM75.h"
-
-#endif

views/SensorsList_view.c

@@ -32,15 +32,15 @@ static void _enter_callback(void* context, uint32_t index) {
     //Имя датчка
     char sensor_name[11];
     snprintf(sensor_name, 11, "Sensor%d", app->sensors_count + 1);
-    const SensorType* st = unitemp_getSensorsTypes()[index];
-    uint8_t anotherValues[1] = {0};
+    const SensorType* st = unitemp_sensors_getTypes()[index];
+    char args[1] = {0};
     //Выбор первого доступного порта для датчиков single wire и one wire
     if(st->interface == &SINGLE_WIRE || st->interface == &ONE_WIRE) {
-        anotherValues[0] = unitemp_GPIO_toInt(unitemp_gpio_getAviablePort(st->interface, 0)->pin);
+        args[0] = unitemp_gpio_toInt(unitemp_gpio_getAviablePort(st->interface, 0));
     }
     //Для I2C адрес выберится автоматически
 
-    unitemp_SensorEdit_switch(unitemp_sensor_alloc(sensor_name, st, anotherValues));
+    unitemp_SensorEdit_switch(unitemp_sensor_alloc(sensor_name, st, args));
 }
 
 /**
@@ -52,9 +52,9 @@ void unitemp_SensorsList_alloc(void) {
     variable_item_list_reset(variable_item_list);
 
     //Добавление в список доступных датчиков
-    for(uint8_t i = 0; i < unitemp_getSensorsTypesCount(); i++) {
+    for(uint8_t i = 0; i < unitemp_sensors_getTypesCount(); i++) {
         variable_item_list_add(
-            variable_item_list, unitemp_getSensorsTypes()[i]->typename, 1, NULL, app);
+            variable_item_list, unitemp_sensors_getTypes()[i]->typename, 1, NULL, app);
     }
 
     //Добавление колбека на нажатие средней кнопки