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

можно выбрать дефолтную периферию, передав в фукнию NULL, а можно и свою кастомную, типа

  Dallas_BusFirstInit(&hdallas, GPIOA, GPIO_PIN_2);

надо теперь расписать все в ридми

DS18B20/dallas_tools.c

@@ -1,288 +1,244 @@
 /**
 ******************************************************************************
 * @file           dallas_tools.c
-* @brief          Äðàéâåð äëÿ ðàáîòû ñ äàò÷èêàìè òåìïåðàòóðû DS18B20
+* @brief          Драйвер для работы с датчиками температуры DS18B20
-* @author         MicroTechnics (microtechnics.ru)
 ******************************************************************************
-@details        
+@details
-Ýòîò ôàéë ñîäåðæèò ðåàëèçàöèþ ôóíêöèé äëÿ ðàáîòû ñ äàò÷èêîì DALLAS_HandleTypeDef 
+Библиотека предназначена для работы с цифровыми датчиками температуры DS18B20 
-÷åðåç èíòåðôåéñ 1-Wire. Îí ïðåäîñòàâëÿåò ôóíêöèè äëÿ ÷òåíèÿ è çàïèñè 
+по однопроводному интерфейсу 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
+==============================================================================
 *****************************************************************************/
 
 
 /* Includes ----------------------------------------------------------------*/
 
 #include "dallas_tools.h"
+#include "string.h"
 
 
 /* Declarations and definitions --------------------------------------------*/
-
+DALLAS_HandleTypeDef hdallas;
-struct
-{
-DALLAS_HandleTypeDef outdoor;
-DALLAS_HandleTypeDef indoor;
-DALLAS_HandleTypeDef bathroom;
-DALLAS_HandleTypeDef kitchen;
-DALLAS_HandleTypeDef big_room;
-DALLAS_HandleTypeDef small_room;
-DALLAS_HandleTypeDef living_room;
-DALLAS_HandleTypeDef basement;
-}AllSens;
 
 /* Functions ---------------------------------------------------------------*/
 
-void Dallas_ReadAll(void)
+/**
+ * @brief  Функция для иниицализации структуры dallas и шины OW для датчиков
+ * @param  hdallas  Указатель на хендл для общения с датчиками
+ * @param  OW       Указатель на структуру OneWire (если NULL — используется по умолчанию)
+ * @param  DS       Указатель на структуру драйвера DS18B20 (если NULL — используется по умолчанию)
+ * @retval HAL Status
+ */
+#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
 {
-  HAL_StatusTypeDef result;
+  if(hdallas == NULL)
+    return HAL_ERROR;
   
-  result = Dallas_StartConvertTAll(&OW, DALLAS_WAIT_BUS, 0);
+#ifndef UART_Driver
-  result = Dallas_ReadTemperature(&AllSens.outdoor);    
+  OW_TIM->CR1 |= TIM_CR1_CEN;
-  result = Dallas_ReadTemperature(&AllSens.indoor);
+  if(GPIOx == NULL)
-  result = Dallas_ReadTemperature(&AllSens.bathroom);
+  {   
-  result = Dallas_ReadTemperature(&AllSens.kitchen);
+    hdallas->onewire.DataPin = OW_Pin;
-  result = Dallas_ReadTemperature(&AllSens.big_room);
+    hdallas->onewire.DataPort = OW_GPIO_Port;  
-  result = Dallas_ReadTemperature(&AllSens.small_room);
+  }
-  result = Dallas_ReadTemperature(&AllSens.living_room);
+  else
-  result = Dallas_ReadTemperature(&AllSens.basement);
+  {   
+    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);
 }
 
-void Dallas_FirstInit(void)
+/**
-{  
+ * @brief  Поиск датчиков на шине onewire
-  OW.DataPin = DS_Pin;
+ * @param  hdallas        Указатель на хендл для общения с датчиками
-  OW.DataPort = DS_GPIO_Port;
+ * @retval HAL Status
-  DS.Resolution = DS18B20_RESOLUTION_9BITS;  
+ */
+HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas)
+{
+  if(hdallas == NULL)
+    return HAL_ERROR;
   
-	OneWire_Init(&OW);
+  return DS18B20_Search(&hdallas->ds_devices, &hdallas->onewire) != HAL_OK;
-  DS18B20_Search(&DS, &OW);
-  
-  Dallas_SensorInitByROM(&OW, &AllSens.outdoor, 0x28C60C61060000DC);
-  Dallas_SensorInitByROM(&OW, &AllSens.indoor, 0x283E4861060000F9);
-  Dallas_SensorInitByROM(&OW, &AllSens.bathroom, 0x28876D60060000CD);
-  
-  
-  uint8_t mask = DALLAS_USER_BYTE_ALL;
-//  Dallas_SensorInitByUserBytes(&OW, &AllSens.outdoor, 1, NULL);
-//  Dallas_SensorInitByUserBytes(&OW, &AllSens.indoor, 2, NULL);
-//  Dallas_SensorInitByUserBytes(&OW, &AllSens.bathroom, 3, NULL);
-  
-//  Dallas_SensorInitByInd(&OW, &AllSens.outdoor, 0);
-//  Dallas_SensorInitByInd(&OW, &AllSens.indoor, 1);
-//  Dallas_SensorInitByInd(&OW, &AllSens.bathroom, 2);
-//  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);
-//  
-//  
-//  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);
 }
 
 
+
 /**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî èíäåêó
+ * @brief  Функция для иниицализации нового датчика в структуре
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
+ * @param  hdallas        Указатель на хендл для общения с датчиками
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @param  sensor         Указатель на структуру датчика
- * @param  ROM            Óêàçàòåëü íà ROM äëÿ îïðåäåëåíèÿ íóæíîãî äàò÷èêà
  * @retval HAL Status
  */
-HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint64_t intROM)
+HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
 {
   HAL_StatusTypeDef result;
-  sensor->isInitialized = 0;
+  
-  if(onewire == NULL)
+  if(hdallas == NULL)
     return HAL_ERROR;
   if(sensor == NULL)
     return HAL_ERROR;  
-  sensor->onewire = onewire;
   
-  uint8_t ROM[8] = {0};
+  sensor->hdallas = hdallas;
-  ROM[0] = (intROM >> (7*8)) & 0xFF;
+  
-  ROM[1] = (intROM >> (6*8)) & 0xFF;
+  result = sensor->Init.init_func(hdallas, sensor);
-  ROM[2] = (intROM >> (5*8)) & 0xFF;
+  
-  ROM[3] = (intROM >> (4*8)) & 0xFF;
+  return result;
-  ROM[4] = (intROM >> (3*8)) & 0xFF;
+}
-  ROM[5] = (intROM >> (2*8)) & 0xFF;
+
-  ROM[6] = (intROM >> (1*8)) & 0xFF;
+
-  ROM[7] = (intROM) & 0xFF;
+
+
+/**
+ * @brief  Функция для нахождения нового датчика на место потерянного
+ * @param  sensor         Указатель на структуру датчика
+ * @retval HAL Status 
+ */
+HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
+{
+  HAL_StatusTypeDef result;
   
   
-  uint8_t comparebytes = DALLAS_ROM_SIZE;
+  if(sensor == NULL)
-  for(int i = 0; i < DS18B20_DEVICE_AMOUNT; i++)
+    return HAL_ERROR;  
+  
+  result = Dallas_IsConnected(sensor);
+  
+  if(sensor->isLost)
   {
-    comparebytes = DALLAS_ROM_SIZE;
+    if(Dallas_Search(sensor->hdallas) != HAL_OK)
-    for(int rom_byte = 0; rom_byte < DALLAS_ROM_SIZE; rom_byte++)
+      return HAL_ERROR;
-    {
+    
-      if(DS.DevAddr[i][rom_byte] == ROM[rom_byte])
+    if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)
-        comparebytes--;
+      return HAL_ERROR;
-    }
-    if(comparebytes == 0)
-    {
-      sensor->sensROM = &DS.DevAddr[i];
-      break;
-    }
-  }
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-  
-  if(comparebytes == 0)
-  {
-    result = Dallas_IsConnected(sensor);
-    if(result != HAL_OK)
-      return result;
     
-    sensor->isInitialized = 1;
     return HAL_OK;
   }
   else
   {
-    return HAL_ERROR;
+    return HAL_BUSY; // датчик не потерян
   }
-  
-  
-}
-
-
-
-/**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîëüçîâàòåëüñêèì áàéòàì
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  UserBytes34    Ïîëüçîâàòåëüñêèå áàéòû 3 è 4, NULL äëÿ èãíîðà
- * @param  UserBytes12    Ïîëüçîâàòåëüñêèå áàéòû 1 è 2, NULL äëÿ èãíîðà
- * @retval HAL Status
- * @details ñòàðøèé áàéò - UserByte4/UserByte2, ìëàäøèé - UserByte3/UserByte1.
- */
-HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34)
-{
-  HAL_StatusTypeDef result;
-  sensor->isInitialized = 0;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-  sensor->onewire = onewire;
-  
-  uint8_t UserByte1 = UserBytes12 & 0xFF;
-  uint8_t UserByte2 = UserBytes12 >> 8;
-  uint8_t UserByte3 = UserBytes34 & 0xFF;
-  uint8_t UserByte4 = UserBytes34 >> 8;
-  uint8_t UserByte12Cmp = 0;
-  uint8_t UserByte34Cmp = 0;
-    
-  for(int i = 0; i < DS18B20_DEVICE_AMOUNT; i++)
-  {
-    UserByte12Cmp = 0; UserByte34Cmp = 0;
-    sensor->sensROM = &DS.DevAddr[i];
-     
-    /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-    result = Dallas_IsConnected(sensor);
-    if (result != HAL_OK)
-      return result;
-
-    
-    /* Ñðàâíåíèå UserByte1 è UserByte2, åñëè âûáðàíî */
-    if(UserBytes12 != NULL)
-    {
-      if( (sensor->scratchpad.tHighRegister == UserByte1) &&
-          (sensor->scratchpad.tLowRegister == UserByte2))
-      {
-        UserByte12Cmp = 1;
-      }
-    }/* Åñëè ðàâíåíèå UserByte1 è UserByte2 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè îäèíàêîâûå */
-    else
-    {
-      UserByte12Cmp = 1;
-    }
-    /* Ñðàâíåíèå UserByte3 è UserByte4, åñëè âûáðàíî */
-    if(UserBytes34 != NULL)
-    {
-      if( (sensor->scratchpad.UserByte3 == UserByte3) &&
-          (sensor->scratchpad.UserByte4 == UserByte4))
-      {
-        UserByte34Cmp = 1;
-      }
-    }/* Åñëè ðàâíåíèå UserByte3 è UserByte4 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè îäèíàêîâûå */
-    else
-    {
-      UserByte34Cmp = 1;
-    }
-    /* Åñëè íàøëè íóæíûé äàò÷èê - çàâåðøàåì ïîèñê */
-    if(UserByte12Cmp && UserByte34Cmp)
-    {
-      sensor->isInitialized = 1;
-      return HAL_OK;
-    }
-  }
-  /* Âîçâðàùàåì îøèáêó åñëè íå íàøëè */
-  return HAL_ERROR;
-}
-
-/**
- * @brief  Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî èíäåêó
- * @param  onewire        Óêàçàòåëü íà ñòðóêòóðó OneWire
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
- * @param  sens_ind       Ïîðÿäêîâûé íîìåð äàò÷èêà â ñòðóêòóðå
- * @retval HAL Status
- * @details Èíäåêñ - ýòî ïîðÿäêîâûé íîìåð äàò÷èêà â ñïèñêå íàéäåííûõ.
- *          Ò.å. êàêèì ïî ñ÷åòó ýòîò äàò÷èê áûë íàéäåí
- */
-HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t sens_ind)
-{
-  HAL_StatusTypeDef result;
-  sensor->isInitialized = 0;
-  
-  if(onewire == NULL)
-    return HAL_ERROR;
-  if(sensor == NULL)
-    return HAL_ERROR;  
-  sensor->onewire = onewire;
-  
-  sensor->sensROM = &DS.DevAddr[sens_ind];
-   
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
-  result = Dallas_IsConnected(sensor);
-  if (result != HAL_OK)
-    return result;
-  
-  sensor->isInitialized = 1;
-  return HAL_OK;
 }
 
 
 /**
- * @brief  Çàïóñêàåò èçìåðåíèå òåìïåðàòóðû íà âñåõ äàò÷èêàõ
+ * @brief  Запускает измерение температуры на всех датчиках
- * @param  waitCondition Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
+ * @param  hdallas        Указатель на хендл для общения с датчиками
+ * @param  waitCondition    Условие ожидания завершения преобразования
+ * @param  dallas_delay_ms  Время ожидания окончания конверсии
  * @retval HAL Status
  */
-HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitCondition 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(hdallas == NULL)
-  result = DS18B20_StartConvTAll(onewire);
+    return HAL_ERROR;
+  
+  // Отправка команды начала преобразования температуры
+  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;
@@ -316,32 +272,37 @@ HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConditi
 }
 
 /**
- * @brief  Èçìåðÿåò òåìïåðàòóðó íà äàò÷èêå
+ * @brief  Измеряет температуру на датчике
- * @param  sensor        Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @param  sensor        Указатель на структуру датчика
- * @param  waitCondition Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
+ * @param  waitCondition Условие ожидания завершения преобразования
  * @retval HAL Status
  */
-HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitCondition waitCondition)
+HAL_StatusTypeDef Dallas_ConvertT(DALLAS_SensorHandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
 {
   HAL_StatusTypeDef result;
   uint8_t rxDummyData;
   
-  /* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
+  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_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++;
@@ -349,12 +310,12 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitCondi
     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;
@@ -379,7 +340,7 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitCondi
     HAL_Delay(delayValueMs);
   }
   
-  /* Íå ñ÷èòûâàåì òåìïåðàòóðó, åñëè íå âûáðàíî îæèäàíèå îêîí÷àíèÿ ïðåîáðàçîâàíèÿ */
+  /* Не считываем температуру, если не выбрано ожидание окончания преобразования */
   if(waitCondition != DALLAS_WAIT_NONE)
   {
     result = Dallas_ReadTemperature(sensor);
@@ -390,21 +351,28 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitCondi
 
 
 /**
- * @brief  ×èòàåò ñîäåðæèìîå ïàìÿòè (scratchpad) äàò÷èêà DALLAS_HandleTypeDef
+ * @brief  Читает измеренную датчиком температуру
- * @param  sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @param  sensor Указатель на структуру датчика
  * @retval HAL Status
  */
-HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
+HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_SensorHandleTypeDef *sensor)
 {
   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_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)
   {
@@ -416,53 +384,71 @@ HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
 }
 
 /**
- * @brief  Âûïîëíÿåò êîìàíäó èíèöèàëèçàöèè DALLAS_HandleTypeDef
+ * @brief  Проверяет подключен ли датчик (чтение scratchpad)
- * @param  sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @param  sensor Указатель на структуру датчика
  * @retval HAL Status
  */
-HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
+HAL_StatusTypeDef Dallas_IsConnected(DALLAS_SensorHandleTypeDef *sensor)
 {
   HAL_StatusTypeDef result;
-   
+  if(sensor == NULL)
-  result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)sensor->sensROM, (uint8_t *)&sensor->scratchpad);
+    return HAL_ERROR;
+     
+  result = Dallas_ReadScratchpad(sensor);
   
   if (result == HAL_OK)
   {
     sensor->isConnected = 1;
+    sensor->isLost = 0;
     return HAL_OK;
   }
   else
   {
+    sensor->temperature = 0;
     if(sensor->isConnected == 1)
     {
       sensor->f.disconnect_cnt++;
     }
+    sensor->isLost = 1;
     sensor->isConnected = 0;
-    return HAL_BUSY; // èñïîëüçóþ busy, ÷òîáû îòëè÷àòü ñèòóàöèþ îò HAL_ERROR
+    
+//    Dallas_ReplaceLostedSensor(sensor);
+    return HAL_BUSY; // использую busy, чтобы отличать ситуацию от HAL_ERROR
   }
 }
 
 /**
- * @brief  Çàïèñûâàåò ïîëüçîâàòåëüñêèå áàéòû
+ * @brief  Записывает пользовательские байты
- * @param  sensor         Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+ * @param  sensor         Указатель на структуру датчика
- * @param  UserBytes12    Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
+ * @param  UserBytes12    Пользовательские байты 1 и 2
- * @param  UserBytes34    Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
+ * @param  UserBytes34    Пользовательские байты 3 и 4
- * @param  UserBytesMask  Ìàñêà, êàêèå áàéòû çàïèñûâàòü, à êàêèå íåò
+ * @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 = DS18B20_WriteUserBytes(sensor->onewire, (uint8_t *)sensor->sensROM, UserBytes12, UserBytes34, 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->hdallas->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
   if (result != HAL_OK)
   {
-    sensor->f.read_temperature_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)
   {
-    sensor->f.read_temperature_err_cnt++;
     return result;
   }  
   
@@ -470,26 +456,229 @@ HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t U
 }
 
 
-///**
+HAL_StatusTypeDef Dallas_ReadScratchpad(DALLAS_SensorHandleTypeDef *sensor)
-// * @brief  ×èòàåò óíèêàëüíûé ROM-êîä äàò÷èêà DALLAS_HandleTypeDef
+{
-// * @param  sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
+  if(sensor == NULL)
-// * @retval HAL Status
+    return HAL_ERROR;
-// */
+  return DS18B20_ReadScratchpad(&sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad);
-//HAL_StatusTypeDef Dallas_ReadRom(DALLAS_HandleTypeDef *sensor)
+}
-//{
-//  HAL_StatusTypeDef result = HAL_OK;
-//  uint8_t rxData[DALLAS_READ_ROM_RX_BYTES_NUM];
-//  
-//  DS18B20_ReadScratchpad(sensor->onewire, sensor->sensROM, (uint8_t *)&sensor->scratchpad);
-//  
-//  
-//  if (result == HAL_OK)
-//  {
-//    for (uint8_t i = 0; i < DALLAS_SERIAL_NUMBER_LEN_BYTES; i++)
-//    {
-//      sensor->sensROM[i] = rxData[DALLAS_SERIAL_NUMBER_OFFSET_BYTES + i];
-//    }
-//  }
 
-//  return result;
+/**
-//}
+ * @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;
+}

DS18B20/dallas_tools.h

@@ -1,44 +1,36 @@
 /**
 ******************************************************************************
-* @file           : dallas_tools.h
+* @file           dallas_tools.h
-* @brief          : DALLAS driver
+* @brief          Драйвер датчиков температуры DALLAS
-* @author         : MicroTechnics (microtechnics.ru)
+******************************************************************************
+* Этот файл предоставляет объявления и определения для работы с датчиками 
+* температуры DS18B20. Он включает структуры данных, макросы и прототипы 
+* функций для инициализации, чтения температуры 
+* и управления датчиками.
+*
+* Работа с датчиками ведётся через протокол OneWire.
 *****************************************************************************/
 
 #ifndef DALLAS_TOOLS_H
 #define DALLAS_TOOLS_H
 
-
-
 /* Includes -----------------------------------------------------------------*/
-#include "stm32f1xx_hal.h"
+#include "ds18b20_driver.h"
-#include "ds18b20.h"
 #include "onewire.h"
 
 
-#define DALLAS_USER_BYTE_1                          (1<<0)
+/* Определения пользовательских байтов для записи чтения */
-#define DALLAS_USER_BYTE_2                          (1<<1)
+#define DALLAS_USER_BYTE_1    (1<<0)  ///< Первый пользовательский байт
-#define DALLAS_USER_BYTE_3                          (1<<2)
+#define DALLAS_USER_BYTE_2    (1<<1)  ///< Второй пользовательский байт
-#define DALLAS_USER_BYTE_4                          (1<<3)
+#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_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_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_ALL                        (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34)
 
 /* Declarations and definitions ---------------------------------------------*/
-#define DALLAS_ROM_SIZE                                              8
+#define DALLAS_ROM_SIZE                                                   8
-#define DALLAS_SERIAL_NUMBER_LEN_BYTES                                    6
-#define DALLAS_SERIAL_NUMBER_OFFSET_BYTES                                 1
-
-#define DALLAS_SCRATCHPAD_T_LSB_BYTE_IDX                                  0
-#define DALLAS_SCRATCHPAD_T_MSB_BYTE_IDX                                  1
-#define DALLAS_SCRATCHPAD_T_LIMIT_H_BYTE_IDX                              2
-#define DALLAS_SCRATCHPAD_T_LIMIT_L_BYTE_IDX                              3
-#define DALLAS_SCRATCHPAD_CONFIG_BYTE_IDX                                 4
-#define DALLAS_SCRATCHPAD_USER_BYTE_3_IDX                                 6
-#define DALLAS_SCRATCHPAD_USER_BYTE_4_IDX                                 7
-#define DALLAS_SCRATCHPAD_CRC_IDX                                         8
 
 #define DALLAS_CONFIG_9_BITS                                              0x1F
 #define DALLAS_CONFIG_10_BITS                                             0x3F
@@ -51,96 +43,127 @@
 #define DALLAS_DELAY_MS_12_BITS                                           750
 #define DALLAS_DELAY_MS_MAX                                               DALLAS_DELAY_MS_12_BITS
 
-#define DALLAS_9_BITS_DATA_MASK                                           0x7F8
+typedef struct _SensorHandleStruct DALLAS_SensorHandleTypeDef;
-#define DALLAS_10_BITS_DATA_MASK                                          0x7FC
+typedef struct _DallasHandleStruct DALLAS_HandleTypeDef;
-#define DALLAS_11_BITS_DATA_MASK                                          0x7FE
-#define DALLAS_12_BITS_DATA_MASK                                          0x7FF
-
-#define DALLAS_SIGN_MASK                                                  0xF800
-
-#define DALLAS_T_STEP                                                     0.0625
-
-#define DALLAS_READ_ROM_RX_BYTES_NUM                                      8
-#define DALLAS_READ_SCRATCHPAD_RX_BYTES_NUM                               9
-
 
+/** @brief Структура Scratchpad датчика DALLAS */
 typedef struct
 {
-  uint8_t TemperatureLSB;
+  uint8_t TemperatureLSB;   ///< Младший байт температуры
-  uint8_t TemperatureMSB;
+  uint8_t TemperatureMSB;   ///< Старший байт температуры
-  uint8_t tHighRegister;
+  uint8_t tHighRegister;    ///< Верхний температурный порог
-  uint8_t tLowRegister;
+  uint8_t tLowRegister;     ///< Нижний температурный порог
-  uint8_t ConfigRegister;
+  uint8_t ConfigRegister;   ///< Конфигурационный регистр
-  uint8_t reserved;
+  uint8_t reserved;         ///< Зарезервировано
-  uint8_t UserByte3;
+  uint8_t UserByte3;        ///< Пользовательский байт 3
-  uint8_t UserByte4;
+  uint8_t UserByte4;        ///< Пользовательский байт 4
-  uint8_t ScratchpadCRC;
+  uint8_t ScratchpadCRC;    ///< Контрольная сумма
 }DALLAS_ScratchpadTypeDef;
 
+/** @brief Структура флагов ошибок датчиков DALLAS */
 typedef struct
 {
-  unsigned disconnect_cnt;
+  uint8_t disconnect_cnt;            ///< Счетчик отключений датчика
-  unsigned read_temperature_err_cnt;
+  uint8_t read_temperature_err_cnt;  ///< Счетчик ошибок чтения температуры
-  unsigned timeout_convertion_cnt;
+  uint8_t timeout_convertion_cnt;    ///< Счетчик ошибок таймаута конвертации
-  
+  uint8_t write_err_cnt;             ///< Счетчик других ошибок
 }DALLAS_FlagsTypeDef;
 
-typedef struct
+
+/** @brief Структура инициализации датчика DALLAS */
+typedef struct __packed
 {
-  uint8_t                   isConnected;
+  union
-  uint8_t                   isInitialized;
+  {
-#ifdef ONEWIRE_UART_H
+    uint64_t  Ind;          ///< порядковый номер датчика
-  UART_HandleTypeDef        *uart;
+    uint64_t  ROM;          ///< ROM датчика
-#else
+    struct  
-  OneWire_t                 *onewire;
+    {
-#endif
+      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;
 
-  uint8_t                   (*sensROM)[DALLAS_ROM_SIZE];
+
-  DALLAS_ScratchpadTypeDef  scratchpad;
+
-  float                     temperature;
+/** @brief Cтруктура обработчика DALLAS для общения с датчиком*/
+struct _DallasHandleStruct
+{
+  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;                 ///< Флаг потери связи
   
+  DALLAS_HandleTypeDef      *hdallas;
+  uint64_t                  sensROM;                  ///< ROM-код датчика
   
-  DALLAS_FlagsTypeDef       f;
+  float                     temperature;              ///< Текущая температура
   
-}DALLAS_HandleTypeDef;
+  DALLAS_InitStructTypeDef  Init;                     ///< Структура инициализации
-extern DALLAS_HandleTypeDef outdoor;
+  DALLAS_FlagsTypeDef       f;                        ///< Флаги  
-extern DALLAS_HandleTypeDef indoor;
+};
-extern DALLAS_HandleTypeDef bathroom;
-extern DALLAS_HandleTypeDef kitchen;
-extern DALLAS_HandleTypeDef big_room;
-extern DALLAS_HandleTypeDef small_room;
-extern DALLAS_HandleTypeDef living_room;
-extern DALLAS_HandleTypeDef basement;
 
 
 
+/** @brief Варианты ожидания окончания конверсии */
 typedef enum
 {
-  DALLAS_WAIT_NONE      = 0x00,
+  DALLAS_WAIT_NONE      = 0x00,   ///< Без ожидания окончания конверсии
-  DALLAS_WAIT_BUS       = 0x01,
+  DALLAS_WAIT_BUS       = 0x01,   ///< Ожидание окончания конверсии по шине (опрос датчиков - чтение бита)
-  DALLAS_WAIT_DELAY     = 0x02,
+  DALLAS_WAIT_DELAY     = 0x02,   ///< Без ожидания окончания через задержку (максимальная задержка для заданной разрядности)
-} DALLAS_WaitCondition;
+} DALLAS_WaitConvertionTypeDef;
 
 
 
 /* Functions ---------------------------------------------------------------*/
-
+/* Функция для иниицализации структуры dallas и шины OW для датчиков */
-void Dallas_Init(DALLAS_HandleTypeDef *sensor, UART_HandleTypeDef *huart);
+#ifndef UART_Driver
-void Dallas_ReadAll(void);
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin);
-void Dallas_FirstInit(void);
+#else
-HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint64_t intROM);
+HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, UART_HandleTypeDef *huart);
-HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34);
+#endif
-HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t sens_ind);
+/* Поиск датчиков на шине onewire */
-HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitCondition waitCondition, uint8_t dallas_delay_ms);
+HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas);
-HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitCondition waitCondition);
+/* Функция для иниицализации нового датчика в структуре */
-HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor);
+HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
-HAL_StatusTypeDef Dallas_ReadScratchpad(DALLAS_HandleTypeDef *sensor);
+/* Инициализирует структуру датчика по ROM */
-HAL_StatusTypeDef Dallas_WriteScratchpad(DALLAS_HandleTypeDef *sensor, uint8_t ExtendUserBytes);
+HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
-HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor);
+/* Инициализирует структуру датчика по пользовательским байтам */
-HAL_StatusTypeDef Dallas_ReadRom(DALLAS_HandleTypeDef *sensor);
+HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
-HAL_StatusTypeDef Dallas_SkipRom(DALLAS_HandleTypeDef *sensor);
+/* Инициализирует структуру датчика по порядковому номеру */
-
+HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
-HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask);
+/* Инициализирует датчик для работы */
+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

DS18B20/ds18b20_driver.c

@@ -1,14 +1,12 @@
 /**
   ******************************************************************************
-  * @file    ds18b20.c
+  * @file    ds18b20_driver.c
   * @brief   This file includes the HAL/LL driver for DS18B20 1-Wire Digital
   * 		 Thermometer
   ******************************************************************************
   */
-#include "ds18b20.h"
+#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;
@@ -222,19 +253,19 @@ HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *
 	switch (resolution) {
 		case DS18B20_RESOLUTION_9BITS: {
 			decimal = (temperature >> 3) & 0x01;
-			decimal *= (float)DS18B20_DECIMAL_STEPS_9BIT;
+			decimal *= (float)DS18B20_DECIMAL_STEP_9BIT;
 		} break;
 		case DS18B20_RESOLUTION_10BITS: {
 			decimal = (temperature >> 2) & 0x03;
-			decimal *= (float)DS18B20_DECIMAL_STEPS_10BIT;
+			decimal *= (float)DS18B20_DECIMAL_STEP_10BIT;
 		} break;
 		case DS18B20_RESOLUTION_11BITS: {
 			decimal = (temperature >> 1) & 0x07;
-			decimal *= (float)DS18B20_DECIMAL_STEPS_11BIT;
+			decimal *= (float)DS18B20_DECIMAL_STEP_11BIT;
 		} break;
 		case DS18B20_RESOLUTION_12BITS: {
 			decimal = temperature & 0x0F;
-			decimal *= (float)DS18B20_DECIMAL_STEPS_12BIT;
+			decimal *= (float)DS18B20_DECIMAL_STEP_12BIT;
 		} break;
 		default: {
       *Destination = 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
+//  * @brief  The function is used as search device that had temperature alarm
-  * 		triggered and store it in DS18B20 alarm data structure
+//  * 		triggered and store it in DS18B20 alarm data structure
-  * @retval status of search, OK = 1, Failed = 0
+//  * @retval status of search, OK = 1, Failed = 0
-  * @param  DS		DS18B20 HandleTypedef
+//  * @param  DS		DS18B20 HandleTypedef
-  * @param  OW		OneWire HandleTypedef
+//  * @param  OW		OneWire HandleTypedef
-  */
+//  */
-uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
+//uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
-{
+//{
-	uint8_t t = 0;
+//	uint8_t t = 0;
 
-	/* Reset Alarm in DS */
+//	/* Reset Alarm in DS */
-	for(uint8_t i = 0; i < DS18B20_DEVICE_AMOUNT; i++)
+//	for(uint8_t i = 0; i < OW->RomCnt; i++)
-	{
+//	{
-		for(uint8_t j = 0; j < 8; j++)
+//		for(uint8_t j = 0; j < 8; j++)
-		{
+//		{
-			DS->AlmAddr[i][j] = 0;
+//			DS->AlmAddr[i][j] = 0;
-		}
+//		}
-	}
+//	}
 
-	/* Start alarm search */
+//	/* Start alarm search */
-	while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
+//	while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
-	{
+//	{
-		/* Store ROM of device which has alarm flag set */
+//		/* Store ROM of device which has alarm flag set */
-		OneWire_GetDevRom(OW, DS->AlmAddr[t]);
+//		OneWire_GetDevRom(OW, DS->AlmAddr[t]);
-		t++;
+//		t++;
-	}
+//	}
-	return (t > 0) ? 1 : 0;
+//	return (t > 0) ? 1 : 0;
-}
+//}
 
 /**
   * @brief  The function is used to initialize the DS18B20 sensor, and search
@@ -514,6 +575,11 @@ 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)
 	{
@@ -523,14 +589,17 @@ HAL_StatusTypeDef DS18B20_Search(DS18B20_Drv_t *DS, OneWire_t *OW)
 		/* Get device ROM */
 		OneWire_GetDevRom(OW, DS->DevAddr[OW->RomCnt]);
 
-		/* Set ROM Resolution */
-		DS18B20_SetResolution(OW, &OW->RomCnt, DS->Resolution);
-
-		/* Reset Temperature Alarm */
-		DS18B20_SetTempAlarm(OW, &OW->RomCnt, 0, 0);
-
 		OW->RomCnt++;
 	}
+  for(int i = OW->RomCnt; i < DS18B20_DEVICE_AMOUNT; i++)
+  {
+    for(int j = 0; j < 8; j++)
+    DS->DevAddr[i][j] = 0;
+  }
+  
 
-	return (OW->RomCnt != 0) ? 1 : 0;
+  if(OW->RomCnt > 0)
+    return HAL_OK;
+  else
+    return HAL_BUSY;
 }

DS18B20/ds18b20_driver.h

@@ -1,6 +1,6 @@
 /**
   ******************************************************************************
-  * @file    ds18b20.h
+  * @file    ds18b20_driver.h
   * @brief   This file contains all the constants parameters for the DS18B20
   * 		 1-Wire Digital Thermometer
   ******************************************************************************
@@ -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
@@ -54,11 +51,10 @@
 #define DS18B20_RESOLUTION_R1			6
 #define DS18B20_RESOLUTION_R0			5
 
-#define DS18B20_DECIMAL_STEPS_12BIT		0.0625
+#define DS18B20_DECIMAL_STEP_12BIT		0.0625
-#define DS18B20_DECIMAL_STEPS_11BIT		0.125
+#define DS18B20_DECIMAL_STEP_11BIT		0.125
-#define DS18B20_DECIMAL_STEPS_10BIT		0.25
+#define DS18B20_DECIMAL_STEP_10BIT		0.25
-#define DS18B20_DECIMAL_STEPS_9BIT		0.5
+#define DS18B20_DECIMAL_STEP_9BIT		  0.5
-
 
 #define DS18B20_DELAY_MS_9_BITS                                            94
 #define DS18B20_DELAY_MS_10_BITS                                           188
@@ -66,11 +62,6 @@
 #define DS18B20_DELAY_MS_12_BITS                                           750
 #define DS18B20_DELAY_MS_MAX                                               DS18B20_DELAY_MS_12_BITS
 
-#define DS18B20_9_BITS_DATA_MASK                                           0x7F8
-#define DS18B20_10_BITS_DATA_MASK                                          0x7FC
-#define DS18B20_11_BITS_DATA_MASK                                          0x7FE
-#define DS18B20_12_BITS_DATA_MASK                                          0x7FF
-
 
 /* DS18B20 Resolutions */
 typedef enum {
@@ -83,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 ---------------------------------------------------------*/
@@ -97,12 +85,16 @@ 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,
 		int16_t UserBytes34, uint8_t UserBytesMask);
 uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW);
 
+HAL_StatusTypeDef DS18B20_SetResolution(OneWire_t* OW, uint8_t *ROM,
+		DS18B20_Res_t Resolution);
+HAL_StatusTypeDef DS18B20_IsValidAddress(uint8_t *ROM);
 #ifdef __cplusplus
 }
 #endif

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)) {};
-}

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 */

DS18B20/onewire.c

@@ -1,9 +1,9 @@
 /**
-  ******************************************************************************
+******************************************************************************
-  * @file    onewire.c
+* @file    onewire.c
-  * @brief   This file includes the HAL/LL driver for OneWire devices
+* @brief   This file includes the HAL/LL driver for OneWire devices
-  ******************************************************************************
+******************************************************************************
-  */
+*/
 #include "onewire.h"
 
 /**
@@ -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;

DS18B20/onewire.h

@@ -1,14 +1,9 @@
 /**
-  ******************************************************************************
+******************************************************************************
-  * @file    onewire.h
+* @file    onewire.h
-  * @brief   This file contains all the constants parameters for the OneWire
+* @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_H
 #define ONEWIRE_H
@@ -19,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"
+/* OneWire Timings -----------------------------------------------------------*/
-#define ONEWIRE_WRITE_0_US          60    // Äëèòåëüíîñòü çàïèñè "0"
+#define ONEWIRE_RESET_PULSE_US      480   // Длительность импульса сброса
-#define ONEWIRE_READ_CMD_US         5     // Âðåìÿ êîììàíäû ÷òåíèÿ áèòà
+#define ONEWIRE_PRESENCE_WAIT_US    70    // Ожидание ответа от датчика
-#define ONEWIRE_READ_DELAY_US       10    // Çàäåðæêà ïåðåä ñ÷èòûâàíèåì áèòà
+#define ONEWIRE_PRESENCE_DURATION_US 410  // Длительность сигнала присутствия
-#define ONEWIRE_RECOVERY_TIME_US    1     // Âîññòàíîâëåíèå ïåðåä ñëåäóþùèì ñëîòîì
+
-#define ONEWIRE_COMMAND_SLOT_US     70    // Îáùåå âðåìÿ êîììàíäû OneWire
+#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
@@ -54,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 ---------------------------------------------------------*/

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;
+}

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

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;
-  }
-}

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 */

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;
-}

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

DS18B20/ow_port.c

@@ -1,11 +1,12 @@
 /**
-  ******************************************************************************
+******************************************************************************
-  * @file    ow_port.c
+* @file    ow_port.c
-  * @brief   This file includes the driver for port for OneWire purposes
+* @brief   This file includes the driver for port for OneWire purposes
-  ******************************************************************************
+******************************************************************************
-  */
+*/
 #include "ow_port.h"
 #include "onewire.h"
+#include "tim.h"
 
 /**
   * @brief  The internal function is used as gpio pin mode
@@ -14,42 +15,26 @@
   */
 void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
 {
-#ifdef CMSIS_Driver
+#if defined(UART_Driver)
-  static uint32_t pin_cr_numb = 4;
+#elif defined(CMSIS_Driver)
-  static int get_pin_numb = 0;
+  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);
-  if(get_pin_numb)
+  // —брос текущих 4 бит (CNF + MODE)
+  *config_reg &= ~(0xF << pin_pos);
+
+  if (Mode == Input)
   {
-    get_pin_numb = 0;
+      // ¬ход с подт¤жкой или без Ц например, CNF = 0b01, MODE = 0b00
-    for(int i = 0; i < 8; i++)
+      // «десь устанавливаем вход с подт¤жкой:
-    {
+      *config_reg |= (0x8 << pin_pos); // CNF=10, MODE=00 (вход с подт¤жкой)
-      if((OW->DataPin >> i) == 0x1)
+      OW->DataPort->ODR |= (1 << OW->DataPinNumb); // ¬ключить подт¤жку вверх
-        pin_cr_numb = i*4;
-    }
-    for(int i = 8; i < 16; i++)
-    {
-      if((OW->DataPin >> i) == 0x1)
-        pin_cr_numb = (i-8)*4;
-    }
   }
-	if(Mode == Input)
+  else
-	{
+  {
-    OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
+      // ¬ыход push-pull, 2 ћ√ц Ц MODE = 0b10, CNF = 0b00
-    OW->DataPort->CRH |= (1 << (pin_cr_numb+2));
+      *config_reg |= (0x2 << pin_pos);
-	}else{
+  }
-    OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
+#elif defined(LL_Driver)
-    OW->DataPort->CRH |= (3 << pin_cr_numb);
-	}
-//	if(Mode == Input)
-//	{
-//    GPIOA->CRH &= ~((GPIO_CRH_CNF9 | GPIO_CRH_MODE9));
-//    GPIOA->CRH |= (1 << GPIO_CRH_CNF9_Pos);
-//	}else{
-//    GPIOA->CRH &= ~((GPIO_CRH_CNF9 | GPIO_CRH_MODE9));
-//    GPIOA->CRH |= (3 << GPIO_CRH_MODE9_Pos);
-//	}
-#else
-#ifdef LL_Driver
 	if(Mode == Input)
 	{
 		LL_GPIO_SetPinMode(OW->DataPort, OW->DataPin, LL_GPIO_MODE_INPUT);
@@ -68,7 +53,6 @@ void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
 	}
 	HAL_GPIO_Init(OW->DataPort, &GPIO_InitStruct);
 #endif
-#endif
 }
 
 /**
@@ -78,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;
@@ -87,8 +72,7 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
   {
     OW->DataPort->BSRR = (uint32_t)OW->DataPin << 16u;
   }
-#else
+#elif defined(LL_Driver)
-#ifdef LL_Driver
 	if(Level == 1)
 	{
 		LL_GPIO_SetOutputPin(OW->DataPort, OW->DataPin);
@@ -98,7 +82,6 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
 #else
 	HAL_GPIO_WritePin(OW->DataPort, OW->DataPin, Level);
 #endif
-#endif
 }
 
 /**
@@ -108,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
+#elif defined(LL_Driver)
-#ifdef 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;
+  }
+}
+

DS18B20/ow_port.h

@@ -1,14 +1,9 @@
 /**
-  ******************************************************************************
+******************************************************************************
-  * @file    onewire.h
+* @file    ow_port.h
-  * @brief   This file contains all the constants parameters for the OneWire
+* @brief   This file includes the driver for port for OneWire purposes
-  ******************************************************************************
+******************************************************************************
-  * @attention
+*/
-  * Usage:
-  *		Uncomment LL Driver for HAL driver
-  *
-  ******************************************************************************
-  */
 /* Define to prevent recursive inclusion -------------------------------------*/
 #ifndef ONEWIRE_PORT_H
 #define ONEWIRE_PORT_H
@@ -16,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 */

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`, она будет искать датчик и пытаться его инициализировать по заданной функции инициализации.

test/Core/Inc/main.h

@@ -36,6 +36,7 @@ extern "C" {
 
 /* Exported types ------------------------------------------------------------*/
 /* USER CODE BEGIN ET */
+
 /* USER CODE END ET */
 
 /* Exported constants --------------------------------------------------------*/

test/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 */

test/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 */
+  /*Configure GPIO pin : PB0 */
-  GPIO_InitStruct.Pin = GPIO_PIN_10;
+  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;

test/Core/Src/main.c

@@ -56,6 +56,7 @@ void SystemClock_Config(void);
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
+DALLAS_SensorHandleTypeDef sens;
 /* USER CODE END 0 */
 
 /**
@@ -87,35 +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 */
-
+#ifndef UART_Driver
-  /* Initialize DWT Delay */
+  Dallas_BusFirstInit(&hdallas, OW_GPIO_Port, OW_Pin);
-  __HAL_RCC_GPIOB_CLK_ENABLE();
+#else
-  DwtInit();
+  Dallas_BusFirstInit(&hdallas, &huart1);
-  /* Set parameter and initialize DS18B20 */
+#endif
-	/* Initialize OneWire and reset all data */
+  sens.Init.InitParam.Ind = 0;
-  Dallas_FirstInit();
+  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)
   {
-    Dallas_ReadAll();
+    Dallas_StartConvertTAll(&hdallas, DALLAS_WAIT_BUS, 0);
-		/* Start temperature conversion on all devices on one bus */
+    Dallas_ReadTemperature(&sens);
-//		DS18B20_StartConvTAll(&OW);
+    
-//    DS18B20_WaitForEndConvertion(&OW);
+    GPIOC->ODR ^= (1<<13);
-		/* Read temperature from device and store it to DS data structure */
-		for(uint8_t i = 0; i < OW.RomCnt; i++)
-		{
-			/* Read Temperature */
-//			DS18B20_CalcTemperature(&OW, DS.DevAddr[i], &DS.Temperature[i]);
-		}
-
-		/* Search Alarm triggered and store in DS data structure */
-//		DS18B20_AlarmSearch(&DS, &OW);
     /* USER CODE END WHILE */
 
     /* USER CODE BEGIN 3 */

test/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 */

test/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 */

test/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);