wxsmart
/
controller-hd
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

“补充合并接口，并增加排底值接口”

This commit is contained in:
gaoyuhang 2024-05-13 15:14:11 +08:00
parent f784f13bac
commit e0b6462ab6
3 changed files with 243 additions and 96 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
.vscode/settings.json vendored
View File

@ -1,3 +1,6 @@
{ {
"C_Cpp.errorSquiggles": "disabled" "C_Cpp.errorSquiggles": "disabled",
"files.associations": {
"cmath": "c"
}
} }

275
User/application/mode/mode_pwmp_hd.c
View File

@ -23,7 +23,6 @@ pwmp_hd_adjust_t *mode_pwmp_hd_adjust;
pid_autotune_hd_t *pid_autotune_hd; pid_autotune_hd_t *pid_autotune_hd;
pwmp_hd_test_t *mode_pwmp_hd_test; pwmp_hd_test_t *mode_pwmp_hd_test;
execute_rsp_hd_t rsp; // 执行结果 execute_rsp_hd_t rsp; // 执行结果
mode_pwmp_hd_valve_type_e valve_type_hd = ANGULAR_TRAVEL;
static execute_rsp_hd_t *execute_dac_plan1(void); // 执行方案1 static execute_rsp_hd_t *execute_dac_plan1(void); // 执行方案1
static execute_rsp_hd_t *execute_dac_plan2(void); // 执行方案2 static execute_rsp_hd_t *execute_dac_plan2(void); // 执行方案2
@ -53,39 +52,45 @@ static void _adjust_stop(void)
static uint8_t _adjust_result(void) static uint8_t _adjust_result(void)
{ {
if (mode_pwmp_hd->process_state == PWMP_HD_PROCESS_ADJUST) if (mode_pwmp_hd->pwmp_save->storage.tuned_flag == TUNED_ONGOING)
{ {
return TUNED_ONGOING; udevice.tuned_flag = TUNED_ONGOING;
}
else if (mode_pwmp_hd->pwmp_save->storage.tuned_flag == TUNED_SUCCESS)
{
udevice.tuned_flag = TUNED_SUCCESS;
} }
else else
{ {
return mode_pwmp_hd->pwmp_save->storage.tuned_flag; udevice.tuned_flag = TUNED_FAILED;
} }
return udevice.tuned_flag;
} }
static uint8_t _adjust_step_count(void) static uint8_t _adjust_step_count(void)
{ {
return LCD_ADJUST_STOP; return mode_pwmp_hd->lcd_adjust_state;
} }
static uint8_t _adjust_step_current(void) static uint8_t _adjust_step_current(void)
{ {
return LCD_ADJUST_IDEL; return mode_pwmp_hd_adjust->adjust_state;
} }
static void _adjust_data(mode_adjust_data_t *data) static void _adjust_data(mode_adjust_data_t *data)
{ {
// data->pos0 = mode_control->storage_data->storage.ad_0; ///< 位置0 ad data->pos0 = mode_pwmp_hd->pwmp_save->storage.trip_0; ///< 位置0 ad
// data->pos100 = mode_control->storage_data->storage.ad_100; ///< 位置100 ad data->pos100 = mode_pwmp_hd->pwmp_save->storage.trip_100; ///< 位置100 ad
// data->pot0 = mode_control->storage_data->storage.aerate_min_arr; ///< 位置0 输出 data->pot0 = mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin; ///< 位置0 输出
// data->pot100 = mode_control->storage_data->storage.aerate_max_arr; ///< 位置100 输出 data->pot100 = mode_pwmp_hd->pwmp_save->storage.pwmp_max_origin; ///< 位置100 输出
// data->current0 = mode_control->storage_data->storage.aerate_min_current; ///< 位置0 电流(毫安，放大100倍, 0.01ma=1) data->current0 = mode_pwmp_hd->pwmp_save->storage.current0; ///< 位置0 电流(毫安，放大100倍, 0.01ma=1)
// data->current100 = mode_control->storage_data->storage.aerate_max_current; ///< 位置100 电流(毫安,放大100倍，0.01ma=1) data->current100 = mode_pwmp_hd->pwmp_save->storage.current100; ///< 位置100 电流(毫安,放大100倍，0.01ma=1)
// data->open_time = mode_control->storage_data->storage.all_open_time; ///< 全开时间(秒) data->open_time = mode_pwmp_hd->pwmp_save->storage.all_open_time; ///< 全开时间(秒)
// data->close_time = mode_control->storage_data->storage.all_close_time; ///< 全关时间(秒) data->close_time = mode_pwmp_hd->pwmp_save->storage.all_close_time; ///< 全关时间(秒)
// data->kp = mode_control->storage_data->storage.kp; ///< pid 比例系数 data->kp = mode_pwmp_hd->pwmp_save->storage.kp; ///< pid 比例系数
// data->ki = mode_control->storage_data->storage.ki; ///< pid 积分系数 data->ki = mode_pwmp_hd->pwmp_save->storage.ki; ///< pid 积分系数
// data->kd = mode_control->storage_data->storage.kd; ///< pid 微分系数 data->kd = mode_pwmp_hd->pwmp_save->storage.kd; ///< pid 微分系数
} }
static BOOL _control_idle(void) static BOOL _control_idle(void)
@ -101,7 +106,7 @@ static BOOL _adjust_isrun(void)
/*程序状态设置*/ /*程序状态设置*/
void pwmp_hd_process_state_set(mode_pwmp_hd_process_state_e state) void pwmp_hd_process_state_set(mode_pwmp_hd_process_state_e state)
{ {
if (mode_pwmp_hd->process_state == state && mode_pwmp_hd->adjust_state == PWMP_HD_PROCESS_ADJUST) if (mode_pwmp_hd->process_state == state && mode_pwmp_hd->process_state == PWMP_HD_PROCESS_ADJUST)
{ {
mode_pwmp_hd->process_state = PWMP_HD_PROCESS_STOP; mode_pwmp_hd->process_state = PWMP_HD_PROCESS_STOP;
} }
@ -184,7 +189,7 @@ static float32 get_pwmp_hd_control_ki(void)
static float32 get_pwmp_hd_control_kd(void) static float32 get_pwmp_hd_control_kd(void)
{ {
// return mode_pwmp_hd->pwmp_save->storage.kd < 0.01 ? mode_pwmp_hd->pwmp_save->storage.kd : 0.001; // return mode_pwmp_hd->pwmp_save->storage.kd < 0.01 ? mode_pwmp_hd->pwmp_save->storage.kd : 0.001;
if (valve_type_hd == LINEAR_TRAVEL) if (udevice.value_travel_type == TRAVEL_TYPE_STRAIGHT)
{ {
return mode_pwmp_hd->pwmp_save->storage.kd = 0; return mode_pwmp_hd->pwmp_save->storage.kd = 0;
} }
@ -215,18 +220,12 @@ static void pwmp_public_params_update()
udevice.tuned_flag = mode_pwmp_hd->pwmp_save->storage.prov_flag; udevice.tuned_flag = mode_pwmp_hd->pwmp_save->storage.prov_flag;
} }
/*程序反初始化*/
void mode_pwmp_hd_dinit(void)
{
if (mode_pwmp_hd != NULL)
{
pwmp_hd_process_state_set(PWMP_HD_PROCESS_STOP);
osel_mem_free(mode_pwmp_hd);
mode_pwmp_hd = NULL;
}
}
//////////////////////////////*控制BEGIN*////////////////////////////////////////////////////// //////////////////////////////*控制BEGIN*//////////////////////////////////////////////////////
void mode_pwmp_hd_stop(mode_pwmp_hd_t *handle)
{
// 释放内存
osel_memset((uint8_t *)&handle->control, 0, sizeof(mode_pwmp_hd_control_t));
}
/** /**
* @brief 算法方案初始化 * @brief 算法方案初始化
@ -291,7 +290,7 @@ static execute_rsp_hd_t *execute_dac_plan1()
_pid.pid_u.hd.set_out_prm_position(&_pid.pid_u.hd, 100, 0); _pid.pid_u.hd.set_out_prm_position(&_pid.pid_u.hd, 100, 0);
out = _pid.pid_u.hd.pid_position(&_pid.pid_u.hd, mode_pwmp_hd->control.real_error); out = _pid.pid_u.hd.pid_position(&_pid.pid_u.hd, mode_pwmp_hd->control.real_error);
out = out / 100; out = out / 100;
if (valve_type_hd == LINEAR_TRAVEL) if (udevice.value_travel_type == TRAVEL_TYPE_STRAIGHT)
{ {
/* 一阶段加权系数*/ /* 一阶段加权系数*/
static float32 index_min_first = 0.5; static float32 index_min_first = 0.5;
@ -315,8 +314,9 @@ static execute_rsp_hd_t *execute_dac_plan1()
out += mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin; out += mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin;
} }
} }
else if (valve_type_hd == ANGULAR_TRAVEL) else if (udevice.value_travel_type == TRAVEL_TYPE_ANGULAR)
{ {
#if 0
/* 一阶段加权系数*/ /* 一阶段加权系数*/
static float32 index_min_first = 1.2; static float32 index_min_first = 1.2;
static float32 index_max_first = 1.2; static float32 index_max_first = 1.2;
@ -341,6 +341,23 @@ static execute_rsp_hd_t *execute_dac_plan1()
out *= (mode_pwmp_hd->pwmp_save->storage.pwmp_max_origin - Control_diff * index_max_third) - (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin + Control_diff * index_min_third); // 映射实际控制器的范围 out *= (mode_pwmp_hd->pwmp_save->storage.pwmp_max_origin - Control_diff * index_max_third) - (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin + Control_diff * index_min_third); // 映射实际控制器的范围
out += (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin + Control_diff * index_min_third); out += (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin + Control_diff * index_min_third);
} }
#else
float32 index = fabs(1 - exp(-(pow(mode_pwmp_hd->control.real_error, 2) - 1)));
if (fabs(mode_pwmp_hd->control.real_error) >= 1)
{
out *= (mode_pwmp_hd->pwmp_save->storage.pwmp_max_origin + Control_diff * index) - (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin - Control_diff * index); // 映射实际控制器的范围
out += mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin - Control_diff * index;
}
else if (fabs(mode_pwmp_hd->control.real_error) > 0.99 && fabs(mode_pwmp_hd->control.real_error) < 1)
{
out = mode_pwmp_hd->pwmp_save->storage.startup_value;
}
else if (fabs(mode_pwmp_hd->control.real_error) < 1)
{
out *= (mode_pwmp_hd->pwmp_save->storage.pwmp_max_origin) - (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin); // 映射实际控制器的范围
out += (mode_pwmp_hd->pwmp_save->storage.pwmp_min_origin);
}
#endif
} }
rsp.code = EXECUTE_HD_OUT; rsp.code = EXECUTE_HD_OUT;
@ -438,6 +455,7 @@ static void pwmp_adjust_hd_idle(uint8_t *state, mode_pwmp_hd_adjust_state_e next
{ {
if (!FSM_IS_WAIT(*state)) if (!FSM_IS_WAIT(*state))
{ {
mode_pwmp_hd->auto_tune_state = PWMP_HD_ADJUST_RESULT_TUNING;
sys_millis_reset(); sys_millis_reset();
osel_memset((uint8_t *)&mode_pwmp_hd->pwmp_save->storage, 0, sizeof(mode_pwmp_hd_storage_data_t)); osel_memset((uint8_t *)&mode_pwmp_hd->pwmp_save->storage, 0, sizeof(mode_pwmp_hd_storage_data_t));
mode_pwmp_hd->pwmp_save->storage.tuned_flag = TUNED_ONGOING; mode_pwmp_hd->pwmp_save->storage.tuned_flag = TUNED_ONGOING;
@ -473,6 +491,15 @@ static void pwmp_adjust_hd_idle(uint8_t *state, mode_pwmp_hd_adjust_state_e next
// 位置不再改变，记录此时阀门位置AD值 // 位置不再改变，记录此时阀门位置AD值
mode_pwmp_hd_adjust->adc_record_1 = pid_autotune_hd->data.adjust_tmp_actual; mode_pwmp_hd_adjust->adc_record_1 = pid_autotune_hd->data.adjust_tmp_actual;
mode_pwmp_hd_adjust->adc_record_0 = pid_autotune_hd->data.adjust_tmp_actual; mode_pwmp_hd_adjust->adc_record_0 = pid_autotune_hd->data.adjust_tmp_actual;
// 记录0位置电流的大小
if (udevice.value_action_type == ATO)
{
mode_pwmp_hd_adjust->current_0 = ip2current();
}
else
{
mode_pwmp_hd_adjust->current_100 = ip2current();
}
break; break;
case POSITION_CHANGE: case POSITION_CHANGE:
*state = PWMP_HD_ADJUST_IDEL; *state = PWMP_HD_ADJUST_IDEL;
@ -493,7 +520,7 @@ static void pwmp_adjust_hd_rough_position0(uint8_t *state, mode_pwmp_hd_adjust_s
if (!FSM_IS_WAIT(*state)) if (!FSM_IS_WAIT(*state))
{ {
// 以10%增加，提高DAC输出，找到能推动阀门的最小值 // 以10%增加，提高DAC输出，找到能推动阀门的最小值
mode_pwmp_hd_adjust->arr_current = 100; mode_pwmp_hd_adjust->arr_current = 200;
mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current; mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current;
pdctrl_out(mode_pwmp_hd_adjust->arr_current); pdctrl_out(mode_pwmp_hd_adjust->arr_current);
mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 20; mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 20;
@ -506,7 +533,7 @@ static void pwmp_adjust_hd_rough_position0(uint8_t *state, mode_pwmp_hd_adjust_s
current_adc = pid_autotune_hd->data.adjust_tmp_actual; current_adc = pid_autotune_hd->data.adjust_tmp_actual;
// 3.28修改：将DIFF_ADC_MAX由10改为6 // 3.28修改：将DIFF_ADC_MAX由10改为6
if (ABS(current_adc - mode_pwmp_hd_adjust->adc_record_1) >= 20U) // 阀位发生改变 if (ABS(current_adc - mode_pwmp_hd_adjust->adc_record_1) >= 10U) // 阀位发生改变
{ {
if (mode_pwmp_hd_adjust->arr_last > 4000) if (mode_pwmp_hd_adjust->arr_last > 4000)
{ {
@ -536,11 +563,11 @@ static void pwmp_adjust_hd_rough_position0(uint8_t *state, mode_pwmp_hd_adjust_s
mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current; mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current;
if (mode_pwmp_hd_adjust->arr_last < 500) if (mode_pwmp_hd_adjust->arr_last < 500)
{ {
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_current * 1.05; mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_current * 1.1;
} }
else else
{ {
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_current * 1.02; mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_current * 1.05;
} }
/*若输出信号为最大值时认定为整定错误*/ /*若输出信号为最大值时认定为整定错误*/
if (mode_pwmp_hd_adjust->arr_current > 4000) if (mode_pwmp_hd_adjust->arr_current > 4000)
@ -549,9 +576,8 @@ static void pwmp_adjust_hd_rough_position0(uint8_t *state, mode_pwmp_hd_adjust_s
*state = PWMP_HD_ADJUST_FAIL; *state = PWMP_HD_ADJUST_FAIL;
return; return;
} }
pdctrl_out(mode_pwmp_hd_adjust->arr_current); pdctrl_out(mode_pwmp_hd_adjust->arr_current);
mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 40; mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 30;
*state = PWMP_HD_ADJUST_ROUGH_POSITION0; *state = PWMP_HD_ADJUST_ROUGH_POSITION0;
FSM_WAIT(*state); // 设置等待状态 FSM_WAIT(*state); // 设置等待状态
} }
@ -576,7 +602,7 @@ static void pwmp_adjust_hd_rough_position0(uint8_t *state, mode_pwmp_hd_adjust_s
} }
/*放气值（0信号）的整定*/ /*放气值（0信号）的整定*/
static void pwmp_adjust_hd_bleeding_position0(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state) static void pwmp_adjust_hd_initiate_position0(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state)
{ {
BOOL flag = FALSE; BOOL flag = FALSE;
mode_pwmp_hd_adjust->psb_adc = get_actual_travel_adc(); mode_pwmp_hd_adjust->psb_adc = get_actual_travel_adc();
@ -763,8 +789,15 @@ static void pwmp_adjust_hd_rough_position100(uint8_t *state, mode_pwmp_hd_adjust
// 等待放气完毕 // 等待放气完毕
return; return;
} }
sys_millis_reset();
mode_pwmp_hd_adjust->all_open_time_full = sys_millis(); // 记录全开起始时间 if (udevice.value_action_type == ATO) // 若调节阀为气开阀
{
mode_pwmp_hd_adjust->all_open_time_full = sys_millis(); // 记录满信号全开起始时间
}
else
{
mode_pwmp_hd_adjust->all_close_time_full = sys_millis(); // 记录满信号全关起始时间
}
mode_pwmp_hd_adjust->tmp_time = 0; mode_pwmp_hd_adjust->tmp_time = 0;
pdctrl_out(mode_pwmp_hd_adjust->arr_record_2); // 以最大值进行输出 pdctrl_out(mode_pwmp_hd_adjust->arr_record_2); // 以最大值进行输出
@ -782,7 +815,16 @@ static void pwmp_adjust_hd_rough_position100(uint8_t *state, mode_pwmp_hd_adjust
case POSITION_NO_CHANGE_FOREVER: case POSITION_NO_CHANGE_FOREVER:
// 位置不再改变，记录此时阀门位置AD值 // 位置不再改变，记录此时阀门位置AD值
mode_pwmp_hd_adjust->adc_record_2 = current_adc; mode_pwmp_hd_adjust->adc_record_2 = current_adc;
mode_pwmp_hd_adjust->all_open_time_full = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_open_time_full; if (udevice.value_action_type == ATO) // 若调节阀为气开阀
{
mode_pwmp_hd_adjust->tmp_time = sys_millis();
mode_pwmp_hd_adjust->all_open_time_full = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_open_time_full;
}
else // 若调节阀为气关阀
{
mode_pwmp_hd_adjust->tmp_time = sys_millis();
mode_pwmp_hd_adjust->all_close_time_full = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_close_time_full;
}
break; break;
case POSITION_CHANGE: case POSITION_CHANGE:
mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 50; mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 50;
@ -800,12 +842,41 @@ static void pwmp_adjust_hd_rough_position100(uint8_t *state, mode_pwmp_hd_adjust
} }
} }
/*排气值整定*/
static void pwmp_adjust_hd_bleeding_position0(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state)
{
if (!FSM_IS_WAIT(*state))
{
mode_pwmp_hd_adjust->adjust_state = (mode_pwmp_hd_adjust_state_e)*state;
FSM_WAIT(*state); // 设置等待状态
}
else
{
valve_position_change_e s = pwmp_adjust_hd_valve_position_change(state, next_state, DIFF_ADC);
mode_pwmp_hd_adjust->psb_adc = pid_autotune_hd->data.adjust_tmp_actual;
switch (s)
{
case POSITION_NO_CHANGE_FOREVER: // 位置不再改变
{
break;
}
case POSITION_CHANGE:
break;
default:
break;
}
}
}
/*精调冲顶值*/ /*精调冲顶值*/
static void pwmp_adjust_hd_accurate_position100(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state) static void pwmp_adjust_hd_accurate_position100(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state)
{ {
if (!FSM_IS_WAIT(*state)) if (!FSM_IS_WAIT(*state))
{ {
mode_pwmp_hd_adjust->all_close_time_flag = TRUE; mode_pwmp_hd_adjust->all_bleed_time_flag = true;
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_1; // 初始值为前一步整定出的最小启动值 mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_1; // 初始值为前一步整定出的最小启动值
mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current; mode_pwmp_hd_adjust->arr_last = mode_pwmp_hd_adjust->arr_current;
mode_pwmp_hd_adjust->adjust_state = (mode_pwmp_hd_adjust_state_e)*state; mode_pwmp_hd_adjust->adjust_state = (mode_pwmp_hd_adjust_state_e)*state;
@ -837,7 +908,17 @@ static void pwmp_adjust_hd_accurate_position100(uint8_t *state, mode_pwmp_hd_adj
if (adc_diff <= 10) if (adc_diff <= 10)
{ {
*state = next_state; *state = next_state;
// 记录在100阀位的adc值
mode_pwmp_hd_adjust->arr_record_2 = mode_pwmp_hd_adjust->arr_current; mode_pwmp_hd_adjust->arr_record_2 = mode_pwmp_hd_adjust->arr_current;
// 记录在100阀位时的电流大小
if (udevice.value_action_type == ATO)
{
mode_pwmp_hd_adjust->current_100 = ip2current();
}
else
{
mode_pwmp_hd_adjust->current_0 = ip2current();
}
} }
else else
{ {
@ -892,7 +973,15 @@ static void pwmp_adjust_hd_all_close_time(uint8_t *state, mode_pwmp_hd_adjust_st
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_0 - 100; // 此处的输入信号大小根据实际控制的最小值来设定 mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_0 - 100; // 此处的输入信号大小根据实际控制的最小值来设定
/*记录起始的全开时间*/ /*记录起始的全开时间*/
mode_pwmp_hd_adjust->all_close_time = sys_millis(); sys_millis_reset();
if (udevice.value_action_type == ATO)
{
mode_pwmp_hd_adjust->all_close_time = sys_millis();
}
else
{
mode_pwmp_hd_adjust->all_open_time = sys_millis();
}
mode_pwmp_hd_adjust->tmp_time = 0; mode_pwmp_hd_adjust->tmp_time = 0;
pdctrl_out(mode_pwmp_hd_adjust->arr_current); pdctrl_out(mode_pwmp_hd_adjust->arr_current);
@ -926,7 +1015,15 @@ static void pwmp_adjust_hd_all_open_time(uint8_t *state, mode_pwmp_hd_adjust_sta
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_2 + 100; // 此处的输入信号大小根据实际控制的最大值来设定 mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_record_2 + 100; // 此处的输入信号大小根据实际控制的最大值来设定
/*记录起始的全开时间*/ /*记录起始的全开时间*/
mode_pwmp_hd_adjust->all_open_time = sys_millis(); sys_millis_reset();
if (udevice.value_action_type == ATO)
{
mode_pwmp_hd_adjust->all_open_time = sys_millis();
}
else
{
mode_pwmp_hd_adjust->all_close_time = sys_millis();
}
mode_pwmp_hd_adjust->tmp_time = 0; mode_pwmp_hd_adjust->tmp_time = 0;
pdctrl_out(mode_pwmp_hd_adjust->arr_current); pdctrl_out(mode_pwmp_hd_adjust->arr_current);
@ -945,7 +1042,7 @@ static void pwmp_adjust_hd_all_open_time(uint8_t *state, mode_pwmp_hd_adjust_sta
else else
{ {
mode_pwmp_hd_adjust->tmp_time = sys_millis(); mode_pwmp_hd_adjust->tmp_time = sys_millis();
mode_pwmp_hd_adjust->all_close_time = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_open_time; mode_pwmp_hd_adjust->all_close_time = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_close_time;
} }
*state = next_state; *state = next_state;
} }
@ -970,12 +1067,18 @@ static void pwmp_adjust_hd_calculate(uint8_t *state, mode_pwmp_hd_adjust_state_e
mode_pwmp_hd->pwmp_save->storage.pwmp_min = mode_pwmp_hd_adjust->arr_record_0 - (mode_pwmp_hd->pwmp_save->storage.arr_diff); mode_pwmp_hd->pwmp_save->storage.pwmp_min = mode_pwmp_hd_adjust->arr_record_0 - (mode_pwmp_hd->pwmp_save->storage.arr_diff);
/*启动值*/ /*启动值*/
mode_pwmp_hd->pwmp_save->storage.startup_value = mode_pwmp_hd_adjust->adc_record_1; mode_pwmp_hd->pwmp_save->storage.startup_value = mode_pwmp_hd_adjust->arr_record_1;
/*0与100阀位位置*/
mode_pwmp_hd->pwmp_save->storage.current0 = mode_pwmp_hd_adjust->current_0;
mode_pwmp_hd->pwmp_save->storage.current100 = mode_pwmp_hd_adjust->current_100;
/*全开及全关时间*/ /*全开及全关时间*/
mode_pwmp_hd->pwmp_save->storage.all_open_time = mode_pwmp_hd_adjust->all_open_time; mode_pwmp_hd->pwmp_save->storage.all_open_time = mode_pwmp_hd_adjust->all_open_time;
mode_pwmp_hd->pwmp_save->storage.all_close_time = mode_pwmp_hd_adjust->all_close_time; mode_pwmp_hd->pwmp_save->storage.all_close_time = mode_pwmp_hd_adjust->all_close_time;
mode_pwmp_hd->pwmp_save->storage.all_open_time_full = mode_pwmp_hd_adjust->all_open_time_full; mode_pwmp_hd->pwmp_save->storage.all_open_time_full = mode_pwmp_hd_adjust->all_open_time_full;
mode_pwmp_hd->pwmp_save->storage.all_close_time_full = mode_pwmp_hd_adjust->all_close_time_full;
/*判断调节阀类型（气开/气关），对最低行程和最高行程进行标定*/ /*判断调节阀类型（气开/气关），对最低行程和最高行程进行标定*/
if (udevice.value_action_type == ATO) if (udevice.value_action_type == ATO)
{ {
@ -1021,6 +1124,19 @@ static void pwmp_adjust_hd_bleeding(uint8_t *state)
{ {
mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_default; mode_pwmp_hd_adjust->arr_current = mode_pwmp_hd_adjust->arr_default;
mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 80; mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 80;
if (mode_pwmp_hd_adjust->all_bleed_time_flag == true)
{
sys_millis_reset();
if (udevice.value_action_type == ATO)
{
mode_pwmp_hd_adjust->all_close_time_full = sys_millis();
}
else
{
mode_pwmp_hd_adjust->all_open_time_full = sys_millis();
}
mode_pwmp_hd_adjust->tmp_time = 0;
}
pdctrl_out(0); pdctrl_out(0);
FSM_WAIT(*state); // 设置等待状态 FSM_WAIT(*state); // 设置等待状态
} }
@ -1031,13 +1147,22 @@ static void pwmp_adjust_hd_bleeding(uint8_t *state)
switch (s) switch (s)
{ {
case POSITION_NO_CHANGE_FOREVER: case POSITION_NO_CHANGE_FOREVER:
if (mode_pwmp_hd_adjust->all_bleed_time_flag == true)
{
if (udevice.value_action_type == ATO) // 若调节阀为气开阀
{
mode_pwmp_hd_adjust->tmp_time = sys_millis();
mode_pwmp_hd_adjust->all_close_time_full = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_close_time_full;
}
else // 若调节阀为气关阀
{
mode_pwmp_hd_adjust->tmp_time = sys_millis();
mode_pwmp_hd_adjust->all_open_time_full = mode_pwmp_hd_adjust->tmp_time - mode_pwmp_hd_adjust->all_open_time_full;
}
mode_pwmp_hd_adjust->all_bleed_time_flag = false;
}
mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 50; // 排气状态结束后在跳转后的状态中等待5s mode_pwmp_hd_adjust->wait_count = mode_pwmp_hd->wait_count_max * 50; // 排气状态结束后在跳转后的状态中等待5s
mode_pwmp_hd_adjust->arr_current = 0; mode_pwmp_hd_adjust->arr_current = 0;
// if (mode_pwmp_hd_adjust->psb_adc != mode_pwmp_hd_adjust->adc_record_1)
// {
// mode_pwmp_hd_adjust->adc_record_1 = mode_pwmp_hd_adjust->psb_adc;
// mode_pwmp_hd->pwmp_save->storage.trip_0 = mode_pwmp_hd_adjust->psb_adc;
// }
break; break;
case POSITION_CHANGE: case POSITION_CHANGE:
if (mode_pwmp_hd_adjust->adc_record_0 == 0) if (mode_pwmp_hd_adjust->adc_record_0 == 0)
@ -1053,21 +1178,20 @@ static void pwmp_adjust_hd_bleeding(uint8_t *state)
case POSITION_NO_CHANGE: case POSITION_NO_CHANGE:
break; break;
default: default:
*state = PWMP_HD_ADJUST_STOP; pwmp_hd_process_state_set(PWMP_HD_PROCESS_ADJUST_STOP);
break; break;
} }
} }
} }
/*停止模式*/ /*停止模式*/
static void pwmp_adjust_hd_stop(uint8_t *state) static void pwmp_adjust_hd_stop()
{ {
if (mode_pwmp_hd_adjust != NULL) if (mode_pwmp_hd_adjust != NULL)
{ {
osel_mem_free(mode_pwmp_hd_adjust); osel_mem_free(mode_pwmp_hd_adjust);
mode_pwmp_hd_adjust = NULL; mode_pwmp_hd_adjust = NULL;
} }
*state = PWMP_HD_ADJUST_IDEL;
if (mode_pwmp_hd->auto_tune_state == PWMP_HD_ADJUST_RESULT_TUNING) if (mode_pwmp_hd->auto_tune_state == PWMP_HD_ADJUST_RESULT_TUNING)
{ {
mode_pwmp_hd->auto_tune_state = PWMP_HD_ADJUST_RESULT_IDEL; mode_pwmp_hd->auto_tune_state = PWMP_HD_ADJUST_RESULT_IDEL;
@ -1089,7 +1213,6 @@ static void pwmp_adjust_hd_fail(uint8_t *state)
/*PID参数整定模式*/ /*PID参数整定模式*/
// 通过整定获得K、T、L（tao） // 通过整定获得K、T、L（tao）
int s_watch;
static void pwmp_adjust_hd_PID_tuning(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state) static void pwmp_adjust_hd_PID_tuning(uint8_t *state, mode_pwmp_hd_adjust_state_e next_state)
{ {
if (!FSM_IS_WAIT(*state)) if (!FSM_IS_WAIT(*state))
@ -1109,7 +1232,6 @@ static void pwmp_adjust_hd_PID_tuning(uint8_t *state, mode_pwmp_hd_adjust_state_
else else
{ {
valve_position_change_e s = pwmp_adjust_hd_valve_position_change(state, next_state, DIFF_ADC); valve_position_change_e s = pwmp_adjust_hd_valve_position_change(state, next_state, DIFF_ADC);
s_watch = s;
/*获取实时行程*/ /*获取实时行程*/
pid_autotune_hd->data.cur_actual = pid_autotune_hd->data.adjust_tmp_actual; pid_autotune_hd->data.cur_actual = pid_autotune_hd->data.adjust_tmp_actual;
/*计算变化率*/ /*计算变化率*/
@ -1158,7 +1280,7 @@ static void pwmp_adjust_hd_PID_tuning(uint8_t *state, mode_pwmp_hd_adjust_state_
case POSITION_NO_CHANGE: case POSITION_NO_CHANGE:
break; break;
default: default:
*state = PWMP_HD_ADJUST_STOP; pwmp_hd_process_state_set(PWMP_HD_PROCESS_ADJUST_STOP);
break; break;
} }
} }
@ -1234,13 +1356,16 @@ void pwmp_adjust(uint8_t *state)
switch (ts) switch (ts)
{ {
case PWMP_HD_ADJUST_ROUGH_POSITION0: case PWMP_HD_ADJUST_ROUGH_POSITION0:
pwmp_adjust_hd_rough_position0(state, PWMP_HD_ADJUST_BLEEDING_POSITION0); pwmp_adjust_hd_rough_position0(state, PWMP_HD_ADJUST_INITIATE);
break; break;
case PWMP_HD_ADJUST_BLEEDING_POSITION0: case PWMP_HD_ADJUST_INITIATE:
pwmp_adjust_hd_bleeding_position0(state, PWMP_HD_ADJUST_ROUGH_POSITION100); pwmp_adjust_hd_initiate_position0(state, PWMP_HD_ADJUST_ROUGH_POSITION100);
break; break;
case PWMP_HD_ADJUST_ROUGH_POSITION100: case PWMP_HD_ADJUST_ROUGH_POSITION100:
pwmp_adjust_hd_rough_position100(state, PWMP_HD_ADJUST_ACCURATE_POSITION100); pwmp_adjust_hd_rough_position100(state, PWMP_HD_ADJUST_BLEEDING_POSITION0);
break;
case PWMP_HD_ADJUST_BLEEDING_POSITION0:
pwmp_adjust_hd_bleeding_position0(state, PWMP_HD_ADJUST_ACCURATE_POSITION100);
break; break;
case PWMP_HD_ADJUST_ACCURATE_POSITION100: case PWMP_HD_ADJUST_ACCURATE_POSITION100:
pwmp_adjust_hd_accurate_position100(state, PWMP_HD_ADJUST_ALL_CLOSE_TIME); pwmp_adjust_hd_accurate_position100(state, PWMP_HD_ADJUST_ALL_CLOSE_TIME);
@ -1270,14 +1395,14 @@ void pwmp_adjust(uint8_t *state)
pwmp_adjust_hd_idle(state, PWMP_HD_ADJUST_ROUGH_POSITION0); pwmp_adjust_hd_idle(state, PWMP_HD_ADJUST_ROUGH_POSITION0);
break; break;
case PWMP_HD_ADJUST_STOP: case PWMP_HD_ADJUST_STOP:
pwmp_adjust_hd_stop(state); pwmp_hd_process_state_set(PWMP_HD_PROCESS_ADJUST_STOP);
break; break;
case PWMP_HD_ADJUST_FAIL: case PWMP_HD_ADJUST_FAIL:
pwmp_adjust_hd_fail(state); pwmp_adjust_hd_fail(state);
pwmp_adjust_hd_stop(state); pwmp_hd_process_state_set(PWMP_HD_PROCESS_ADJUST_STOP);
break; break;
default: default:
pwmp_adjust_hd_stop(state); pwmp_hd_process_state_set(PWMP_HD_PROCESS_ADJUST_STOP);
break; break;
} }
@ -1679,11 +1804,18 @@ void mode_pwmp_hd_process(void)
break; break;
} }
case PWMP_HD_PROCESS_ADJUST: case PWMP_HD_PROCESS_ADJUST:
{
pwmp_adjust((uint8_t *)&mode_pwmp_hd->adjust_state); pwmp_adjust((uint8_t *)&mode_pwmp_hd->adjust_state);
break; break;
}
case PWMP_HD_PROCESS_ADJUST_STOP:
{
pwmp_adjust_hd_stop();
break;
}
case PWMP_HD_PROCESS_STOP: case PWMP_HD_PROCESS_STOP:
{ {
// TODO 完成停止自整定，并释放资源 mode_pwmp_hd_stop((mode_pwmp_hd_t *)&mode_pwmp_hd);
break; break;
} }
case PWMP_HD_PROCESS_TEST: case PWMP_HD_PROCESS_TEST:
@ -1755,3 +1887,14 @@ void mode_pwmp_hd_init(mode_interface_req_t *req, uint16_t positioner_model, mod
pwmp_public_params_update(); pwmp_public_params_update();
calib_parapos_perent(); calib_parapos_perent();
} }
/*程序反初始化*/
void mode_pwmp_hd_dinit(void)
{
if (mode_pwmp_hd != NULL)
{
pwmp_hd_process_state_set(PWMP_HD_PROCESS_STOP);
osel_mem_free(mode_pwmp_hd);
mode_pwmp_hd = NULL;
}
}

59
User/application/mode/mode_pwmp_hd.h
View File

@ -20,11 +20,6 @@
/*----------------------------------------*/ /*----------------------------------------*/
typedef enum typedef enum
{
ANGULAR_TRAVEL,
LINEAR_TRAVEL,
} mode_pwmp_hd_valve_type_e; // 阀门类型
typedef enum
{ {
PWMP_HD_PROCESS_CONTROL, PWMP_HD_PROCESS_CONTROL,
PWMP_HD_PROCESS_ADJUST, PWMP_HD_PROCESS_ADJUST,
@ -36,25 +31,26 @@ typedef enum
/*需要存储的变量*/ /*需要存储的变量*/
typedef struct typedef struct
{ {
uint8_t tuned_flag; // 整定标志 0：未整定，1：整定中，2：整定成功，3：整定失败 uint8_t tuned_flag; // 整定标志 0：未整定，1：整定中，2：整定成功，3：整定失败
uint16_t startup_value; // 阀位启动值 uint16_t startup_value; // 阀位启动值
uint16_t arr_diff; // 控制区间 uint16_t arr_diff; // 控制区间
uint16_t ad_diff; // 磁条区间 uint16_t ad_diff; // 磁条区间
uint16_t pwmp_min; // 控制最小值 uint16_t pwmp_min; // 控制最小值
uint16_t pwmp_max; // 控制最大值 uint16_t pwmp_max; // 控制最大值
uint16_t pwmp_min_origin; // 整定控制最小值 uint16_t pwmp_min_origin; // 整定控制最小值
uint16_t pwmp_max_origin; // 整定控制最大值 uint16_t pwmp_max_origin; // 整定控制最大值
uint16_t trip_0; // 磁条0位置AD uint16_t trip_0; // 磁条0位置AD
uint16_t trip_100; // 词条100位置AD uint16_t trip_100; // 词条100位置AD
uint16_t trip_min0; // 小回路行程0位置AD uint16_t trip_min0; // 小回路行程0位置AD
uint16_t trip_min100; // 小回路行程100位置AD uint16_t trip_min100; // 小回路行程100位置AD
uint16_t current0; // 电流最小值 uint16_t current0; // 电流最小值
uint16_t current100; // 电流最大值 uint16_t current100; // 电流最大值
uint16_t all_open_time; // 全开时间 uint16_t all_open_time; // 全开时间
uint16_t all_close_time; // 全关时间 uint16_t all_close_time; // 全关时间
uint16_t all_open_time_full; // 最大信号全开时间 uint16_t all_open_time_full; // 最大信号全开时间
uint16_t prov_flag; // 磁条安装的正反：倒装：0 正装：1 uint16_t all_close_time_full; // 最大信号全关时间
uint16_t valve_type; // 阀门正反行程：气开：ATO 气关：ATC uint16_t prov_flag; // 磁条安装的正反：倒装：0 正装：1
uint16_t valve_type; // 阀门正反行程：气开：ATO 气关：ATC
float32 kp; float32 kp;
float32 ki; float32 ki;
float32 kd; float32 kd;
@ -165,6 +161,7 @@ typedef enum
PWMP_HD_ADJUST_SAVE, // 存储变量 PWMP_HD_ADJUST_SAVE, // 存储变量
PWMP_HD_ADJUST_BLEEDING, // 在整定状态中放气 PWMP_HD_ADJUST_BLEEDING, // 在整定状态中放气
PWMP_HD_ADJUST_BLEEDING_POSITION0, // 放气位置0 PWMP_HD_ADJUST_BLEEDING_POSITION0, // 放气位置0
PWMP_HD_ADJUST_INITIATE, // 启动值
PWMP_HD_ADJUST_STOP, PWMP_HD_ADJUST_STOP,
PWMP_HD_ADJUST_FAIL, // 整定失败 PWMP_HD_ADJUST_FAIL, // 整定失败
PWMP_HD_ADJUST_TEST, PWMP_HD_ADJUST_TEST,
@ -197,6 +194,7 @@ typedef struct
BOOL adc_0_100_flag; // 判断0-100移动过程中ad值是增大还是减少，TRUE 增大，FALSE 减小 BOOL adc_0_100_flag; // 判断0-100移动过程中ad值是增大还是减少，TRUE 增大，FALSE 减小
BOOL flag_stable_begin; BOOL flag_stable_begin;
BOOL flag_stable_end; BOOL flag_stable_end;
BOOL all_bleed_time_flag;
uint16_t adc_record_0; // 记录放气时阀门最小位置ad值 uint16_t adc_record_0; // 记录放气时阀门最小位置ad值
uint16_t adc_record_1; // 记录放气时阀门最小位置ad值 uint16_t adc_record_1; // 记录放气时阀门最小位置ad值
@ -209,11 +207,14 @@ typedef struct
uint16_t arr_record_stable_begin; // 记录阀门稳定区域开始的ad值 uint16_t arr_record_stable_begin; // 记录阀门稳定区域开始的ad值
uint16_t arr_record_stable_end; // 记录阀门稳定区域结束的ad值 uint16_t arr_record_stable_end; // 记录阀门稳定区域结束的ad值
uint32_t all_open_time; // 全开时间 uint32_t all_open_time; // 全开时间
uint32_t all_open_time_full; // 信号为最大输出时的全开时间 uint32_t all_open_time_full; // 信号为最大输出时的全开时间
uint32_t all_close_time; // 全关时间 uint32_t all_close_time; // 全关时间
BOOL all_close_time_flag; uint32_t all_close_time_full; // 信号为最大输出时的全关时间
uint32_t tmp_time; // 临时用来记录全开全关/整定时间 uint32_t tmp_time; // 临时用来记录全开全关/整定时间
uint32_t current_0; // 0位置电流大小
uint32_t current_100; // 100位置电流大小
/*输出值*/ /*输出值*/
uint16_t arr_default; // 默认计数器(推动计数值) uint16_t arr_default; // 默认计数器(推动计数值)