1. 欠压和过流5ms内检测完成

2. 记录错误，需要先判断是否已经记录过
3. 用户设置idc，回收等级，不保存，作为runtime参数

Signed-off-by: huhui <huhui@sharkgulf.com>

Applications/foc/commands.c

@@ -538,9 +538,9 @@ static void process_foc_command(foc_cmd_body_t *command) {
 		{
 			if (command->len >= 4) {
 
-				float phase_curr = (float)decode_s16((u8 *)command->data);
-				float dc_curr = (float)decode_s16((u8 *)command->data + 2);
-				PMSM_FOC_SetEbrkTorque(phase_curr, dc_curr);
+				s16 torque = decode_s16((u8 *)command->data);
+				u16 time = decode_u16((u8 *)command->data + 2);
+				mc_set_ebrk_level(torque, time);
 			}
 			break;
 		}

Applications/foc/core/PMSM_FOC_Core.c

@@ -177,7 +177,6 @@ static void PMSM_FOC_UserInit(void) {
 	gFoc_Ctrl.userLim.s_vDCMaxLim = nv_get_foc_params()->s_maxDCVol;
 	gFoc_Ctrl.userLim.s_vDCMinLim = nv_get_foc_params()->s_minDCVol;
 	gFoc_Ctrl.userLim.s_iDCeBrkLim = nv_get_foc_params()->s_iDCeBrkLim;
-	gFoc_Ctrl.userLim.s_TorqueBrkLim = nv_get_foc_params()->s_TorqueBrkLim;
 	gFoc_Ctrl.userLim.s_PhaseVoleBrkLim = gFoc_Ctrl.hwLim.s_PhaseVolMax;
 }
 
@@ -215,7 +214,7 @@ void PMSM_FOC_CoreInit(void) {
 		//_DEBUG("Hw Limit:\n");
 		//_DEBUG("dc %f, rpm %f, torque %f, phase %f\n", gFoc_Ctrl.hwLim.s_iDCMax, gFoc_Ctrl.hwLim.s_motRPMMax, gFoc_Ctrl.hwLim.s_torqueMax, gFoc_Ctrl.hwLim.s_PhaseCurrMax);
 	}
-	
+	gFoc_Ctrl.userLim.s_TorqueBrkLim = mc_get_ebrk_torque();
 	gFoc_Ctrl.params.n_modulation = CONFIG_SVM_MODULATION;//SVM_Modulation;
 	gFoc_Ctrl.params.n_PhaseFilterCeof = CONFIG_CURR_LP_CEOF;
 	gFoc_Ctrl.params.n_poles = nv_get_motor_params()->poles;//MOTOR_POLES;
@@ -968,9 +967,9 @@ float PMSM_FOC_GetTorqueLimit(void) {
 	return gFoc_Ctrl.userLim.s_torqueLim;
 }
 
-void PMSM_FOC_SetEbrkTorque(float phase_curr, float dc_curr) {
-	gFoc_Ctrl.userLim.s_TorqueBrkLim = fclamp(phase_curr, 0, nv_get_foc_params()->s_TorqueBrkLim);
-	gFoc_Ctrl.userLim.s_iDCeBrkLim = fclamp(dc_curr, 0, nv_get_foc_params()->s_iDCeBrkLim);
+void PMSM_FOC_SetEbrkTorque(s16 torque) {
+	gFoc_Ctrl.userLim.s_TorqueBrkLim = (float)torque;
+	//gFoc_Ctrl.userLim.s_iDCeBrkLim = fclamp(dc_curr, 0, nv_get_foc_params()->s_iDCeBrkLim);
 }
 
 float PMSM_FOC_GetEbrkTorque(void) {

Applications/foc/core/PMSM_FOC_Core.h

@@ -284,7 +284,7 @@ bool PMSM_FOC_Set_epmMode(bool epm);
 bool PMSM_FOC_is_epmMode(void);
 bool PMSM_FOC_Start_epmMove(bool move, EPM_Dir_t dir);
 EPM_Dir_t PMSM_FOC_Get_epmDir(void);
-void PMSM_FOC_SetEbrkTorque(float phase_curr, float dc_curr);
+void PMSM_FOC_SetEbrkTorque(s16 torque);
 float PMSM_FOC_GetEbrkTorque(void);
 void PMSM_FOC_PhaseCurrLim(float lim);
 float PMSM_FOC_GetPhaseCurrLim(void);

Applications/foc/core/e_ctrl.c

@@ -1,5 +1,6 @@
 #include "e_ctrl.h"
 #include "foc/foc_config.h"
+#include "foc/motor/motor.h"
 #include "math/fix_math.h"
 #include "foc/core/PMSM_FOC_Core.h"
 #include "app/nv_storage.h"
@@ -18,7 +19,7 @@ void eCtrl_init(u16 accl_time, u16 dec_time){
 	g_eCtrl.dec_time = dec_time;
 	g_eCtrl.accl_time = accl_time;
 
-	g_eCtrl.ebrk_time = nv_get_foc_params()->n_ebrk_time;
+	g_eCtrl.ebrk_time = mc_get_ebrk_time();
 	
 	g_eCtrl.ebrk_time_shadow = g_eCtrl.ebrk_time;
 	g_eCtrl.accl_time_shadow = g_eCtrl.accl_time;

Applications/foc/limit.c

@@ -67,7 +67,7 @@ static u16 _vol_limiter(s16 vol, limter_t *lim) {
 		}
 		if (lim->ticks == 0) {
 			lim->ticks = get_tick_ms();
-		}else if (get_delta_ms(lim->ticks) >= 100){
+		}else if (get_delta_ms(lim->ticks) >= 5){
 			lim->is_limit = true;
 			lim->ticks = 0;
 			return lim->limit_value;
@@ -96,7 +96,9 @@ static u16 _motor_limit(void) {
 		u16 lim_value = _temp_limiter(temp, lim);
 		if (lim_value != HW_LIMIT_NONE) {
 			if (lim_value == 0) {
-				mc_set_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
+				if (mc_set_critical_error(FOC_CRIT_MOTOR_TEMP_Err)) {
+					mc_crit_err_add_s16(FOC_CRIT_MOTOR_TEMP_Err, temp);
+				}
 			}else if (_can_recovery){
 				mc_clr_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
 			}
@@ -120,7 +122,6 @@ static u16 _motor_limit(void) {
 			curr_value = fclamp(curr_value, 0, prv_lim_value);
 			lim_value = (u16)(((float)gear->n_max_trq * curr_value) / 100.0f);
 			mc_set_motor_lim_level(i + 1);
-			mc_crit_err_add_s16(FOC_CRIT_MOTOR_TEMP_Err, temp);
 			return lim_value;
 		}
 	}
@@ -135,7 +136,9 @@ static u16 _mos_limit(void) {
 		u16 lim_value = _temp_limiter(temp, lim);
 		if (lim_value != HW_LIMIT_NONE) {
 			if (lim_value == 0) {
-				mc_set_critical_error(FOC_CRIT_MOS_TEMP_Err);
+				if (mc_set_critical_error(FOC_CRIT_MOS_TEMP_Err)) {
+					mc_crit_err_add_s16(FOC_CRIT_MOS_TEMP_Err, temp);
+				}
 			}else if (_can_recovery){
 				mc_clr_critical_error(FOC_CRIT_MOS_TEMP_Err);
 			}
@@ -158,7 +161,6 @@ static u16 _mos_limit(void) {
 			float curr_value = prv_lim_value - (float)(temp - lim->enter_pointer)/delta_tmp * delta_value;
 			curr_value = fclamp(curr_value, 0, prv_lim_value);
 			lim_value = (u16)(((float)gear->n_max_trq * curr_value) / 100.0f);
-			mc_crit_err_add_s16(FOC_CRIT_MOS_TEMP_Err, temp);
 			mc_set_mos_lim_level(i + 1);
 			return lim_value;
 		}
@@ -191,13 +193,14 @@ u16 vbus_under_vol_limit(void) {
 		_inited = true;
 		limiter_init();
 	}
-	s16 vol = get_vbus_int();
+	s16 vol = (s16)sample_vbus_raw();
 	for(int i = 0; i < ARRAY_SIZE(vol_under_lim); i++) {
 		limter_t *lim = vol_under_lim + i;
 		u16 lim_value = _vol_limiter(vol, lim);
 		if (lim_value != HW_LIMIT_NONE) {
-			mc_set_critical_error(FOC_CRIT_UN_Vol_Err);
-			mc_crit_err_add_s16(FOC_CRIT_UN_Vol_Err, vol);
+			if (mc_set_critical_error(FOC_CRIT_UN_Vol_Err)) {
+				mc_crit_err_add_s16(FOC_CRIT_UN_Vol_Err, vol);
+			}
 			return lim_value;
 		}
 	}

Applications/foc/motor/motor.c

@@ -43,7 +43,9 @@ static motor_t motor = {
 	.mode = CTRL_MODE_OPEN,
 	.mos_lim = 0,
 	.motor_lim = 0,
-	.idc_user_lim = IDC_USER_LIMIT_NONE,
+	.u_set.idc_lim = IDC_USER_LIMIT_NONE,
+	.u_set.ebrk_torque = IDC_USER_LIMIT_NONE,
+	.u_set.ebrk_time = MAX_U16,
 };
 /* 无感运行的挡位，限制速度，母线电流，最大扭矩 */
 static mc_gear_t sensorless_gear = {
@@ -185,7 +187,7 @@ static void mc_gear_vmode_changed(void) {
 	mc_gear_t *gears = mc_get_gear_config();
 
 	PMSM_FOC_SpeedLimit(gears->n_max_speed);
-	PMSM_FOC_DCCurrLimit(min(gears->n_max_idc, motor.idc_user_lim));
+	PMSM_FOC_DCCurrLimit(min(gears->n_max_idc, motor.u_set.idc_lim));
 	PMSM_FOC_TorqueLimit(gears->n_max_trq);
 }
 
@@ -425,15 +427,34 @@ bool mc_set_cruise_speed(bool rpm_abs, float target_rpm) {
 }
 
 void mc_set_idc_limit(s16 limit) {
-	if ((limit == motor.idc_user_lim) || (limit < 0)) {
+	if ((limit == motor.u_set.idc_lim) || (limit < 0)) {
 		return;
 	}
-	motor.idc_user_lim = limit;
+	motor.u_set.idc_lim = limit;
 	s16 g_limit = mc_get_gear_idc_limit();
 	limit = min(g_limit, limit);
 	PMSM_FOC_DCCurrLimit(limit);
 }
 
+void mc_set_ebrk_level(s16 trq, u16 time) {
+	motor.u_set.ebrk_torque = MAX(0, trq);
+	motor.u_set.ebrk_time = MAX(1, time);
+
+	eCtrl_Set_eBrk_RampTime(mc_get_ebrk_time());
+	PMSM_FOC_SetEbrkTorque(mc_get_ebrk_torque());
+}
+
+s16 mc_get_ebrk_torque(void) {
+	return min(motor.u_set.ebrk_torque, nv_get_foc_params()->s_TorqueBrkLim);
+}
+
+u16 mc_get_ebrk_time(void) {
+	if (motor.u_set.ebrk_time == MAX_U16) {
+		return (u16)nv_get_foc_params()->n_ebrk_time;
+	}
+	return motor.u_set.ebrk_time;
+}
+
 bool mc_set_foc_mode(u8 mode) {
 	if (mode == motor.mode) {
 		return true;
@@ -801,14 +822,24 @@ bool mc_auto_hold(bool hold) {
 }
 
 
-void mc_set_critical_error(u8 err) {
+bool mc_set_critical_error(u8 err) {
+	if (mc_critical_err_is_set(err)) {
+		return false;
+	}
 	motor.n_CritiCalErrMask |= (1u << err);
+
+	return true;
 }
 
 void mc_clr_critical_error(u8 err) {
 	motor.n_CritiCalErrMask &= ~(1u << err);
 }
 
+bool mc_critical_err_is_set(u8 err) {
+	u32 mask = (1u << err);
+	return (motor.n_CritiCalErrMask & mask) != 0;
+}
+
 u32 mc_get_critical_error(void) {
 	return motor.n_CritiCalErrMask;
 }
@@ -1228,10 +1259,11 @@ void Sched_MC_mTask(void) {
 
 	if ((PMSM_FOC_GetVbusCurrent() > (CONFIG_MAX_VBUS_CURRENT * 1.1f)) || (PMSM_FOC_GetVbusCurrent() < CONFIG_MAX_CHRG_CURRENT)) {
 		vbus_err_cnt ++;
-		if (vbus_err_cnt > 10) {
-			mc_set_critical_error(FOC_CRIT_IDC_OV);
-			mc_crit_err_add(FOC_CRIT_IDC_OV, (s16)sample_vbus_raw(), (s16)sample_ibus_raw());
-			mc_save_err_runtime();
+		if (vbus_err_cnt >= 5) {
+			if (mc_set_critical_error(FOC_CRIT_IDC_OV)) {
+				mc_crit_err_add(FOC_CRIT_IDC_OV, (s16)sample_vbus_raw(), (s16)sample_ibus_raw());
+				mc_save_err_runtime();
+			}
 		}
 	}else {
 		vbus_err_cnt = 0;

Applications/foc/motor/motor.h

@@ -16,6 +16,12 @@ typedef struct {
 	bool error;
 }fan_t;
 
+typedef struct {
+	s16 idc_lim;
+	s16 ebrk_torque;
+	u16 ebrk_time;
+}user_rt_set;
+
 typedef struct {
 	bool   b_start;
 	float  throttle;
@@ -49,7 +55,7 @@ typedef struct {
 	bool   b_wait_brk_release;
 	u8     mos_lim;
 	u8     motor_lim;
-	s16    idc_user_lim;
+	user_rt_set u_set; //用户运行时设置
 	fan_t  fan[2];
 }motor_t;
 
@@ -76,7 +82,7 @@ bool mc_is_start(void);
 bool mc_set_gear(u8 gear);
 u8 mc_get_gear(void);
 u8 mc_get_internal_gear(void);
-void mc_set_critical_error(u8 err);
+bool mc_set_critical_error(u8 err);
 void mc_clr_critical_error(u8 err);
 u32 mc_get_critical_error(void);
 void mc_set_fan_duty(u8 duty);
@@ -92,6 +98,10 @@ void mc_set_motor_lim_level(u8 l);
 void mc_set_mos_lim_level(u8 l);
 void motor_debug(void);
 int mc_get_phase_errinfo_block(u8 *data, int dlen);
+void mc_set_ebrk_level(s16 trq, u16 time);
+s16 mc_get_ebrk_torque(void);
+u16 mc_get_ebrk_time(void);
+bool mc_critical_err_is_set(u8 err);
 
 static __INLINE float motor_encoder_get_angle(void) {
 #ifdef USE_ENCODER_HALL

Applications/os/os_types.h

@@ -52,6 +52,7 @@ typedef unsigned int	uint32;
 #define ABS(x) 					( (x)>0?(x):-(x) )
 
 #define MAX_S16 (0x7FFF)
+#define MAX_U16 (0xFFFF)
 
 extern void *pvPortMalloc( size_t xWantedSize );
 #define os_alloc pvPortMalloc