处理EPM模式

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

Applications/app/app.c

@@ -95,7 +95,6 @@ static u32 _app_report_task(void *p) {
 	can_report_phase_voltage(0x45);
 	if (++loop % 10 == 0) {
 		can_report_pid_value(0x45, PID_TRQ_id);
-		sys_debug("start time %d\n", shark_get_seconds());
 	}
 	return 500;
 }

Applications/app/nv_storage.c

@@ -45,10 +45,11 @@ static void nv_default_foc_params(void) {
 	foc_params.s_maxiDC = 30;
 	//foc_params.s_maxIdq = 200;
 	//foc_params.s_minIdq = -200;
-	foc_params.s_PhaseCurrLim = 180;
+	foc_params.s_PhaseCurrLim = 10;
 	foc_params.s_maxRPM = 8000;
-	foc_params.s_maxEpmRPM = 133;
-	foc_params.s_maxTorque = 50;//foc_params.s_PhaseCurrLim;
+	foc_params.s_maxEpmRPM = 200;
+	foc_params.s_maxEpmPhaseCurrLim = 10;
+	foc_params.s_maxTorque = foc_params.s_PhaseCurrLim;
 	foc_params.s_PhaseCurreBrkLim = 0.0f;
 	foc_params.n_currentBand = 500;
 	foc_params.n_modulation = 1.0f;

Applications/app/nv_storage.h

@@ -7,13 +7,12 @@
 
 typedef struct {
 	float s_PhaseCurrLim;
-	//float s_maxIdq;
-	//float s_minIdq;
 	float s_maxiDC;
 	float s_maxDCVol;
 	float s_minDCVol;
 	float s_maxRPM;
 	float s_maxEpmRPM;
+	float s_maxEpmPhaseCurrLim;
 	float s_maxTorque;
 	float s_PhaseCurreBrkLim;
 	float s_iDCeBrkLim;

Applications/bsp/board_mc_v1.h

@@ -9,7 +9,7 @@
 #define CONFIG_MOS_MAX_VOL 145.0F
 #define CONFIG_MAX_DC_VOL 120.0F
 #define CONFIG_RATED_DC_VOL (96.0f)   /* 母线最大电压 V*/
-#define CONFIG_MIN_DC_VOL   (36.0f)
+#define CONFIG_MIN_DC_VOL   (25.0f)
 
 #define CONFIG_MAX_VBUS_CURRENT 45.0f
 #define CONFIG_MAX_MOT_RPM      8000.0f

Applications/foc/commands.c

@@ -176,7 +176,7 @@ static void process_foc_command(foc_cmd_body_t *command) {
 		case Foc_Start_EPM_Move:
 		{
 			EPM_Dir_t dir = (EPM_Dir_t)decode_u8((u8 *)command->data);
-			if(!mc_start_epm_move(dir)) {
+			if(!mc_command_epm_move(dir)) {
 				erroCode = PMSM_FOC_GetErrCode();
 			}
 			break;

Applications/foc/core/PMSM_FOC_Core.c

@@ -446,21 +446,22 @@ void PMSM_FOC_idqCalc(void) {
 		float maxTrq = PI_Controller_RunSat(gFoc_Ctrl.pi_torque, errRef);
 		gFoc_Ctrl.in.s_targetTorque = PMSM_FOC_Limit_Power(maxTrq);
 	}else if (gFoc_Ctrl.out.n_RunMode == CTRL_MODE_SPD){
-		if (eCtrl_get_FinalSpeed() > 0) {
+		float maxSpeed = eCtrl_get_FinalSpeed();
+		float refSpeed = eCtrl_get_RefSpeed();
+		if (gFoc_Ctrl.in.b_cruiseEna) {
+			maxSpeed = refSpeed = gFoc_Ctrl.in.s_cruiseRPM;
+		}
+		if (maxSpeed > 0) {
 			gFoc_Ctrl.pi_speed->max = eRamp_get_intepolation(&gFoc_Ctrl.userLim.phaseCurrLimRamp);//gFoc_Ctrl.userLim.s_PhaseCurrLim;
 			gFoc_Ctrl.pi_speed->min = -gFoc_Ctrl.userLim.s_PhaseCurreBrkLim;
-		}else if (eCtrl_get_FinalSpeed() < 0) {
+		}else if (maxSpeed < 0) {
 			gFoc_Ctrl.pi_speed->min = -eRamp_get_intepolation(&gFoc_Ctrl.userLim.phaseCurrLimRamp);//gFoc_Ctrl.userLim.s_PhaseCurrLim;
 			gFoc_Ctrl.pi_speed->max = gFoc_Ctrl.userLim.s_PhaseCurreBrkLim;
 		}
-		float refSpeed = eCtrl_get_RefSpeed();
-		if (gFoc_Ctrl.in.b_cruiseEna) {
-			refSpeed = gFoc_Ctrl.in.s_cruiseRPM;
-		}else {
-			if ((eCtrl_get_FinalSpeed() == 0) && (gFoc_Ctrl.in.s_motRPM < CONFIG_MIN_RPM_EXIT_EBRAKE)) {
-				gFoc_Ctrl.pi_speed->max = 0;
-				gFoc_Ctrl.pi_speed->min = 0; //防止倒转
-			}
+
+		if ((maxSpeed == 0) && (gFoc_Ctrl.in.s_motRPM < CONFIG_MIN_RPM_EXIT_EBRAKE)) {
+			gFoc_Ctrl.pi_speed->max = 0;
+			gFoc_Ctrl.pi_speed->min = 0; //防止倒转
 		}
 		gFoc_Ctrl.in.s_targetRPM = refSpeed;
 		float errRef = refSpeed - gFoc_Ctrl.in.s_motRPM;

Applications/foc/core/torque.c

@@ -45,9 +45,9 @@ void torque_speed_target(u8 run_mode, float f_throttle) {
 		float speed_Ref = speed_target_from_throttle(f_throttle);
 		if (mc_is_epm()) {
 			if (speed_Ref == 0.0f) {
-				mc_start_epm_move(EPM_Dir_None);
+				mc_throttle_epm_move(EPM_Dir_None);
 			}else {
-				mc_start_epm_move(EPM_Dir_Forward);
+				mc_throttle_epm_move(EPM_Dir_Forward);
 			}
 		}else {
 			PMSM_FOC_Set_Speed(speed_Ref);

Applications/foc/motor/motor.c

@@ -132,10 +132,15 @@ bool mc_start(u8 mode) {
 	pwm_start();
 	adc_start_convert();
 	phase_current_calibrate_wait();
+
 	motor.throttle = 0;
 	motor.b_start = true;
 	motor.b_runStall = false;
 	motor.runStall_time = 0;
+	motor.b_epm = false;
+	motor.b_epm_cmd_move = false;
+	motor.epm_dir = EPM_Dir_None;
+
 	if (phase_curr_offset_check()) {
 		PMSM_FOC_SetCriticalError(FOC_CRIT_CURR_OFF_Err);
 		mc_stop();
@@ -196,6 +201,7 @@ bool mc_set_foc_mode(u8 mode) {
 }
 
 bool mc_start_epm(bool epm) {
+	sys_debug("%s epm mode\n", epm?"enter":"exit");
 	if (motor.b_epm == epm) {
 		return true;
 	}
@@ -215,17 +221,22 @@ bool mc_start_epm(bool epm) {
 	motor.b_epm = epm;
 	if (epm) {
 		motor.lim_rpm = PMSM_FOC_GetSpeedLimit();
+		motor.lim_phase_curr = PMSM_FOC_GetPhaseCurrLim();
 		eCtrl_set_TgtSpeed(0);
 		motor.mode = CTRL_MODE_SPD;
 		PMSM_FOC_SpeedLimit(nv_get_foc_params()->s_maxEpmRPM);
+		PMSM_FOC_PhaseCurrLim(nv_get_foc_params()->s_maxEpmPhaseCurrLim);
 		PMSM_FOC_SetCtrlMode(CTRL_MODE_SPD);
 	}else {
 		motor.epm_dir = EPM_Dir_None;
 		motor.mode = CTRL_MODE_TRQ;
+		motor.b_epm_cmd_move = false;
 		PMSM_FOC_SetCtrlMode(CTRL_MODE_TRQ);
 		PMSM_FOC_SpeedLimit(motor.lim_rpm);
+		PMSM_FOC_PhaseCurrLim(motor.lim_phase_curr);
 	}
 	cpu_exit_critical(mask);
+	
 	return false;
 }
 
@@ -233,16 +244,18 @@ bool mc_is_epm(void) {
 	return motor.b_epm;
 }
 
-bool mc_start_epm_move(EPM_Dir_t dir) {
+bool mc_start_epm_move(EPM_Dir_t dir, bool is_command) {
+	sys_debug("epm dir %d, %d\n", dir, motor.epm_dir);
 	if (!motor.b_epm || !motor.b_start) {
 		PMSM_FOC_SetErrCode(FOC_NotAllowed);
 		return false;
 	}
-	if (dir == motor.epm_dir) {
+	if ((dir == motor.epm_dir) && (is_command == motor.b_epm_cmd_move)) {
 		return true;
 	}
 	motor.epm_dir = dir;
 	if (dir != EPM_Dir_None) {
+		motor.b_epm_cmd_move = is_command;
 		u32 mask = cpu_enter_critical();
 		if (!PMSM_FOC_Is_Start()) {
 			PMSM_FOC_Start(motor.mode);
@@ -255,11 +268,20 @@ bool mc_start_epm_move(EPM_Dir_t dir) {
 		}
 		PMSM_FOC_Set_Speed(rpm);
 	}else {
+		motor.b_epm_cmd_move = false;
 		PMSM_FOC_Set_Speed(0);
 	}
 	return true;
 }
 
+bool mc_command_epm_move(EPM_Dir_t dir) {
+	return mc_start_epm_move(dir, true);
+}
+
+bool mc_throttle_epm_move(EPM_Dir_t dir) {
+	return mc_start_epm_move(dir, false);
+}
+
 void mc_set_spd_torque(s32 target) {
 	motor.b_ignor_throttle = true;
 	motor.s_targetFix = target;
@@ -551,7 +573,9 @@ void Sched_MC_mTask(void) {
 			float f_throttle = get_throttle_float();
 			if (f_throttle != motor.throttle) {
 				motor.throttle = f_throttle;
-				torque_speed_target(runMode, f_throttle);
+				if (!motor.b_epm_cmd_move) {//通过命令前进后退，不处理转把
+					torque_speed_target(runMode, f_throttle);
+				}
 			}
 			PMSM_FOC_Slow_Task();
 		}

Applications/foc/motor/motor.h

@@ -13,7 +13,9 @@ typedef struct {
 	bool   b_runStall; //是否堵转
 	bool   b_epm;
 	EPM_Dir_t epm_dir;
+	bool   b_epm_cmd_move;
 	float  lim_rpm;
+	float  lim_phase_curr;
 	u32    runStall_time;
 	s16    s_testAngle;
 	s32    s_targetFix;
@@ -35,8 +37,10 @@ bool mc_encoder_zero_calibrate(s16 vd);
 bool mc_set_foc_mode(u8 mode);
 bool mc_is_epm(void);
 bool mc_start_epm(bool epm);
-bool mc_start_epm_move(EPM_Dir_t dir);
+bool mc_start_epm_move(EPM_Dir_t dir, bool is_command);
 void mc_get_running_status(u8 *data);
+bool mc_command_epm_move(EPM_Dir_t dir);
+bool mc_throttle_epm_move(EPM_Dir_t dir);
 
 static __INLINE float motor_encoder_get_angle(void) {
 #ifdef USE_ENCODER_HALL