电子刹车使用扭矩方式

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

Applications/app/nv_storage.c

@@ -52,7 +52,7 @@ static void nv_default_foc_params(void) {
 	foc_params.s_maxEpmRPM = CONFIG_DEFAULT_EPM_RPM;
 	foc_params.s_maxEpmTorqueLim = CONFIG_DEFAULT_EPM_PHASE_CURR;
 	foc_params.s_maxTorque = CONFIG_MAX_MOTOR_TORQUE;
-	foc_params.s_PhaseCurreBrkLim = CONFIG_DEFAULT_EBRK_PHASE_CURR;
+	foc_params.s_TorqueBrkLim = CONFIG_DEFAULT_EBRK_TORQUE;
 	foc_params.n_currentBand = CONFIG_CURRENT_BANDWITH;
 	foc_params.n_brkShutPower = CONFIG_BRK_SHUT_POWER_ENABLE;
 	foc_params.s_LimitiDC = CONFIG_DEFAULT_IDC_LIM;

Applications/app/nv_storage.h

@@ -13,7 +13,7 @@ typedef struct {
 	float s_maxEpmRPM;
 	float s_maxEpmTorqueLim;
 	float s_maxTorque;
-	float s_PhaseCurreBrkLim;
+	float s_TorqueBrkLim;
 	float s_iDCeBrkLim;
 	float s_LimitiDC;
 	float n_currentBand; //电流环带宽

Applications/foc/commands.c

@@ -459,7 +459,7 @@ static void process_foc_command(foc_cmd_body_t *command) {
 			}else {
 				nv_get_foc_params()->s_PhaseCurrLim = decode_s16((u8 *)command->data);
 				nv_get_foc_params()->s_maxRPM = decode_s16((u8 *)command->data + 2);
-				nv_get_foc_params()->s_PhaseCurreBrkLim = decode_s16((u8 *)command->data + 4);
+				nv_get_foc_params()->s_TorqueBrkLim = decode_s16((u8 *)command->data + 4);
 				nv_get_foc_params()->s_iDCeBrkLim = decode_s16((u8 *)command->data + 6);
 				nv_get_foc_params()->s_LimitiDC = decode_s16((u8 *)command->data + 8);
 				nv_get_foc_params()->n_startThroVol = (float)decode_s16((u8 *)command->data + 10)/100.0f;
@@ -488,7 +488,7 @@ static void process_foc_command(foc_cmd_body_t *command) {
 
 				float phase_curr = (float)decode_s16((u8 *)command->data);
 				float dc_curr = (float)decode_s16((u8 *)command->data + 2);
-				PMSM_FOC_SeteBrkPhaseCurrent(phase_curr, dc_curr);
+				PMSM_FOC_SetEbrkTorque(phase_curr, dc_curr);
 			}
 			break;
 		}

Applications/foc/core/PMSM_FOC_Core.c

@@ -180,7 +180,7 @@ 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_PhaseCurreBrkLim = nv_get_foc_params()->s_PhaseCurreBrkLim;
+	gFoc_Ctrl.userLim.s_TorqueBrkLim = nv_get_foc_params()->s_TorqueBrkLim;
 	gFoc_Ctrl.userLim.s_PhaseVoleBrkLim = gFoc_Ctrl.hwLim.s_PhaseVolMax;
 }
 
@@ -222,7 +222,7 @@ void PMSM_FOC_CoreInit(void) {
 		g_focinit = true;
 		_DEBUG("User Limit:\n");
 		_DEBUG("dc %f, rpm %f, torque %f, phase %f, vDCmax %f, vDCmin %f, ebrk %f\n", gFoc_Ctrl.userLim.s_iDCLim, gFoc_Ctrl.userLim.s_motRPMLim, gFoc_Ctrl.userLim.s_torqueLim,
-			gFoc_Ctrl.userLim.s_PhaseCurrLim, gFoc_Ctrl.userLim.s_vDCMaxLim, gFoc_Ctrl.userLim.s_vDCMinLim, gFoc_Ctrl.userLim.s_PhaseCurreBrkLim);
+			gFoc_Ctrl.userLim.s_PhaseCurrLim, gFoc_Ctrl.userLim.s_vDCMaxLim, gFoc_Ctrl.userLim.s_vDCMinLim, gFoc_Ctrl.userLim.s_TorqueBrkLim);
 		_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);
 	}
@@ -483,9 +483,13 @@ u8 PMSM_FOC_CtrlMode(void) {
 			PI_Controller_Reset(&gFoc_Ctrl.pi_torque, gFoc_Ctrl.in.s_targetTorque);
 #endif
 		}else if ((preMode == CTRL_MODE_TRQ) && (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE)) {
+#if 0
 			float real_trq = PMSM_FOC_Get_Real_dqVector() * 0.9f;
 			eCtrl_reset_Current(min(real_trq, gFoc_Ctrl.in.s_targetTorque));
-			eCtrl_set_TgtCurrent(-PMSM_FOC_GeteBrkPhaseCurrent());
+			eCtrl_set_TgtCurrent(-PMSM_FOC_GetEbrkTorque());
+#else			
+			eCtrl_set_TgtTorque(-PMSM_FOC_GetEbrkTorque());
+#endif
 		}	
 	}
 	
@@ -552,7 +556,7 @@ static __INLINE float PMSM_FOC_Limit_Speed(float maxTrq) {
 }
 
 static __INLINE void PMSM_FOC_idq_Assign(void) {
-	if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_CURRENT || gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE) {
+	if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_CURRENT) {
 		if (gFoc_Ctrl.in.b_MTPA_calibrate && (gFoc_Ctrl.in.s_manualAngle != INVALID_ANGLE)) {
 			float s, c;
 			normal_sincosf(degree_2_pi(gFoc_Ctrl.in.s_manualAngle + 90.0f), &s, &c);
@@ -568,7 +572,8 @@ static __INLINE void PMSM_FOC_idq_Assign(void) {
 			gFoc_Ctrl.in.s_targetIdq.d = 0;
 			gFoc_Ctrl.in.s_targetIdq.q = gFoc_Ctrl.in.s_targetCurrent;
 		}
-	}else if ((gFoc_Ctrl.out.n_RunMode == CTRL_MODE_TRQ) || (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_SPD)) {
+	}else if ((gFoc_Ctrl.out.n_RunMode == CTRL_MODE_TRQ) || (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_SPD) ||
+				(gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE)) {
 		trq2dq_lookup((int)gFoc_Ctrl.in.s_motRPM, gFoc_Ctrl.in.s_targetTorque, &gFoc_Ctrl.in.s_targetIdq);
 		PMSM_FOC_FieldWeak();
 	}
@@ -589,13 +594,14 @@ void PMSM_FOC_idqCalc(void) {
 		PMSM_FOC_idq_Assign();
 		return;
 	}
-	if ((gFoc_Ctrl.out.n_RunMode == CTRL_MODE_CURRENT) || (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE)) {
+	if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_CURRENT) {
 		gFoc_Ctrl.in.s_targetCurrent = eCtrl_get_RefCurrent();
-		if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE) {
-			if (eCtrl_get_FinalCurrent() < 0.0001f && gFoc_Ctrl.in.s_motRPM < CONFIG_MIN_RPM_EXIT_EBRAKE) {
-				gFoc_Ctrl.in.s_targetCurrent = 0;
-			}
+	}else if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_EBRAKE) {
+		float maxTrq = eCtrl_get_RefTorque();
+		if (eCtrl_get_FinalTorque() < 0.0001f && gFoc_Ctrl.in.s_motRPM < CONFIG_MIN_RPM_EXIT_EBRAKE) {
+			maxTrq = 0;
 		}
+		crosszero_step_towards(&gFoc_Ctrl.in.s_targetTorque, maxTrq);
 	}else if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_TRQ) {
 		float refTorque = min(eCtrl_get_RefTorque(), eRamp_get_intepolation(&gFoc_Ctrl.rtLim.torqueLimRamp));
 		float maxTrq = PMSM_FOC_Limit_Speed(refTorque);
@@ -773,13 +779,13 @@ float PMSM_FOC_GetTorqueLimit(void) {
 	return gFoc_Ctrl.userLim.s_torqueLim;
 }
 
-void PMSM_FOC_SeteBrkPhaseCurrent(float phase_curr, float dc_curr) {
-	gFoc_Ctrl.userLim.s_PhaseCurreBrkLim = fclamp(phase_curr, 0, nv_get_foc_params()->s_PhaseCurreBrkLim);
+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);
 }
 
-float PMSM_FOC_GeteBrkPhaseCurrent(void) {
-	return gFoc_Ctrl.userLim.s_PhaseCurreBrkLim ;
+float PMSM_FOC_GetEbrkTorque(void) {
+	return gFoc_Ctrl.userLim.s_TorqueBrkLim;
 }
 
 float PMSM_FOC_GetVbusVoltage(void) {
@@ -871,50 +877,6 @@ bool PMSM_FOC_Set_Speed(float rpm) {
 	return true;
 }
 
-#if 0
-bool PMSM_FOC_Set_epmMode(bool epm) {
-	if (epm && !gFoc_Ctrl.in.b_motEnable) {
-		PMSM_FOC_SetErrCode(FOC_NotAllowed);
-		return false;
-	}
-	if (gFoc_Ctrl.in.b_epmMode != epm) {
-		if (PMSM_FOC_GetSpeed() != 0.0f) {
-			PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
-			return false;
-		}
-		gFoc_Ctrl.in.epmDirection = EPM_Dir_None;
-		gFoc_Ctrl.in.b_epmMode = epm;
-		if (epm) {
-			PMSM_FOC_SpeedLimit(nv_get_foc_params()->s_maxEpmRPM);
-			eCtrl_set_TgtSpeed(0);
-			PMSM_FOC_SetCtrlMode(CTRL_MODE_SPD);
-		}else {
-			PMSM_FOC_SetCtrlMode(CTRL_MODE_TRQ);
-			PMSM_FOC_SpeedLimit(nv_get_foc_params()->s_maxRPM);
-		}
-	}
-	return true;
-}
-
-bool PMSM_FOC_Start_epmMove(bool move, EPM_Dir_t dir) {
-	if (!gFoc_Ctrl.in.b_epmMode) {
-		return false;
-	}
-	if (move) {
-		if (gFoc_Ctrl.in.epmDirection != EPM_Dir_None) {
-			return false;
-		}
-		gFoc_Ctrl.in.epmDirection = dir;
-	}else {
-		gFoc_Ctrl.in.epmDirection = EPM_Dir_None;
-	}
-	return true;
-}
-
-EPM_Dir_t PMSM_FOC_Get_epmDir(void) {
-	return gFoc_Ctrl.in.epmDirection;
-}
-#endif
 
 bool PMSM_FOC_Set_Current(float is) {
 	if (is > gFoc_Ctrl.userLim.s_PhaseCurrLim) {
@@ -959,7 +921,6 @@ void PMSM_FOC_MTPA_Calibrate(bool enable) {
 	if (enable) {
 		gFoc_Ctrl.in.b_MTPA_calibrate = true;
 		gFoc_Ctrl.in.s_manualAngle = 0;
-		eCtrl_set_ebrk_time(CONFIG_MTPA_CALI_RAMP_TIME);
 	}else {
 		gFoc_Ctrl.in.s_manualAngle = INVALID_ANGLE;
 		gFoc_Ctrl.in.b_MTPA_calibrate = false;

Applications/foc/core/PMSM_FOC_Core.h

@@ -115,7 +115,7 @@ typedef struct {
 	float s_iDCLim;
 	float s_PhaseCurrLim; //最大相电流
 	float s_iDCeBrkLim; //最大母线回收电流
-	float s_PhaseCurreBrkLim;
+	float s_TorqueBrkLim;
 	float s_PhaseVoleBrkLim;
 	float s_vDCMinLim;
 	float s_vDCMaxLim;
@@ -281,8 +281,8 @@ 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_SeteBrkPhaseCurrent(float phase_curr, float dc_curr);
-float PMSM_FOC_GeteBrkPhaseCurrent(void);
+void PMSM_FOC_SetEbrkTorque(float phase_curr, float dc_curr);
+float PMSM_FOC_GetEbrkTorque(void);
 void PMSM_FOC_PhaseCurrLim(float lim);
 float PMSM_FOC_GetPhaseCurrLim(void);
 float PMSM_FOC_GetDCCurrLimit(void);

Applications/foc/core/e_ctrl.c

@@ -28,16 +28,11 @@ void eCtrl_init(u16 accl_time, u16 dec_time){
 	g_eCtrl.dec_time_shadow = g_eCtrl.dec_time;
 	g_eCtrl.hw_brake = false;
 	g_eCtrl.is_ebrake = false;
-	eRamp_init(&g_eCtrl.current, g_eCtrl.ebrk_time, g_eCtrl.ebrk_time);
+	eRamp_init(&g_eCtrl.current, 10*1000, 10*1000);
 	eRamp_init(&g_eCtrl.speed, g_eCtrl.accl_time, g_eCtrl.dec_time);
 	eRamp_init(&g_eCtrl.torque, g_eCtrl.accl_time, g_eCtrl.dec_time);
 }
 
-void eCtrl_set_ebrk_time(u16 ebrk_time) {
-	g_eCtrl.ebrk_time_shadow = ebrk_time;
-}
-
-
 void eCtrl_set_TgtCurrent(float c) {
 	g_eCtrl.current_shadow = c;
 }
@@ -62,7 +57,7 @@ void eCtrl_set_TgtSpeed(float s) {
 
 bool eCtrl_enable_eBrake(bool enable) {
 	float ebrak = g_eCtrl.is_ebrake;
-	if (PMSM_FOC_GeteBrkPhaseCurrent() == 0.0f) {
+	if (PMSM_FOC_GetEbrkTorque() == 0.0f) {
 		ebrak = false;
 	}else {
 		if (enable && ((PMSM_FOC_GetSpeed() > CONFIG_MIN_RPM_FOR_EBRAKE))) {
@@ -113,8 +108,8 @@ void eCtrl_Running(void) {
 	}
 	if (g_eCtrl.ebrk_time_shadow != g_eCtrl.ebrk_time) {
 		g_eCtrl.ebrk_time = g_eCtrl.ebrk_time_shadow;
-		eRamp_set_time(&g_eCtrl.current, g_eCtrl.ebrk_time, g_eCtrl.ebrk_time);
-		_eCtrl_set_TgtCurrent(g_eCtrl.current_shadow);
+		eRamp_set_time(&g_eCtrl.torque, g_eCtrl.ebrk_time, g_eCtrl.ebrk_time);
+		_eCtrl_set_TgtTorque(g_eCtrl.torque_shadow);
 	}
 	if (g_eCtrl.current_shadow != g_eCtrl.current.target) {
 		_eCtrl_set_TgtCurrent(g_eCtrl.current_shadow);
@@ -123,6 +118,11 @@ void eCtrl_Running(void) {
 		_eCtrl_set_TgtSpeed(g_eCtrl.speed_shadow);
 	}
 	if (g_eCtrl.torque_shadow != g_eCtrl.torque.target) {
+		if (PMSM_FOC_Get()->out.n_RunMode == CTRL_MODE_TRQ) {
+			eRamp_set_time(&g_eCtrl.torque, g_eCtrl.accl_time, g_eCtrl.dec_time);
+		}else {
+			eRamp_set_time(&g_eCtrl.torque, g_eCtrl.ebrk_time, g_eCtrl.ebrk_time);
+		}
 		_eCtrl_set_TgtTorque(g_eCtrl.torque_shadow);
 	}
 	eRamp_X2_running(&g_eCtrl.current);
@@ -140,7 +140,6 @@ static bool _eCtrl_isHwBrk_shutPower(void) {
 }
 
 static void _eCtrl_set_TgtCurrent(float c) {
-	//eRamp_set_step_target(&g_eCtrl.current, c, CONFIG_eCTRL_STEP_TS);
 	eRamp_set_X2_target(&g_eCtrl.current, c);
 }
 
@@ -152,7 +151,7 @@ static void _eCtrl_set_TgtSpeed(float s) {
 }
 
 static void _eCtrl_set_TgtTorque(float t) {
-	if (_eCtrl_isHwBrk_shutPower()){
+	if (_eCtrl_isHwBrk_shutPower() && !g_eCtrl.is_ebrake){
 		return;
 	}
 	eRamp_set_X2_target(&g_eCtrl.torque, t);

Applications/foc/core/e_ctrl.h

@@ -117,6 +117,7 @@ static void eRamp_set_step_target(e_Ramp *ramp, float c, u32 intval) {
 	eRamp_set_step(ramp, step_val);
 }
 
+#if 0
 extern float PMSM_FOC_GetSpeed(void);
 static void eRamp_X2_running(e_Ramp *r) {
 #if 1
@@ -163,7 +164,12 @@ static void eRamp_X2_running(e_Ramp *r) {
 	eRamp_running(r);
 #endif
 }
-
+#else
+static void eRamp_X2_running(e_Ramp *r) {
+	eRamp_running(r);
+}
+#endif
+#if 0
 static void eRamp_set_X2_target(e_Ramp *r, float c) {
 #if 1
 	eRamp_set_target(r, c);
@@ -204,10 +210,14 @@ static void eRamp_set_X2_target(e_Ramp *r, float c) {
 
 #endif
 }
+#else
+static void eRamp_set_X2_target(e_Ramp *r, float c) {
+	eRamp_set_step_target(r, c, CONFIG_eCTRL_STEP_TS);
+}
 
+#endif
 //y=Ax^2;
 void eCtrl_init(u16 accl_time, u16 dec_time);
-void eCtrl_set_ebrk_time(u16 ebrk_time);
 void eCtrl_brake_signal(bool hw_brake);
 bool eCtrl_is_eBrk_Running(void);
 void eCtrl_set_TgtCurrent(float c);

Applications/foc/core/thro_torque.c

@@ -164,8 +164,7 @@ void thro_torque_process(u8 run_mode, float f_throttle) {
 			PMSM_FOC_Set_Speed(speed_Ref);
 		}
 	}else if (run_mode == CTRL_MODE_EBRAKE) {
-		eCtrl_reset_Torque(0);
-		if (eCtrl_get_FinalCurrent() < 0.0001f && PMSM_FOC_GetSpeed() < CONFIG_MIN_RPM_EXIT_EBRAKE) {
+		if (eCtrl_get_FinalTorque() < 0.0001f && PMSM_FOC_GetSpeed() < CONFIG_MIN_RPM_EXIT_EBRAKE) {
 			eCtrl_enable_eBrake(false);	
 		}
 		if (!mc_throttle_released() || (mc_throttle_released() && (PMSM_FOC_GetSpeed() == 0.0f))) {

Applications/foc/foc_config.h

@@ -10,7 +10,7 @@
 
 #define CONFIG_DEFAULT_EPM_PHASE_CURR 50
 #define CONFIG_DEFAULT_EPM_RPM        200
-#define CONFIG_DEFAULT_EBRK_PHASE_CURR 0 //0:means disable ebrake
+#define CONFIG_DEFAULT_EBRK_TORQUE 0 //0:means disable ebrake
 #define CONFIG_DEFAULT_EBRK_IDC_LIM 15
 #define CONFIG_SVM_MODULATION       1.0f//(1.0F/SQRT3_BY_2)
 #define CONFIG_BRK_SHUT_POWER_ENABLE 1