Razvalyaev/UPP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Рефакторинг и доработки

Browse Source
This commit is contained in:
Razvalyaev 2025-11-18 14:16:20 +03:00
parent edac877616
commit 6882d6d014
21 changed files with 421 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

89
MATLAB/MCU_STM32_Matlab/Drivers/STM32_SIMULINK/stm32_matlab_tim.c
View File

@ -18,24 +18,33 @@ void TIM_Simulation(TIM_TypeDef *TIMx, struct TIM_Sim *TIMS)
// Выбор режима работы таймера // Выбор режима работы таймера
switch (TIMx->SMCR & TIM_SMCR_SMS) // TIMER MODE switch (TIMx->SMCR & TIM_SMCR_SMS) // TIMER MODE
{ {
// обычный счет // обычный счет
case(TIM_SLAVEMODE_DISABLE):// NORMAL MODE counting case(TIM_SLAVEMODE_DISABLE):// NORMAL MODE counting
TIMx_Count(TIMx, TIMS); TIMx_Count(TIMx, TIMS);
Channels_Simulation(TIMx, TIMS); // CaptureCompare and PWM channels simulation Channels_Simulation(TIMx, TIMS); // CaptureCompare and PWM channels simulation
Write_TRGO(TIMx, TIMS); Write_TRGO(TIMx, TIMS);
break; break;
// включение слейв таймера по ивенту // включение слейв таймера по ивенту
case(TIM_SLAVEMODE_TRIGGER): // SLAVE MODE: TRIGGER MODE case(TIM_SLAVEMODE_TRIGGER): // SLAVE MODE: TRIGGER MODE
Slave_Mode_Check_Source(TIMx, TIMS); Slave_Mode_Check_Source(TIMx, TIMS);
TIMx_Count(TIMx, TIMS); TIMx_Count(TIMx, TIMS);
Channels_Simulation(TIMx, TIMS); // CaptureCompare and PWM channels simulation Channels_Simulation(TIMx, TIMS); // CaptureCompare and PWM channels simulation
Write_TRGO(TIMx, TIMS); Write_TRGO(TIMx, TIMS);
break; break;
} }
// EGR
TIM_EGR_Simulation(TIMx);
// Прерывание если какое-то выставлено
if (TIMx->SR & (TIM_SR_UIF | TIM_SR_CC1IF | TIM_SR_CC2IF | TIM_SR_CC3IF | TIM_SR_CC4IF))
{
TIM_Call_IRQHandller(TIMx); // call HANDLER
}
} }
/* Счет таймера за один такт */ /* Счет таймера за один такт */
@ -68,7 +77,9 @@ void Overflow_Check(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS)
if(TIMS->tx_step > TIMS->RELOAD) if(TIMS->tx_step > TIMS->RELOAD)
TIMS->tx_cnt = 0; TIMS->tx_cnt = 0;
TIM_Call_IRQHandller(TIMx); // call HANDLER if (TIMx->DIER & TIM_DIER_UIE) {
TIMx->SR |= TIM_SR_UIF;
}
} }
} }
} }
@ -134,12 +145,10 @@ void CC_PWM_Ch1_Simulation(TIM_TypeDef *TIMx, struct TIM_Sim *TIMS)
if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR1) && (TIMS->tx_cnt >= TIMx->CCR1)) if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR1) && (TIMS->tx_cnt >= TIMx->CCR1))
{ {
TIMx->SR |= TIM_SR_CC1IF; TIMx->SR |= TIM_SR_CC1IF;
TIM_Call_IRQHandller(TIMx);
} }
else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR1) && (TIMS->tx_cnt <= TIMx->CCR1)) else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR1) && (TIMS->tx_cnt <= TIMx->CCR1))
{ {
TIMx->SR |= TIM_SR_CC1IF; TIMx->SR |= TIM_SR_CC1IF;
TIM_Call_IRQHandller(TIMx);
} }
} }
} }
@ -188,12 +197,10 @@ void CC_PWM_Ch2_Simulation(TIM_TypeDef *TIMx, struct TIM_Sim *TIMS)
if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR2) && (TIMS->tx_cnt >= TIMx->CCR2)) if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR2) && (TIMS->tx_cnt >= TIMx->CCR2))
{ {
TIMx->SR |= TIM_SR_CC2IF; TIMx->SR |= TIM_SR_CC2IF;
TIM_Call_IRQHandller(TIMx);
} }
else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR2) && (TIMS->tx_cnt <= TIMx->CCR2)) else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR2) && (TIMS->tx_cnt <= TIMx->CCR2))
{ {
TIMx->SR |= TIM_SR_CC2IF; TIMx->SR |= TIM_SR_CC2IF;
TIM_Call_IRQHandller(TIMx);
} }
} }
} }
@ -242,12 +249,10 @@ void CC_PWM_Ch3_Simulation(TIM_TypeDef *TIMx, struct TIM_Sim *TIMS)
if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR3) && (TIMS->tx_cnt >= TIMx->CCR3)) if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR3) && (TIMS->tx_cnt >= TIMx->CCR3))
{ {
TIMx->SR |= TIM_SR_CC3IF; TIMx->SR |= TIM_SR_CC3IF;
TIM_Call_IRQHandller(TIMx);
} }
else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR3) && (TIMS->tx_cnt <= TIMx->CCR3)) else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR3) && (TIMS->tx_cnt <= TIMx->CCR3))
{ {
TIMx->SR |= TIM_SR_CC3IF; TIMx->SR |= TIM_SR_CC3IF;
TIM_Call_IRQHandller(TIMx);
} }
} }
} }
@ -296,12 +301,10 @@ void CC_PWM_Ch4_Simulation(TIM_TypeDef *TIMx, struct TIM_Sim *TIMS)
if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR4) && (TIMS->tx_cnt >= TIMx->CCR4)) if (((TIMS->tx_cnt - TIMS->tx_step) < TIMx->CCR4) && (TIMS->tx_cnt >= TIMx->CCR4))
{ {
TIMx->SR |= TIM_SR_CC4IF; TIMx->SR |= TIM_SR_CC4IF;
TIM_Call_IRQHandller(TIMx);
} }
else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR4) && (TIMS->tx_cnt <= TIMx->CCR4)) else if (((TIMS->tx_cnt - TIMS->tx_step) > TIMx->CCR4) && (TIMS->tx_cnt <= TIMx->CCR4))
{ {
TIMx->SR |= TIM_SR_CC4IF; TIMx->SR |= TIM_SR_CC4IF;
TIM_Call_IRQHandller(TIMx);
} }
} }
} }
@ -456,6 +459,42 @@ void Write_TRGO(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS)
//--------------------MISC (temporary) FUNCTIONS--------------------// //--------------------MISC (temporary) FUNCTIONS--------------------//
void TIM_EGR_Simulation(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS)
{
// Update
if (TIMx->EGR & TIM_EGR_UG) {
TIMx->EGR &= ~TIM_EGR_UG;
if (TIMx->DIER & TIM_DIER_UIE) {
TIMx->SR |= TIM_SR_UIF;
}
}
// Channels
if (TIMx->EGR & TIM_EGR_CC1G) {
TIMx->EGR &= ~TIM_EGR_CC1G;
if (TIMx->DIER & TIM_IT_CC1) {
TIMx->SR |= TIM_SR_CC1IF;
}
}
if (TIMx->EGR & TIM_EGR_CC2G) {
TIMx->EGR &= ~TIM_EGR_CC2G;
if (TIMx->DIER & TIM_IT_CC2) {
TIMx->SR |= TIM_SR_CC2IF;
}
}
if (TIMx->EGR & TIM_EGR_CC3G) {
TIMx->EGR &= ~TIM_EGR_CC3G;
if (TIMx->DIER & TIM_IT_CC3) {
TIMx->SR |= TIM_SR_CC3IF;
}
}
if (TIMx->EGR & TIM_EGR_CC4G) {
TIMx->EGR &= ~TIM_EGR_CC4G;
if (TIMx->DIER & TIM_IT_CC4) {
TIMx->SR |= TIM_SR_CC4IF;
}
}
}
/* Определение источника для запуска таймера в SLAVE MODE */ /* Определение источника для запуска таймера в SLAVE MODE */
void Slave_Mode_Check_Source(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS) void Slave_Mode_Check_Source(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS)
{ {

2
MATLAB/MCU_STM32_Matlab/Drivers/STM32_SIMULINK/stm32_matlab_tim.h
View File

@ -108,6 +108,8 @@ void Write_TRGO(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS);
//--------------------MISC (temporary) FUNCTIONS--------------------// //--------------------MISC (temporary) FUNCTIONS--------------------//
void TIM_Call_IRQHandller(TIM_TypeDef* TIMx);
/* Определение источника для запуска таймера в SLAVE MODE */ /* Определение источника для запуска таймера в SLAVE MODE */
void Slave_Mode_Check_Source(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS); void Slave_Mode_Check_Source(TIM_TypeDef* TIMx, struct TIM_Sim* TIMS);
//------------------------------------------------------------------// //------------------------------------------------------------------//

BIN
MATLAB/upp_r2023.slx
View File

Binary file not shown.

2
UPP/Core/Configs/modbus_data.h
View File

@ -52,7 +52,7 @@
#define _MODBUS_DATA_H_ #define _MODBUS_DATA_H_
#include "upp_defs.h" #include "upp_defs.h"
#include "upp_control.h" #include "upp_params.h"
#include "stdint.h" #include "stdint.h"

9
UPP/Core/Configs/upp_config.h
View File

@ -97,6 +97,12 @@
* @brief Параметры устанавливаемые на этапе компиляции. Без перепрошивки их не поменять * @brief Параметры устанавливаемые на этапе компиляции. Без перепрошивки их не поменять
* @{ * @{
*/ */
//#if defined(STM32F417xx)
//#endif
/* Периоды вызова всякого */ /* Периоды вызова всякого */
#define PM_ADC_PERIOD_US 10 ///< Период опроса АЦП в мкс #define PM_ADC_PERIOD_US 10 ///< Период опроса АЦП в мкс
#define PM_SLOW_PERIOD_CNT 50 ///< Период обновления медленных расчетов тиках @ref PM_ADC_PERIOD_US #define PM_SLOW_PERIOD_CNT 50 ///< Период обновления медленных расчетов тиках @ref PM_ADC_PERIOD_US
@ -109,4 +115,7 @@
#define PWM_TIM3_FREQ_MHZ 90 ///< Частота тиков таймера ШИМ (5-6 каналы) #define PWM_TIM3_FREQ_MHZ 90 ///< Частота тиков таймера ШИМ (5-6 каналы)
#define ANGLE_TIM2_FREQ_MHZ 90 ///< Частота тиков таймера отсчета угла открытия тиристоров #define ANGLE_TIM2_FREQ_MHZ 90 ///< Частота тиков таймера отсчета угла открытия тиристоров
/** //UPP_COMPILED_PARAMS
* @}
*/
#endif //_UPP_CONFIG_H_ #endif //_UPP_CONFIG_H_

3
UPP/Core/Configs/upp_defs.h
View File

@ -151,6 +151,9 @@ typedef struct {
#define PM_SLOW_PERIOD_US (PM_ADC_PERIOD_US*PM_SLOW_PERIOD_CNT) #define PM_SLOW_PERIOD_US (PM_ADC_PERIOD_US*PM_SLOW_PERIOD_CNT)
#define ANGLE_PERIOD_MS(_freq_) (((float)1/(_freq_*2))*1000) #define ANGLE_PERIOD_MS(_freq_) (((float)1/(_freq_*2))*1000)
#define PARAM_INTERNAL MB_INTERNAL.param
#define PARAM_PUI MB_DATA.HoldRegs.pui_params
/** /**
* @brief Состояния полуволны * @brief Состояния полуволны
*/ */

28
UPP/Core/PowerMonitor/power_monitor.c
View File

@ -32,32 +32,32 @@ HAL_StatusTypeDef PowerMonitor_Init(PowerMonitor_t *hpm)
/* Инициализация каналов АЦП */ /* Инициализация каналов АЦП */
if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_UBA, if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_UBA,
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_UBA], PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_UBA],
to_float(MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_UBA], 10), to_float(PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_UBA], 10),
4095) != HAL_OK) 4095) != HAL_OK)
return HAL_ERROR; return HAL_ERROR;
if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_UAC, if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_UAC,
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_UAC], PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_UAC],
to_float(MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_UAC], 10), to_float(PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_UAC], 10),
4095) != HAL_OK) 4095) != HAL_OK)
return HAL_ERROR; return HAL_ERROR;
if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_IC, if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_IC,
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_IC], PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_IC],
to_float(MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_IC], 10), to_float(PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_IC], 10),
4095) != HAL_OK) 4095) != HAL_OK)
return HAL_ERROR; return HAL_ERROR;
if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_IA, if(ADC_ConfigChannel(&hpm->adc, ADC_CHANNEL_IA,
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_IA], PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_IA],
to_float(MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_IA], 10), to_float(PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_IA], 10),
4095) != HAL_OK) 4095) != HAL_OK)
return HAL_ERROR; return HAL_ERROR;
/* Инициализация алгоритма перехода через ноль */ /* Инициализация алгоритма перехода через ноль */
if(ZC_Init(&hpm->zc, 3, to_float(MB_INTERNAL.param.zc.Hysteresis, 100), MB_INTERNAL.param.zc.DebouneCouner) != HAL_OK) if(ZC_Init(&hpm->zc, 3, to_float(PARAM_INTERNAL.zc.Hysteresis, 100), PARAM_INTERNAL.zc.DebouneCouner) != HAL_OK)
return HAL_ERROR; return HAL_ERROR;
/* Инициализация каналов алгоритма перехода через ноль */ /* Инициализация каналов алгоритма перехода через ноль */
@ -72,7 +72,7 @@ HAL_StatusTypeDef PowerMonitor_Init(PowerMonitor_t *hpm)
/* Инициализация экпоненциального фильтра медленного алга */ /* Инициализация экпоненциального фильтра медленного алга */
for(int i = 0; i < EXP_ALL; i++) for(int i = 0; i < EXP_ALL; i++)
{ {
if(FilterExp_Init(&hpm->exp[i], to_float(MB_INTERNAL.param.pm.mean_alpha,65535))) if(FilterExp_Init(&hpm->exp[i], to_float(PARAM_INTERNAL.pm.mean_alpha,65535)))
return HAL_ERROR; return HAL_ERROR;
Filter_Start(&hpm->exp[i]); Filter_Start(&hpm->exp[i]);
} }
@ -195,8 +195,8 @@ void PowerMonitor_FastCalc(PowerMonitor_t *hpm)
/* Преобразуем в относительные единицы (о.е.) */ /* Преобразуем в относительные единицы (о.е.) */
for(int i = 0; i < 3; i++) for(int i = 0; i < 3; i++)
{ {
meas->fast.U[i] = 10*meas->real.U[i]/MB_INTERNAL.param.nominal.U; meas->fast.U[i] = 10*meas->real.U[i]/PARAM_INTERNAL.nominal.U;
meas->fast.I[i] = 10*meas->real.I[i]/MB_INTERNAL.param.nominal.I; meas->fast.I[i] = 10*meas->real.I[i]/PARAM_INTERNAL.nominal.I;
} }
/* Ищем переход через ноль */ /* Ищем переход через ноль */
@ -250,8 +250,8 @@ int PowerMonitor_Protect(PowerMonitor_t *hpm, uint8_t Running)
return 1; return 1;
PowerMonitor_Measured_t *measure = &hpm->measured; PowerMonitor_Measured_t *measure = &hpm->measured;
UPP_PUI_Params_t *protect = &MB_DATA.HoldRegs.pui_params; UPP_PUI_Params_t *protect = &PARAM_PUI;
UPP_ParamsNominal_t *nominal = &MB_INTERNAL.param.nominal; UPP_ParamsNominal_t *nominal = &PARAM_INTERNAL.nominal;
/*=============== ЗАЩИТЫ ПО НАПРЯЖЕНИЮ ==================*/ /*=============== ЗАЩИТЫ ПО НАПРЯЖЕНИЮ ==================*/
hpm->f.isU = Protect_Voltages(measure, protect, nominal); hpm->f.isU = Protect_Voltages(measure, protect, nominal);

2
UPP/Core/PowerMonitor/power_monitor.h
View File

@ -92,11 +92,13 @@ typedef struct
}PowerMonitor_t; }PowerMonitor_t;
extern PowerMonitor_t pm; extern PowerMonitor_t pm;
// ====== ИНИЦИАЛИЗАЦИЯ ==========
/* Инициализация мониторинга сети */ /* Инициализация мониторинга сети */
HAL_StatusTypeDef PowerMonitor_Init(PowerMonitor_t *hpm); HAL_StatusTypeDef PowerMonitor_Init(PowerMonitor_t *hpm);
/* Запустить мониторинг сети */ /* Запустить мониторинг сети */
HAL_StatusTypeDef PowerMonitor_Start(PowerMonitor_t *hpm); HAL_StatusTypeDef PowerMonitor_Start(PowerMonitor_t *hpm);
// ====== РАСЧЕТЫ ==========
/* Медленные расчеты АЦП */ /* Медленные расчеты АЦП */
void PowerMonitor_SlowCalc(PowerMonitor_t *hpm); void PowerMonitor_SlowCalc(PowerMonitor_t *hpm);
/* Считывание АЦП и быстрые расчеты */ /* Считывание АЦП и быстрые расчеты */

10
UPP/Core/PowerMonitor/power_protect.c
View File

@ -133,12 +133,12 @@ int Protect_Currents(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect
void Protect_Misc(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect, UPP_ParamsNominal_t *nominal) void Protect_Misc(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect, UPP_ParamsNominal_t *nominal)
{ {
/* Переводим внутренние уставки в удобный вид */ /* Переводим внутренние уставки в удобный вид */
float lFnom = to_float(MB_INTERNAL.param.nominal.F, 100); float lFnom = to_float(PARAM_INTERNAL.nominal.F, 100);
float lFmin = lFnom - lFnom*to_float(MB_INTERNAL.param.nominal.F_deviation_minus, 100); float lFmin = lFnom - lFnom*to_float(PARAM_INTERNAL.nominal.F_deviation_minus, 100);
float lFmax = lFnom + lFnom*to_float(MB_INTERNAL.param.nominal.F_deviation_plus, 100); float lFmax = lFnom + lFnom*to_float(PARAM_INTERNAL.nominal.F_deviation_plus, 100);
float lTwarn = to_float(MB_INTERNAL.param.setpoints.TemperatureWarn, 100); float lTwarn = to_float(PARAM_INTERNAL.setpoints.TemperatureWarn, 100);
float lTerr = to_float(MB_INTERNAL.param.setpoints.TemperatureWarn, 100); float lTerr = to_float(PARAM_INTERNAL.setpoints.TemperatureWarn, 100);
/*=============== ЗАЩИТЫ ПО ЧАСТОТЕ ==================*/ /*=============== ЗАЩИТЫ ПО ЧАСТОТЕ ==================*/

16
UPP/Core/PowerMonitor/zero_cross.h
View File

@ -124,32 +124,36 @@ typedef struct {
uint32_t LastTick; ///< Послднее время вызова uint32_t LastTick; ///< Послднее время вызова
} ZeroCross_Handle_t; } ZeroCross_Handle_t;
// ====== ИНИЦИАЛИЗАЦИЯ ==========
/* Инициализация детектора нуля с индивидуальными настройками */ /* Инициализация детектора нуля с индивидуальными настройками */
HAL_StatusTypeDef ZC_Init(ZeroCross_Handle_t *zc, uint8_t num_channels, HAL_StatusTypeDef ZC_Init(ZeroCross_Handle_t *zc, uint8_t num_channels,
float hysteresis, uint16_t debounce_samples); float hysteresis, uint16_t debounce_samples);
/* Настройка канала детектора */ /* Настройка канала детектора */
HAL_StatusTypeDef ZC_ConfigChannel(ZeroCross_Handle_t *zc, uint8_t channel, HAL_StatusTypeDef ZC_ConfigChannel(ZeroCross_Handle_t *zc, uint8_t channel,
ZC_EdgeType_t edgeType); ZC_EdgeType_t edgeType);
// ====== УПРАВЛЕНИЕ ==========
/* Включение/выключение мониторинга */
void ZC_EnableMonitoring(ZeroCross_Handle_t *zc, uint8_t enable);
/* Сброс статистики канала */
void ZC_Reset(ZeroCross_Handle_t *zc, uint8_t channel);
// ====== РАСЧЕТЫ ==========
/* Обработка значения отдельного канала */ /* Обработка значения отдельного канала */
void ZC_ProcessChannel(ZeroCross_Handle_t *zc, uint8_t channel, float value, void ZC_ProcessChannel(ZeroCross_Handle_t *zc, uint8_t channel, float value,
uint32_t timestamp); uint32_t timestamp);
/* Пакетная обработка всех каналов */ /* Пакетная обработка всех каналов */
void ZC_ProcessAllChannels(ZeroCross_Handle_t *zc, float *values, void ZC_ProcessAllChannels(ZeroCross_Handle_t *zc, float *values,
uint32_t timestamp); uint32_t timestamp);
// ====== API ==========
/* Полученить флаг - переход произошел. */ /* Полученить флаг - переход произошел. */
int ZC_isOccurred(ZeroCross_Handle_t *zc, uint8_t channel); int ZC_isOccurred(ZeroCross_Handle_t *zc, uint8_t channel);
/* Получение частоты сигнала */ /* Получение частоты сигнала */
float ZC_GetFrequency(ZeroCross_Handle_t *zc, uint8_t channel); float ZC_GetFrequency(ZeroCross_Handle_t *zc, uint8_t channel);
/* Получение полуволны (после последнего zero-cross) */ /* Получение полуволны (после последнего zero-cross) */
UPP_HalfWave_t ZC_GetHalfWave(ZeroCross_Handle_t *zc, uint8_t channel); UPP_HalfWave_t ZC_GetHalfWave(ZeroCross_Handle_t *zc, uint8_t channel);
/* Включение/выключение мониторинга */
void ZC_EnableMonitoring(ZeroCross_Handle_t *zc, uint8_t enable);
/* Сброс статистики канала */
void ZC_Reset(ZeroCross_Handle_t *zc, uint8_t channel);
#endif /* _ZERO_CROSS_H_ */ #endif /* _ZERO_CROSS_H_ */

311
UPP/Core/UPP/angle_control.c
View File

@ -22,9 +22,9 @@ HAL_StatusTypeDef Angle_Init(Angle_Handle_t *hangle)
hangle->htim = &angletim; hangle->htim = &angletim;
// Инициализация ПИД // Инициализация ПИД
float kp = to_float(MB_INTERNAL.param.angle.PID_Kp, 10000); float kp = to_float(PARAM_INTERNAL.angle.PID_Kp, 10000);
float ki = to_float(MB_INTERNAL.param.angle.PID_Ki, 10000); float ki = to_float(PARAM_INTERNAL.angle.PID_Ki, 10000);
float kd = to_float(MB_INTERNAL.param.angle.PID_Kd, 10000); float kd = to_float(PARAM_INTERNAL.angle.PID_Kd, 10000);
Angle_PID_Init(hangle, kp, ki, kd); Angle_PID_Init(hangle, kp, ki, kd);
// Инициализация каналов // Инициализация каналов
@ -39,8 +39,8 @@ HAL_StatusTypeDef Angle_Init(Angle_Handle_t *hangle)
// Инициализация углов // Инициализация углов
float angle_max = to_float(MB_INTERNAL.param.angle.Angle_Max, 65535); float angle_max = to_float(PARAM_INTERNAL.angle.Angle_Max, 65535);
float angle_min = to_float(MB_INTERNAL.param.angle.Angle_Min, 65535); float angle_min = to_float(PARAM_INTERNAL.angle.Angle_Min, 65535);
hangle->f.Initialized = 1; hangle->f.Initialized = 1;
@ -48,50 +48,6 @@ HAL_StatusTypeDef Angle_Init(Angle_Handle_t *hangle)
} }
/**
* @brief Управление углом через ПИД регулятор.
* @param hangle Указатель на таймер
* @param setpoint Уставка куда регулировать
* @param measurement Измеренные регулируемые величины
*/
void Angle_PID(Angle_Handle_t *hangle, float setpoint, float measurement)
{
if(assert_upp(hangle))
return;
/* Ошибка регулирования = уставка - измеренное */
float err = setpoint - measurement;
/* ПИД регулирование */
float reverse_angle = arm_pid_f32(&hangle->pid, err); // 0 - открыть максимально поздно, 1 - открыть макситмально рано
/* Ограничиваем диапазон и сохраняем в alpha */
float angle = hangle->Config.AngleMax - reverse_angle;
if (angle > hangle->Config.AngleMax) angle = hangle->Config.AngleMax;
if(angle < hangle->Config.AngleMin) angle = hangle->Config.AngleMin;
Angle_SetAngle(hangle, angle);
}
/**
* @brief Сброс ПИД регулятора.
* @param hangle Указатель на таймер
*/
void Angle_PID_Reset(Angle_Handle_t *hangle)
{
if(assert_upp(hangle))
return;
/* Вычисляем выход PID */
arm_pid_reset_f32(&hangle->pid);
Angle_SetAngle(hangle, hangle->Config.AngleLimit);
Angle_Reset(hangle, UPP_PHASE_A);
Angle_Reset(hangle, UPP_PHASE_B);
Angle_Reset(hangle, UPP_PHASE_C);
}
/** /**
* @brief Инициализация ПИД регулятора. * @brief Инициализация ПИД регулятора.
* @param hangle Указатель на таймер * @param hangle Указатель на таймер
@ -109,118 +65,89 @@ void Angle_PID_Init(Angle_Handle_t *hangle, float kp, float ki, float kd)
} }
/** /**
* @brief Инициализация углов открытия. * @brief Управление углом через ПИД регулятор.
* @param hangle Указатель на таймер * @param hangle Указатель на таймер
* @param AngleLimit Лимит AngleMax, рассчитывается от параметров ШИМ * @param setpoint Уставка куда регулировать
* @param AngleMin Минимально возможный угол открытия * @param measurement Измеренные регулируемые величины
* @param AngleMax Максимально возможный угол открытия
* @return HAL Status.
*/ */
HAL_StatusTypeDef Angle_SetRange(Angle_Handle_t *hangle, float AngleMin, float AngleMax) void Angle_PID(Angle_Handle_t *hangle, float setpoint, float measurement)
{ {
if(assert_upp(hangle)) if(assert_upp(hangle))
return HAL_ERROR; return;
if(hangle->f.Running)
return HAL_BUSY; /* Ошибка регулирования = уставка - измеренное */
if(AngleMax < 0 || AngleMax > 1) float err = setpoint - measurement;
return HAL_ERROR;
if(AngleMin < 0 || AngleMin > 1)
return HAL_ERROR;
if(AngleMax > hangle->Config.AngleLimit) /* ПИД регулирование */
AngleMax = hangle->Config.AngleLimit; float open_control = arm_pid_f32(&hangle->pid, err); // 0 - открыть максимально поздно, 1 - открыть макситмально рано
if(AngleMin > hangle->Config.AngleLimit)
AngleMin = hangle->Config.AngleLimit; /* Ограничиваем диапазон */
if (open_control > 1) open_control = 1;
if(AngleMin >= AngleMax) if(open_control < 0) open_control = 0;
return HAL_ERROR;
/* Выставляем заданный уровень открытия */
hangle->Config.AngleMax = AngleMax; Angle_SetAngle(hangle, open_control);
hangle->Config.AngleMin = AngleMin;
return HAL_OK;
} }
/** /**
* @brief Выставление текущего угла открытия тиристоров. * @brief Сброс ПИД регулятора.
* @param hangle Указатель на таймер * @param hangle Указатель на таймер
* @param AngleLimit Лимит AngleMax, рассчитывается от параметров ШИМ
* @param AngleMin Минимально возможный угол открытия
* @param AngleMax Максимально возможный угол открытия
* @return HAL Status.
*/ */
HAL_StatusTypeDef Angle_SetAngle(Angle_Handle_t *hangle, float Angle) void Angle_PID_Reset(Angle_Handle_t *hangle)
{ {
if(assert_upp(hangle)) if(assert_upp(hangle))
return HAL_ERROR; return;
if(Angle > hangle->Config.AngleLimit) /* Вычисляем выход PID */
Angle = hangle->Config.AngleLimit; arm_pid_reset_f32(&hangle->pid);
hangle->alpha = Angle; Angle_SetAngle(hangle, 0);
Angle_Reset(hangle, UPP_PHASE_A);
return HAL_OK; Angle_Reset(hangle, UPP_PHASE_B);
Angle_Reset(hangle, UPP_PHASE_C);
} }
/** /**
* @brief Инициализация предельного угла открытия. * @brief Выставление степени открытия тиристоров.
* @param hangle Указатель на таймер * @param hangle Указатель на таймер
* @param AngleLimit Лимит AngleMax, рассчитывается от параметров ШИМ * @param OpenLevel Насколько открыть тиристор:
* @param AngleMin Минимально возможный угол открытия - 0 - полностбю закрыт,
* @param AngleMax Максимально возможный угол открытия - 1 - полностью открыт
* @return HAL Status. * @return HAL Status.
*/ */
HAL_StatusTypeDef Angle_SetLimit(Angle_Handle_t *hangle, float AngleLimit) HAL_StatusTypeDef Angle_SetAngle(Angle_Handle_t *hangle, float OpenLevel)
{ {
if(assert_upp(hangle)) if(assert_upp(hangle))
return HAL_ERROR; return HAL_ERROR;
if(hangle->f.Running)
return HAL_BUSY; /* Приводим уровень открытия к косинусу [-1:1]*/
float OpenLevelForCos = (OpenLevel*2)-1;
float alpha_rad = acosf(OpenLevelForCos); // угол в радианах
float alpha = alpha_rad/PI; // время открытие в процентах от периода - когда открыть
if(alpha > hangle->Config.AngleMax)
alpha = hangle->Config.AngleMax;
if(alpha < hangle->Config.AngleMin)
alpha = hangle->Config.AngleMin;
// if(alpha > hangle->Config.PeriodLimit)
// {
// alpha = hangle->Config.PeriodLimit;
// }
// float alpha_degree = alpha*180;// угол в градусах
// hangle->alpha_degree = alpha_degree;
hangle->alpha = alpha;
if(AngleLimit < 0 || AngleLimit > 1)
return HAL_ERROR;
hangle->Config.AngleLimit = AngleLimit;
return HAL_OK; return HAL_OK;
} }
/**
* @brief Хендл таймера для рассчета угла открытия.
* @param hangle Указатель на таймер
* @return HAL Status.
*/
UPP_Phase_t Angle_Handle(Angle_Handle_t *hangle)
{
if(assert_upp(hangle))
return UPP_PHASE_UNKNOWN;
switch(hangle->htim->Channel)
{
case HAL_TIM_ACTIVE_CHANNEL_1:
return UPP_PHASE_A;
break;
case HAL_TIM_ACTIVE_CHANNEL_2:
return UPP_PHASE_B;
break;
case HAL_TIM_ACTIVE_CHANNEL_3:
return UPP_PHASE_C;
break;
default:
return UPP_PHASE_UNKNOWN;
break;
}
return UPP_PHASE_UNKNOWN;
}
/** /**
* @brief Установка угла открытия в таймер. * @brief Запуск отсчета угла открытия.
* @param hangle Указатель на таймер * @param hangle Указатель на таймер
* @param Phase Для какой фазы надо установить угол открытия * @param Phase Для какой фазы надо установить угол открытия
* @return HAL Status. * @return HAL Status.
@ -235,6 +162,7 @@ HAL_StatusTypeDef Angle_Start(Angle_Handle_t *hangle, UPP_Phase_t Phase, float P
{ {
return HAL_ERROR; return HAL_ERROR;
} }
// Дополнительно проверяем на соответствие альфа диапазону
if(hangle->alpha > hangle->Config.AngleMax) if(hangle->alpha > hangle->Config.AngleMax)
{ {
hangle->alpha = hangle->Config.AngleMax; hangle->alpha = hangle->Config.AngleMax;
@ -244,25 +172,47 @@ HAL_StatusTypeDef Angle_Start(Angle_Handle_t *hangle, UPP_Phase_t Phase, float P
hangle->alpha = hangle->Config.AngleMin; hangle->alpha = hangle->Config.AngleMin;
} }
// сколько тиков надо выждать для угла
uint32_t timer_ticks = TIM_MillisToTick(PeriodMs*hangle->alpha, ANGLE_TIM2_FREQ_MHZ); uint32_t timer_ticks = TIM_MillisToTick(PeriodMs*hangle->alpha, ANGLE_TIM2_FREQ_MHZ);
// сколько тиков будет в таймере когда угол отсчитается (пойдет в CCRx регистр)
uint32_t ccr_ticks = __HAL_TIM_GET_COUNTER(hangle->htim) + timer_ticks; uint32_t ccr_ticks = __HAL_TIM_GET_COUNTER(hangle->htim) + timer_ticks;
// Выставялем
switch(Phase) switch(Phase)
{ {
case UPP_PHASE_A: case UPP_PHASE_A:
__HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_1, ccr_ticks); __HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_1, ccr_ticks);
// Если слишком маленький timer_tick и счетчик уже перевалил за ccr, но не сгенерил прервыание:
if (__HAL_TIM_GET_COMPARE(hangle->htim, ANGLE_CHANNEL_1) <= __HAL_TIM_GET_COUNTER(hangle->htim))
{
// включаем прерывание вручную
HAL_TIM_GenerateEvent(hangle->htim, TIM_EVENTSOURCE_CC1);
}
__HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC1); __HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC1);
hangle->f.Running++; hangle->f.Running++;
break; break;
case UPP_PHASE_B: case UPP_PHASE_B:
__HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_2, ccr_ticks); __HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_2, ccr_ticks);
// Если слишком маленький timer_tick и счетчик уже перевалил за ccr, но не сгенерил прервыание:
if (__HAL_TIM_GET_COMPARE(hangle->htim, ANGLE_CHANNEL_2) <= __HAL_TIM_GET_COUNTER(hangle->htim))
{
// включаем прерывание вручную
HAL_TIM_GenerateEvent(hangle->htim, TIM_EVENTSOURCE_CC2);
}
__HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC2); __HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC2);
hangle->f.Running++; hangle->f.Running++;
break; break;
case UPP_PHASE_C: case UPP_PHASE_C:
__HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_3, ccr_ticks); __HAL_TIM_SET_COMPARE(hangle->htim, ANGLE_CHANNEL_3, ccr_ticks);
// Если слишком маленький timer_tick и счетчик уже перевалил за ccr, но не сгенерил прервыание:
if (__HAL_TIM_GET_COMPARE(hangle->htim, ANGLE_CHANNEL_3) <= __HAL_TIM_GET_COUNTER(hangle->htim))
{
// включаем прерывание вручную
HAL_TIM_GenerateEvent(hangle->htim, TIM_EVENTSOURCE_CC3);
}
__HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC3); __HAL_TIM_ENABLE_IT(hangle->htim, TIM_IT_CC3);
hangle->f.Running++; hangle->f.Running++;
break; break;
@ -319,4 +269,99 @@ HAL_StatusTypeDef Angle_Reset(Angle_Handle_t *hangle, UPP_Phase_t Phase)
break; break;
} }
return HAL_OK; return HAL_OK;
} }
/**
* @brief Инициализация предельного угла открытия.
* @param hangle Указатель на таймер
* @param PeriodLimit Лимит AngleMax, рассчитывается от параметров ШИМ
* @param AngleMin Минимально возможный угол открытия
* @param AngleMax Максимально возможный угол открытия
* @return HAL Status.
*/
HAL_StatusTypeDef Angle_SetLimit(Angle_Handle_t *hangle, float PeriodLimit)
{
if(assert_upp(hangle))
return HAL_ERROR;
if(hangle->f.Running)
return HAL_BUSY;
if(PeriodLimit < 0 || PeriodLimit > 1)
return HAL_ERROR;
hangle->Config.PeriodLimit = PeriodLimit;
return HAL_OK;
}
/**
* @brief Инициализация углов открытия.
* @param hangle Указатель на таймер
* @param PeriodLimit Лимит AngleMax, рассчитывается от параметров ШИМ
* @param AngleMin Минимально возможный угол открытия
* @param AngleMax Максимально возможный угол открытия
* @return HAL Status.
*/
HAL_StatusTypeDef Angle_SetRange(Angle_Handle_t *hangle, float AngleMin, float AngleMax)
{
if(assert_upp(hangle))
return HAL_ERROR;
if(hangle->f.Running)
return HAL_BUSY;
if(AngleMax < 0 || AngleMax > 1)
return HAL_ERROR;
if(AngleMin < 0 || AngleMin > 1)
return HAL_ERROR;
if(AngleMax > hangle->Config.PeriodLimit)
AngleMax = hangle->Config.PeriodLimit;
if(AngleMin > hangle->Config.PeriodLimit)
AngleMin = hangle->Config.PeriodLimit;
if(AngleMin >= AngleMax)
return HAL_ERROR;
hangle->Config.AngleMax = AngleMax;
hangle->Config.AngleMin = AngleMin;
return HAL_OK;
}
/**
* @brief Хендл таймера для рассчета угла открытия.
* @param hangle Указатель на таймер
* @return HAL Status.
* @details Просто возвращает фазу, у которой закончился отсчет угла
*/
UPP_Phase_t Angle_Handle(Angle_Handle_t *hangle)
{
if(assert_upp(hangle))
return UPP_PHASE_UNKNOWN;
switch(hangle->htim->Channel)
{
case HAL_TIM_ACTIVE_CHANNEL_1:
return UPP_PHASE_A;
break;
case HAL_TIM_ACTIVE_CHANNEL_2:
return UPP_PHASE_B;
break;
case HAL_TIM_ACTIVE_CHANNEL_3:
return UPP_PHASE_C;
break;
default:
return UPP_PHASE_UNKNOWN;
break;
}
return UPP_PHASE_UNKNOWN;
}

37
UPP/Core/UPP/angle_control.h
View File

@ -13,9 +13,9 @@
*/ */
typedef struct typedef struct
{ {
float AngleLimit; ///< Лимит AngleMax, рассчитывается от параметров ШИМ float PeriodLimit; ///< Лимит периода, выше которого нельзя выставить рассчитывается от параметров ШИМ
float AngleMin; ///< Минимально возможный угол открытия float AngleMin; ///< Минимально возможный угол открытия
float AngleMax; ///< Максимально возможный угол открытия float AngleMax; ///< Максимально возможный угол открытия
}Angle_Config_t; }Angle_Config_t;
/** /**
@ -23,10 +23,12 @@ typedef struct
*/ */
typedef struct typedef struct
{ {
TIM_HandleTypeDef *htim; ///< Указатель на таймер для расчета угла TIM_HandleTypeDef *htim; ///< Указатель на таймер для расчета угла
Angle_Config_t Config; ///< Конфигурации алгоритма расчета угла открытия тиристоров Angle_Config_t Config; ///< Конфигурации алгоритма расчета угла открытия тиристоров
//float alpha_degree; ///< текущий угол открытия в градусах [0..180]
float alpha; ///< текущий угол открытия в процентах от периода [0..1]
float alpha; ///< текущий угол открытия
arm_pid_instance_f32 pid; ///< ПИД регулятор для управления углом arm_pid_instance_f32 pid; ///< ПИД регулятор для управления углом
struct { struct {
@ -35,25 +37,32 @@ typedef struct
} f; ///< Флаги } f; ///< Флаги
}Angle_Handle_t; }Angle_Handle_t;
// ====== ИНИЦИАЛИЗАЦИЯ ==========
/* Инициализация Таймера для рассчета угла открытия. */ /* Инициализация Таймера для рассчета угла открытия. */
HAL_StatusTypeDef Angle_Init(Angle_Handle_t *hangle); HAL_StatusTypeDef Angle_Init(Angle_Handle_t *hangle);
/* Управление углом через ПИД регулятор */
void Angle_PID(Angle_Handle_t *hangle, float setpoint, float measurement);
/* Сброс ПИД регулятора. */
void Angle_PID_Reset(Angle_Handle_t *hangle);
/* Инициализация ПИД регулятора. */ /* Инициализация ПИД регулятора. */
void Angle_PID_Init(Angle_Handle_t *hangle, float kp, float ki, float kd); void Angle_PID_Init(Angle_Handle_t *hangle, float kp, float ki, float kd);
// ====== УПРАВЛЕНИЕ ==========
/* Управление углом через ПИД регулятор */
void Angle_PID(Angle_Handle_t *hangle, float setpoint, float measurement);
/* Выставление текущего угла открытия тиристоров. */ /* Выставление текущего угла открытия тиристоров. */
HAL_StatusTypeDef Angle_SetAngle(Angle_Handle_t *hangle, float Angle); HAL_StatusTypeDef Angle_SetAngle(Angle_Handle_t *hangle, float Angle);
/* Инициализация углов открытия. */
HAL_StatusTypeDef Angle_SetRange(Angle_Handle_t *hangle, float AngleMin, float AngleMax);
/* Инициализация предельного угла открытия. */
HAL_StatusTypeDef Angle_SetLimit(Angle_Handle_t *hangle, float AngleLimit);
/* Установка угла открытия в таймер. */ /* Установка угла открытия в таймер. */
HAL_StatusTypeDef Angle_Start(Angle_Handle_t *hangle, UPP_Phase_t Phase, float PeriodMs); HAL_StatusTypeDef Angle_Start(Angle_Handle_t *hangle, UPP_Phase_t Phase, float PeriodMs);
// ====== СБРОС ==========
/* Сброс угла открытия у таймера. */ /* Сброс угла открытия у таймера. */
HAL_StatusTypeDef Angle_Reset(Angle_Handle_t *hangle, UPP_Phase_t Phase); HAL_StatusTypeDef Angle_Reset(Angle_Handle_t *hangle, UPP_Phase_t Phase);
/* Сброс ПИД регулятора. */
void Angle_PID_Reset(Angle_Handle_t *hangle);
// ====== СЕРВИС ==========
/* Инициализация предельного угла открытия. */
HAL_StatusTypeDef Angle_SetLimit(Angle_Handle_t *hangle, float PeriodLimit);
/* Инициализация углов открытия. */
HAL_StatusTypeDef Angle_SetRange(Angle_Handle_t *hangle, float AngleMin, float AngleMax);
/* Хендл таймера для рассчета угла открытия. */ /* Хендл таймера для рассчета угла открытия. */
UPP_Phase_t Angle_Handle(Angle_Handle_t *hangle); UPP_Phase_t Angle_Handle(Angle_Handle_t *hangle);
#endif /* _ANGLE_CONTROL_H_ */ #endif /* _ANGLE_CONTROL_H_ */

8
UPP/Core/UPP/pwm_thyristors.c
View File

@ -58,7 +58,7 @@ HAL_StatusTypeDef PWM_Init(PWM_Handle_t *hpwm)
PWM_SetHalfWave(hpwm, UPP_PHASE_B, UPP_WAVE_UNKNOWED); PWM_SetHalfWave(hpwm, UPP_PHASE_B, UPP_WAVE_UNKNOWED);
PWM_SetHalfWave(hpwm, UPP_PHASE_C, UPP_WAVE_UNKNOWED); PWM_SetHalfWave(hpwm, UPP_PHASE_C, UPP_WAVE_UNKNOWED);
PWM_SetConfig(hpwm, MB_INTERNAL.param.pwm.PhaseMask, MB_INTERNAL.param.pwm.Frequency, MB_INTERNAL.param.pwm.PulseNumber); PWM_SetConfig(hpwm, PARAM_INTERNAL.pwm.PhaseMask, PARAM_INTERNAL.pwm.Frequency, PARAM_INTERNAL.pwm.PulseNumber);
HAL_TIM_PWM_Start(&hpwm1, PWM_CHANNEL_1); HAL_TIM_PWM_Start(&hpwm1, PWM_CHANNEL_1);
HAL_TIM_PWM_Start(&hpwm1, PWM_CHANNEL_2); HAL_TIM_PWM_Start(&hpwm1, PWM_CHANNEL_2);
@ -77,7 +77,7 @@ HAL_StatusTypeDef PWM_Init(PWM_Handle_t *hpwm)
* @param hpwm Указатель на хендл ШИМ тиристоров * @param hpwm Указатель на хендл ШИМ тиристоров
* @param Phase На какой фазе надо запустить ШИМ * @param Phase На какой фазе надо запустить ШИМ
* @return HAL Status. * @return HAL Status.
* @details Переводит автомат канала ШИМ в состояние запуска ШИМ. * @details Переводит автомат состояний канала ШИМ в состояние запуска ШИМ.
*/ */
HAL_StatusTypeDef PWM_Start(PWM_Handle_t *hpwm, UPP_Phase_t Phase) HAL_StatusTypeDef PWM_Start(PWM_Handle_t *hpwm, UPP_Phase_t Phase)
{ {
@ -184,14 +184,14 @@ HAL_StatusTypeDef PWM_Handle(PWM_Handle_t *hpwm)
case PWM_THYR_TIM_START: // начать ШИМ (пачка импульсов) case PWM_THYR_TIM_START: // начать ШИМ (пачка импульсов)
__PWM_SetOutputState(hPhase, PWM_ENABLE); __PWM_SetOutputState(hPhase, PWM_ENABLE);
hPhase->PulseCnt = hpwm->Config.PulseNumber; hPhase->PulseCnt = hpwm->Config.PulseNumber - 1; // 1 импульс уже прошел
hPhase->State = PWM_THYR_TIM_ACTIVE; hPhase->State = PWM_THYR_TIM_ACTIVE;
hpwm->f.Running++; hpwm->f.Running++;
break; break;
case PWM_THYR_TIM_ACTIVE: // управление пачкой импульсов ШИМ case PWM_THYR_TIM_ACTIVE: // управление пачкой импульсов ШИМ
hPhase->PulseCnt--; hPhase->PulseCnt--;
if (hPhase->PulseCnt <= 0) if (hPhase->PulseCnt <= 1) // если остался один импльс в след раз идем в PWM_THYR_TIM_DONE
{ {
hPhase->PulseCnt = 0; hPhase->PulseCnt = 0;
hPhase->State = PWM_THYR_TIM_DONE; hPhase->State = PWM_THYR_TIM_DONE;

6
UPP/Core/UPP/pwm_thyristors.h
View File

@ -85,9 +85,12 @@ typedef struct {
} f; } f;
} PWM_Handle_t; } PWM_Handle_t;
/* ---- API ---- */
// ====== ИНИЦИАЛИЗАЦИЯ ==========
/* Инициализация ШИМ тиристоров. */ /* Инициализация ШИМ тиристоров. */
HAL_StatusTypeDef PWM_Init(PWM_Handle_t *hpwm); HAL_StatusTypeDef PWM_Init(PWM_Handle_t *hpwm);
// ====== УПРАВЛЕНИЕ ==========
/* Запуск ШИМ. */ /* Запуск ШИМ. */
HAL_StatusTypeDef PWM_Start(PWM_Handle_t *hpwm, UPP_Phase_t Phase); HAL_StatusTypeDef PWM_Start(PWM_Handle_t *hpwm, UPP_Phase_t Phase);
/* Остановить ШИМ. */ /* Остановить ШИМ. */
@ -97,6 +100,7 @@ HAL_StatusTypeDef PWM_SetConfig(PWM_Handle_t *hpwm, uint8_t PhaseMask, uint16_t
/* Установка полуволны для слежения. */ /* Установка полуволны для слежения. */
HAL_StatusTypeDef PWM_SetHalfWave(PWM_Handle_t *hpwm, UPP_Phase_t Phase, UPP_HalfWave_t halfwave); HAL_StatusTypeDef PWM_SetHalfWave(PWM_Handle_t *hpwm, UPP_Phase_t Phase, UPP_HalfWave_t halfwave);
// ====== СЕРВИС ==========
/* Хендл ШИМ тиристоров. */ /* Хендл ШИМ тиристоров. */
HAL_StatusTypeDef PWM_Handle(PWM_Handle_t *hpwm); HAL_StatusTypeDef PWM_Handle(PWM_Handle_t *hpwm);
#endif /* _PWM_THYRISTORS_H */ #endif /* _PWM_THYRISTORS_H */

2
UPP/Core/UPP/upp_errors.c
View File

@ -52,7 +52,7 @@ void UPP_Errors_Power(void)
void UPP_Errors_Ranges(void) void UPP_Errors_Ranges(void)
{ {
/* Преобразуем уставки в нормальные тики */ /* Преобразуем уставки в нормальные тики */
float ticksTiMax = to_float(MB_DATA.HoldRegs.pui_params.TiMax, 1)/PM_SLOW_PERIOD_US; float ticksTiMax = to_float(PARAM_PUI.TiMax, 1)/PM_SLOW_PERIOD_US;
/* Счетчики для отсчитывания задержки выставления ошибки */ /* Счетчики для отсчитывания задержки выставления ошибки */
static int IMaxCnt = 0; static int IMaxCnt = 0;
static int UMaxCnt = 0; static int UMaxCnt = 0;

6
UPP/Core/UPP/upp_main.c
View File

@ -21,7 +21,7 @@ int UPP_Init(void)
BenchTime_Init(); BenchTime_Init();
// Подключение указателей // Подключение указателей
upp.errors = &errors; upp.errors = &errors;
upp.PUI.params = &MB_DATA.HoldRegs.pui_params; upp.PUI.params = &PARAM_PUI;
upp.PUI.values = &MB_DATA.InRegs.pui; upp.PUI.values = &MB_DATA.InRegs.pui;
upp.call = &MB_INTERNAL.FuncCalls; upp.call = &MB_INTERNAL.FuncCalls;
@ -40,7 +40,7 @@ int UPP_Init(void)
*/ */
int UPP_PreWhile(void) int UPP_PreWhile(void)
{ {
UPP_Control_InternalParams(); UPP_Params_InternalControl();
Angle_SetRange(&upp.hangle, 0.0, 0.8); Angle_SetRange(&upp.hangle, 0.0, 0.8);
PowerMonitor_Start(&upp.pm); PowerMonitor_Start(&upp.pm);
return 0; return 0;
@ -143,7 +143,7 @@ void UPP_Tick(void)
if(upp.workmode == WM_Not_Init) if(upp.workmode == WM_Not_Init)
return; return;
UPP_Errors_Handle(); UPP_Errors_Handle();
UPP_Control_InternalParams(); UPP_Params_InternalControl();
} }

2
UPP/Core/UPP/upp_main.h
View File

@ -15,7 +15,7 @@
#include "angle_control.h" // Управление углом открытия #include "angle_control.h" // Управление углом открытия
#include "upp_status.h" // статус упп #include "upp_status.h" // статус упп
#include "upp_control.h" // управление упп #include "upp_params.h" // управление упп
typedef struct typedef struct

107
UPP/Core/UPP/upp_control.c → UPP/Core/UPP/upp_params.c
View File

@ -1,6 +1,6 @@
/** /**
****************************************************************************** ******************************************************************************
* @file upp_control.c * @file upp_params.c
* @brief Модуль определябщий поведение УПП * @brief Модуль определябщий поведение УПП
****************************************************************************** ******************************************************************************
* @details * @details
@ -18,7 +18,7 @@ static void __AngleSetLimit(void);
* @brief Контроль внутренних параметров УПП. * @brief Контроль внутренних параметров УПП.
* @return HAL Status. * @return HAL Status.
*/ */
void UPP_Control_InternalParams(void) void UPP_Params_InternalControl(void)
{ {
if(upp.call->go) // при запущеном УПП ничего не меняем if(upp.call->go) // при запущеном УПП ничего не меняем
return; return;
@ -51,23 +51,23 @@ void UPP_Control_InternalParams(void)
// Параметры регулятора Угла открытия // Параметры регулятора Угла открытия
if(__CheckSimpleParamF(&angle_max, MB_INTERNAL.param.angle.Angle_Max, 65535)) if(__CheckSimpleParamF(&angle_max, PARAM_INTERNAL.angle.Angle_Max, 65535))
{ {
alpha_update = 1; alpha_update = 1;
} }
if(__CheckSimpleParamF(&angle_min, MB_INTERNAL.param.angle.Angle_Min, 65535)) if(__CheckSimpleParamF(&angle_min, PARAM_INTERNAL.angle.Angle_Min, 65535))
{ {
alpha_update = 1; alpha_update = 1;
} }
if(__CheckSimpleParamF(&angle_pid_kp, MB_INTERNAL.param.angle.PID_Kp, 10000)) if(__CheckSimpleParamF(&angle_pid_kp, PARAM_INTERNAL.angle.PID_Kp, 10000))
{ {
alpha_update = 1; alpha_update = 1;
} }
if(__CheckSimpleParamF(&angle_pid_ki, MB_INTERNAL.param.angle.PID_Ki, 10000)) if(__CheckSimpleParamF(&angle_pid_ki, PARAM_INTERNAL.angle.PID_Ki, 10000))
{ {
alpha_update = 1; alpha_update = 1;
} }
if(__CheckSimpleParamF(&angle_pid_kd, MB_INTERNAL.param.angle.PID_Kd, 10000)) if(__CheckSimpleParamF(&angle_pid_kd, PARAM_INTERNAL.angle.PID_Kd, 10000))
{ {
alpha_update = 1; alpha_update = 1;
} }
@ -81,42 +81,42 @@ void UPP_Control_InternalParams(void)
adc_channel_zero[i] = upp.pm.adc.Coefs[i].lZero; adc_channel_zero[i] = upp.pm.adc.Coefs[i].lZero;
// Максимальное измеряемое напряжение // Максимальное измеряемое напряжение
if(__CheckSimpleParamF(&adc_channel_max[i], MB_INTERNAL.param.adc.ADC_Max[i], 10)) if(__CheckSimpleParamF(&adc_channel_max[i], PARAM_INTERNAL.adc.ADC_Max[i], 10))
{ {
adc_channel_update[i] = 1; adc_channel_update[i] = 1;
} }
// Значение АЦП при нулевом входе // Значение АЦП при нулевом входе
if(__CheckSimpleParamU16(&adc_channel_zero[i], MB_INTERNAL.param.adc.ADC_Zero[i])) if(__CheckSimpleParamU16(&adc_channel_zero[i], PARAM_INTERNAL.adc.ADC_Zero[i]))
{ {
adc_channel_update[i] = 1; adc_channel_update[i] = 1;
} }
} }
// Параметры алгоритма перехода через ноль // Параметры алгоритма перехода через ноль
if(__CheckSimpleParamF(&zc_hysteresis, MB_INTERNAL.param.zc.Hysteresis, 10000)) if(__CheckSimpleParamF(&zc_hysteresis, PARAM_INTERNAL.zc.Hysteresis, 10000))
{ {
zc_update = 1; zc_update = 1;
} }
if(__CheckSimpleParamU16(&zc_debounce, MB_INTERNAL.param.zc.DebouneCouner)) if(__CheckSimpleParamU16(&zc_debounce, PARAM_INTERNAL.zc.DebouneCouner))
{ {
zc_update = 1; zc_update = 1;
} }
// Параметры ШИМ токов // Параметры ШИМ токов
if(__CheckSimpleParamU8(&pwm_phase_mask, MB_INTERNAL.param.pwm.PhaseMask, 1)) if(__CheckSimpleParamU8(&pwm_phase_mask, PARAM_INTERNAL.pwm.PhaseMask, 1))
{ {
pwm_update = 1; pwm_update = 1;
} }
if(__CheckSimpleParamU16(&pwm_freq, MB_INTERNAL.param.pwm.Frequency)) if(__CheckSimpleParamU16(&pwm_freq, PARAM_INTERNAL.pwm.Frequency))
{ {
pwm_update = 1; pwm_update = 1;
} }
if(__CheckSimpleParamU8(&pwm_pulse_num, MB_INTERNAL.param.pwm.PulseNumber, 1)) if(__CheckSimpleParamU8(&pwm_pulse_num, PARAM_INTERNAL.pwm.PulseNumber, 1))
{ {
pwm_update = 1; pwm_update = 1;
} }
// Параметры мониторинга // Параметры мониторинга
if(__CheckSimpleParamF(&pm_alpha, MB_INTERNAL.param.pm.mean_alpha, 65535)) if(__CheckSimpleParamF(&pm_alpha, PARAM_INTERNAL.pm.mean_alpha, 65535))
{ {
for(int i = 0; i < EXP_ALL; i++) for(int i = 0; i < EXP_ALL; i++)
{ {
@ -162,7 +162,7 @@ void UPP_Control_InternalParams(void)
else else
errors.prvt.cnt.pwm_reinit_err++; errors.prvt.cnt.pwm_reinit_err++;
} }
if (upp.hangle.Config.AngleLimit == 0) if ((upp.hangle.Config.PeriodLimit == 0) || (upp.hangle.Config.PeriodLimit >= 0.999))
{ {
__AngleSetLimit(); __AngleSetLimit();
} }
@ -179,59 +179,60 @@ void UPP_SetDefault(int pui_default, int internal_default)
{ {
if(pui_default) if(pui_default)
{ {
MB_DATA.HoldRegs.pui_params.Iref = PUI_Iref_PERCENT_DEFAULT; PARAM_PUI.Iref = PUI_Iref_PERCENT_DEFAULT;
MB_DATA.HoldRegs.pui_params.Tnt = PUI_Tnt_MS_DEFAULT; PARAM_PUI.Tnt = PUI_Tnt_MS_DEFAULT;
MB_DATA.HoldRegs.pui_params.Umin = PUI_Umin_PERCENT_DEFAULT; PARAM_PUI.Umin = PUI_Umin_PERCENT_DEFAULT;
MB_DATA.HoldRegs.pui_params.Umax = PUI_Umax_PERCENT_DEFAULT; PARAM_PUI.Umax = PUI_Umax_PERCENT_DEFAULT;
MB_DATA.HoldRegs.pui_params.Imax = PUI_Imax_PERCENT_DEFAULT; PARAM_PUI.Imax = PUI_Imax_PERCENT_DEFAULT;
MB_DATA.HoldRegs.pui_params.Imin = PUI_Imin_PERCENT_DEFAULT; PARAM_PUI.Imin = PUI_Imin_PERCENT_DEFAULT;
MB_DATA.HoldRegs.pui_params.TiMax = PUI_TiMax_US_DEFAULT; PARAM_PUI.TiMax = PUI_TiMax_US_DEFAULT;
MB_DATA.HoldRegs.pui_params.Tdelay = PUI_Tdelay_SECONDS_DEFAULT; PARAM_PUI.Tdelay = PUI_Tdelay_SECONDS_DEFAULT;
MB_DATA.HoldRegs.pui_params.Interlace = PUI_Interlace_EN_DEFAULT; PARAM_PUI.Interlace = PUI_Interlace_EN_DEFAULT;
} }
if(internal_default) if(internal_default)
{ {
MB_INTERNAL.param.setpoints.TemperatureWarn = SETPOINT_TEMP_WARN*10; PARAM_INTERNAL.setpoints.TemperatureWarn = SETPOINT_TEMP_WARN*10;
MB_INTERNAL.param.setpoints.TemperatureErr = SETPOINT_TEMP_ERR*10; PARAM_INTERNAL.setpoints.TemperatureErr = SETPOINT_TEMP_ERR*10;
MB_INTERNAL.param.nominal.PhaseNumber = NOM_PHASE_NUMB; PARAM_INTERNAL.nominal.PhaseNumber = NOM_PHASE_NUMB;
MB_INTERNAL.param.nominal.U = NOM_U_V_DEFAULT*10; PARAM_INTERNAL.nominal.U = NOM_U_V_DEFAULT*10;
MB_INTERNAL.param.nominal.U_deviation_plus = NOM_U_DEVIATION_PLUS_PERCENT_DEFAULT*100; PARAM_INTERNAL.nominal.U_deviation_plus = NOM_U_DEVIATION_PLUS_PERCENT_DEFAULT*100;
MB_INTERNAL.param.nominal.U_deviation_minus = NOM_U_DEVIATION_MINUS_PERCENT_DEFAULT*100; PARAM_INTERNAL.nominal.U_deviation_minus = NOM_U_DEVIATION_MINUS_PERCENT_DEFAULT*100;
MB_INTERNAL.param.nominal.F = NOM_F_HZ_DEFAULT*100; PARAM_INTERNAL.nominal.F = NOM_F_HZ_DEFAULT*100;
MB_INTERNAL.param.nominal.F_deviation_plus = NOM_F_DEVIATION_PLUS_PERCENT_DEFAULT*100; PARAM_INTERNAL.nominal.F_deviation_plus = NOM_F_DEVIATION_PLUS_PERCENT_DEFAULT*100;
MB_INTERNAL.param.nominal.F_deviation_minus = NOM_F_DEVIATION_MINUS_PERCENT_DEFAULT*100; PARAM_INTERNAL.nominal.F_deviation_minus = NOM_F_DEVIATION_MINUS_PERCENT_DEFAULT*100;
MB_INTERNAL.param.nominal.I = NOM_I_A_DEFAULT*10; PARAM_INTERNAL.nominal.I = NOM_I_A_DEFAULT*10;
MB_INTERNAL.param.pm.mean_alpha = PM_EXP_ALPHA_COEF_DEFAULT*65535; PARAM_INTERNAL.pm.mean_alpha = PM_EXP_ALPHA_COEF_DEFAULT*65535;
MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_UBA] = ADC_U_MAX_V_DEFAULT*10; PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_UBA] = ADC_U_MAX_V_DEFAULT*10;
MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_UAC] = ADC_U_MAX_V_DEFAULT*10; PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_UAC] = ADC_U_MAX_V_DEFAULT*10;
MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_IC] = ADC_I_MAX_A_DEFAULT*10; PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_IC] = ADC_I_MAX_A_DEFAULT*10;
MB_INTERNAL.param.adc.ADC_Max[ADC_CHANNEL_IA] = ADC_I_MAX_A_DEFAULT*10; PARAM_INTERNAL.adc.ADC_Max[ADC_CHANNEL_IA] = ADC_I_MAX_A_DEFAULT*10;
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_UBA] = ADC_U_ZERO_DEFAULT; PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_UBA] = ADC_U_ZERO_DEFAULT;
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_UAC] = ADC_U_ZERO_DEFAULT; PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_UAC] = ADC_U_ZERO_DEFAULT;
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_IC] = ADC_I_ZERO_DEFAULT; PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_IC] = ADC_I_ZERO_DEFAULT;
MB_INTERNAL.param.adc.ADC_Zero[ADC_CHANNEL_IA] = ADC_I_ZERO_DEFAULT; PARAM_INTERNAL.adc.ADC_Zero[ADC_CHANNEL_IA] = ADC_I_ZERO_DEFAULT;
MB_INTERNAL.param.pwm.PhaseMask = 0x7; // (все три фазы) PARAM_INTERNAL.pwm.PhaseMask = 0x7; // (все три фазы)
MB_INTERNAL.param.pwm.Frequency = (float)PWM_THYR_FREQUENCY_HZ_DEFAULT; PARAM_INTERNAL.pwm.Frequency = (float)PWM_THYR_FREQUENCY_HZ_DEFAULT;
MB_INTERNAL.param.pwm.PulseNumber = PWM_THYR_PULSE_NUMBER_DEFAULT; PARAM_INTERNAL.pwm.PulseNumber = PWM_THYR_PULSE_NUMBER_DEFAULT;
MB_INTERNAL.param.zc.Hysteresis = ZERO_CROSS_HYSTERESIS_PERCENT_DEFAULT*100; PARAM_INTERNAL.zc.Hysteresis = ZERO_CROSS_HYSTERESIS_PERCENT_DEFAULT*100;
MB_INTERNAL.param.zc.DebouneCouner = ZERO_CROSS_DEBOUNCE_CNT_DEFAULT; PARAM_INTERNAL.zc.DebouneCouner = ZERO_CROSS_DEBOUNCE_CNT_DEFAULT;
//__AngleSetLimit(); //__AngleSetLimit();
} }
} }
// Перерасчет максимально допустимого угла
static void __AngleSetLimit(void) static void __AngleSetLimit(void)
{ { // Сколько пачка ипульсов занимает процентов от всего периода
// Перерасчет максимально допустимого угла float pulses_percent_of_period = (((float)PARAM_INTERNAL.pwm.PulseNumber / PARAM_INTERNAL.pwm.Frequency) * 1000) / ANGLE_PERIOD_MS(NOM_F_HZ_DEFAULT);
float pulses_percent_of_period = ((MB_INTERNAL.param.pwm.PulseNumber / MB_INTERNAL.param.pwm.Frequency) * 1000) / ANGLE_PERIOD_MS(NOM_F_HZ_DEFAULT); // Вычитаем этот процент из 1 - получаем максимально безопасный угол
float angle_limit = 1 - pulses_percent_of_period; float angle_limit = 1 - pulses_percent_of_period*1.5; // добавляем запас в половину пачки импульсов
Angle_SetLimit(&upp.hangle, angle_limit); Angle_SetLimit(&upp.hangle, angle_limit);
} }

10
UPP/Core/UPP/upp_control.h → UPP/Core/UPP/upp_params.h
View File

@ -1,13 +1,13 @@
/** /**
****************************************************************************** ******************************************************************************
* @file upp_control.h * @file upp_params.h
* @brief Модуль определябщий поведение УПП * @brief Модуль определябщий поведение УПП
****************************************************************************** ******************************************************************************
* @details * @details
******************************************************************************/ ******************************************************************************/
#ifndef _UPP_CONTROL_H #ifndef _UPP_PARAMS_H
#define _UPP_CONTROL_H #define _UPP_PARAMS_H
#include "upp_defs.h" #include "upp_defs.h"
#define to_float(_u16_, _coef_) ((float)_u16_/_coef_) #define to_float(_u16_, _coef_) ((float)_u16_/_coef_)
@ -93,8 +93,8 @@ typedef struct
/* Контроль внутренних параметров УПП. */ /* Контроль внутренних параметров УПП. */
void UPP_Control_InternalParams(void); void UPP_Params_InternalControl(void);
/* Установка параметров на дефолтные значения */ /* Установка параметров на дефолтные значения */
void UPP_SetDefault(int pui_default, int internal_default); void UPP_SetDefault(int pui_default, int internal_default);
#endif //_UPP_CONTROL_H #endif //_UPP_PARAMS_H

54
UPP/MDK-ARM/UPP.uvoptx
View File

@ -411,30 +411,6 @@
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2> <bDave2>0</bDave2>
<PathWithFileName>..\Core\UPP\upp_control.c</PathWithFileName>
<FilenameWithoutPath>upp_control.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>18</FileNumber>
<FileType>5</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\Core\UPP\upp_control.h</PathWithFileName>
<FilenameWithoutPath>upp_control.h</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>19</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\Core\UPP\upp_status.c</PathWithFileName> <PathWithFileName>..\Core\UPP\upp_status.c</PathWithFileName>
<FilenameWithoutPath>upp_status.c</FilenameWithoutPath> <FilenameWithoutPath>upp_status.c</FilenameWithoutPath>
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
@ -442,7 +418,7 @@
</File> </File>
<File> <File>
<GroupNumber>2</GroupNumber> <GroupNumber>2</GroupNumber>
<FileNumber>20</FileNumber> <FileNumber>18</FileNumber>
<FileType>5</FileType> <FileType>5</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
@ -454,7 +430,7 @@
</File> </File>
<File> <File>
<GroupNumber>2</GroupNumber> <GroupNumber>2</GroupNumber>
<FileNumber>21</FileNumber> <FileNumber>19</FileNumber>
<FileType>1</FileType> <FileType>1</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
@ -466,7 +442,7 @@
</File> </File>
<File> <File>
<GroupNumber>2</GroupNumber> <GroupNumber>2</GroupNumber>
<FileNumber>22</FileNumber> <FileNumber>20</FileNumber>
<FileType>5</FileType> <FileType>5</FileType>
<tvExp>0</tvExp> <tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg> <tvExpOptDlg>0</tvExpOptDlg>
@ -476,6 +452,30 @@
<RteFlg>0</RteFlg> <RteFlg>0</RteFlg>
<bShared>0</bShared> <bShared>0</bShared>
</File> </File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>21</FileNumber>
<FileType>1</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\Core\UPP\upp_params.c</PathWithFileName>
<FilenameWithoutPath>upp_params.c</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
<File>
<GroupNumber>2</GroupNumber>
<FileNumber>22</FileNumber>
<FileType>5</FileType>
<tvExp>0</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<bDave2>0</bDave2>
<PathWithFileName>..\Core\UPP\upp_params.h</PathWithFileName>
<FilenameWithoutPath>upp_params.h</FilenameWithoutPath>
<RteFlg>0</RteFlg>
<bShared>0</bShared>
</File>
</Group> </Group>
<Group> <Group>

20
UPP/MDK-ARM/UPP.uvprojx
View File

@ -470,16 +470,6 @@
<FileType>5</FileType> <FileType>5</FileType>
<FilePath>..\Core\UPP\angle_control.h</FilePath> <FilePath>..\Core\UPP\angle_control.h</FilePath>
</File> </File>
<File>
<FileName>upp_control.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\UPP\upp_control.c</FilePath>
</File>
<File>
<FileName>upp_control.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\UPP\upp_control.h</FilePath>
</File>
<File> <File>
<FileName>upp_status.c</FileName> <FileName>upp_status.c</FileName>
<FileType>1</FileType> <FileType>1</FileType>
@ -500,6 +490,16 @@
<FileType>5</FileType> <FileType>5</FileType>
<FilePath>..\Core\UPP\upp_errors.h</FilePath> <FilePath>..\Core\UPP\upp_errors.h</FilePath>
</File> </File>
<File>
<FileName>upp_params.c</FileName>
<FileType>1</FileType>
<FilePath>..\Core\UPP\upp_params.c</FilePath>
</File>
<File>
<FileName>upp_params.h</FileName>
<FileType>5</FileType>
<FilePath>..\Core\UPP\upp_params.h</FilePath>
</File>
</Files> </Files>
</Group> </Group>
<Group> <Group>