сделана инициализация всей периферии для OW в Dallas_BusFirstInit

можно выбрать дефолтную периферию, передав в фукнию NULL, а можно и свою кастомную, типа Dallas_BusFirstInit(&hdallas, GPIOA, GPIO_PIN_2); надо теперь расписать все в ридми
глобальные структуруы OW и DS перенесены в hdallas напрямую, без указателей
2025-06-30 19:00:42 +03:00 · 2025-06-30 18:39:10 +03:00 · 2025-06-30 18:34:17 +03:00 · 2025-06-22 20:35:10 +03:00 · 2025-06-22 20:34:39 +03:00 · 2025-06-21 09:18:25 +03:00
942 changed files with 482553 additions and 1754 deletions
--- a/DS18B20/dallas_tools.c
+++ b/DS18B20/dallas_tools.c
@@ -1,13 +1,76 @@
 /**
 ******************************************************************************
 * @file           dallas_tools.c
-* @brief          Äðàéâåð äëÿ ðàáîòû ñ äàò÷èêàìè òåìïåðàòóðû DS18B20
-* @author         MicroTechnics (microtechnics.ru)
+* @brief          Драйвер для работы с датчиками температуры DS18B20
 ******************************************************************************
-@details        
-Ýòîò ôàéë ñîäåðæèò ðåàëèçàöèþ ôóíêöèé äëÿ ðàáîòû ñ äàò÷èêîì DS18B20 
-÷åðåç èíòåðôåéñ 1-Wire. Îí ïðåäîñòàâëÿåò ôóíêöèè äëÿ ÷òåíèÿ è çàïèñè 
-êîíôèãóðàöèè, âûïîëíåíèÿ èçìåðåíèé è îáðàáîòêè ïîëó÷åííûõ äàííûõ.
+@details
+Библиотека предназначена для работы с цифровыми датчиками температуры DS18B20 
+по однопроводному интерфейсу 1-Wire. Реализована поддержка инициализации, поиска, 
+добавления и работы с несколькими датчиками.
+
+@verbatim
+==============================================================================
+                        ## Основные задачи библиотеки ##
+==============================================================================
+Эта библиотека предоставляет следующие основные функции:
+  (+) Инициализация шины 1-Wire и обнаружение подключённых датчиков
+  (+) Инициализация структуры датчика по:
+       - ROM-адресу
+       - пользовательским байтам (TH, TL, UserByte3, UserByte4)
+       - порядковому номеру в списке найденных устройств
+  (+) Конфигурация разрешения измерения
+  (+) Чтение температуры
+  (+) Замена «потерянного» датчика
+  (+) Деинициализация структуры датчика
+
+==============================================================================
+                             ## Быстрый старт ##
+==============================================================================
+Пример последовательности инициализации и использования:
+
+  1. Определение пина и таймера для OneWire в ow_port.h:
+      #define OW_GPIO_Port  GPIOB
+      #define OW_Pin_Numb   0
+      #define OW_Pin        (1<<OW_Pin_Numb)
+      #define OW_TIM        TIM3
+      #define OW_TIM_1US_PERIOD 24
+      
+  2. Подключение библиотеки и настройка таймеров:
+      #include "dallas_tools.h"
+      MX_TIM_Init();
+      
+  3. Инициализация шины и поиск датчиков:
+      Dallas_BusFirstInit(&htim);
+
+  4. Инициализация датчика Dallas_SensorHandleTypeDef по одному из методов:
+      sens1.Init.init_func = &Dallas_SensorInitByInd;          // по индексу
+      sens1.Init.InitParam.Ind = 0;  // порядковый номер найденного датика для инициализации
+      
+      sens2.Init.init_func = &Dallas_SensorInitByROM;          // по ROM-адресу
+      sens2.Init.InitParam.ROM = 0;  // ROM датика для инициализации
+      
+      sens3.Init.init_func = &Dallas_SensorInitByUserBytes;    // по пользовательским байтам
+      sens3.Init.InitParam.UserBytes.UserByte1 = 1;  // UseBytes датика для инициализации
+      sens3.Init.InitParam.UserBytes.UserByte2 = 2;  // UseBytes датика для инициализации
+      sens3.Init.InitParam.UserBytes.UserByte3 = 3;  // UseBytes датика для инициализации
+      sens3.Init.InitParam.UserBytes.UserByte4 = 4;  // UseBytes датика для инициализации
+
+  5. Инициализация структуруы датчика:
+      Dallas_AddNewSensors(&hdallas, &sens);
+
+  6. Работа с датчиком:
+      Dallas_StartConvertTAll(hdallas, DALLAS_WAIT_BUS, 0);
+      Dallas_ReadTemperature(&sens);
+
+==============================================================================
+                        ## Требуемые зависимости ##
+==============================================================================
+Для работы библиотеки требуется:
+  - Драйвер OneWire (файлы onewire.c/h и ow_port.c/.h)
+  - Драйвер DS18B20 (файлы ds18b20.c/h)
+
+@endverbatim
+==============================================================================
 *****************************************************************************/


@@ -18,14 +81,105 @@


 /* Declarations and definitions --------------------------------------------*/
+DALLAS_HandleTypeDef hdallas;

 /* Functions ---------------------------------------------------------------*/
+
 /**
- * @brief  Ôóíêöèÿ äëÿ íàõîæäåíèÿ íîâîãî äàò÷èêà íà ìåñòî ïîòåðÿííîãî
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @brief  Функция для иниицализации структуры dallas и шины OW для датчиков
+ * @param  hdallas  Указатель на хендл для общения с датчиками
+ * @param  OW       Указатель на структуру OneWire (если NULL — используется по умолчанию)
+ * @param  DS       Указатель на структуру драйвера DS18B20 (если NULL — используется по умолчанию)
 * @retval HAL Status
 */
-HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor)
+#ifndef UART_Driver
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin)
+#else
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, UART_HandleTypeDef *huart)
+#endif
+{
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  
+#ifndef UART_Driver
+  OW_TIM->CR1 |= TIM_CR1_CEN;
+  if(GPIOx == NULL)
+  {   
+    hdallas->onewire.DataPin = OW_Pin;
+    hdallas->onewire.DataPort = OW_GPIO_Port;  
+  }
+  else
+  {   
+    hdallas->onewire.DataPin = GPIO_Pin;
+    hdallas->onewire.DataPort = GPIOx;  
+  }
+  for (uint32_t i = 0; i < 16; i++)
+  {
+      if (hdallas->onewire.DataPin & (1 << i))
+      {
+          hdallas->onewire.DataPinNumb = i;
+          break;
+      }
+  }
+#else
+  if(huart == NULL)
+    hdallas->onewire.huart = &OW_UART_Handle;
+  else
+    hdallas->onewire.huart = huart;
+#endif
+  /* Инициализация onewire и поиск датчиков*/
+  OneWire_Init(&hdallas->onewire);
+  
+  
+  return Dallas_Search(hdallas);
+}
+
+/**
+ * @brief  Поиск датчиков на шине onewire
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas)
+{
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  
+  return DS18B20_Search(&hdallas->ds_devices, &hdallas->onewire) != HAL_OK;
+}
+
+
+
+/**
+ * @brief  Функция для иниицализации нового датчика в структуре
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
+{
+  HAL_StatusTypeDef result;
+  
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  if(sensor == NULL)
+    return HAL_ERROR;  
+  
+  sensor->hdallas = hdallas;
+  
+  result = sensor->Init.init_func(hdallas, sensor);
+  
+  return result;
+}
+
+
+
+
+/**
+ * @brief  Функция для нахождения нового датчика на место потерянного
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status 
+ */
+HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
 {
  HAL_StatusTypeDef result;
  
@@ -37,302 +191,54 @@ HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor)
  
  if(sensor->isLost)
  {
-    if(DS18B20_Search(&DS, &OW) != HAL_OK)
+    if(Dallas_Search(sensor->hdallas) != HAL_OK)
      return HAL_ERROR;
    
-    if(sensor->Init.init_func(sensor->onewire, sensor) != HAL_OK)
+    if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)
      return HAL_ERROR;
    
    return HAL_OK;
  }
  else
  {
-    return HAL_BUSY; // äàò÷èê íå ïîòåðÿí
+    return HAL_BUSY; // датчик не потерян
  }
 }


 /**
- * @brief  Ôóíêöèÿ äëÿ èíèèöàëèçàöèè íîâîãî äàò÷èêà â ñòðóêòóðå
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @brief  Запускает измерение температуры на всех датчиках
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  waitCondition    Условие ожидания завершения преобразования
+ * @param  dallas_delay_ms  Время ожидания окончания конверсии
 * @retval HAL Status
 */
-HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-  
-  sensor->onewire = onewire;
-  
-  result = sensor->Init.init_func(onewire, sensor);
-  
-  return result;
-}
-
-
-
-/**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ROM
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @retval HAL Status
- */
-HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-    
-  uint8_t ROM[8] = {0};
-  ROM[0] = (sensor->Init.ROM >> (0*8)) & 0xFF;
-  ROM[1] = (sensor->Init.ROM >> (1*8)) & 0xFF;
-  ROM[2] = (sensor->Init.ROM >> (2*8)) & 0xFF;
-  ROM[3] = (sensor->Init.ROM >> (3*8)) & 0xFF;
-  ROM[4] = (sensor->Init.ROM >> (4*8)) & 0xFF;
-  ROM[5] = (sensor->Init.ROM >> (5*8)) & 0xFF;
-  ROM[6] = (sensor->Init.ROM >> (6*8)) & 0xFF;
-  ROM[7] = (sensor->Init.ROM >> (7*8)) & 0xFF;
-  
-  if(DS18B20_IsValidAddress(ROM) != HAL_OK)
-    return HAL_ERROR;
-  
-  uint8_t comparebytes = DALLAS_ROM_SIZE;
-  int ROM_ind = 0;
-  for(int i = 0; i < onewire->RomCnt; i++)
-  {
-    comparebytes = DALLAS_ROM_SIZE;
-    for(int rom_byte = 0; rom_byte < DALLAS_ROM_SIZE; rom_byte++)
-    {
-      if(DS.DevAddr[i][rom_byte] == ROM[rom_byte])
-        comparebytes--;
-    }
-    if(comparebytes == 0)
-    {
-      ROM_ind = i;
-      break;
-    }
-  }
-  
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-  if(comparebytes == 0)
-  {
-    
-    result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[ROM_ind]);
-    return result;
-  }
-  else
-  {
-    return HAL_ERROR;
-  }
-  
-  
-}
-
-
-
-/**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîëüçîâàòåëüñêèì áàéòàì
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @retval HAL Status
- */
-HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-    
-  uint8_t UserByte1 = sensor->Init.UserBytes12 & 0xFF;
-  uint8_t UserByte2 = sensor->Init.UserBytes12 >> 8;
-  uint8_t UserByte3 = sensor->Init.UserBytes34 & 0xFF;
-  uint8_t UserByte4 = sensor->Init.UserBytes34 >> 8;
-  uint8_t UserByte12Cmp = 0;
-  uint8_t UserByte34Cmp = 0;
-   
-  DALLAS_ScratchpadTypeDef scratchpad;
-  for(int i = 0; i < onewire->RomCnt; i++)
-  {    
-    /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-    result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
-    if (result != HAL_OK)
-      return result;
-    
-    /* Ñðàâíåíèå UserByte1 è UserByte2, åñëè îíè íå ðàâíû íóëþ */
-    if(sensor->Init.UserBytes12 != NULL)
-    {
-      if( (scratchpad.tHighRegister == UserByte1) &&
-          (scratchpad.tLowRegister == UserByte2))
-      {
-        UserByte12Cmp = 1;
-      }
-    }/* Åñëè ñðàâíåíèå UserByte1 è UserByte2 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè ñîâïàäàþò */
-    else
-    {
-      UserByte12Cmp = 1;
-    }
-    /* Ñðàâíåíèå UserByte3 è UserByte4, åñëè îíè íå ðàâíû íóëþ */
-    if(sensor->Init.UserBytes34 != NULL)
-    {
-      if( (scratchpad.UserByte3 == UserByte3) &&
-          (scratchpad.UserByte4 == UserByte4))
-      {
-        UserByte34Cmp = 1;
-      }
-    }/* Åñëè ñðàâíåíèå UserByte3 è UserByte4 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè îäèíàêîâûå */
-    else
-    {
-      UserByte34Cmp = 1;
-    }
-    /* Åñëè íàøëè íóæíûé äàò÷èê - çàâåðøàåì ïîèñê */
-    if(UserByte12Cmp && UserByte34Cmp)
-    {
-//      sensor->isInitialized = 1;
-//      sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByUserBytes;
-      result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[i]);
-      return result;
-    }
-  }
-  
-  sensor->sensROM = 0; 
-  memset(&sensor->scratchpad, 0, sizeof(DALLAS_ScratchpadTypeDef)); 
-  /* Âîçâðàùàåì îøèáêó åñëè íå íàøëè */
-  return HAL_ERROR;
-}
-
-/**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîðÿäêîâîìó íîìåðó
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @retval HAL Status
- * @details Ïîðÿäêîâûé íîìåð äàò÷èêà â ñïèñêå íàéäåííûõ.
- *          Ò.å. êàêèì ïî ñ÷åòó ýòîò äàò÷èê áûë íàéäåí
- */
-HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-
-//  sensor->onewire = onewire;  
-//  sensor->sensROM = &DS.DevAddr[sensor->Init.SensInd];
-//  sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByInd;
-   
-  result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[sensor->Init.SensInd]);
-  
-  return result;
-}
-
-/**
- * @brief  Èíèöèàëèçèðóåò äàò÷èê äëÿ ðàáîòû
- * @param  onewire    Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor     Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  ROM        ROM äàò÷èêà, êîòîðûé íàäî èíèöèàëèçèðîâàòü
- * @retval HAL Status
- */
-HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
-{
-  HAL_StatusTypeDef result;
-  
-  if(sensor == NULL)
-    return HAL_ERROR;
-  if(onewire == 0)
-    return HAL_ERROR;
-  
-  sensor->onewire = onewire;
-  sensor->sensROM = 0;
-  sensor->sensROM = *(uint64_t *)(ROM);
-//  for(int i = 0; i < DALLAS_ROM_SIZE; i++)
-//    sensor->sensROM |= ((uint64_t)(*ROM)[i] << (56 - 8*i));
-  
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-  result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
-  if (result == HAL_OK)
-  {
-    /* Óñòàíîâêà ðàçðåøåíèÿ */
-    result = DS18B20_SetResolution(onewire, (uint8_t *)ROM, sensor->Init.Resolution);
-    if (result == HAL_OK)
-    {
-      sensor->isInitialized = 1;
-      return HAL_OK;
-    }
-    else
-    {
-      sensor->isInitialized = 0;
-      return result;
-    }
-  }
-  else
-  {
-    sensor->isInitialized = 0;
-    return result;
-  }
-}
-
-/**
- * @brief  Äåèíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  sens_ind       Ïîðÿäêîâûé íîìåð äàò÷èêà â ñòðóêòóðå
- * @retval HAL Status
- */
-HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor)
-{
-  if(sensor == NULL)
-    return HAL_ERROR;
-  
-  DALLAS_InitStructTypeDef initbuff = sensor->Init;
-  
-  memset(sensor, 0, sizeof(DALLAS_HandleTypeDef));  
-  
-  sensor->Init = initbuff;
-  
-  return HAL_OK;
-}
-
-/**
- * @brief  Çàïóñêàåò èçìåðåíèå òåìïåðàòóðû íà âñåõ äàò÷èêàõ
- * @param  onewire          Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  waitCondition    Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
- * @param  dallas_delay_ms  Âðåìÿ îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè
- * @retval HAL Status
- */
-HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
+HAL_StatusTypeDef Dallas_StartConvertTAll(DALLAS_HandleTypeDef *hdallas, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
 {
  HAL_StatusTypeDef result;
  uint8_t rxDummyData;

-  if(onewire == NULL)
+  if(hdallas == NULL)
    return HAL_ERROR;
  
-  // Îòïðàâêà êîìàíäû íà÷àëà ïðåîáðàçîâàíèÿ òåìïåðàòóðû
-  result = DS18B20_StartConvTAll(onewire);
+  // Отправка команды начала преобразования температуры
+  result = DS18B20_StartConvTAll(&hdallas->onewire);
  if(result != HAL_OK)
  {
    return result;
  }
-
-  // Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì ïðîâåðêè øèíû
+//  // Проверка что преобразование началось
+//  if(OneWire_ReadBit(onewire) == 1)
+//    return HAL_ERROR;
+    
+  // Ожидание завершения преобразования, путем проверки шины
  if (waitCondition == DALLAS_WAIT_BUS)
  {
-    result = DS18B20_WaitForEndConvertion(onewire);
+    result = DS18B20_WaitForEndConvertion(&hdallas->onewire);
    return result;
  }

-  // Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì çàäåðæêè
+  // Ожидание завершения преобразования, путем задержки
  if (waitCondition == DALLAS_WAIT_DELAY)
  {
    uint32_t delayValueMs = 0;
@@ -366,12 +272,12 @@ HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvert
 }

 /**
- * @brief  Èçìåðÿåò òåìïåðàòóðó íà äàò÷èêå
- * @param  sensor        Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  waitCondition Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
+ * @brief  Измеряет температуру на датчике
+ * @param  sensor        Указатель на структуру датчика
+ * @param  waitCondition Условие ожидания завершения преобразования
 * @retval HAL Status
 */
-HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
+HAL_StatusTypeDef Dallas_ConvertT(DALLAS_SensorHandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
 {
  HAL_StatusTypeDef result;
  uint8_t rxDummyData;
@@ -381,22 +287,22 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
  if(sensor->isInitialized == 0)
    return HAL_ERROR;
  
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
+  /* Проверка присутствует ли выбранный датчик на линии */
  result = Dallas_IsConnected(sensor);
  if (result != HAL_OK)
    return result;

-  // Îòïðàâêà êîìàíäû íà÷àëà ïðåîáðàçîâàíèÿ òåìïåðàòóðû
-  result = DS18B20_StartConvT(sensor->onewire, (uint8_t *)&sensor->sensROM);
+  // Отправка команды начала преобразования температуры
+  result = DS18B20_StartConvT(&sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM);
  if(result != HAL_OK)
  {
    return result;
  }

-  // Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì ïðîâåðêè øèíû
+  // Ожидание завершения преобразования, путем проверки шины
  if (waitCondition == DALLAS_WAIT_BUS)
  {
-    result = DS18B20_WaitForEndConvertion(sensor->onewire);
+    result = DS18B20_WaitForEndConvertion(&sensor->hdallas->onewire);
    if(result == HAL_TIMEOUT)
    {
      sensor->f.timeout_convertion_cnt++;
@@ -404,12 +310,12 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
    return result;
  }

-  // Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì çàäåðæêè
+  // Ожидание завершения преобразования, путем задержки
  if (waitCondition == DALLAS_WAIT_DELAY)
  {
    uint32_t delayValueMs = 0;

-    switch (sensor->scratchpad.ConfigRegister)
+    switch (sensor->hdallas->scratchpad.ConfigRegister)
    {
      case DALLAS_CONFIG_9_BITS:
        delayValueMs = DALLAS_DELAY_MS_9_BITS;
@@ -434,7 +340,7 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
    HAL_Delay(delayValueMs);
  }
  
-  /* Íå ñ÷èòûâàåì òåìïåðàòóðó, åñëè íå âûáðàíî îæèäàíèå îêîí÷àíèÿ ïðåîáðàçîâàíèÿ */
+  /* Не считываем температуру, если не выбрано ожидание окончания преобразования */
  if(waitCondition != DALLAS_WAIT_NONE)
  {
    result = Dallas_ReadTemperature(sensor);
@@ -445,11 +351,11 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve


 /**
- * @brief  ×èòàåò èçìåðåííóþ äàò÷èêîì òåìïåðàòóðó
- * @param  sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @brief  Читает измеренную датчиком температуру
+ * @param  sensor Указатель на структуру датчика
 * @retval HAL Status
 */
-HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
+HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_SensorHandleTypeDef *sensor)
 {
  HAL_StatusTypeDef result;
  
@@ -458,13 +364,15 @@ HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
  if(sensor->isInitialized == 0)
    return HAL_ERROR;
  
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
+  /* Проверка присутствует ли выбранный датчик на линии */
  result = Dallas_IsConnected(sensor);
  if (result != HAL_OK)
+  {
    return result;
+  }

  
-  result = DS18B20_CalcTemperature(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad, &sensor->temperature);
+  result = DS18B20_CalcTemperature(&sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad, &sensor->temperature);
  
  if (result != HAL_OK)
  {
@@ -476,18 +384,17 @@ HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
 }

 /**
- * @brief  Ïðîâåðÿåò ïîäêëþ÷åí ëè äàò÷èê (÷òåíèå scratchpad)
- * @param  sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @brief  Проверяет подключен ли датчик (чтение scratchpad)
+ * @param  sensor Указатель на структуру датчика
 * @retval HAL Status
 */
-HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
+HAL_StatusTypeDef Dallas_IsConnected(DALLAS_SensorHandleTypeDef *sensor)
 {
  HAL_StatusTypeDef result;
-   
-  if(sensor->isInitialized == 0)
+  if(sensor == NULL)
    return HAL_ERROR;
-  
-  result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
+     
+  result = Dallas_ReadScratchpad(sensor);
  
  if (result == HAL_OK)
  {
@@ -497,47 +404,49 @@ HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
  }
  else
  {
-    
+    sensor->temperature = 0;
    if(sensor->isConnected == 1)
    {
      sensor->f.disconnect_cnt++;
-      sensor->isLost = 1;
    }
+    sensor->isLost = 1;
    sensor->isConnected = 0;
    
 //    Dallas_ReplaceLostedSensor(sensor);
-    return HAL_BUSY; // èñïîëüçóþ busy, ÷òîáû îòëè÷àòü ñèòóàöèþ îò HAL_ERROR
+    return HAL_BUSY; // использую busy, чтобы отличать ситуацию от HAL_ERROR
  }
 }

 /**
- * @brief  Çàïèñûâàåò ïîëüçîâàòåëüñêèå áàéòû
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  UserBytes12    Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
- * @param  UserBytes34    Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
- * @param  UserBytesMask  Ìàñêà, êàêèå áàéòû çàïèñûâàòü, à êàêèå íåò
+ * @brief  Записывает пользовательские байты
+ * @param  sensor         Указатель на структуру датчика
+ * @param  UserBytes12    Пользовательские байты 1 и 2
+ * @param  UserBytes34    Пользовательские байты 3 и 4
+ * @param  UserBytesMask  Маска, какие байты записывать, а какие нет
 * @retval HAL Status
- * @details ñòàðøèé áàéò - UserByte4/UserByte2, ìëàäøèé - UserByte3/UserByte1.
+ * @details старший байт - UserByte4/UserByte2, младший - UserByte3/UserByte1.
 */
-HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask)
+HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_SensorHandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask)
 {  
  HAL_StatusTypeDef result;
+  if(sensor == NULL)
+    return HAL_ERROR;
  
  if(sensor->isInitialized == 0)
    return HAL_ERROR;
  
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
+  /* Проверка присутствует ли выбранный датчик на линии */
  result = Dallas_IsConnected(sensor);
  if (result != HAL_OK)
    return result;
  
-  result = DS18B20_WriteUserBytes(sensor->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
+  result = DS18B20_WriteUserBytes(&sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
  if (result != HAL_OK)
  {
-    sensor->f.other_err_cnt++;
+    sensor->f.write_err_cnt++;
    return result;
  }  
-  result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
+  result = Dallas_ReadScratchpad(sensor);
  if (result != HAL_OK)
  {
    return result;
@@ -547,3 +456,229 @@ HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t U
 }


+HAL_StatusTypeDef Dallas_ReadScratchpad(DALLAS_SensorHandleTypeDef *sensor)
+{
+  if(sensor == NULL)
+    return HAL_ERROR;
+  return DS18B20_ReadScratchpad(&sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad);
+}
+
+/**
+ * @brief  Инициализирует структуру датчика по ROM
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
+{
+  HAL_StatusTypeDef result;
+  
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  if(sensor == NULL)
+    return HAL_ERROR;  
+    
+  uint8_t ROM[8] = {0};
+  ROM[0] = (sensor->Init.InitParam.ROM >> (7*8)) & 0xFF;
+  ROM[1] = (sensor->Init.InitParam.ROM >> (6*8)) & 0xFF;
+  ROM[2] = (sensor->Init.InitParam.ROM >> (5*8)) & 0xFF;
+  ROM[3] = (sensor->Init.InitParam.ROM >> (4*8)) & 0xFF;
+  ROM[4] = (sensor->Init.InitParam.ROM >> (3*8)) & 0xFF;
+  ROM[5] = (sensor->Init.InitParam.ROM >> (2*8)) & 0xFF;
+  ROM[6] = (sensor->Init.InitParam.ROM >> (1*8)) & 0xFF;
+  ROM[7] = (sensor->Init.InitParam.ROM >> (0*8)) & 0xFF;
+  
+  if(DS18B20_IsValidAddress(ROM) != HAL_OK)
+    return HAL_ERROR;
+  
+  uint8_t comparebytes = DALLAS_ROM_SIZE;
+  int ROM_ind = 0;
+  for(int i = 0; i < hdallas->onewire.RomCnt; i++)
+  {
+    comparebytes = DALLAS_ROM_SIZE;
+    for(int rom_byte = 0; rom_byte < DALLAS_ROM_SIZE; rom_byte++)
+    {
+      if(hdallas->ds_devices.DevAddr[i][rom_byte] == ROM[rom_byte])
+        comparebytes--;
+    }
+    if(comparebytes == 0)
+    {
+      ROM_ind = i;
+      break;
+    }
+  }
+  
+  /* Проверка присутствует ли выбранный датчик на линии */
+  if(comparebytes == 0)
+  {
+    
+    result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices.DevAddr[ROM_ind]);
+    return result;
+  }
+  else
+  {
+    return HAL_ERROR;
+  }
+  
+  
+}
+
+
+
+/**
+ * @brief  Инициализирует структуру датчика по пользовательским байтам
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
+{
+  HAL_StatusTypeDef result;
+  
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  if(sensor == NULL)
+    return HAL_ERROR;  
+    
+  uint8_t UserByte1 = sensor->Init.InitParam.UserBytes.UserByte1;
+  uint8_t UserByte2 = sensor->Init.InitParam.UserBytes.UserByte2;
+  uint8_t UserByte3 = sensor->Init.InitParam.UserBytes.UserByte3;
+  uint8_t UserByte4 = sensor->Init.InitParam.UserBytes.UserByte4;
+  uint8_t UserByte12Cmp = 0;
+  uint8_t UserByte34Cmp = 0;
+   
+  for(int i = 0; i < hdallas->onewire.RomCnt; i++)
+  {    
+    /* Проверка присутствует ли выбранный датчик на линии */
+    result = DS18B20_ReadScratchpad(&hdallas->onewire, (uint8_t *)&hdallas->ds_devices.DevAddr[i], (uint8_t *)&hdallas->scratchpad);
+    if (result != HAL_OK)
+      return result;
+    
+    /* Сравнение UserByte1 и UserByte2, если они не равны нулю */
+    if(UserByte1 | UserByte2)
+    {
+      if( (hdallas->scratchpad.tHighRegister == UserByte1) &&
+          (hdallas->scratchpad.tLowRegister == UserByte2))
+      {
+        UserByte12Cmp = 1;
+      }
+    }/* Если сравнение UserByte1 и UserByte2 не выбрано, то считаем что они совпадают */
+    else
+    {
+      UserByte12Cmp = 1;
+    }
+    /* Сравнение UserByte3 и UserByte4, если они не равны нулю */
+    if(UserByte3 | UserByte4)
+    {
+      if( (hdallas->scratchpad.UserByte3 == UserByte3) &&
+          (hdallas->scratchpad.UserByte4 == UserByte4))
+      {
+        UserByte34Cmp = 1;
+      }
+    }/* Если сравнение UserByte3 и UserByte4 не выбрано, то считаем что они одинаковые */
+    else
+    {
+      UserByte34Cmp = 1;
+    }
+    /* Если нашли нужный датчик - завершаем поиск */
+    if(UserByte12Cmp && UserByte34Cmp)
+    {
+//      sensor->isInitialized = 1;
+//      sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByUserBytes;
+      result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices.DevAddr[i]);
+      return result;
+    }
+  }
+  
+  sensor->sensROM = 0; 
+  /* Возвращаем ошибку если не нашли */
+  return HAL_ERROR;
+}
+
+/**
+ * @brief  Инициализирует структуру датчика по порядковому номеру
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status
+ * @details Порядковый номер датчика в списке найденных.
+ *          Т.е. каким по счету этот датчик был найден
+ */
+HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
+{
+  HAL_StatusTypeDef result;
+  
+  if(hdallas == NULL)
+    return HAL_ERROR;
+  if(sensor == NULL)
+    return HAL_ERROR;  
+
+  result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices.DevAddr[sensor->Init.InitParam.Ind]);
+  
+  return result;
+}
+
+/**
+ * @brief  Инициализирует датчик для работы
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  sensor     Указатель на структуру датчика
+ * @param  ROM        ROM датчика, который надо инициализировать
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_SensorInit(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
+{
+  HAL_StatusTypeDef result;
+  
+  if(sensor == NULL)
+    return HAL_ERROR;
+  if(hdallas == 0)
+    return HAL_ERROR;
+  
+  sensor->hdallas = hdallas;
+  sensor->sensROM = 0;
+  sensor->sensROM = *(uint64_t *)(ROM);
+//  for(int i = 0; i < DALLAS_ROM_SIZE; i++)
+//    sensor->sensROM |= ((uint64_t)(*ROM)[i] << (56 - 8*i));
+  
+  /* Проверка присутствует ли выбранный датчик на линии */
+  result = Dallas_ReadScratchpad(sensor);
+  if (result == HAL_OK)
+  {
+    /* Установка разрешения */
+    result = DS18B20_SetResolution(&hdallas->onewire, (uint8_t *)ROM, sensor->Init.Resolution);
+    if (result == HAL_OK)
+    {
+      sensor->isInitialized = 1;
+      return HAL_OK;
+    }
+    else
+    {
+      sensor->isInitialized = 0;
+      return result;
+    }
+  }
+  else
+  {
+    sensor->isInitialized = 0;
+    return result;
+  }
+}
+
+/**
+ * @brief  Деинициализирует структуру датчика
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status
+ */
+HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor)
+{
+  if(sensor == NULL)
+    return HAL_ERROR;
+    
+  memset(&sensor->f, 0, sizeof(sensor->f));
+  sensor->isConnected = 0;
+  sensor->isInitialized = 0;
+  sensor->isLost = 0;
+  sensor->temperature = 0;
+  sensor->sensROM = 0;
+  
+  return HAL_OK;
+}
--- a/DS18B20/dallas_tools.h
+++ b/DS18B20/dallas_tools.h
@@ -1,34 +1,33 @@
 /**
 ******************************************************************************
 * @file           dallas_tools.h
-* @brief          Äðàéâåð äàò÷èêîâ òåìïåðàòóðû DALLAS
+* @brief          Драйвер датчиков температуры DALLAS
 ******************************************************************************
-* Ýòîò ôàéë ïðåäîñòàâëÿåò îáúÿâëåíèÿ è îïðåäåëåíèÿ äëÿ ðàáîòû ñ äàò÷èêàìè 
-* òåìïåðàòóðû DS18B20. Îí âêëþ÷àåò ñòðóêòóðû äàííûõ, ìàêðîñû è ïðîòîòèïû 
-* ôóíêöèé äëÿ èíèöèàëèçàöèè, ÷òåíèÿ òåìïåðàòóðû 
-* è óïðàâëåíèÿ äàò÷èêàìè.
+* Этот файл предоставляет объявления и определения для работы с датчиками 
+* температуры DS18B20. Он включает структуры данных, макросы и прототипы 
+* функций для инициализации, чтения температуры 
+* и управления датчиками.
 *
-* Ðàáîòà ñ äàò÷èêàìè âåä¸òñÿ ÷åðåç ïðîòîêîë OneWire.
+* Работа с датчиками ведётся через протокол OneWire.
 *****************************************************************************/

 #ifndef DALLAS_TOOLS_H
 #define DALLAS_TOOLS_H

-
-
 /* Includes -----------------------------------------------------------------*/
 #include "ds18b20_driver.h"
 #include "onewire.h"

-/* Îïðåäåëåíèÿ ïîëüçîâàòåëüñêèõ áàéòîâ äëÿ çàïèñè ÷òåíèÿ */
-#define DALLAS_USER_BYTE_1    (1<<0)  ///< Ïåðâûé ïîëüçîâàòåëüñêèé áàéò
-#define DALLAS_USER_BYTE_2    (1<<1)  ///< Âòîðîé ïîëüçîâàòåëüñêèé áàéò
-#define DALLAS_USER_BYTE_3    (1<<2)  ///< Òðåòèé ïîëüçîâàòåëüñêèé áàéò
-#define DALLAS_USER_BYTE_4    (1<<3)  ///< ×åòâ¸ðòûé ïîëüçîâàòåëüñêèé áàéò

-#define DALLAS_USER_BYTE_12   (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Ïåðâûå äâà áàéòà
-#define DALLAS_USER_BYTE_34   (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Âòîðûå äâà áàéòà
-#define DALLAS_USER_BYTE_ALL  (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Âñå ïîëüçîâàòåëüñêèå áàéòû
+/* Определения пользовательских байтов для записи чтения */
+#define DALLAS_USER_BYTE_1    (1<<0)  ///< Первый пользовательский байт
+#define DALLAS_USER_BYTE_2    (1<<1)  ///< Второй пользовательский байт
+#define DALLAS_USER_BYTE_3    (1<<2)  ///< Третий пользовательский байт
+#define DALLAS_USER_BYTE_4    (1<<3)  ///< Четвёртый пользовательский байт
+
+#define DALLAS_USER_BYTE_12   (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Первые два байта
+#define DALLAS_USER_BYTE_34   (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Вторые два байта
+#define DALLAS_USER_BYTE_ALL  (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Все пользовательские байты

 /* Declarations and definitions ---------------------------------------------*/
 #define DALLAS_ROM_SIZE                                                   8
@@ -44,97 +43,127 @@
 #define DALLAS_DELAY_MS_12_BITS                                           750
 #define DALLAS_DELAY_MS_MAX                                               DALLAS_DELAY_MS_12_BITS

-/** @brief Ñòðóêòóðà Scratchpad äàò÷èêà DALLAS */
+typedef struct _SensorHandleStruct DALLAS_SensorHandleTypeDef;
+typedef struct _DallasHandleStruct DALLAS_HandleTypeDef;
+
+/** @brief Структура Scratchpad датчика DALLAS */
 typedef struct
 {
-  uint8_t TemperatureLSB;   ///< Ìëàäøèé áàéò òåìïåðàòóðû
-  uint8_t TemperatureMSB;   ///< Ñòàðøèé áàéò òåìïåðàòóðû
-  uint8_t tHighRegister;    ///< Âåðõíèé òåìïåðàòóðíûé ïîðîã
-  uint8_t tLowRegister;     ///< Íèæíèé òåìïåðàòóðíûé ïîðîã
-  uint8_t ConfigRegister;   ///< Êîíôèãóðàöèîííûé ðåãèñòð
-  uint8_t reserved;         ///< Çàðåçåðâèðîâàíî
-  uint8_t UserByte3;        ///< Ïîëüçîâàòåëüñêèé áàéò 3
-  uint8_t UserByte4;        ///< Ïîëüçîâàòåëüñêèé áàéò 4
-  uint8_t ScratchpadCRC;    ///< Êîíòðîëüíàÿ ñóììà
+  uint8_t TemperatureLSB;   ///< Младший байт температуры
+  uint8_t TemperatureMSB;   ///< Старший байт температуры
+  uint8_t tHighRegister;    ///< Верхний температурный порог
+  uint8_t tLowRegister;     ///< Нижний температурный порог
+  uint8_t ConfigRegister;   ///< Конфигурационный регистр
+  uint8_t reserved;         ///< Зарезервировано
+  uint8_t UserByte3;        ///< Пользовательский байт 3
+  uint8_t UserByte4;        ///< Пользовательский байт 4
+  uint8_t ScratchpadCRC;    ///< Контрольная сумма
 }DALLAS_ScratchpadTypeDef;

-/** @brief Ñòðóêòóðà ôëàãîâ îøèáîê äàò÷èêîâ DALLAS */
+/** @brief Структура флагов ошибок датчиков DALLAS */
 typedef struct
 {
-  unsigned disconnect_cnt;            ///< Ñ÷åò÷èê îòêëþ÷åíèé äàò÷èêà
-  unsigned read_temperature_err_cnt;  ///< Ñ÷åò÷èê îøèáîê ÷òåíèÿ òåìïåðàòóðû
-  unsigned timeout_convertion_cnt;    ///< Ñ÷åò÷èê îøèáîê òàéìàóòà êîíâåðòàöèè
-  unsigned other_err_cnt;             ///< Ñ÷åò÷èê äðóãèõ îøèáîê
+  uint8_t disconnect_cnt;            ///< Счетчик отключений датчика
+  uint8_t read_temperature_err_cnt;  ///< Счетчик ошибок чтения температуры
+  uint8_t timeout_convertion_cnt;    ///< Счетчик ошибок таймаута конвертации
+  uint8_t write_err_cnt;             ///< Счетчик других ошибок
 }DALLAS_FlagsTypeDef;


-/** @brief Ñòðóêòóðà èíèöèàëèçàöèè äàò÷èêà DALLAS */
-typedef struct
+/** @brief Структура инициализации датчика DALLAS */
+typedef struct __packed
 {
-  uint64_t            ROM;              ///< Óíèêàëüíûé ROM-êîä äàò÷èêà
-  uint16_t            UserBytes12;      ///< Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
-  uint16_t            UserBytes34;      ///< Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
-  uint8_t             SensInd;          ///< Èíäåêñ ñåíñîðà
-  uint8_t             Resolution;       ///< Ðàçðåøåíèå äàò÷èêà
-  HAL_StatusTypeDef   (*init_func)();   ///< Ôóíêöèÿ èíèöèàëèçàöèè
+  union
+  {
+    uint64_t  Ind;          ///< порядковый номер датчика
+    uint64_t  ROM;          ///< ROM датчика
+    struct  
+    {
+      uint8_t UserByte1;    ///< Младший байт (бит 0–7)
+      uint8_t UserByte2;    ///< Следующий байт (бит 8–15)
+      uint8_t UserByte3;    ///< Байт (бит 16–23)
+      uint8_t UserByte4;    ///< Байт (бит 24–31)
+      uint8_t Reserved[4];  ///< Остальные байты (бит 32–63, если нужно)
+    } UserBytes;            ///< UserBytes датчика
+  }InitParam;                           ///< Параметр для инициализации: ROM/UserBytes/Индекс
+  uint8_t             Resolution;       ///< Разрешение датчика
+  HAL_StatusTypeDef   (*init_func)(DALLAS_HandleTypeDef *, DALLAS_SensorHandleTypeDef *);   ///< Функция инициализации
 } DALLAS_InitStructTypeDef;

-/** @brief Îñíîâíàÿ ñòðóêòóðà îáðàáîò÷èêà äàò÷èêà DALLAS */
-typedef struct
+
+
+/** @brief Cтруктура обработчика DALLAS для общения с датчиком*/
+struct _DallasHandleStruct
 {
-  unsigned                  isConnected:1;            ///< Ôëàã ñîåäèíåíèÿ
-  unsigned                  isInitialized:1;          ///< Ôëàã èíèöèàëèçàöèè
-  unsigned                  isLost:1;                 ///< Ôëàã ïîòåðè ñâÿçè
+  OneWire_t                   onewire;
+  DS18B20_Drv_t               ds_devices;
+  DALLAS_ScratchpadTypeDef    scratchpad;  
+};
+extern DALLAS_HandleTypeDef hdallas;
+
+/** @brief Основная структура обработчика датчика DALLAS */
+struct _SensorHandleStruct
+{
+  unsigned                  isConnected:1;            ///< Флаг соединения
+  unsigned                  isInitialized:1;          ///< Флаг инициализации
+  unsigned                  isLost:1;                 ///< Флаг потери связи
  
-  OneWire_t                 *onewire;                 ///< Èíòåðôåéñ OneWire  
-  uint64_t                  sensROM;                  ///< ROM-êîä äàò÷èêà
+  DALLAS_HandleTypeDef      *hdallas;
+  uint64_t                  sensROM;                  ///< ROM-код датчика
  
-  DALLAS_ScratchpadTypeDef  scratchpad;               ///< Scratchpad äàò÷èêà
-  float                     temperature;              ///< Òåêóùàÿ òåìïåðàòóðà
+  float                     temperature;              ///< Текущая температура
  
-  DALLAS_InitStructTypeDef  Init;                     ///< Ñòðóêòóðà èíèöèàëèçàöèè
-  DALLAS_FlagsTypeDef       f;                        ///< Ôëàãè
-  
-} DALLAS_HandleTypeDef;
+  DALLAS_InitStructTypeDef  Init;                     ///< Структура инициализации
+  DALLAS_FlagsTypeDef       f;                        ///< Флаги  
+};



-/** @brief Âàðèàíòû îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè */
+/** @brief Варианты ожидания окончания конверсии */
 typedef enum
 {
-  DALLAS_WAIT_NONE      = 0x00,   ///< Áåç îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè
-  DALLAS_WAIT_BUS       = 0x01,   ///< Îæèäàíèå îêîí÷àíèÿ êîíâåðñèè ïî øèíå (îïðîñ äàò÷èêîâ - ÷òåíèå áèòà)
-  DALLAS_WAIT_DELAY     = 0x02,   ///< Áåç îæèäàíèÿ îêîí÷àíèÿ ÷åðåç çàäåðæêó (ìàêñèìàëüíàÿ çàäåðæêà äëÿ çàäàííîé ðàçðÿäíîñòè)
+  DALLAS_WAIT_NONE      = 0x00,   ///< Без ожидания окончания конверсии
+  DALLAS_WAIT_BUS       = 0x01,   ///< Ожидание окончания конверсии по шине (опрос датчиков - чтение бита)
+  DALLAS_WAIT_DELAY     = 0x02,   ///< Без ожидания окончания через задержку (максимальная задержка для заданной разрядности)
 } DALLAS_WaitConvertionTypeDef;



 /* Functions ---------------------------------------------------------------*/
-
-/* Ôóíêöèÿ äëÿ íàõîæäåíèÿ íîâîãî äàò÷èêà íà ìåñòî ïîòåðÿííîãî */
-HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor);
-/* Ôóíêöèÿ äëÿ èíèèöàëèçàöèè íîâîãî äàò÷èêà â ñòðóêòóðå */
-HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
-/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ROM */
-HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
-/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîëüçîâàòåëüñêèì áàéòàì */
-HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
-/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîðÿäêîâîìó íîìåðó */
-HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
-/* Èíèöèàëèçèðóåò äàò÷èê äëÿ ðàáîòû */
-HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE]);
-/* Äåèíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà */
-HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor);
-/* Çàïóñêàåò èçìåðåíèå òåìïåðàòóðû íà âñåõ äàò÷èêàõ */
-HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms);
-/* Èçìåðÿåò òåìïåðàòóðó íà äàò÷èêå */
-HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition);
-/* ×èòàåò èçìåðåííóþ äàò÷èêîì òåìïåðàòóðó */
-HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor);
-/* Ïðîâåðÿåò ïîäêëþ÷åí ëè äàò÷èê (÷òåíèå scratchpad) */
-HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor);
-/* Çàïèñûâàåò ïîëüçîâàòåëüñêèå áàéòû */
-HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask);
+/* Функция для иниицализации структуры dallas и шины OW для датчиков */
+#ifndef UART_Driver
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin);
+#else
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, UART_HandleTypeDef *huart);
+#endif
+/* Поиск датчиков на шине onewire */
+HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas);
+/* Функция для иниицализации нового датчика в структуре */
+HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
+/* Инициализирует структуру датчика по ROM */
+HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
+/* Инициализирует структуру датчика по пользовательским байтам */
+HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
+/* Инициализирует структуру датчика по порядковому номеру */
+HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
+/* Инициализирует датчик для работы */
+HAL_StatusTypeDef Dallas_SensorInit(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE]);
+/* Деинициализирует структуру датчика */
+HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor);
+/* Функция для нахождения нового датчика на место потерянного */
+HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor);
+/* Запускает измерение температуры на всех датчиках */
+HAL_StatusTypeDef Dallas_StartConvertTAll(DALLAS_HandleTypeDef *hdallas, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms);
+/* Измеряет температуру на датчике */
+HAL_StatusTypeDef Dallas_ConvertT(DALLAS_SensorHandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition);
+/* Читает измеренную датчиком температуру */
+HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_SensorHandleTypeDef *sensor);
+/* Проверяет подключен ли датчик (чтение scratchpad) */
+HAL_StatusTypeDef Dallas_IsConnected(DALLAS_SensorHandleTypeDef *sensor);
+/* Записывает пользовательские байты */
+HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_SensorHandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask);
+/* Записывает пользовательские байты */
+HAL_StatusTypeDef Dallas_ReadScratchpad(DALLAS_SensorHandleTypeDef *sensor);


 #endif // #ifndef DALLAS_TOOLS_H
--- a/DS18B20/ds18b20_driver.c
+++ b/DS18B20/ds18b20_driver.c
@@ -7,8 +7,6 @@
  */
 #include "ds18b20_driver.h"

-DS18B20_Drv_t DS;
-OneWire_t OW;

 /**
  * @brief  The function is used to check valid DS18B20 ROM
@@ -17,6 +15,9 @@ OneWire_t OW;
  */
 HAL_StatusTypeDef DS18B20_IsValidAddress(uint8_t *ROM)
 {
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
  uint8_t check_family = (*ROM == DS18B20_FAMILY_CODE);
 	/* Calculate CRC */
 	uint8_t crc = OneWire_CRC8(ROM, 7);
@@ -34,6 +35,9 @@ HAL_StatusTypeDef DS18B20_IsValidAddress(uint8_t *ROM)
  */
 HAL_StatusTypeDef DS18B20_IsValid(uint8_t *ROM)
 {
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
  if(*ROM == DS18B20_FAMILY_CODE)
    return HAL_OK;
  else
@@ -49,6 +53,11 @@ HAL_StatusTypeDef DS18B20_IsValid(uint8_t *ROM)
 uint8_t DS18B20_GetResolution(OneWire_t* OW, uint8_t *ROM) {
 	uint8_t conf;

+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
 	/* Check valid ROM */
 	if (DS18B20_IsValid(ROM) != HAL_OK) 
    return 0;
@@ -85,6 +94,11 @@ uint8_t DS18B20_GetResolution(OneWire_t* OW, uint8_t *ROM) {
 HAL_StatusTypeDef DS18B20_SetResolution(OneWire_t* OW, uint8_t *ROM,
 		DS18B20_Res_t Resolution)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
 	uint8_t th, tl, conf;

 	/* Check valid ROM */
@@ -146,6 +160,11 @@ HAL_StatusTypeDef DS18B20_SetResolution(OneWire_t* OW, uint8_t *ROM,
  */
 HAL_StatusTypeDef DS18B20_StartConvT(OneWire_t* OW, uint8_t *ROM)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
 	/* Check if device is DS18B20 */
 	if(DS18B20_IsValid(ROM) != HAL_OK)
    return HAL_ERROR;
@@ -167,6 +186,9 @@ HAL_StatusTypeDef DS18B20_StartConvT(OneWire_t* OW, uint8_t *ROM)
  */
 HAL_StatusTypeDef DS18B20_StartConvTAll(OneWire_t* OW)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  
 	/* Reset pulse */
 	OneWire_Reset(OW);

@@ -189,6 +211,15 @@ HAL_StatusTypeDef DS18B20_StartConvTAll(OneWire_t* OW)
  */
 HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad, float *Destination)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  if(Scratchpad == NULL)
+    return HAL_ERROR;
+  if(Destination == NULL)
+    return HAL_ERROR;
+  
 	uint16_t temperature;
 	uint8_t resolution;
 	int8_t digit, minus = 0;
@@ -256,8 +287,6 @@ HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *
 }


-
-uint8_t scratchpad_buff[8];
 /**
  * @brief  The function is used as read scratchpad from device
  * @retval status in OK = 1, Failed = 0
@@ -267,8 +296,12 @@ uint8_t scratchpad_buff[8];
  */
 HAL_StatusTypeDef DS18B20_ReadScratchpad(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
  if(Scratchpad == NULL)
-    Scratchpad = scratchpad_buff;
+    return HAL_ERROR;
  
 	/* Reset line */
 	OneWire_Reset(OW);
@@ -303,6 +336,8 @@ HAL_StatusTypeDef DS18B20_ReadScratchpad(OneWire_t* OW, uint8_t *ROM, uint8_t *S
  */
 HAL_StatusTypeDef DS18B20_WaitForEndConvertion(OneWire_t* OW)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
  uint32_t tickstart = HAL_GetTick();
  
 	/* Wait until line is released, then coversion is completed */
@@ -315,6 +350,22 @@ HAL_StatusTypeDef DS18B20_WaitForEndConvertion(OneWire_t* OW)
 }


+/**
+  * @brief  The function is used to wait for end of convertion without blocking
+  * @param  OW			OneWire HandleTypedef
+  */
+HAL_StatusTypeDef DS18B20_WaitForEndConvertion_NonBlocking(OneWire_t* OW)
+{
+  if(OW == NULL)
+    return HAL_ERROR;
+    
+	/* If line is pull down - conversion is ongoing */
+	if(OneWire_ReadBit(OW) == 0)
+    return HAL_BUSY;
+  else
+    return HAL_OK; // convertion done
+}
+

 /**
  * @brief  The function is used as set temperature alarm range on
@@ -328,6 +379,11 @@ HAL_StatusTypeDef DS18B20_WaitForEndConvertion(OneWire_t* OW)
 HAL_StatusTypeDef DS18B20_SetTempAlarm(OneWire_t* OW, uint8_t *ROM, int8_t Low,
 		int8_t High)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
 	uint8_t tl, th, conf;

 	/* Check if device is DS18B20 */
@@ -396,6 +452,11 @@ HAL_StatusTypeDef DS18B20_SetTempAlarm(OneWire_t* OW, uint8_t *ROM, int8_t Low,
 HAL_StatusTypeDef DS18B20_WriteUserBytes(OneWire_t* OW, uint8_t *ROM, int16_t UserBytes12,
 		int16_t UserBytes34, uint8_t UserBytesMask)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  if(ROM == NULL)
+    return HAL_ERROR;
+  
 	uint8_t ub1, ub2, conf, ub3, ub4;
  uint8_t UserByte1 = UserBytes12 & 0xFF;
  uint8_t UserByte2 = UserBytes12 >> 8;
@@ -475,35 +536,35 @@ HAL_StatusTypeDef DS18B20_WriteUserBytes(OneWire_t* OW, uint8_t *ROM, int16_t Us
 }


-/**
-  * @brief  The function is used as search device that had temperature alarm
-  * 		triggered and store it in DS18B20 alarm data structure
-  * @retval status of search, OK = 1, Failed = 0
-  * @param  DS		DS18B20 HandleTypedef
-  * @param  OW		OneWire HandleTypedef
-  */
-uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
-{
-	uint8_t t = 0;
+///**
+//  * @brief  The function is used as search device that had temperature alarm
+//  * 		triggered and store it in DS18B20 alarm data structure
+//  * @retval status of search, OK = 1, Failed = 0
+//  * @param  DS		DS18B20 HandleTypedef
+//  * @param  OW		OneWire HandleTypedef
+//  */
+//uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
+//{
+//	uint8_t t = 0;

-	/* Reset Alarm in DS */
-	for(uint8_t i = 0; i < OW->RomCnt; i++)
-	{
-		for(uint8_t j = 0; j < 8; j++)
-		{
-			DS->AlmAddr[i][j] = 0;
-		}
-	}
+//	/* Reset Alarm in DS */
+//	for(uint8_t i = 0; i < OW->RomCnt; i++)
+//	{
+//		for(uint8_t j = 0; j < 8; j++)
+//		{
+//			DS->AlmAddr[i][j] = 0;
+//		}
+//	}

-	/* Start alarm search */
-	while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
-	{
-		/* Store ROM of device which has alarm flag set */
-		OneWire_GetDevRom(OW, DS->AlmAddr[t]);
-		t++;
-	}
-	return (t > 0) ? 1 : 0;
-}
+//	/* Start alarm search */
+//	while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
+//	{
+//		/* Store ROM of device which has alarm flag set */
+//		OneWire_GetDevRom(OW, DS->AlmAddr[t]);
+//		t++;
+//	}
+//	return (t > 0) ? 1 : 0;
+//}

 /**
  * @brief  The function is used to initialize the DS18B20 sensor, and search
@@ -514,6 +575,10 @@ uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
  */
 HAL_StatusTypeDef DS18B20_Search(DS18B20_Drv_t *DS, OneWire_t *OW)
 {
+  if(OW == NULL)
+    return HAL_ERROR;
+  
+  
  OW->RomCnt = 0;
 	/* Search all OneWire devices ROM */
 	while(1)
@@ -526,6 +591,12 @@ HAL_StatusTypeDef DS18B20_Search(DS18B20_Drv_t *DS, OneWire_t *OW)

 		OW->RomCnt++;
 	}
+  for(int i = OW->RomCnt; i < DS18B20_DEVICE_AMOUNT; i++)
+  {
+    for(int j = 0; j < 8; j++)
+    DS->DevAddr[i][j] = 0;
+  }
+  

  if(OW->RomCnt > 0)
    return HAL_OK;
--- a/DS18B20/ds18b20_driver.h
+++ b/DS18B20/ds18b20_driver.h
@@ -21,12 +21,9 @@
 /* Includes ------------------------------------------------------------------*/
 #include "onewire.h"

-/* I/O Port ------------------------------------------------------------------*/
-#define DS_Pin        GPIO_PIN_9
-#define DS_GPIO_Port  GPIOA

 /* Data Structure ------------------------------------------------------------*/
-#define DS18B20_DEVICE_AMOUNT		8
+#define DS18B20_DEVICE_AMOUNT		30

 /* Register ------------------------------------------------------------------*/
 #define DS18B20_CMD_CONVERT				    0x44
@@ -77,11 +74,8 @@ typedef enum {
 typedef struct
 {
 	uint8_t 		  DevAddr[DS18B20_DEVICE_AMOUNT][8];
-	uint8_t 		  AlmAddr[DS18B20_DEVICE_AMOUNT][8];
-	float 			  Temperature[DS18B20_DEVICE_AMOUNT];
-	DS18B20_Res_t	Resolution;
 } DS18B20_Drv_t;
-extern DS18B20_Drv_t DS;
+extern DS18B20_Drv_t DS;;
 extern OneWire_t OW;

 /* External Function ---------------------------------------------------------*/
@@ -91,6 +85,7 @@ HAL_StatusTypeDef DS18B20_StartConvTAll(OneWire_t* OW);
 HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad, float *destination);
 HAL_StatusTypeDef DS18B20_ReadScratchpad(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad);
 HAL_StatusTypeDef DS18B20_WaitForEndConvertion(OneWire_t* OW);
+HAL_StatusTypeDef DS18B20_WaitForEndConvertion_NonBlocking(OneWire_t* OW);
 HAL_StatusTypeDef DS18B20_SetTempAlarm(OneWire_t* OW, uint8_t *ROM, int8_t Low,
 		int8_t High);
 HAL_StatusTypeDef DS18B20_WriteUserBytes(OneWire_t* OW, uint8_t *ROM, int16_t UserBytes12,
--- a/DS18B20/dwt.c
+++ b/DS18B20/dwt.c
@@ -1,58 +0,0 @@
-/**
-  ******************************************************************************
-  * @file    dwt.c
-  * @brief   This file includes the utilities for DWT
-  ******************************************************************************
-  */
-#include "dwt.h"
-
-static uint32_t SysCClk, start;
-
-/**
-  * @brief  Initialize DWT
-  */
-void DwtInit(void)
-{
-	SysCClk 		= (SystemCoreClock / 1000000);	// Calculate in us
-	DWT_LAR			|= DWT_LAR_UNLOCK;
-	DEM_CR			|= (uint32_t)DEM_CR_TRCENA;
-	DWT_CYCCNT		= (uint32_t)0u;					// Reset the clock counter
-	DWT_CR			|= (uint32_t)DWT_CR_CYCCNTENA;
-}
-
-/**
-  * @brief  Start DWT Counter
-  */
-void DwtStart(void)
-{
-	start = DWT_CYCCNT;
-}
-
-/**
-  * @brief  Calculate Interval Base On Previous Start Time
-  * @retval Interval in us
-  */
-float DwtInterval(void)
-{
-	return (float)(DWT_CYCCNT - start) / SysCClk;
-}
-
-/**
-  * @brief  Function to delay in microsecond
-  * @param	usec	Period in microsecond
-  */
-inline void DwtDelay_us(uint32_t usec)
-{
-	start = DWT_CYCCNT;
-	while(((DWT_CYCCNT - start) / SysCClk) < usec) {};
-}
-
-/**
-  * @brief  Function to delay in millisecond
-  * @param	msec	Period in millisecond
-  */
-inline void DwtDelay_ms(uint32_t msec)
-{
-	start = DWT_CYCCNT;
-	while(((DWT_CYCCNT - start) / SysCClk) < (msec * 1000)) {};
-}
--- a/DS18B20/dwt.h
+++ b/DS18B20/dwt.h
@@ -1,39 +0,0 @@
-/**
-  ******************************************************************************
-  * @file    dwt.h
-  * @brief   This file contains all the constants parameters for the dwt delay
-  ******************************************************************************
-  */
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef DWT_H
-#define DWT_H
-
-#ifdef __cplusplus
- extern "C" {
-#endif
-
-/* Includes ------------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
-
-/* Custom Define -------------------------------------------------------------*/
-#define  DWT_LAR_UNLOCK		(uint32_t)0xC5ACCE55
-#define  DEM_CR_TRCENA		(1 << 24)
-#define  DWT_CR_CYCCNTENA	(1 <<  0)
-#define  DWT_CR				*(volatile uint32_t *)0xE0001000
-#define  DWT_LAR			*(volatile uint32_t *)0xE0001FB0
-#define  DWT_CYCCNT			*(volatile uint32_t *)0xE0001004
-#define  DEM_CR				*(volatile uint32_t *)0xE000EDFC
-
-
-/* External Function ---------------------------------------------------------*/
-void DwtInit(void);
-void DwtStart(void);
-float DwtInterval(void);
-void DwtDelay_us(uint32_t usec);
-void DwtDelay_ms(uint32_t msec);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif /* DWT_H */
--- a/DS18B20/onewire.c
+++ b/DS18B20/onewire.c
@@ -16,6 +16,7 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
  if(OW == NULL)
    return;
 #ifndef ONEWIRE_UART_H
+  __disable_irq();
 	if(bit)
 	{
 		/* Set line low */
@@ -23,13 +24,13 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
 		OneWire_Pin_Mode(OW, Output);
    
    /* Forming pulse */
-		OneWireDelay_uw(ONEWIRE_WRITE_1_US);
+		OneWire_Delay_us(ONEWIRE_WRITE_1_US);

 		/* Release line (pull up line) */
 		OneWire_Pin_Mode(OW, Input);

 		/* Wait for 55 us and release the line */
-		OneWireDelay_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_1_US);
+		OneWire_Delay_us(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_1_US);
 		OneWire_Pin_Mode(OW, Input);
 	}else{
 		/* Set line low */
@@ -37,17 +38,18 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
 		OneWire_Pin_Mode(OW, Output);
    
    /* Forming pulse */
-		OneWireDelay_uw(ONEWIRE_WRITE_0_US);
+		OneWire_Delay_us(ONEWIRE_WRITE_0_US);

 		/* Release line (pull up line) */
 		OneWire_Pin_Mode(OW, Input);

 		/* Wait for 5 us and release the line */
-		OneWireDelay_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_0_US);
+		OneWire_Delay_us(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_0_US);
 		OneWire_Pin_Mode(OW, Input);
 	}
+  __enable_irq();
 #else
-  OneWireUART_ProcessBit(onewire_uart, bit);
+  OneWireUART_ProcessBit(OW->huart, bit);
 #endif
 }

@@ -61,24 +63,26 @@ uint8_t OneWire_ReadBit(OneWire_t* OW)
  if(OW == NULL)
    return 0;
  
+  __disable_irq();
 	uint8_t bit = 0;
 #ifndef ONEWIRE_UART_H
 	/* Line low */
 	OneWire_Pin_Level(OW, 0);
 	OneWire_Pin_Mode(OW, Output);
-	OneWireDelay_uw(ONEWIRE_READ_CMD_US);
+	OneWire_Delay_us(ONEWIRE_READ_CMD_US);

 	/* Release line */
 	OneWire_Pin_Mode(OW, Input);
-	OneWireDelay_uw(ONEWIRE_READ_DELAY_US);
+	OneWire_Delay_us(ONEWIRE_READ_DELAY_US);

 	/* Read line value */
 	bit = OneWire_Pin_Read(OW);

 	/* Wait 50us to complete 60us period */
-	OneWireDelay_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_READ_CMD_US - ONEWIRE_READ_DELAY_US);
+	OneWire_Delay_us(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_READ_CMD_US - ONEWIRE_READ_DELAY_US);
+  __enable_irq();
 #else
-  bit = OneWireUART_ProcessBit(onewire_uart, 1);
+  bit = OneWireUART_ProcessBit(OW->huart, 1);
 #endif
 	/* Return bit value */
 	return bit;
@@ -103,7 +107,7 @@ void OneWire_WriteByte(OneWire_t* OW, uint8_t byte)
 		byte >>= 1;
 	}
 #else
- OneWireUART_ProcessByte(onewire_uart, byte);
+ OneWireUART_ProcessByte(OW->huart, byte);
 #endif
 }

@@ -125,7 +129,7 @@ uint8_t OneWire_ReadByte(OneWire_t* OW)
 		byte |= (OneWire_ReadBit(OW) << 7);
 	}
 #else
-  byte = OneWireUART_ProcessByte(onewire_uart, 0xFF);
+  byte = OneWireUART_ProcessByte(OW->huart, 0xFF);
 #endif

 	return byte;
@@ -145,21 +149,21 @@ uint8_t OneWire_Reset(OneWire_t* OW)
 	/* Line low, and wait 480us */
 	OneWire_Pin_Level(OW, 0);
 	OneWire_Pin_Mode(OW, Output);
-	OneWireDelay_uw(ONEWIRE_RESET_PULSE_US);
+	OneWire_Delay_us(ONEWIRE_RESET_PULSE_US);

 	/* Release line and wait for 70us */
 	OneWire_Pin_Mode(OW, Input);
-	OneWireDelay_uw(ONEWIRE_PRESENCE_WAIT_US);
+	OneWire_Delay_us(ONEWIRE_PRESENCE_WAIT_US);

 	/* Check bit value */
 	uint8_t rslt = OneWire_Pin_Read(OW);

 	/* Delay for 410 us */
-	OneWireDelay_uw(ONEWIRE_PRESENCE_DURATION_US);
+	OneWire_Delay_us(ONEWIRE_PRESENCE_DURATION_US);
 #else
  
  uint8_t rslt = 0;
-  if(OneWireUART_Reset(onewire_uart) == HAL_OK)
+  if(OneWireUART_Reset(OW->huart) == HAL_OK)
    rslt = 0;
  else
    rslt = 1;
@@ -310,14 +314,15 @@ void OneWire_GetDevRom(OneWire_t* OW, uint8_t *ROM)
  */
 void OneWire_Init(OneWire_t* OW)
 {
+#ifndef UART_Driver
 	OneWire_Pin_Mode(OW, Output);
 	OneWire_Pin_Level(OW, 1);
-	OneWireDelay_uw(1000);
+	OneWire_Delay_us(1000);
 	OneWire_Pin_Level(OW, 0);
-	OneWireDelay_uw(1000);
+	OneWire_Delay_us(1000);
 	OneWire_Pin_Level(OW, 1);
-	OneWireDelay_uw(2000);
-
+	OneWire_Delay_us(2000);
+#endif
 	/* Reset the search state */
 	OW->LastDiscrepancy 		= 0;
 	OW->LastDeviceFlag 			= 0;
--- a/DS18B20/onewire.h
+++ b/DS18B20/onewire.h
@@ -14,21 +14,19 @@

 /* Includes ------------------------------------------------------------------*/
 #include "ow_port.h"
-
 /* Driver Selection ----------------------------------------------------------*/
-//#define LL_Driver
-#define CMSIS_Driver
-/* OneWire Timings -----------------------------------------------------------*/
-#define ONEWIRE_RESET_PULSE_US      480   // Äëèòåëüíîñòü èìïóëüñà ñáðîñà
-#define ONEWIRE_PRESENCE_WAIT_US    70    // Îæèäàíèå îòâåòà îò äàò÷èêà
-#define ONEWIRE_PRESENCE_DURATION_US 410  // Äëèòåëüíîñòü ñèãíàëà ïðèñóòñòâèÿ

-#define ONEWIRE_WRITE_1_US          6     // Äëèòåëüíîñòü çàïèñè "1"
-#define ONEWIRE_WRITE_0_US          60    // Äëèòåëüíîñòü çàïèñè "0"
-#define ONEWIRE_READ_CMD_US         5     // Âðåìÿ êîììàíäû ÷òåíèÿ áèòà
-#define ONEWIRE_READ_DELAY_US       10    // Çàäåðæêà ïåðåä ñ÷èòûâàíèåì áèòà
-#define ONEWIRE_RECOVERY_TIME_US    1     // Âîññòàíîâëåíèå ïåðåä ñëåäóþùèì ñëîòîì
-#define ONEWIRE_COMMAND_SLOT_US     70    // Îáùåå âðåìÿ êîììàíäû OneWire
+/* OneWire Timings -----------------------------------------------------------*/
+#define ONEWIRE_RESET_PULSE_US      480   // Длительность импульса сброса
+#define ONEWIRE_PRESENCE_WAIT_US    70    // Ожидание ответа от датчика
+#define ONEWIRE_PRESENCE_DURATION_US 410  // Длительность сигнала присутствия
+
+#define ONEWIRE_WRITE_1_US          8     // Длительность записи "1"
+#define ONEWIRE_WRITE_0_US          57    // Длительность записи "0"
+#define ONEWIRE_READ_CMD_US         2     // Время комманды чтения бита
+#define ONEWIRE_READ_DELAY_US       6    // Задержка перед считыванием бита
+#define ONEWIRE_COMMAND_SLOT_US     58    // Общее время комманды OneWire
+#define ONEWIRE_RECOVERY_TIME_US    1     // Восстановление перед следующим слотом
 /* Common Register -----------------------------------------------------------*/
 #define ONEWIRE_CMD_SEARCHROM			0xF0
 #define ONEWIRE_CMD_READROM				0x33
@@ -49,8 +47,13 @@ typedef struct
 	uint8_t 		LastDeviceFlag;
 	uint8_t			RomByte[8];
 	uint8_t 		RomCnt;
+#if defined(UART_Driver)
+  UART_HandleTypeDef *huart;
+#else
+	uint16_t		DataPinNumb;
 	uint16_t		DataPin;
 	GPIO_TypeDef	*DataPort;
+#endif
 } OneWire_t;

 /* External Function ---------------------------------------------------------*/
--- a/DS18B20/onewire_uart.c
+++ b/DS18B20/onewire_uart.c
@@ -0,0 +1,158 @@
+/**
+******************************************************************************
+* @file           : onewire_uart.c
+* @brief          : Драйвер для работы с шиной 1-Wire через UART
+* @author         : MicroTechnics (microtechnics.ru)
+******************************************************************************
+@details
+Этот файл реализует базовые функции для работы с 1-Wire через UART.
+Он включает в себя методы для передачи и приёма битов и байтов, а также
+выполнение reset-команды для устройств 1-Wire. 
+
+UART передает специально сформированные импульсы, эмулируя 1-Wire.
+*****************************************************************************/
+
+/* Includes ----------------------------------------------------------------*/
+
+#include "onewire_uart.h"
+
+/* Declarations and definitions --------------------------------------------*/
+
+/* Functions ---------------------------------------------------------------*/
+
+/**
+ * @brief Устанавливает скорость передачи данных для UART.
+ * @param huart Указатель на структуру UART
+ * @param baudrate Требуемая скорость передачи (бит/с)
+ * @details Функция изменяет скорость передачи UART в зависимости от используемой шины
+ * (PCLK1 или PCLK2). Это важно для эмуляции временных параметров 1-Wire.
+ */
+static void UARTSetBaudrate(UART_HandleTypeDef *huart, uint32_t baudrate)
+{
+  uint32_t pclk = 0;
+  huart->Init.BaudRate = baudrate;
+    
+  #if defined(USART6) && defined(UART9) && defined(UART10)
+      if ((huart->Instance == USART1) || (huart->Instance == USART6) ||
+          (huart->Instance == UART9)  || (huart->Instance == UART10))
+      {
+        pclk = HAL_RCC_GetPCLK2Freq();
+      }
+  #elif defined(USART6)
+      if ((huart->Instance == USART1) || (huart->Instance == USART6))
+      {
+        pclk = HAL_RCC_GetPCLK2Freq();
+      }
+  #else
+      if (huart->Instance == USART1)
+      {
+        pclk = HAL_RCC_GetPCLK2Freq();
+      }
+  #endif /* USART6 */
+      else
+      {
+        pclk = HAL_RCC_GetPCLK1Freq();
+      }
+
+  #if defined(USART_CR1_OVER8)
+    if (huart->Init.OverSampling == UART_OVERSAMPLING_8)
+    {
+      huart->Instance->BRR = UART_BRR_SAMPLING8(pclk, huart->Init.BaudRate);
+    }
+    else
+    {
+      huart->Instance->BRR = UART_BRR_SAMPLING16(pclk, huart->Init.BaudRate);
+    }
+  #else
+    huart->Instance->BRR = UART_BRR_SAMPLING16(pclk, huart->Init.BaudRate);
+  #endif /* USART_CR1_OVER8 */
+}
+
+/**
+ * @brief Передает и принимает один бит через 1-Wire.
+ * @param huart Указатель на структуру UART
+ * @param bit Бит для передачи (0 или 1)
+ * @return Полученный бит (0 или 1)
+ * @details Передача осуществляется отправкой специального импульса, длина которого определяет передаваемый бит. 
+ * Ответное значение читается сразу после передачи.
+ */
+uint8_t OneWireUART_ProcessBit(UART_HandleTypeDef *huart, uint8_t bit)
+{
+  uint8_t txData;
+  uint8_t rxData = 0x00;
+
+  if (bit == 1)
+  {
+    txData = ONEWIRE_PULSE_SHORT; // Короткий импульс для передачи '1'
+  }
+  else
+  {
+    txData = ONEWIRE_PULSE_LONG;  // Длинный импульс для передачи '0'
+  }
+
+  HAL_UART_Transmit(huart, &txData, 1, ONEWIRE_UART_TIMEOUT);
+  HAL_UART_Receive(huart, &rxData, 1, ONEWIRE_UART_TIMEOUT);
+
+  if (rxData == 0xFF)
+  {
+    bit = 1; // Короткий импульс для передачи '1'
+  }
+  else
+  {
+    bit = 0;  // Длинный импульс для передачи '0'
+  }
+  return bit;
+}
+
+/**
+ * @brief Передает и принимает байт через 1-Wire.
+ * @param huart Указатель на структуру UART
+ * @param byte Отправляемый байт
+ * @return Принятый байт
+ * @details Отправляет 8 бит последовательно, используя @ref OneWire_ProcessBit.
+ * Каждый полученный бит собирается в байт и возвращается.
+ */
+uint8_t OneWireUART_ProcessByte(UART_HandleTypeDef *huart, uint8_t byte)
+{
+  uint8_t rxByte = 0x00;
+  uint8_t txBit = 0;
+  uint8_t rxBit = 0;
+
+  for (uint8_t i = 0; i < 8; i++)
+  {
+    txBit = (byte >> i) & 0x01; // Извлекаем очередной бит для отправки
+    rxBit = OneWireUART_ProcessBit(huart, txBit);
+
+    rxByte |= (rxBit << i); // Собираем принятые биты в байт
+  }
+
+  return rxByte;
+}
+
+/**
+ * @brief Выполняет 1-Wire Reset и проверяет наличие устройств на шине.
+ * @param huart Указатель на структуру UART
+ * @return HAL Status
+ * @details Процедура Reset требует изменения скорости UART, чтобы сформировать
+ * большой по длительности импульс сброса. Если устройство ответило, шина в рабочем состоянии.
+ */
+HAL_StatusTypeDef OneWireUART_Reset(UART_HandleTypeDef *huart)
+{
+  HAL_StatusTypeDef status = HAL_OK;
+  uint8_t txByte = ONEWIRE_RESET;
+  uint8_t rxByte = 0x00;
+
+  UARTSetBaudrate(huart, ONEWIRE_RESET_BAUDRATE); // Устанавливаем низкую скорость для Reset-импульса
+
+  HAL_UART_Transmit(huart, &txByte, 1, ONEWIRE_UART_TIMEOUT);
+  HAL_UART_Receive(huart, &rxByte, 1, ONEWIRE_UART_TIMEOUT);
+
+  UARTSetBaudrate(huart, ONEWIRE_BAUDRATE); // Возвращаем стандартную скорость
+
+  if (rxByte == txByte)
+  {
+    status = HAL_ERROR; // Если ответ совпадает с отправленным байтом, значит, устройств нет
+  }
+
+  return status;
+}
--- a/DS18B20/onewire_uart.h
+++ b/DS18B20/onewire_uart.h
@@ -0,0 +1,57 @@
+/**
+******************************************************************************
+* @file           : onewire_uart.h
+* @brief          : 1-Wire driver
+* @author         : MicroTechnics (microtechnics.ru)
+*****************************************************************************/
+
+#ifndef ONEWIRE_UART_H
+#define ONEWIRE_UART_H
+
+
+
+/* Includes ----------------------------------------------------------------*/
+
+#include "stm32f1xx_hal.h"
+
+
+/* Declarations and definitions --------------------------------------------*/
+#define ONEWIRE_BAUDRATE                                              115200
+#define ONEWIRE_RESET_BAUDRATE                                        9600
+#define ONEWIRE_UART_TIMEOUT                                          10
+
+/**
+  * @brief Комманды OneWire
+  * @details Определяет байты для uart, которые будут 
+  * формировать необходимую длину импульса для разных комманд 
+  */
+typedef enum
+{
+  ONEWIRE_RESET = 0xF0,         /*!<  @brief Импульс длиной 520мкс для команды Reset (9600bod) 
+                                      @details 1-Wire требует импульс длительностью >480мкс */
+  
+  ONEWIRE_PULSE_SHORT = 0xFF,   /*!<  @brief Импульс длиной 8.7 мкс для записи "1"/чтения бита (115200bod) 
+                                      @details 1-Wire требует импульс длительностью 1-15мкс */
+  
+  
+  ONEWIRE_PULSE_LONG = 0x00,    /*!<  @brief импульс длиной 78.3 мкс для записи "0" (115200bod)
+                                      @details 1-Wire требует импульс длительностью 60-120мкс */
+ 
+//  ONEWIRE_PULSE_1_15US = 0xFF,
+//  ONEWIRE_PULSE_60_120US = 0x00,
+}ONEWIRE_Commands;
+
+
+
+
+/* Functions ---------------------------------------------------------------*/
+/* Выполняет 1-Wire Reset и проверяет наличие устройств на шине */
+HAL_StatusTypeDef OneWireUART_Reset(UART_HandleTypeDef *huart);
+/* Передает и принимает байт через 1-Wire */
+uint8_t OneWireUART_ProcessByte(UART_HandleTypeDef *huart, uint8_t byte);
+/* Передает и принимает один бит через 1-Wire */
+uint8_t OneWireUART_ProcessBit(UART_HandleTypeDef *huart, uint8_t bit);
+
+
+
+#endif // #ifndef ONEWIRE_UART_H
--- a/DS18B20/outdate/onewire_it_driver.c
+++ b/DS18B20/outdate/onewire_it_driver.c
@@ -1,230 +0,0 @@
-#include "onewire_it_driver.h"
-
-#define owtim     htim3
-OneWire_ITHandleTypeDef honewire;
-static OneWire_State ow_state = OW_IDLE;
-static int32_t ow_delay_counter = 0;  // Ñ÷åò÷èê âðåìåíè äëÿ çàäåðæåê
-
-
-extern TIM_HandleTypeDef owtim;
-extern OneWire_t OW;
-void OneWireIT_Init(OneWire_ITHandleTypeDef *OW_IT) {
-  OW_IT->onewire = &OW;
-  // Ðàçðåøàåì ïðåðûâàíèå òàéìåðà
-  HAL_TIM_Base_Start_IT(&owtim);
-}
-void OneWire_AddOperation(OneWire_ITHandleTypeDef *OW_IT, void (*operation)(OneWire_t*), uint8_t *io_data_buffer) 
-{
-  uint8_t next_tail = (OW_IT->tail + 1) % OP_QUEUE_SIZE;
-  if (next_tail != OW_IT->head) 
-  {  // Î÷åðåäü íå ïåðåïîëíåíà
-    OW_IT->operation_queue[OW_IT->tail] = operation;
-    OW_IT->tail = next_tail;
-  }
-}
-
-void OneWire_ProcessNextOperation(OneWire_ITHandleTypeDef *OW_IT) {
-  if (OW_IT->head != OW_IT->tail) {  // Åñëè î÷åðåäü íå ïóñòà
-    void (*current_op)(OneWire_t*) = OW_IT->operation_queue[OW_IT->head];
-    
-    current_op(OW_IT->onewire);
-    
-    if(OW_IT->op_done)
-    {
-      OW_IT->op_done = 0;
-      OW_IT->head = (OW_IT->head + 1) % OP_QUEUE_SIZE;  // Ïåðåõîäèì ê ñëåäóþùåé îïåðàöèè
-    }
-  }
-}
-
-void OneWireTIMHandler(TIM_HandleTypeDef *htim, OneWire_ITHandleTypeDef *OW_IT) 
-{
-  if (htim == &owtim) 
-  {
-    if (ow_delay_counter > 0)
-    {
-      ow_delay_counter -= ONE_WIRE_TIMER_PERIOD_US;  // Óìåíüøàåì ñ÷åò÷èê çàäåðæêè
-    }
-    
-    OneWire_Reset_ITHandle(OW_IT->onewire);
-//    OneWire_ProcessNextOperation(OW_IT);
-    
-  }
-}
-
-void OneWire_WriteBytes_IT(OneWire_ITHandleTypeDef *OW_IT)
-{
-  static HAL_StatusTypeDef res;
-  
-  if (OW_IT->current_byte_idx < OW_IT->data_len)  // Åñëè íå îáðàáîòàíû âñå äàííûå
-  {
-    uint8_t byte = OW_IT->data[OW_IT->current_byte_idx];  // Áåðåì òåêóùèé áàéò äàííûõ
-    for (OW_IT->current_bit_idx = 0; OW_IT->current_bit_idx < 8; OW_IT->current_bit_idx++)
-    {
-      uint8_t bit = (byte >> (7 - OW_IT->current_bit_idx)) & 0x01;  // Ïîëó÷àåì áèò èç áàéòà
-      OneWire_WriteBit_ITHandle(OW_IT->onewire, bit);  // Ïèøåì ýòîò áèò â OneWire
-    }
-    OW_IT->current_byte_idx++;  // Ïåðåõîäèì ê ñëåäóþùåìó áàéòó
-  }
-  else
-  {
-    OW_IT->current_byte_idx = 0;  // Çàâåðøàåì îïåðàöèþ çàïèñè
-    OW_IT->op_done = 1;
-  }
-}
-
-void OneWire_ReadBytes_IT(OneWire_ITHandleTypeDef *OW_IT)
-{
-  uint8_t bit;
-  if (OW_IT->current_byte_idx < OW_IT->data_len)  // Åñëè íå îáðàáîòàíû âñå äàííûå
-  {
-    uint8_t byte = 0;  // Äëÿ õðàíåíèÿ ïðî÷èòàííîãî áàéòà
-    for (OW_IT->current_bit_idx = 0; OW_IT->current_bit_idx < 8; OW_IT->current_bit_idx++)
-    {
-      OneWire_ReadBit_ITHandle(OW_IT->onewire, &bit);  // ×èòàåì áèò
-      byte |= (bit << (7 - OW_IT->current_bit_idx));  // Ñîáèðàåì áàéò èç áèòîâ
-    }
-    OW_IT->data[OW_IT->current_byte_idx] = byte;  // Ñîõðàíÿåì áàéò â áóôåð
-    OW_IT->current_byte_idx++;  // Ïåðåõîäèì ê ñëåäóþùåìó áàéòó
-  }
-  else
-  {
-    OW_IT->current_byte_idx = 0;  // Çàâåðøàåì îïåðàöèþ ÷òåíèÿ
-    OW_IT->head = (OW_IT->head + 1) % OP_QUEUE_SIZE;  // Óáèðàåì âûïîëíåííóþ îïåðàöèþ èç î÷åðåäè
-  }
-}
-
-
-
-
-HAL_StatusTypeDef OneWire_ReadBit_ITHandle(OneWire_t *OW, uint8_t *bit) {
-  static uint8_t read_bit_step = 0;
-
-  switch (read_bit_step) 
-  {
-    case 0:
-      // Ñíèæàåì ïèí íà 1 ìêñ äëÿ íà÷àëà ïåðåäà÷è áèòà
-      OneWire_Pin_Level(OW, 0);
-      OneWire_Pin_Mode(OW, Output);
-      ow_delay_counter = ONEWIRE_READ_CMD_US;  // Çàäåðæêà 1 ìêñ äëÿ ÷òåíèÿ áèòà
-      read_bit_step++;
-      return HAL_BUSY;
-    case 1:
-      // Ïîäíèìàåì ïèí è ïðîâåðÿåì ñîñòîÿíèå äëÿ ÷òåíèÿ áèòà
-      if (ow_delay_counter <= 0)
-      {
-        OneWire_Pin_Mode(OW, Input);
-        ow_delay_counter = ONEWIRE_READ_DELAY_US;  // Çàäåðæêà ïåðåä ñ÷èòûâàíèåì
-        read_bit_step++;
-      }
-      return HAL_BUSY;
-    case 2:
-      // ×èòàåì ïèí íà 1 ìêñ äëÿ îïðåäåëåíèÿ áèòà
-      if (ow_delay_counter <= 0) 
-      {
-        *bit = OneWire_Pin_Read(OW);
-        ow_delay_counter = ONEWIRE_COMMAND_SLOT_US - ONEWIRE_READ_CMD_US - ONEWIRE_READ_DELAY_US;
-      }
-      return HAL_BUSY;
-    case 3:      
-        read_bit_step = 0;  // Çàâåðøàåì êîìàíäó ÷òåíèÿ
-        ow_state = OW_IDLE;
-      return HAL_OK;
-    default:
-      read_bit_step = 3;
-      return HAL_ERROR;
-  }
-}
-
-HAL_StatusTypeDef OneWire_WriteBit_ITHandle(OneWire_t *OW, uint8_t bit) 
-{
-  static uint8_t write_bit_step = 0;
-
-  switch (write_bit_step) 
-  {
-    case 0:
-      // Ïèøåì áèò 0 èëè 1
-      OneWire_Pin_Level(OW, 0);
-      OneWire_Pin_Mode(OW, Output);
-      if (bit) 
-      {
-        ow_delay_counter = ONEWIRE_WRITE_1_US;  // Çàäåðæêà ìêñ äëÿ çàïèñè 1
-      } 
-      else 
-      {
-        ow_delay_counter = ONEWIRE_WRITE_0_US;  // Çàäåðæêà ìêñ äëÿ çàïèñè 0
-      }
-      write_bit_step++;
-      return HAL_BUSY;
-    case 1:
-      // Çàâåðøàåì çàïèñü, ïîäíèìàåì ïèí
-      if (ow_delay_counter == 0) 
-      {
-        OneWire_Pin_Mode(OW, Input);
-            
-        if (bit) {
-          ow_delay_counter = ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_1_US;  // Çàäåðæêà ìêñ äëÿ çàâåðøåíèÿ çàïèñè 1
-        } 
-        else
-        {
-          ow_delay_counter = ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_0_US;  // Çàäåðæêà ìêñ äëÿ çàâåðøåíèÿ çàïèñè 0
-        }
-        write_bit_step++;
-      }
-      return HAL_BUSY;
-    case 2:
-      OneWire_Pin_Mode(OW, Input);
-      // Çàâåðøàåì çàïèñü
-      write_bit_step = 0;
-      ow_state = OW_IDLE;
-      return HAL_OK;
-    default:
-      write_bit_step = 2;
-      return HAL_ERROR;
-  }
-}
-
-
-HAL_StatusTypeDef OneWire_Reset_ITHandle(OneWire_t *OW) 
-{
-  static uint8_t reset_step = 0;
-  static uint8_t rslt = 0;
-  GPIOC->ODR ^= (1<<13);
-  switch (reset_step) 
-  {
-    case 0:
-      // Íà÷àëî êîìàíäû Reset - îïóñêàåì ïèí íà 480 ìêñ
-      OneWire_Pin_Level(OW, 0);
-      OneWire_Pin_Mode(OW, Output);
-      ow_delay_counter = ONEWIRE_RESET_PULSE_US;  // Óñòàíàâëèâàåì çàäåðæêó â 480 ìêñ
-      reset_step++;
-      return HAL_BUSY;
-    case 1:
-      // Ïðîâåðÿåì, ïðîøëà ëè çàäåðæêà 480 ìêñ
-      if (ow_delay_counter <= 0) 
-      {
-        /* Release line and wait for 70us */
-        OneWire_Pin_Mode(OW, Input);
-        ow_delay_counter = ONEWIRE_PRESENCE_WAIT_US;  // Óñòàíàâëèâàåì çàäåðæêó íà 70 ìêñ
-        reset_step++;
-      }
-      return HAL_BUSY;
-    case 2:
-      // Æäåì îòâåòà îò óñòðîéñòâà íà ïîäíÿòèå ïèíà
-      if (ow_delay_counter <= 0) 
-      {
-        // ×èòàåì ïèí, åñëè óñòðîéñòâî îòâåòèëî
-        uint8_t rslt = OneWire_Pin_Read(OW);
-        reset_step++;
-      }
-      return HAL_BUSY;
-    case 3:      
-      reset_step = 0;  // Çàâåðøàåì êîìàíäó Reset
-      ow_delay_counter = ONEWIRE_PRESENCE_DURATION_US;  // Óñòàíàâëèâàåì çàäåðæêó íà 70 ìêñ
-      ow_state = OW_IDLE;
-      return HAL_OK;
-    default:
-      reset_step = 3;
-      return HAL_ERROR;
-  }
-}
--- a/DS18B20/outdate/onewire_it_driver.h
+++ b/DS18B20/outdate/onewire_it_driver.h
@@ -1,51 +0,0 @@
-/**
-  ******************************************************************************
-  * @file    onewire.h
-  * @brief   This file contains all the constants parameters for the OneWire
-  ******************************************************************************
-  * @attention
-  * Usage:
-  *		Uncomment LL Driver for HAL driver
-  *
-  ******************************************************************************
-  */
-/* Define to prevent recursive inclusion -------------------------------------*/
-#ifndef ONEWIRE_IT_DRIVER_H
-#define ONEWIRE_IT_DRIVER_H
-
-/* Includes ------------------------------------------------------------------*/
-#include "stm32f1xx.h"
-#include "onewire.h"
-
-#define ONE_WIRE_TIMER_PERIOD_US          1   // Ïåðèîä òàéìåðà â ìèêðîñåêóíäàõ (1 ìêñ)
-#define OP_QUEUE_SIZE                     10  // Áóôåð îïåðàöèé OneWire
-typedef enum {
-    OW_RESET,
-    OW_READ_BIT,
-    OW_SET_BIT,
-    OW_RESET_BIT,
-    OW_IDLE
-} OneWire_State;
-
-
-typedef struct
-{
-  OneWire_t *onewire;
-  uint8_t *data;            // Áóôåð äëÿ äàííûõ (äëÿ çàïèñè è ÷òåíèÿ)
-  uint8_t data_len;         // Äëèíà äàííûõ
-  uint8_t current_byte_idx; // Èíäåêñ òåêóùåãî áàéòà äëÿ çàïèñè/÷òåíèÿ
-  uint8_t current_bit_idx;  // Èíäåêñ òåêóùåãî áèòà äëÿ çàïèñè/÷òåíèÿ
-  uint8_t head;              // Èíäåêñ ïåðâîé îïåðàöèè â î÷åðåäè
-  uint8_t tail;              // Èíäåêñ ïîñëåäíåé îïåðàöèè â î÷åðåäè
-  uint8_t op_done;              // Èíäåêñ ïîñëåäíåé îïåðàöèè â î÷åðåäè
-  void (*operation_queue[OP_QUEUE_SIZE])(OneWire_t*); // Î÷åðåäü îïåðàöèé
-}OneWire_ITHandleTypeDef;
-extern OneWire_ITHandleTypeDef honewire;
-
-void OneWireTIMHandler(TIM_HandleTypeDef *htim, OneWire_ITHandleTypeDef *OW);
-void OneWireIT_Init(OneWire_ITHandleTypeDef *OW_IT);
-HAL_StatusTypeDef OneWire_ReadBit_ITHandle(OneWire_t *OW, uint8_t *bit);
-HAL_StatusTypeDef OneWire_WriteBit_ITHandle(OneWire_t *OW, uint8_t bit);
-HAL_StatusTypeDef OneWire_Reset_ITHandle(OneWire_t *OW);
-
-#endif /* ONEWIRE_IT_DRIVER_H */
--- a/DS18B20/outdate/onewire_uart.c
+++ b/DS18B20/outdate/onewire_uart.c
@@ -1,159 +0,0 @@
-/**
-******************************************************************************
-* @file           : onewire_uart.c
-* @brief          : Драйвер для работы с шиной 1-Wire через UART
-* @author         : MicroTechnics (microtechnics.ru)
-******************************************************************************
-@details
-Этот файл реализует базовые функции для работы с 1-Wire через UART.
-Он включает в себя методы для передачи и приёма битов и байтов, а также
-выполнение reset-команды для устройств 1-Wire. 
-
-UART передает специально сформированные импульсы, эмулируя 1-Wire.
-*****************************************************************************/
-
-/* Includes ----------------------------------------------------------------*/
-
-#include "onewire_uart.h"
-
-/* Declarations and definitions --------------------------------------------*/
-
-/* Functions ---------------------------------------------------------------*/
-
-/**
- * @brief Устанавливает скорость передачи данных для UART.
- * @param huart Указатель на структуру UART
- * @param baudrate Требуемая скорость передачи (бит/с)
- * @details Функция изменяет скорость передачи UART в зависимости от используемой шины
- * (PCLK1 или PCLK2). Это важно для эмуляции временных параметров 1-Wire.
- */
-static void UARTSetBaudrate(UART_HandleTypeDef *huart, uint32_t baudrate)
-{
-  uint32_t pclk = 0;
-  huart->Init.BaudRate = baudrate;
-  
-#if defined(USART6) && defined(UART9) && defined(UART10)
-    if ((huart->Instance == USART1) || (huart->Instance == USART6) ||
-        (huart->Instance == UART9)  || (huart->Instance == UART10))
-    {
-      pclk = HAL_RCC_GetPCLK2Freq();
-    }
-#elif defined(USART6)
-    if ((huart->Instance == USART1) || (huart->Instance == USART6))
-    {
-      pclk = HAL_RCC_GetPCLK2Freq();
-    }
-#else
-    if (huart->Instance == USART1)
-    {
-      pclk = HAL_RCC_GetPCLK2Freq();
-    }
-#endif /* USART6 */
-    else
-    {
-      pclk = HAL_RCC_GetPCLK1Freq();
-    }
-
-#if defined(USART_CR1_OVER8)
-  if (huart->Init.OverSampling == UART_OVERSAMPLING_8)
-  {
-    huart->Instance->BRR = UART_BRR_SAMPLING8(pclk, huart->Init.BaudRate);
-  }
-  else
-  {
-    huart->Instance->BRR = UART_BRR_SAMPLING16(pclk, huart->Init.BaudRate);
-  }
-#else
-  huart->Instance->BRR = UART_BRR_SAMPLING16(pclk, huart->Init.BaudRate);
-#endif /* USART_CR1_OVER8 */
-}
-
-/**
- * @brief Передает и принимает один бит через 1-Wire.
- * @param huart Указатель на структуру UART
- * @param bit Бит для передачи (0 или 1)
- * @return Полученный бит (0 или 1)
- * @details Передача осуществляется отправкой специального импульса, длина которого определяет передаваемый бит. 
- * Ответное значение читается сразу после передачи.
- */
-uint8_t OneWireUART_ProcessBit(UART_HandleTypeDef *huart, uint8_t bit)
-{
-  uint8_t txData;
-  uint8_t rxData = 0x00;
-
-  if (bit == 1)
-  {
-    txData = ONEWIRE_PULSE_SHORT; // Короткий импульс для передачи '1'
-  }
-  else
-  {
-    txData = ONEWIRE_PULSE_LONG;  // Длинный импульс для передачи '0'
-  }
-
-  HAL_UART_Transmit(huart, &txData, 1, ONEWIRE_UART_TIMEOUT);
-  HAL_UART_Receive(huart, &rxData, 1, ONEWIRE_UART_TIMEOUT);
-
-  return rxData;
-}
-
-/**
- * @brief Передает и принимает байт через 1-Wire.
- * @param huart Указатель на структуру UART
- * @param byte Отправляемый байт
- * @return Принятый байт
- * @details Отправляет 8 бит последовательно, используя @ref OneWire_ProcessBit.
- * Каждый полученный бит собирается в байт и возвращается.
- */
-uint8_t OneWireUART_ProcessByte(UART_HandleTypeDef *huart, uint8_t byte)
-{
-  uint8_t rxByte = 0x00;
-  uint8_t txBit = 0;
-  uint8_t rxBit = 0;
-
-  for (uint8_t i = 0; i < ONEWIRE_BITS_NUM; i++)
-  {
-    txBit = (byte >> i) & 0x01; // Извлекаем очередной бит для отправки
-    uint8_t tempRxData = OneWireUART_ProcessBit(huart, txBit);
-
-    if (tempRxData == 0xFF)
-    {
-      rxBit = 1; // В случае высокого уровня на линии интерпретируем как '1'
-    }
-    else
-    {
-      rxBit = 0;
-    }
-
-    rxByte |= (rxBit << i); // Собираем принятые биты в байт
-  }
-
-  return rxByte;
-}
-
-/**
- * @brief Выполняет 1-Wire Reset и проверяет наличие устройств на шине.
- * @param huart Указатель на структуру UART
- * @return HAL Status
- * @details Процедура Reset требует изменения скорости UART, чтобы сформировать
- * большой по длительности импульс сброса. Если устройство ответило, шина в рабочем состоянии.
- */
-HAL_StatusTypeDef OneWireUART_Reset(UART_HandleTypeDef *huart)
-{
-  HAL_StatusTypeDef status = HAL_OK;
-  uint8_t txByte = ONEWIRE_RESET;
-  uint8_t rxByte = 0x00;
-
-  UARTSetBaudrate(huart, ONEWIRE_RESET_BAUDRATE); // Устанавливаем низкую скорость для Reset-импульса
-
-  HAL_UART_Transmit(huart, &txByte, 1, ONEWIRE_UART_TIMEOUT);
-  HAL_UART_Receive(huart, &rxByte, 1, ONEWIRE_UART_TIMEOUT);
-
-  UARTSetBaudrate(huart, ONEWIRE_BAUDRATE); // Возвращаем стандартную скорость
-
-  if (rxByte == txByte)
-  {
-    status = HAL_ERROR; // Если ответ совпадает с отправленным байтом, значит, устройств нет
-  }
-
-  return status;
-}
--- a/DS18B20/outdate/onewire_uart.h
+++ b/DS18B20/outdate/onewire_uart.h
@@ -1,61 +0,0 @@
-/**
-******************************************************************************
-* @file           : onewire_uart.h
-* @brief          : 1-Wire driver
-* @author         : MicroTechnics (microtechnics.ru)
-*****************************************************************************/
-
-#ifndef ONEWIRE_UART_H
-#define ONEWIRE_UART_H
-
-
-
-/* Includes ----------------------------------------------------------------*/
-
-#include "stm32f1xx_hal.h"
-
-
-
-/* Declarations and definitions --------------------------------------------*/
-extern UART_HandleTypeDef huart1;
-#define onewire_uart                                                  (&huart1)
-#define ONEWIRE_BAUDRATE                                              115200
-#define ONEWIRE_RESET_BAUDRATE                                        9600
-#define ONEWIRE_UART_TIMEOUT                                          10
-#define ONEWIRE_BITS_NUM                                              8
-
-/**
-  * @brief Êîììàíäû OneWire
-  * @details Îïðåäåëÿåò áàéòû äëÿ uart, êîòîðûå áóäóò 
-  * ôîðìèðîâàòü íåîáõîäèìóþ äëèíó èìïóëüñà äëÿ ðàçíûõ êîììàíä 
-  */
-typedef enum
-{
-  ONEWIRE_RESET = 0xF0,         /*!<  @brief Èìïóëüñ äëèíîé 520ìêñ äëÿ êîìàíäû Reset (9600bod) 
-                                      @details 1-Wire òðåáóåò èìïóëüñ äëèòåëüíîñòüþ >480ìêñ */
-  
-  ONEWIRE_PULSE_SHORT = 0xFF,   /*!<  @brief Èìïóëüñ äëèíîé 8.7 ìêñ äëÿ çàïèñè "1"/÷òåíèÿ áèòà (115200bod) 
-                                      @details 1-Wire òðåáóåò èìïóëüñ äëèòåëüíîñòüþ 1-15ìêñ */
-  
-  
-  ONEWIRE_PULSE_LONG = 0x00,    /*!<  @brief èìïóëüñ äëèíîé 78.3 ìêñ äëÿ çàïèñè "0" (115200bod)
-                                      @details 1-Wire òðåáóåò èìïóëüñ äëèòåëüíîñòüþ 60-120ìêñ */
- 
-//  ONEWIRE_PULSE_1_15US = 0xFF,
-//  ONEWIRE_PULSE_60_120US = 0x00,
-}ONEWIRE_Commands;
-
-
-
-
-/* Functions ---------------------------------------------------------------*/
-/* Âûïîëíÿåò 1-Wire Reset è ïðîâåðÿåò íàëè÷èå óñòðîéñòâ íà øèíå */
-HAL_StatusTypeDef OneWireUART_Reset(UART_HandleTypeDef *huart);
-/* Ïåðåäàåò è ïðèíèìàåò áàéò ÷åðåç 1-Wire */
-uint8_t OneWireUART_ProcessByte(UART_HandleTypeDef *huart, uint8_t byte);
-/* Ïåðåäàåò è ïðèíèìàåò îäèí áèò ÷åðåç 1-Wire */
-uint8_t OneWireUART_ProcessBit(UART_HandleTypeDef *huart, uint8_t bit);
-
-
-
-#endif // #ifndef ONEWIRE_UART_H
--- a/DS18B20/ow_port.c
+++ b/DS18B20/ow_port.c
@@ -6,6 +6,7 @@
 */
 #include "ow_port.h"
 #include "onewire.h"
+#include "tim.h"

 /**
  * @brief  The internal function is used as gpio pin mode
@@ -14,34 +15,26 @@
  */
 void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
 {
-#ifdef CMSIS_Driver
-  static uint32_t pin_cr_numb = 4;
-  static int get_pin_numb = 0;
-  
-  if(get_pin_numb)
+#if defined(UART_Driver)
+#elif defined(CMSIS_Driver)
+  volatile uint32_t *config_reg = (OW->DataPinNumb < 8) ? &(OW->DataPort->CRL) : &(OW->DataPort->CRH);
+  uint32_t pin_pos = (OW->DataPinNumb < 8) ? (OW->DataPinNumb * 4) : ((OW->DataPinNumb - 8) * 4);
+  // —брос текущих 4 бит (CNF + MODE)
+  *config_reg &= ~(0xF << pin_pos);
+
+  if (Mode == Input)
  {
-    get_pin_numb = 0;
-    for(int i = 0; i < 8; i++)
-    {
-      if((OW->DataPin >> i) == 0x1)
-        pin_cr_numb = i*4;
-    }
-    for(int i = 8; i < 16; i++)
-    {
-      if((OW->DataPin >> i) == 0x1)
-        pin_cr_numb = (i-8)*4;
-    }
+      // ¬ход с подт¤жкой или без Ц например, CNF = 0b01, MODE = 0b00
+      // «десь устанавливаем вход с подт¤жкой:
+      *config_reg |= (0x8 << pin_pos); // CNF=10, MODE=00 (вход с подт¤жкой)
+      OW->DataPort->ODR |= (1 << OW->DataPinNumb); // ¬ключить подт¤жку вверх
  }
-	if(Mode == Input)
-	{
-    OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
-    OW->DataPort->CRH |= (1 << (pin_cr_numb+2));
-	}else{
-    OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
-    OW->DataPort->CRH |= (3 << pin_cr_numb);
-	}
-#else
-#ifdef LL_Driver
+  else
+  {
+      // ¬ыход push-pull, 2 ћ√ц Ц MODE = 0b10, CNF = 0b00
+      *config_reg |= (0x2 << pin_pos);
+  }
+#elif defined(LL_Driver)
 	if(Mode == Input)
 	{
 		LL_GPIO_SetPinMode(OW->DataPort, OW->DataPin, LL_GPIO_MODE_INPUT);
@@ -60,7 +53,6 @@ void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
 	}
 	HAL_GPIO_Init(OW->DataPort, &GPIO_InitStruct);
 #endif
-#endif
 }

 /**
@@ -70,7 +62,8 @@ void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
  */
 void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
 {
-#ifdef CMSIS_Driver
+#if defined(UART_Driver)
+#elif defined(CMSIS_Driver)
  if (Level != GPIO_PIN_RESET)
  {
    OW->DataPort->BSRR = OW->DataPin;
@@ -79,8 +72,7 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
  {
    OW->DataPort->BSRR = (uint32_t)OW->DataPin << 16u;
  }
-#else
-#ifdef LL_Driver
+#elif defined(LL_Driver)
 	if(Level == 1)
 	{
 		LL_GPIO_SetOutputPin(OW->DataPort, OW->DataPin);
@@ -90,7 +82,6 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
 #else
 	HAL_GPIO_WritePin(OW->DataPort, OW->DataPin, Level);
 #endif
-#endif
 }

 /**
@@ -100,13 +91,31 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
  */
 uint8_t OneWire_Pin_Read(OneWire_t* OW)
 {
-#ifdef CMSIS_Driver
+#if defined(UART_Driver)
+  return 0;
+#elif defined(CMSIS_Driver)
 	return ((OW->DataPort->IDR & OW->DataPin) != 0x00U) ? 1 : 0;
-#else
-#ifdef LL_Driver
+#elif defined(LL_Driver)
 	return ((OW->DataPort->IDR & OW->DataPin) != 0x00U) ? 1 : 0;
 #else
 	return HAL_GPIO_ReadPin(OW->DataPort, OW->DataPin);
 #endif
-#endif
-}
+}
+
+uint32_t tim_1us_period = OW_TIM_1US_PERIOD;
+void OneWire_Delay_us(uint32_t us)
+{
+  uint32_t ticks = us * tim_1us_period;
+  uint16_t start = OW_TIM->CNT;
+  uint32_t elapsed = 0;
+  uint16_t prev = start;
+
+  while (elapsed < ticks)
+  {
+    uint16_t curr = OW_TIM->CNT;
+    uint16_t delta = (uint16_t)(curr - prev);  // учЄт переполнени¤
+    elapsed += delta;
+    prev = curr;
+  }
+}
+
--- a/DS18B20/ow_port.h
+++ b/DS18B20/ow_port.h
@@ -11,9 +11,62 @@

 /* Includes ------------------------------------------------------------------*/
 #include "stm32f1xx_hal.h"
-#include "dwt.h"
+
+/* I/O Port ------------------------------------------------------------------*/
+#define UART_Driver       ///< использовтаь UART (onewire_uart.c/.h)
+//#define LL_Driver       ///< использовать CMSIS для управления ножкой
+#define CMSIS_Driver      ///< использовать CMSIS для управления ножкой
+// если ничего не выбрано - используется HAL
+
+
+/**
+  * @defgroup    DEFAULT_SETTINGS   Дефолтные параметры для OW
+  * @details     Определены дефолтные параметры для OW, применятся если передать NULL в Dallas_BusFirstInit.
+  * @{
+  */
+  
+/**
+ * @brief Порт вывода для шины 1-Wire.
+ * @details Указывает порт GPIO, к которому подключена линия данных 1-Wire (например, для DS18B20).
+ */
+#define OW_UART_Handle  huart1
+
+/**
+ * @brief Порт вывода для шины 1-Wire.
+ * @details Указывает порт GPIO, к которому подключена линия данных 1-Wire (например, для DS18B20).
+ */
+#define OW_GPIO_Port  GPIOA
+
+/**
+ * @brief Маска пина, соответствующая номеру OW_Pin_Numb.
+ * @details Используется при доступе к регистрам порта для управления состоянием линии 1-Wire.
+ */
+#define OW_Pin        (GPIO_PIN_9)
+
+/**
+ * @brief Аппаратный таймер для формирования временных интервалов протокола 1-Wire.
+ * @details Применяется для создания точных задержек при обмене данными по шине 1-Wire.
+ */
+#define OW_TIM        TIM3
+
+/**
+ * @brief Количество тактов таймера OW_TIM, соответствующее 1 микросекунде.
+ * @details Вычисляется на основе частоты таймера. Например, для таймера с частотой 24 МГц значение будет равно 24.
+ */
+#define OW_TIM_1US_PERIOD 72
+
+
+/** DEFAULT_SETTINGS
+  * @}
+  */

 /* OneWire Timings -----------------------------------------------------------*/
-#define OneWireDelay_uw(_us_)       DwtDelay_us(_us_)
+void OneWire_Delay_us(uint32_t us);
 /* Common Register -----------------------------------------------------------*/
+
+
+#if defined(UART_Driver)
+#include "onewire_uart.h"
+#include "usart.h"
+#endif
 #endif /* ONEWIRE_PORT_H */
--- a/DS18B20/pch_sensors.c
+++ b/DS18B20/pch_sensors.c
@@ -1,293 +0,0 @@
-/**
-******************************************************************************
-* @file           pch_sensors.c
-* @brief          Ðàáîòà ñ äàò÷èêàìè òåìïåðàòóðû DS18B20 â Ï×
-*****************************************************************************/
-
-
-/* Includes ----------------------------------------------------------------*/
-
-#include "pch_sensors.h"
-PCHSens_UnknownSensorsTypeDef UnknownSensors;
-
-/* Declarations and definitions --------------------------------------------*/
-
-PCHSens_ModuleTypeDef module1;
-/* Functions ---------------------------------------------------------------*/
-HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM)
-{  
-  DALLAS_HandleTypeDef tempsens;  
-  HAL_StatusTypeDef result;
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;
-    
-//  sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
-  
-  sensor->sens.Init.ROM = ROM;
-  
-  sensor->sens.Init.UserBytes12 = sensor->Location.all;
-  
-  sensor->sens.Init.init_func = &Dallas_SensorInitByROM;
-    
-  result = Dallas_AddNewSensors(onewire, &sensor->sens);
-  if(result != HAL_OK)
-  {
-    sensor->not_found = 1;  
-    return result;
-  }
-  
-  result = Dallas_WriteUserBytes(&sensor->sens, sensor->Location.all, sensor->Location.all, USED_USER_BYTES);
-  if(result != HAL_OK)
-    return result;
-
-  sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
-  
-  result = Dallas_AddNewSensors(onewire, &sensor->sens);  
-  if(result == HAL_OK)
-    sensor->not_found = 0;
-  else
-    sensor->not_found = 1;
-  
-  return result;
-}
-
-
-
-
-HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
-{   
-  HAL_StatusTypeDef result;
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;
-    
-//  sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
-  
-  sensor->sens.Init.UserBytes12 = sensor->Location.all;
-  
-  sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
-  
-  result = Dallas_AddNewSensors(onewire, &sensor->sens);
-  
-  if(result == HAL_OK)
-    sensor->not_found = 0;
-  else
-    sensor->not_found = 1;
-  
-  return result;
-}
-
-HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param)
-{
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(module == NULL)
-    return HAL_ERROR;
-  
-  PCHSens_LocationTypeDef initlocation;
-  initlocation.all = param;
-  
-  module->onewire = onewire;
-  module->refLocation = initlocation;
-  
-  module->sens1.Location.all = module->refLocation.all;
-  module->sens1.Location.param.Location = 0;
-  PCHSens_AddSensor(onewire, &module->sens1);
-  
-  module->sens2.Location.all = module->refLocation.all;
-  module->sens2.Location.param.Location = 1;
-  PCHSens_AddSensor(onewire, &module->sens2);
-  
-  module->sens3.Location.all = module->refLocation.all;
-  module->sens3.Location.param.Location = 2;
-  PCHSens_AddSensor(onewire, &module->sens3);
-  
-  module->sens4.Location.all = module->refLocation.all;
-  module->sens4.Location.param.Location = 3;
-  PCHSens_AddSensor(onewire, &module->sens4);
-  return HAL_OK;
-}
-
-
-HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module)
-{
-  HAL_StatusTypeDef result;
-  
-  if(module == NULL)
-    return HAL_ERROR;
-  
-  result = Dallas_StartConvertTAll(module->onewire, DALLAS_WAIT_BUS, 0);
-  
-  result = PCHSens_SensorHandleActions(module->onewire, &module->sens1);
-  result = PCHSens_SensorHandleActions(module->onewire, &module->sens2);
-  result = PCHSens_SensorHandleActions(module->onewire, &module->sens3);
-  result = PCHSens_SensorHandleActions(module->onewire, &module->sens4);
-   
-  PCHSens_DefineUnknownSensor(&UnknownSensors, NULL);
-  
-  return result;
-}
-
-
-HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
-{
-  HAL_StatusTypeDef result;
-  PCHSens_LocationTypeDef initlocation;
-  unsigned unknow_sensors_flag = 0;
-  
-  if(sensor == NULL)
-    return HAL_ERROR;
-  if(sensor->sens.isInitialized == 0)
-    return HAL_ERROR;
-  
-  if((sensor->sens.isLost == 1))
-  {
-    initlocation.param.Location = 0;
-    if(Dallas_ReplaceLostedSensor(&sensor->sens) != HAL_OK)
-    {
-      sensor->not_found = 1;
-    }
-    else
-    {
-      sensor->not_found = 0;      
-    }
-  }
-  return HAL_OK;
-}
-
-
-HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns)
-{  
-  HAL_StatusTypeDef result;
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(unknowns == NULL)
-    return HAL_ERROR;
-    
-  unknowns->onewire = onewire;  
-  unknowns->UnknownCnt = 0;
-  DALLAS_ScratchpadTypeDef scratchpad;
-  
-  PCHSens_LocationTypeDef *param = (PCHSens_LocationTypeDef *)&scratchpad.tHighRegister;
-  for(int i = 0; i < onewire->RomCnt; i++)
-  {    
-    /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-    result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
-    if(result != HAL_OK)
-      __NOP();
-    
-    if((IS_REG_SENS_LOCATION(param) == 0) ||
-      (IS_REG_PCH_LOCATION(param) == 0) ||
-      (IS_REG_PCH_NUMB(param) == 0) )
-    {
-      unknowns->unknown_sensors[unknowns->UnknownCnt].Init.SensInd = i;
-      unknowns->unknown_sensors[unknowns->UnknownCnt].Init.init_func = &Dallas_SensorInitByInd;
-      result = Dallas_AddNewSensors(onewire, &unknowns->unknown_sensors[unknowns->UnknownCnt++]);
-      if(result != HAL_OK)
-        __NOP();
-    }
-  }
-  return HAL_OK;
-}
-HAL_StatusTypeDef PCHSens_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  if(sensor == NULL)
-    return HAL_ERROR;
-  
-  if((unknowns->ROMtoDefine != NULL) && (unknowns->LocationtoDefine.all != NULL) && (unknowns->senstoDefine != NULL))
-  {
-    result = PCHSens_InitNewSensor(unknowns->onewire, unknowns->senstoDefine, unknowns->ROMtoDefine);    
-    unknowns->ROMtoDefine = 0;
-    unknowns->LocationtoDefine.all = 0;
-    unknowns->senstoDefine = 0;
-    return result;
-  }
-  return HAL_OK;
-}
-
-HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  if(sensor == NULL)
-    return HAL_ERROR;
-  
-  result = Dallas_WriteUserBytes(&sensor->sens, 0, 0, USED_USER_BYTES);
-  if(result != HAL_OK)
-  {
-    return result;
-  }
-  
-  result = Dallas_SensorDeInit(&sensor->sens);  
-  return result;
-}
-
-HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor)
-{
-  HAL_StatusTypeDef result;
-  if(sensor == NULL)
-    return HAL_ERROR;
-  
-  if(sensor->action.connectROM != NULL)
-  {
-    result = PCHSens_InitNewSensor(onewire, sensor, sensor->action.connectROM);    
-    sensor->action.connectROM = 0;
-  }
-  
-  if(sensor->action.read != NULL)
-  {
-//    sensor->action.read = 0;
-    result = Dallas_ReadTemperature(&sensor->sens);
-    if(result != HAL_OK)
-      PCHSens_CheckSensor(onewire, sensor);
-  }
-  
-  if(sensor->action.deinit != NULL)
-  {
-    sensor->action.deinit = 0;
-    result = PCHSens_UndefineSensor(sensor);
-  }
-  
-  return result;
-}
-
-void PCHSens_FirstInit(void)
-{  
-  int init_find = 0;
-  OW.DataPin = DS_Pin;
-  OW.DataPort = DS_GPIO_Port;
-  DS.Resolution = DS18B20_RESOLUTION_9BITS;  
-  
-	OneWire_Init(&OW);
-  DS18B20_Search(&DS, &OW);
-  
-  PCHSens_InitModule(&OW, &module1, REG_PCH_NUMB_11|REG_PCH_DIODE_NUMB_1);
-  
-  PCHSens_FindUnknownSensors(&OW, &UnknownSensors);
-  PCHSens_DefineUnknownSensor(&UnknownSensors, NULL);
-//  Dallas_SensorInitByInd(&OW, &AllSens.outdoor, 0);
-//  Dallas_SensorInitByInd(&OW, &AllSens.indoor, 2);
-//  Dallas_SensorInitByInd(&OW, &AllSens.bathroom, 1);
-//  Dallas_SensorInitByInd(&OW, &AllSens.kitchen, 3);
-//  Dallas_SensorInitByInd(&OW, &AllSens.big_room, 4);
-//  Dallas_SensorInitByInd(&OW, &AllSens.small_room, 5);
-//  Dallas_SensorInitByInd(&OW, &AllSens.living_room, 6);
-//  Dallas_SensorInitByInd(&OW, &AllSens.basement, 7);
-//  
-//  uint8_t mask = DALLAS_USER_BYTE_ALL;
-//  Dallas_WriteUserBytes(&AllSens.outdoor, 1, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.indoor, 2, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.bathroom, 3, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.kitchen, 4, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.big_room, 5, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.small_room, 6, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.living_room, 7, NULL, mask);
-//  Dallas_WriteUserBytes(&AllSens.basement, 8, NULL, mask);
-}
-
-
-
-
--- a/DS18B20/pch_sensors.h
+++ b/DS18B20/pch_sensors.h
@@ -1,174 +0,0 @@
-/**
-******************************************************************************
-* @file           pch_sensors.h
-* @brief          Ðàáîòà ñ äàò÷èêàìè òåìïåðàòóðû DS18B20 â Ï×
-******************************************************************************
-*****************************************************************************/
-
-#ifndef PCH_SENSORS_H
-#define PCH_SENSORS_H
-
-
-
-/* Includes -----------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
-#include "dallas_tools.h"
-
-/* Declarations and definitions ---------------------------------------------*/
-#define USED_USER_BYTES               DALLAS_USER_BYTE_12
-
-/* Ïîçèöèè ïàðàìåòðîâ â UserBytes */
-#define REG_SENS_LOCATION_Pos         (0)     /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
-
-#define REG_PCH_LOCATION_Pos          (8)     /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ðàñïîëîæåíèå â Ï×" */
-#define REG_PCH_DIOD_PHASE_Pos        (10)    /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Äèîäíûé èëè ôàçíûé ìîäóëü" @ref REG_PCH_LOCATION_Pos */
-#define REG_PCH_MODULE_NUMB_Pos       (8)     /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" @ref REG_PCH_LOCATION_Pos */
-
-#define REG_PCH_NUMB_Pos              (11)    /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
-#define REG_PCH_NUMB_DIGIT_1_Pos      (13)    /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" @ref REG_PCH_NUMB_Pos */
-#define REG_PCH_NUMB_DIGIT_2_Pos      (11)    /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" @ref REG_PCH_NUMB_Pos */
-    
-#define REG_ZIP_Pos                   (15)    /*!< @brief Ïîçèöèÿ ïàðàìåòðà "ÇÈÏ/íå ÇÈÏ" */
-
-/* Ìàñêè ïàðàìåòðîâ â UserBytes */
-#define REG_SENS_LOCATION_Mask        ((uint16_t)0x3 << REG_SENS_LOCATION_Pos)      /*!< @brief Ìàñêà ïàðàìåòðà "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
-
-#define REG_PCH_LOCATION_Mask         ((uint16_t)0x7 << REG_PCH_LOCATION_Pos)       /*!< @brief Ìàñêà ïàðàìåòðà "Ðàñïîëîæåíèå â Ï×" */
-#define REG_PCH_DIOD_PHASE_Mask       ((uint16_t)0x1 << REG_PCH_DIOD_PHASE_Pos)     /*!< @brief Ìàñêà ïàðàìåòðà "Äèîäíûé èëè ôàçíûé ìîäóëü" */
-#define REG_PCH_MODULE_NUMB_Mask      ((uint16_t)0x3 << REG_PCH_MODULE_NUMB_Pos)    /*!< @brief Ìàñêà ïàðàìåòðà "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
-
-#define REG_PCH_NUMB_Mask             ((uint16_t)0xF << REG_PCH_NUMB_Pos)           /*!< @brief Ìàñêà ïàðàìåòðà "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
-#define REG_PCH_NUMB_DIGIT_1_Mask     ((uint16_t)0x3 << REG_PCH_NUMB_DIGIT_1_Pos)   /*!< @brief Ìàñêà ïàðàìåòðà "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
-#define REG_PCH_NUMB_DIGIT_2_Mask     ((uint16_t)0x3 << REG_PCH_NUMB_DIGIT_2_Pos)   /*!< @brief Ìàñêà ïàðàìåòðà "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
-    
-#define REG_ZIP_Mask                  ((uint16_t)0x1 << REG_ZIP_Pos)                /*!< @brief Ìàñêà ïàðàìåòðà "ÇÈÏ/íå ÇÈÏ" */
-
-/* Âàðèàíòû ïàðàìåòðîâ â UserBytes */
-#define REG_PCH_NUMB_11               ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
-#define REG_PCH_NUMB_12               ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
-#define REG_PCH_NUMB_13               ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
-#define REG_PCH_NUMB_21               ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
-#define REG_PCH_NUMB_22               ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
-#define REG_PCH_NUMB_23               ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
-
-#define REG_PCH_DIODE_NUMB_1          ((0 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
-#define REG_PCH_DIODE_NUMB_2          ((0 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
-#define REG_PCH_DIODE_NUMB_3          ((0 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
-#define REG_PCH_PHASE_NUMB_1          ((1 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
-#define REG_PCH_PHASE_NUMB_2          ((1 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
-#define REG_PCH_PHASE_NUMB_3          ((1 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
-
-/* Ïîëó÷èòü ïàðàìåòð èç UserBytes */
-#define GET_REG_SENS_LOCATION(_REG_)      ((_REG_) & REG_SENS_LOCATION_Mask)      /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
-
-#define GET_REG_PCH_LOCATION(_REG_)       ((_REG_) & REG_PCH_LOCATION_Mask)       /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ðàñïîëîæåíèå â Ï×" */
-#define GET_REG_PCH_DIOD_PHASE(_REG_)     ((_REG_) & REG_PCH_DIOD_PHASE_Mask)     /*!< @brief Ïîëó÷èòü ïàðàìåòð "Äèîäíûé èëè ôàçíûé ìîäóëü" */
-#define GET_REG_PCH_MODULE_NUMB(_REG_)    ((_REG_) & REG_PCH_MODULE_NUMB_Mask)    /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
-
-#define GET_REG_PCH_NUMB(_REG_)           ((_REG_) & REG_PCH_NUMB_Mask)           /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
-#define GET_REG_PCH_NUMB_DIGIT_1(_REG_)   ((_REG_) & REG_PCH_NUMB_DIGIT_1_Mask)   /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
-#define GET_REG_PCH_NUMB_DIGIT_2(_REG_)   ((_REG_) & REG_PCH_NUMB_DIGIT_2_Mask)   /*!< @brief Ïîëó÷èòü ïàðàìåòð "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
-    
-#define GET_REG_ZIP(_REG_)                ((_REG_) & REG_ZIP_Mask)                /*!< @brief Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
-
-/* Äèàïàçîíû ïàðàìåòðîâ èç UserBytes */
-#define REG_SENS_LOCATION_MAX     3
-#define REG_SENS_LOCATION_MIN     0
-#define REG_PCH_DIOD_PHASE_MAX    1
-#define REG_PCH_DIOD_PHASE_MIN    0
-#define REG_PCH_MODULE_NUMB_MAX   3
-#define REG_PCH_MODULE_NUMB_MIN   0
-#define REG_PCH_NUMB_DIGIT_1_MAX  3
-#define REG_PCH_NUMB_DIGIT_1_MIN  1
-#define REG_PCH_NUMB_DIGIT_2_MAX  2
-#define REG_PCH_NUMB_DIGIT_2_MIN  1
-
-
-/** @brief Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
-#define IS_REG_SENS_LOCATION(_REG_)      (((_REG_)->param.Location <= REG_SENS_LOCATION_MAX) && ((_REG_)->param.Location >= REG_SENS_LOCATION_MIN))
-
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ðàñïîëîæåíèå â Ï×" */
-#define IS_REG_PCH_LOCATION(_REG_)       (IS_REG_PCH_DIOD_PHASE(_REG_) && IS_REG_PCH_MODULE_NUMB(_REG_))
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Äèîäíûé èëè ôàçíûé ìîäóëü" */
-#define IS_REG_PCH_DIOD_PHASE(_REG_)     (((_REG_)->param.DiodeOrPhase <= REG_PCH_DIOD_PHASE_MAX) && ((_REG_)->param.DiodeOrPhase >= REG_PCH_DIOD_PHASE_MIN))
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
-#define IS_REG_PCH_MODULE_NUMB(_REG_)    (((_REG_)->param.ModuleNumb <= REG_PCH_MODULE_NUMB_MAX) && ((_REG_)->param.ModuleNumb >= REG_PCH_MODULE_NUMB_MIN))
-
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
-#define IS_REG_PCH_NUMB(_REG_)           (IS_REG_PCH_NUMB_DIGIT_1(_REG_) && IS_REG_PCH_NUMB_DIGIT_2(_REG_)) 
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
-#define IS_REG_PCH_NUMB_DIGIT_1(_REG_)   (((_REG_)->param.PCHdig1 <= REG_PCH_NUMB_DIGIT_1_MAX) && ((_REG_)->param.PCHdig1 >= REG_PCH_NUMB_DIGIT_1_MIN))
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" s*/
-#define IS_REG_PCH_NUMB_DIGIT_2(_REG_)   (((_REG_)->param.PCHdig2 <= REG_PCH_NUMB_DIGIT_2_MAX) && ((_REG_)->param.PCHdig2 >= REG_PCH_NUMB_DIGIT_2_MIN))
-/*!< @brief Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
-#define IS_REG_ZIP(_REG_)                (GET_REG_ZIP(_REG_))
-
-typedef union
-{
-  uint16_t all;
-  struct
-  {
-    unsigned Location:2; 
-    unsigned reserved:6;
-    unsigned ModuleNumb:2;
-    unsigned DiodeOrPhase:1;
-    unsigned PCHdig2:2;
-    unsigned PCHdig1:2;
-    unsigned ZIP:1;
-  }param;
-}PCHSens_LocationTypeDef;
-
-
-typedef struct
-{
-  unsigned connectROM;
-  unsigned read;
-  unsigned deinit;
-}PCHSens_SensorActionsTypeDef;
-
-typedef struct
-{
-  DALLAS_HandleTypeDef          sens;
-//  PCHSens_LocationTypeDef       *UserBytes;
-  PCHSens_LocationTypeDef       Location;
-  PCHSens_SensorActionsTypeDef  action;
-  unsigned                      not_found:1;
-}PCHSens_SensorTypeDef;
-
-typedef struct
-{
-  OneWire_t                 *onewire;
-  
-  PCHSens_SensorTypeDef     sens1;
-  PCHSens_SensorTypeDef     sens2;
-  PCHSens_SensorTypeDef     sens3;
-  PCHSens_SensorTypeDef     sens4;
-  
-  PCHSens_LocationTypeDef   refLocation; 
-  
-}PCHSens_ModuleTypeDef;
-extern PCHSens_ModuleTypeDef module1;
-
-typedef struct
-{
-  OneWire_t               *onewire;
-  
-  DALLAS_HandleTypeDef    unknown_sensors[DS18B20_DEVICE_AMOUNT];
-  uint8_t                 UnknownCnt;
-  uint64_t                ROMtoDefine;
-  PCHSens_LocationTypeDef LocationtoDefine;
-  PCHSens_SensorTypeDef   *senstoDefine;
-}PCHSens_UnknownSensorsTypeDef;
-
-
-/* Functions ---------------------------------------------------------------*/
-HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns);
-HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM);
-HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
-HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param);
-HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module);
-HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
-HAL_StatusTypeDef PCHSens_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor);
-HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor);
-void PCHSens_FirstInit(void);
-#endif // #ifndef PCH_SENSORS_H
--- a/README.md
+++ b/README.md
@@ -1,3 +1,101 @@
-# DS18B20_Library
+# Библиотека для работы с датчиками температуры DS18B20 по 1-Wire

-Библиотека для работы с датчиками температуры Dallas DS18B20 по 1-Wire
+---
+
+## Описание
+
+Данная библиотека предоставляет драйвер для работы с цифровыми температурными датчиками DS18B20, подключёнными по однопроводному интерфейсу 1-Wire. Библиотека поддерживает:
+- Инициализация шины 1-Wire и обнаружение всех датчиков на шине
+- Инициализация датчика по:
+  - ROM-адресу
+  - Пользовательским байтам (TH, TL, UserByte3, UserByte4)
+  - Индексу (порядковому номеру) найденного устройства
+- Запуск преобразования температуры у всех или отдельных датчиков с выбором метода ожидания окончания преобразования (по шине или задержкой)
+- Чтение температуры и проверка статуса подключения датчика
+- Возможность замены потерянного датчика в структуре
+
+---
+
+## Быстрый старт
+
+### 1. Настройка порта и таймера для 1-Wire (файл `ow_port.h`):
+```c
+#define OW_GPIO_Port  GPIOB
+#define OW_Pin_Numb   0
+#define OW_Pin        (1 << OW_Pin_Numb)
+#define OW_TIM        TIM3
+#define OW_TIM_1US_PERIOD 24
+```
+
+### 2. Подключение библиотеки и инициализация таймера:
+```c
+#include "dallas_tools.h"
+
+MX_TIM_Init();  // Инициализация таймера (например, TIM3)
+```
+
+### 3. Инициализация шины и поиск датчиков:
+```c
+Dallas_BusFirstInit(&htim);
+```
+
+### 4. Инициализация структуры датчика по одному из методов:
+```c
+// Объявление хендлов датчиков
+DALLAS_SensorHandleTypeDef sens;
+
+// Инициализация по индексу (порядковому номеру найденного датчика)
+sens1.Init.init_func = &Dallas_SensorInitByInd;
+sens1.Init.InitParam.Ind = 0;
+
+// Инициализация по ROM-адресу
+sens.Init.init_func = &Dallas_SensorInitByROM;
+sens.Init.InitParam.ROM = rom_address;
+
+// Инициализация по пользовательским байтам
+sens.Init.init_func = &Dallas_SensorInitByUserBytes;
+sens.Init.InitParam.UserBytes.UserByte1 = 1;
+sens.Init.InitParam.UserBytes.UserByte2 = 2;
+sens.Init.InitParam.UserBytes.UserByte3 = 3;
+sens.Init.InitParam.UserBytes.UserByte4 = 4;
+
+// добавление датчика в структуру sens
+Dallas_AddNewSensors(&hdallas, &sens);
+```
+
+### 5. Запуск измерения и чтение температуры:
+```c
+Dallas_StartConvertTAll(&hdallas, DALLAS_WAIT_BUS, 0);
+Dallas_ReadTemperature(&sens);
+```
+
+---
+
+## Функции
+
+| Функция                                                  | Описание                                                   | 
+| -------------------------------------------------------- | ---------------------------------------------------------- | 
+| `Dallas_BusFirstInit(&htim)`           | Инициализация шины 1-Wire, запуск таймера и поиск датчиков |
+| `Dallas_AddNewSensors(&hdallas, &sensor)`                  | Инициализация структуры датчика и добавление в работу      |
+| `Dallas_ReplaceLostedSensor(&sensor)`                     | Замена потерянного датчика на новый, если доступен         |
+| `Dallas_StartConvertTAll(&hdallas, waitCondition, delay)` | Запуск преобразования температуры на всех датчиках         |
+| `Dallas_ConvertT(&sensor, waitCondition)`                 | Запуск преобразования температуры на одном датчике         |
+| `Dallas_ReadTemperature(&sensor)`                         | Чтение температуры с датчика                               |
+| `Dallas_IsConnected(&sensor)`                             | Проверка подключения датчика (чтение scratchpad)           |
+| `Dallas_WriteUserBytes(&sensor, bytes12, bytes34, mask)`  | Запись пользовательских байт в датчик                      |
+
+
+## Требуемые зависимости
+
+- Драйвер 1-Wire (`onewire.c/h`, `ow_port.c/h`)
+- Драйвер DS18B20 (`ds18b20_driver.c/h`)
+
+---
+
+## Примечания
+- Функции работы с датчиками возвращают статус в формате `HAL_StatusTypeDef`.
+- Ожидание окончания преобразования температуры настраивается через `DALLAS_WaitConvertionTypeDef`:
+  - `DALLAS_WAIT_BUS` — ожидание по состоянию линии 1-Wire.
+  - `DALLAS_WAIT_DELAY` — фиксированная задержка, зависящая от выбранного разрешения.
+  - `DALLAS_WAIT_NONE` — без ожидания (асинхронный режим).
+- При потере связи с датчиком функция `Dallas_IsConnected` помечает датчик как потерянный. Для восстановления работы можно вызвать `Dallas_ReplaceLostedSensor`, она будет искать датчик и пытаться его инициализировать по заданной функции инициализации.
--- a/ds18b20_locations.xlsx
+++ b/ds18b20_locations.xlsx
--- a/test_project/.mxproject
+++ b/test_project/.mxproject
--- a/test_project/Core/Inc/gpio.h
+++ b/test_project/Core/Inc/gpio.h
--- a/test_project/Core/Inc/main.h
+++ b/test_project/Core/Inc/main.h
@@ -36,6 +36,7 @@ extern "C" {

 /* Exported types ------------------------------------------------------------*/
 /* USER CODE BEGIN ET */
+
 /* USER CODE END ET */

 /* Exported constants --------------------------------------------------------*/
--- a/test_project/Core/Inc/stm32f1xx_hal_conf.h
+++ b/test_project/Core/Inc/stm32f1xx_hal_conf.h
--- a/test_project/Core/Inc/stm32f1xx_it.h
+++ b/test_project/Core/Inc/stm32f1xx_it.h
@@ -55,7 +55,6 @@ void SVC_Handler(void);
 void DebugMon_Handler(void);
 void PendSV_Handler(void);
 void SysTick_Handler(void);
-void TIM3_IRQHandler(void);
 /* USER CODE BEGIN EFP */

 /* USER CODE END EFP */
--- a/test_project/Core/Inc/tim.h
+++ b/test_project/Core/Inc/tim.h
--- a/test_project/Core/Inc/usart.h
+++ b/test_project/Core/Inc/usart.h
--- a/test_project/Core/Src/gpio.c
+++ b/test_project/Core/Src/gpio.c
@@ -54,7 +54,7 @@ void MX_GPIO_Init(void)
  HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
-  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_10, GPIO_PIN_RESET);
+  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_0, GPIO_PIN_RESET);

  /*Configure GPIO pin : PC13 */
  GPIO_InitStruct.Pin = GPIO_PIN_13;
@@ -63,8 +63,8 @@ void MX_GPIO_Init(void)
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOC, &GPIO_InitStruct);

-  /*Configure GPIO pin : PB10 */
-  GPIO_InitStruct.Pin = GPIO_PIN_10;
+  /*Configure GPIO pin : PB0 */
+  GPIO_InitStruct.Pin = GPIO_PIN_0;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
--- a/test_project/Core/Src/main.c
+++ b/test_project/Core/Src/main.c
@@ -24,7 +24,7 @@

 /* Private includes ----------------------------------------------------------*/
 /* USER CODE BEGIN Includes */
-#include "pch_sensors.h"
+#include "dallas_tools.h"
 /* USER CODE END Includes */

 /* Private typedef -----------------------------------------------------------*/
@@ -56,6 +56,7 @@ void SystemClock_Config(void);

 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
+DALLAS_SensorHandleTypeDef sens;
 /* USER CODE END 0 */

 /**
@@ -87,31 +88,28 @@ int main(void)

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
-  MX_USART1_UART_Init();
  MX_TIM3_Init();
+  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */
-
-  /* Initialize DWT Delay */
-  __HAL_RCC_GPIOB_CLK_ENABLE();
-  DwtInit();
-  /* Set parameter and initialize DS18B20 */
-	/* Initialize OneWire and reset all data */
-  PCHSens_FirstInit();
+#ifndef UART_Driver
+  Dallas_BusFirstInit(&hdallas, OW_GPIO_Port, OW_Pin);
+#else
+  Dallas_BusFirstInit(&hdallas, &huart1);
+#endif
+  sens.Init.InitParam.Ind = 0;
+  sens.Init.init_func = &Dallas_SensorInitByInd;
+  sens.Init.Resolution = DALLAS_CONFIG_12_BITS;
+  Dallas_AddNewSensors(&hdallas, &sens);
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
-    PCHSens_ReadTemperature(&module1);
-//    Dallas_ReadAll();
-		/* Start temperature conversion on all devices on one bus */
-//		DS18B20_StartConvTAll(&OW);
-//    DS18B20_WaitForEndConvertion(&OW);
-
-
-		/* Search Alarm triggered and store in DS data structure */
-//		DS18B20_AlarmSearch(&DS, &OW);
+    Dallas_StartConvertTAll(&hdallas, DALLAS_WAIT_BUS, 0);
+    Dallas_ReadTemperature(&sens);
+    
+    GPIOC->ODR ^= (1<<13);
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
--- a/test_project/Core/Src/stm32f1xx_hal_msp.c
+++ b/test_project/Core/Src/stm32f1xx_hal_msp.c
--- a/test_project/Core/Src/stm32f1xx_it.c
+++ b/test_project/Core/Src/stm32f1xx_it.c
@@ -55,7 +55,7 @@
 /* USER CODE END 0 */

 /* External variables --------------------------------------------------------*/
-extern TIM_HandleTypeDef htim3;
+
 /* USER CODE BEGIN EV */

 /* USER CODE END EV */
@@ -198,20 +198,6 @@ void SysTick_Handler(void)
 /* please refer to the startup file (startup_stm32f1xx.s).                    */
 /******************************************************************************/

-/**
-  * @brief This function handles TIM3 global interrupt.
-  */
-void TIM3_IRQHandler(void)
-{
-  /* USER CODE BEGIN TIM3_IRQn 0 */
-
-  /* USER CODE END TIM3_IRQn 0 */
-  HAL_TIM_IRQHandler(&htim3);
-  /* USER CODE BEGIN TIM3_IRQn 1 */
-
-  /* USER CODE END TIM3_IRQn 1 */
-}
-
 /* USER CODE BEGIN 1 */

 /* USER CODE END 1 */
--- a/test_project/Core/Src/system_stm32f1xx.c
+++ b/test_project/Core/Src/system_stm32f1xx.c
--- a/test_project/Core/Src/tim.c
+++ b/test_project/Core/Src/tim.c
@@ -43,7 +43,7 @@ void MX_TIM3_Init(void)
  htim3.Instance = TIM3;
  htim3.Init.Prescaler = 0;
  htim3.Init.CounterMode = TIM_COUNTERMODE_UP;
-  htim3.Init.Period = 72-1;
+  htim3.Init.Period = 65535;
  htim3.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim3.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init(&htim3) != HAL_OK)
@@ -77,10 +77,6 @@ void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
  /* USER CODE END TIM3_MspInit 0 */
    /* TIM3 clock enable */
    __HAL_RCC_TIM3_CLK_ENABLE();
-
-    /* TIM3 interrupt Init */
-    HAL_NVIC_SetPriority(TIM3_IRQn, 0, 0);
-    HAL_NVIC_EnableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspInit 1 */

  /* USER CODE END TIM3_MspInit 1 */
@@ -97,9 +93,6 @@ void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
  /* USER CODE END TIM3_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM3_CLK_DISABLE();
-
-    /* TIM3 interrupt Deinit */
-    HAL_NVIC_DisableIRQ(TIM3_IRQn);
  /* USER CODE BEGIN TIM3_MspDeInit 1 */

  /* USER CODE END TIM3_MspDeInit 1 */
--- a/test_project/Core/Src/usart.c
+++ b/test_project/Core/Src/usart.c
@@ -74,7 +74,6 @@ void HAL_UART_MspInit(UART_HandleTypeDef* uartHandle)
    */
    GPIO_InitStruct.Pin = GPIO_PIN_9;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
-    GPIO_InitStruct.Pull = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);

--- a/test_project/Drivers/CMSIS/Include/cmsis_armcc.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_armcc.h
--- a/test_project/Drivers/CMSIS/Include/cmsis_armclang.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_armclang.h
--- a/test_project/Drivers/CMSIS/Include/cmsis_compiler.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_compiler.h
--- a/test_project/Drivers/CMSIS/Include/cmsis_gcc.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_gcc.h
--- a/test_project/Drivers/CMSIS/Include/cmsis_iccarm.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_iccarm.h
--- a/test_project/Drivers/CMSIS/Include/cmsis_version.h
+++ b/test_project/Drivers/CMSIS/Include/cmsis_version.h
--- a/test_project/Drivers/CMSIS/Include/core_armv8mbl.h
+++ b/test_project/Drivers/CMSIS/Include/core_armv8mbl.h
--- a/test_project/Drivers/CMSIS/Include/core_armv8mml.h
+++ b/test_project/Drivers/CMSIS/Include/core_armv8mml.h
--- a/test_project/Drivers/CMSIS/Include/core_cm0.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm0.h
--- a/test_project/Drivers/CMSIS/Include/core_cm0plus.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm0plus.h
--- a/test_project/Drivers/CMSIS/Include/core_cm1.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm1.h
--- a/test_project/Drivers/CMSIS/Include/core_cm23.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm23.h
--- a/test_project/Drivers/CMSIS/Include/core_cm3.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm3.h
--- a/test_project/Drivers/CMSIS/Include/core_cm33.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm33.h
--- a/test_project/Drivers/CMSIS/Include/core_cm4.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm4.h
--- a/test_project/Drivers/CMSIS/Include/core_cm7.h
+++ b/test_project/Drivers/CMSIS/Include/core_cm7.h
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Razvalyaev	5cc733f4d2	сделана инициализация всей периферии для OW в Dallas_BusFirstInit можно выбрать дефолтную периферию, передав в фукнию NULL, а можно и свою кастомную, типа Dallas_BusFirstInit(&hdallas, GPIOA, GPIO_PIN_2); надо теперь расписать все в ридми	2025-06-30 19:00:42 +03:00
Razvalyaev	fad8b2551a	глобальные структуруы OW и DS перенесены в hdallas напрямую, без указателей и соответственно укорочены аргументы Dallas_BusFirstInit	2025-06-30 18:39:10 +03:00
Razvalyaev	fa32d653e8	добавлена реализация onewire через uart и переделана структуруа шины OneWire и инциализация Теперь при выборе UART, в функцию Dallas_BusFirstInit передается hdallas, huart, ow, ds А при выборе GPIO ножки: hdallas, gpiox, gpio_pin, ow, ds но надо как-то структуруизировать дальше	2025-06-30 18:34:17 +03:00
Razvalyaev	175bcd539f	Обновить README.md	2025-06-22 20:35:10 +03:00
Razvalyaev	2e1b08b11b	Обновить README.md	2025-06-22 20:34:39 +03:00
Razvalyaev	dbbf9f8f62	Обновить README.md	2025-06-21 09:18:25 +03:00
Razvalyaev	72767cece9	+readme	2025-06-21 09:16:35 +03:00
Razvalyaev	36339503eb	доавбелно настройка ow_port в шапку dallas_tools	2025-06-21 09:08:25 +03:00
Razvalyaev	7ef076e289	чуть структурирована, добавлено описение по подключению в шапке добавлен пример для stm32	2025-06-21 09:05:50 +03:00
Razvalyaev	c2dca42be6	библиотека для stm32f103	2025-06-20 14:46:25 +03:00
Razvalyaev	0689046c85	Обновлена библиотека для датчиков с py32 модуля	2025-03-05 11:45:32 +03:00