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

библиотека для stm32f103

Browse Source
This commit is contained in:
Razvalyaev
2025-06-20 14:46:25 +03:00
parent 0689046c85
commit c2dca42be6
15 changed files with 118 additions and 1090 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
DS18B20/dallas_tools.c
View File

@@ -18,38 +18,32 @@
/* Declarations and definitions --------------------------------------------*/
DALLAS_HandleTypeDef hdallas1;
DALLAS_HandleTypeDef hdallas;
/* Functions ---------------------------------------------------------------*/
/**
* @brief Функция для нахождения нового датчика на место потерянного
* @param sensor Указатель на структуру датчика
* @retval HAL Status
* @brief Функция для иниицализации шины OW для датчиков
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_BusFirstInit(TIM_HandleTypeDef *htim)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(HAL_TIM_Base_Start(htim))
return HAL_ERROR;
result = Dallas_IsConnected(sensor);
if(sensor->isLost)
{
if(DS18B20_Search(&DS, &OW) != HAL_OK)
return HAL_ERROR;
if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)
return HAL_ERROR;
return HAL_OK;
}
else
{
return HAL_BUSY; // датчик не потерян
}
hdallas.onewire = &OW;
hdallas.ds_devices = &DS;
OW.DataPin = DS_Pin;
OW.DataPort = DS_GPIO_Port;
/* Инициализация onewire и поиск датчиков*/
OneWire_Init(&OW);
return DS18B20_Search(&DS, &OW) != HAL_OK;
}
@@ -286,15 +280,47 @@ HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor)
{
if(sensor == NULL)
return HAL_ERROR;
DALLAS_InitStructTypeDef initbuff = sensor->Init;
memset(sensor, 0, sizeof(DALLAS_SensorHandleTypeDef));
sensor->Init = initbuff;
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;
}
/**
* @brief Функция для нахождения нового датчика на место потерянного
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
result = Dallas_IsConnected(sensor);
if(sensor->isLost)
{
if(DS18B20_Search(sensor->hdallas->ds_devices, sensor->hdallas->onewire) != HAL_OK)
return HAL_ERROR;
if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)
return HAL_ERROR;
return HAL_OK;
}
else
{
return HAL_BUSY; // датчик не потерян
}
}
/**
* @brief Запускает измерение температуры на всех датчиках

10
DS18B20/dallas_tools.h
View File

@@ -14,12 +14,11 @@
#ifndef DALLAS_TOOLS_H
#define DALLAS_TOOLS_H
/* Includes -----------------------------------------------------------------*/
#include "ds18b20_driver.h"
#include "onewire.h"
/* Определения пользовательских байтов для записи чтения */
#define DALLAS_USER_BYTE_1 (1<<0) ///< Первый пользовательский байт
#define DALLAS_USER_BYTE_2 (1<<1) ///< Второй пользовательский байт
@@ -85,7 +84,7 @@ typedef struct
DS18B20_Drv_t *ds_devices;
DALLAS_ScratchpadTypeDef scratchpad;
}DALLAS_HandleTypeDef;
extern DALLAS_HandleTypeDef hdallas1;
extern DALLAS_HandleTypeDef hdallas;
/** @brief Основная структура обработчика датчика DALLAS */
typedef struct
@@ -117,8 +116,7 @@ typedef enum
/* Functions ---------------------------------------------------------------*/
/* Функция для нахождения нового датчика на место потерянного */
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor);
HAL_StatusTypeDef Dallas_BusFirstInit(TIM_HandleTypeDef *htim);
/* Функция для иниицализации нового датчика в структуре */
HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует структуру датчика по ROM */
@@ -131,6 +129,8 @@ HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_S
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);
/* Измеряет температуру на датчике */

6
DS18B20/ds18b20_driver.c
View File

@@ -593,6 +593,12 @@ HAL_StatusTypeDef DS18B20_Search(DS18B20_Drv_t *DS, OneWire_t *OW)
OW->RomCnt++;
}
for(int i = OW->RomCnt; i < DS18B20_DEVICE_AMOUNT; i++)
{
for(int j = 0; j < 8; j++)
DS->DevAddr[i][j] = 0;
}
if(OW->RomCnt > 0)
return HAL_OK;

5
DS18B20/ds18b20_driver.h
View File

@@ -21,9 +21,6 @@
/* Includes ------------------------------------------------------------------*/
#include "onewire.h"
/* I/O Port ------------------------------------------------------------------*/
#define DS_Pin GPIO_PIN_9
#define DS_GPIO_Port GPIOA
/* Data Structure ------------------------------------------------------------*/
#define DS18B20_DEVICE_AMOUNT 30
@@ -78,7 +75,7 @@ typedef struct
{
uint8_t DevAddr[DS18B20_DEVICE_AMOUNT][8];
} DS18B20_Drv_t;
extern DS18B20_Drv_t DS;
extern DS18B20_Drv_t DS;;
extern OneWire_t OW;
/* External Function ---------------------------------------------------------*/

58
DS18B20/dwt.c
View File

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

39
DS18B20/dwt.h
View File

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

12
DS18B20/onewire.h
View File

@@ -17,17 +17,17 @@
/* Driver Selection ----------------------------------------------------------*/
//#define LL_Driver
#define CMSIS_Driver
//#define CMSIS_Driver
/* OneWire Timings -----------------------------------------------------------*/
#define ONEWIRE_RESET_PULSE_US 480 // Длительность импульса сброса
#define ONEWIRE_PRESENCE_WAIT_US 70 // Ожидание ответа от датчика
#define ONEWIRE_PRESENCE_DURATION_US 410 // Длительность сигнала присутствия
#define ONEWIRE_WRITE_1_US 6 // Длительность записи "1"
#define ONEWIRE_WRITE_0_US 60 // Длительность записи "0"
#define ONEWIRE_READ_CMD_US 5 // Время комманды чтения бита
#define ONEWIRE_READ_DELAY_US 10 // Задержка перед считыванием бита
#define ONEWIRE_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

230
DS18B20/outdate/onewire_it_driver.c
View File

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

51
DS18B20/outdate/onewire_it_driver.h
View File

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

159
DS18B20/outdate/onewire_uart.c
View File

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

61
DS18B20/outdate/onewire_uart.h
View File

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

58
DS18B20/ow_port.c
View File

@@ -6,6 +6,8 @@
*/
#include "ow_port.h"
#include "onewire.h"
#include "tim.h"
uint32_t pin_pos = (DS_Pin_Numb < 8) ? (DS_Pin_Numb * 4) : ((DS_Pin_Numb - 8) * 4);
/**
* @brief The internal function is used as gpio pin mode
@@ -15,31 +17,22 @@
void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
{
#ifdef CMSIS_Driver
static uint32_t pin_cr_numb = 4;
static int get_pin_numb = 0;
if(get_pin_numb)
volatile uint32_t *config_reg = (DS_Pin_Numb < 8) ? &(OW->DataPort->CRL) : &(OW->DataPort->CRH);
// Ñáðîñ òåêóùèõ 4 áèò (CNF + MODE)
*config_reg &= ~(0xF << pin_pos);
if (Mode == Input)
{
get_pin_numb = 0;
for(int i = 0; i < 8; i++)
{
if((OW->DataPin >> i) == 0x1)
pin_cr_numb = i*4;
}
for(int i = 8; i < 16; i++)
{
if((OW->DataPin >> i) == 0x1)
pin_cr_numb = (i-8)*4;
}
// Âõîä ñ ïîäòÿæêîé èëè áåç – íàïðèìåð, CNF = 0b01, MODE = 0b00
// Çäåñü óñòàíàâëèâàåì âõîä ñ ïîäòÿæêîé:
*config_reg |= (0x8 << pin_pos); // CNF=10, MODE=00 (âõîä ñ ïîäòÿæêîé)
OW->DataPort->ODR |= (1 << DS_Pin_Numb); // Âêëþ÷èòü ïîäòÿæêó ââåðõ
}
else
{
// Âûõîä push-pull, 2 ÌÃö – MODE = 0b10, CNF = 0b00
*config_reg |= (0x2 << pin_pos);
}
if(Mode == Input)
{
OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
OW->DataPort->CRH |= (1 << (pin_cr_numb+2));
}else{
OW->DataPort->CRH &= ~((GPIO_CRL_CNF0 | GPIO_CRL_MODE0) << pin_cr_numb);
OW->DataPort->CRH |= (3 << pin_cr_numb);
}
#else
#ifdef LL_Driver
if(Mode == Input)
@@ -109,4 +102,21 @@ uint8_t OneWire_Pin_Read(OneWire_t* OW)
return HAL_GPIO_ReadPin(OW->DataPort, OW->DataPin);
#endif
#endif
}
}
uint32_t tim_1us_period = OW_TIM_1US_PERIOD;
void OneWire_Delay_uw(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;
}
}

14
DS18B20/ow_port.h
View File

@@ -11,9 +11,19 @@
/* Includes ------------------------------------------------------------------*/
#include "stm32f1xx_hal.h"
#include "dwt.h"
/* I/O Port ------------------------------------------------------------------*/
//#define LL_Driver
#define CMSIS_Driver
#define DS_GPIO_Port GPIOB
#define DS_Pin_Numb 0
#define DS_Pin (1<<DS_Pin_Numb)
#define OW_TIM TIM3
#define OW_TIM_1US_PERIOD 24
/* OneWire Timings -----------------------------------------------------------*/
#define OneWire_Delay_uw(_us_) DwtDelay_us(_us_)
void OneWire_Delay_uw(uint32_t us);
/* Common Register -----------------------------------------------------------*/
#endif /* ONEWIRE_PORT_H */

255
DS18B20/pch_sensors.c
View File

@@ -1,255 +0,0 @@
/**
******************************************************************************
* @file pch_sensors.c
* @brief Работа с датчиками температуры DS18B20 в ПЧ
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "pch_sensors.h"
/* Declarations and definitions --------------------------------------------*/
PCHSens_ModuleTypeDef module1;
PCHSens_DallasBusHandle DallasBus;
/* Functions ---------------------------------------------------------------*/
void PCHSens_FirstInit(void)
{
OW.DataPin = DS_Pin;
OW.DataPort = DS_GPIO_Port;
/* Инициализация onewire и поиск датчиков*/
OneWire_Init(&OW);
DS18B20_Search(&DS, &OW);
/* Инициализация структур датчиков ПЧ */
DallasBus.hdallas = &hdallas1;
DallasBus.hdallas->onewire = &OW;
DallasBus.hdallas->ds_devices = &DS;
PCHSens_InitModule(&hdallas1, &module1, REG_PCH_NUMB_11|REG_PCH_DIODE_NUMB_1);
/* Поиск неизвестных сенсоров */
PCHSens_FindUnknownSensors(&DallasBus);
}
HAL_StatusTypeDef PCHSens_InitNewSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor, uint64_t ROM)
{
DALLAS_SensorHandleTypeDef tempsens;
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
sensor->sens.Init.InitParam = ROM;
sensor->sens.Init.init_func = &Dallas_SensorInitByROM;
result = Dallas_AddNewSensors(hdallas, &sensor->sens);
if(result != HAL_OK)
{
sensor->not_found = 1;
return result;
}
result = Dallas_WriteUserBytes(&sensor->sens, sensor->Location.all, sensor->Location.all, USED_USER_BYTES);
if(result != HAL_OK)
return result;
sensor->sens.Init.InitParam = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(hdallas, &sensor->sens);
if(result == HAL_OK)
{
sensor->not_found = 0;
}
else
{
sensor->not_found = 1;
}
return result;
}
HAL_StatusTypeDef PCHSens_AddSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
sensor->sens.Init.InitParam = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(hdallas, &sensor->sens);
if(result == HAL_OK)
{
sensor->not_found = 0;
}
else
{
sensor->not_found = 1;
}
return result;
}
HAL_StatusTypeDef PCHSens_InitModule(DALLAS_HandleTypeDef *hdallas, PCHSens_ModuleTypeDef* module, uint16_t param)
{
if(hdallas == NULL)
return HAL_ERROR;
if(module == NULL)
return HAL_ERROR;
PCHSens_LocationTypeDef initlocation;
initlocation.all = param;
module->hdallas = hdallas;
module->refLocation = initlocation;
module->sens1.Location.all = module->refLocation.all;
module->sens1.Location.param.Location = 0;
PCHSens_AddSensor(hdallas, &module->sens1);
module->sens2.Location.all = module->refLocation.all;
module->sens2.Location.param.Location = 1;
PCHSens_AddSensor(hdallas, &module->sens2);
module->sens3.Location.all = module->refLocation.all;
module->sens3.Location.param.Location = 2;
PCHSens_AddSensor(hdallas, &module->sens3);
module->sens4.Location.all = module->refLocation.all;
module->sens4.Location.param.Location = 3;
PCHSens_AddSensor(hdallas, &module->sens4);
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_ModuleReadTemperature(PCHSens_ModuleTypeDef* module)
{
HAL_StatusTypeDef result;
if(module == NULL)
return HAL_ERROR;
result = PCHSens_SensorReadTemperature(module->hdallas, &module->sens1);
result = PCHSens_SensorReadTemperature(module->hdallas, &module->sens2);
result = PCHSens_SensorReadTemperature(module->hdallas, &module->sens3);
result = PCHSens_SensorReadTemperature(module->hdallas, &module->sens4);
return result;
}
HAL_StatusTypeDef PCHSens_SensorReadTemperature(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
result = PCHSens_ReadTemperature(sensor);
if(result != HAL_OK)
PCHSens_CheckSensor(hdallas, sensor);
return result;
}
HAL_StatusTypeDef PCHSens_StartCovert(PCHSens_DallasBusHandle *hbus)
{
return Dallas_StartConvertTAll(hbus->hdallas, DALLAS_WAIT_NONE, 0);
}
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->sens.isInitialized == 0)
return HAL_ERROR;
result = Dallas_ReadTemperature(&sensor->sens);
return result;
}
HAL_StatusTypeDef PCHSens_CheckSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
unsigned unknow_sensors_flag = 0;
if(sensor == NULL)
return HAL_ERROR;
if((sensor->sens.isLost == 1) || (sensor->sens.isInitialized == 0))
{
if(Dallas_ReplaceLostedSensor(&sensor->sens) == HAL_ERROR)
{
sensor->not_found = 1;
}
else
{
sensor->not_found = 0;
}
}
else
{
sensor->not_found = 0;
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_FindUnknownSensors(PCHSens_DallasBusHandle *hbus)
{
HAL_StatusTypeDef result;
if(hbus == NULL)
return HAL_ERROR;
hbus->UnknownCnt = 0;
PCHSens_LocationTypeDef *param = (PCHSens_LocationTypeDef *)&hbus->hdallas->scratchpad.tHighRegister;
for(int i = 0; i < hbus->hdallas->onewire->RomCnt; i++)
{
/* Проверка присутствует ли выбранный датчик на линии */
result = DS18B20_ReadScratchpad(hbus->hdallas->onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&hbus->hdallas->scratchpad);
if(result != HAL_OK)
__NOP();
if((IS_REG_SENS_LOCATION(param) == 0) ||
(IS_REG_PCH_LOCATION(param) == 0) ||
(IS_REG_PCH_NUMB(param) == 0) )
{
// unknowns->unknown_sensors[unknowns->UnknownCnt].Init.InitParam = i;
// unknowns->unknown_sensors[unknowns->UnknownCnt].Init.init_func = &Dallas_SensorInitByInd;
// result = Dallas_AddNewSensors(hbus, &unknowns->unknown_sensors[unknowns->UnknownCnt]);
hbus->UnknownCnt++;
if(result != HAL_OK)
__NOP();
}
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
result = Dallas_WriteUserBytes(&sensor->sens, 0, 0, USED_USER_BYTES);
if(result != HAL_OK)
{
return result;
}
result = Dallas_SensorDeInit(&sensor->sens);
return result;
}

168
DS18B20/pch_sensors.h
View File

@@ -1,168 +0,0 @@
/**
******************************************************************************
* @file pch_sensors.h
* @brief Работа с датчиками температуры DS18B20 в ПЧ
******************************************************************************
*****************************************************************************/
#ifndef PCH_SENSORS_H
#define PCH_SENSORS_H
/* Includes -----------------------------------------------------------------*/
#include "dallas_tools.h"
/* Declarations and definitions ---------------------------------------------*/
#define USED_USER_BYTES DALLAS_USER_BYTE_12
/* Позиции параметров в UserBytes */
#define REG_SENS_LOCATION_Pos (0) /*!< @brief Позиция параметра "Локация внутри модуля" */
#define REG_PCH_LOCATION_Pos (8) /*!< @brief Позиция параметра "Расположение в ПЧ" */
#define REG_PCH_DIOD_PHASE_Pos (10) /*!< @brief Позиция параметра "Диодный или фазный модуль" @ref REG_PCH_LOCATION_Pos */
#define REG_PCH_MODULE_NUMB_Pos (8) /*!< @brief Позиция параметра "Порядковый номер диодного/фазного модуля" @ref REG_PCH_LOCATION_Pos */
#define REG_PCH_NUMB_Pos (11) /*!< @brief Позиция параметра "Преобразователь частоты" */
#define REG_PCH_NUMB_DIGIT_1_Pos (13) /*!< @brief Позиция параметра "Первая цифра номера преобразователя частоты" @ref REG_PCH_NUMB_Pos */
#define REG_PCH_NUMB_DIGIT_2_Pos (11) /*!< @brief Позиция параметра "Вторая цифра номера преобразователя частоты" @ref REG_PCH_NUMB_Pos */
#define REG_ZIP_Pos (15) /*!< @brief Позиция параметра "ЗИП/не ЗИП" */
/* Маски параметров в UserBytes */
#define REG_SENS_LOCATION_Mask ((uint16_t)0x3 << REG_SENS_LOCATION_Pos) /*!< @brief Маска параметра "Локация внутри модуля" */
#define REG_PCH_LOCATION_Mask ((uint16_t)0x7 << REG_PCH_LOCATION_Pos) /*!< @brief Маска параметра "Расположение в ПЧ" */
#define REG_PCH_DIOD_PHASE_Mask ((uint16_t)0x1 << REG_PCH_DIOD_PHASE_Pos) /*!< @brief Маска параметра "Диодный или фазный модуль" */
#define REG_PCH_MODULE_NUMB_Mask ((uint16_t)0x3 << REG_PCH_MODULE_NUMB_Pos) /*!< @brief Маска параметра "Порядковый номер диодного/фазного модуля" */
#define REG_PCH_NUMB_Mask ((uint16_t)0xF << REG_PCH_NUMB_Pos) /*!< @brief Маска параметра "Преобразователь частоты" */
#define REG_PCH_NUMB_DIGIT_1_Mask ((uint16_t)0x3 << REG_PCH_NUMB_DIGIT_1_Pos) /*!< @brief Маска параметра "Первая цифра номера преобразователя частоты" */
#define REG_PCH_NUMB_DIGIT_2_Mask ((uint16_t)0x3 << REG_PCH_NUMB_DIGIT_2_Pos) /*!< @brief Маска параметра "Вторая цифра номера преобразователя частоты" */
#define REG_ZIP_Mask ((uint16_t)0x1 << REG_ZIP_Pos) /*!< @brief Маска параметра "ЗИП/не ЗИП" */
/* Варианты параметров в UserBytes */
#define REG_PCH_NUMB_11 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_12 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_21 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_22 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_31 ((3 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_32 ((3 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_DIODE_NUMB_1 ((0 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_DIODE_NUMB_2 ((0 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_DIODE_NUMB_3 ((0 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_1 ((1 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_2 ((1 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_3 ((1 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
/* Получить параметр из UserBytes */
#define GET_REG_SENS_LOCATION(_REG_) ((_REG_) & REG_SENS_LOCATION_Mask) /*!< @brief Получить параметр "Локация внутри модуля" */
#define GET_REG_PCH_LOCATION(_REG_) ((_REG_) & REG_PCH_LOCATION_Mask) /*!< @brief Получить параметр "Расположение в ПЧ" */
#define GET_REG_PCH_DIOD_PHASE(_REG_) ((_REG_) & REG_PCH_DIOD_PHASE_Mask) /*!< @brief Получить параметр "Диодный или фазный модуль" */
#define GET_REG_PCH_MODULE_NUMB(_REG_) ((_REG_) & REG_PCH_MODULE_NUMB_Mask) /*!< @brief Получить параметр "Порядковый номер диодного/фазного модуля" */
#define GET_REG_PCH_NUMB(_REG_) ((_REG_) & REG_PCH_NUMB_Mask) /*!< @brief Получить параметр "Преобразователь частоты" */
#define GET_REG_PCH_NUMB_DIGIT_1(_REG_) ((_REG_) & REG_PCH_NUMB_DIGIT_1_Mask) /*!< @brief Получить параметр "Первая цифра номера преобразователя частоты" */
#define GET_REG_PCH_NUMB_DIGIT_2(_REG_) ((_REG_) & REG_PCH_NUMB_DIGIT_2_Mask) /*!< @brief Получить параметр "Вторая цифра номера преобразователя частоты" */
#define GET_REG_ZIP(_REG_) ((_REG_) & REG_ZIP_Mask) /*!< @brief Получить параметр "ЗИП/не ЗИП" */
/* Диапазоны параметров из UserBytes */
#define REG_SENS_LOCATION_MAX 3
#define REG_SENS_LOCATION_MIN 0
#define REG_PCH_DIOD_PHASE_MAX 1
#define REG_PCH_DIOD_PHASE_MIN 0
#define REG_PCH_MODULE_NUMB_MAX 3
#define REG_PCH_MODULE_NUMB_MIN 0
#define REG_PCH_NUMB_DIGIT_1_MAX 3
#define REG_PCH_NUMB_DIGIT_1_MIN 1
#define REG_PCH_NUMB_DIGIT_2_MAX 2
#define REG_PCH_NUMB_DIGIT_2_MIN 1
/** @brief Получить параметр "Локация внутри модуля" */
#define IS_REG_SENS_LOCATION(_REG_) (((_REG_)->param.Location <= REG_SENS_LOCATION_MAX) && ((_REG_)->param.Location >= REG_SENS_LOCATION_MIN))
/*!< @brief Получить параметр "Расположение в ПЧ" */
#define IS_REG_PCH_LOCATION(_REG_) (IS_REG_PCH_DIOD_PHASE(_REG_) && IS_REG_PCH_MODULE_NUMB(_REG_))
/*!< @brief Получить параметр "Диодный или фазный модуль" */
#define IS_REG_PCH_DIOD_PHASE(_REG_) (((_REG_)->param.DiodeOrPhase <= REG_PCH_DIOD_PHASE_MAX) && ((_REG_)->param.DiodeOrPhase >= REG_PCH_DIOD_PHASE_MIN))
/*!< @brief Получить параметр "Порядковый номер диодного/фазного модуля" */
#define IS_REG_PCH_MODULE_NUMB(_REG_) (((_REG_)->param.ModuleNumb <= REG_PCH_MODULE_NUMB_MAX) && ((_REG_)->param.ModuleNumb >= REG_PCH_MODULE_NUMB_MIN))
/*!< @brief Получить параметр "Преобразователь частоты" */
#define IS_REG_PCH_NUMB(_REG_) (IS_REG_PCH_NUMB_DIGIT_1(_REG_) && IS_REG_PCH_NUMB_DIGIT_2(_REG_))
/*!< @brief Получить параметр "Первая цифра номера преобразователя частоты" */
#define IS_REG_PCH_NUMB_DIGIT_1(_REG_) (((_REG_)->param.PCHdig1 <= REG_PCH_NUMB_DIGIT_1_MAX) && ((_REG_)->param.PCHdig1 >= REG_PCH_NUMB_DIGIT_1_MIN))
/*!< @brief Получить параметр "Вторая цифра номера преобразователя частоты" */
#define IS_REG_PCH_NUMB_DIGIT_2(_REG_) (((_REG_)->param.PCHdig2 <= REG_PCH_NUMB_DIGIT_2_MAX) && ((_REG_)->param.PCHdig2 >= REG_PCH_NUMB_DIGIT_2_MIN))
/*!< @brief Получить параметр "ЗИП/не ЗИП" */
#define IS_REG_ZIP(_REG_) (GET_REG_ZIP(_REG_))
typedef union
{
uint16_t all;
struct
{
unsigned Location:2;
unsigned reserved:6;
unsigned ModuleNumb:2;
unsigned DiodeOrPhase:1;
unsigned PCHdig2:2;
unsigned PCHdig1:2;
unsigned ZIP:1;
}param;
}PCHSens_LocationTypeDef;
typedef struct
{
unsigned convertion;
uint64_t connectROM;
unsigned read;
unsigned deinit;
}PCHSens_SensorActionsTypeDef;
extern PCHSens_SensorActionsTypeDef action;
typedef struct
{
DALLAS_SensorHandleTypeDef sens;
PCHSens_LocationTypeDef Location;
unsigned not_found:1;
}PCHSens_SensorTypeDef;
typedef struct
{
DALLAS_HandleTypeDef *hdallas;
PCHSens_SensorTypeDef sens1;
PCHSens_SensorTypeDef sens2;
PCHSens_SensorTypeDef sens3;
PCHSens_SensorTypeDef sens4;
PCHSens_LocationTypeDef refLocation;
}PCHSens_ModuleTypeDef;
extern PCHSens_ModuleTypeDef module1;
typedef struct
{
DALLAS_HandleTypeDef *hdallas;
uint8_t UnknownCnt;
}PCHSens_DallasBusHandle;
/* Functions ---------------------------------------------------------------*/
void PCHSens_FirstInit(void);
HAL_StatusTypeDef PCHSens_InitNewSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor, uint64_t ROM);
HAL_StatusTypeDef PCHSens_AddSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_InitModule(DALLAS_HandleTypeDef *hdallas, PCHSens_ModuleTypeDef* module, uint16_t param);
HAL_StatusTypeDef PCHSens_ModuleReadTemperature(PCHSens_ModuleTypeDef* module);
HAL_StatusTypeDef PCHSens_SensorReadTemperature(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef *sensor);
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_StartCovert(PCHSens_DallasBusHandle *hbus);
HAL_StatusTypeDef PCHSens_CheckSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_FindUnknownSensors(PCHSens_DallasBusHandle *hbus);
HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor);
#endif // #ifndef PCH_SENSORS_H