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

Обновлена библиотека для датчиков с py32 модуля

Browse Source
This commit is contained in:
Razvalyaev
2025-03-05 11:45:32 +03:00
parent d86a7899a3
commit 0689046c85
12 changed files with 524 additions and 513 deletions
Download Patch File Download Diff File Expand all files Collapse all files

285
DS18B20/dallas_tools.c
View File

@@ -1,13 +1,13 @@
/**
******************************************************************************
* @file dallas_tools.c
* @brief Драйвер для работы с датчиками температуры DS18B20
* @brief Драйвер для работы с датчиками температуры DS18B20
* @author MicroTechnics (microtechnics.ru)
******************************************************************************
@details
Этот файл содержит реализацию функций для работы с датчиком DS18B20
через интерфейс 1-Wire. Он предоставляет функции для чтения и записи
конфигурации, выполнения измерений и обработки полученных данных.
Этот файл содержит реализацию функций для работы с датчиком DS18B20
через интерфейс 1-Wire. Он предоставляет функции для чтения и записи
конфигурации, выполнения измерений и обработки полученных данных.
*****************************************************************************/
@@ -18,14 +18,15 @@
/* Declarations and definitions --------------------------------------------*/
DALLAS_HandleTypeDef hdallas1;
/* Functions ---------------------------------------------------------------*/
/**
* @brief Функция для нахождения нового датчика на место потерянного
* @param sensor Указатель на структуру датчика
* @retval HAL Status
* @brief Функция для нахождения нового датчика на место потерянного
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
@@ -40,36 +41,36 @@ HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor)
if(DS18B20_Search(&DS, &OW) != HAL_OK)
return HAL_ERROR;
if(sensor->Init.init_func(sensor->onewire, sensor) != HAL_OK)
if(sensor->Init.init_func(sensor->hdallas, sensor) != HAL_OK)
return HAL_ERROR;
return HAL_OK;
}
else
{
return HAL_BUSY; // датчик не потерян
return HAL_BUSY; // датчик не потерян
}
}
/**
* @brief Функция для иниицализации нового датчика в структуре
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @brief Функция для иниицализации нового датчика в структуре
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
sensor->onewire = onewire;
sensor->hdallas = hdallas;
result = sensor->Init.init_func(onewire, sensor);
result = sensor->Init.init_func(hdallas, sensor);
return result;
}
@@ -77,41 +78,41 @@ HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef
/**
* @brief Инициализирует структуру датчика по ROM
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @brief Инициализирует структуру датчика по ROM
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t ROM[8] = {0};
ROM[0] = (sensor->Init.ROM >> (0*8)) & 0xFF;
ROM[1] = (sensor->Init.ROM >> (1*8)) & 0xFF;
ROM[2] = (sensor->Init.ROM >> (2*8)) & 0xFF;
ROM[3] = (sensor->Init.ROM >> (3*8)) & 0xFF;
ROM[4] = (sensor->Init.ROM >> (4*8)) & 0xFF;
ROM[5] = (sensor->Init.ROM >> (5*8)) & 0xFF;
ROM[6] = (sensor->Init.ROM >> (6*8)) & 0xFF;
ROM[7] = (sensor->Init.ROM >> (7*8)) & 0xFF;
ROM[0] = (sensor->Init.InitParam >> (7*8)) & 0xFF;
ROM[1] = (sensor->Init.InitParam >> (6*8)) & 0xFF;
ROM[2] = (sensor->Init.InitParam >> (5*8)) & 0xFF;
ROM[3] = (sensor->Init.InitParam >> (4*8)) & 0xFF;
ROM[4] = (sensor->Init.InitParam >> (3*8)) & 0xFF;
ROM[5] = (sensor->Init.InitParam >> (2*8)) & 0xFF;
ROM[6] = (sensor->Init.InitParam >> (1*8)) & 0xFF;
ROM[7] = (sensor->Init.InitParam >> (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 < onewire->RomCnt; i++)
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(DS.DevAddr[i][rom_byte] == ROM[rom_byte])
if(hdallas->ds_devices->DevAddr[i][rom_byte] == ROM[rom_byte])
comparebytes--;
}
if(comparebytes == 0)
@@ -121,11 +122,11 @@ HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDe
}
}
/* Проверка присутствует ли выбранный датчик на линии */
/* Проверка присутствует ли выбранный датчик на линии */
if(comparebytes == 0)
{
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[ROM_ind]);
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[ROM_ind]);
return result;
}
else
@@ -139,131 +140,125 @@ HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDe
/**
* @brief Инициализирует структуру датчика по пользовательским байтам
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @brief Инициализирует структуру датчика по пользовательским байтам
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t UserByte1 = sensor->Init.UserBytes12 & 0xFF;
uint8_t UserByte2 = sensor->Init.UserBytes12 >> 8;
uint8_t UserByte3 = sensor->Init.UserBytes34 & 0xFF;
uint8_t UserByte4 = sensor->Init.UserBytes34 >> 8;
uint8_t UserByte1 = sensor->Init.InitParam & 0xFF;
uint8_t UserByte2 = sensor->Init.InitParam >> 8;
uint8_t UserByte3 = (sensor->Init.InitParam >> 16) & 0xFF;
uint8_t UserByte4 = (sensor->Init.InitParam >> 16) >> 8;
uint8_t UserByte12Cmp = 0;
uint8_t UserByte34Cmp = 0;
DALLAS_ScratchpadTypeDef scratchpad;
for(int i = 0; i < onewire->RomCnt; i++)
for(int i = 0; i < hdallas->onewire->RomCnt; i++)
{
/* Проверка присутствует ли выбранный датчик на линии */
result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
/* Проверка присутствует ли выбранный датчик на линии */
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(sensor->Init.UserBytes12 != NULL)
/* Сравнение UserByte1 и UserByte2, если они не равны нулю */
if((sensor->Init.InitParam & 0xFFFF) != NULL)
{
if( (scratchpad.tHighRegister == UserByte1) &&
(scratchpad.tLowRegister == UserByte2))
if( (hdallas->scratchpad.tHighRegister == UserByte1) &&
(hdallas->scratchpad.tLowRegister == UserByte2))
{
UserByte12Cmp = 1;
}
}/* Если сравнение UserByte1 и UserByte2 не выбрано, то считаем что они совпадают */
}/* Если сравнение UserByte1 и UserByte2 не выбрано, то считаем что они совпадают */
else
{
UserByte12Cmp = 1;
}
/* Сравнение UserByte3 и UserByte4, если они не равны нулю */
if(sensor->Init.UserBytes34 != NULL)
/* Сравнение UserByte3 и UserByte4, если они не равны нулю */
if((sensor->Init.InitParam & 0xFFFF0000) != NULL)
{
if( (scratchpad.UserByte3 == UserByte3) &&
(scratchpad.UserByte4 == UserByte4))
if( (hdallas->scratchpad.UserByte3 == UserByte3) &&
(hdallas->scratchpad.UserByte4 == UserByte4))
{
UserByte34Cmp = 1;
}
}/* Если сравнение UserByte3 и UserByte4 не выбрано, то считаем что они одинаковые */
}/* Если сравнение UserByte3 и UserByte4 не выбрано, то считаем что они одинаковые */
else
{
UserByte34Cmp = 1;
}
/* Если нашли нужный датчик - завершаем поиск */
/* Если нашли нужный датчик - завершаем поиск */
if(UserByte12Cmp && UserByte34Cmp)
{
// sensor->isInitialized = 1;
// sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByUserBytes;
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[i]);
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[i]);
return result;
}
}
sensor->sensROM = 0;
memset(&sensor->scratchpad, 0, sizeof(DALLAS_ScratchpadTypeDef));
/* Возвращаем ошибку если не нашли */
/* Возвращаем ошибку если не нашли */
return HAL_ERROR;
}
/**
* @brief Инициализирует структуру датчика по порядковому номеру
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @brief Инициализирует структуру датчика по порядковому номеру
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
* @details Порядковый номер датчика в списке найденных.
* Т.е. каким по счету этот датчик был найден
* @details Порядковый номер датчика в списке найденных.
* Т.е. каким по счету этот датчик был найден
*/
HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->onewire = onewire;
// sensor->sensROM = &DS.DevAddr[sensor->Init.SensInd];
// sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByInd;
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[sensor->Init.SensInd]);
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[sensor->Init.InitParam]);
return result;
}
/**
* @brief Инициализирует датчик для работы
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @param ROM ROM датчика, который надо инициализировать
* @brief Инициализирует датчик для работы
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @param ROM ROM датчика, который надо инициализировать
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
HAL_StatusTypeDef Dallas_SensorInit(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(onewire == 0)
if(hdallas == 0)
return HAL_ERROR;
sensor->onewire = onewire;
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 = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_ReadScratchpad(sensor);
if (result == HAL_OK)
{
/* Установка разрешения */
result = DS18B20_SetResolution(onewire, (uint8_t *)ROM, sensor->Init.Resolution);
/* Установка разрешения */
result = DS18B20_SetResolution(hdallas->onewire, (uint8_t *)ROM, sensor->Init.Resolution);
if (result == HAL_OK)
{
sensor->isInitialized = 1;
@@ -283,20 +278,18 @@ HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *se
}
/**
* @brief Деинициализирует структуру датчика
* @param onewire Указатель на структуру OneWire
* @param sensor Указатель на структуру датчика
* @param sens_ind Порядковый номер датчика в структуре
* @brief Деинициализирует структуру датчика
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor)
{
if(sensor == NULL)
return HAL_ERROR;
DALLAS_InitStructTypeDef initbuff = sensor->Init;
memset(sensor, 0, sizeof(DALLAS_HandleTypeDef));
memset(sensor, 0, sizeof(DALLAS_SensorHandleTypeDef));
sensor->Init = initbuff;
@@ -304,35 +297,38 @@ HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor)
}
/**
* @brief Запускает измерение температуры на всех датчиках
* @param onewire Указатель на структуру OneWire
* @param waitCondition Условие ожидания завершения преобразования
* @param dallas_delay_ms Время ожидания окончания конверсии
* @brief Запускает измерение температуры на всех датчиках
* @param hdallas Указатель на хендл для общения с датчиками
* @param waitCondition Условие ожидания завершения преобразования
* @param dallas_delay_ms Время ожидания окончания конверсии
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
HAL_StatusTypeDef Dallas_StartConvertTAll(DALLAS_HandleTypeDef *hdallas, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvTAll(onewire);
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvTAll(hdallas->onewire);
if(result != HAL_OK)
{
return result;
}
// Ожидание завершения преобразования, путем проверки шины
// // Проверка что преобразование началось
// if(OneWire_ReadBit(onewire) == 1)
// return HAL_ERROR;
// Ожидание завершения преобразования, путем проверки шины
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(onewire);
result = DS18B20_WaitForEndConvertion(hdallas->onewire);
return result;
}
// Ожидание завершения преобразования, путем задержки
// Ожидание завершения преобразования, путем задержки
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
@@ -366,12 +362,12 @@ HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvert
}
/**
* @brief Измеряет температуру на датчике
* @param sensor Указатель на структуру датчика
* @param waitCondition Условие ожидания завершения преобразования
* @brief Измеряет температуру на датчике
* @param sensor Указатель на структуру датчика
* @param waitCondition Условие ожидания завершения преобразования
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
HAL_StatusTypeDef Dallas_ConvertT(DALLAS_SensorHandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
@@ -381,22 +377,22 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Проверка присутствует ли выбранный датчик на линии */
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
return result;
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvT(sensor->onewire, (uint8_t *)&sensor->sensROM);
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvT(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM);
if(result != HAL_OK)
{
return result;
}
// Ожидание завершения преобразования, путем проверки шины
// Ожидание завершения преобразования, путем проверки шины
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(sensor->onewire);
result = DS18B20_WaitForEndConvertion(sensor->hdallas->onewire);
if(result == HAL_TIMEOUT)
{
sensor->f.timeout_convertion_cnt++;
@@ -404,12 +400,12 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
return result;
}
// Ожидание завершения преобразования, путем задержки
// Ожидание завершения преобразования, путем задержки
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
switch (sensor->scratchpad.ConfigRegister)
switch (sensor->hdallas->scratchpad.ConfigRegister)
{
case DALLAS_CONFIG_9_BITS:
delayValueMs = DALLAS_DELAY_MS_9_BITS;
@@ -434,7 +430,7 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
HAL_Delay(delayValueMs);
}
/* Не считываем температуру, если не выбрано ожидание окончания преобразования */
/* Не считываем температуру, если не выбрано ожидание окончания преобразования */
if(waitCondition != DALLAS_WAIT_NONE)
{
result = Dallas_ReadTemperature(sensor);
@@ -445,11 +441,11 @@ HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConve
/**
* @brief Читает измеренную датчиком температуру
* @param sensor Указатель на структуру датчика
* @brief Читает измеренную датчиком температуру
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
@@ -458,13 +454,15 @@ HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Проверка присутствует ли выбранный датчик на линии */
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
{
return result;
}
result = DS18B20_CalcTemperature(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad, &sensor->temperature);
result = DS18B20_CalcTemperature(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad, &sensor->temperature);
if (result != HAL_OK)
{
@@ -476,18 +474,17 @@ HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
}
/**
* @brief Проверяет подключен ли датчик (чтение scratchpad)
* @param sensor Указатель на структуру датчика
* @brief Проверяет подключен ли датчик (чтение scratchpad)
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
HAL_StatusTypeDef Dallas_IsConnected(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor->isInitialized == 0)
if(sensor == NULL)
return HAL_ERROR;
result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
result = Dallas_ReadScratchpad(sensor);
if (result == HAL_OK)
{
@@ -497,47 +494,49 @@ HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
}
else
{
sensor->temperature = 0;
if(sensor->isConnected == 1)
{
sensor->f.disconnect_cnt++;
sensor->isLost = 1;
}
sensor->isLost = 1;
sensor->isConnected = 0;
// Dallas_ReplaceLostedSensor(sensor);
return HAL_BUSY; // использую busy, чтобы отличать ситуацию от HAL_ERROR
return HAL_BUSY; // использую busy, чтобы отличать ситуацию от HAL_ERROR
}
}
/**
* @brief Записывает пользовательские байты
* @param sensor Указатель на структуру датчика
* @param UserBytes12 Пользовательские байты 1 и 2
* @param UserBytes34 Пользовательские байты 3 и 4
* @param UserBytesMask Маска, какие байты записывать, а какие нет
* @brief Записывает пользовательские байты
* @param sensor Указатель на структуру датчика
* @param UserBytes12 Пользовательские байты 1 и 2
* @param UserBytes34 Пользовательские байты 3 и 4
* @param UserBytesMask Маска, какие байты записывать, а какие нет
* @retval HAL Status
* @details старший байт - UserByte4/UserByte2, младший - UserByte3/UserByte1.
* @details старший байт - UserByte4/UserByte2, младший - UserByte3/UserByte1.
*/
HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask)
HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_SensorHandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Проверка присутствует ли выбранный датчик на линии */
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
return result;
result = DS18B20_WriteUserBytes(sensor->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
result = DS18B20_WriteUserBytes(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
if (result != HAL_OK)
{
sensor->f.other_err_cnt++;
sensor->f.write_err_cnt++;
return result;
}
result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
result = Dallas_ReadScratchpad(sensor);
if (result != HAL_OK)
{
return result;
@@ -547,3 +546,9 @@ HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t U
}
HAL_StatusTypeDef Dallas_ReadScratchpad(DALLAS_SensorHandleTypeDef *sensor)
{
if(sensor == NULL)
return HAL_ERROR;
return DS18B20_ReadScratchpad(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad);
}

162
DS18B20/dallas_tools.h
View File

@@ -1,14 +1,14 @@
/**
******************************************************************************
* @file dallas_tools.h
* @brief Äðàéâåð äàò÷èêîâ òåìïåðàòóðû DALLAS
* @brief Драйвер датчиков температуры DALLAS
******************************************************************************
* Ýòîò ôàéë ïðåäîñòàâëÿåò îáúÿâëåíèÿ è îïðåäåëåíèÿ äëÿ ðàáîòû ñ äàò÷èêàìè
* òåìïåðàòóðû DS18B20. Îí âêëþ÷àåò ñòðóêòóðû äàííûõ, ìàêðîñû è ïðîòîòèïû
* ôóíêöèé äëÿ èíèöèàëèçàöèè, ÷òåíèÿ òåìïåðàòóðû
* è óïðàâëåíèÿ äàò÷èêàìè.
* Этот файл предоставляет объявления и определения для работы с датчиками
* температуры DS18B20. Он включает структуры данных, макросы и прототипы
* функций для инициализации, чтения температуры
* и управления датчиками.
*
* Ðàáîòà ñ äàò÷èêàìè âåä¸òñÿ ÷åðåç ïðîòîêîë OneWire.
* Работа с датчиками ведётся через протокол OneWire.
*****************************************************************************/
#ifndef DALLAS_TOOLS_H
@@ -20,15 +20,15 @@
#include "ds18b20_driver.h"
#include "onewire.h"
/* Îïðåäåëåíèÿ ïîëüçîâàòåëüñêèõ áàéòîâ äëÿ çàïèñè ÷òåíèÿ */
#define DALLAS_USER_BYTE_1 (1<<0) ///< Ïåðâûé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_2 (1<<1) ///< Âòîðîé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_3 (1<<2) ///< Òðåòèé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_4 (1<<3) ///< ×åòâ¸ðòûé ïîëüçîâàòåëüñêèé áàéò
/* Определения пользовательских байтов для записи чтения */
#define DALLAS_USER_BYTE_1 (1<<0) ///< Первый пользовательский байт
#define DALLAS_USER_BYTE_2 (1<<1) ///< Второй пользовательский байт
#define DALLAS_USER_BYTE_3 (1<<2) ///< Третий пользовательский байт
#define DALLAS_USER_BYTE_4 (1<<3) ///< Четвёртый пользовательский байт
#define DALLAS_USER_BYTE_12 (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Ïåðâûå äâà áàéòà
#define DALLAS_USER_BYTE_34 (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Âòîðûå äâà áàéòà
#define DALLAS_USER_BYTE_ALL (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Âñå ïîëüçîâàòåëüñêèå áàéòû
#define DALLAS_USER_BYTE_12 (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Первые два байта
#define DALLAS_USER_BYTE_34 (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Вторые два байта
#define DALLAS_USER_BYTE_ALL (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Все пользовательские байты
/* Declarations and definitions ---------------------------------------------*/
#define DALLAS_ROM_SIZE 8
@@ -44,97 +44,105 @@
#define DALLAS_DELAY_MS_12_BITS 750
#define DALLAS_DELAY_MS_MAX DALLAS_DELAY_MS_12_BITS
/** @brief Ñòðóêòóðà Scratchpad äàò÷èêà DALLAS */
/** @brief Структура Scratchpad датчика DALLAS */
typedef struct
{
uint8_t TemperatureLSB; ///< Ìëàäøèé áàéò òåìïåðàòóðû
uint8_t TemperatureMSB; ///< Ñòàðøèé áàéò òåìïåðàòóðû
uint8_t tHighRegister; ///< Âåðõíèé òåìïåðàòóðíûé ïîðîã
uint8_t tLowRegister; ///< Íèæíèé òåìïåðàòóðíûé ïîðîã
uint8_t ConfigRegister; ///< Êîíôèãóðàöèîííûé ðåãèñòð
uint8_t reserved; ///< Çàðåçåðâèðîâàíî
uint8_t UserByte3; ///< Ïîëüçîâàòåëüñêèé áàéò 3
uint8_t UserByte4; ///< Ïîëüçîâàòåëüñêèé áàéò 4
uint8_t ScratchpadCRC; ///< Êîíòðîëüíàÿ ñóììà
uint8_t TemperatureLSB; ///< Младший байт температуры
uint8_t TemperatureMSB; ///< Старший байт температуры
uint8_t tHighRegister; ///< Верхний температурный порог
uint8_t tLowRegister; ///< Нижний температурный порог
uint8_t ConfigRegister; ///< Конфигурационный регистр
uint8_t reserved; ///< Зарезервировано
uint8_t UserByte3; ///< Пользовательский байт 3
uint8_t UserByte4; ///< Пользовательский байт 4
uint8_t ScratchpadCRC; ///< Контрольная сумма
}DALLAS_ScratchpadTypeDef;
/** @brief Ñòðóêòóðà ôëàãîâ îøèáîê äàò÷èêîâ DALLAS */
/** @brief Структура флагов ошибок датчиков DALLAS */
typedef struct
{
unsigned disconnect_cnt; ///< Ñ÷åò÷èê îòêëþ÷åíèé äàò÷èêà
unsigned read_temperature_err_cnt; ///< Ñ÷åò÷èê îøèáîê ÷òåíèÿ òåìïåðàòóðû
unsigned timeout_convertion_cnt; ///< Ñ÷åò÷èê îøèáîê òàéìàóòà êîíâåðòàöèè
unsigned other_err_cnt; ///< Ñ÷åò÷èê äðóãèõ îøèáîê
uint8_t disconnect_cnt; ///< Счетчик отключений датчика
uint8_t read_temperature_err_cnt; ///< Счетчик ошибок чтения температуры
uint8_t timeout_convertion_cnt; ///< Счетчик ошибок таймаута конвертации
uint8_t write_err_cnt; ///< Счетчик других ошибок
}DALLAS_FlagsTypeDef;
/** @brief Ñòðóêòóðà èíèöèàëèçàöèè äàò÷èêà DALLAS */
typedef struct
/** @brief Структура инициализации датчика DALLAS */
typedef struct __packed
{
uint64_t ROM; ///< Óíèêàëüíûé ROM-êîä äàò÷èêà
uint16_t UserBytes12; ///< Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
uint16_t UserBytes34; ///< Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
uint8_t SensInd; ///< Èíäåêñ ñåíñîðà
uint8_t Resolution; ///< Ðàçðåøåíèå äàò÷èêà
HAL_StatusTypeDef (*init_func)(); ///< Ôóíêöèÿ èíèöèàëèçàöèè
uint64_t InitParam; ///< Параметр для инициализации: ROM/UserBytes/Индекс
uint8_t Resolution; ///< Разрешение датчика
HAL_StatusTypeDef (*init_func)(); ///< Функция инициализации
} DALLAS_InitStructTypeDef;
/** @brief Îñíîâíàÿ ñòðóêòóðà îáðàáîò÷èêà äàò÷èêà DALLAS */
/** @brief Cтруктура обработчика DALLAS для общения с датчиком*/
typedef struct
{
unsigned isConnected:1; ///< Ôëàã ñîåäèíåíèÿ
unsigned isInitialized:1; ///< Ôëàã èíèöèàëèçàöèè
unsigned isLost:1; ///< Ôëàã ïîòåðè ñâÿçè
OneWire_t *onewire;
DS18B20_Drv_t *ds_devices;
DALLAS_ScratchpadTypeDef scratchpad;
}DALLAS_HandleTypeDef;
extern DALLAS_HandleTypeDef hdallas1;
/** @brief Основная структура обработчика датчика DALLAS */
typedef struct
{
unsigned isConnected:1; ///< Флаг соединения
unsigned isInitialized:1; ///< Флаг инициализации
unsigned isLost:1; ///< Флаг потери связи
OneWire_t *onewire; ///< Èíòåðôåéñ OneWire
uint64_t sensROM; ///< ROM-êîä äàò÷èêà
DALLAS_HandleTypeDef *hdallas;
uint64_t sensROM; ///< ROM-код датчика
DALLAS_ScratchpadTypeDef scratchpad; ///< Scratchpad äàò÷èêà
float temperature; ///< Òåêóùàÿ òåìïåðàòóðà
float temperature; ///< Текущая температура
DALLAS_InitStructTypeDef Init; ///< Ñòðóêòóðà èíèöèàëèçàöèè
DALLAS_FlagsTypeDef f; ///< Ôëàãè
} DALLAS_HandleTypeDef;
DALLAS_InitStructTypeDef Init; ///< Структура инициализации
DALLAS_FlagsTypeDef f; ///< Флаги
} DALLAS_SensorHandleTypeDef;
/** @brief Âàðèàíòû îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè */
/** @brief Варианты ожидания окончания конверсии */
typedef enum
{
DALLAS_WAIT_NONE = 0x00, ///< Áåç îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè
DALLAS_WAIT_BUS = 0x01, ///< Îæèäàíèå îêîí÷àíèÿ êîíâåðñèè ïî øèíå (îïðîñ äàò÷èêîâ - ÷òåíèå áèòà)
DALLAS_WAIT_DELAY = 0x02, ///< Áåç îæèäàíèÿ îêîí÷àíèÿ ÷åðåç çàäåðæêó (ìàêñèìàëüíàÿ çàäåðæêà äëÿ çàäàííîé ðàçðÿäíîñòè)
DALLAS_WAIT_NONE = 0x00, ///< Без ожидания окончания конверсии
DALLAS_WAIT_BUS = 0x01, ///< Ожидание окончания конверсии по шине (опрос датчиков - чтение бита)
DALLAS_WAIT_DELAY = 0x02, ///< Без ожидания окончания через задержку (максимальная задержка для заданной разрядности)
} DALLAS_WaitConvertionTypeDef;
/* Functions ---------------------------------------------------------------*/
/* Ôóíêöèÿ äëÿ íàõîæäåíèÿ íîâîãî äàò÷èêà íà ìåñòî ïîòåðÿííîãî */
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor);
/* Ôóíêöèÿ äëÿ èíèèöàëèçàöèè íîâîãî äàò÷èêà â ñòðóêòóðå */
HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ROM */
HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîëüçîâàòåëüñêèì áàéòàì */
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
/* Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîðÿäêîâîìó íîìåðó */
HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor);
/* Èíèöèàëèçèðóåò äàò÷èê äëÿ ðàáîòû */
HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE]);
/* Äåèíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà */
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor);
/* Çàïóñêàåò èçìåðåíèå òåìïåðàòóðû íà âñåõ äàò÷èêàõ */
HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms);
/* Èçìåðÿåò òåìïåðàòóðó íà äàò÷èêå */
HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition);
/* ×èòàåò èçìåðåííóþ äàò÷èêîì òåìïåðàòóðó */
HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor);
/* Ïðîâåðÿåò ïîäêëþ÷åí ëè äàò÷èê (÷òåíèå scratchpad) */
HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor);
/* Çàïèñûâàåò ïîëüçîâàòåëüñêèå áàéòû */
HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask);
/* Функция для нахождения нового датчика на место потерянного */
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_SensorHandleTypeDef *sensor);
/* Функция для иниицализации нового датчика в структуре */
HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует структуру датчика по ROM */
HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует структуру датчика по пользовательским байтам */
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует структуру датчика по порядковому номеру */
HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor);
/* Инициализирует датчик для работы */
HAL_StatusTypeDef Dallas_SensorInit(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE]);
/* Деинициализирует структуру датчика */
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor);
/* Запускает измерение температуры на всех датчиках */
HAL_StatusTypeDef Dallas_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

127
DS18B20/ds18b20_driver.c
View File

@@ -17,6 +17,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 +37,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 +55,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 +96,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 +162,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 +188,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 +213,15 @@ HAL_StatusTypeDef DS18B20_StartConvTAll(OneWire_t* OW)
*/
HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad, float *Destination)
{
if(OW == NULL)
return HAL_ERROR;
if(ROM == NULL)
return HAL_ERROR;
if(Scratchpad == NULL)
return HAL_ERROR;
if(Destination == NULL)
return HAL_ERROR;
uint16_t temperature;
uint8_t resolution;
int8_t digit, minus = 0;
@@ -256,8 +289,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 +298,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 +338,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 +352,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 +381,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 +454,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 +538,35 @@ HAL_StatusTypeDef DS18B20_WriteUserBytes(OneWire_t* OW, uint8_t *ROM, int16_t Us
}
/**
* @brief The function is used as search device that had temperature alarm
* triggered and store it in DS18B20 alarm data structure
* @retval status of search, OK = 1, Failed = 0
* @param DS DS18B20 HandleTypedef
* @param OW OneWire HandleTypedef
*/
uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
{
uint8_t t = 0;
///**
// * @brief The function is used as search device that had temperature alarm
// * triggered and store it in DS18B20 alarm data structure
// * @retval status of search, OK = 1, Failed = 0
// * @param DS DS18B20 HandleTypedef
// * @param OW OneWire HandleTypedef
// */
//uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
//{
// uint8_t t = 0;
/* Reset Alarm in DS */
for(uint8_t i = 0; i < OW->RomCnt; i++)
{
for(uint8_t j = 0; j < 8; j++)
{
DS->AlmAddr[i][j] = 0;
}
}
// /* Reset Alarm in DS */
// for(uint8_t i = 0; i < OW->RomCnt; i++)
// {
// for(uint8_t j = 0; j < 8; j++)
// {
// DS->AlmAddr[i][j] = 0;
// }
// }
/* Start alarm search */
while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
{
/* Store ROM of device which has alarm flag set */
OneWire_GetDevRom(OW, DS->AlmAddr[t]);
t++;
}
return (t > 0) ? 1 : 0;
}
// /* Start alarm search */
// while (OneWire_Search(OW, DS18B20_CMD_ALARM_SEARCH))
// {
// /* Store ROM of device which has alarm flag set */
// OneWire_GetDevRom(OW, DS->AlmAddr[t]);
// t++;
// }
// return (t > 0) ? 1 : 0;
//}
/**
* @brief The function is used to initialize the DS18B20 sensor, and search
@@ -514,6 +577,10 @@ uint8_t DS18B20_AlarmSearch(DS18B20_Drv_t *DS, OneWire_t* OW)
*/
HAL_StatusTypeDef DS18B20_Search(DS18B20_Drv_t *DS, OneWire_t *OW)
{
if(OW == NULL)
return HAL_ERROR;
OW->RomCnt = 0;
/* Search all OneWire devices ROM */
while(1)

6
DS18B20/ds18b20_driver.h
View File

@@ -26,7 +26,7 @@
#define DS_GPIO_Port GPIOA
/* Data Structure ------------------------------------------------------------*/
#define DS18B20_DEVICE_AMOUNT 8
#define DS18B20_DEVICE_AMOUNT 30
/* Register ------------------------------------------------------------------*/
#define DS18B20_CMD_CONVERT 0x44
@@ -77,9 +77,6 @@ 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 OneWire_t OW;
@@ -91,6 +88,7 @@ HAL_StatusTypeDef DS18B20_StartConvTAll(OneWire_t* OW);
HAL_StatusTypeDef DS18B20_CalcTemperature(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad, float *destination);
HAL_StatusTypeDef DS18B20_ReadScratchpad(OneWire_t* OW, uint8_t *ROM, uint8_t *Scratchpad);
HAL_StatusTypeDef DS18B20_WaitForEndConvertion(OneWire_t* OW);
HAL_StatusTypeDef DS18B20_WaitForEndConvertion_NonBlocking(OneWire_t* OW);
HAL_StatusTypeDef DS18B20_SetTempAlarm(OneWire_t* OW, uint8_t *ROM, int8_t Low,
int8_t High);
HAL_StatusTypeDef DS18B20_WriteUserBytes(OneWire_t* OW, uint8_t *ROM, int16_t UserBytes12,

2
DS18B20/dwt.h
View File

@@ -13,7 +13,7 @@
#endif
/* Includes ------------------------------------------------------------------*/
#include "stm32f1xx_hal.h"
#include "stm32f1xx.h"
/* Custom Define -------------------------------------------------------------*/
#define DWT_LAR_UNLOCK (uint32_t)0xC5ACCE55

30
DS18B20/onewire.c
View File

@@ -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_uw(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_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_1_US);
OneWire_Pin_Mode(OW, Input);
}else{
/* Set line low */
@@ -37,15 +38,16 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
OneWire_Pin_Mode(OW, Output);
/* Forming pulse */
OneWireDelay_uw(ONEWIRE_WRITE_0_US);
OneWire_Delay_uw(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_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_WRITE_0_US);
OneWire_Pin_Mode(OW, Input);
}
__enable_irq();
#else
OneWireUART_ProcessBit(onewire_uart, bit);
#endif
@@ -61,22 +63,24 @@ 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_uw(ONEWIRE_READ_CMD_US);
/* Release line */
OneWire_Pin_Mode(OW, Input);
OneWireDelay_uw(ONEWIRE_READ_DELAY_US);
OneWire_Delay_uw(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_uw(ONEWIRE_COMMAND_SLOT_US - ONEWIRE_READ_CMD_US - ONEWIRE_READ_DELAY_US);
__enable_irq();
#else
bit = OneWireUART_ProcessBit(onewire_uart, 1);
#endif
@@ -145,17 +149,17 @@ 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_uw(ONEWIRE_RESET_PULSE_US);
/* Release line and wait for 70us */
OneWire_Pin_Mode(OW, Input);
OneWireDelay_uw(ONEWIRE_PRESENCE_WAIT_US);
OneWire_Delay_uw(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_uw(ONEWIRE_PRESENCE_DURATION_US);
#else
uint8_t rslt = 0;
@@ -312,11 +316,11 @@ void OneWire_Init(OneWire_t* OW)
{
OneWire_Pin_Mode(OW, Output);
OneWire_Pin_Level(OW, 1);
OneWireDelay_uw(1000);
OneWire_Delay_uw(1000);
OneWire_Pin_Level(OW, 0);
OneWireDelay_uw(1000);
OneWire_Delay_uw(1000);
OneWire_Pin_Level(OW, 1);
OneWireDelay_uw(2000);
OneWire_Delay_uw(2000);
/* Reset the search state */
OW->LastDiscrepancy = 0;

18
DS18B20/onewire.h
View File

@@ -19,16 +19,16 @@
//#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_RESET_PULSE_US 480 // Длительность импульса сброса
#define ONEWIRE_PRESENCE_WAIT_US 70 // Ожидание ответа от датчика
#define ONEWIRE_PRESENCE_DURATION_US 410 // Длительность сигнала присутствия
#define ONEWIRE_WRITE_1_US 6 // Äëèòåëüíîñòü çàïèñè "1"
#define ONEWIRE_WRITE_0_US 60 // Äëèòåëüíîñòü çàïèñè "0"
#define ONEWIRE_READ_CMD_US 5 // Âðåìÿ êîììàíäû ÷òåíèÿ áèòà
#define ONEWIRE_READ_DELAY_US 10 // Çàäåðæêà ïåðåä ñ÷èòûâàíèåì áèòà
#define ONEWIRE_RECOVERY_TIME_US 1 // Âîññòàíîâëåíèå ïåðåä ñëåäóþùèì ñëîòîì
#define ONEWIRE_COMMAND_SLOT_US 70 // Îáùåå âðåìÿ êîììàíäû OneWire
#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_RECOVERY_TIME_US 1 // Восстановление перед следующим слотом
/* Common Register -----------------------------------------------------------*/
#define ONEWIRE_CMD_SEARCHROM 0xF0
#define ONEWIRE_CMD_READROM 0x33

2
DS18B20/ow_port.h
View File

@@ -14,6 +14,6 @@
#include "dwt.h"
/* OneWire Timings -----------------------------------------------------------*/
#define OneWireDelay_uw(_us_) DwtDelay_us(_us_)
#define OneWire_Delay_uw(_us_) DwtDelay_us(_us_)
/* Common Register -----------------------------------------------------------*/
#endif /* ONEWIRE_PORT_H */

248
DS18B20/pch_sensors.c
View File

@@ -1,40 +1,57 @@
/**
******************************************************************************
* @file pch_sensors.c
* @brief Ðàáîòà ñ äàò÷èêàìè òåìïåðàòóðû DS18B20 â Ï×
* @brief Работа с датчиками температуры DS18B20 в ПЧ
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "pch_sensors.h"
PCHSens_UnknownSensorsTypeDef UnknownSensors;
/* Declarations and definitions --------------------------------------------*/
PCHSens_ModuleTypeDef module1;
PCHSens_DallasBusHandle DallasBus;
/* Functions ---------------------------------------------------------------*/
HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM)
void PCHSens_FirstInit(void)
{
DALLAS_HandleTypeDef tempsens;
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(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
sensor->sens.Init.ROM = ROM;
sensor->sens.Init.UserBytes12 = sensor->Location.all;
sensor->sens.Init.InitParam = ROM;
sensor->sens.Init.init_func = &Dallas_SensorInitByROM;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
result = Dallas_AddNewSensors(hdallas, &sensor->sens);
if(result != HAL_OK)
{
sensor->not_found = 1;
sensor->not_found = 1;
return result;
}
@@ -42,13 +59,18 @@ HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDe
if(result != HAL_OK)
return result;
sensor->sens.Init.InitParam = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
result = Dallas_AddNewSensors(hdallas, &sensor->sens);
if(result == HAL_OK)
{
sensor->not_found = 0;
}
else
{
sensor->not_found = 1;
}
return result;
}
@@ -56,33 +78,35 @@ HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDe
HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
HAL_StatusTypeDef PCHSens_AddSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
sensor->sens.Init.UserBytes12 = sensor->Location.all;
sensor->sens.Init.InitParam = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
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(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param)
HAL_StatusTypeDef PCHSens_InitModule(DALLAS_HandleTypeDef *hdallas, PCHSens_ModuleTypeDef* module, uint16_t param)
{
if(onewire == NULL)
if(hdallas == NULL)
return HAL_ERROR;
if(module == NULL)
return HAL_ERROR;
@@ -90,92 +114,113 @@ HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef*
PCHSens_LocationTypeDef initlocation;
initlocation.all = param;
module->onewire = onewire;
module->hdallas = hdallas;
module->refLocation = initlocation;
module->sens1.Location.all = module->refLocation.all;
module->sens1.Location.param.Location = 0;
PCHSens_AddSensor(onewire, &module->sens1);
PCHSens_AddSensor(hdallas, &module->sens1);
module->sens2.Location.all = module->refLocation.all;
module->sens2.Location.param.Location = 1;
PCHSens_AddSensor(onewire, &module->sens2);
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(onewire, &module->sens3);
PCHSens_AddSensor(hdallas, &module->sens3);
module->sens4.Location.all = module->refLocation.all;
module->sens4.Location.param.Location = 3;
PCHSens_AddSensor(onewire, &module->sens4);
PCHSens_AddSensor(hdallas, &module->sens4);
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module)
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 = Dallas_StartConvertTAll(module->onewire, DALLAS_WAIT_BUS, 0);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens1);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens2);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens3);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens4);
PCHSens_DefineUnknownSensor(&UnknownSensors, NULL);
result = PCHSens_ReadTemperature(sensor);
if(result != HAL_OK)
PCHSens_CheckSensor(hdallas, sensor);
return result;
}
HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
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;
PCHSens_LocationTypeDef initlocation;
unsigned unknow_sensors_flag = 0;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->sens.isInitialized == 0)
return HAL_ERROR;
result = Dallas_ReadTemperature(&sensor->sens);
if((sensor->sens.isLost == 1))
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))
{
initlocation.param.Location = 0;
if(Dallas_ReplaceLostedSensor(&sensor->sens) != HAL_OK)
if(Dallas_ReplaceLostedSensor(&sensor->sens) == HAL_ERROR)
{
sensor->not_found = 1;
}
else
{
sensor->not_found = 0;
sensor->not_found = 0;
}
}
else
{
sensor->not_found = 0;
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns)
HAL_StatusTypeDef PCHSens_FindUnknownSensors(PCHSens_DallasBusHandle *hbus)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(unknowns == NULL)
if(hbus == NULL)
return HAL_ERROR;
unknowns->onewire = onewire;
unknowns->UnknownCnt = 0;
DALLAS_ScratchpadTypeDef scratchpad;
hbus->UnknownCnt = 0;
PCHSens_LocationTypeDef *param = (PCHSens_LocationTypeDef *)&scratchpad.tHighRegister;
for(int i = 0; i < onewire->RomCnt; i++)
PCHSens_LocationTypeDef *param = (PCHSens_LocationTypeDef *)&hbus->hdallas->scratchpad.tHighRegister;
for(int i = 0; i < hbus->hdallas->onewire->RomCnt; i++)
{
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
/* Проверка присутствует ли выбранный датчик на линии */
result = DS18B20_ReadScratchpad(hbus->hdallas->onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&hbus->hdallas->scratchpad);
if(result != HAL_OK)
__NOP();
@@ -183,32 +228,16 @@ HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_Unknown
(IS_REG_PCH_LOCATION(param) == 0) ||
(IS_REG_PCH_NUMB(param) == 0) )
{
unknowns->unknown_sensors[unknowns->UnknownCnt].Init.SensInd = i;
unknowns->unknown_sensors[unknowns->UnknownCnt].Init.init_func = &Dallas_SensorInitByInd;
result = Dallas_AddNewSensors(onewire, &unknowns->unknown_sensors[unknowns->UnknownCnt++]);
// 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_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if((unknowns->ROMtoDefine != NULL) && (unknowns->LocationtoDefine.all != NULL) && (unknowns->senstoDefine != NULL))
{
result = PCHSens_InitNewSensor(unknowns->onewire, unknowns->senstoDefine, unknowns->ROMtoDefine);
unknowns->ROMtoDefine = 0;
unknowns->LocationtoDefine.all = 0;
unknowns->senstoDefine = 0;
return result;
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
@@ -224,70 +253,3 @@ HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor)
result = Dallas_SensorDeInit(&sensor->sens);
return result;
}
HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->action.connectROM != NULL)
{
result = PCHSens_InitNewSensor(onewire, sensor, sensor->action.connectROM);
sensor->action.connectROM = 0;
}
if(sensor->action.read != NULL)
{
// sensor->action.read = 0;
result = Dallas_ReadTemperature(&sensor->sens);
if(result != HAL_OK)
PCHSens_CheckSensor(onewire, sensor);
}
if(sensor->action.deinit != NULL)
{
sensor->action.deinit = 0;
result = PCHSens_UndefineSensor(sensor);
}
return result;
}
void PCHSens_FirstInit(void)
{
int init_find = 0;
OW.DataPin = DS_Pin;
OW.DataPort = DS_GPIO_Port;
DS.Resolution = DS18B20_RESOLUTION_9BITS;
OneWire_Init(&OW);
DS18B20_Search(&DS, &OW);
PCHSens_InitModule(&OW, &module1, REG_PCH_NUMB_11|REG_PCH_DIODE_NUMB_1);
PCHSens_FindUnknownSensors(&OW, &UnknownSensors);
PCHSens_DefineUnknownSensor(&UnknownSensors, NULL);
// Dallas_SensorInitByInd(&OW, &AllSens.outdoor, 0);
// Dallas_SensorInitByInd(&OW, &AllSens.indoor, 2);
// Dallas_SensorInitByInd(&OW, &AllSens.bathroom, 1);
// Dallas_SensorInitByInd(&OW, &AllSens.kitchen, 3);
// Dallas_SensorInitByInd(&OW, &AllSens.big_room, 4);
// Dallas_SensorInitByInd(&OW, &AllSens.small_room, 5);
// Dallas_SensorInitByInd(&OW, &AllSens.living_room, 6);
// Dallas_SensorInitByInd(&OW, &AllSens.basement, 7);
//
// uint8_t mask = DALLAS_USER_BYTE_ALL;
// Dallas_WriteUserBytes(&AllSens.outdoor, 1, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.indoor, 2, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.bathroom, 3, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.kitchen, 4, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.big_room, 5, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.small_room, 6, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.living_room, 7, NULL, mask);
// Dallas_WriteUserBytes(&AllSens.basement, 8, NULL, mask);
}

122
DS18B20/pch_sensors.h
View File

@@ -1,7 +1,7 @@
/**
******************************************************************************
* @file pch_sensors.h
* @brief Ðàáîòà ñ äàò÷èêàìè òåìïåðàòóðû DS18B20 â Ï×
* @brief Работа с датчиками температуры DS18B20 в ПЧ
******************************************************************************
*****************************************************************************/
@@ -11,45 +11,43 @@
/* Includes -----------------------------------------------------------------*/
#include "stm32f1xx_hal.h"
#include "dallas_tools.h"
/* Declarations and definitions ---------------------------------------------*/
#define USED_USER_BYTES DALLAS_USER_BYTE_12
/* Ïîçèöèè ïàðàìåòðîâ â UserBytes */
#define REG_SENS_LOCATION_Pos (0) /*!< @brief Ïîçèöèÿ ïàðàìåòðà "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
/* Позиции параметров в 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_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_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 Ïîçèöèÿ ïàðàìåòðà "ÇÈÏ/íå ÇÈÏ" */
#define REG_ZIP_Pos (15) /*!< @brief Позиция параметра "ЗИП/не ЗИП" */
/* Ìàñêè ïàðàìåòðîâ â UserBytes */
#define REG_SENS_LOCATION_Mask ((uint16_t)0x3 << REG_SENS_LOCATION_Pos) /*!< @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_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_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 Ìàñêà ïàðàìåòðà "ÇÈÏ/íå ÇÈÏ" */
#define REG_ZIP_Mask ((uint16_t)0x1 << REG_ZIP_Pos) /*!< @brief Маска параметра "ЗИП/не ЗИП" */
/* Âàðèàíòû ïàðàìåòðîâ â UserBytes */
/* Варианты параметров в UserBytes */
#define REG_PCH_NUMB_11 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_12 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_13 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_21 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_22 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_23 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_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))
@@ -58,20 +56,20 @@
#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 Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
/* Получить параметр из 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_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_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 Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
#define GET_REG_ZIP(_REG_) ((_REG_) & REG_ZIP_Mask) /*!< @brief Получить параметр "ЗИП/не ЗИП" */
/* Äèàïàçîíû ïàðàìåòðîâ èç UserBytes */
/* Диапазоны параметров из UserBytes */
#define REG_SENS_LOCATION_MAX 3
#define REG_SENS_LOCATION_MIN 0
#define REG_PCH_DIOD_PHASE_MAX 1
@@ -84,23 +82,23 @@
#define REG_PCH_NUMB_DIGIT_2_MIN 1
/** @brief Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
/** @brief Получить параметр "Локация внутри модуля" */
#define IS_REG_SENS_LOCATION(_REG_) (((_REG_)->param.Location <= REG_SENS_LOCATION_MAX) && ((_REG_)->param.Location >= REG_SENS_LOCATION_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ðàñïîëîæåíèå â Ï×" */
/*!< @brief Получить параметр "Расположение в ПЧ" */
#define IS_REG_PCH_LOCATION(_REG_) (IS_REG_PCH_DIOD_PHASE(_REG_) && IS_REG_PCH_MODULE_NUMB(_REG_))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Äèîäíûé èëè ôàçíûé ìîäóëü" */
/*!< @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 Ïîëó÷èòü ïàðàìåòð "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
/*!< @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 Ïîëó÷èòü ïàðàìåòð "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
/*!< @brief Получить параметр "Преобразователь частоты" */
#define IS_REG_PCH_NUMB(_REG_) (IS_REG_PCH_NUMB_DIGIT_1(_REG_) && IS_REG_PCH_NUMB_DIGIT_2(_REG_))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
/*!< @brief Получить параметр "Первая цифра номера преобразователя частоты" */
#define IS_REG_PCH_NUMB_DIGIT_1(_REG_) (((_REG_)->param.PCHdig1 <= REG_PCH_NUMB_DIGIT_1_MAX) && ((_REG_)->param.PCHdig1 >= REG_PCH_NUMB_DIGIT_1_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" s*/
/*!< @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 Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
/*!< @brief Получить параметр "ЗИП/не ЗИП" */
#define IS_REG_ZIP(_REG_) (GET_REG_ZIP(_REG_))
typedef union
@@ -121,23 +119,23 @@ typedef union
typedef struct
{
unsigned connectROM;
unsigned convertion;
uint64_t connectROM;
unsigned read;
unsigned deinit;
}PCHSens_SensorActionsTypeDef;
extern PCHSens_SensorActionsTypeDef action;
typedef struct
{
DALLAS_HandleTypeDef sens;
// PCHSens_LocationTypeDef *UserBytes;
DALLAS_SensorHandleTypeDef sens;
PCHSens_LocationTypeDef Location;
PCHSens_SensorActionsTypeDef action;
unsigned not_found:1;
}PCHSens_SensorTypeDef;
typedef struct
{
OneWire_t *onewire;
DALLAS_HandleTypeDef *hdallas;
PCHSens_SensorTypeDef sens1;
PCHSens_SensorTypeDef sens2;
@@ -151,24 +149,20 @@ extern PCHSens_ModuleTypeDef module1;
typedef struct
{
OneWire_t *onewire;
DALLAS_HandleTypeDef unknown_sensors[DS18B20_DEVICE_AMOUNT];
uint8_t UnknownCnt;
uint64_t ROMtoDefine;
PCHSens_LocationTypeDef LocationtoDefine;
PCHSens_SensorTypeDef *senstoDefine;
}PCHSens_UnknownSensorsTypeDef;
DALLAS_HandleTypeDef *hdallas;
uint8_t UnknownCnt;
}PCHSens_DallasBusHandle;
/* Functions ---------------------------------------------------------------*/
HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns);
HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM);
HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param);
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module);
HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor);
HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor);
void PCHSens_FirstInit(void);
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

2
test_project/Core/Src/main.c
View File

@@ -103,7 +103,7 @@ int main(void)
/* USER CODE BEGIN WHILE */
while (1)
{
PCHSens_ReadTemperature(&module1);
PCHSens_ModuleReadTemperature(&module1);
// Dallas_ReadAll();
/* Start temperature conversion on all devices on one bus */
// DS18B20_StartConvTAll(&OW);

33
test_project/MDK-ARM/ds18b20.uvoptx
View File

@@ -145,42 +145,15 @@
<SetRegEntry>
<Number>0</Number>
<Key>ST-LINKIII-KEIL_SWO</Key>
<Name>-U53FF72064980555724221187 -O2254 -SF10000 -C0 -A0 -I0 -HNlocalhost -HP7184 -P1 -N00("ARM CoreSight SW-DP (ARM Core") -D00(1BA01477) -L00(0) -TO131090 -TC10000000 -TT10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO7 -FD20000000 -FC800 -FN1 -FF0STM32F10x_128.FLM -FS08000000 -FL08000 -FP0($$Device:STM32F103C6$Flash\STM32F10x_128.FLM) -WA0 -WE0 -WVCE4 -WS2710 -WM0 -WP2</Name>
<Name>-U005600373433510237363934 -O2254 -SF10000 -C0 -A0 -I0 -HNlocalhost -HP7184 -P1 -N00("ARM CoreSight SW-DP (ARM Core") -D00(1BA01477) -L00(0) -TO131090 -TC10000000 -TT10000000 -TP21 -TDS8007 -TDT0 -TDC1F -TIEFFFFFFFF -TIP8 -FO7 -FD20000000 -FC800 -FN1 -FF0STM32F10x_128.FLM -FS08000000 -FL08000 -FP0($$Device:STM32F103C6$Flash\STM32F10x_128.FLM) -WA0 -WE0 -WVCE4 -WS2710 -WM0 -WP2</Name>
</SetRegEntry>
</TargetDriverDllRegistry>
<Breakpoint>
<Bp>
<Number>0</Number>
<Type>0</Type>
<LineNumber>264</LineNumber>
<EnabledFlag>1</EnabledFlag>
<Address>134230484</Address>
<ByteObject>0</ByteObject>
<HtxType>0</HtxType>
<ManyObjects>0</ManyObjects>
<SizeOfObject>0</SizeOfObject>
<BreakByAccess>0</BreakByAccess>
<BreakIfRCount>1</BreakIfRCount>
<Filename>..\..\DS18B20\pch_sensors.c</Filename>
<ExecCommand></ExecCommand>
<Expression>\\ds18b20\../../DS18B20/pch_sensors.c\264</Expression>
</Bp>
</Breakpoint>
<Breakpoint/>
<WatchWindow1>
<Ww>
<count>0</count>
<WinNumber>1</WinNumber>
<ItemText>OW</ItemText>
</Ww>
<Ww>
<count>1</count>
<WinNumber>1</WinNumber>
<ItemText>DS</ItemText>
</Ww>
<Ww>
<count>2</count>
<WinNumber>1</WinNumber>
<ItemText>UnknownSensors</ItemText>
<ItemText>DallasBus</ItemText>
</Ww>
</WatchWindow1>
<WatchWindow2>