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 22:29:48 +03:00
parent 297cf9802e
commit e1d6f1139d
24 changed files with 384 additions and 196 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
MATLAB/MCU_STM32_Matlab/Drivers/STM32F4xx_HAL_Driver/Src/stm32f4xx_hal_gpio.c
View File

@ -421,6 +421,7 @@ void HAL_GPIO_WritePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin, GPIO_PinState Pin
{
GPIOx->BSRR = (uint32_t)GPIO_Pin << 16U;
}
__GPIO_BSRR_Sim(GPIOx);
}
/**
@ -442,6 +443,7 @@ void HAL_GPIO_TogglePin(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
/* Set selected pins that were at low level, and reset ones that were high */
GPIOx->BSRR = ((odr & GPIO_Pin) << GPIO_NUMBER) | (~odr & GPIO_Pin);
__GPIO_BSRR_Sim(GPIOx);
}
/**

12
MATLAB/MCU_STM32_Matlab/Drivers/STM32_SIMULINK/stm32_matlab_gpio.c
View File

@ -16,6 +16,18 @@ void Simulate_GPIO_BSRR(void)
#ifdef GPIOD
__GPIO_BSRR_Sim(GPIOD);
#endif
#ifdef GPIOE
__GPIO_BSRR_Sim(GPIOE);
#endif
#ifdef GPIOF
__GPIO_BSRR_Sim(GPIOF);
#endif
#ifdef GPIOG
__GPIO_BSRR_Sim(GPIOG);
#endif
#ifdef GPIOH
__GPIO_BSRR_Sim(GPIOH);
#endif
}

1
MATLAB/MCU_STM32_Matlab/stm32_matlab_conf.c
View File

@ -26,6 +26,7 @@ void Simulate_Periph_Sim(void)
{
Simulate_TIMs();
Simulate_ADCs();
Simulate_GPIO_BSRR();
}
// MCU PERIPH DEINIT

10
MATLAB/MCU_Wrapper/mcu_wrapper.c
View File

@ -37,9 +37,10 @@ const int inOffsets[IN_PORT_NUMB] = {
*/
const int outLengths[OUT_PORT_NUMB] = {
THYR_PORT_1_WIDTH,
PM_PORT_2_WIDTH,
ANGLE_PORT_3_WIDTH,
OUT_PORT_4_WIDTH
DO_PORT_2_WIDTH,
PM_PORT_3_WIDTH,
ANGLE_PORT_4_WIDTH,
OUT_PORT_5_WIDTH
};
/**
* @brief Таблица смещений в выходном массиве OUT
@ -48,7 +49,8 @@ const int outOffsets[OUT_PORT_NUMB] = {
OFFSET_OUT_ARRAY_1,
OFFSET_OUT_ARRAY_2,
OFFSET_OUT_ARRAY_3,
OFFSET_OUT_ARRAY_4
OFFSET_OUT_ARRAY_4,
OFFSET_OUT_ARRAY_5
};
// INPUT/OUTPUTS AUTO-PARAMS END

16
MATLAB/MCU_Wrapper/mcu_wrapper_conf.h
View File

@ -57,11 +57,12 @@
#define ADC_PORT_1_WIDTH 6
#define IN_PORT_2_WIDTH 16
#define OUT_PORT_NUMB 4
#define OUT_PORT_NUMB 5
#define THYR_PORT_1_WIDTH 6
#define PM_PORT_2_WIDTH 32
#define ANGLE_PORT_3_WIDTH 16
#define OUT_PORT_4_WIDTH 16
#define DO_PORT_2_WIDTH 3
#define PM_PORT_3_WIDTH 32
#define ANGLE_PORT_4_WIDTH 16
#define OUT_PORT_5_WIDTH 16
// INPUT/OUTPUTS PARAMS END
/** WRAPPER_CONF
@ -100,13 +101,14 @@
#define OFFSET_IN_ARRAY_2 (OFFSET_IN_ARRAY_1 + ADC_PORT_1_WIDTH)
/// === Полный размер буфера ===
#define TOTAL_OUT_SIZE (THYR_PORT_1_WIDTH + PM_PORT_2_WIDTH + ANGLE_PORT_3_WIDTH + OUT_PORT_4_WIDTH)
#define TOTAL_OUT_SIZE (THYR_PORT_1_WIDTH + DO_PORT_2_WIDTH + PM_PORT_3_WIDTH + ANGLE_PORT_4_WIDTH + OUT_PORT_5_WIDTH)
/// === Смещения массивов (внутри общего буфера) ===
#define OFFSET_OUT_ARRAY_1 0
#define OFFSET_OUT_ARRAY_2 (OFFSET_OUT_ARRAY_1 + THYR_PORT_1_WIDTH)
#define OFFSET_OUT_ARRAY_3 (OFFSET_OUT_ARRAY_2 + PM_PORT_2_WIDTH)
#define OFFSET_OUT_ARRAY_4 (OFFSET_OUT_ARRAY_3 + ANGLE_PORT_3_WIDTH)
#define OFFSET_OUT_ARRAY_3 (OFFSET_OUT_ARRAY_2 + DO_PORT_2_WIDTH)
#define OFFSET_OUT_ARRAY_4 (OFFSET_OUT_ARRAY_3 + PM_PORT_3_WIDTH)
#define OFFSET_OUT_ARRAY_5 (OFFSET_OUT_ARRAY_4 + ANGLE_PORT_4_WIDTH)
// INPUT/OUTPUTS AUTO-PARAMS END

1
MATLAB/app_wrapper/app_init.c
View File

@ -27,6 +27,7 @@ void app_init(void) {
UPP_SetDefault(1, 1);
UPP_Init();
UPP_PreWhile();
UPP_DO.CEN(DISABLE);
// USER APP INIT END
}

51
MATLAB/app_wrapper/app_io.c
View File

@ -10,7 +10,7 @@ float dbg[16];
extern float iref_dbg;
#define PIN_READ(_verbname_) (_verbname_##_GPIO_Port->ODR & (_verbname_##_Pin)) ? 1 : 0
void Write_Thyristors(real_T* Buffer, int ind_port)
void Write_UPP_Outputs(real_T* Buffer, int ind_port)
{
int pwm1_pin = PIN_READ(PWM1);
int pwm2_pin = PIN_READ(PWM2);
@ -18,14 +18,39 @@ void Write_Thyristors(real_T* Buffer, int ind_port)
int pwm4_pin = PIN_READ(PWM4);
int pwm5_pin = PIN_READ(PWM5);
int pwm6_pin = PIN_READ(PWM6);
int err = PIN_READ(RDO1);
int work = PIN_READ(RDO2);
int ready = PIN_READ(RDO3);
if (CEN_GPIO_Port->ODR & CEN_Pin)
{
WriteOutputArray(0, ind_port, 0);
WriteOutputArray(0, ind_port, 1);
WriteOutputArray(0, ind_port, 2);
WriteOutputArray(0, ind_port, 3);
WriteOutputArray(0, ind_port, 4);
WriteOutputArray(0, ind_port, 5);
WriteOutputArray(0, ind_port+1, 0);
WriteOutputArray(0, ind_port+1, 1);
WriteOutputArray(0, ind_port+1, 2);
}
else
{
WriteOutputArray(pwm1_pin, ind_port, 0);
WriteOutputArray(pwm2_pin, ind_port, 1);
WriteOutputArray(pwm3_pin, ind_port, 2);
WriteOutputArray(pwm4_pin, ind_port, 3);
WriteOutputArray(pwm5_pin, ind_port, 4);
WriteOutputArray(pwm6_pin, ind_port, 5);
WriteOutputArray(ready, ind_port+1, 0);
WriteOutputArray(work, ind_port+1, 1);
WriteOutputArray(err, ind_port+1, 2);
}
WriteOutputArray(pwm1_pin, ind_port, 0);
WriteOutputArray(pwm2_pin, ind_port, 1);
WriteOutputArray(pwm3_pin, ind_port, 2);
WriteOutputArray(pwm4_pin, ind_port, 3);
WriteOutputArray(pwm5_pin, ind_port, 4);
WriteOutputArray(pwm6_pin, ind_port, 5);
}
void Write_PowerMonitor(real_T* Buffer, int ind_port)
@ -71,9 +96,9 @@ void Write_AngleControl(real_T* Buffer, int ind_port)
WriteOutputArray(upp.hangle.alpha, ind_port, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR1) - upp.hangle.htim->Instance->CNT, 2, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR2) - upp.hangle.htim->Instance->CNT, 2, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR3) - upp.hangle.htim->Instance->CNT, 2, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR1) - upp.hangle.htim->Instance->CNT, ind_port, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR2) - upp.hangle.htim->Instance->CNT, ind_port, nn++);
WriteOutputArray((long long)(upp.hangle.htim->Instance->CCR3) - upp.hangle.htim->Instance->CNT, ind_port, nn++);
}
@ -108,11 +133,11 @@ void app_readInputs(const real_T* Buffer) {
*/
void app_writeOutputBuffer(real_T* Buffer) {
// USER APP OUTPUT START
Write_Thyristors(Buffer, 0);
Write_UPP_Outputs(Buffer, 0);
Write_PowerMonitor(Buffer, 1);
Write_PowerMonitor(Buffer, 2);
Write_AngleControl(Buffer, 2);
Write_AngleControl(Buffer, 3);
int nn = 0;
//WriteOutputArray(upp.hangle.htim->Instance->CNT, 2, nn++);

BIN
MATLAB/upp_r2023.slx
View File

Binary file not shown.

5
UPP/Core/Configs/modbus_config.h
View File

@ -20,6 +20,7 @@
#ifndef _MODBUS_CONFIG_H_
#define _MODBUS_CONFIG_H_
#include "upp_defs.h"
#include "upp_io.h"
// Общие параметры
#define MODBUS_DEVICE_ID 1 ///< Адрес устройства в сети Modbus
@ -40,8 +41,8 @@
// Периферия (опционально)
//#define mb_huart huart1 ///< Удобный дефайн для модбасовского uart
//#define mb_htim htim3 ///< Удобный дефайн для модбасовского таймера
//#define RS_EnableReceive() ///< Функция изменения направления передачи на ПРИЕМ для RS-485
//#define RS_EnableTransmit() ///< Функция изменения направления передачи на ПЕРЕДАЧУ для RS-485
#define RS_EnableReceive() UPP_UART1_SetDirection(GPIO_PIN_RESET) ///< Функция изменения направления передачи на ПРИЕМ для RS-485
#define RS_EnableTransmit() UPP_UART1_SetDirection(GPIO_PIN_RESET) ///< Функция изменения направления передачи на ПЕРЕДАЧУ для RS-485
// Модули modbus

7
UPP/Core/Configs/mylibs_config.h
View File

@ -99,9 +99,10 @@
#define BENCH_TIME_ENABLE ///< Включить бенч времени
#define BENCH_TIME_MAX_CHANNELS 5 ///< Максимальное количество каналов измерения
#define BT_ADC 0
#define BT_PWM 1
#define BT_SYSTICK 2
#define BT_SLOWCALC 0
#define BT_ADC 1
#define BT_PWM 2
#define BT_SYSTICK 3
/** GEN_CONFIG
* @}
*/

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

@ -51,8 +51,8 @@
#define NOM_U_DEVIATION_PLUS_PERCENT_DEFAULT 6
#define NOM_U_DEVIATION_MINUS_PERCENT_DEFAULT 10
#define NOM_F_HZ_DEFAULT 50
#define NOM_F_DEVIATION_PLUS_PERCENT_DEFAULT 5
#define NOM_F_DEVIATION_MINUS_PERCENT_DEFAULT 5
#define NOM_F_DEVIATION_PLUS_PERCENT_DEFAULT 10
#define NOM_F_DEVIATION_MINUS_PERCENT_DEFAULT 10
#define NOM_I_A_DEFAULT 5
/* Параметры ПУИ */
@ -66,8 +66,10 @@
#define PUI_Tdelay_SECONDS_DEFAULT 30
#define PUI_Interlace_EN_DEFAULT 5000
/* Дефолтное коливчество тиков для задержки выставления ошибки */
#define ERRORS_DELAY_TICKS_DEFAULT 10
/* Время задержки перед выставлением ошибки */
#define ERRORS_DELAY_MS_UAMP_ERR 1500 // todo
#define ERRORS_DELAY_MS_F_ERR 5000
#define ERRORS_DELAY_MS_DEFAULT 0.1f
/* Параметри мониторинга сети */
#define PM_EXP_ALPHA_COEF_DEFAULT 0.01

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

@ -152,8 +152,15 @@ typedef struct {
#define PM_SLOW_PERIOD_US (PM_ADC_PERIOD_US*PM_SLOW_PERIOD_CNT)
#define ANGLE_PERIOD_MS(_freq_) (((float)1/(_freq_*2))*1000)
#define US_TO_SLOW_TICKS(_us_) ((_us_)/PM_SLOW_PERIOD_US)
#define MS_TO_SLOW_TICKS(_ms_) US_TO_SLOW_TICKS((_ms_)*1000)
#define PARAM_INTERNAL MB_INTERNAL.param
#define PARAM_PUI MB_DATA.HoldRegs.pui_params
#define ERR_PUI errors.pui.err
#define ERR_PRIVATE errors.prvt.f.err
/**
* @brief Состояния полуволны

3
UPP/Core/Inc/main.h
View File

@ -31,8 +31,11 @@ extern "C" {
/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
/* Общее по УПП */
#include "upp_defs.h"
#include "upp_io.h"
#include "upp_errors.h"
/* Общие библиотеки */
#include "mylibs_include.h"
#include "modbus.h"
/* USER CODE END Includes */

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

@ -225,7 +225,7 @@ void PowerMonitor_FastCalc(PowerMonitor_t *hpm)
}
else // если уже запущена - ставим overrun slow calc
{
errors.prvt.f.err.slow_calc_overrun = 1;
ERR_PRIVATE.slow_calc_overrun = 1;
errors.prvt.cnt.slow_calc_overrun++;
}
}

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

@ -24,30 +24,30 @@ int Protect_Voltages(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect
/* Общее напряжение */
if(measure->final.Uamp > lUmax)
{
errors.prvt.f.err.uamp_max = 1;
ERR_PRIVATE.uamp_max = 1;
}
else if (measure->final.Uamp < lUmin)
{
errors.prvt.f.err.uamp_min = 1;
ERR_PRIVATE.uamp_min = 1;
}
else
{
errors.prvt.f.err.uamp_max = 0;
errors.prvt.f.err.uamp_min = 0;
ERR_PRIVATE.uamp_max = 0;
ERR_PRIVATE.uamp_min = 0;
}
/* Последовательность фаз */
int realPhaseSequence = 0;
if(realPhaseSequence != lPhaseSequence)
{
errors.prvt.f.err.interlance = 1;
ERR_PRIVATE.interlance = 1;
}
else
{
errors.prvt.f.err.interlance = 0;
ERR_PRIVATE.interlance = 0;
}
return (errors.prvt.f.err.uamp_min == 0);
return (ERR_PRIVATE.uamp_min == 0);
}
/**
@ -65,62 +65,62 @@ int Protect_Currents(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect
/* Общий ток */
if(measure->final.Iamp > lImax)
{
errors.prvt.f.err.iamp_max = 1;
ERR_PRIVATE.iamp_max = 1;
}
else if (measure->final.Iamp < lImin)
{
errors.prvt.f.err.iamp_min = 1;
ERR_PRIVATE.iamp_min = 1;
}
else
{
errors.prvt.f.err.iamp_max = 0;
errors.prvt.f.err.iamp_min = 0;
ERR_PRIVATE.iamp_max = 0;
ERR_PRIVATE.iamp_min = 0;
}
/* Ток по фазам */
if(measure->final.I[I_A] > lImax)
{
errors.prvt.f.err.ia_max = 1;
ERR_PRIVATE.ia_max = 1;
}
else if (measure->final.I[I_A] < lImin)
{
errors.prvt.f.err.ia_min = 1;
ERR_PRIVATE.ia_min = 1;
}
else
{
errors.prvt.f.err.ia_max = 0;
errors.prvt.f.err.ia_min = 0;
ERR_PRIVATE.ia_max = 0;
ERR_PRIVATE.ia_min = 0;
}
if(measure->final.I[I_B] > lImax)
{
errors.prvt.f.err.ib_max = 1;
ERR_PRIVATE.ib_max = 1;
}
else if (measure->final.I[I_B] < lImin)
{
errors.prvt.f.err.ib_min = 1;
ERR_PRIVATE.ib_min = 1;
}
else
{
errors.prvt.f.err.ib_max = 0;
errors.prvt.f.err.ib_min = 0;
ERR_PRIVATE.ib_max = 0;
ERR_PRIVATE.ib_min = 0;
}
if(measure->final.I[I_C] > lImax)
{
errors.prvt.f.err.ic_max = 1;
ERR_PRIVATE.ic_max = 1;
}
else if (measure->final.I[I_C] < lImin)
{
errors.prvt.f.err.ic_min = 1;
ERR_PRIVATE.ic_min = 1;
}
else
{
errors.prvt.f.err.ic_max = 0;
errors.prvt.f.err.ic_min = 0;
ERR_PRIVATE.ic_max = 0;
ERR_PRIVATE.ic_min = 0;
}
return (errors.prvt.f.err.iamp_min == 0);
return (ERR_PRIVATE.iamp_min == 0);
}
@ -144,44 +144,44 @@ void Protect_Misc(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect, U
/*=============== ЗАЩИТЫ ПО ЧАСТОТЕ ==================*/
if(measure->final.F[U_AC] > lFmax)
{
errors.prvt.f.err.fac_max = 1;
ERR_PRIVATE.fac_max = 1;
}
else if (measure->final.F[U_AC] < lFmin)
{
errors.prvt.f.err.fac_min = 1;
ERR_PRIVATE.fac_min = 1;
}
else
{
errors.prvt.f.err.fac_max = 0;
errors.prvt.f.err.fac_min = 0;
ERR_PRIVATE.fac_max = 0;
ERR_PRIVATE.fac_min = 0;
}
if(measure->final.F[U_BA] > lFmax)
{
errors.prvt.f.err.fba_max = 1;
ERR_PRIVATE.fba_max = 1;
}
else if (measure->final.F[U_BA] < lFmin)
{
errors.prvt.f.err.fba_min = 1;
ERR_PRIVATE.fba_min = 1;
}
else
{
errors.prvt.f.err.fba_max = 0;
errors.prvt.f.err.fba_min = 0;
ERR_PRIVATE.fba_max = 0;
ERR_PRIVATE.fba_min = 0;
}
if(measure->final.F[U_BC] > lFmax)
{
errors.prvt.f.err.fbc_max = 1;
ERR_PRIVATE.fbc_max = 1;
}
else if (measure->final.F[U_BC] < lFmin)
{
errors.prvt.f.err.fbc_min = 1;
ERR_PRIVATE.fbc_min = 1;
}
else
{
errors.prvt.f.err.fbc_max = 0;
errors.prvt.f.err.fbc_min = 0;
ERR_PRIVATE.fbc_max = 0;
ERR_PRIVATE.fbc_min = 0;
}
@ -189,15 +189,15 @@ void Protect_Misc(PowerMonitor_Measured_t *measure, UPP_PUI_Params_t *protect, U
/*=============== ЗАЩИТЫ ПО ТЕМПЕРАТУРЕ ==================*/
if(measure->final.T[TEMP_1] > lTerr)
{
errors.prvt.f.err.temp_err = 1;
ERR_PRIVATE.temp_err = 1;
}
else if (measure->final.T[TEMP_1] > lTwarn)
{
errors.prvt.f.err.temp_warn = 1;
ERR_PRIVATE.temp_warn = 1;
}
else
{
errors.prvt.f.err.temp_err = 0;
errors.prvt.f.err.temp_warn = 0;
ERR_PRIVATE.temp_err = 0;
ERR_PRIVATE.temp_warn = 0;
}
}

0
UPP/Core/Src/DBG_stm32f417_support.c Normal file
View File

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

@ -4,6 +4,12 @@
* @brief Формирование ошибок в ПУИ
******************************************************************************
* @details
Общая логика:
В программе выставляются всякие внутренние флаги ошибок: ERR_PRIVATE
В этом модуле смотрятся какие флаги выставились и переносят эти флаги
в структуру ошибок ПУИ ERR_PUI.
Также реализована защита от дребезга и в целом задержка на выставление ошибок.
******************************************************************************/
#include "upp_main.h" // УПП
#include "upp_errors.h" // всё остальное по работе с УПП
@ -62,50 +68,50 @@ void UPP_Errors_Ranges(void)
static int TMaxCnt = 0;
/* Напряжения */
errors.pui.err.OverVoltage = setError(errors.prvt.f.err.uamp_max,
errors.pui.err.OverVoltage,
&UMaxCnt,
ticksTiMax);
errors.pui.err.UnderVoltage = setError(errors.prvt.f.err.uamp_min,
errors.pui.err.UnderVoltage,
&UMinCnt,
ticksTiMax);
ERR_PUI.OverVoltage = setError(ERR_PRIVATE.uamp_max,
ERR_PUI.OverVoltage,
&UMaxCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_UAMP_ERR));
ERR_PUI.UnderVoltage = setError(ERR_PRIVATE.uamp_min,
ERR_PUI.UnderVoltage,
&UMinCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_UAMP_ERR));
/* Токи */
int i_max = ( errors.prvt.f.err.iamp_max ||
errors.prvt.f.err.ia_max ||
errors.prvt.f.err.ib_max ||
errors.prvt.f.err.ic_max);
errors.pui.err.OverCurrent = setError(i_max,
errors.pui.err.OverCurrent,
&IMaxCnt,
ticksTiMax);
int i_max = ( ERR_PRIVATE.iamp_max ||
ERR_PRIVATE.ia_max ||
ERR_PRIVATE.ib_max ||
ERR_PRIVATE.ic_max);
ERR_PUI.OverCurrent = setError(i_max,
ERR_PUI.OverCurrent,
&IMaxCnt,
ticksTiMax);
/* Частота */
int f_max = ( errors.prvt.f.err.fac_max ||
errors.prvt.f.err.fba_max ||
errors.prvt.f.err.fbc_max);
int f_min = ( errors.prvt.f.err.fac_max ||
errors.prvt.f.err.fba_max ||
errors.prvt.f.err.fbc_max);
errors.pui.err.OverFrequency = setError(f_max,
errors.pui.err.OverFrequency,
&FMaxCnt,
ERRORS_DELAY_TICKS_DEFAULT);
int f_max = ( ERR_PRIVATE.fac_max ||
ERR_PRIVATE.fba_max ||
ERR_PRIVATE.fbc_max);
int f_min = ( ERR_PRIVATE.fac_max ||
ERR_PRIVATE.fba_max ||
ERR_PRIVATE.fbc_max);
ERR_PUI.OverFrequency = setError(f_max,
ERR_PUI.OverFrequency,
&FMaxCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_F_ERR));
errors.pui.err.UnderFrequency = setError( f_min,
errors.pui.err.UnderFrequency,
&FMinCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.UnderFrequency = setError( f_min,
ERR_PUI.UnderFrequency,
&FMinCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_F_ERR));
/* Температуры */
errors.pui.err.OverTemperature = setError(errors.prvt.f.err.temp_err,
errors.pui.err.OverTemperature,
&TMaxCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.OverTemperature = setError(ERR_PRIVATE.temp_err,
ERR_PUI.OverTemperature,
&TMaxCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
}
void UPP_Errors_LossPhase(void)
@ -116,39 +122,39 @@ void UPP_Errors_LossPhase(void)
static int LossPhaseBCnt = 0;
static int LossPhaseCCnt = 0;
int loss_phases_all = ( errors.prvt.f.err.ia_min &&
errors.prvt.f.err.ib_min &&
errors.prvt.f.err.ic_min );
int loss_phases_all = ( ERR_PRIVATE.ia_min &&
ERR_PRIVATE.ib_min &&
ERR_PRIVATE.ic_min );
errors.pui.err.LossPhaseAll = setError( loss_phases_all,
errors.pui.err.LossPhaseAll,
&LossPhaseAllCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.LossPhaseAll = setError( loss_phases_all,
ERR_PUI.LossPhaseAll,
&LossPhaseAllCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
/* Если хотя бы одна фаза есть проверяем фазы отдельно */
if(!errors.pui.err.LossPhaseAll)
if(!ERR_PUI.LossPhaseAll)
{
errors.pui.err.LossPhaseA = setError( errors.prvt.f.err.ia_min,
errors.pui.err.LossPhaseA,
&LossPhaseACnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.LossPhaseA = setError( ERR_PRIVATE.ia_min,
ERR_PUI.LossPhaseA,
&LossPhaseACnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
errors.pui.err.LossPhaseB = setError( errors.prvt.f.err.ib_min,
errors.pui.err.LossPhaseB,
&LossPhaseBCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.LossPhaseB = setError( ERR_PRIVATE.ib_min,
ERR_PUI.LossPhaseB,
&LossPhaseBCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
errors.pui.err.LossPhaseC = setError( errors.prvt.f.err.ic_min,
errors.pui.err.LossPhaseC,
&LossPhaseCCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.LossPhaseC = setError( ERR_PRIVATE.ic_min,
ERR_PUI.LossPhaseC,
&LossPhaseCCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
}
/* Если всех фаз нет, то отдельные не смотрим */
else
{
errors.pui.err.LossPhaseA = 0;
errors.pui.err.LossPhaseB = 0;
errors.pui.err.LossPhaseC = 0;
ERR_PUI.LossPhaseA = 0;
ERR_PUI.LossPhaseB = 0;
ERR_PUI.LossPhaseC = 0;
}
}
@ -156,15 +162,15 @@ void UPP_Errors_Other(void)
{
static int InterlaceCnt = 0;
if(errors.prvt.f.err.longstart)
errors.pui.err.LongStart = 1;
if(ERR_PRIVATE.longstart)
ERR_PUI.LongStart = 1;
else
errors.pui.err.LongStart = 0;
ERR_PUI.LongStart = 0;
errors.pui.err.Interlace = setError(errors.prvt.f.err.interlance,
errors.pui.err.Interlace,
&InterlaceCnt,
ERRORS_DELAY_TICKS_DEFAULT);
ERR_PUI.Interlace = setError(ERR_PRIVATE.interlance,
ERR_PUI.Interlace,
&InterlaceCnt,
MS_TO_SLOW_TICKS(ERRORS_DELAY_MS_DEFAULT));
//Interlance
}

121
UPP/Core/UPP/upp_io.c
View File

@ -7,62 +7,131 @@
******************************************************************************/
#include "upp_io.h"
#include "main.h"
UPP_LEDs_t UPP_LEDS;
UPP_DiscreteInputs_t UPP_DIN;
UPP_DiscreteOutputs_t UPP_DO;
static void UPP_CEN_Write(int state);
static void UPP_RDO1_Write(int state);
static void UPP_RDO2_Write(int state);
static void UPP_RDO3_Write(int state);
static void UPP_RDO4_Write(int state);
static void UPP_DO1_Write(int state);
static void UPP_DO2_Write(int state);
static void UPP_DO3_Write(int state);
static void UPP_DO4_Write(int state);
static void UPP_DO5_Write(int state);
void UPP_CEN_Write(int state)
/**
* @brief Инициализация дискретных входов/выходов УПП
*/
void UPP_IO_Init(void)
{
HAL_GPIO_WritePin(CEN_GPIO_Port, CEN_Pin, state);
/* Дискретне выходы */
UPP_DO.CEN = &UPP_CEN_Write;
UPP_DO.Ready = &UPP_RDO3_Write;
UPP_DO.Work = &UPP_RDO2_Write;
UPP_DO.Error = &UPP_RDO1_Write;
UPP_DO.RDO4 = &UPP_RDO4_Write;
UPP_DO.DO1 = &UPP_DO1_Write;
UPP_DO.DO2 = &UPP_DO2_Write;
UPP_DO.DO3 = &UPP_DO3_Write;
UPP_DO.DO4 = &UPP_DO4_Write;
UPP_DO.DO5 = &UPP_DO5_Write;
/* Дискретные входы */
GPIO_Switch_Init(&UPP_DIN.Pusk, DIN1_GPIO_Port, DIN1_Pin, 0);
GPIO_Switch_Init(&UPP_DIN.MestDist, DIN2_GPIO_Port, DIN2_Pin, 0);
GPIO_Switch_Init(&UPP_DIN.DIN3, DIN3_GPIO_Port, DIN3_Pin, 0);
GPIO_Switch_Init(&UPP_DIN.err_24Vdio, ERR_24VDIO_GPIO_Port, ERR_24VDIO_Pin, 1);
GPIO_Switch_Init(&UPP_DIN.err_24V, ERR_24V_GPIO_Port, ERR_24V_Pin, 1);
GPIO_Switch_Init(&UPP_DIN.err_5Vsi, ERR_5VSI_GPIO_Port, ERR_5VSI_Pin, 0);
/* Дискретные входы платы УМ */
GPIO_Switch_Init(&UPP_DIN.err_5Vd, UM_ERR_5VD_GPIO_Port, UM_ERR_5VD_Pin, 0);
GPIO_Switch_Init(&UPP_DIN.err_Va, UM_ERR_VA_GPIO_Port, UM_ERR_VA_Pin, 1);
/* Светодиоды платы УМ */
GPIO_LED_Init(&UPP_LEDS.green1, UM_LED_GREEN1_GPIO_Port, UM_LED_GREEN1_Pin, 0);
GPIO_LED_Init(&UPP_LEDS.green2, UM_LED_GREEN2_GPIO_Port, UM_LED_GREEN2_Pin, 0);
GPIO_LED_Init(&UPP_LEDS.red, UM_LED_RED_GPIO_Port, UM_LED_RED_Pin, 0);
/* Очищаем выходы */
UPP_DO.CEN(DISABLE);
UPP_DO.Error(DISABLE);
UPP_DO.Work(DISABLE);
UPP_DO.Ready(DISABLE);
UPP_DO.RDO4(DISABLE);
UPP_DO.DO1(DISABLE);
UPP_DO.DO2(DISABLE);
UPP_DO.DO3(DISABLE);
UPP_DO.DO4(DISABLE);
UPP_DO.DO5(DISABLE);
GPIO_LED_Off(&UPP_LEDS.green1);
GPIO_LED_Off(&UPP_LEDS.green2);
GPIO_LED_Off(&UPP_LEDS.red);
}
void UPP_RDO1_Write(int state)
/**
* @brief Выставить направление UART1 (STM USART2)
*/
void UPP_UART1_SetDirection(int state)
{
HAL_GPIO_WritePin(SCIDE1_GPIO_Port, SCIDE1_Pin, state);
}
/**
* @brief Выставить направление UART2 (STM USART5)
*/
void UPP_UART2_SetDirection(int state)
{
HAL_GPIO_WritePin(SCIDE2_GPIO_Port, SCIDE2_Pin, state);
}
static void UPP_CEN_Write(int state)
{
HAL_GPIO_WritePin(CEN_GPIO_Port, CEN_Pin, !state);
}
static void UPP_RDO1_Write(int state)
{
HAL_GPIO_WritePin(RDO1_GPIO_Port, RDO1_Pin, state);
}
void UPP_RDO2_Write(int state)
static void UPP_RDO2_Write(int state)
{
HAL_GPIO_WritePin(RDO2_GPIO_Port, RDO2_Pin, state);
}
void UPP_RDO3_Write(int state)
static void UPP_RDO3_Write(int state)
{
HAL_GPIO_WritePin(RDO3_GPIO_Port, RDO3_Pin, state);
}
void UPP_RDO4_Write(int state)
static void UPP_RDO4_Write(int state)
{
HAL_GPIO_WritePin(RDO4_GPIO_Port, RDO4_Pin, state);
}
void UPP_DO1_Write(int state)
static void UPP_DO1_Write(int state)
{
HAL_GPIO_WritePin(DO1_GPIO_Port, DO1_Pin, state);
}
void UPP_DO2_Write(int state)
static void UPP_DO2_Write(int state)
{
HAL_GPIO_WritePin(DO2_GPIO_Port, DO2_Pin, state);
}
void UPP_DO3_Write(int state)
static void UPP_DO3_Write(int state)
{
HAL_GPIO_WritePin(DO3_GPIO_Port, DO3_Pin, state);
}
void UPP_DO4_Write(int state)
static void UPP_DO4_Write(int state)
{
HAL_GPIO_WritePin(DO4_GPIO_Port, DO4_Pin, state);
}
void UPP_DO5_Write(int state)
static void UPP_DO5_Write(int state)
{
HAL_GPIO_WritePin(DO5_GPIO_Port, DO5_Pin, state);
}
void UPP_Connect_Discrete(void)
{
UPP_DO.CEN = &UPP_CEN_Write;
UPP_DO.RDO_Error = &UPP_RDO1_Write;
UPP_DO.RDO_Work = &UPP_RDO2_Write;
UPP_DO.RDO_Ready = &UPP_RDO3_Write;
UPP_DO.RDO4_Reserved = &UPP_RDO4_Write;
UPP_DO.DO1_Reserved = &UPP_DO1_Write;
UPP_DO.DO2_Reserved = &UPP_DO2_Write;
UPP_DO.DO3_Reserved = &UPP_DO3_Write;
UPP_DO.DO4_Reserved = &UPP_DO4_Write;
UPP_DO.DO5_Reserved = &UPP_DO5_Write;
}

48
UPP/Core/UPP/upp_io.h
View File

@ -6,10 +6,12 @@
* @details
******************************************************************************/
#ifndef _UPP_ERRORS_H
#define _UPP_ERRORS_H
#ifndef _UPP_IO_H
#define _UPP_IO_H
#include "mylibs_include.h"
typedef struct
{
/* Отладочные светодиоды */
@ -21,13 +23,15 @@ extern UPP_LEDs_t UPP_LEDS;
typedef struct
{
GPIO_SwitchTypeDef in1;
GPIO_SwitchTypeDef in2;
GPIO_SwitchTypeDef in3;
GPIO_SwitchTypeDef Pusk; ///< Команда «ПУСК»
GPIO_SwitchTypeDef MestDist; ///< Мест/дист управление
GPIO_SwitchTypeDef DIN3; ///< Резерв
GPIO_SwitchTypeDef err_24V;
GPIO_SwitchTypeDef err_5Vd;
GPIO_SwitchTypeDef err_5Vsi;
GPIO_SwitchTypeDef err_24Vdio;///< Сигнал ошибки источника питания цифровых входов/выходов
GPIO_SwitchTypeDef err_24V; ///< Сигнал ошибки основного источника питания 24В
GPIO_SwitchTypeDef err_5Vsi; ///< Сигнал ошибки источника питания цифровых интерфейсов
GPIO_SwitchTypeDef err_5Vd; ///< Вход сигнала неисправности цифрового источника питания 5В(+5Vd) микроконтроллера и микросхем ввода-вывода (5 В).
GPIO_SwitchTypeDef err_Va; ///< Вход обобщенного сигнала неисправности аналоговых источников питания +3,3В(+3Va), 5В(+5Vа), +15В(+15Va).
}UPP_DiscreteInputs_t;
extern UPP_DiscreteInputs_t UPP_DIN;
@ -35,17 +39,25 @@ typedef struct
{
void (*CEN)(int state);
void (*RDO_Error)(int state);
void (*RDO_Work)(int state);
void (*RDO_Ready)(int state);
void (*RDO4_Reserved)(int state);
void (*Error)(int state);
void (*Work)(int state);
void (*Ready)(int state);
void (*RDO4)(int state);
void (*DO1_Reserved)(int state);
void (*DO2_Reserved)(int state);
void (*DO3_Reserved)(int state);
void (*DO4_Reserved)(int state);
void (*DO5_Reserved)(int state);
void (*DO1)(int state);
void (*DO2)(int state);
void (*DO3)(int state);
void (*DO4)(int state);
void (*DO5)(int state);
}UPP_DiscreteOutputs_t;
extern UPP_DiscreteOutputs_t UPP_DO;
#endif //_UPP_ERRORS_H
/* Инициализация дискретных входов/выходов УПП */
void UPP_IO_Init(void);
/* Выставить направление UART1 (STM USART2) */
void UPP_UART1_SetDirection(int state);
/* Выставить направление UART2 (STM USART5) */
void UPP_UART2_SetDirection(int state);
#endif //_UPP_IO_H

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

@ -18,6 +18,9 @@ float iref_dbg = 0;
*/
int UPP_Init(void)
{
/* Очищаем входы */
UPP_IO_Init();
BenchTime_Init();
// Подключение указателей
upp.errors = &errors;
@ -43,6 +46,8 @@ int UPP_PreWhile(void)
UPP_Params_InternalControl();
Angle_SetRange(&upp.hangle, 0.0, 0.8);
PowerMonitor_Start(&upp.pm);
return 0;
}
@ -52,8 +57,12 @@ int UPP_PreWhile(void)
*/
int UPP_While(void)
{
int retval = 0;
if(upp.pm.f.runSlow)
{
BenchTime_Start(BT_SLOWCALC, angletim.Instance->CNT, HAL_MAX_DELAY);
UPP_DO.CEN(ENABLE);
// если ошибка вызываем СТОП
if(errors.pui.all)
{
@ -84,7 +93,14 @@ int UPP_While(void)
// Автомат состояний УПП
switch(upp.workmode)
{
/* Состояние готовности */
case WM_Ready:
PWM_Stop(&upp.hpwm, 0, 1); // Останавливаем ВЕСЬ ШИМ
// Индикация
UPP_DO.Ready(ENABLE);
UPP_DO.Work(DISABLE);
UPP_DO.Error(DISABLE);
// если пришла команда на запуск
if (upp.call->go)
{
@ -94,7 +110,12 @@ int UPP_While(void)
}
break;
/* Состояние В работе */
case WM_Running:
// Индикация
UPP_DO.Ready(DISABLE);
UPP_DO.Work(ENABLE);
UPP_DO.Error(DISABLE);
// если пришла команда на остановку
if (!upp.call->go)
upp.workmode = WM_Ready;
@ -105,32 +126,43 @@ int UPP_While(void)
// если слишком долгий запуск
if((local_time() - upp.StartTick) > (upp.PUI.params->Tdelay*1000))
{
errors.pui.err.LongStart = 1;
ERR_PRIVATE.longstart = 1;
}
break;
// /* Состояние Работа завершена */
// case WM_Done:
// // Индикация
// UPP_DO.Ready(DISABLE);
// UPP_DO.Work(DISABLE);
// UPP_DO.Error(DISABLE);
// PWM_Stop(&upp.hpwm, 0, 1); // Останавливаем ВЕСЬ ШИМ
// break;
/* Состояние Ошибки */
case WM_Error:
default:
PWM_Stop(&upp.hpwm, 0, 1); // Останавливаем ВЕСЬ ШИМ
// Индикация
UPP_DO.Ready(ENABLE);
UPP_DO.Work(DISABLE);
UPP_DO.Error(ENABLE);
// Находимся до тех пор пока ошибки не будет устранена
if(errors.common == Err_None)
upp.workmode = WM_Ready;
PWM_Stop(&upp.hpwm, 0, 1); // Останавливаем ВЕСЬ ШИМ
break;
case WM_Done:
PWM_Stop(&upp.hpwm, 0, 1); // Останавливаем ВЕСЬ ШИМ
break;
default:
retval = 1;
break;
}
upp.pm.f.runSlow = 0;
upp.Timings.slow_calc = BenchTime_End(BT_SLOWCALC, angletim.Instance->CNT);
}//if(upp.pm.f.runSlow)
else
{
}
return 0;
return retval;
}

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

@ -39,6 +39,7 @@ typedef struct
struct
{
uint32_t slow_calc;
uint32_t isr_adc;
uint32_t isr_pwm;
uint32_t isr_systick;

9
UPP/MDK-ARM/EventRecorderStub.scvd Normal file
View File

@ -0,0 +1,9 @@
<?xml version="1.0" encoding="utf-8"?>
<component_viewer schemaVersion="0.1" xmlns:xs="http://www.w3.org/2001/XMLSchema-instance" xs:noNamespaceSchemaLocation="Component_Viewer.xsd">
<component name="EventRecorderStub" version="1.0.0"/> <!--name and version of the component-->
<events>
</events>
</component_viewer>

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

@ -900,7 +900,7 @@
<Group>
<GroupName>Modbus</GroupName>
<tvExp>0</tvExp>
<tvExp>1</tvExp>
<tvExpOptDlg>0</tvExpOptDlg>
<cbSel>0</cbSel>
<RteFlg>0</RteFlg>

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

@ -17,8 +17,8 @@
<TargetCommonOption>
<Device>STM32F427ZGTx</Device>
<Vendor>STMicroelectronics</Vendor>
<PackID>Keil.STM32F4xx_DFP.2.17.1</PackID>
<PackURL>https://www.keil.com/pack/</PackURL>
<PackID>Keil.STM32F4xx_DFP.2.16.0</PackID>
<PackURL>http://www.keil.com/pack/</PackURL>
<Cpu>IRAM(0x20000000-0x2002FFFF) IRAM2(0x10000000-0x1000FFFF) IROM(0x8000000-0x80FFFFF) CLOCK(25000000) FPU2 CPUTYPE("Cortex-M4") TZ</Cpu>
<FlashUtilSpec></FlashUtilSpec>
<StartupFile></StartupFile>