重新处理温度limit

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

Applications/app/app.c

@@ -112,7 +112,7 @@ static u32 _app_report_task(void *p) {
 	}
 	return 200;
 }
-static int plot_type = 1;
+static int plot_type = 4;
 static void plot_smo_angle(void) {
 	float smo_angle = foc_observer_smo_angle();
 	float delta = smo_angle - PMSM_FOC_Get()->in.s_hallAngle;

Applications/bsp/board_mc100_v1.h

@@ -34,6 +34,8 @@
 
 #define CONFIG_SMO_OBSERVER 1
 
+//#define CONFIG_FORCE_96V_MODE 1
+
 #define SCHED_TIMER TIMER5
 #define SCHED_TIMER_RCU RCU_TIMER5
 #define SCHED_TIMER_IRQ TIMER5_IRQn

Applications/foc/core/PMSM_FOC_Core.c

@@ -16,7 +16,7 @@
 #include "libs/logger.h"
 #include "math/fir.h"
 
-#define _DEBUG(fmt, args...) no_debug(fmt, ##args)
+#define _DEBUG(fmt, args...) sys_debug(fmt, ##args)
 
 PMSM_FOC_Ctrl gFoc_Ctrl;
 static Fir_t phase1, phase2;
@@ -177,8 +177,8 @@ static void PMSM_FOC_UserInit(void) {
 }
 
 void PMSM_FOC_RT_LimInit(void) {
-	gFoc_Ctrl.protLim.s_iDCLim = gFoc_Ctrl.userLim.s_iDCLim;
-	gFoc_Ctrl.protLim.s_TorqueLim = gFoc_Ctrl.userLim.s_torqueLim;
+	gFoc_Ctrl.protLim.s_iDCLim = HW_LIMIT_NONE;
+	gFoc_Ctrl.protLim.s_TorqueLim = HW_LIMIT_NONE;
 
 	eRamp_init_target(&gFoc_Ctrl.rtLim.rpmLimRamp, gFoc_Ctrl.userLim.s_motRPMLim, CONFIG_LIMIT_RAMP_TIME, CONFIG_LIMIT_RAMP_TIME);
 	eRamp_init_target(&gFoc_Ctrl.rtLim.torqueLimRamp, gFoc_Ctrl.userLim.s_torqueLim, CONFIG_LIMIT_RAMP_TIME, CONFIG_LIMIT_RAMP_TIME);
@@ -605,15 +605,6 @@ bool PMSM_FOC_RunTime_Limit(void) {
 	float dc_lim = (float)vbus_current_vol_lower_limit();
 	float torque_lim = (float)torque_temp_high_limit();
 
-	dc_lim = (dc_lim != CURRENT_LIMIT_NONE)?dc_lim:gFoc_Ctrl.userLim.s_iDCLim;
-	torque_lim = (torque_lim != CURRENT_LIMIT_NONE)?torque_lim:gFoc_Ctrl.userLim.s_torqueLim;
-
-	if (torque_lim < gFoc_Ctrl.rtLim.torqueLimRamp.target) {
-		eRamp_set_step_target(&gFoc_Ctrl.rtLim.torqueLimRamp, torque_lim, CONFIG_eCTRL_STEP_TS);
-	}
-	if (dc_lim < gFoc_Ctrl.rtLim.DCCurrLimRamp.target) {
-		eRamp_set_step_target(&gFoc_Ctrl.rtLim.DCCurrLimRamp, dc_lim, CONFIG_eCTRL_STEP_TS);
-	}
 	if (gFoc_Ctrl.protLim.s_iDCLim != dc_lim || gFoc_Ctrl.protLim.s_TorqueLim != torque_lim) {
 		gFoc_Ctrl.protLim.s_iDCLim = dc_lim;
 		gFoc_Ctrl.protLim.s_TorqueLim = torque_lim;
@@ -668,8 +659,10 @@ void PMSM_FOC_DCCurrLimit(float ibusLimit) {
 	if (ibusLimit > gFoc_Ctrl.hwLim.s_iDCMax) {
 		ibusLimit = gFoc_Ctrl.hwLim.s_iDCMax;
 	}
+	if (gFoc_Ctrl.protLim.s_iDCLim != HW_LIMIT_NONE) {
+		ibusLimit = min(ibusLimit, gFoc_Ctrl.protLim.s_iDCLim);
+	}
 	gFoc_Ctrl.userLim.s_iDCLim = ibusLimit;
-	gFoc_Ctrl.protLim.s_iDCLim = gFoc_Ctrl.userLim.s_iDCLim;
 
 	if (ABS(gFoc_Ctrl.in.s_motRPM) <= CONFIG_ZERO_SPEED_RPM){
 		eRamp_reset_target(&gFoc_Ctrl.rtLim.DCCurrLimRamp, ibusLimit);
@@ -711,8 +704,12 @@ void PMSM_FOC_TorqueLimit(float torqueLimit) {
 	if (torqueLimit > gFoc_Ctrl.hwLim.s_torqueMax) {
 		torqueLimit = gFoc_Ctrl.hwLim.s_torqueMax;
 	}
+
+	if (gFoc_Ctrl.protLim.s_TorqueLim != HW_LIMIT_NONE) {
+		torqueLimit = min(torqueLimit, gFoc_Ctrl.protLim.s_TorqueLim);
+	}
+
 	gFoc_Ctrl.userLim.s_torqueLim = torqueLimit;
-	gFoc_Ctrl.protLim.s_TorqueLim = gFoc_Ctrl.userLim.s_torqueLim;
 
 	if (ABS(gFoc_Ctrl.in.s_motRPM) <= CONFIG_ZERO_SPEED_RPM){
 		eRamp_reset_target(&gFoc_Ctrl.rtLim.torqueLimRamp, torqueLimit);

Applications/foc/core/trq2dq_table.c

@@ -83,11 +83,14 @@ void trq2dq_lookup(int rpm, float torque, DQ_t *dq_out) {
 	if (low >= RPM_I_MAX) {
 		low = RPM_I_MAX - 1;
 	}
-	if ((low < 0) || low == (RPM_I_MAX-1))  {
+	if (low < 0)  {
 		high = low = 0;
+	}else if (low == (RPM_I_MAX-1)) {
+		high = low;
 	}else {
 		high = low + 1;
 	}
+
 	_DEBUG("speed %d-%d\n", low, high);
 
 	int low_left = TRQ_I_MAX - 1, low_right = TRQ_I_MAX - 1;

Applications/foc/limit.c

@@ -1,18 +1,19 @@
 #include "foc/limit.h"
 #include "foc/core/PMSM_FOC_Core.h"
 #include "foc/motor/motor.h"
+#include "foc/motor/motor_param.h"
 #include "foc/samples.h"
 #include "foc/mc_error.h"
 
 static limter_t motor_temp_lim[] = {//电机过温限流，限制相电流
 	{.enter_pointer = 120, .exit_pointer = 110, .limit_value = 0},
-	{.enter_pointer = 110, .exit_pointer = 100, .limit_value = 12},
-	{.enter_pointer = 100, .exit_pointer = 90, .limit_value = 13},
+	{.enter_pointer = 110, .exit_pointer = 100, .limit_value = CONFIG_MAX_MOTOR_TORQUE/2},
+	{.enter_pointer = 100, .exit_pointer = 90, .limit_value = CONFIG_MAX_MOTOR_TORQUE/3*2},
 }; 
 static limter_t mos_temp_lim[] = { //mos过温限流，限制相电流
 	{.enter_pointer = 95, .exit_pointer = 85, .limit_value = 0},
-	{.enter_pointer = 86, .exit_pointer = 80, .limit_value = 80},
-	{.enter_pointer = 81, .exit_pointer = 70, .limit_value = 120},
+	{.enter_pointer = 86, .exit_pointer = 80, .limit_value = CONFIG_MAX_MOTOR_TORQUE/2},
+	{.enter_pointer = 81, .exit_pointer = 70, .limit_value = CONFIG_MAX_MOTOR_TORQUE/3*2},
 };  
 static limter_t vol_under_lim[] = { //欠压限流,限制母线
 	{.enter_pointer = 20, .exit_pointer = 20, .limit_value = 10},
@@ -27,7 +28,7 @@ static u16 _temp_limiter(s16 temp, limter_t *lim) {
 	if (!lim->is_limit) {
 		if (temp < lim->enter_pointer) {
 			lim->ticks = 0;
-			return CURRENT_LIMIT_NONE;
+			return HW_LIMIT_NONE;
 		}
 		if (lim->ticks == 0) {
 			lim->ticks = get_tick_ms();
@@ -36,7 +37,7 @@ static u16 _temp_limiter(s16 temp, limter_t *lim) {
 			lim->ticks = 0;
 			return lim->limit_value;
 		}
-		return CURRENT_LIMIT_NONE;
+		return HW_LIMIT_NONE;
 	}else {
 		if (temp >= lim->exit_pointer) {
 			lim->ticks = 0;
@@ -47,7 +48,7 @@ static u16 _temp_limiter(s16 temp, limter_t *lim) {
 		}else if (get_delta_ms(lim->ticks) >= 5000) {
 			lim->is_limit = false;
 			lim->ticks = 0;
-			return CURRENT_LIMIT_NONE;
+			return HW_LIMIT_NONE;
 		}
 		return lim->limit_value;
 	}
@@ -57,7 +58,7 @@ static u16 _vol_limiter(s16 vol, limter_t *lim) {
 	if (!lim->is_limit) {
 		if (vol > lim->enter_pointer) {
 			lim->ticks = 0;
-			return CURRENT_LIMIT_NONE;
+			return HW_LIMIT_NONE;
 		}
 		if (lim->ticks == 0) {
 			lim->ticks = get_tick_ms();
@@ -66,7 +67,7 @@ static u16 _vol_limiter(s16 vol, limter_t *lim) {
 			lim->ticks = 0;
 			return lim->limit_value;
 		}
-		return CURRENT_LIMIT_NONE;
+		return HW_LIMIT_NONE;
 	}else {
 		if (vol <= lim->exit_pointer) {
 			lim->ticks = 0;
@@ -77,7 +78,7 @@ static u16 _vol_limiter(s16 vol, limter_t *lim) {
 		}else if (get_delta_ms(lim->ticks) >= 1000) {
 			lim->is_limit = false;
 			lim->ticks = 0;
-			return CURRENT_LIMIT_NONE;
+			return HW_LIMIT_NONE;
 		}
 		return lim->limit_value;
 	}
@@ -88,14 +89,16 @@ static u16 _motor_limit(void) {
 	for(int i = 0; i < ARRAY_SIZE(motor_temp_lim); i++) {
 		limter_t *lim = motor_temp_lim + i;
 		u16 lim_value = _temp_limiter(temp, lim);
-		if (lim_value != CURRENT_LIMIT_NONE) {
-			mc_set_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
+		if (lim_value != HW_LIMIT_NONE) {
+			if (lim_value == 0) {
+				mc_set_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
+			}
 			err_add_record(FOC_CRIT_MOTOR_TEMP_Err, temp);
 			return lim_value;
 		}
 	}
 	mc_clr_critical_error(FOC_CRIT_MOTOR_TEMP_Err);
-	return CURRENT_LIMIT_NONE;
+	return HW_LIMIT_NONE;
 }
 
 static u16 _mos_limit(void) {
@@ -103,14 +106,16 @@ static u16 _mos_limit(void) {
 	for(int i = 0; i < ARRAY_SIZE(mos_temp_lim); i++) {
 		limter_t *lim = mos_temp_lim + i;
 		u16 lim_value = _temp_limiter(temp, lim);
-		if (lim_value != CURRENT_LIMIT_NONE) {
-			mc_set_critical_error(FOC_CRIT_MOS_TEMP_Err);
+		if (lim_value != HW_LIMIT_NONE) {
+			if (lim_value == 0) {
+				mc_set_critical_error(FOC_CRIT_MOS_TEMP_Err);
+			}
 			err_add_record(FOC_CRIT_MOS_TEMP_Err, temp);
 			return lim_value;
 		}
 	}
 	mc_clr_critical_error(FOC_CRIT_MOS_TEMP_Err);
-	return CURRENT_LIMIT_NONE;
+	return HW_LIMIT_NONE;
 }
 
 u16 torque_temp_high_limit(void) {
@@ -124,11 +129,11 @@ u16 vbus_current_vol_lower_limit(void) {
 	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 != CURRENT_LIMIT_NONE) {
+		if (lim_value != HW_LIMIT_NONE) {
 			mc_set_critical_error(FOC_CRIT_UN_Vol_Err);
 			return lim_value;
 		}
 	}
 	mc_clr_critical_error(FOC_CRIT_UN_Vol_Err);
-	return CURRENT_LIMIT_NONE;
+	return HW_LIMIT_NONE;
 }

Applications/foc/limit.h

@@ -2,7 +2,7 @@
 #define _Limit_H__
 #include "os/os_types.h"
 
-#define CURRENT_LIMIT_NONE ((u16)0xFFFF)
+#define HW_LIMIT_NONE ((u16)0xFFFF)
 typedef struct {
 	u16 limit_value;
 	s16 enter_pointer;

Applications/foc/motor/motor.c

@@ -121,7 +121,11 @@ static u32 _self_check_task(void *p) {
 }
 
 static void mc_detect_vbus_mode(void) {
+#ifdef CONFIG_FORCE_96V_MODE
+	motor.b_is96Mode = true;
+#else
 	motor.b_is96Mode = get_vbus_int() >= CONFIG_96V_MODE_VOL;
+#endif
 }
 
 static void _mc_internal_init(u8 mode, bool start) {
@@ -151,7 +155,7 @@ static void mc_gear_vmode_changed(void) {
 	sys_debug("limit %d-%d-%d, mode = %s\n", gears[motor.n_gear].u_maxRPM, gears[motor.n_gear].u_maxIdc, gears[motor.n_gear].u_maxTorque, motor.b_is96Mode?"96V":"48V");
 	PMSM_FOC_SpeedLimit(gears[motor.n_gear].u_maxRPM);
 	PMSM_FOC_DCCurrLimit(gears[motor.n_gear].u_maxIdc);
-	PMSM_FOC_TorqueLimit(/*gears[motor.n_gear].u_maxTorque*/CONFIG_MAX_MOTOR_TORQUE);
+	PMSM_FOC_TorqueLimit(gears[motor.n_gear].u_maxTorque);
 }
 
 void mc_init(void) {
@@ -420,7 +424,7 @@ bool mc_command_epm_move(EPM_Dir_t dir) {
 bool mc_throttle_epm_move(EPM_Dir_t dir) {
 	return mc_start_epm_move(dir, false);
 }
-
+extern void sample_test_start(void);
 void mc_set_throttle_r(u8 r) {
 	motor.u_throttle_ration = r;
 
@@ -428,7 +432,7 @@ void mc_set_throttle_r(u8 r) {
 		motor.b_ignor_throttle = true;
 		mc_clr_critical_error(FOC_CRIT_THRO_Err);
 	}else {
-		motor.b_ignor_throttle = false;		
+		motor.b_ignor_throttle = false;
 	}
 }
 
@@ -837,7 +841,7 @@ static bool mc_can_stop_foc(void) {
 }
 
 static bool mc_can_restart_foc(void) {
-	return (!PMSM_FOC_Is_Start()) && (!mc_throttle_released());
+	return (!PMSM_FOC_Is_Start()) && (!mc_throttle_released()) && (!mc_unsafe_critical_error());
 }
 
 #endif