严重错误放到motor.h/.c 中

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

Applications/foc/core/PMSM_FOC_Core.h

@@ -268,9 +268,6 @@ bool PMSM_FOC_Start_epmMove(bool move, EPM_Dir_t dir);
 EPM_Dir_t PMSM_FOC_Get_epmDir(void);
 void PMSM_FOC_SeteBrkPhaseCurrent(float curr);
 float PMSM_FOC_GeteBrkPhaseCurrent(void);
-void PMSM_FOC_SetCriticalError(u8 err) ;
-void PMSM_FOC_ClrCriticalError(u8 err);
-u32 PMSM_FOC_GetCriticalError(void);
 void PMSM_FOC_PhaseCurrLim(float lim);
 float PMSM_FOC_GetPhaseCurrLim(void);
 float PMSM_FOC_GetDCCurrLimit(void);

Applications/foc/limit.c

@@ -1,5 +1,6 @@
 #include "foc/limit.h"
 #include "foc/core/PMSM_FOC_Core.h"
+#include "foc/motor/motor.h"
 #include "foc/samples.h"
 #include "foc/mc_error.h"
 
@@ -90,12 +91,12 @@ static u16 _motor_limit(void) {
 		limter_t *lim = motor_temp_lim + i;
 		u16 lim_value = _temp_limiter(temp, lim);
 		if (lim_value != CURRENT_LIMIT_NONE) {
-			PMSM_FOC_SetCriticalError(FOC_CRIT_MOTOR_TEMP_Err);
+			mc_set_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
 			err_add_record(FOC_CRIT_MOTOR_TEMP_Err, temp);
 			return lim_value;
 		}
 	}
-	PMSM_FOC_ClrCriticalError(FOC_CRIT_MOTOR_TEMP_Err);
+	mc_clr_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
 	return CURRENT_LIMIT_NONE;
 }
 
@@ -105,12 +106,12 @@ static u16 _mos_limit(void) {
 		limter_t *lim = mos_temp_lim + i;
 		u16 lim_value = _temp_limiter(temp, lim);
 		if (lim_value != CURRENT_LIMIT_NONE) {
-			PMSM_FOC_SetCriticalError(FOC_CRIT_MOS_TEMP_Err);
+			mc_set_critical_error(FOC_CRIT_MOS_TEMP_Err);
 			err_add_record(FOC_CRIT_MOS_TEMP_Err, temp);
 			return lim_value;
 		}
 	}
-	PMSM_FOC_ClrCriticalError(FOC_CRIT_MOS_TEMP_Err);
+	mc_clr_critical_error(FOC_CRIT_MOS_TEMP_Err);
 	return CURRENT_LIMIT_NONE;
 }
 
@@ -126,10 +127,10 @@ u16 vbus_current_vol_lower_limit(void) {
 		limter_t *lim = vol_under_lim + i;
 		u16 lim_value = _vol_limiter(vol, lim);
 		if (lim_value != CURRENT_LIMIT_NONE) {
-			PMSM_FOC_SetCriticalError(FOC_CRIT_UN_Vol_Err);
+			mc_set_critical_error(FOC_CRIT_UN_Vol_Err);
 			return lim_value;
 		}
 	}
-	PMSM_FOC_ClrCriticalError(FOC_CRIT_UN_Vol_Err);
+	mc_clr_critical_error(FOC_CRIT_UN_Vol_Err);
 	return CURRENT_LIMIT_NONE;
 }

Applications/foc/motor/motor.c

@@ -48,11 +48,11 @@ static void MC_Check_MosVbusThrottle(void) {
 	get_phase_vols(abc);
 	int vbus_vol = get_vbus_int();
 	if (abc[0] > vbus_vol/2 || abc[1] > vbus_vol/2 || abc[2] > vbus_vol/2) {
-		PMSM_FOC_SetCriticalError(FOC_CRIT_H_MOS_Err);
+		mc_set_critical_error(FOC_CRIT_H_MOS_Err);
 	}else if (abc[0] < 0.001f){
-		PMSM_FOC_SetCriticalError(FOC_CRIT_L_MOS_Err);
+		mc_set_critical_error(FOC_CRIT_L_MOS_Err);
 	}else if ((abc[0] > 0.5f) && (abc[1] < 0.001f || abc[2] < 0.001f)) {
-		PMSM_FOC_SetCriticalError(FOC_CRIT_Phase_Conn_Err);
+		mc_set_critical_error(FOC_CRIT_Phase_Conn_Err);
 	}
 	sys_debug("phase vol %f, %f, %f\n", abc[0], abc[1], abc[2]);
 }
@@ -60,7 +60,7 @@ static void MC_Check_MosVbusThrottle(void) {
 static u32 _self_check_task(void *p) {
 	if (ENC_Check_error()) {
 		err_add_record(FOC_CRIT_Encoder_Err, 0);
-		PMSM_FOC_SetCriticalError(FOC_CRIT_Encoder_Err);
+		mc_set_critical_error(FOC_CRIT_Encoder_Err);
 	}
 	return 0;
 }
@@ -138,7 +138,7 @@ bool mc_start(u8 mode) {
 	}
 	MC_Check_MosVbusThrottle();
 
-	if (PMSM_FOC_GetCriticalError() != 0) {
+	if (mc_get_critical_error() != 0) {
 		PMSM_FOC_SetErrCode(FOC_Have_CritiCal_Err);
 		return false;
 	}
@@ -169,14 +169,14 @@ bool mc_start(u8 mode) {
 	phase_current_offset_calibrate();
 	pwm_start();
 	delay_us(10); //wait for ebrake error
-	if (PMSM_FOC_GetCriticalError() != 0) {
+	if (mc_get_critical_error() != 0) {
 		mc_stop();
 		return false;
 	}
 	adc_start_convert();
 	phase_current_calibrate_wait();
 	if (phase_curr_offset_check()) {
-		PMSM_FOC_SetCriticalError(FOC_CRIT_CURR_OFF_Err);
+		mc_set_critical_error(FOC_CRIT_CURR_OFF_Err);
 		mc_stop();
 		return false;
 	}
@@ -511,6 +511,19 @@ bool mc_auto_hold(bool hold) {
 	return true;
 }
 
+
+void mc_set_critical_error(u8 err) {
+	motor.n_CritiCalErrMask |= (1u << err);
+}
+
+void mc_clr_critical_error(u8 err) {
+	motor.n_CritiCalErrMask &= ~(1u << err);
+}
+
+u32 mc_get_critical_error(void) {
+	return motor.n_CritiCalErrMask;
+}
+
 bool mc_throttle_released(void) {
 	return get_throttle_float() <= nv_get_foc_params()->n_minThroVol;
 }
@@ -572,12 +585,12 @@ void MC_Protect_IRQHandler(void){
 	if (!motor.b_start) {
 		return;
 	}
+	mc_set_critical_error(FOC_CRIT_Phase_Err);
 	_mc_internal_init(CTRL_MODE_OPEN, false);
 	adc_stop_convert();
 	pwm_stop();
 	PMSM_FOC_Stop();
 	pwm_up_enable(true);
-	PMSM_FOC_SetCriticalError(FOC_CRIT_Phase_Err);
 }
 
 void TIMER_UP_IRQHandler(void){

Applications/foc/motor/motor.h

@@ -24,6 +24,7 @@ typedef struct {
 	s32    s_targetFix;
 	s8     s_direction;
 	u32    n_brake_errors;
+	u32    n_CritiCalErrMask;
 	u8     mode;
 	bool   b_is96Mode;
 	u8     n_gear;
@@ -56,6 +57,9 @@ void mc_need_update(void);
 bool mc_is_start(void);
 bool mc_set_gear(u8 gear);
 u8 mc_get_gear(void);
+void mc_set_critical_error(u8 err);
+void mc_clr_critical_error(u8 err);
+u32 mc_get_critical_error(void);
 
 static __INLINE float motor_encoder_get_angle(void) {
 #ifdef USE_ENCODER_HALL

Applications/prot/can_foc_msg.c

@@ -82,7 +82,7 @@ void can_report_foc_status(u8 can) {
 	u8 data[16];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Status));
 	mc_get_running_status(data+2);
-	u32 errMask = PMSM_FOC_GetCriticalError();
+	u32 errMask = mc_get_critical_error();
 	encode_u32(data + 3, errMask);
 	encode_s16(data + 7, get_motor_temp());
 	encode_s16(data + 9, get_mos_temp());