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

Compare commits

base: Templates:0f2736b8a519cf612dfa5a36d62222f368783acd
Branches Tags
Templates:dallas_lib Templates:py32_dallas
...
compare: Templates:py32_dallas
Branches Tags
Templates:dallas_lib Templates:py32_dallas

36 Commits
0f2736b8a5 ... py32_dalla

Author SHA1 Message Date
Razvalyaev
1ba89a0f52 добавлены еще пару файлов для py32f001a,но теперь на нем перерасход оперативки, надо ужать 2025-03-10 11:50:32 +03:00
Razvalyaev
bef05f2773 Исправлено, работает для 002B. Было лишнее задание высокого приоритета таймера модбас, также была переименована функция прерывания таймера модбас 2025-03-06 16:13:41 +03:00
Razvalyaev
016efe4a05 перестал работать проект для 002B 2025-03-06 15:42:54 +03:00
Razvalyaev
570a11a37f Обновлены пины в проекте PY32F002A и в принципе описание всех пинов для B и A контроллера 2025-03-06 14:35:40 +03:00
Razvalyaev
4c987be8e7 Добавлен таргет проект для PY32F002A 2025-03-06 13:26:17 +03:00
Razvalyaev
15134a549a память уменьшена до 20кбайт, все компилируется 2025-03-06 12:45:38 +03:00
Razvalyaev
dbc9388f67 Прога ужата до 20 кб флеш: удален HAL_TIM и HAL_GPIO 
удалена ненужна по сути MyLibs библиотека
 2025-03-06 12:44:55 +03:00
Razvalyaev
fad121a9fd Добавлена терминалка от андрея, +проект вынесен в отдельную папку 2025-03-05 17:23:57 +03:00
Razvalyaev
424ca121f8 Merge branch 'py32f002b_dallas_allrom_in_modbus' into py32f002b_dallas 2025-03-05 17:17:42 +03:00
Razvalyaev
1d6ccdbef3 Merge remote-tracking branch 'DS18B20_Library/py32f002b_dallas' into py32f002b_dallas 2025-03-05 17:17:18 +03:00
Razvalyaev
8d44a1a153 Убраны пока лишние пч, т.к. датчиков всего 4 
Убрана функция скана
Исправлен оформирование ром для инициализации датчика
Переделан функция деинита структуры сенсора
 2025-03-05 17:16:00 +03:00
Coal56AB
b4305e8296 Обновить README.md 2025-03-05 17:14:43 +03:00
Razvalyaev
b59da11afc добавлены адреса и ответ на запрос по регистрам со всеми найденными ROM 2025-03-05 13:12:54 +03:00
Razvalyaev
1633a224f3 проблема была в невыровненых данных 
была строчка
  sensor->sensROM = *(uint64_t *)(ROM);

и она требует чтобы указатель ROM был выровнен по 4 байта

Но он не выровнен, потому что шаг модбас структуры 2 байта и он оказывается смещен на 2 байта вместо 4

Добавил резервные 2 байта, чтобы адрес быо кратен 4 байтам
 2025-03-05 13:04:40 +03:00
Razvalyaev
54c8a663e4 попытка перенести адреса всех найденных устройств в modbus_data 
почему-то вылетает на Dallas_SensorInit
 2025-03-05 12:23:39 +03:00
Razvalyaev
458d2d77c9 исправлены диапазоны адресов у коилов 
сделано обращение по указателям в паре мест
убрана громоздская конструкция из OneWire_Pin_Mode
 2025-03-05 12:22:35 +03:00
Coal56AB
3687f2db60 Обновить README.md 2025-03-05 11:54:23 +03:00
Razvalyaev
26852bbec0 Добавлен статус для окончания скана 2025-03-05 10:56:23 +03:00
Coal56AB
68794b6981 Обновить README.md 2025-03-05 10:55:25 +03:00
Coal56AB
0b26757a73 Описание работы с модулем 2025-03-05 10:53:38 +03:00
Razvalyaev
28749c63e8 Добавлен функция скана всех сенсоров на линии через модбас 
Заполнение респонса в модбас выведено в отдельную функцию
 2025-03-05 10:07:05 +03:00
Coal56AB
932a6cc8e0 Обновить README.md 2025-03-04 17:24:39 +03:00
Razvalyaev
617dcdd228 Регистр модбас Resolution переименован в Config регистр 2025-03-04 13:52:04 +03:00
Razvalyaev
102831d24c Merge branch 'py32f002b_dallas' of https://git.arktika.cyou/set506/DS18B20_Library into py32f002b_dallas 2025-03-04 13:48:39 +03:00
Razvalyaev
9f438ccd2f Сделано базовое управление по модбас 
- сохранение температур в модбас
- чтение параметров датчика
- инициализация нового датчика
- деинициализация старого датчика

Проект связанный с PY32модулем и температурами ПЧ перенесен в отдельную папку
 2025-03-04 13:48:28 +03:00
Coal56AB
495c358ada Описание работы с модулем 2025-03-04 09:51:32 +03:00
Razvalyaev
369e4a4b82 Merge branch 'py32f002b_dallas' of https://git.arktika.cyou/set506/DS18B20_Library into py32f002b_dallas 2025-03-04 09:42:26 +03:00
Razvalyaev
b5a26200f3 сурсы преобразованы в utf-8 2025-03-04 09:41:49 +03:00
Razvalyaev
a5a14679f3 Добавлен watchdog таймер 2025-03-04 09:39:24 +03:00
Coal56AB
3402381c55 Заготовка для readme 2025-03-03 18:49:43 +03:00
Razvalyaev
324c26e559 Базово всё запущено. Датчики считываются записываются в модбас регистры, и по запросу выдаются. 
Есть запас на 27-30 датчиков
 2025-03-03 16:49:25 +03:00
Razvalyaev
b96e00b166 hardfault исправлен, передавался неправильный указатель в функции Dallas_ReplaceLostedSensor 2025-03-03 13:52:22 +03:00
Razvalyaev
aa5b4b3fcb примерная примерная такая же по размеру структура данных модбас которая будет в итоге, все помещается 
hardfault при отключении датчика
 2025-03-03 13:48:21 +03:00
Razvalyaev
e4b2830fcc добавил проверки на пустой указатель в драйвере ds18b20 2025-03-03 13:45:03 +03:00
Razvalyaev
884f1fc3f1 уменьшил размер максимального сообщения модбас до 27 элементов и вроде помещается... но надо проверить с структурой данных модбас под эти датчики 2025-03-03 13:09:20 +03:00
Razvalyaev
b6978c385a Переструктурирован проект, перенесена ветка тестирования modbus и чуть скомпрессированная библиотека dallas 2025-03-03 13:05:37 +03:00
556 changed files with 93029 additions and 7688 deletions
Expand all files Collapse all files

3
.gitignore vendored
View File

@@ -47,3 +47,6 @@ JLinkLog.txt
/MDK-ARM/DebugConfig/
/MDK-ARM/Output/
/~$ds18b20_locations.xlsx
/~$PY32F002A_Pins.xlsx
/~$PY32F002B_Pins.xlsx

552
Core/Dallas/dallas_tools.c
View File

@@ -1,552 +0,0 @@
/**
******************************************************************************
* @file dallas_tools.c
* @brief Äðàéâåð äëÿ ðàáîòû ñ äàò÷èêàìè òåìïåðàòóðû DS18B20
* @author MicroTechnics (microtechnics.ru)
******************************************************************************
@details
Ýòîò ôàéë ñîäåðæèò ðåàëèçàöèþ ôóíêöèé äëÿ ðàáîòû ñ äàò÷èêîì DS18B20
÷åðåç èíòåðôåéñ 1-Wire. Îí ïðåäîñòàâëÿåò ôóíêöèè äëÿ ÷òåíèÿ è çàïèñè
êîíôèãóðàöèè, âûïîëíåíèÿ èçìåðåíèé è îáðàáîòêè ïîëó÷åííûõ äàííûõ.
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "dallas_tools.h"
#include "string.h"
/* Declarations and definitions --------------------------------------------*/
/* Functions ---------------------------------------------------------------*/
/**
* @brief Ôóíêöèÿ äëÿ íàõîæäåíèÿ íîâîãî äàò÷èêà íà ìåñòî ïîòåðÿííîãî
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReplaceLostedSensor(DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
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->onewire, sensor) != HAL_OK)
return HAL_ERROR;
return HAL_OK;
}
else
{
return HAL_BUSY; // äàò÷èê íå ïîòåðÿí
}
}
/**
* @brief Ôóíêöèÿ äëÿ èíèèöàëèçàöèè íîâîãî äàò÷èêà â ñòðóêòóðå
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_AddNewSensors(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
sensor->onewire = onewire;
result = sensor->Init.init_func(onewire, sensor);
return result;
}
/**
* @brief Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ROM
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByROM(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t ROM[8] = {0};
ROM[0] = (sensor->Init.ROM >> (7*8)) & 0xFF;
ROM[1] = (sensor->Init.ROM >> (6*8)) & 0xFF;
ROM[2] = (sensor->Init.ROM >> (5*8)) & 0xFF;
ROM[3] = (sensor->Init.ROM >> (4*8)) & 0xFF;
ROM[4] = (sensor->Init.ROM >> (3*8)) & 0xFF;
ROM[5] = (sensor->Init.ROM >> (2*8)) & 0xFF;
ROM[6] = (sensor->Init.ROM >> (1*8)) & 0xFF;
ROM[7] = (sensor->Init.ROM >> (0*8)) & 0xFF;
if(DS18B20_IsValidAddress(ROM) != HAL_OK)
return HAL_ERROR;
uint8_t comparebytes = DALLAS_ROM_SIZE;
int ROM_ind = 0;
for(int i = 0; i < onewire->RomCnt; i++)
{
comparebytes = DALLAS_ROM_SIZE;
for(int rom_byte = 0; rom_byte < DALLAS_ROM_SIZE; rom_byte++)
{
if(DS.DevAddr[i][rom_byte] == ROM[rom_byte])
comparebytes--;
}
if(comparebytes == 0)
{
ROM_ind = i;
break;
}
}
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
if(comparebytes == 0)
{
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[ROM_ind]);
return result;
}
else
{
return HAL_ERROR;
}
}
/**
* @brief Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîëüçîâàòåëüñêèì áàéòàì
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t UserByte1 = sensor->Init.UserBytes12 & 0xFF;
uint8_t UserByte2 = sensor->Init.UserBytes12 >> 8;
uint8_t UserByte3 = sensor->Init.UserBytes34 & 0xFF;
uint8_t UserByte4 = sensor->Init.UserBytes34 >> 8;
uint8_t UserByte12Cmp = 0;
uint8_t UserByte34Cmp = 0;
DALLAS_ScratchpadTypeDef scratchpad;
for(int i = 0; i < onewire->RomCnt; i++)
{
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
if (result != HAL_OK)
return result;
/* Ñðàâíåíèå UserByte1 è UserByte2, åñëè îíè íå ðàâíû íóëþ */
if(sensor->Init.UserBytes12 != NULL)
{
if( (scratchpad.tHighRegister == UserByte1) &&
(scratchpad.tLowRegister == UserByte2))
{
UserByte12Cmp = 1;
}
}/* Åñëè ñðàâíåíèå UserByte1 è UserByte2 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè ñîâïàäàþò */
else
{
UserByte12Cmp = 1;
}
/* Ñðàâíåíèå UserByte3 è UserByte4, åñëè îíè íå ðàâíû íóëþ */
if(sensor->Init.UserBytes34 != NULL)
{
if( (scratchpad.UserByte3 == UserByte3) &&
(scratchpad.UserByte4 == UserByte4))
{
UserByte34Cmp = 1;
}
}/* Åñëè ñðàâíåíèå UserByte3 è UserByte4 íå âûáðàíî, òî ñ÷èòàåì ÷òî îíè îäèíàêîâûå */
else
{
UserByte34Cmp = 1;
}
/* Åñëè íàøëè íóæíûé äàò÷èê - çàâåðøàåì ïîèñê */
if(UserByte12Cmp && UserByte34Cmp)
{
// sensor->isInitialized = 1;
// sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByUserBytes;
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[i]);
return result;
}
}
sensor->sensROM = 0;
memset(&sensor->scratchpad, 0, sizeof(DALLAS_ScratchpadTypeDef));
/* Âîçâðàùàåì îøèáêó åñëè íå íàøëè */
return HAL_ERROR;
}
/**
* @brief Èíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà ïî ïîðÿäêîâîìó íîìåðó
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
* @details Ïîðÿäêîâûé íîìåð äàò÷èêà â ñïèñêå íàéäåííûõ.
* Ò.å. êàêèì ïî ñ÷åòó ýòîò äàò÷èê áûë íàéäåí
*/
HAL_StatusTypeDef Dallas_SensorInitByInd(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->onewire = onewire;
// sensor->sensROM = &DS.DevAddr[sensor->Init.SensInd];
// sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByInd;
result = Dallas_SensorInit(onewire, sensor, &DS.DevAddr[sensor->Init.SensInd]);
return result;
}
/**
* @brief Èíèöèàëèçèðóåò äàò÷èê äëÿ ðàáîòû
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @param ROM ROM äàò÷èêà, êîòîðûé íàäî èíèöèàëèçèðîâàòü
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInit(OneWire_t *onewire, DALLAS_HandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(onewire == 0)
return HAL_ERROR;
sensor->onewire = onewire;
sensor->sensROM = 0;
sensor->sensROM = *(uint64_t *)(ROM);
// for(int i = 0; i < DALLAS_ROM_SIZE; i++)
// sensor->sensROM |= ((uint64_t)(*ROM)[i] << (56 - 8*i));
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
if (result == HAL_OK)
{
/* Óñòàíîâêà ðàçðåøåíèÿ */
result = DS18B20_SetResolution(onewire, (uint8_t *)ROM, sensor->Init.Resolution);
if (result == HAL_OK)
{
sensor->isInitialized = 1;
return HAL_OK;
}
else
{
sensor->isInitialized = 0;
return result;
}
}
else
{
sensor->isInitialized = 0;
return result;
}
}
/**
* @brief Äåèíèöèàëèçèðóåò ñòðóêòóðó äàò÷èêà
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @param sens_ind Ïîðÿäêîâûé íîìåð äàò÷èêà â ñòðóêòóðå
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_HandleTypeDef *sensor)
{
if(sensor == NULL)
return HAL_ERROR;
DALLAS_InitStructTypeDef initbuff = sensor->Init;
memset(sensor, 0, sizeof(DALLAS_HandleTypeDef));
sensor->Init = initbuff;
return HAL_OK;
}
/**
* @brief Çàïóñêàåò èçìåðåíèå òåìïåðàòóðû íà âñåõ äàò÷èêàõ
* @param onewire Óêàçàòåëü íà ñòðóêòóðó OneWire
* @param waitCondition Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
* @param dallas_delay_ms Âðåìÿ îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_StartConvertTAll(OneWire_t *onewire, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
if(onewire == NULL)
return HAL_ERROR;
// Îòïðàâêà êîìàíäû íà÷àëà ïðåîáðàçîâàíèÿ òåìïåðàòóðû
result = DS18B20_StartConvTAll(onewire);
if(result != HAL_OK)
{
return result;
}
// // Ïðîâåðêà ÷òî ïðåîáðàçîâàíèå íà÷àëîñü
// if(OneWire_ReadBit(onewire) == 1)
// return HAL_ERROR;
// Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì ïðîâåðêè øèíû
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(onewire);
return result;
}
// Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì çàäåðæêè
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
switch (dallas_delay_ms)
{
case DALLAS_CONFIG_9_BITS:
delayValueMs = DALLAS_DELAY_MS_9_BITS;
break;
case DALLAS_CONFIG_10_BITS:
delayValueMs = DALLAS_DELAY_MS_10_BITS;
break;
case DALLAS_CONFIG_11_BITS:
delayValueMs = DALLAS_DELAY_MS_11_BITS;
break;
case DALLAS_CONFIG_12_BITS:
delayValueMs = DALLAS_DELAY_MS_12_BITS;
break;
default:
break;
}
HAL_Delay(delayValueMs);
}
return result;
}
/**
* @brief Èçìåðÿåò òåìïåðàòóðó íà äàò÷èêå
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @param waitCondition Óñëîâèå îæèäàíèÿ çàâåðøåíèÿ ïðåîáðàçîâàíèÿ
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ConvertT(DALLAS_HandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
return result;
// Îòïðàâêà êîìàíäû íà÷àëà ïðåîáðàçîâàíèÿ òåìïåðàòóðû
result = DS18B20_StartConvT(sensor->onewire, (uint8_t *)&sensor->sensROM);
if(result != HAL_OK)
{
return result;
}
// Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì ïðîâåðêè øèíû
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(sensor->onewire);
if(result == HAL_TIMEOUT)
{
sensor->f.timeout_convertion_cnt++;
}
return result;
}
// Îæèäàíèå çàâåðøåíèÿ ïðåîáðàçîâàíèÿ, ïóòåì çàäåðæêè
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
switch (sensor->scratchpad.ConfigRegister)
{
case DALLAS_CONFIG_9_BITS:
delayValueMs = DALLAS_DELAY_MS_9_BITS;
break;
case DALLAS_CONFIG_10_BITS:
delayValueMs = DALLAS_DELAY_MS_10_BITS;
break;
case DALLAS_CONFIG_11_BITS:
delayValueMs = DALLAS_DELAY_MS_11_BITS;
break;
case DALLAS_CONFIG_12_BITS:
delayValueMs = DALLAS_DELAY_MS_12_BITS;
break;
default:
break;
}
HAL_Delay(delayValueMs);
}
/* Íå ñ÷èòûâàåì òåìïåðàòóðó, åñëè íå âûáðàíî îæèäàíèå îêîí÷àíèÿ ïðåîáðàçîâàíèÿ */
if(waitCondition != DALLAS_WAIT_NONE)
{
result = Dallas_ReadTemperature(sensor);
}
return result;
}
/**
* @brief ×èòàåò èçìåðåííóþ äàò÷èêîì òåìïåðàòóðó
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
return result;
result = DS18B20_CalcTemperature(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad, &sensor->temperature);
if (result != HAL_OK)
{
sensor->f.read_temperature_err_cnt++;
return result;
}
return HAL_OK;
}
/**
* @brief Ïðîâåðÿåò ïîäêëþ÷åí ëè äàò÷èê (÷òåíèå scratchpad)
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_IsConnected(DALLAS_HandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor->isInitialized == 0)
return HAL_ERROR;
result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
if (result == HAL_OK)
{
sensor->isConnected = 1;
sensor->isLost = 0;
return HAL_OK;
}
else
{
if(sensor->isConnected == 1)
{
sensor->f.disconnect_cnt++;
sensor->isLost = 1;
}
sensor->isConnected = 0;
// Dallas_ReplaceLostedSensor(sensor);
return HAL_BUSY; // èñïîëüçóþ busy, ÷òîáû îòëè÷àòü ñèòóàöèþ îò HAL_ERROR
}
}
/**
* @brief Çàïèñûâàåò ïîëüçîâàòåëüñêèå áàéòû
* @param sensor Óêàçàòåëü íà ñòðóêòóðó äàò÷èêà
* @param UserBytes12 Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
* @param UserBytes34 Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
* @param UserBytesMask Ìàñêà, êàêèå áàéòû çàïèñûâàòü, à êàêèå íåò
* @retval HAL Status
* @details ñòàðøèé áàéò - UserByte4/UserByte2, ìëàäøèé - UserByte3/UserByte1.
*/
HAL_StatusTypeDef Dallas_WriteUserBytes(DALLAS_HandleTypeDef *sensor, uint16_t UserBytes12, uint16_t UserBytes34, uint8_t UserBytesMask)
{
HAL_StatusTypeDef result;
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);
if (result != HAL_OK)
{
sensor->f.other_err_cnt++;
return result;
}
result = DS18B20_ReadScratchpad(sensor->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->scratchpad);
if (result != HAL_OK)
{
return result;
}
return result;
}

140
Core/Dallas/dallas_tools.h
View File

@@ -1,140 +0,0 @@
/**
******************************************************************************
* @file dallas_tools.h
* @brief Äðàéâåð äàò÷èêîâ òåìïåðàòóðû DALLAS
******************************************************************************
* Ýòîò ôàéë ïðåäîñòàâëÿåò îáúÿâëåíèÿ è îïðåäåëåíèÿ äëÿ ðàáîòû ñ äàò÷èêàìè
* òåìïåðàòóðû DS18B20. Îí âêëþ÷àåò ñòðóêòóðû äàííûõ, ìàêðîñû è ïðîòîòèïû
* ôóíêöèé äëÿ èíèöèàëèçàöèè, ÷òåíèÿ òåìïåðàòóðû
* è óïðàâëåíèÿ äàò÷èêàìè.
*
* Ðàáîòà ñ äàò÷èêàìè âåä¸òñÿ ÷åðåç ïðîòîêîë OneWire.
*****************************************************************************/
#ifndef DALLAS_TOOLS_H
#define DALLAS_TOOLS_H
/* Includes -----------------------------------------------------------------*/
#include "ds18b20_driver.h"
#include "onewire.h"
/* Îïðåäåëåíèÿ ïîëüçîâàòåëüñêèõ áàéòîâ äëÿ çàïèñè ÷òåíèÿ */
#define DALLAS_USER_BYTE_1 (1<<0) ///< Ïåðâûé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_2 (1<<1) ///< Âòîðîé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_3 (1<<2) ///< Òðåòèé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_4 (1<<3) ///< ×åòâ¸ðòûé ïîëüçîâàòåëüñêèé áàéò
#define DALLAS_USER_BYTE_12 (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Ïåðâûå äâà áàéòà
#define DALLAS_USER_BYTE_34 (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Âòîðûå äâà áàéòà
#define DALLAS_USER_BYTE_ALL (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Âñå ïîëüçîâàòåëüñêèå áàéòû
/* Declarations and definitions ---------------------------------------------*/
#define DALLAS_ROM_SIZE 8
#define DALLAS_CONFIG_9_BITS 0x1F
#define DALLAS_CONFIG_10_BITS 0x3F
#define DALLAS_CONFIG_11_BITS 0x5F
#define DALLAS_CONFIG_12_BITS 0x7F
#define DALLAS_DELAY_MS_9_BITS 94
#define DALLAS_DELAY_MS_10_BITS 188
#define DALLAS_DELAY_MS_11_BITS 375
#define DALLAS_DELAY_MS_12_BITS 750
#define DALLAS_DELAY_MS_MAX DALLAS_DELAY_MS_12_BITS
/** @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; ///< Êîíòðîëüíàÿ ñóììà
}DALLAS_ScratchpadTypeDef;
/** @brief Ñòðóêòóðà ôëàãîâ îøèáîê äàò÷èêîâ DALLAS */
typedef struct
{
unsigned disconnect_cnt; ///< Ñ÷åò÷èê îòêëþ÷åíèé äàò÷èêà
unsigned read_temperature_err_cnt; ///< Ñ÷åò÷èê îøèáîê ÷òåíèÿ òåìïåðàòóðû
unsigned timeout_convertion_cnt; ///< Ñ÷åò÷èê îøèáîê òàéìàóòà êîíâåðòàöèè
unsigned other_err_cnt; ///< Ñ÷åò÷èê äðóãèõ îøèáîê
}DALLAS_FlagsTypeDef;
/** @brief Ñòðóêòóðà èíèöèàëèçàöèè äàò÷èêà DALLAS */
typedef struct
{
uint64_t ROM; ///< Óíèêàëüíûé ROM-êîä äàò÷èêà
uint16_t UserBytes12; ///< Ïîëüçîâàòåëüñêèå áàéòû 1 è 2
uint16_t UserBytes34; ///< Ïîëüçîâàòåëüñêèå áàéòû 3 è 4
uint8_t SensInd; ///< Èíäåêñ ñåíñîðà
uint8_t Resolution; ///< Ðàçðåøåíèå äàò÷èêà
HAL_StatusTypeDef (*init_func)(); ///< Ôóíêöèÿ èíèöèàëèçàöèè
} DALLAS_InitStructTypeDef;
/** @brief Îñíîâíàÿ ñòðóêòóðà îáðàáîò÷èêà äàò÷èêà DALLAS */
typedef struct
{
unsigned isConnected:1; ///< Ôëàã ñîåäèíåíèÿ
unsigned isInitialized:1; ///< Ôëàã èíèöèàëèçàöèè
unsigned isLost:1; ///< Ôëàã ïîòåðè ñâÿçè
OneWire_t *onewire; ///< Èíòåðôåéñ OneWire
uint64_t sensROM; ///< ROM-êîä äàò÷èêà
DALLAS_ScratchpadTypeDef scratchpad; ///< Scratchpad äàò÷èêà
float temperature; ///< Òåêóùàÿ òåìïåðàòóðà
DALLAS_InitStructTypeDef Init; ///< Ñòðóêòóðà èíèöèàëèçàöèè
DALLAS_FlagsTypeDef f; ///< Ôëàãè
} DALLAS_HandleTypeDef;
/** @brief Âàðèàíòû îæèäàíèÿ îêîí÷àíèÿ êîíâåðñèè */
typedef enum
{
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);
#endif // #ifndef DALLAS_TOOLS_H

304
Core/Dallas/pch_sensors.c
View File

@@ -1,304 +0,0 @@
/**
******************************************************************************
* @file pch_sensors.c
* @brief Ðàáîòà ñ äàò÷èêàìè òåìïåðàòóðû DS18B20 â Ï×
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "pch_sensors.h"
PCHSens_UnknownSensorsTypeDef UnknownSensors;
/* Declarations and definitions --------------------------------------------*/
PCHSens_ModuleTypeDef module1;
/* Functions ---------------------------------------------------------------*/
HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM)
{
DALLAS_HandleTypeDef tempsens;
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
sensor->sens.Init.ROM = ROM;
sensor->sens.Init.UserBytes12 = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByROM;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
if(result != HAL_OK)
{
sensor->not_found = 1;
return result;
}
result = Dallas_WriteUserBytes(&sensor->sens, sensor->Location.all, sensor->Location.all, USED_USER_BYTES);
if(result != HAL_OK)
return result;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
if(result == HAL_OK)
{
sensor->not_found = 0;
}
else
{
sensor->not_found = 1;
}
return result;
}
HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
// sensor->UserBytes = (PCHSens_LocationTypeDef *)&sensor->sens.scratchpad.tHighRegister;
sensor->sens.Init.UserBytes12 = sensor->Location.all;
sensor->sens.Init.init_func = &Dallas_SensorInitByUserBytes;
result = Dallas_AddNewSensors(onewire, &sensor->sens);
if(result == HAL_OK)
{
sensor->not_found = 0;
}
else
{
sensor->not_found = 1;
}
return result;
}
HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param)
{
if(onewire == NULL)
return HAL_ERROR;
if(module == NULL)
return HAL_ERROR;
PCHSens_LocationTypeDef initlocation;
initlocation.all = param;
module->onewire = onewire;
module->refLocation = initlocation;
module->sens1.Location.all = module->refLocation.all;
module->sens1.Location.param.Location = 0;
module->sens1.action.read = 1;
PCHSens_AddSensor(onewire, &module->sens1);
module->sens2.Location.all = module->refLocation.all;
module->sens2.Location.param.Location = 1;
module->sens2.action.read = 1;
PCHSens_AddSensor(onewire, &module->sens2);
module->sens3.Location.all = module->refLocation.all;
module->sens3.Location.param.Location = 2;
module->sens3.action.read = 1;
PCHSens_AddSensor(onewire, &module->sens3);
module->sens4.Location.all = module->refLocation.all;
module->sens4.Location.param.Location = 3;
module->sens4.action.read = 1;
PCHSens_AddSensor(onewire, &module->sens4);
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module)
{
HAL_StatusTypeDef result;
if(module == NULL)
return HAL_ERROR;
result = Dallas_StartConvertTAll(module->onewire, DALLAS_WAIT_BUS, 0);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens1);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens2);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens3);
result = PCHSens_SensorHandleActions(module->onewire, &module->sens4);
PCHSens_DefineUnknownSensor(&UnknownSensors, NULL);
return result;
}
HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor)
{
HAL_StatusTypeDef result;
PCHSens_LocationTypeDef initlocation;
unsigned unknow_sensors_flag = 0;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->sens.isInitialized == 0)
return HAL_ERROR;
if((sensor->sens.isLost == 1))
{
initlocation.param.Location = 0;
if(Dallas_ReplaceLostedSensor(&sensor->sens) != HAL_OK)
{
sensor->not_found = 1;
}
else
{
sensor->not_found = 0;
}
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns)
{
HAL_StatusTypeDef result;
if(onewire == NULL)
return HAL_ERROR;
if(unknowns == NULL)
return HAL_ERROR;
unknowns->onewire = onewire;
unknowns->UnknownCnt = 0;
DALLAS_ScratchpadTypeDef scratchpad;
PCHSens_LocationTypeDef *param = (PCHSens_LocationTypeDef *)&scratchpad.tHighRegister;
for(int i = 0; i < onewire->RomCnt; i++)
{
/* Ïðîâåðêà ïðèñóòñòâóåò ëè âûáðàííûé äàò÷èê íà ëèíèè */
result = DS18B20_ReadScratchpad(onewire, (uint8_t *)&DS.DevAddr[i], (uint8_t *)&scratchpad);
if(result != HAL_OK)
__NOP();
if((IS_REG_SENS_LOCATION(param) == 0) ||
(IS_REG_PCH_LOCATION(param) == 0) ||
(IS_REG_PCH_NUMB(param) == 0) )
{
unknowns->unknown_sensors[unknowns->UnknownCnt].Init.SensInd = i;
unknowns->unknown_sensors[unknowns->UnknownCnt].Init.init_func = &Dallas_SensorInitByInd;
result = Dallas_AddNewSensors(onewire, &unknowns->unknown_sensors[unknowns->UnknownCnt++]);
if(result != HAL_OK)
__NOP();
}
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if((unknowns->ROMtoDefine != NULL) && (unknowns->LocationtoDefine.all != NULL) && (unknowns->senstoDefine != NULL))
{
result = PCHSens_InitNewSensor(unknowns->onewire, unknowns->senstoDefine, unknowns->ROMtoDefine);
unknowns->ROMtoDefine = 0;
unknowns->LocationtoDefine.all = 0;
unknowns->senstoDefine = 0;
return result;
}
return HAL_OK;
}
HAL_StatusTypeDef PCHSens_UndefineSensor(PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
result = Dallas_WriteUserBytes(&sensor->sens, 0, 0, USED_USER_BYTES);
if(result != HAL_OK)
{
return result;
}
result = Dallas_SensorDeInit(&sensor->sens);
return result;
}
HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->action.connectROM != NULL)
{
result = PCHSens_InitNewSensor(onewire, sensor, sensor->action.connectROM);
sensor->action.connectROM = 0;
}
if(sensor->action.read != NULL)
{
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);
}

173
Core/Dallas/pch_sensors.h
View File

@@ -1,173 +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_13 ((1 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_21 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (1 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_22 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (2 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_NUMB_23 ((2 << REG_PCH_NUMB_DIGIT_1_Pos) | (3 << REG_PCH_NUMB_DIGIT_2_Pos))
#define REG_PCH_DIODE_NUMB_1 ((0 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_DIODE_NUMB_2 ((0 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_DIODE_NUMB_3 ((0 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_1 ((1 << REG_PCH_DIOD_PHASE_Pos) | (1 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_2 ((1 << REG_PCH_DIOD_PHASE_Pos) | (2 << REG_PCH_MODULE_NUMB_Pos))
#define REG_PCH_PHASE_NUMB_3 ((1 << REG_PCH_DIOD_PHASE_Pos) | (3 << REG_PCH_MODULE_NUMB_Pos))
/* Ïîëó÷èòü ïàðàìåòð èç UserBytes */
#define GET_REG_SENS_LOCATION(_REG_) ((_REG_) & REG_SENS_LOCATION_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
#define GET_REG_PCH_LOCATION(_REG_) ((_REG_) & REG_PCH_LOCATION_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ðàñïîëîæåíèå â Ï×" */
#define GET_REG_PCH_DIOD_PHASE(_REG_) ((_REG_) & REG_PCH_DIOD_PHASE_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Äèîäíûé èëè ôàçíûé ìîäóëü" */
#define GET_REG_PCH_MODULE_NUMB(_REG_) ((_REG_) & REG_PCH_MODULE_NUMB_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
#define GET_REG_PCH_NUMB(_REG_) ((_REG_) & REG_PCH_NUMB_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
#define GET_REG_PCH_NUMB_DIGIT_1(_REG_) ((_REG_) & REG_PCH_NUMB_DIGIT_1_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
#define GET_REG_PCH_NUMB_DIGIT_2(_REG_) ((_REG_) & REG_PCH_NUMB_DIGIT_2_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
#define GET_REG_ZIP(_REG_) ((_REG_) & REG_ZIP_Mask) /*!< @brief Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
/* Äèàïàçîíû ïàðàìåòðîâ èç UserBytes */
#define REG_SENS_LOCATION_MAX 3
#define REG_SENS_LOCATION_MIN 0
#define REG_PCH_DIOD_PHASE_MAX 1
#define REG_PCH_DIOD_PHASE_MIN 0
#define REG_PCH_MODULE_NUMB_MAX 3
#define REG_PCH_MODULE_NUMB_MIN 0
#define REG_PCH_NUMB_DIGIT_1_MAX 3
#define REG_PCH_NUMB_DIGIT_1_MIN 1
#define REG_PCH_NUMB_DIGIT_2_MAX 2
#define REG_PCH_NUMB_DIGIT_2_MIN 1
/** @brief Ïîëó÷èòü ïàðàìåòð "Ëîêàöèÿ âíóòðè ìîäóëÿ" */
#define IS_REG_SENS_LOCATION(_REG_) (((_REG_)->param.Location <= REG_SENS_LOCATION_MAX) && ((_REG_)->param.Location >= REG_SENS_LOCATION_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ðàñïîëîæåíèå â Ï×" */
#define IS_REG_PCH_LOCATION(_REG_) (IS_REG_PCH_DIOD_PHASE(_REG_) && IS_REG_PCH_MODULE_NUMB(_REG_))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Äèîäíûé èëè ôàçíûé ìîäóëü" */
#define IS_REG_PCH_DIOD_PHASE(_REG_) (((_REG_)->param.DiodeOrPhase <= REG_PCH_DIOD_PHASE_MAX) && ((_REG_)->param.DiodeOrPhase >= REG_PCH_DIOD_PHASE_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïîðÿäêîâûé íîìåð äèîäíîãî/ôàçíîãî ìîäóëÿ" */
#define IS_REG_PCH_MODULE_NUMB(_REG_) (((_REG_)->param.ModuleNumb <= REG_PCH_MODULE_NUMB_MAX) && ((_REG_)->param.ModuleNumb >= REG_PCH_MODULE_NUMB_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïðåîáðàçîâàòåëü ÷àñòîòû" */
#define IS_REG_PCH_NUMB(_REG_) (IS_REG_PCH_NUMB_DIGIT_1(_REG_) && IS_REG_PCH_NUMB_DIGIT_2(_REG_))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Ïåðâàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" */
#define IS_REG_PCH_NUMB_DIGIT_1(_REG_) (((_REG_)->param.PCHdig1 <= REG_PCH_NUMB_DIGIT_1_MAX) && ((_REG_)->param.PCHdig1 >= REG_PCH_NUMB_DIGIT_1_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "Âòîðàÿ öèôðà íîìåðà ïðåîáðàçîâàòåëÿ ÷àñòîòû" s*/
#define IS_REG_PCH_NUMB_DIGIT_2(_REG_) (((_REG_)->param.PCHdig2 <= REG_PCH_NUMB_DIGIT_2_MAX) && ((_REG_)->param.PCHdig2 >= REG_PCH_NUMB_DIGIT_2_MIN))
/*!< @brief Ïîëó÷èòü ïàðàìåòð "ÇÈÏ/íå ÇÈÏ" */
#define IS_REG_ZIP(_REG_) (GET_REG_ZIP(_REG_))
typedef union
{
uint16_t all;
struct
{
unsigned Location:2;
unsigned reserved:6;
unsigned ModuleNumb:2;
unsigned DiodeOrPhase:1;
unsigned PCHdig2:2;
unsigned PCHdig1:2;
unsigned ZIP:1;
}param;
}PCHSens_LocationTypeDef;
typedef struct
{
uint64_t connectROM;
unsigned read;
unsigned deinit;
}PCHSens_SensorActionsTypeDef;
typedef struct
{
DALLAS_HandleTypeDef sens;
// PCHSens_LocationTypeDef *UserBytes;
PCHSens_LocationTypeDef Location;
PCHSens_SensorActionsTypeDef action;
unsigned not_found:1;
}PCHSens_SensorTypeDef;
typedef struct
{
OneWire_t *onewire;
PCHSens_SensorTypeDef sens1;
PCHSens_SensorTypeDef sens2;
PCHSens_SensorTypeDef sens3;
PCHSens_SensorTypeDef sens4;
PCHSens_LocationTypeDef refLocation;
}PCHSens_ModuleTypeDef;
extern PCHSens_ModuleTypeDef module1;
typedef struct
{
OneWire_t *onewire;
DALLAS_HandleTypeDef unknown_sensors[DS18B20_DEVICE_AMOUNT];
uint8_t UnknownCnt;
uint64_t ROMtoDefine;
PCHSens_LocationTypeDef LocationtoDefine;
PCHSens_SensorTypeDef *senstoDefine;
}PCHSens_UnknownSensorsTypeDef;
/* Functions ---------------------------------------------------------------*/
HAL_StatusTypeDef PCHSens_FindUnknownSensors(OneWire_t *onewire, PCHSens_UnknownSensorsTypeDef *unknowns);
HAL_StatusTypeDef PCHSens_InitNewSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor, uint64_t ROM);
HAL_StatusTypeDef PCHSens_AddSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_InitModule(OneWire_t *onewire, PCHSens_ModuleTypeDef* module, uint16_t param);
HAL_StatusTypeDef PCHSens_ReadTemperature(PCHSens_ModuleTypeDef *module);
HAL_StatusTypeDef PCHSens_CheckSensor(OneWire_t *onewire, PCHSens_SensorTypeDef* sensor);
HAL_StatusTypeDef PCHSens_DefineUnknownSensor(PCHSens_UnknownSensorsTypeDef *unknowns, PCHSens_SensorTypeDef *sensor);
HAL_StatusTypeDef PCHSens_SensorHandleActions(OneWire_t *onewire, PCHSens_SensorTypeDef *sensor);
void PCHSens_FirstInit(void);
#endif // #ifndef PCH_SENSORS_H

116
Core/Modbus/crc_algs.c
View File

@@ -1,116 +0,0 @@
#include "crc_algs.h"
uint32_t CRC_calc;
uint32_t CRC_ref;
//uint16_t CRC_calc;
//uint16_t CRC_ref;
// left this global for debug
uint8_t uchCRCHi = 0xFF;
uint8_t uchCRCLo = 0xFF;
unsigned uIndex;
uint32_t crc32(uint8_t *data, uint32_t data_size)
{
static const unsigned int crc32_table[] =
{
0x00000000, 0x77073096, 0xEE0E612C, 0x990951BA, 0x076DC419, 0x706AF48F, 0xE963A535, 0x9E6495A3,
0x0EDB8832, 0x79DCB8A4, 0xE0D5E91E, 0x97D2D988, 0x09B64C2B, 0x7EB17CBD, 0xE7B82D07, 0x90BF1D91,
0x1DB71064, 0x6AB020F2, 0xF3B97148, 0x84BE41DE, 0x1ADAD47D, 0x6DDDE4EB, 0xF4D4B551, 0x83D385C7,
0x136C9856, 0x646BA8C0, 0xFD62F97A, 0x8A65C9EC, 0x14015C4F, 0x63066CD9, 0xFA0F3D63, 0x8D080DF5,
0x3B6E20C8, 0x4C69105E, 0xD56041E4, 0xA2677172, 0x3C03E4D1, 0x4B04D447, 0xD20D85FD, 0xA50AB56B,
0x35B5A8FA, 0x42B2986C, 0xDBBBC9D6, 0xACBCF940, 0x32D86CE3, 0x45DF5C75, 0xDCD60DCF, 0xABD13D59,
0x26D930AC, 0x51DE003A, 0xC8D75180, 0xBFD06116, 0x21B4F4B5, 0x56B3C423, 0xCFBA9599, 0xB8BDA50F,
0x2802B89E, 0x5F058808, 0xC60CD9B2, 0xB10BE924, 0x2F6F7C87, 0x58684C11, 0xC1611DAB, 0xB6662D3D,
0x76DC4190, 0x01DB7106, 0x98D220BC, 0xEFD5102A, 0x71B18589, 0x06B6B51F, 0x9FBFE4A5, 0xE8B8D433,
0x7807C9A2, 0x0F00F934, 0x9609A88E, 0xE10E9818, 0x7F6A0DBB, 0x086D3D2D, 0x91646C97, 0xE6635C01,
0x6B6B51F4, 0x1C6C6162, 0x856530D8, 0xF262004E, 0x6C0695ED, 0x1B01A57B, 0x8208F4C1, 0xF50FC457,
0x65B0D9C6, 0x12B7E950, 0x8BBEB8EA, 0xFCB9887C, 0x62DD1DDF, 0x15DA2D49, 0x8CD37CF3, 0xFBD44C65,
0x4DB26158, 0x3AB551CE, 0xA3BC0074, 0xD4BB30E2, 0x4ADFA541, 0x3DD895D7, 0xA4D1C46D, 0xD3D6F4FB,
0x4369E96A, 0x346ED9FC, 0xAD678846, 0xDA60B8D0, 0x44042D73, 0x33031DE5, 0xAA0A4C5F, 0xDD0D7CC9,
0x5005713C, 0x270241AA, 0xBE0B1010, 0xC90C2086, 0x5768B525, 0x206F85B3, 0xB966D409, 0xCE61E49F,
0x5EDEF90E, 0x29D9C998, 0xB0D09822, 0xC7D7A8B4, 0x59B33D17, 0x2EB40D81, 0xB7BD5C3B, 0xC0BA6CAD,
0xEDB88320, 0x9ABFB3B6, 0x03B6E20C, 0x74B1D29A, 0xEAD54739, 0x9DD277AF, 0x04DB2615, 0x73DC1683,
0xE3630B12, 0x94643B84, 0x0D6D6A3E, 0x7A6A5AA8, 0xE40ECF0B, 0x9309FF9D, 0x0A00AE27, 0x7D079EB1,
0xF00F9344, 0x8708A3D2, 0x1E01F268, 0x6906C2FE, 0xF762575D, 0x806567CB, 0x196C3671, 0x6E6B06E7,
0xFED41B76, 0x89D32BE0, 0x10DA7A5A, 0x67DD4ACC, 0xF9B9DF6F, 0x8EBEEFF9, 0x17B7BE43, 0x60B08ED5,
0xD6D6A3E8, 0xA1D1937E, 0x38D8C2C4, 0x4FDFF252, 0xD1BB67F1, 0xA6BC5767, 0x3FB506DD, 0x48B2364B,
0xD80D2BDA, 0xAF0A1B4C, 0x36034AF6, 0x41047A60, 0xDF60EFC3, 0xA867DF55, 0x316E8EEF, 0x4669BE79,
0xCB61B38C, 0xBC66831A, 0x256FD2A0, 0x5268E236, 0xCC0C7795, 0xBB0B4703, 0x220216B9, 0x5505262F,
0xC5BA3BBE, 0xB2BD0B28, 0x2BB45A92, 0x5CB36A04, 0xC2D7FFA7, 0xB5D0CF31, 0x2CD99E8B, 0x5BDEAE1D,
0x9B64C2B0, 0xEC63F226, 0x756AA39C, 0x026D930A, 0x9C0906A9, 0xEB0E363F, 0x72076785, 0x05005713,
0x95BF4A82, 0xE2B87A14, 0x7BB12BAE, 0x0CB61B38, 0x92D28E9B, 0xE5D5BE0D, 0x7CDCEFB7, 0x0BDBDF21,
0x86D3D2D4, 0xF1D4E242, 0x68DDB3F8, 0x1FDA836E, 0x81BE16CD, 0xF6B9265B, 0x6FB077E1, 0x18B74777,
0x88085AE6, 0xFF0F6A70, 0x66063BCA, 0x11010B5C, 0x8F659EFF, 0xF862AE69, 0x616BFFD3, 0x166CCF45,
0xA00AE278, 0xD70DD2EE, 0x4E048354, 0x3903B3C2, 0xA7672661, 0xD06016F7, 0x4969474D, 0x3E6E77DB,
0xAED16A4A, 0xD9D65ADC, 0x40DF0B66, 0x37D83BF0, 0xA9BCAE53, 0xDEBB9EC5, 0x47B2CF7F, 0x30B5FFE9,
0xBDBDF21C, 0xCABAC28A, 0x53B39330, 0x24B4A3A6, 0xBAD03605, 0xCDD70693, 0x54DE5729, 0x23D967BF,
0xB3667A2E, 0xC4614AB8, 0x5D681B02, 0x2A6F2B94, 0xB40BBE37, 0xC30C8EA1, 0x5A05DF1B, 0x2D02EF8D
};
unsigned int crc = 0xFFFFFFFF;
while (data_size--)
{
crc = (crc >> 8) ^ crc32_table[(crc ^ *data) & 255];
data++;
}
return crc^0xFFFFFFFF;
}
uint16_t crc16(uint8_t *data, uint32_t data_size)
{
/*Table of CRC values for high order byte*/
static unsigned char auchCRCHi[]=
{
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
};
/*Table of CRC values for low order byte*/
static char auchCRCLo[] =
{
0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,0x04,
0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,0x08,0xC8,
0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,
0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,0x11,0xD1,0xD0,0x10,
0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,0x3B,0xFB,0x39,0xF9,0xF8,0x38,
0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,
0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,
0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,0xA4,
0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,
0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,0x70,0xB0,
0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,0x99,0x59,0x58,0x98,
0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40,
};
uchCRCHi = 0xFF;
uchCRCLo = 0xFF;
/* CRC Generation Function */
while( data_size--) /* pass through message buffer */
{
uIndex = uchCRCHi ^ *data++; /* calculate the CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
uchCRCLo = auchCRCLo[uIndex];
}
return uchCRCHi | uchCRCLo<<8;
}

249
Core/MyLibs/bit_access.h
View File

@@ -1,249 +0,0 @@
/**
**************************************************************************
* @file mylibs_defs.h
* @brief Заголочный файл для дефайнов библиотеки MyLibsGeneral.
**************************************************************************
* @defgroup BIT_ACCESS_DEFINES Bit access defines
* @ingroup MYLIBS_DEFINES
* @brief Всякое для доступа к битам в unsigned
*************************************************************************/
#ifndef __BIT_ACCESS_H_
#define __BIT_ACCESS_H_
#include "mylibs_defs.h"
/**
* @addtogroup BIT_ACCESS_TYPEDEF Byte access typedefs
* @ingroup BIT_ACCESS_DEFINES
* @brief Дефайны юнионов для обращения к битам.
@{
*/
typedef union
{
uint8_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned reserved:4;
}bit;
}uint4_BitTypeDef;
typedef union
{
uint8_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned reserved:3;
}bit;
}uint5_BitTypeDef;
typedef union
{
uint8_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned reserved:2;
}bit;
}uint6_BitTypeDef;
typedef union
{
uint8_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned reserved:1;
}bit;
}uint7_BitTypeDef;
typedef union
{
uint8_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
}bit;
}uint8_BitTypeDef;
typedef union
{
uint16_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
unsigned bit8:1;
unsigned bit9:1;
unsigned bit10:1;
unsigned bit11:1;
unsigned bit12:1;
unsigned bit13:1;
unsigned bit14:1;
unsigned bit15:1;
}bit;
}uint16_BitTypeDef;
typedef union
{
uint32_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
unsigned bit8:1;
unsigned bit9:1;
unsigned bit10:1;
unsigned bit11:1;
unsigned bit12:1;
unsigned bit13:1;
unsigned bit14:1;
unsigned bit15:1;
unsigned bit16:1;
unsigned bit17:1;
unsigned bit18:1;
unsigned bit19:1;
unsigned bit20:1;
unsigned bit21:1;
unsigned bit22:1;
unsigned bit23:1;
unsigned bit24:1;
unsigned bit25:1;
unsigned bit26:1;
unsigned bit27:1;
unsigned bit28:1;
unsigned bit29:1;
unsigned bit30:1;
unsigned bit31:1;
}bit;
}uint32_BitTypeDef;
typedef union
{
uint64_t all;
struct
{
unsigned bit0:1;
unsigned bit1:1;
unsigned bit2:1;
unsigned bit3:1;
unsigned bit4:1;
unsigned bit5:1;
unsigned bit6:1;
unsigned bit7:1;
unsigned bit8:1;
unsigned bit9:1;
unsigned bit10:1;
unsigned bit11:1;
unsigned bit12:1;
unsigned bit13:1;
unsigned bit14:1;
unsigned bit15:1;
unsigned bit16:1;
unsigned bit17:1;
unsigned bit18:1;
unsigned bit19:1;
unsigned bit20:1;
unsigned bit21:1;
unsigned bit22:1;
unsigned bit23:1;
unsigned bit24:1;
unsigned bit25:1;
unsigned bit26:1;
unsigned bit27:1;
unsigned bit28:1;
unsigned bit29:1;
unsigned bit30:1;
unsigned bit31:1;
unsigned bit32:1;
unsigned bit33:1;
unsigned bit34:1;
unsigned bit35:1;
unsigned bit36:1;
unsigned bit37:1;
unsigned bit38:1;
unsigned bit39:1;
unsigned bit40:1;
unsigned bit41:1;
unsigned bit42:1;
unsigned bit43:1;
unsigned bit44:1;
unsigned bit45:1;
unsigned bit46:1;
unsigned bit47:1;
unsigned bit48:1;
unsigned bit49:1;
unsigned bit50:1;
unsigned bit51:1;
unsigned bit52:1;
unsigned bit53:1;
unsigned bit54:1;
unsigned bit55:1;
unsigned bit56:1;
unsigned bit57:1;
unsigned bit58:1;
unsigned bit59:1;
unsigned bit60:1;
unsigned bit61:1;
unsigned bit62:1;
unsigned bit63:1;
}bit;
}uint64_BitTypeDef;
/** BIT_ACCESS_TYPEDEF
* @}
*/
/**
* @addtogroup BIT_ACCESS_FUNCTIONS Byte access functions
* @ingroup BIT_ACCESS_DEFINES
* @brief Дефайны для обращения к битам в unsigned.
@{
*/
#define uint8_bit(_uint8_, _bit_) (*(uint8_BitTypeDef *)(&(_uint8_))).bit.bit##_bit_
#define uint16_bit(_uint8_, _bit_) (*(uint16_BitTypeDef *)(&(_uint8_))).bit.bit##_bit_
#define uint32_bit(_uint8_, _bit_) (*(uint32_BitTypeDef *)(&(_uint8_))).bit.bit##_bit_
#define uint64_bit(_uint8_, _bit_) (*(uint64_BitTypeDef *)(&(_uint8_))).bit.bit##_bit_
/** BIT_ACCESS_FUNCTIONS
* @}
*/
#endif //__BIT_ACCESS_H_

128
Core/MyLibs/general_gpio.c
View File

@@ -1,128 +0,0 @@
/**
**************************************************************************
* @file general_gpio.c
* @brief Модуль для инициализации портов.
**************************************************************************
@verbatim
//-------------------Функции-------------------//
Functions: users
- GPIO_Clock_Enable Инициализация тактирования порта
@endverbatim
***************************************************************************/
#include "general_gpio.h"
//-------------------------------------------------------------------
//------------------------GPIO INIT FUNCTIONS------------------------
HAL_StatusTypeDef GPIO_Clock_Enable(GPIO_TypeDef *GPIOx)
{
HAL_StatusTypeDef status = HAL_OK;
// choose port for enable clock
if (GPIOx==GPIOA)
__HAL_RCC_GPIOA_CLK_ENABLE();
else if (GPIOx==GPIOB)
__HAL_RCC_GPIOB_CLK_ENABLE();
else if (GPIOx==GPIOC)
__HAL_RCC_GPIOC_CLK_ENABLE();
#ifdef GPIOD
else if (GPIOx==GPIOD)
__HAL_RCC_GPIOD_CLK_ENABLE();
#endif
#ifdef GPIOE
else if (GPIOx==GPIOE)
__HAL_RCC_GPIOE_CLK_ENABLE();
#endif
else
status = HAL_ERROR;
return status;
}
//------------------------GPIO INIT FUNCTIONS------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//------------------------GPIO LED FUNCTIONS-------------------------
/**
* @brief Включить светодиод
*/
void GPIO_LED_On(GPIO_LEDTypeDef *led)
{
led->state = LED_IS_ON;
HAL_GPIO_WritePin(led->LED_Port, led->LED_Pin, LED_ON);
}
/**
* @brief Выключить светодиод
*/
void GPIO_LED_Off(GPIO_LEDTypeDef *led)
{
led->state = LED_IS_OFF;
HAL_GPIO_WritePin(led->LED_Port, led->LED_Pin, LED_OFF);
}
/**
* @brief Активировать моргание светодиодом
*/
void GPIO_LED_Blink_Start(GPIO_LEDTypeDef *led, uint32_t period)
{
led->state = LED_IS_BLINKING;
led->LED_Period = period;
}
/**
* @brief Моргание светодиодом
*/
void GPIO_LED_Blink_Handle(GPIO_LEDTypeDef *led)
{
if(led->state == LED_IS_BLINKING)
{
uint32_t tickcurrent = HAL_GetTick();
if((tickcurrent - led->tickprev) > led->LED_Period)
{
HAL_GPIO_TogglePin(led->LED_Port, led->LED_Pin);
led->tickprev = tickcurrent;
}
}
}
//------------------------GPIO LED FUNCTIONS-------------------------
//-------------------------------------------------------------------
//-------------------------------------------------------------------
//------------------------GPIO SW FUNCTIONS-------------------------
/**
* @brief Считать состоянии кнопки запуска
*/
uint8_t GPIO_Read_Swich(GPIO_SwitchTypeDef *sw)
{
if(HAL_GPIO_ReadPin(sw->Sw_Port, sw->Sw_Pin) == SW_ON)
{
sw->Sw_PrevState = 1;
if(sw->tickprev == 0)
sw->tickprev = HAL_GetTick();
if((HAL_GetTick() - sw->tickprev) > sw->Sw_FilterDelay)
{
if(HAL_GPIO_ReadPin(sw->Sw_Port, sw->Sw_Pin) == SW_ON)
{
return 1;
}
else
{
sw->tickprev = 0;
return 0;
}
}
}
else
{
sw->Sw_PrevState = 0;
}
return 0;
}
//------------------------GPIO SW FUNCTIONS-------------------------
//-------------------------------------------------------------------

88
Core/MyLibs/general_gpio.h
View File

@@ -1,88 +0,0 @@
/**
**************************************************************************
* @file general_gpio.h
* @brief Заголовочный файл для модуля инициализации портов.
*************************************************************************/
#ifndef __GPIO_GENERAL_H_
#define __GPIO_GENERAL_H_
#include "mylibs_defs.h"
#define SPI_Alternate_Mapping(INSTANCE) ((((INSTANCE) == TIM1) || ((INSTANCE) == TIM2))? GPIO_AF1_TIM1: \
(((INSTANCE) == TIM3) || ((INSTANCE) == TIM4) || ((INSTANCE) == TIM5))? GPIO_AF2_TIM3: \
(((INSTANCE) == TIM8) || ((INSTANCE) == TIM9) || ((INSTANCE) == TIM10) || ((INSTANCE) == TIM11))? GPIO_AF3_TIM8: \
(((INSTANCE) == TIM12) || ((INSTANCE) == TIM13) || ((INSTANCE) == TIM14))? GPIO_AF9_TIM12: \
(0))
#define TIM_Alternate_Mapping(INSTANCE) ((((INSTANCE) == TIM1) || ((INSTANCE) == TIM2))? GPIO_AF1_TIM1: \
(((INSTANCE) == TIM3) || ((INSTANCE) == TIM4) || ((INSTANCE) == TIM5))? GPIO_AF2_TIM3: \
(((INSTANCE) == TIM8) || ((INSTANCE) == TIM9) || ((INSTANCE) == TIM10) || ((INSTANCE) == TIM11))? GPIO_AF3_TIM8: \
(((INSTANCE) == TIM12) || ((INSTANCE) == TIM13) || ((INSTANCE) == TIM14))? GPIO_AF9_TIM12: \
(0))
typedef enum
{
LED_IS_OFF = 0,
LED_IS_ON = 1,
LED_IS_BLINKING = 2,
LED_IS_FADING = 3,
}GPIO_LEDStateTypeDef;
typedef struct
{
GPIO_LEDStateTypeDef state;
GPIO_TypeDef *LED_Port;
uint32_t LED_Pin;
uint32_t LED_Period;
uint32_t tickprev;
}GPIO_LEDTypeDef;
typedef struct
{
GPIO_TypeDef *Sw_Port;
uint32_t Sw_Pin;
uint32_t Sw_PrevState;
uint32_t Sw_FilterDelay;
uint32_t tickprev;
}GPIO_SwitchTypeDef;
/////////////////////////////////////////////////////////////////////
///////////////////////////---FUNCTIONS---///////////////////////////
HAL_StatusTypeDef GPIO_Clock_Enable(GPIO_TypeDef *GPIOx);
/* Считать состоянии кнопки запуска */
uint8_t GPIO_Read_Swich(GPIO_SwitchTypeDef *swstart);
/* Включить светодиод */
void GPIO_LED_On(GPIO_LEDTypeDef *led);
/* Выключить светодиод */
void GPIO_LED_Off(GPIO_LEDTypeDef *led);
/* Активировать моргание светодиодом */
void GPIO_LED_Blink_Start(GPIO_LEDTypeDef *led, uint32_t period);
/* Моргание светодиодом */
void GPIO_LED_Blink_Handle(GPIO_LEDTypeDef *led);
///////////////////////////---FUNCTIONS---///////////////////////////
#ifndef LED_ON
#define LED_ON 0
#endif
#ifndef LED_0FF
#define LED_OFF 1
#endif
#ifndef SW_ON
#define SW_ON 0
#endif
#ifndef SW_0FF
#define SW_OFF 1
#endif
#endif // __GPIO_GENERAL_H_

35
Core/MyLibs/mylibs_config.h
View File

@@ -1,35 +0,0 @@
/**
**************************************************************************
* @file mylibs_config.h
* @brief Конфигурации для библиотек MyLibs
**************************************************************************
* @defgroup MYLIBS_CONFIG Configs My Libs
* @ingroup MYLIBS_ALL
* @brief Конфигурации для библиотек MyLibs
@{
*************************************************************************/
#ifndef __MYLIBS_CONFIG_H_
#define __MYLIBS_CONFIG_H_
#include "py32f0xx_hal.h"
// user includes
#include "interface_config.h"
#define RS_USER_VARS_NUMB 0
#define ADC_USER_VARS_NUMB 0
#define ADC_CH_USER_VARS_NUMB 0
#define INCLUDE_BIT_ACCESS_LIB
#define INCLUDE_TRACKERS_LIB
#define INCLUDE_TRACE_LIB
//#define INCLUDE_GENERAL_PERIPH_LIBS
//#define FREERTOS_DELAY
/** MYLIBS_CONFIG
* @}
*/
#endif //__MYLIBS_CONFIG_H_

105
Core/MyLibs/mylibs_defs.h
View File

@@ -1,105 +0,0 @@
/**
**************************************************************************
* @file mylibs_defs.h
* @brief Заголочный файл для дефайнов библиотеки MyLibsGeneral.
**************************************************************************
* @defgroup MYLIBS_DEFINES My Libs defines
* @brief Базовые дефайны для всего проекта
*
*************************************************************************/
#ifndef __MYLIBS_DEFINES_H_
#define __MYLIBS_DEFINES_H_
#include "mylibs_config.h"
/***************************************************************************
******************************ERROR_HANDLER********************************/
/**
* @addtogroup ERROR_HANDLER_DEFINES Error Handler defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для определения функции обработки ошибок
@{
*/
/* extern Error_Handler from main.h */
extern void Error_Handler(void);
/* Define error handler for MyLibs */
#define MyLibs_Error_Handler(_params_) Error_Handler(_params_)
/* If error handler not defined - set void */
#ifndef MyLibs_Error_Handler
#define ((void)0U)
#endif // MyLibs_Error_Handler
/** ERROR_HANDLER_DEFINES
* @}
*/
/***************************************************************************
********************************ACCESS_DEFINES*****************************/
#define ClearStruct(_struct_) memset(&(_struct_), 0, sizeof(_struct_))
/***************************************************************************
******************************DELAYS_DEFINES*******************************/
/**
* @addtogroup DELAYS_DEFINES Delays defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для реализации задержек
@{
*/
#ifdef FREERTOS_DELAY
#define msDelay(_ms_) osDelay(_ms_)
#else
#define msDelay(_ms_) if(_ms_ != 0) HAL_Delay(_ms_-1)
#endif
/** DELAYS_DEFINES
* @}
*/
/***************************************************************************
*******************************MATH_DEFINES********************************/
/**
* @addtogroup MATH_DEFINES Math defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для различных математических функций
@{
*/
/**
* @brief Calc dividing including remainder
* @param _val_ - делимое.
* @param _div_ - делитель.
* @details Если результат деления без остатка: он возвращается как есть
Если с остатком - округляется вверх
*/
//#define Divide_Up(_val_, _div_) (((_val_)%(_div_))? (_val_)/(_div_)+1 : (_val_)/_div_) /* через тернарный оператор */
#define Divide_Up(_val_, _div_) ((_val_ - 1) / _div_) + 1 /* через мат выражение */
/**
* @brief Swap between Little Endian and Big Endian
* @param v - Переменная для свапа.
* @return v (new) - Свапнутая переменная.
* @details Переключения между двумя типами хранения слова: HI-LO байты и LO-HI байты.
*/
#define ByteSwap16(v) (((v&0xFF00) >> (8)) | ((v&0x00FF) << (8)))
/**
* @brief Absolute
* @param x - Переменная для модудя.
* @return x (new) - Число по модулю.
* @details Берет число по модулю. Хз как работает библиотечный abs в stdlib.h, мб это быстрее, но вряд ли конечно.
*/
#define ABS(x) ( ((x) > 0)? (x) : -(x))?
/** MATH_DEFINES
* @}
*/
#endif //__MYLIBS_DEFINES_H_

80
Core/MyLibs/mylibs_include.h
View File

@@ -1,80 +0,0 @@
/**
**************************************************************************
* @file mylibs_include.h
* @brief Заголочный файл для всех библиотек
**************************************************************************
@details
Здесь нужно собрать библиотеки и дефайны, которые должны быть видны во всем проекте,
чтобы не подключать 100 инклюдов в каждом ".c" файле
**************************************************************************
* @defgroup MYLIBS_ALL My Libs
* @brief Все используемые MyLibs библиотеки
*
*************************************************************************/
#ifndef __MYLIBS_INCLUDE_H_
#define __MYLIBS_INCLUDE_H_
#include "mylibs_defs.h"
#ifdef ARM_MATH_CM4
#include "arm_math.h"
#endif
#ifdef INCLUDE_BIT_ACCESS_LIB
#include "bit_access.h"
#endif
#ifdef INCLUDE_TRACKERS_LIB
#include "trackers.h"
#endif
#ifdef INCLUDE_TRACE_LIB
#include "trace.h"
#endif
#ifdef INCLUDE_GENERAL_PERIPH_LIBS
#include "general_flash.h"
#include "general_gpio.h"
#ifdef HAL_SPI_MODULE_ENABLED
#include "general_spi.h"
#endif
#ifdef HAL_UART_MODULE_ENABLED
#include "general_uart.h"
#endif
#ifdef HAL_TIM_MODULE_ENABLED
#include "general_tim.h"
#endif
#endif //INCLUDE_GENERAL_PERIPH_LIBS
/////////////////////////---USER SETTINGS---/////////////////////////
// user includes
#include "stdlib.h"
#include "string.h"
#include "stdio.h"
#include "math.h"
#include "main.h"
#include "modbus_data.h"
#include "general_gpio.h"
/** @brief Struct for trackers for Measure */
/** @brief Struct for trackers for RS */
typedef TrackerTypeDef(RS_USER_VARS_NUMB) RS_TrackerTypeDef;
/** @brief Struct for trackers for ADC */
typedef TrackerTypeDef(ADC_USER_VARS_NUMB) ADC_TrackerTypeDef;
/** @brief Struct for trackers for ADC Channel */
typedef TrackerTypeDef(ADC_CH_USER_VARS_NUMB) ADCChannel_TrackerTypeDef;
/////////////////////////---USER SETTINGS---/////////////////////////
#endif // __MYLIBS_INCLUDE_H_

80
Core/MyLibs/trace.h
View File

@@ -1,80 +0,0 @@
/**
**************************************************************************
* @file trace.h
* @brief Заголочный файл для работы с трассировкой.
**************************************************************************
* @addtogroup TRACE Trace defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для работы с трассировкой
*************************************************************************/
#ifndef __TRACE_H_
#define __TRACE_H_
#include "mylibs_defs.h"
/**
* @addtogroup TRACE_SERIAL Serial trace defines
* @ingroup TRACE
* @brief Дефайны для работы с serial трассировкой
* @details Определяется дефайн my_printf() для работы с serial трассировкой:
- для RTT это будет вызов функции SEGGER_RTT_printf(), с подключением библиотеки SEGGER_RTT.h
- для SWO это будет просто printf(), но библиотеку STDOUT надо подключить самостоятельно:
@verbatim
Manage Run-Time Environment -> Compiler -> I/O -> STDOUT
@endverbatim
- Если трассировка отключена, то все дефайны определяются как 'ничего' и на производительность кода не влияют
@{
*/
/* Выбор какой serial trace использовать */
#ifdef SERIAL_TRACE_ENABLE
#if defined(RTT_TRACE_ENABLE)
#undef SWO_TRACE_ENABLE
#include "SEGGER_RTT.h"
#define my_printf(...) SEGGER_RTT_printf(0, __VA_ARGS__)
#elif defined(SWO_TRACE_ENABLE)
#undef RTT_TRACE_ENABLE
#define my_printf(...) printf(__VA_ARGS__)
#else // NO_TRACE
#define my_printf(...)
#warning No trace is selected. Serial debug wont work.
#endif // RTT_TRACE_ENABLE/SWO_TRACE_ENABLE/NO_TRACE
#else //SERIAL_TRACE_ENABLE
#define my_printf(...)
#undef RTT_TRACE_ENABLE
#undef SWO_TRACE_ENABLE
#endif //SERIAL_TRACE_ENABLE
/** TRACE_SERIAL
* @}
*/
/**
* @addtogroup TRACE_GPIO GPIO trace defines
* @ingroup TRACE
* @brief Дефайны для работы с GPIO трассировкой
* @details Определяется дефайны для работы с GPIO трассировкой:
- TRACE_GPIO_RESET() - для сброса ножки GPIO (через BSRR)
- TRACE_GPIO_SET() - для выставления ножки GPIO (через BSRR)
- Если трассировка отключена, то все дефайны определяются как 'ничего' и на производительность кода не влияют
@{
*/
#ifndef GPIO_TRACE_ENABLE
#define TRACE_GPIO_RESET(_gpio_,_pin_)
#define TRACE_GPIO_SET(_gpio_,_pin_)
#else
#define TRACE_GPIO_RESET(_gpio_,_pin_) (_gpio_)->BSRR = ((_pin_)<<16)
#define TRACE_GPIO_SET(_gpio_,_pin_) (_gpio_)->BSRR = (((_pin_)))
#endif //GPIO_TRACE_ENABLE
/** TRACE_GPIO
* @}
*/
#endif //__TRACE_H_

141
Core/MyLibs/trackers.h
View File

@@ -1,141 +0,0 @@
/**
**************************************************************************
* @file mylibs_defs.h
* @brief Заголочный файл для дефайнов библиотеки MyLibsGeneral.
**************************************************************************
* @defgroup MYLIBS_DEFINES My Libs defines
* @brief Базовые дефайны для всего проекта
*
*************************************************************************/
#ifndef __TRACKERS_H_
#define __TRACKERS_H_
#include "mylibs_defs.h"
/**
* @addtogroup TRACKERS Trackers defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для работы с трекерами
* @details Есть дефайн для объявления структуры трекера: TrackerTypeDef(num_user_vars).
Структура состоит из следующих элементов:
- cnt_ok
- cnt_err
- cnt_warn
- user[num_user_vars]
Также есть ряд функций (дефайнов) для обращения к элементам этой структуры.
Если трассировка отключена, то все дефайны определяются как ничего и на производительность кода не влияют
@par Пример:
Определяем typedef трекера измерений @ref Measure_TrackerTypeDef
@verbatim
typedef TrackerTypeDef(MEASURE_USER_VARS_NUMB) Measure_TrackerTypeDef;
@endverbatim
И через @ref Measure_TrackerTypeDef структура подключается в @ref TESTER_MeasureHandleTypeDef, а также
если необхожимо в другие структуру, например в структуру всех ошибок через указатель @ref TESTER_TrackerTypeDef
@{
*/
#ifdef TRACKERS_ENABLE
/**
* @brief Структура для счетчиков отладки
* @param num_user_vars - количество пользовательских счетчиков
* @details Содержит счетчик для успешных событый (cnt_ok),
* счетчик для ошибок (cnt_err), счетчик для предупреждений (cnt_warn).
*
* Также есть возможность объявить пользовательские счетчики в
* количестве <num_user_vars> штук.
*
* Для работы с структурой можно использовать функции:
* - TrackerCnt_Ok()
* - TrackerCnt_Err()
* - TrackerCnt_Warn()
* - TrackerCnt_User()
* - TrackerWrite_User()
* - TrackerClear_All()
* - TrackerClear_Ok()
* - TrackerClear_Err()
* - TrackerClear_Warn()
* - TrackerClear_User()
* - TrackerClear_UserAll()
*/
#define TrackerTypeDef(num_user_vars) \
struct \
{ \
uint32_t cnt_ok; \
uint32_t cnt_err; \
uint32_t cnt_warn; \
uint32_t user[num_user_vars]; \
}
/** @brief Получить количетство пользовательских переменных */
#define num_of_usercnts(_user_) (sizeof(_user_) / sizeof(_user_[0]))
/** @brief Проверка существует ли указанная пользовательская переменная */
#define assert_usertracker(_cntstruct_, _uservarnumb_) ((_uservarnumb_) < num_of_usercnts((_cntstruct_).user))
/** @brief Условие для проверки существует ли указанная пользовательская переменная */
#define if_assert_usertracker(_cntstruct_, _uservarnumb_) if(assert_usertracker(_cntstruct_, _uservarnumb_))
/** @brief Тернарный оператор для проверки существует ли указанная пользовательская переменная */
#define tern_assert_usertracker(_cntstruct_, _uservarnumb_) (assert_usertracker(_cntstruct_, _uservarnumb_)) ? _uservarnumb_ : 0
/**
* @brief Запись числа в пользовательскую переменную
* @note Здесь нет проверки - существует ли пользовательская переменная!
* Есть возможность выйти за границы структуры!!!
* Чтобы этого избежать используете дефайн #ref assert_usertracker()
*/
#define TrackerGet_User(_cntstruct_, _uservarnumb_) (_cntstruct_).user[tern_assert_usertracker(_cntstruct_, _uservarnumb_)]
/** @brief Инкрементирование счетчика успешных событий */
#define TrackerCnt_Ok(_cntstruct_) (_cntstruct_).cnt_ok++
/** @brief Инкрементирование счетчика ошибок */
#define TrackerCnt_Err(_cntstruct_) (_cntstruct_).cnt_err++
/** @brief Инкрементирование счетчика предупреждений */
#define TrackerCnt_Warn(_cntstruct_) (_cntstruct_).cnt_warn++
/** @brief Инкрементирование пользовательской переменной */
#define TrackerCnt_User(_cntstruct_, _uservarnumb_) if_assert_usertracker(_cntstruct_, _uservarnumb_) (_cntstruct_).user[_uservarnumb_]++;
/** @brief Запись числа в пользовательскую переменную */
#define TrackerWrite_User(_cntstruct_, _uservarnumb_, _val_) if_assert_usertracker(_cntstruct_, _uservarnumb_) (_cntstruct_).user[_uservarnumb_] = (_val_)
/** @brief Очистка всей структуры */
#define TrackerClear_All(_cntstruct_) memset(&(_cntstruct_), 0, sizeof(_cntstruct_))
/** @brief Очистка счетчика успешных событий */
#define TrackerClear_Ok(_cntstruct_) (_cntstruct_).cnt_ok = 0
/** @brief Очистка счетчика ошибок */
#define TrackerClear_Err(_cntstruct_) (_cntstruct_).cnt_err = 0
/** @brief Очистка счетчика предупреждений */
#define TrackerClear_Warn(_cntstruct_) (_cntstruct_).cnt_warn = 0
/** @brief Очистка пользовательской переменной */
#define TrackerClear_User(_cntstruct_, _uservarnumb_) if_assert_usertracker(_cntstruct_, _uservarnumb_) (_cntstruct_).user[_uservarnumb_] = 0;
/** @brief Очистка всех пользовательских переменных */
#define TrackerClear_UserAll(_cntstruct_) memset(&(_cntstruct_).user, 0, sizeof((_cntstruct_).user))
#else //TRACKERS_ENABLE
#define TrackerTypeDef(num_user_vars) void *
#define num_of_usercnts(_user_)
#define assert_tracecnt(_cntstruct_, _uservarnumb_)
#define TrackerCnt_Ok(_cntstruct_)
#define TrackerCnt_Err(_cntstruct_)
#define TrackerCnt_Warn(_cntstruct_)
#define TrackerCnt_User(_cntstruct_, _uservarnumb_)
#define TrackerWrite_User(_cntstruct_, _uservarnumb_, _val_)
/** @brief Очистка всей структуры */
#define TrackerClear_All(_cntstruct_)
#define TrackerClear_Ok(_cntstruct_)
#define TrackerClear_Err(_cntstruct_)
#define TrackerClear_Warn(_cntstruct_)
#define TrackerClear_User(_cntstruct_)
#define TrackerClear_UserAll(_cntstruct_)
#endif //TRACKERS_ENABLE
#endif //__TRACKERS_H_

137
Core/Src/main.c
View File

@@ -1,137 +0,0 @@
/**
******************************************************************************
* @file main.c
* @author MCU Application Team
* @brief Main program body
******************************************************************************
* @attention
*
* <h2><center>&copy; Copyright (c) Puya Semiconductor Co.
* All rights reserved.</center></h2>
*
* <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
* All rights reserved.</center></h2>
*
* This software component is licensed by ST under BSD 3-Clause license,
* the "License"; You may not use this file except in compliance with the
* License. You may obtain a copy of the License at:
* opensource.org/licenses/BSD-3-Clause
*
******************************************************************************
*/
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "gpio.h"
#include "tim.h"
#include "pch_sensors.h"
#include "rs_message.h"
/* Private define ------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/
/* Private user code ---------------------------------------------------------*/
/* Private macro -------------------------------------------------------------*/
/* Private function prototypes -----------------------------------------------*/
static void APP_SystemClockConfig(void);
/**
* @brief Application Entry Function.
* @retval int
*/
int main(void)
{
__HAL_DBGMCU_FREEZE_TIM1();
__HAL_DBGMCU_FREEZE_TIM14();
/* Reset of all peripherals, Initializes the Systick. */
HAL_Init();
/* System clock configuration */
APP_SystemClockConfig();
MX_GPIO_Init();
MX_TIM1_Init();
HAL_TIM_Base_Start(&htim1);
PCHSens_FirstInit();
/* infinite loop */
while (1)
{
GPIOA->ODR ^= GPIO_LED_2;
PCHSens_ReadTemperature(&module1);
}
}
/**
* @brief System clock configuration function
* @param None
* @retval None
*/
static void APP_SystemClockConfig(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct = {0};
RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
/* Oscillator configuration */
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE | RCC_OSCILLATORTYPE_HSI | RCC_OSCILLATORTYPE_LSI | RCC_OSCILLATORTYPE_LSE; /* Select oscillator HSE, HSI, LSI, LSE */
RCC_OscInitStruct.HSIState = RCC_HSI_ON; /* Enable HSI */
RCC_OscInitStruct.HSIDiv = RCC_HSI_DIV1; /* HSI 1 frequency division */
RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_24MHz; /* Configure HSI clock 24MHz */
RCC_OscInitStruct.HSEState = RCC_HSE_BYPASS_DISABLE; /* Close HSE bypass */
RCC_OscInitStruct.LSIState = RCC_LSI_OFF; /* Close LSI */
/*RCC_OscInitStruct.LSICalibrationValue = RCC_LSICALIBRATION_32768Hz;*/
RCC_OscInitStruct.LSEState = RCC_LSE_OFF; /* Close LSE */
/*RCC_OscInitStruct.LSEDriver = RCC_LSEDRIVE_MEDIUM;*/
/* Configure oscillator */
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
Error_Handler();
}
/* Clock source configuration */
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK | RCC_CLOCKTYPE_SYSCLK | RCC_CLOCKTYPE_PCLK1; /* Choose to configure clock HCLK, SYSCLK, PCLK1 */
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_HSISYS; /* Select HSISYS as the system clock */
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1; /* AHB clock 1 division */
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1; /* APB clock 1 division */
/* Configure clock source */
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_0) != HAL_OK)
{
Error_Handler();
}
}
/**
* @brief This function is executed in case of error occurrence.
* @retval None
*/
void Error_Handler(void)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
__disable_irq();
while (1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t *file, uint32_t line)
{
/* Users can add their own printing information as needed,
for example: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* Infinite loop */
while (1)
{
}
}
#endif /* USE_FULL_ASSERT */
/************************ (C) COPYRIGHT Puya *****END OF FILE******************/

177
Core/Src/tim.c
View File

@@ -1,177 +0,0 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file tim.c
* @brief This file provides code for the configuration
* of the TIM instances.
******************************************************************************
* @attention
*
* Copyright (c) 2025 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "tim.h"
/* USER CODE BEGIN 0 */
/* USER CODE END 0 */
TIM_HandleTypeDef htim1;
TIM_HandleTypeDef htim14;
/* TIM3 init function */
void MX_TIM1_Init(void)
{
/* USER CODE BEGIN TIM3_Init 0 */
/* USER CODE END TIM3_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
/* USER CODE BEGIN TIM3_Init 1 */
HAL_RCC_GetPCLK1Freq();
/* USER CODE END TIM3_Init 1 */
htim1.Instance = TIM1;
htim1.Init.Prescaler = 0;
htim1.Init.CounterMode = TIM_COUNTERMODE_UP;
htim1.Init.Period = 0xFFFFFFFF;
htim1.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim1.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim1) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim1, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim1, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM3_Init 2 */
/* USER CODE END TIM3_Init 2 */
}
/* TIM2 init function */
void MX_TIM2_Init(void)
{
/* USER CODE BEGIN TIM2_Init 0 */
/* USER CODE END TIM2_Init 0 */
TIM_ClockConfigTypeDef sClockSourceConfig = {0};
TIM_MasterConfigTypeDef sMasterConfig = {0};
/* USER CODE BEGIN TIM2_Init 1 */
/* USER CODE END TIM2_Init 1 */
htim14.Instance = TIM14;
htim14.Init.Prescaler = (HAL_RCC_GetPCLK1Freq()/1000000) - 1;
htim14.Init.CounterMode = TIM_COUNTERMODE_UP;
htim14.Init.Period = 50000;
htim14.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
htim14.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
if (HAL_TIM_Base_Init(&htim14) != HAL_OK)
{
Error_Handler();
}
sClockSourceConfig.ClockSource = TIM_CLOCKSOURCE_INTERNAL;
if (HAL_TIM_ConfigClockSource(&htim14, &sClockSourceConfig) != HAL_OK)
{
Error_Handler();
}
sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
if (HAL_TIMEx_MasterConfigSynchronization(&htim14, &sMasterConfig) != HAL_OK)
{
Error_Handler();
}
/* USER CODE BEGIN TIM2_Init 2 */
/* USER CODE END TIM2_Init 2 */
}
void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{
if(tim_baseHandle->Instance==TIM1)
{
/* USER CODE BEGIN TIM1_MspInit 0 */
/* USER CODE END TIM1_MspInit 0 */
/* TIM1 clock enable */
__HAL_RCC_TIM1_CLK_ENABLE();
/* USER CODE BEGIN TIM1_MspInit 1 */
/* USER CODE END TIM1_MspInit 1 */
}
else if(tim_baseHandle->Instance==TIM14)
{
/* USER CODE BEGIN TIM14_MspInit 0 */
/* USER CODE END TIM14_MspInit 0 */
/* TIM14 clock enable */
__HAL_RCC_TIM14_CLK_ENABLE();
/* TIM14 interrupt Init */
HAL_NVIC_SetPriority(TIM14_IRQn, 0, 0);
HAL_NVIC_EnableIRQ(TIM14_IRQn);
/* USER CODE BEGIN TIM14_MspInit 1 */
/* USER CODE END TIM14_MspInit 1 */
}
}
void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{
if(tim_baseHandle->Instance==TIM1)
{
/* USER CODE BEGIN TIM1_MspDeInit 0 */
/* USER CODE END TIM1_MspDeInit 0 */
/* Peripheral clock disable */
__HAL_RCC_TIM1_CLK_DISABLE();
/* TIM1 interrupt Deinit */
HAL_NVIC_DisableIRQ(TIM1_BRK_UP_TRG_COM_IRQn);
/* USER CODE BEGIN TIM1_MspDeInit 1 */
/* USER CODE END TIM1_MspDeInit 1 */
}
else if(tim_baseHandle->Instance==TIM14)
{
/* USER CODE BEGIN TIM14_MspDeInit 0 */
/* USER CODE END TIM14_MspDeInit 0 */
/* TIM14 clock disable */
__HAL_RCC_TIM14_CLK_DISABLE();
/* TIM14 interrupt Deinit */
HAL_NVIC_DisableIRQ(TIM14_IRQn);
/* USER CODE BEGIN TIM14_MspDeInit 1 */
/* USER CODE END TIM14_MspDeInit 1 */
}
}
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */

3986
MDK-ARM/Project.uvguix.I
View File

File diff suppressed because one or more lines are too long

660
MDK-ARM/Project.uvprojx
View File

@@ -1,660 +0,0 @@
<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
<Project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="project_projx.xsd">
<SchemaVersion>2.1</SchemaVersion>
<Header>### uVision Project, (C) Keil Software</Header>
<Targets>
<Target>
<TargetName>PY32F002Bx5_Project</TargetName>
<ToolsetNumber>0x4</ToolsetNumber>
<ToolsetName>ARM-ADS</ToolsetName>
<pArmCC>6190000::V6.19::ARMCLANG</pArmCC>
<pCCUsed>6190000::V6.19::ARMCLANG</pCCUsed>
<uAC6>1</uAC6>
<TargetOption>
<TargetCommonOption>
<Device>PY32F002Bx5</Device>
<Vendor>Puya</Vendor>
<PackID>Puya.PY32F0xx_DFP.1.2.2</PackID>
<PackURL>https://www.puyasemi.com/uploadfiles/</PackURL>
<Cpu>IRAM(0x20000000,0x00000C00) IROM(0x08000000,0x00006000) CPUTYPE("Cortex-M0+") CLOCK(12000000) ELITTLE</Cpu>
<FlashUtilSpec></FlashUtilSpec>
<StartupFile></StartupFile>
<FlashDriverDll>UL2CM3(-S0 -C0 -P0 -FD20000000 -FC800 -FN1 -FF0PY32F002Bxx_24 -FS08000000 -FL06000 -FP0($$Device:PY32F002Bx5$Flash\PY32F002Bxx_24.FLM))</FlashDriverDll>
<DeviceId>0</DeviceId>
<RegisterFile>$$Device:PY32F002Bx5$Device\Include\py32f0xx.h</RegisterFile>
<MemoryEnv></MemoryEnv>
<Cmp></Cmp>
<Asm></Asm>
<Linker></Linker>
<OHString></OHString>
<InfinionOptionDll></InfinionOptionDll>
<SLE66CMisc></SLE66CMisc>
<SLE66AMisc></SLE66AMisc>
<SLE66LinkerMisc></SLE66LinkerMisc>
<SFDFile>$$Device:PY32F002Bx5$SVD\py32f002bxx.svd</SFDFile>
<bCustSvd>0</bCustSvd>
<UseEnv>0</UseEnv>
<BinPath></BinPath>
<IncludePath></IncludePath>
<LibPath></LibPath>
<RegisterFilePath></RegisterFilePath>
<DBRegisterFilePath></DBRegisterFilePath>
<TargetStatus>
<Error>0</Error>
<ExitCodeStop>0</ExitCodeStop>
<ButtonStop>0</ButtonStop>
<NotGenerated>0</NotGenerated>
<InvalidFlash>1</InvalidFlash>
</TargetStatus>
<OutputDirectory>.\Output\</OutputDirectory>
<OutputName>Project</OutputName>
<CreateExecutable>1</CreateExecutable>
<CreateLib>0</CreateLib>
<CreateHexFile>1</CreateHexFile>
<DebugInformation>1</DebugInformation>
<BrowseInformation>1</BrowseInformation>
<ListingPath>.\Output\</ListingPath>
<HexFormatSelection>1</HexFormatSelection>
<Merge32K>0</Merge32K>
<CreateBatchFile>0</CreateBatchFile>
<BeforeCompile>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopU1X>0</nStopU1X>
<nStopU2X>0</nStopU2X>
</BeforeCompile>
<BeforeMake>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopB1X>0</nStopB1X>
<nStopB2X>0</nStopB2X>
</BeforeMake>
<AfterMake>
<RunUserProg1>0</RunUserProg1>
<RunUserProg2>0</RunUserProg2>
<UserProg1Name></UserProg1Name>
<UserProg2Name></UserProg2Name>
<UserProg1Dos16Mode>0</UserProg1Dos16Mode>
<UserProg2Dos16Mode>0</UserProg2Dos16Mode>
<nStopA1X>0</nStopA1X>
<nStopA2X>0</nStopA2X>
</AfterMake>
<SelectedForBatchBuild>0</SelectedForBatchBuild>
<SVCSIdString></SVCSIdString>
</TargetCommonOption>
<CommonProperty>
<UseCPPCompiler>0</UseCPPCompiler>
<RVCTCodeConst>0</RVCTCodeConst>
<RVCTZI>0</RVCTZI>
<RVCTOtherData>0</RVCTOtherData>
<ModuleSelection>0</ModuleSelection>
<IncludeInBuild>1</IncludeInBuild>
<AlwaysBuild>0</AlwaysBuild>
<GenerateAssemblyFile>0</GenerateAssemblyFile>
<AssembleAssemblyFile>0</AssembleAssemblyFile>
<PublicsOnly>0</PublicsOnly>
<StopOnExitCode>3</StopOnExitCode>
<CustomArgument></CustomArgument>
<IncludeLibraryModules></IncludeLibraryModules>
<ComprImg>1</ComprImg>
</CommonProperty>
<DllOption>
<SimDllName>SARMCM3.DLL</SimDllName>
<SimDllArguments> -REMAP </SimDllArguments>
<SimDlgDll>DARMCM1.DLL</SimDlgDll>
<SimDlgDllArguments>-pCM0+</SimDlgDllArguments>
<TargetDllName>SARMCM3.DLL</TargetDllName>
<TargetDllArguments> </TargetDllArguments>
<TargetDlgDll>TARMCM1.DLL</TargetDlgDll>
<TargetDlgDllArguments>-pCM0+</TargetDlgDllArguments>
</DllOption>
<DebugOption>
<OPTHX>
<HexSelection>1</HexSelection>
<HexRangeLowAddress>0</HexRangeLowAddress>
<HexRangeHighAddress>0</HexRangeHighAddress>
<HexOffset>0</HexOffset>
<Oh166RecLen>16</Oh166RecLen>
</OPTHX>
</DebugOption>
<Utilities>
<Flash1>
<UseTargetDll>1</UseTargetDll>
<UseExternalTool>0</UseExternalTool>
<RunIndependent>0</RunIndependent>
<UpdateFlashBeforeDebugging>1</UpdateFlashBeforeDebugging>
<Capability>1</Capability>
<DriverSelection>4096</DriverSelection>
</Flash1>
<bUseTDR>1</bUseTDR>
<Flash2>BIN\UL2CM3.DLL</Flash2>
<Flash3></Flash3>
<Flash4></Flash4>
<pFcarmOut></pFcarmOut>
<pFcarmGrp></pFcarmGrp>
<pFcArmRoot></pFcArmRoot>
<FcArmLst>0</FcArmLst>
</Utilities>
<TargetArmAds>
<ArmAdsMisc>
<GenerateListings>0</GenerateListings>
<asHll>1</asHll>
<asAsm>1</asAsm>
<asMacX>1</asMacX>
<asSyms>1</asSyms>
<asFals>1</asFals>
<asDbgD>1</asDbgD>
<asForm>1</asForm>
<ldLst>0</ldLst>
<ldmm>1</ldmm>
<ldXref>1</ldXref>
<BigEnd>0</BigEnd>
<AdsALst>1</AdsALst>
<AdsACrf>1</AdsACrf>
<AdsANop>0</AdsANop>
<AdsANot>0</AdsANot>
<AdsLLst>1</AdsLLst>
<AdsLmap>1</AdsLmap>
<AdsLcgr>1</AdsLcgr>
<AdsLsym>1</AdsLsym>
<AdsLszi>1</AdsLszi>
<AdsLtoi>1</AdsLtoi>
<AdsLsun>1</AdsLsun>
<AdsLven>1</AdsLven>
<AdsLsxf>1</AdsLsxf>
<RvctClst>0</RvctClst>
<GenPPlst>0</GenPPlst>
<AdsCpuType>"Cortex-M0+"</AdsCpuType>
<RvctDeviceName></RvctDeviceName>
<mOS>0</mOS>
<uocRom>0</uocRom>
<uocRam>0</uocRam>
<hadIROM>1</hadIROM>
<hadIRAM>1</hadIRAM>
<hadXRAM>0</hadXRAM>
<uocXRam>0</uocXRam>
<RvdsVP>0</RvdsVP>
<RvdsMve>0</RvdsMve>
<RvdsCdeCp>0</RvdsCdeCp>
<nBranchProt>0</nBranchProt>
<hadIRAM2>0</hadIRAM2>
<hadIROM2>0</hadIROM2>
<StupSel>8</StupSel>
<useUlib>1</useUlib>
<EndSel>0</EndSel>
<uLtcg>0</uLtcg>
<nSecure>0</nSecure>
<RoSelD>3</RoSelD>
<RwSelD>3</RwSelD>
<CodeSel>0</CodeSel>
<OptFeed>0</OptFeed>
<NoZi1>0</NoZi1>
<NoZi2>0</NoZi2>
<NoZi3>0</NoZi3>
<NoZi4>0</NoZi4>
<NoZi5>0</NoZi5>
<Ro1Chk>0</Ro1Chk>
<Ro2Chk>0</Ro2Chk>
<Ro3Chk>0</Ro3Chk>
<Ir1Chk>1</Ir1Chk>
<Ir2Chk>0</Ir2Chk>
<Ra1Chk>0</Ra1Chk>
<Ra2Chk>0</Ra2Chk>
<Ra3Chk>0</Ra3Chk>
<Im1Chk>1</Im1Chk>
<Im2Chk>0</Im2Chk>
<OnChipMemories>
<Ocm1>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm1>
<Ocm2>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm2>
<Ocm3>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm3>
<Ocm4>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm4>
<Ocm5>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm5>
<Ocm6>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</Ocm6>
<IRAM>
<Type>0</Type>
<StartAddress>0x20000000</StartAddress>
<Size>0xc00</Size>
</IRAM>
<IROM>
<Type>1</Type>
<StartAddress>0x8000000</StartAddress>
<Size>0x6000</Size>
</IROM>
<XRAM>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</XRAM>
<OCR_RVCT1>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT1>
<OCR_RVCT2>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT2>
<OCR_RVCT3>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT3>
<OCR_RVCT4>
<Type>1</Type>
<StartAddress>0x8000000</StartAddress>
<Size>0x6000</Size>
</OCR_RVCT4>
<OCR_RVCT5>
<Type>1</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT5>
<OCR_RVCT6>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT6>
<OCR_RVCT7>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT7>
<OCR_RVCT8>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT8>
<OCR_RVCT9>
<Type>0</Type>
<StartAddress>0x20000000</StartAddress>
<Size>0xc00</Size>
</OCR_RVCT9>
<OCR_RVCT10>
<Type>0</Type>
<StartAddress>0x0</StartAddress>
<Size>0x0</Size>
</OCR_RVCT10>
</OnChipMemories>
<RvctStartVector></RvctStartVector>
</ArmAdsMisc>
<Cads>
<interw>1</interw>
<Optim>1</Optim>
<oTime>0</oTime>
<SplitLS>0</SplitLS>
<OneElfS>1</OneElfS>
<Strict>0</Strict>
<EnumInt>0</EnumInt>
<PlainCh>0</PlainCh>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<wLevel>3</wLevel>
<uThumb>0</uThumb>
<uSurpInc>0</uSurpInc>
<uC99>1</uC99>
<uGnu>0</uGnu>
<useXO>0</useXO>
<v6Lang>3</v6Lang>
<v6LangP>5</v6LangP>
<vShortEn>1</vShortEn>
<vShortWch>1</vShortWch>
<v6Lto>0</v6Lto>
<v6WtE>0</v6WtE>
<v6Rtti>0</v6Rtti>
<VariousControls>
<MiscControls></MiscControls>
<Define>USE_HAL_DRIVER,PY32F002Bx5</Define>
<Undefine></Undefine>
<IncludePath>..\Core\Inc;..\Drivers\CMSIS\Include;..\Drivers\CMSIS\Device\PY32F0xx\Include;..\Drivers\PY32F002B_HAL_Driver\Inc;..\Core\Dallas;..\Core\Modbus;..\Core\MyLibs</IncludePath>
</VariousControls>
</Cads>
<Aads>
<interw>1</interw>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<thumb>0</thumb>
<SplitLS>0</SplitLS>
<SwStkChk>0</SwStkChk>
<NoWarn>0</NoWarn>
<uSurpInc>0</uSurpInc>
<useXO>0</useXO>
<ClangAsOpt>4</ClangAsOpt>
<VariousControls>
<MiscControls></MiscControls>
<Define></Define>
<Undefine></Undefine>
<IncludePath></IncludePath>
</VariousControls>
</Aads>
<LDads>
<umfTarg>1</umfTarg>
<Ropi>0</Ropi>
<Rwpi>0</Rwpi>
<noStLib>0</noStLib>
<RepFail>1</RepFail>
<useFile>0</useFile>
<TextAddressRange>0x00000000</TextAddressRange>
<DataAddressRange>0x20000000</DataAddressRange>
<pXoBase></pXoBase>
<ScatterFile>.\Objects\Project.sct</ScatterFile>
<IncludeLibs></IncludeLibs>
<IncludeLibsPath></IncludeLibsPath>
<Misc></Misc>
<LinkerInputFile></LinkerInputFile>
<DisabledWarnings></DisabledWarnings>
</LDads>
</TargetArmAds>
</TargetOption>
<Groups>
<Group>
<GroupName>Common</GroupName>
<Files>
<File>
<FileName>startup_py32f002bxx.s</FileName>
<FileType>2</FileType>
<FilePath>.\startup_py32f002bxx.s</FilePath>
</File>
<File>
<FileName>system_py32f002b.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\system_py32f002b.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_conf.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Inc\py32f002b_hal_conf.h</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>Application/User</GroupName>
<Files>
<File>
<FileName>main.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\main.c</FilePath>
</File>
<File>
<FileName>gpio.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\gpio.c</FilePath>
</File>
<File>
<FileName>tim.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\tim.c</FilePath>
</File>
<File>
<FileName>usart.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\usart.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_msp.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\py32f002b_hal_msp.c</FilePath>
</File>
<File>
<FileName>py32f002b_it.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Src\py32f002b_it.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>Drivers/PY32F002B_HAL_Driver</GroupName>
<Files>
<File>
<FileName>py32f002b_hal.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_rcc.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_rcc.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_rcc_ex.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_rcc_ex.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_cortex.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_cortex.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_gpio.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_gpio.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_pwr.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_pwr.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_usart.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_usart.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_tim.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_tim.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_tim_ex.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_tim_ex.c</FilePath>
</File>
<File>
<FileName>py32f002b_hal_uart.c</FileName>
<FileType>1</FileType>
<FilePath>..\Drivers\PY32F002B_HAL_Driver\Src\py32f002b_hal_uart.c</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>Dallas</GroupName>
<Files>
<File>
<FileName>pch_sensors.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Dallas\pch_sensors.c</FilePath>
</File>
<File>
<FileName>pch_sensors.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Dallas\pch_sensors.h</FilePath>
</File>
<File>
<FileName>dallas_tools.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Dallas\dallas_tools.c</FilePath>
</File>
<File>
<FileName>dallas_tools.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Dallas\dallas_tools.h</FilePath>
</File>
<File>
<FileName>ds18b20_driver.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Dallas\ds18b20_driver.c</FilePath>
</File>
<File>
<FileName>ds18b20_driver.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Dallas\ds18b20_driver.h</FilePath>
</File>
<File>
<FileName>onewire.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Dallas\onewire.c</FilePath>
</File>
<File>
<FileName>onewire.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Dallas\onewire.h</FilePath>
</File>
<File>
<FileName>ow_port.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Dallas\ow_port.c</FilePath>
</File>
<File>
<FileName>ow_port.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Dallas\ow_port.h</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>Modbus</GroupName>
<Files>
<File>
<FileName>crc_algs.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Modbus\crc_algs.c</FilePath>
</File>
<File>
<FileName>crc_algs.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Modbus\crc_algs.h</FilePath>
</File>
<File>
<FileName>interface_config.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Modbus\interface_config.h</FilePath>
</File>
<File>
<FileName>modbus.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Modbus\modbus.c</FilePath>
</File>
<File>
<FileName>modbus.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Modbus\modbus.h</FilePath>
</File>
<File>
<FileName>modbus_data.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Modbus\modbus_data.h</FilePath>
</File>
<File>
<FileName>rs_message.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\Modbus\rs_message.c</FilePath>
</File>
<File>
<FileName>rs_message.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\Modbus\rs_message.h</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>MyLibs</GroupName>
<Files>
<File>
<FileName>bit_access.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\bit_access.h</FilePath>
</File>
<File>
<FileName>general_gpio.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\MyLibs\general_gpio.c</FilePath>
</File>
<File>
<FileName>general_gpio.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\general_gpio.h</FilePath>
</File>
<File>
<FileName>mylibs_config.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\mylibs_config.h</FilePath>
</File>
<File>
<FileName>mylibs_defs.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\mylibs_defs.h</FilePath>
</File>
<File>
<FileName>mylibs_include.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\mylibs_include.h</FilePath>
</File>
<File>
<FileName>trace.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\trace.h</FilePath>
</File>
<File>
<FileName>trackers.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\MyLibs\trackers.h</FilePath>
</File>
</Files>
</Group>
<Group>
<GroupName>::CMSIS</GroupName>
</Group>
</Groups>
</Target>
</Targets>
<RTE>
<apis/>
<components>
<component Cclass="CMSIS" Cgroup="CORE" Cvendor="ARM" Cversion="5.6.0" condition="ARMv6_7_8-M Device">
<package name="CMSIS" schemaVersion="1.7.7" url="http://www.keil.com/pack/" vendor="ARM" version="5.9.0"/>
<targetInfos>
<targetInfo name="PY32F002Bx5_Project"/>
</targetInfos>
</component>
</components>
<files/>
</RTE>
</Project>

BIN
PY32F002A_Pins.xlsx Normal file
View File

Binary file not shown.

BIN
PY32F002B_Pins.xlsx Normal file
View File

Binary file not shown.

111
README.md
View File

@@ -1,2 +1,109 @@
# PY32F002B Scan Dallas + Modbus Module
Прога для PY32F002B которая будет считывать датчики температуры, сохранять в модбас и выдавать если надо будет
# PY32F002B PCHTemperature+Modbus Module
Прога для PY32F002B которая будет считывать датчики температуры в ПЧ и сохранять их в модбас регистры.
Конверсия идет непрерывно и после каждой конверсии считываются все датчики и записываются в модбас регистры.
## **Чтение температуры**
Для считывания температуры необходимо:
- выставить коил `RunConvertion` (`№0`)
- считывать инпут регистры `№0-29` для получения температуры [***Цельсий x 100***]
После выставления коила модуль будет непрерывно запускать конверсию и по её завершении обновлять инпут регистры.
После каждого завершения конверсии выставляется коил `ConvertionDone` (`№16`), который сбрасывается при чтении инпут регистров температуры. Поэтому имеет смысл дополнительно проверить этот коил, обновились ли значения температуры с прошлого считывания.
Если какой-то датчик был потерян, в инпут регистры на его место записывается `0x0` и выставляется коил `LostedSensors` (`№17`)
## Управление датчиками
Взаимодействие с датчиком строится по следующему принципу:
- заполнение холдинг регистров (`№0-5`) для параметров датчика для обращения к нему
- выставление коила для взаимодействия с датчиком (поиск, чтение, инит, деинит)
- чтение инпут регистров (`№30-36`) содержащих ответ от датчика и [статус взаимодействия](#статус-общения-с-датчиком)
После выставления коила, происходит выбранное действие с датчиком и заполнение инпут регистров с ответом, поэтому имеет смысл сделать выдержку в пару миллисекунд между выставлением коила с считыванием ответа
### Адреса всех датчиков
Для получения ROM всех датчиков необходимо:
- считать инпут регистры `№38-158`
В них записаны ROM всех найденных датчиков (максимум 30 датчиков на линии), каждый ROM занимает 4 регистра Modbus. Т.е. ROM первого датчика находится в регистрах `№38-41`, ROM второго - в регистрах `№42-45` и так далее.
### Считывание параметров датчика
Для считывания параметров конкретного датчика необходимо:
- выставить холдинг регистры:
- `Location` (`№0`), где находится датчик
- `ROM` (`№1-4`), адрес датчика
- Выставляется что-то одно из `Location`/`ROM`, а второе должно быть в нуле
- выставить коил `ReadSensor` (`№1`)
- считать ответ в инпут регистры:
- `Location` (`№30`), где находится датчик
- `ROM` (`№31-34`), адрес датчика
- `Config` (`№35`), конфиг регистр датчика
- `Status` (`№36`), [статус общения с датчиком](#статус-общения-с-датчиком)
После выставления коила, происходит чтение скратчпада датчика и заполнение им инпут регистров. Если чтение по локации не прошло успешно статус выставляется в `0xF0`. Если чтение по ROM не прошло успешно статус выставляется в `0xF0`
### Инициализация датчика
Для инициализации датчика необходимо:
- выставить холдинг регистры:
- `Location` (`№0`), где находится датчик
- `ROM` (`№1-4`), адрес датчика
- `Config` (`№5`), конфиг регистр датчика
- выставить коил `InitSensor` (`№2`)
- считать ответ в инпут регистры:
- `Location` (`№30`), где находится датчик
- `ROM` (`№31-34`), адрес датчика
- `Config` (`№35`), конфиг регистр датчика
- `Status` (`№36`), [статус общения с датчиком](#статус-общения-с-датчиком)
После выставления коила в `UserByte` выбранного по ROM датчика записывается его локация и он включается в структуру датчиков микроконтроллера. Если инициализация не прошла успешно статус выставляется в `0xAA`
### Деинициализация датчика
Для деинициализации датчика необходимо:
- выставить холдинг регистр `Location` (`№0`), где находится датчик
- выставить коил `DeInitSensor` (`№3`)
- считать ответ в инпут регистры:
- `Location` (`№30`), где находится датчик
- `ROM` (`№31-34`), адрес датчика
- `Config` (`№35`), конфиг регистр датчика
- `Status` (`№36`), [статус общения с датчиком](#статус-общения-с-датчиком)
После выставления коила в `UserByte` выбранного по `ROM` датчика записываются нули и он выключается из структуры датчиков микроконтроллера. Если деинициализация не прошла успешно статус выставляется в `0x55`
### Статус общения с датчиком
Статус сигнализирует о следующих событиях:
- `0x01`- без ошибок, все ок
- `0x11` - конец скана
- `0xF0` - ошибка при чтении по выбранной локации
- `0x0F` - ошибка при чтении по выбранному ROM
- `0xAA` - ошибка инициализации выбранного датчика
- `0x55` - ошибка деинициализации выбранного датчика
- `0xBB` - ошибка при сканировании (в МК хранится адрес несуществующего датчика например)
## Структура данных
**Coils**: адреса для управления работой модуля
- 0: `RunConvertion` - [запуск преобразований всех датчиков](#чтение-температуры)
- 1: `ReadSensor` - [считать параметры датчика](#считывание-параметров-датчика)
- 2: `InitSensor` - [инициализация датчика](#инициализация-датчика)
- 3: `DeInitSensor` - [деинициализировать датчик](#деинициализация-датчика)
- 4: `ScanSensors` - включить режим [поиска датчиков](#сканирование-датчиков)
**Coils**: адреса для флагов модуля
- 16: `ConvertionDone` - флаг окончания конверсии. Сбрасывается после считывания температуры из регистров
- 17: `LostedSensors` - флаг есть ли потерянные сенсоры. Сбрасывается по модбас
**Hodling Registers**: адреса для передачи параметров датчика и для инициализации/деинициализации.
- 0: `Location` - локация датчика
- 1-4: `ROM` - ROM датчика
- 5: `Config` - разрешение датчика
- 6: `Enable` - считывать напряжение с этого датчика или нет
**Input Registers**: адреса для хранения температуры и параметров датчика
Температура храниться в первых 30 инпут регистрах
- 0-29: `SensTemperature` - температура n-го датчика в [***Цельсий x 100***]
Параметры храняться в рестрах N+1. Хранятся параметры последнего датчика к которому было совершнео обращение (коилы №1-3)
- 30: `Location` - локация датчика, к которому было совершено обращение
- 31-34: `ROM` - ROM датчика, к которому было совершено обращение
- 35: `Config` - конфигурационный регистр датчика, к которому было совершено обращение
- 36: `Status` - статус работы датчика, к которому было совершено обращение

BIN
ds18b20_locations.xlsx Normal file
View File

Binary file not shown.

555
py_project/Core/Dallas/dallas_tools.c Normal file
View File

@@ -0,0 +1,555 @@
/**
******************************************************************************
* @file dallas_tools.c
* @brief Драйвер для работы с датчиками температуры DS18B20
* @author MicroTechnics (microtechnics.ru)
******************************************************************************
@details
Этот файл содержит реализацию функций для работы с датчиком DS18B20
через интерфейс 1-Wire. Он предоставляет функции для чтения и записи
конфигурации, выполнения измерений и обработки полученных данных.
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "dallas_tools.h"
#include "string.h"
/* Declarations and definitions --------------------------------------------*/
DALLAS_HandleTypeDef hdallas1;
/* Functions ---------------------------------------------------------------*/
/**
* @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 Функция для иниицализации нового датчика в структуре
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_AddNewSensors(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
sensor->hdallas = hdallas;
result = sensor->Init.init_func(hdallas, sensor);
return result;
}
/**
* @brief Инициализирует структуру датчика по ROM
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByROM(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t ROM[8] = {0};
ROM[0] = (sensor->Init.InitParam >> (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 < hdallas->onewire->RomCnt; i++)
{
comparebytes = DALLAS_ROM_SIZE;
for(int rom_byte = 0; rom_byte < DALLAS_ROM_SIZE; rom_byte++)
{
if(hdallas->ds_devices->DevAddr[i][rom_byte] == ROM[rom_byte])
comparebytes--;
}
if(comparebytes == 0)
{
ROM_ind = i;
break;
}
}
/* Проверка присутствует ли выбранный датчик на линии */
if(comparebytes == 0)
{
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[ROM_ind]);
return result;
}
else
{
return HAL_ERROR;
}
}
/**
* @brief Инициализирует структуру датчика по пользовательским байтам
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInitByUserBytes(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
uint8_t UserByte1 = sensor->Init.InitParam & 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;
for(int i = 0; i < hdallas->onewire->RomCnt; i++)
{
/* Проверка присутствует ли выбранный датчик на линии */
result = DS18B20_ReadScratchpad(hdallas->onewire, (uint8_t *)&hdallas->ds_devices->DevAddr[i], (uint8_t *)&hdallas->scratchpad);
if (result != HAL_OK)
return result;
/* Сравнение UserByte1 и UserByte2, если они не равны нулю */
if((sensor->Init.InitParam & 0xFFFF) != NULL)
{
if( (hdallas->scratchpad.tHighRegister == UserByte1) &&
(hdallas->scratchpad.tLowRegister == UserByte2))
{
UserByte12Cmp = 1;
}
}/* Если сравнение UserByte1 и UserByte2 не выбрано, то считаем что они совпадают */
else
{
UserByte12Cmp = 1;
}
/* Сравнение UserByte3 и UserByte4, если они не равны нулю */
if((sensor->Init.InitParam & 0xFFFF0000) != NULL)
{
if( (hdallas->scratchpad.UserByte3 == UserByte3) &&
(hdallas->scratchpad.UserByte4 == UserByte4))
{
UserByte34Cmp = 1;
}
}/* Если сравнение UserByte3 и UserByte4 не выбрано, то считаем что они одинаковые */
else
{
UserByte34Cmp = 1;
}
/* Если нашли нужный датчик - завершаем поиск */
if(UserByte12Cmp && UserByte34Cmp)
{
// sensor->isInitialized = 1;
// sensor->Init.init_func = (HAL_StatusTypeDef (*)())Dallas_SensorInitByUserBytes;
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[i]);
return result;
}
}
sensor->sensROM = 0;
/* Возвращаем ошибку если не нашли */
return HAL_ERROR;
}
/**
* @brief Инициализирует структуру датчика по порядковому номеру
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @retval HAL Status
* @details Порядковый номер датчика в списке найденных.
* Т.е. каким по счету этот датчик был найден
*/
HAL_StatusTypeDef Dallas_SensorInitByInd(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(hdallas == NULL)
return HAL_ERROR;
if(sensor == NULL)
return HAL_ERROR;
result = Dallas_SensorInit(hdallas, sensor, &hdallas->ds_devices->DevAddr[sensor->Init.InitParam]);
return result;
}
/**
* @brief Инициализирует датчик для работы
* @param hdallas Указатель на хендл для общения с датчиками
* @param sensor Указатель на структуру датчика
* @param ROM ROM датчика, который надо инициализировать
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorInit(DALLAS_HandleTypeDef *hdallas, DALLAS_SensorHandleTypeDef *sensor, uint8_t (*ROM)[DALLAS_ROM_SIZE])
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(hdallas == 0)
return HAL_ERROR;
sensor->hdallas = hdallas;
sensor->sensROM = 0;
sensor->sensROM = *(uint64_t *)(ROM);
// for(int i = 0; i < DALLAS_ROM_SIZE; i++)
// sensor->sensROM |= ((uint64_t)(*ROM)[i] << (56 - 8*i));
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_ReadScratchpad(sensor);
if (result == HAL_OK)
{
/* Установка разрешения */
result = DS18B20_SetResolution(hdallas->onewire, (uint8_t *)ROM, sensor->Init.Resolution);
if (result == HAL_OK)
{
sensor->isInitialized = 1;
return HAL_OK;
}
else
{
sensor->isInitialized = 0;
return result;
}
}
else
{
sensor->isInitialized = 0;
return result;
}
}
/**
* @brief Деинициализирует структуру датчика
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_SensorDeInit(DALLAS_SensorHandleTypeDef *sensor)
{
if(sensor == NULL)
return HAL_ERROR;
memset(&sensor->f, 0, sizeof(sensor->f));
sensor->isConnected = 0;
sensor->isInitialized = 0;
sensor->isLost = 0;
sensor->temperature = 0;
sensor->sensROM = 0;
return HAL_OK;
}
/**
* @brief Запускает измерение температуры на всех датчиках
* @param hdallas Указатель на хендл для общения с датчиками
* @param waitCondition Условие ожидания завершения преобразования
* @param dallas_delay_ms Время ожидания окончания конверсии
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_StartConvertTAll(DALLAS_HandleTypeDef *hdallas, DALLAS_WaitConvertionTypeDef waitCondition, uint8_t dallas_delay_ms)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
if(hdallas == NULL)
return HAL_ERROR;
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvTAll(hdallas->onewire);
if(result != HAL_OK)
{
return result;
}
// // Проверка что преобразование началось
// if(OneWire_ReadBit(onewire) == 1)
// return HAL_ERROR;
// Ожидание завершения преобразования, путем проверки шины
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(hdallas->onewire);
return result;
}
// Ожидание завершения преобразования, путем задержки
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
switch (dallas_delay_ms)
{
case DALLAS_CONFIG_9_BITS:
delayValueMs = DALLAS_DELAY_MS_9_BITS;
break;
case DALLAS_CONFIG_10_BITS:
delayValueMs = DALLAS_DELAY_MS_10_BITS;
break;
case DALLAS_CONFIG_11_BITS:
delayValueMs = DALLAS_DELAY_MS_11_BITS;
break;
case DALLAS_CONFIG_12_BITS:
delayValueMs = DALLAS_DELAY_MS_12_BITS;
break;
default:
break;
}
HAL_Delay(delayValueMs);
}
return result;
}
/**
* @brief Измеряет температуру на датчике
* @param sensor Указатель на структуру датчика
* @param waitCondition Условие ожидания завершения преобразования
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ConvertT(DALLAS_SensorHandleTypeDef *sensor, DALLAS_WaitConvertionTypeDef waitCondition)
{
HAL_StatusTypeDef result;
uint8_t rxDummyData;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
return result;
// Отправка команды начала преобразования температуры
result = DS18B20_StartConvT(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM);
if(result != HAL_OK)
{
return result;
}
// Ожидание завершения преобразования, путем проверки шины
if (waitCondition == DALLAS_WAIT_BUS)
{
result = DS18B20_WaitForEndConvertion(sensor->hdallas->onewire);
if(result == HAL_TIMEOUT)
{
sensor->f.timeout_convertion_cnt++;
}
return result;
}
// Ожидание завершения преобразования, путем задержки
if (waitCondition == DALLAS_WAIT_DELAY)
{
uint32_t delayValueMs = 0;
switch (sensor->hdallas->scratchpad.ConfigRegister)
{
case DALLAS_CONFIG_9_BITS:
delayValueMs = DALLAS_DELAY_MS_9_BITS;
break;
case DALLAS_CONFIG_10_BITS:
delayValueMs = DALLAS_DELAY_MS_10_BITS;
break;
case DALLAS_CONFIG_11_BITS:
delayValueMs = DALLAS_DELAY_MS_11_BITS;
break;
case DALLAS_CONFIG_12_BITS:
delayValueMs = DALLAS_DELAY_MS_12_BITS;
break;
default:
break;
}
HAL_Delay(delayValueMs);
}
/* Не считываем температуру, если не выбрано ожидание окончания преобразования */
if(waitCondition != DALLAS_WAIT_NONE)
{
result = Dallas_ReadTemperature(sensor);
}
return result;
}
/**
* @brief Читает измеренную датчиком температуру
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_ReadTemperature(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
if(sensor->isInitialized == 0)
return HAL_ERROR;
/* Проверка присутствует ли выбранный датчик на линии */
result = Dallas_IsConnected(sensor);
if (result != HAL_OK)
{
return result;
}
result = DS18B20_CalcTemperature(sensor->hdallas->onewire, (uint8_t *)&sensor->sensROM, (uint8_t *)&sensor->hdallas->scratchpad, &sensor->temperature);
if (result != HAL_OK)
{
sensor->f.read_temperature_err_cnt++;
return result;
}
return HAL_OK;
}
/**
* @brief Проверяет подключен ли датчик (чтение scratchpad)
* @param sensor Указатель на структуру датчика
* @retval HAL Status
*/
HAL_StatusTypeDef Dallas_IsConnected(DALLAS_SensorHandleTypeDef *sensor)
{
HAL_StatusTypeDef result;
if(sensor == NULL)
return HAL_ERROR;
result = Dallas_ReadScratchpad(sensor);
if (result == HAL_OK)
{
sensor->isConnected = 1;
sensor->isLost = 0;
return HAL_OK;
}
else
{
sensor->temperature = 0;
if(sensor->isConnected == 1)
{
sensor->f.disconnect_cnt++;
}
sensor->isLost = 1;
sensor->isConnected = 0;
// Dallas_ReplaceLostedSensor(sensor);
return HAL_BUSY; // использую busy, чтобы отличать ситуацию от HAL_ERROR
}
}
/**
* @brief Записывает пользовательские байты
* @param sensor Указатель на структуру датчика
* @param UserBytes12 Пользовательские байты 1 и 2
* @param UserBytes34 Пользовательские байты 3 и 4
* @param UserBytesMask Маска, какие байты записывать, а какие нет
* @retval HAL Status
* @details старший байт - UserByte4/UserByte2, младший - UserByte3/UserByte1.
*/
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->hdallas->onewire, (uint8_t *)&sensor->sensROM, UserBytes12, UserBytes34, UserBytesMask);
if (result != HAL_OK)
{
sensor->f.write_err_cnt++;
return result;
}
result = Dallas_ReadScratchpad(sensor);
if (result != HAL_OK)
{
return result;
}
return result;
}
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);
}

148
py_project/Core/Dallas/dallas_tools.h Normal file
View File

@@ -0,0 +1,148 @@
/**
******************************************************************************
* @file dallas_tools.h
* @brief Драйвер датчиков температуры DALLAS
******************************************************************************
* Этот файл предоставляет объявления и определения для работы с датчиками
* температуры DS18B20. Он включает структуры данных, макросы и прототипы
* функций для инициализации, чтения температуры
* и управления датчиками.
*
* Работа с датчиками ведётся через протокол OneWire.
*****************************************************************************/
#ifndef DALLAS_TOOLS_H
#define DALLAS_TOOLS_H
/* Includes -----------------------------------------------------------------*/
#include "ds18b20_driver.h"
#include "onewire.h"
/* Определения пользовательских байтов для записи чтения */
#define DALLAS_USER_BYTE_1 (1<<0) ///< Первый пользовательский байт
#define DALLAS_USER_BYTE_2 (1<<1) ///< Второй пользовательский байт
#define DALLAS_USER_BYTE_3 (1<<2) ///< Третий пользовательский байт
#define DALLAS_USER_BYTE_4 (1<<3) ///< Четвёртый пользовательский байт
#define DALLAS_USER_BYTE_12 (DALLAS_USER_BYTE_1|DALLAS_USER_BYTE_2) ///< Первые два байта
#define DALLAS_USER_BYTE_34 (DALLAS_USER_BYTE_3|DALLAS_USER_BYTE_4) ///< Вторые два байта
#define DALLAS_USER_BYTE_ALL (DALLAS_USER_BYTE_12|DALLAS_USER_BYTE_34) ///< Все пользовательские байты
/* Declarations and definitions ---------------------------------------------*/
#define DALLAS_ROM_SIZE 8
#define DALLAS_CONFIG_9_BITS 0x1F
#define DALLAS_CONFIG_10_BITS 0x3F
#define DALLAS_CONFIG_11_BITS 0x5F
#define DALLAS_CONFIG_12_BITS 0x7F
#define DALLAS_DELAY_MS_9_BITS 94
#define DALLAS_DELAY_MS_10_BITS 188
#define DALLAS_DELAY_MS_11_BITS 375
#define DALLAS_DELAY_MS_12_BITS 750
#define DALLAS_DELAY_MS_MAX DALLAS_DELAY_MS_12_BITS
/** @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; ///< Контрольная сумма
}DALLAS_ScratchpadTypeDef;
/** @brief Структура флагов ошибок датчиков DALLAS */
typedef struct
{
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 __packed
{
uint64_t InitParam; ///< Параметр для инициализации: ROM/UserBytes/Индекс
uint8_t Resolution; ///< Разрешение датчика
HAL_StatusTypeDef (*init_func)(); ///< Функция инициализации
} DALLAS_InitStructTypeDef;
/** @brief Cтруктура обработчика DALLAS для общения с датчиком*/
typedef struct
{
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; ///< Флаг потери связи
DALLAS_HandleTypeDef *hdallas;
uint64_t sensROM; ///< ROM-код датчика
float temperature; ///< Текущая температура
DALLAS_InitStructTypeDef Init; ///< Структура инициализации
DALLAS_FlagsTypeDef f; ///< Флаги
} DALLAS_SensorHandleTypeDef;
/** @brief Варианты ожидания окончания конверсии */
typedef enum
{
DALLAS_WAIT_NONE = 0x00, ///< Без ожидания окончания конверсии
DALLAS_WAIT_BUS = 0x01, ///< Ожидание окончания конверсии по шине (опрос датчиков - чтение бита)
DALLAS_WAIT_DELAY = 0x02, ///< Без ожидания окончания через задержку (максимальная задержка для заданной разрядности)
} DALLAS_WaitConvertionTypeDef;
/* Functions ---------------------------------------------------------------*/
/* Функция для нахождения нового датчика на место потерянного */
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

135
Core/Dallas/ds18b20_driver.c → py_project/Core/Dallas/ds18b20_driver.c
View File

@@ -7,7 +7,7 @@
*/
#include "ds18b20_driver.h"
DS18B20_Drv_t DS;
DS18B20_Drv_t *DS;
OneWire_t OW;
/**
@@ -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)
@@ -526,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;

14
Core/Dallas/ds18b20_driver.h → py_project/Core/Dallas/ds18b20_driver.h
View File

@@ -22,11 +22,17 @@
#include "onewire.h"
/* I/O Port ------------------------------------------------------------------*/
#ifdef PY32F002Bx5
#define DS_Pin GPIO_PIN_0
#define DS_GPIO_Port GPIOB
#endif
#ifdef PY32F002Ax5
#define DS_Pin GPIO_PIN_3
#define DS_GPIO_Port GPIOA
#endif
/* Data Structure ------------------------------------------------------------*/
#define DS18B20_DEVICE_AMOUNT 8
#define DS18B20_DEVICE_AMOUNT 30
/* Register ------------------------------------------------------------------*/
#define DS18B20_CMD_CONVERT 0x44
@@ -77,11 +83,8 @@ typedef enum {
typedef struct
{
uint8_t DevAddr[DS18B20_DEVICE_AMOUNT][8];
uint8_t AlmAddr[DS18B20_DEVICE_AMOUNT][8];
float Temperature[DS18B20_DEVICE_AMOUNT];
DS18B20_Res_t Resolution;
} DS18B20_Drv_t;
extern DS18B20_Drv_t DS;
extern DS18B20_Drv_t *DS;;
extern OneWire_t OW;
/* External Function ---------------------------------------------------------*/
@@ -91,6 +94,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,

0
Core/Dallas/dwt.c → py_project/Core/Dallas/dwt.c
View File

0
Core/Dallas/dwt.h → py_project/Core/Dallas/dwt.h
View File

4
Core/Dallas/onewire.c → py_project/Core/Dallas/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 */
@@ -46,6 +47,7 @@ void OneWire_WriteBit(OneWire_t* OW, uint8_t bit)
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,6 +63,7 @@ uint8_t OneWire_ReadBit(OneWire_t* OW)
if(OW == NULL)
return 0;
__disable_irq();
uint8_t bit = 0;
#ifndef ONEWIRE_UART_H
/* Line low */
@@ -77,6 +80,7 @@ uint8_t OneWire_ReadBit(OneWire_t* OW)
/* Wait 50us to complete 60us period */
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

18
Core/Dallas/onewire.h → py_project/Core/Dallas/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 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 // Âîññòàíîâëåíèå ïåðåä ñëåäóþùèì ñëîòîì
#define ONEWIRE_WRITE_1_US 8 // Длительность записи "1"
#define ONEWIRE_WRITE_0_US 57 // Длительность записи "0"
#define ONEWIRE_READ_CMD_US 2 // Время комманды чтения бита
#define ONEWIRE_READ_DELAY_US 6 // Задержка перед считыванием бита
#define ONEWIRE_COMMAND_SLOT_US 58 // Общее время комманды OneWire
#define ONEWIRE_RECOVERY_TIME_US 1 // Восстановление перед следующим слотом
/* Common Register -----------------------------------------------------------*/
#define ONEWIRE_CMD_SEARCHROM 0xF0
#define ONEWIRE_CMD_READROM 0x33

36
Core/Dallas/ow_port.c → py_project/Core/Dallas/ow_port.c
View File

@@ -8,6 +8,13 @@
#include "onewire.h"
#include "tim.h"
#ifdef PY32F002Bx5
#define PIN_NUMB 0
#endif
#ifdef PY32F002Ax5
#define PIN_NUMB 3
#endif
/**
* @brief The internal function is used as gpio pin mode
* @param OW OneWire HandleTypedef
@@ -16,30 +23,13 @@
void OneWire_Pin_Mode(OneWire_t* OW, PinMode Mode)
{
#ifdef CMSIS_Driver
static uint32_t pin_cr_numb = 0;
static int get_pin_numb = 1;
if(get_pin_numb)
{
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;
}
}
if(Mode == Input)
{
OW->DataPort->MODER &= ~((GPIO_MODER_MODE0_Msk) << pin_cr_numb);
OW->DataPort->MODER |= (GPIO_MODE_INPUT << (pin_cr_numb+2));
OW->DataPort->MODER &= ~((GPIO_MODER_MODE0_Msk) << PIN_NUMB);
OW->DataPort->MODER |= (GPIO_MODE_INPUT << (PIN_NUMB));
}else{
OW->DataPort->MODER &= ~((GPIO_MODER_MODE0_Msk) << pin_cr_numb);
OW->DataPort->MODER |= (GPIO_MODE_OUTPUT_PP << pin_cr_numb);
OW->DataPort->MODER &= ~((GPIO_MODER_MODE0_Msk) << PIN_NUMB);
OW->DataPort->MODER |= (GPIO_MODE_OUTPUT_PP << PIN_NUMB);
}
#else
#ifdef LL_Driver
@@ -119,8 +109,8 @@ void OneWire_Delay_uw(uint32_t us)
{
// start = htim1.Instance->CNT;
// end = start + us*tim_1us_period;
htim1.Instance->CNT = 0;
TIM1->CNT = 0;
end = us*tim_1us_period;
while(htim1.Instance->CNT < end) {};
while(TIM1->CNT < end) {};
}

0
Core/Dallas/ow_port.h → py_project/Core/Dallas/ow_port.h
View File

0
Core/Inc/gpio.h → py_project/Core/Inc/gpio.h
View File

52
py_project/Core/Inc/iwdg.h Normal file
View File

@@ -0,0 +1,52 @@
/* USER CODE BEGIN Header */
/**
******************************************************************************
* @file iwdg.h
* @brief This file contains all the function prototypes for
* the iwdg.c file
******************************************************************************
* @attention
*
* Copyright (c) 2024 STMicroelectronics.
* All rights reserved.
*
* This software is licensed under terms that can be found in the LICENSE file
* in the root directory of this software component.
* If no LICENSE file comes with this software, it is provided AS-IS.
*
******************************************************************************
*/
/* USER CODE END Header */
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __IWDG_H__
#define __IWDG_H__
#ifdef __cplusplus
extern "C" {
#endif
/* Includes ------------------------------------------------------------------*/
#include "main.h"
/* USER CODE BEGIN Includes */
/* USER CODE END Includes */
extern IWDG_HandleTypeDef hiwdg;
/* USER CODE BEGIN Private defines */
/* USER CODE END Private defines */
void MX_IWDG_Init(void);
/* USER CODE BEGIN Prototypes */
/* USER CODE END Prototypes */
#ifdef __cplusplus
}
#endif
#endif /* __IWDG_H__ */

18
Core/Inc/main.h → py_project/Core/Inc/main.h
View File

@@ -31,13 +31,29 @@ extern "C" {
/* Includes ------------------------------------------------------------------*/
#include "py32f0xx_hal.h"
#include "interface_config.h"
/* Private includes ----------------------------------------------------------*/
/* Private defines -----------------------------------------------------------*/
#define GPIO_LED_2 GPIO_PIN_1
#define GPIO_LED_3 GPIO_PIN_5
#define GPIO_LED_4 GPIO_PIN_4
#ifdef PY32F002Bx5
#define TIM_MB TIM14
#define __HAL_DBGMCU_FREEZE_TIM_MB __HAL_DBGMCU_FREEZE_TIM14
#define __HAL_RCC_TIM_MB_CLK_ENABLE __HAL_RCC_TIM14_CLK_ENABLE
#define TIM_MB_IRQn TIM14_IRQn
#define TIM_MB_IRQHandler TIM14_IRQHandler
#endif
#ifdef PY32F002Ax5
#define TIM_MB TIM16
#define __HAL_DBGMCU_FREEZE_TIM_MB __HAL_DBGMCU_FREEZE_TIM16
#define __HAL_RCC_TIM_MB_CLK_ENABLE __HAL_RCC_TIM16_CLK_ENABLE
#define TIM_MB_IRQn TIM16_IRQn
#define TIM_MB_IRQHandler TIM16_IRQHandler
#endif
/* Exported variables prototypes ---------------------------------------------*/
/* Exported functions prototypes ---------------------------------------------*/
void Error_Handler(void);

2
Core/Inc/py32f002b_hal_conf.h → py_project/Core/Inc/py32f002b_hal_conf.h
View File

@@ -42,7 +42,7 @@
//#define HAL_COMP_MODULE_ENABLED
#define HAL_FLASH_MODULE_ENABLED
#define HAL_GPIO_MODULE_ENABLED
//#define HAL_IWDG_MODULE_ENABLED
#define HAL_IWDG_MODULE_ENABLED
#define HAL_TIM_MODULE_ENABLED
//#define HAL_LPTIM_MODULE_ENABLED
#define HAL_PWR_MODULE_ENABLED

0
Core/Inc/py32f002b_it.h → py_project/Core/Inc/py32f002b_it.h
View File

222
py_project/Core/Inc/py32f0xx_hal_conf.h Normal file
View File

@@ -0,0 +1,222 @@
/**
******************************************************************************
* @file py32f0xx_hal_conf.h
* @author MCU Application Team
* @Version V1.0.0
* @Date
* @brief HAL configuration file.
******************************************************************************
**/
/* Define to prevent recursive inclusion -------------------------------------*/
#ifndef __PY32F0xx_HAL_CONF_H
#define __PY32F0xx_HAL_CONF_H
#ifdef __cplusplus
extern "C" {
#endif
/* Exported types ------------------------------------------------------------*/
/* Exported constants --------------------------------------------------------*/
/* ########################## Module Selection ############################## */
/**
* @brief This is the list of modules to be used in the HAL driver
*/
#define HAL_MODULE_ENABLED
#define HAL_RCC_MODULE_ENABLED
//#define HAL_ADC_MODULE_ENABLED
//#define HAL_CRC_MODULE_ENABLED
//#define HAL_COMP_MODULE_ENABLED
#define HAL_FLASH_MODULE_ENABLED
#define HAL_GPIO_MODULE_ENABLED
#define HAL_IWDG_MODULE_ENABLED
#define HAL_TIM_MODULE_ENABLED
//#define HAL_LPTIM_MODULE_ENABLED
#define HAL_PWR_MODULE_ENABLED
//#define HAL_I2C_MODULE_ENABLED
#define HAL_UART_MODULE_ENABLED
#define HAL_USART_MODULE_ENABLED
//#define HAL_SPI_MODULE_ENABLED
//#define HAL_EXTI_MODULE_ENABLED
#define HAL_CORTEX_MODULE_ENABLED
/* ########################## Oscillator Values adaptation ####################*/
#if !defined (HSI_VALUE)
#define HSI_VALUE ((uint32_t)8000000) /*!< Value of the Internal oscillator in Hz */
#endif /* HSI_VALUE */
/**
* @brief Adjust the value of External High Speed oscillator (HXT) used in your application.
* This value is used by the RCC HAL module to compute the system frequency
*/
#if !defined (HSE_VALUE)
#define HSE_VALUE ((uint32_t)24000000) /*!< Value of the External oscillator in Hz */
#endif /* HSE_VALUE */
#if !defined (HSE_STARTUP_TIMEOUT)
#define HSE_STARTUP_TIMEOUT ((uint32_t)200) /*!< Time out for HXT start up, in ms */
#endif /* HSE_STARTUP_TIMEOUT */
/**
* @brief Internal Low Speed Internal oscillator (LIRC) value.
*/
#if !defined (LSI_VALUE)
#define LSI_VALUE 32768U /*!< LIRC Typical Value in Hz */
#endif /* LSI_VALUE */ /*!< Value of the Internal Low Speed oscillator in Hz
The real value may vary depending on the variations
in voltage and temperature. */
/**
* @brief Adjust the value of External Low Speed oscillator (LXT) used in your application.
* This value is used by the RCC HAL module to compute the system frequency
*/
#if !defined (LSE_VALUE)
#define LSE_VALUE ((uint32_t)32768) /*!< Value of the External oscillator in Hz*/
#endif /* LSE_VALUE */
#if !defined (LSE_STARTUP_TIMEOUT)
#define LSE_STARTUP_TIMEOUT ((uint32_t)5000) /*!< Time out for LXT start up, in ms */
#endif /* LSE_STARTUP_TIMEOUT */
/* Tip: To avoid modifying this file each time you need to use different HSE,
=== you can define the HSE value in your toolchain compiler preprocessor. */
/* ########################### System Configuration ######################### */
/**
* @brief This is the HAL system configuration section
*/
#define VDD_VALUE ((uint32_t)3300) /*!< Value of VDD in mv */
#define PRIORITY_HIGHEST 0
#define PRIORITY_HIGH 1
#define PRIORITY_LOW 2
#define PRIORITY_LOWEST 3
#define TICK_INT_PRIORITY ((uint32_t)PRIORITY_LOWEST) /*!< tick interrupt priority (lowest by default) */
#define USE_RTOS 0
#define PREFETCH_ENABLE 1
/* ########################## Assert Selection ############################## */
/**
* @brief Uncomment the line below to expanse the "assert_param" macro in the
* HAL drivers code
*/
/* #define USE_FULL_ASSERT 1U */
/* Includes ------------------------------------------------------------------*/
/**
* @brief Include module's header file
*/
#ifdef HAL_MODULE_ENABLED
#include "py32f0xx_hal.h"
#endif /* HAL_MODULE_ENABLED */
#ifdef HAL_RCC_MODULE_ENABLED
#include "py32f0xx_hal_rcc.h"
#endif /* HAL_RCC_MODULE_ENABLED */
#ifdef HAL_EXTI_MODULE_ENABLED
#include "py32f0xx_hal_exti.h"
#endif /* HAL_EXTI_MODULE_ENABLED */
#ifdef HAL_GPIO_MODULE_ENABLED
#include "py32f0xx_hal_gpio.h"
#endif /* HAL_GPIO_MODULE_ENABLED */
#ifdef HAL_CORTEX_MODULE_ENABLED
#include "py32f0xx_hal_cortex.h"
#endif /* HAL_CORTEX_MODULE_ENABLED */
#ifdef HAL_DMA_MODULE_ENABLED
#include "py32f0xx_hal_dma.h"
#endif /* HAL_DMA_MODULE_ENABLED */
#ifdef HAL_ADC_MODULE_ENABLED
#include "py32f0xx_hal_adc.h"
#endif /* HAL_ADC_MODULE_ENABLED */
#ifdef HAL_CRC_MODULE_ENABLED
#include "py32f0xx_hal_crc.h"
#endif /* HAL_CRC_MODULE_ENABLED */
#ifdef HAL_COMP_MODULE_ENABLED
#include "py32f0xx_hal_comp.h"
#endif /* HAL_COMP_MODULE_ENABLED */
#ifdef HAL_FLASH_MODULE_ENABLED
#include "py32f0xx_hal_flash.h"
#endif /* HAL_FLASH_MODULE_ENABLED */
#ifdef HAL_I2C_MODULE_ENABLED
#include "py32f0xx_hal_i2c.h"
#endif /* HAL_I2C_MODULE_ENABLED */
#ifdef HAL_IWDG_MODULE_ENABLED
#include "py32f0xx_hal_iwdg.h"
#endif /* HAL_IWDG_MODULE_ENABLED */
#ifdef HAL_PWR_MODULE_ENABLED
#include "py32f0xx_hal_pwr.h"
#endif /* HAL_PWR_MODULE_ENABLED */
#ifdef HAL_RTC_MODULE_ENABLED
#include "py32f0xx_hal_rtc.h"
#endif /* HAL_RTC_MODULE_ENABLED */
#ifdef HAL_SPI_MODULE_ENABLED
#include "py32f0xx_hal_spi.h"
#endif /* HAL_SPI_MODULE_ENABLED */
#ifdef HAL_TIM_MODULE_ENABLED
#include "py32f0xx_hal_tim.h"
#endif /* HAL_TIM_MODULE_ENABLED */
#ifdef HAL_LPTIM_MODULE_ENABLED
#include "py32f0xx_hal_lptim.h"
#endif /* HAL_LPTIM_MODULE_ENABLED */
#ifdef HAL_UART_MODULE_ENABLED
#include "py32f0xx_hal_uart.h"
#endif /* HAL_UART_MODULE_ENABLED */
#ifdef HAL_WWDG_MODULE_ENABLED
#include "py32f0xx_hal_wwdg.h"
#endif /* HAL_WWDG_MODULE_ENABLED */
#ifdef HAL_LED_MODULE_ENABLED
#include "py32f0xx_hal_led.h"
#endif /* HAL_LED_MODULE_ENABLED */
#ifdef HAL_USART_MODULE_ENABLED
#include "py32f0xx_hal_usart.h"
#endif /* HAL_USART_MODULE_ENABLED */
/* Exported macro ------------------------------------------------------------*/
#ifdef USE_FULL_ASSERT
/**
* @brief The assert_param macro is used for function's parameters check.
* @param expr: If expr is false, it calls assert_failed function
* which reports the name of the source file and the source
* line number of the call that failed.
* If expr is true, it returns no value.
* @retval None
*/
#define assert_param(expr) ((expr) ? (void)0U : assert_failed((uint8_t *)__FILE__, __LINE__))
/* Exported functions ------------------------------------------------------- */
void assert_failed(uint8_t* file, uint32_t line);
#else
#define assert_param(expr) ((void)0U)
#endif /* USE_FULL_ASSERT */
#ifdef __cplusplus
}
#endif
#endif /* __PY32F0xx_HAL_CONF_H */

3
Core/Inc/tim.h → py_project/Core/Inc/tim.h
View File

@@ -39,7 +39,8 @@ extern TIM_HandleTypeDef htim14;
/* USER CODE END Private defines */
void MX_TIM1_Init(void);
void MX_TIM1_Init(void);
void MX_TIMMB_Init(void);
/* USER CODE BEGIN Prototypes */

0
Core/Inc/usart.h → py_project/Core/Inc/usart.h
View File

58
py_project/Core/Modbus/crc_algs.c Normal file
View File

@@ -0,0 +1,58 @@
#include "crc_algs.h"
/*Table of CRC values for high order byte*/
const unsigned char auchCRCHi[]=
{
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,
0x00,0xC1,0x81,0x40,0x01,0xC0,0x80,0x41,0x01,0xC0,0x80,0x41,0x00,0xC1,0x81,0x40,
};
/*Table of CRC values for low order byte*/
const char auchCRCLo[] =
{
0x00,0xC0,0xC1,0x01,0xC3,0x03,0x02,0xC2,0xC6,0x06,0x07,0xC7,0x05,0xC5,0xC4,0x04,
0xCC,0x0C,0x0D,0xCD,0x0F,0xCF,0xCE,0x0E,0x0A,0xCA,0xCB,0x0B,0xC9,0x09,0x08,0xC8,
0xD8,0x18,0x19,0xD9,0x1B,0xDB,0xDA,0x1A,0x1E,0xDE,0xDF,0x1F,0xDD,0x1D,0x1C,0xDC,
0x14,0xD4,0xD5,0x15,0xD7,0x17,0x16,0xD6,0xD2,0x12,0x13,0xD3,0x11,0xD1,0xD0,0x10,
0xF0,0x30,0x31,0xF1,0x33,0xF3,0xF2,0x32,0x36,0xF6,0xF7,0x37,0xF5,0x35,0x34,0xF4,
0x3C,0xFC,0xFD,0x3D,0xFF,0x3F,0x3E,0xFE,0xFA,0x3A,0x3B,0xFB,0x39,0xF9,0xF8,0x38,
0x28,0xE8,0xE9,0x29,0xEB,0x2B,0x2A,0xEA,0xEE,0x2E,0x2F,0xEF,0x2D,0xED,0xEC,0x2C,
0xE4,0x24,0x25,0xE5,0x27,0xE7,0xE6,0x26,0x22,0xE2,0xE3,0x23,0xE1,0x21,0x20,0xE0,
0xA0,0x60,0x61,0xA1,0x63,0xA3,0xA2,0x62,0x66,0xA6,0xA7,0x67,0xA5,0x65,0x64,0xA4,
0x6C,0xAC,0xAD,0x6D,0xAF,0x6F,0x6E,0xAE,0xAA,0x6A,0x6B,0xAB,0x69,0xA9,0xA8,0x68,
0x78,0xB8,0xB9,0x79,0xBB,0x7B,0x7A,0xBA,0xBE,0x7E,0x7F,0xBF,0x7D,0xBD,0xBC,0x7C,
0xB4,0x74,0x75,0xB5,0x77,0xB7,0xB6,0x76,0x72,0xB2,0xB3,0x73,0xB1,0x71,0x70,0xB0,
0x50,0x90,0x91,0x51,0x93,0x53,0x52,0x92,0x96,0x56,0x57,0x97,0x55,0x95,0x94,0x54,
0x9C,0x5C,0x5D,0x9D,0x5F,0x9F,0x9E,0x5E,0x5A,0x9A,0x9B,0x5B,0x99,0x59,0x58,0x98,
0x88,0x48,0x49,0x89,0x4B,0x8B,0x8A,0x4A,0x4E,0x8E,0x8F,0x4F,0x8D,0x4D,0x4C,0x8C,
0x44,0x84,0x85,0x45,0x87,0x47,0x46,0x86,0x82,0x42,0x43,0x83,0x41,0x81,0x80,0x40,
};
uint16_t crc16(uint8_t *data, uint32_t data_size)
{
uint8_t uchCRCHi = 0xFF;
uint8_t uchCRCLo = 0xFF;
unsigned uIndex;
/* CRC Generation Function */
while( data_size--) /* pass through message buffer */
{
uIndex = uchCRCHi ^ *data++; /* calculate the CRC */
uchCRCHi = uchCRCLo ^ auchCRCHi[uIndex];
uchCRCLo = auchCRCLo[uIndex];
}
return uchCRCHi | uchCRCLo<<8;
}

2
Core/Modbus/crc_algs.h → py_project/Core/Modbus/crc_algs.h
View File

@@ -1,4 +1,4 @@
#include "mylibs_include.h"
#include "main.h"
// extern here to use in bootloader.c
extern uint32_t CRC_calc;

22
Core/Modbus/interface_config.h → py_project/Core/Modbus/interface_config.h
View File

@@ -21,23 +21,16 @@
#define MODBUS_VENDOR_NAME "NIO-12"
#define MODBUS_PRODUCT_CODE "12345"
#define MODBUS_REVISION "Ver. 1.0"
#define MODBUS_VENDOR_URL "https://git.arktika.cyou/Andrey/Diod_Test"
#define MODBUS_PRODUCT_NAME "Diode Tester"
#define MODBUS_MODEL_NAME "STM32F103"
#define MODBUS_USER_APPLICATION_NAME "diode_tester"
#define MODBUS_VENDOR_URL "https://git.arktika.cyou/set506/DS18B20_Library/"
#define MODBUS_PRODUCT_NAME "Dallas Driver"
#define MODBUS_MODEL_NAME "PY32F002B"
#define MODBUS_USER_APPLICATION_NAME "PY32Dallas"
//#define MODBUS_UART_NUMB 1 ///< Номер используемого UART, по нему выставляется дефайн USED_MB_UART = USARTx
#define MODBUS_SPEED 115200 ///< Скорость UART для модбас
//#define MODBUS_GPIOX GPIOA ///< Порт для UART RX/TX
//#define MODBUS_GPIO_PIN_RX GPIO_PIN_9 ///< Пин для UART RX
//#define MODBUS_GPIO_PIN_TX GPIO_PIN_10 ///< Пин для UART TX
//#define MODBUS_TIM_NUMB 2 ///< number of used tim, accord to this define sets define USED_MB_TIM = TIMx
//#define MODBUS_TIM_AHB_FREQ 72 ///< TIM AHB Bus Freq
// defines for modbus behaviour
#define MODBUS_DEVICE_ID 1 ///< девайс текущего устройства
//#define MODBUS_MAX_TIMEOUT 500 ///< максимальнйы тайтаут MB is ms
#define MODBUS_DATA_SIZE 27 ///< maximum number of data: DWORD (NOT MESSAGE SIZE)
#define RS_UART_Init MX_USART1_UART_Init
@@ -46,6 +39,9 @@
#define RS_TIM_DeInit HAL_TIM_Base_MspDeInit
#define rs_huart huart1
#define rs_htim htim14
#define RS_EnableReceive() GPIOB->ODR |= GPIO_PIN_3
#define RS_EnableTransmit() GPIOB->ODR &= ~GPIO_PIN_3
/**
* @brief Поменять комманды 0x03 и 0x04 местами (для LabView терминалки от двигателей)
* @details Терминалка от двигателей использует для чтения регистров комманду R_HOLD_REGS вместо R_IN_REGS

47
Core/Modbus/modbus.c → py_project/Core/Modbus/modbus.c
View File

@@ -81,14 +81,13 @@ EXAMPLE: INIT SLAVE RECEIVE
*************************************************************************/
#include "rs_message.h"
uint32_t dbg_temp, dbg_temp2, dbg_temp3; // for debug
/* MODBUS HANDLES */
#ifdef INCLUDE_GENERAL_PERIPH_LIBS
UART_SettingsTypeDef modbus1_suart;
TIM_SettingsTypeDef modbus1_stim;
#else
extern UART_HandleTypeDef rs_huart;
extern TIM_HandleTypeDef rs_htim;
//extern TIM_HandleTypeDef rs_htim;
#endif
RS_HandleTypeDef hmodbus1;
@@ -130,12 +129,13 @@ void MODBUS_FirstInit(void)
hmodbus1.ID = MODBUS_DEVICE_ID;
hmodbus1.sRS_Mode = SLAVE_ALWAYS_WAIT;
hmodbus1.sRS_RX_Size_Mode = RS_RX_Size_NotConst;
hmodbus1.sRS_Timeout = 1;
// INIT
#ifdef INCLUDE_GENERAL_PERIPH_LIBS
hmodbus1.RS_STATUS = RS_Init(&hmodbus1, &modbus1_suart, &modbus1_stim, 0);
#else
hmodbus1.RS_STATUS = RS_Init(&hmodbus1, &rs_huart, &rs_htim, 0);
hmodbus1.RS_STATUS = RS_Init(&hmodbus1, &rs_huart, NULL, 0);
#endif
RS_EnableReceive();
@@ -263,8 +263,8 @@ MB_ExceptionTypeDef MB_DefineRegistersAddress(uint16_t **pRegs, uint16_t Addr, u
if(RegisterType == RegisterType_Holding)
{
// Устаки для тестера
if(MB_Check_Address_For_Arr(Addr, Qnt, R_SETTINGS_ADDR, R_SETTINGS_QNT) == NO_ERRORS)
// Параметры для инициализации датчика
if(MB_Check_Address_For_Arr(Addr, Qnt, R_SENS_INIT_ADDR, R_SENS_INIT_QNT) == NO_ERRORS)
{
*pRegs = MB_Set_Register_Ptr(&MB_DATA.HoldRegs, Addr); // начало регистров хранения/входных
}
@@ -276,8 +276,22 @@ MB_ExceptionTypeDef MB_DefineRegistersAddress(uint16_t **pRegs, uint16_t Addr, u
}
else if(RegisterType == RegisterType_Input)
{
// Измеренные параметры диода
if(MB_Check_Address_For_Arr(Addr, Qnt, R_MEASURED_ADDR, R_MEASURED_QNT) == NO_ERRORS)
// Измеренные температуры
if(MB_Check_Address_For_Arr(Addr, Qnt, R_TEMPERATURE_ADDR, R_TEMPERATURE_QNT) == NO_ERRORS)
{
*pRegs = MB_Set_Register_Ptr(&MB_DATA.InRegs, Addr); // начало регистров хранения/входных
MB_DATA.Coils.ConvertionDone = 0; // сброс флага
}
// Параметры датчика
else if(MB_Check_Address_For_Arr(Addr, Qnt, R_SENS_PARAMS_ADDR, R_SENS_PARAMS_QNT) == NO_ERRORS)
{
*pRegs = MB_Set_Register_Ptr(&MB_DATA.InRegs, Addr); // начало регистров хранения/входных
// икрементирвоание счетчика скана, для вывода всех датчиков на линии в модбас структуру
extern void PYModule_IncrementScanSensor(void);
PYModule_IncrementScanSensor();
}
// Все найденные ROM на линии
else if(MB_Check_Address_For_Arr(Addr, Qnt, R_ALL_ROMS_ADDR, R_ALL_ROMS_QNT) == NO_ERRORS)
{
*pRegs = MB_Set_Register_Ptr(&MB_DATA.InRegs, Addr); // начало регистров хранения/входных
}
@@ -314,11 +328,12 @@ MB_ExceptionTypeDef MB_DefineCoilsAddress(uint16_t **pCoils, uint16_t Addr, uint
return ILLEGAL_DATA_VALUE; // return exception code
}
// tester settings coils
if(MB_Check_Address_For_Arr(Addr, Qnt, C_SETTINGS_ADDR, C_SETTINGS_QNT) == NO_ERRORS)
// Флаги всей шины датчиков
if(MB_Check_Address_For_Arr(Addr, Qnt, C_FLAGS_ADDR, C_FLAGS_QNT) == NO_ERRORS)
{
*pCoils = MB_Set_Coil_Reg_Ptr(&MB_DATA.Coils, Addr);
}// tester control coils
}
// Управление датчиками
else if(MB_Check_Address_For_Arr(Addr, Qnt, C_CONTROL_ADDR, C_CONTROL_QNT) == NO_ERRORS)
{
*pCoils = MB_Set_Coil_Reg_Ptr(&MB_DATA.Coils, Addr);
@@ -722,12 +737,12 @@ RS_StatusTypeDef RS_Response(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modbus_ms
if(hmodbus->f.MessageHandled == 0)
{
TrackerCnt_Err(hmodbus->rs_err);
modbus_msg->Func_Code += ERR_VALUES_START;
}
else
{
TrackerCnt_Ok(hmodbus->rs_err);
}
@@ -782,7 +797,7 @@ RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *mo
if (modbus_msg->ByteCnt > DATA_SIZE*2) // if ByteCnt less than DATA_SIZE
{
TrackerCnt_Err(hmodbus->rs_err);
return RS_COLLECT_MSG_ERR;
}
@@ -804,7 +819,7 @@ RS_StatusTypeDef RS_Collect_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *mo
modbus_uart_buff[ind++] = modbus_msg->ByteCnt;
else // otherwise return data_size err
{
TrackerCnt_Err(hmodbus->rs_err);
return RS_COLLECT_MSG_ERR;
}
@@ -892,7 +907,7 @@ RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modb
//check that data size is correct
if (modbus_msg->ByteCnt > DATA_SIZE*2)
{
TrackerCnt_Err(hmodbus->rs_err);
modbus_msg->Func_Code += ERR_VALUES_START;
return RS_PARSE_MSG_ERR;
}
@@ -919,7 +934,7 @@ RS_StatusTypeDef RS_Parse_Message(RS_HandleTypeDef *hmodbus, RS_MsgTypeDef *modb
// compare crc
if (modbus_msg->MB_CRC != CRC_VALUE)
{
TrackerCnt_Err(hmodbus->rs_err);
modbus_msg->Func_Code += ERR_VALUES_START;
}
// hmodbus->MB_RESPONSE = MB_CRC_ERR; // set func code - error about wrong crc

43
Core/Modbus/modbus.h → py_project/Core/Modbus/modbus.h
View File

@@ -12,7 +12,7 @@
#ifndef __MODBUS_H_
#define __MODBUS_H_
#include "mylibs_include.h"
#include "main.h"
#include "modbus_data.h"
//#include "settings.h" // for modbus settings
@@ -37,7 +37,7 @@
#define Addr_SIZE 2 ///< size of (Addr)
#define Qnt_SIZE 2 ///< size of (Qnt)
#define ByteCnt_SIZE 1 ///< size of (ByteCnt)
#define DATA_SIZE 125 ///< maximum number of data: DWORD (NOT MESSAGE SIZE)
#define DATA_SIZE MODBUS_DATA_SIZE ///< maximum number of data: DWORD (NOT MESSAGE SIZE)
#define CRC_SIZE 2 ///< size of (MB_CRC) in bytes
/** @brief Size of whole message */
@@ -330,7 +330,44 @@ uint8_t MB_Write_Miltuple_Regs(RS_MsgTypeDef *modbus_msg);
* @}
*/
/////////////////////////---FUNCTIONS---/////////////////////////////
/***************************************************************************
*******************************MATH_DEFINES********************************/
/**
* @addtogroup MATH_DEFINES Math defines
* @ingroup MYLIBS_DEFINES
* @brief Дефайны для различных математических функций
@{
*/
/**
* @brief Calc dividing including remainder
* @param _val_ - делимое.
* @param _div_ - делитель.
* @details Если результат деления без остатка: он возвращается как есть
Если с остатком - округляется вверх
*/
//#define Divide_Up(_val_, _div_) (((_val_)%(_div_))? (_val_)/(_div_)+1 : (_val_)/_div_) /* через тернарный оператор */
#define Divide_Up(_val_, _div_) ((_val_ - 1) / _div_) + 1 /* через мат выражение */
/**
* @brief Swap between Little Endian and Big Endian
* @param v - Переменная для свапа.
* @return v (new) - Свапнутая переменная.
* @details Переключения между двумя типами хранения слова: HI-LO байты и LO-HI байты.
*/
#define ByteSwap16(v) (((v&0xFF00) >> (8)) | ((v&0x00FF) << (8)))
/**
* @brief Absolute
* @param x - Переменная для модудя.
* @return x (new) - Число по модулю.
* @details Берет число по модулю. Хз как работает библиотечный abs в stdlib.h, мб это быстрее, но вряд ли конечно.
*/
#define ABS(x) ( ((x) > 0)? (x) : -(x))?
/** MATH_DEFINES
* @}
*/
/////////////////////////////////////////////////////////////////////

78
Core/Modbus/modbus_data.h → py_project/Core/Modbus/modbus_data.h
View File

@@ -13,8 +13,9 @@
#ifndef _MODBUS_DATA_H_
#define _MODBUS_DATA_H_
#include "stdint.h"
#include "ds18b20_driver.h"
//--------------DEFINES FOR REGISTERS---------------
// DEFINES FOR ARRAYS
/**
@@ -30,15 +31,31 @@
@endverbatim
* @{
*/
//typedef struct
//{
// uint16_t ROM[4];
// uint16_t Location;
// uint16_t Resolution;
// uint16_t Losted;
//}MB_SensorResponseTypeDef;
typedef struct
{
uint16_t Location;
uint16_t ROM[4];
uint16_t Config;
uint16_t Status;
}MB_SensorParamsTypeDef;
/**
* @brief Регистры хранения
*/
typedef struct //MB_DataInRegsTypeDef
{
uint16_t ForwardVoltage;
uint16_t ReversePeakVoltage;
uint16_t SensTemperature[DS18B20_DEVICE_AMOUNT];
MB_SensorParamsTypeDef Response;
uint16_t reserved;
uint16_t AllROMs[DS18B20_DEVICE_AMOUNT][4];
}MB_DataInRegsTypeDef;
@@ -47,27 +64,21 @@ typedef struct //MB_DataInRegsTypeDef
*/
typedef struct //MB_DataInRegsTypeDef
{
uint16_t TimeForForward;
uint16_t TimeForReverse;
uint16_t TimeBeforeTest;
uint16_t TimeDeadtime;
uint16_t TimeBeforePeak;
uint16_t Adc_PulseWidth;
uint16_t Adc_PulseSign;
uint16_t Adc_CalibrValue;
uint16_t Adc_ZeroValue;
uint16_t Adc_U_Calibr;
MB_SensorParamsTypeDef InitStruct;
}MB_DataHoldRegsTypeDef;
// DEFINES FOR INPUT REGISTERS ARRAYS
#define R_MEASURED_ADDR 0
#define R_MEASURED_QNT 2
#define R_TEMPERATURE_ADDR (0)
#define R_TEMPERATURE_QNT (DS18B20_DEVICE_AMOUNT)
#define R_SENS_PARAMS_ADDR (DS18B20_DEVICE_AMOUNT) // 30
#define R_SENS_PARAMS_QNT (sizeof(MB_SensorParamsTypeDef)/sizeof(uint16_t)) // 7
#define R_ALL_ROMS_ADDR (R_SENS_PARAMS_ADDR+R_SENS_PARAMS_QNT + 1) // 38
#define R_ALL_ROMS_QNT (DS18B20_DEVICE_AMOUNT*4)
// DEFINES FOR HOLDING REGISTERS ARRAYS
#define R_SETTINGS_ADDR 0
#define R_SETTINGS_QNT 10
#define R_SENS_INIT_ADDR (0)
#define R_SENS_INIT_QNT (sizeof(MB_SensorParamsTypeDef)/sizeof(uint16_t))
// DEFINES FOR REGISTERS LOCAL ADDRESSES
@@ -101,31 +112,26 @@ typedef struct //MB_DataInRegsTypeDef
typedef struct //MB_DataCoilsTypeDef
{
/* reg 1 - control */
unsigned ForwardTest:1;
unsigned ReverseTest:1;
unsigned StartTest:1;
unsigned KeyForwardHiTest:1;
unsigned KeyForwardLoTest:1;
unsigned KeyReverseHiTest:1;
unsigned KeyReverseLoTest:1;
unsigned RunConvertions:1;
unsigned ReadSensor:1;
unsigned InitSensor:1;
unsigned DeInitSensor:1;
unsigned ScanSensors:1;
unsigned reserved:9;
unsigned reserved:11;
/* reg 2 - settings */
unsigned msTimeForForward_enable:1;
unsigned msTimeForReverse_enable:1;
unsigned msTimeBeforeTest_enable:1;
unsigned msTimeDeadtime_enable:1;
unsigned msTimeBeforePeak_enable:1;
unsigned ConvertionDone:1;
unsigned LostedSensors:1;
unsigned reserved2:11;
}MB_DataCoilsTypeDef;
// DEFINES FOR COIL ARRAYS
#define C_CONTROL_ADDR 0
#define C_CONTROL_QNT 7
#define C_CONTROL_QNT 5
#define C_SETTINGS_ADDR 16
#define C_SETTINGS_QNT 5
#define C_FLAGS_ADDR 16
#define C_FLAGS_QNT 10
/** MODBUS_DATA_COILS_DEFINES
* @}

50
Core/Modbus/rs_message.c → py_project/Core/Modbus/rs_message.c
View File

@@ -82,13 +82,13 @@ RS_StatusTypeDef RS_Receive_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
{
RS_RES = RS_Abort(hRS, ABORT_RS);
printf_rs_err("\n%d: Error RS: Failed to start RS receiving...", uwTick);
TrackerCnt_Err(hRS->rs_err);
}
else
{
RS_RES = RS_OK;
printf_rs("\n%d: RS: Start Receiving...", uwTick);
TrackerCnt_Ok(hRS->rs_err);
}
hRS->RS_STATUS = RS_RES;
@@ -138,13 +138,13 @@ RS_StatusTypeDef RS_Transmit_IT(RS_HandleTypeDef *hRS, RS_MsgTypeDef *RS_msg)
{
RS_RES = RS_Abort(hRS, ABORT_RS);
printf_rs_err("\n%d: Error RS: Failed to start RS transmitting...", uwTick);
TrackerCnt_Err(hRS->rs_err);
}
else
{
RS_RES = RS_OK;
printf_rs("\n%d: RS: Start Transmitting...", uwTick);
TrackerCnt_Ok(hRS->rs_err);
}
}
@@ -285,10 +285,13 @@ RS_StatusTypeDef RS_Abort(RS_HandleTypeDef *hRS, RS_AbortTypeDef AbortMode)
{
HAL_StatusTypeDef uart_res = 0;
hRS->htim->Instance->CNT = 0;
__HAL_TIM_CLEAR_IT(hRS->htim, TIM_IT_UPDATE);
if(hRS->sRS_Timeout) // if timeout setted
HAL_TIM_Base_Stop_IT(hRS->htim); // stop timeout
{
TIM_MB->DIER &= ~(TIM_IT_UPDATE);
/* Disable the Peripheral */
TIM_MB->CR1 &= ~(TIM_CR1_CEN);
}
if((AbortMode&ABORT_RS) == 0x00)
{
@@ -342,7 +345,7 @@ RS_StatusTypeDef RS_Handle_Receive_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *R
if(RS_RES != RS_OK)
{
TrackerCnt_Err(hRS->rs_err);
}
return RS_RES;
@@ -366,7 +369,7 @@ RS_StatusTypeDef RS_Handle_Transmit_Start(RS_HandleTypeDef *hRS, RS_MsgTypeDef *
}
if(RS_RES != RS_OK)
{
TrackerCnt_Err(hRS->rs_err);
}
return RS_RES;
@@ -395,7 +398,7 @@ RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS)
// if we need to skip this message - restart receive
if(RS_RES == RS_SKIP || NuRS_of_Rest_Bytes == 0xFFFF)
{
TrackerCnt_Err(hRS->rs_err);
RS_Abort(hRS, ABORT_RX);
RS_RES = RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
return RS_RES;
@@ -410,7 +413,11 @@ RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS)
RS_Set_RX_End(hRS);
if(hRS->sRS_Timeout) // if timeout setted
HAL_TIM_Base_Stop_IT(hRS->htim); // stop timeout
{
TIM_MB->DIER &= ~(TIM_IT_UPDATE);
/* Disable the Peripheral */
TIM_MB->CR1 &= ~(TIM_CR1_CEN);
}
// parse received data
RS_RES = RS_Parse_Message(hRS, hRS->pMessagePtr, hRS->pBufferPtr); // parse message
@@ -426,7 +433,6 @@ RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS)
if(uart_res != HAL_OK)
{// need uart status, so doesnt write abort to RS_RES
TrackerCnt_Err(hRS->rs_err);
RS_RES = RS_Abort(hRS, ABORT_RS);
}
else
@@ -440,7 +446,11 @@ RS_StatusTypeDef RS_UART_RxCpltCallback(RS_HandleTypeDef *hRS)
RS_Set_RX_End(hRS);
if(hRS->sRS_Timeout) // if timeout setted
HAL_TIM_Base_Stop_IT(hRS->htim); // stop timeout
{
TIM_MB->DIER &= ~(TIM_IT_UPDATE);
/* Disable the Peripheral */
TIM_MB->CR1 &= ~(TIM_CR1_CEN);
}
// parse received data
RS_RES = RS_Parse_Message(hRS, hRS->pMessagePtr, hRS->pBufferPtr); // parse message
@@ -493,7 +503,9 @@ void RS_UART_Handler(RS_HandleTypeDef *hRS)
if(hRS->sRS_Timeout) // if timeout setted
if((hRS->huart->RxXferCount+1 == hRS->huart->RxXferSize) && RS_Is_RX_Busy(hRS)) // if first byte is received and receive is active
{
HAL_TIM_Base_Start_IT(hRS->htim);
TIM_MB->DIER |= (TIM_IT_UPDATE);
/* Disable the Peripheral */
TIM_MB->CR1 |= (TIM_CR1_CEN);
RS_Set_RX_Active_Flags(hRS);
}
@@ -510,7 +522,7 @@ void RS_UART_Handler(RS_HandleTypeDef *hRS)
//----------------ERRORS HANDLER----------------
else
{
TrackerCnt_Err(hRS->rs_err);
/* de-init uart transfer */
RS_Abort(hRS, ABORT_RS);
RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);
@@ -528,8 +540,12 @@ void RS_UART_Handler(RS_HandleTypeDef *hRS)
*/
void RS_TIM_Handler(RS_HandleTypeDef *hRS)
{
HAL_TIM_IRQHandler(hRS->htim);
HAL_TIM_Base_Stop_IT(hRS->htim);
TIM_MB->SR = ~(TIM_IT_UPDATE);
/* Disable the TIM Update interrupt */
TIM_MB->DIER &= ~(TIM_IT_UPDATE);
/* Disable the Peripheral */
TIM_MB->CR1 &= ~(TIM_CR1_CEN);
RS_Abort(hRS, ABORT_RS);
RS_Handle_Receive_Start(hRS, hRS->pMessagePtr);

2
Core/Modbus/rs_message.h → py_project/Core/Modbus/rs_message.h
View File

@@ -27,7 +27,6 @@
#include "modbus.h"
#include "mylibs_include.h"
#include "crc_algs.h"
@@ -187,7 +186,6 @@ typedef struct // RS_HandleTypeDef
/* RS STATUS */
RS_StatusTypeDef RS_STATUS; ///< RS status
RS_TrackerTypeDef rs_err;
}RS_HandleTypeDef;
extern RS_HandleTypeDef hmodbus1;

384
py_project/Core/PY32Module/PY32module_main.c Normal file
View File

@@ -0,0 +1,384 @@
/**
******************************************************************************
* @file pch_sensors.c
* @brief Работа с датчиками температуры DS18B20 в ПЧ
*****************************************************************************/
/* Includes ----------------------------------------------------------------*/
#include "PY32module_main.h"
#include "rs_message.h"
/* Declarations and definitions --------------------------------------------*/
PCHSens_TypeDef pchsens;
PCHSens_DallasBusHandle DallasBus;
static uint8_t scan_cnt;
/* Functions ---------------------------------------------------------------*/
void PYModule_FillResponse(PCHSens_SensorTypeDef* sensor, Sensor_ResponseStatusTypeDef status);
void PYModule_CheckModuleLosted(PCHSens_ModuleTypeDef *module, uint8_t *losted_flag);
void PYModule_StoreModuleToModbus(PCHSens_ModuleTypeDef *module);
void PYModule_main(void)
{
if(MB_DATA.Coils.RunConvertions)
{
if(DS18B20_WaitForEndConvertion_NonBlocking(hdallas1.onewire) == HAL_OK)
{
PCHSens_ModuleReadTemperature(&pchsens.module1);
// PCHSens_ModuleReadTemperature(&pchsens.module2);
// PCHSens_ModuleReadTemperature(&pchsens.module3);
// PCHSens_ModuleReadTemperature(&pchsens.module4);
// PCHSens_ModuleReadTemperature(&pchsens.module5);
// PCHSens_ModuleReadTemperature(&pchsens.module6);
PYModule_StoreModbus(&pchsens);
PCHSens_StartCovert(&DallasBus);
GPIOA->ODR ^= GPIO_LED_2;
}
}
if(MB_DATA.Coils.ReadSensor)
{
PYModule_ReadSensor(&hdallas1, &pchsens);
MB_DATA.Coils.ReadSensor = 0;
}
// if(MB_DATA.Coils.ScanSensors)
// {
// PYModule_ScanSensor(&DallasBus);
// }
// else
// {
// scan_cnt = 0;
// }
if(MB_DATA.Coils.InitSensor)
{
PYModule_InitSensor(&pchsens);
MB_DATA.Coils.InitSensor = 0;
}
if(MB_DATA.Coils.DeInitSensor != NULL)
{
PYModule_DeInitSensor(&pchsens);
MB_DATA.Coils.DeInitSensor = 0;
}
PYModule_CheckLosted(&pchsens);
}
void PYModule_FirstInit(void)
{
OW.DataPin = DS_Pin;
OW.DataPort = DS_GPIO_Port;
/* Инициализация onewire и поиск датчиков*/
DS = (DS18B20_Drv_t *)&MB_DATA.InRegs.AllROMs;
OneWire_Init(&OW);
DS18B20_Search(DS, &OW);
/* Инициализация modbus */
MODBUS_FirstInit();
RS_Receive_IT(&hmodbus1, &MODBUS_MSG);
/* Инициализация структур датчиков ПЧ */
DallasBus.hdallas = &hdallas1;
DallasBus.hdallas->onewire = &OW;
DallasBus.hdallas->ds_devices = DS;
PCHSens_InitModule(&hdallas1, &pchsens.module1, REG_PCH_NUMB_11|REG_PCH_DIODE_NUMB_1);
// PCHSens_InitModule(&hdallas1, &pchsens.module2, REG_PCH_NUMB_12|REG_PCH_DIODE_NUMB_1);
// PCHSens_InitModule(&hdallas1, &pchsens.module3, REG_PCH_NUMB_21|REG_PCH_DIODE_NUMB_1);
// PCHSens_InitModule(&hdallas1, &pchsens.module4, REG_PCH_NUMB_22|REG_PCH_DIODE_NUMB_1);
// PCHSens_InitModule(&hdallas1, &pchsens.module5, REG_PCH_NUMB_31|REG_PCH_DIODE_NUMB_1);
// PCHSens_InitModule(&hdallas1, &pchsens.module6, REG_PCH_NUMB_32|REG_PCH_DIODE_NUMB_1);
/* Поиск неизвестных сенсоров */
PCHSens_FindUnknownSensors(&DallasBus);
MB_DATA.Coils.RunConvertions = 1;
}
void PYModule_ScanSensor(PCHSens_DallasBusHandle *hbus)
{
PCHSens_SensorTypeDef sensor;
sensor.sens.hdallas = hbus->hdallas;
sensor.sens.sensROM = *(uint64_t *)(hbus->hdallas->ds_devices->DevAddr[scan_cnt]);
if (scan_cnt >= hbus->hdallas->onewire->RomCnt)
{
scan_cnt = hbus->hdallas->onewire->RomCnt;
PYModule_FillResponse(&sensor, STATUS_SCAN_END);
return;
}
if(Dallas_ReadScratchpad(&sensor.sens) == HAL_OK)
{
PYModule_FillResponse(&sensor, STATUS_OK);
}
else
{
PYModule_FillResponse(&sensor, STATUS_ERR_SCAN);
}
}
void PYModule_IncrementScanSensor(void)
{
if(MB_DATA.Coils.ScanSensors)
{
scan_cnt++;
}
}
void PYModule_ReadSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_TypeDef *pchsens)
{
// чтение по локации
if(MB_DATA.HoldRegs.InitStruct.Location != 0) // если локация не равна нулю
{
PCHSens_SensorTypeDef *sensor;
if(PCHSens_GetSensorByLocation(pchsens, (PCHSens_LocationTypeDef)MB_DATA.HoldRegs.InitStruct.Location, &sensor) != HAL_OK)
return;
if(Dallas_ReadScratchpad(&sensor->sens) == HAL_OK)
{
PYModule_FillResponse(sensor, STATUS_OK);
}
else
{
PYModule_FillResponse(sensor, STATUS_ERR_READ_LOCATION);
}
}
// чтение по ROM
else if(MB_DATA.HoldRegs.InitStruct.ROM[0] | MB_DATA.HoldRegs.InitStruct.ROM[1] | // если РОМ не равен нулю
MB_DATA.HoldRegs.InitStruct.ROM[2] | MB_DATA.HoldRegs.InitStruct.ROM[3] != 0)
{
PCHSens_SensorTypeDef sensor;
sensor.sens.hdallas = hdallas;
sensor.sens.sensROM = *(uint64_t *)MB_DATA.HoldRegs.InitStruct.ROM;
if(Dallas_ReadScratchpad(&sensor.sens) == HAL_OK)
{
PYModule_FillResponse(&sensor, STATUS_OK);
}
else
{
PYModule_FillResponse(&sensor, STATUS_ERR_READ_ROM);
}
}
}
void PYModule_InitSensor(PCHSens_TypeDef *pchsens)
{
if( (MB_DATA.HoldRegs.InitStruct.Location != 0) && // если локация не равна нулю
(MB_DATA.HoldRegs.InitStruct.ROM[0] | MB_DATA.HoldRegs.InitStruct.ROM[1] | // И если РОМ не равен нулю
MB_DATA.HoldRegs.InitStruct.ROM[2] | MB_DATA.HoldRegs.InitStruct.ROM[3] != 0) )
{
PCHSens_SensorTypeDef *sensor;
if(PCHSens_GetSensorByLocation(pchsens, (PCHSens_LocationTypeDef)MB_DATA.HoldRegs.InitStruct.Location, &sensor) != HAL_OK)
return;
uint64_t connectROM = 0;
connectROM = ((uint64_t)(__REV16(MB_DATA.HoldRegs.InitStruct.ROM[0])))<<48;
connectROM |= ((uint64_t)(__REV16(MB_DATA.HoldRegs.InitStruct.ROM[1])))<<32;
connectROM |= ((uint64_t)(__REV16(MB_DATA.HoldRegs.InitStruct.ROM[2])))<<16;
connectROM |= ((uint64_t)(__REV16(MB_DATA.HoldRegs.InitStruct.ROM[3])));
if(PCHSens_InitNewSensor(&hdallas1, sensor, connectROM) == HAL_OK)
{
PYModule_FillResponse(sensor, STATUS_OK);
}
else
{
PYModule_FillResponse(sensor, STATUS_ERR_INIT);
}
}
}
void PYModule_DeInitSensor(PCHSens_TypeDef *pchsens)
{
if(MB_DATA.HoldRegs.InitStruct.Location != 0) // если локация не равна нулю
{
PCHSens_SensorTypeDef *sensor;
if(PCHSens_GetSensorByLocation(pchsens, (PCHSens_LocationTypeDef)MB_DATA.HoldRegs.InitStruct.Location, &sensor) != HAL_OK)
return;
if(PCHSens_UndefineSensor(sensor) == HAL_OK)
{
PYModule_FillResponse(sensor, STATUS_OK);
}
else
{
PYModule_FillResponse(sensor, STATUS_ERR_DEINIT);
}
}
}
void PYModule_CheckLosted(PCHSens_TypeDef *pchsens)
{
uint8_t losted = 0;
// module1
PYModule_CheckModuleLosted(&pchsens->module1, &losted);
PYModule_CheckModuleLosted(&pchsens->module2, &losted);
PYModule_CheckModuleLosted(&pchsens->module3, &losted);
PYModule_CheckModuleLosted(&pchsens->module4, &losted);
PYModule_CheckModuleLosted(&pchsens->module5, &losted);
PYModule_CheckModuleLosted(&pchsens->module6, &losted);
if(losted)
MB_DATA.Coils.LostedSensors = 1;
else
MB_DATA.Coils.LostedSensors = 0;
}
void PYModule_StoreModbus(PCHSens_TypeDef *pchsens)
{
uint8_t losted = 0;
// module1
PYModule_StoreModuleToModbus(&pchsens->module1);
PYModule_StoreModuleToModbus(&pchsens->module2);
PYModule_StoreModuleToModbus(&pchsens->module3);
PYModule_StoreModuleToModbus(&pchsens->module4);
PYModule_StoreModuleToModbus(&pchsens->module5);
PYModule_StoreModuleToModbus(&pchsens->module6);
MB_DATA.Coils.ConvertionDone |= 1;
}
void PYModule_FillResponse(PCHSens_SensorTypeDef* sensor, Sensor_ResponseStatusTypeDef status)
{
switch(status)
{
// successfull response
case STATUS_OK:
// fil with sensor data
MB_DATA.InRegs.Response.Location = *(uint16_t *)&sensor->sens.hdallas->scratchpad.tHighRegister;
MB_DATA.InRegs.Response.Config = sensor->sens.hdallas->scratchpad.ConfigRegister;
MB_DATA.InRegs.Response.ROM[0] = __REV16((sensor->sens.sensROM) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[1] = __REV16((sensor->sens.sensROM >> 16) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[2] = __REV16((sensor->sens.sensROM >> 32) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[3] = __REV16((sensor->sens.sensROM >> 48) & 0xFFFF);
MB_DATA.InRegs.Response.Status = status;
break;
case STATUS_SCAN_END:
MB_DATA.InRegs.Response.Location = 0;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = 0;
MB_DATA.InRegs.Response.ROM[1] = 0;
MB_DATA.InRegs.Response.ROM[2] = 0;
MB_DATA.InRegs.Response.ROM[3] = 0;
MB_DATA.InRegs.Response.Status = status;
break;
// error read by location
case STATUS_ERR_READ_LOCATION:
// fill only location from holdreg
MB_DATA.InRegs.Response.Location = MB_DATA.HoldRegs.InitStruct.Location;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = 0;
MB_DATA.InRegs.Response.ROM[1] = 0;
MB_DATA.InRegs.Response.ROM[2] = 0;
MB_DATA.InRegs.Response.ROM[3] = 0;
MB_DATA.InRegs.Response.Status = status;
break;
// error read by ROM
case STATUS_ERR_READ_ROM:
// fill only ROM from holdreg
MB_DATA.InRegs.Response.Location = 0;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = MB_DATA.HoldRegs.InitStruct.ROM[0];
MB_DATA.InRegs.Response.ROM[1] = MB_DATA.HoldRegs.InitStruct.ROM[1];
MB_DATA.InRegs.Response.ROM[2] = MB_DATA.HoldRegs.InitStruct.ROM[2];
MB_DATA.InRegs.Response.ROM[3] = MB_DATA.HoldRegs.InitStruct.ROM[3];
MB_DATA.InRegs.Response.Status = status;
break;
// error init
case STATUS_ERR_INIT:
// fill ROM and location from holdreg
MB_DATA.InRegs.Response.Location = MB_DATA.HoldRegs.InitStruct.Location;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = MB_DATA.HoldRegs.InitStruct.ROM[0];
MB_DATA.InRegs.Response.ROM[1] = MB_DATA.HoldRegs.InitStruct.ROM[1];
MB_DATA.InRegs.Response.ROM[2] = MB_DATA.HoldRegs.InitStruct.ROM[2];
MB_DATA.InRegs.Response.ROM[3] = MB_DATA.HoldRegs.InitStruct.ROM[3];
MB_DATA.InRegs.Response.Status = status;
break;
// error deinit
case STATUS_ERR_DEINIT:
// fill with sensor data
MB_DATA.InRegs.Response.Location = *(uint16_t *)&sensor->sens.hdallas->scratchpad.tHighRegister;
MB_DATA.InRegs.Response.Config = sensor->sens.hdallas->scratchpad.ConfigRegister;
MB_DATA.InRegs.Response.ROM[0] = __REV16((sensor->sens.sensROM) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[1] = __REV16((sensor->sens.sensROM >> 16) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[2] = __REV16((sensor->sens.sensROM >> 32) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[3] = __REV16((sensor->sens.sensROM >> 48) & 0xFFFF);
MB_DATA.InRegs.Response.Status = status;
break;
// error deinit
case STATUS_ERR_SCAN:
// fill with sensor data
MB_DATA.InRegs.Response.Location = 0;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = __REV16((sensor->sens.sensROM) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[1] = __REV16((sensor->sens.sensROM >> 16) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[2] = __REV16((sensor->sens.sensROM >> 32) & 0xFFFF);
MB_DATA.InRegs.Response.ROM[3] = __REV16((sensor->sens.sensROM >> 48) & 0xFFFF);
MB_DATA.InRegs.Response.Status = status;
break;
default:
MB_DATA.InRegs.Response.Location = 0;
MB_DATA.InRegs.Response.Config = 0;
MB_DATA.InRegs.Response.ROM[0] = 0;
MB_DATA.InRegs.Response.ROM[1] = 0;
MB_DATA.InRegs.Response.ROM[2] = 0;
MB_DATA.InRegs.Response.ROM[3] = 0;
MB_DATA.InRegs.Response.Status = 0;
break;
}
}
void PYModule_CheckModuleLosted(PCHSens_ModuleTypeDef *module, uint8_t *losted_flag)
{
if(module->sens1.not_found)
*losted_flag |= 1;
if(module->sens2.not_found)
*losted_flag |= 1;
if(module->sens3.not_found)
*losted_flag |= 1;
if(module->sens4.not_found)
*losted_flag |= 1;
}
void PYModule_StoreModuleToModbus(PCHSens_ModuleTypeDef *module)
{
uint8_t mb_location;
uint8_t pch_numb = (module->refLocation.param.PCHdig1 - 1)*3 + (module->refLocation.param.PCHdig2 - 1);
pch_numb *= 4;
mb_location = pch_numb + module->sens1.Location.param.Location;
if (mb_location < DS18B20_DEVICE_AMOUNT)
MB_DATA.InRegs.SensTemperature[mb_location] = module->sens1.sens.temperature*100;
mb_location = pch_numb + module->sens2.Location.param.Location;
if (mb_location < DS18B20_DEVICE_AMOUNT)
MB_DATA.InRegs.SensTemperature[mb_location] = module->sens2.sens.temperature*100;
mb_location = pch_numb + module->sens3.Location.param.Location;
if (mb_location < DS18B20_DEVICE_AMOUNT)
MB_DATA.InRegs.SensTemperature[mb_location] = module->sens3.sens.temperature*100;
mb_location = pch_numb + module->sens4.Location.param.Location;
if (mb_location < DS18B20_DEVICE_AMOUNT)
MB_DATA.InRegs.SensTemperature[mb_location] = module->sens4.sens.temperature*100;
}

37
py_project/Core/PY32Module/PY32module_main.h Normal file
View File

@@ -0,0 +1,37 @@
/**
******************************************************************************
* @file pch_sensors.h
* @brief Работа с датчиками температуры DS18B20 в ПЧ
******************************************************************************
*****************************************************************************/
#ifndef MODULE_MAIN_H
#define MODULE_MAIN_H
/* Includes -----------------------------------------------------------------*/
#include "main.h"
#include "pch_sensors.h"
#include "modbus_data.h"
/* Declarations and definitions ---------------------------------------------*/
typedef enum
{
STATUS_OK = 0x01,
STATUS_SCAN_END = 0x11,
STATUS_ERR_READ_LOCATION = 0xF0,
STATUS_ERR_READ_ROM = 0x0F,
STATUS_ERR_INIT = 0xAA,
STATUS_ERR_DEINIT = 0x55,
STATUS_ERR_SCAN = 0xBB,
}Sensor_ResponseStatusTypeDef;
/* Functions ---------------------------------------------------------------*/
void PYModule_main(void);
void PYModule_FirstInit(void);
void PYModule_ScanSensor(PCHSens_DallasBusHandle *hbus);
void PYModule_ReadSensor(DALLAS_HandleTypeDef *hdallas, PCHSens_TypeDef *pchsens);
void PYModule_InitSensor(PCHSens_TypeDef *pchsens);
void PYModule_DeInitSensor(PCHSens_TypeDef *pchsens);
void PYModule_CheckLosted(PCHSens_TypeDef *pchsens);
void PYModule_StoreModbus(PCHSens_TypeDef *pchsens);
#endif // #ifndef MODULE_MAIN_H

Some files were not shown because too many files have changed in this diff Show More