Templates/DS18B20_Library
9
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

добавлена реализация onewire через uart и переделана структуруа шины OneWire и инциализация

Browse Source 
Теперь при выборе UART, в функцию Dallas_BusFirstInit передается hdallas, huart, ow, ds

А при выборе GPIO ножки: hdallas, gpiox, gpio_pin, ow, ds

но надо как-то структуруизировать дальше
This commit is contained in:
Razvalyaev
2025-06-30 18:34:17 +03:00
parent 175bcd539f
commit fa32d653e8
14 changed files with 373 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files

55
DS18B20/dallas_tools.c
View File

@@ -86,30 +86,61 @@ DALLAS_HandleTypeDef hdallas;
/* Functions ---------------------------------------------------------------*/
/**
* @brief Функция для иниицализации шины OW для датчиков
* @brief Функция для иниицализации структуры dallas и шины OW для датчиков
* @param hdallas Указатель на хендл для общения с датчиками
* @param OW Указатель на структуру OneWire (если NULL — используется по умолчанию)
* @param DS Указатель на структуру драйвера DS18B20 (если NULL — используется по умолчанию)
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_BusFirstInit(TIM_HandleTypeDef *htim)
#ifndef UART_Driver
HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin, OneWire_t *OW_Ptr, DS18B20_Drv_t *DS_Ptr)
#else
HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, UART_HandleTypeDef *huart, OneWire_t *OW_Ptr, DS18B20_Drv_t *DS_Ptr)
#endif
{
if(htim == NULL)
if(hdallas == NULL)
return HAL_ERROR;
HAL_StatusTypeDef result;
if(OW_Ptr == NULL)
hdallas->onewire = &OW;
HAL_TIM_Base_Start(htim);
if(DS_Ptr == NULL)
hdallas->ds_devices = &DS;
hdallas.onewire = &OW;
hdallas.ds_devices = &DS;
OW.DataPin = OW_Pin;
OW.DataPort = OW_GPIO_Port;
#ifndef UART_Driver
if(GPIOx == NULL)
return HAL_ERROR;
OW_TIM->CR1 |= TIM_CR1_CEN;
hdallas->onewire->DataPin = GPIO_Pin;
hdallas->onewire->DataPort = GPIOx;
#else
if(huart == NULL)
return HAL_ERROR;
hdallas->onewire->huart = huart;
#endif
/* Инициализация onewire и поиск датчиков*/
OneWire_Init(&OW);
OneWire_Init(hdallas->onewire);
return DS18B20_Search(&DS, &OW) != HAL_OK;
return Dallas_Search(hdallas);
}
/**
* @brief Поиск датчиков на шине onewire
* @param hdallas Указатель на хендл для общения с датчиками
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas)
{
if(hdallas == NULL)
return HAL_ERROR;
return DS18B20_Search(hdallas->ds_devices, hdallas->onewire) != HAL_OK;
}
/**
* @brief Функция для иниицализации нового датчика в структуре
@@ -153,7 +184,7 @@ HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
if(sensor->isLost)
{
if(DS18B20_Search(sensor->hdallas->ds_devices, sensor->hdallas->onewire) != HAL_OK)
if(Dallas_Search(sensor->hdallas) != HAL_OK)
return HAL_ERROR;
if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)

10
DS18B20/dallas_tools.h
View File

@@ -130,8 +130,14 @@ typedef enum
/* Functions ---------------------------------------------------------------*/
HAL_StatusTypeDef Dallas_BusFirstInit(TIM_HandleTypeDef *htim);
/* Функция для иниицализации структуры dallas и шины OW для датчиков */
#ifndef UART_Driver
HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, GPIO_TypeDef *GPIOx, uint32_t GPIO_Pin, OneWire_t *OW, DS18B20_Drv_t *DS);
#else
HAL_StatusTypeDef Dallas_BusFirstInit(DALLAS_HandleTypeDef *hdallas, UART_HandleTypeDef *huart, OneWire_t *OW, DS18B20_Drv_t *DS);
#endif
/* Поиск датчиков на шине onewire */
HAL_StatusTypeDef Dallas_Search(DALLAS_HandleTypeDef *hdallas);
/* Функция для иниицализации нового датчика в структуре */
HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует структуру датчика по ROM */

13
DS18B20/onewire.c
View File

@@ -49,7 +49,7 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
}
__enable_irq();
#else
OneWireUART_ProcessBit(onewire_uart, bit);
OneWireUART_ProcessBit(OW->huart, bit);
#endif
}
@@ -82,7 +82,7 @@ uint8_t OneWire_ReadBit(OneWire_t* OW)
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;
@@ -107,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
}
@@ -129,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;
@@ -163,7 +163,7 @@ uint8_t OneWire_Reset(OneWire_t* OW)
#else
uint8_t rslt = 0;
if(OneWireUART_Reset(onewire_uart) == HAL_OK)
if(OneWireUART_Reset(OW->huart) == HAL_OK)
rslt = 0;
else
rslt = 1;
@@ -314,6 +314,7 @@ 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);
OneWire_Delay_us(1000);
@@ -321,7 +322,7 @@ void OneWire_Init(OneWire_t* OW)
OneWire_Delay_us(1000);
OneWire_Pin_Level(OW, 1);
OneWire_Delay_us(2000);
#endif
/* Reset the search state */
OW->LastDiscrepancy = 0;
OW->LastDeviceFlag = 0;

8
DS18B20/onewire.h
View File

@@ -14,10 +14,8 @@
/* 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 // Ожидание ответа от датчика
@@ -49,8 +47,12 @@ typedef struct
uint8_t LastDeviceFlag;
uint8_t RomByte[8];
uint8_t RomCnt;
#if defined(UART_Driver)
UART_HandleTypeDef *huart;
#else
uint16_t DataPin;
GPIO_TypeDef *DataPort;
#endif
} OneWire_t;
/* External Function ---------------------------------------------------------*/

158
DS18B20/onewire_uart.c Normal file
View File

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

57
DS18B20/onewire_uart.h Normal file
View File

@@ -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

22
DS18B20/ow_port.c
View File

@@ -16,7 +16,8 @@ uint32_t pin_pos = (OW_Pin_Numb < 8) ? (OW_Pin_Numb * 4) : ((OW_Pin_Numb - 8) *
*/
void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
{
#ifdef CMSIS_Driver
#if defined(UART_Driver)
#elif defined(CMSIS_Driver)
volatile uint32_t *config_reg = (OW_Pin_Numb < 8) ? &(OW->DataPort->CRL) : &(OW->DataPort->CRH);
// —брос текущих 4 бит (CNF + MODE)
*config_reg &= ~(0xF << pin_pos);
@@ -33,8 +34,7 @@ volatile uint32_t *config_reg = (OW_Pin_Numb < 8) ? &(OW->DataPort->CRL) : &(OW-
// ¬ыход push-pull, 2 ћ√ц Ц MODE = 0b10, CNF = 0b00
*config_reg |= (0x2 << pin_pos);
}
#else
#ifdef LL_Driver
#elif defined(LL_Driver)
if(Mode == Input)
{
LL_GPIO_SetPinMode(OW->DataPort, OW->DataPin, LL_GPIO_MODE_INPUT);
@@ -53,7 +53,6 @@ volatile uint32_t *config_reg = (OW_Pin_Numb < 8) ? &(OW->DataPort->CRL) : &(OW-
}
HAL_GPIO_Init(OW->DataPort, &GPIO_InitStruct);
#endif
#endif
}
/**
@@ -63,7 +62,8 @@ volatile uint32_t *config_reg = (OW_Pin_Numb < 8) ? &(OW->DataPort->CRL) : &(OW-
*/
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;
@@ -72,8 +72,7 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
{
OW->DataPort->BSRR = (uint32_t)OW->DataPin << 16u;
}
#else
#ifdef LL_Driver
#elif defined(LL_Driver)
if(Level == 1)
{
LL_GPIO_SetOutputPin(OW->DataPort, OW->DataPin);
@@ -83,7 +82,6 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
#else
HAL_GPIO_WritePin(OW->DataPort, OW->DataPin, Level);
#endif
#endif
}
/**
@@ -93,15 +91,15 @@ void OneWire_Pin_Level(OneWire_t* OW, uint8_t Level)
*/
uint8_t OneWire_Pin_Read(OneWire_t* OW)
{
#ifdef CMSIS_Driver
#if defined(UART_Driver)
return 0;
#elif defined(CMSIS_Driver)
return ((OW->DataPort->IDR & OW->DataPin) != 0x00U) ? 1 : 0;
#else
#ifdef LL_Driver
#elif defined(LL_Driver)
return ((OW->DataPort->IDR & OW->DataPin) != 0x00U) ? 1 : 0;
#else
return HAL_GPIO_ReadPin(OW->DataPort, OW->DataPin);
#endif
#endif
}
uint32_t tim_1us_period = OW_TIM_1US_PERIOD;

14
DS18B20/ow_port.h
View File

@@ -13,24 +13,26 @@
#include "stm32f1xx_hal.h"
/* I/O Port ------------------------------------------------------------------*/
#define UART_Driver ///< использовтаь UART (onewire_uart.c/.h)
//#define LL_Driver ///< использовать CMSIS для управления ножкой
#define CMSIS_Driver ///< использовать CMSIS для управления ножкой
// если ничего не выбрано - используется HAL
/**
* @def OW_GPIO_Port
* @brief Порт вывода для шины 1-Wire.
* @details Указывает порт GPIO, к которому подключена линия данных 1-Wire (например, для DS18B20).
*/
#define OW_GPIO_Port GPIOB
#define OW_GPIO_Port GPIOA
/**
* @def OW_Pin_Numb
* @brief Номер пина в порту OW_GPIO_Port.
* @details Используется для формирования маски пина и настройки ввода/вывода.
*/
#define OW_Pin_Numb 0
#define OW_Pin_Numb 9
/**
* @def OW_Pin
@@ -51,10 +53,16 @@
* @brief Количество тактов таймера OW_TIM, соответствующее 1 микросекунде.
* @details Вычисляется на основе частоты таймера. Например, для таймера с частотой 24 МГц значение будет равно 24.
*/
#define OW_TIM_1US_PERIOD 24
#define OW_TIM_1US_PERIOD 72
/* OneWire Timings -----------------------------------------------------------*/
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 */