优化

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

Applications/app/app.c

@@ -68,10 +68,6 @@ void fetch_jtag_cmd(void){
 }
 #endif
 
-static void mc_exec_log(void) {
-	PMSM_FOC_LogDebug();
-}
-
 void app_start(void){
 	set_log_level(MOD_SYSTEM, L_debug);
 	can_message_init();
@@ -110,8 +106,7 @@ static u32 _app_report_task(void *p) {
 
 static u32 _app_low_task(void *args) {
 	wdog_reload();
-	mc_exec_log();
 	fetch_jtag_cmd();
-	return 100;
+	return 1;
 }
 

Applications/bsp/board_mc_v1.h

@@ -26,7 +26,7 @@
 #define CONFIG_UNDER_VOL_DC_CURR 15.0F
 #define CONFIG_MAX_FW_D_CURR     100.0F //d轴最大的退磁电流
 
-#define CONFIG_CURR_LP_CUT_FREQ (3000.0F)
+#define CONFIG_CURR_LP_CUT_FREQ (2500.0F)
 
 #define CONFIG_CURR_LP_PARAM (CONFIG_CURR_LP_CUT_FREQ*2*3.14F/(float)FOC_PWM_FS)
 

Applications/bsp/delay.c

@@ -29,9 +29,7 @@ void task_ticks_delay(uint32_t ticks)
 	uint32_t start;
 
 	start = task_ticks_abs();
-	while (task_ticks_rel(start) < ticks){
-		
-	};
+	while (task_ticks_rel(start) < ticks);
 }
 
 void task_udelay(uint32_t delay)
@@ -53,6 +51,6 @@ void delay_us(uint16_t cnt)
 */
 void delay_ms(uint32_t count)
 {
-	task_udelay(1000);
+	task_udelay(1000 * count);
 }
 

Applications/foc/commands.c

@@ -78,11 +78,11 @@ static void process_ext_command(foc_cmd_body_t *command) {
 
 		u8 epm_dir = decode_8bits(b1, 6, 7);
 		if (epm_dir == 0) {
-			mc_start_epm_move(EPM_Dir_None, true);
+			mc_command_epm_move(EPM_Dir_None);
 		}else if (epm_dir == 1) {
-			mc_start_epm_move(EPM_Dir_Back, true);
+			mc_command_epm_move(EPM_Dir_Back);
 		}else if (epm_dir == 2) {
-			mc_start_epm_move(EPM_Dir_Forward, true);
+			mc_command_epm_move(EPM_Dir_Forward);
 		}
 		u8 response[8] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
 		response[0] &= 0xFC;

Applications/foc/core/PMSM_FOC_Core.c

@@ -218,6 +218,8 @@ void PMSM_FOC_CoreInit(void) {
 	gFoc_Ctrl.in.s_manualAngle = INVALID_ANGLE;
 	gFoc_Ctrl.in.s_vDC = nv_get_foc_params()->s_maxDCVol;//(CONFIG_RATED_DC_VOL);
 
+	eRamp_init_target(&gFoc_Ctrl.in.cruiseRpmRamp, 0, CONFIG_ACC_TIME, CONFIG_DEC_TIME);
+	
 	gFoc_Ctrl.out.n_RunMode = CTRL_MODE_OPEN;
 	gFoc_Ctrl.out.f_vdqRation = 0;
 
@@ -503,7 +505,8 @@ void PMSM_FOC_idqCalc(void) {
 		float maxSpeed = eCtrl_get_FinalSpeed();
 		float refSpeed = eCtrl_get_RefSpeed();
 		if (gFoc_Ctrl.in.b_cruiseEna) {
-			maxSpeed = refSpeed = gFoc_Ctrl.in.s_cruiseRPM;
+			maxSpeed = eRamp_get_target(&gFoc_Ctrl.in.cruiseRpmRamp);
+			refSpeed = eRamp_get_intepolation(&gFoc_Ctrl.in.cruiseRpmRamp);//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;
@@ -550,6 +553,7 @@ void PMSM_FOC_Slow_Task(void) {
 	eRamp_running(&gFoc_Ctrl.userLim.phaseCurrLimRamp);
 	eRamp_running(&gFoc_Ctrl.userLim.rpmLimRamp);
 	eRamp_running(&gFoc_Ctrl.userLim.DCCurrLimRamp);
+	eRamp_running(&gFoc_Ctrl.in.cruiseRpmRamp);
 
 	PMSM_FOC_idqCalc();
 }
@@ -677,6 +681,7 @@ bool PMSM_FOC_EnableCruise(bool enable) {
 			PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
 			return false;
 		}
+		eRamp_init_target(&gFoc_Ctrl.in.cruiseRpmRamp, motSpd, CONFIG_ACC_TIME, CONFIG_DEC_TIME);
 		gFoc_Ctrl.in.s_cruiseRPM = motSpd;
 		gFoc_Ctrl.in.b_cruiseEna = enable;
 	}
@@ -768,6 +773,7 @@ bool PMSM_FOC_Set_CruiseSpeed(float rpm) {
 			return false;
 		}
 		gFoc_Ctrl.in.s_cruiseRPM = min(ABS(rpm), gFoc_Ctrl.userLim.s_motRPMLim)*SIGN(rpm);
+		eRamp_set_step_target(&gFoc_Ctrl.in.cruiseRpmRamp, gFoc_Ctrl.in.s_cruiseRPM, CONFIG_eCTRL_STEP_TS);
 		return true;
 	}
 	PMSM_FOC_SetErrCode(FOC_NotCruiseMode);

Applications/foc/core/PMSM_FOC_Core.h

@@ -82,6 +82,7 @@ typedef struct {
 	float 	s_hallAngle;//from hall or encoder
 	float   s_targetRPM;
 	float   s_cruiseRPM;
+	e_Ramp  cruiseRpmRamp;
 	float 	s_targetCurrent;
 	DQ_t    s_targetIdq;
 	DQ_t    s_targetVdq;

Applications/foc/motor/current.c

@@ -42,7 +42,6 @@ void phase_current_offset_calibrate(void){
 	g_cs.adc_offset_c = 0;
 
 	phase_current_init();
-	g_cs.is_calibrating_offset = true;
 #ifdef HIGH_SIDE_CURRENT_SENSOR
 	g_cs.c_phases = PHASE_BC;
 #else
@@ -50,6 +49,7 @@ void phase_current_offset_calibrate(void){
 #endif
 	g_cs.c_ignore_phase = IGNORE_NONE;
 	adc_current_sample_config(g_cs.c_phases);
+	g_cs.is_calibrating_offset = true;
 }
 
 void phase_current_calibrate_wait(void) {

Applications/foc/motor/motor.c

@@ -145,7 +145,6 @@ bool mc_start(u8 mode) {
 		return false;
 	}
 	if (mc_is_hwbrake()) {
-		sys_debug("hw brake\n");
 		PMSM_FOC_Brake(true);
 	}
 	gpio_beep(200);
@@ -164,12 +163,10 @@ bool mc_stop(void) {
 
 	if (motor_encoder_get_speed() > 10.0f) {
 		PMSM_FOC_SetErrCode(FOC_NowAllowed_With_Speed);
-		sys_debug("speed error\n");
 		return false;
 	}
 	if (!mc_throttle_released()) {
 		PMSM_FOC_SetErrCode(FOC_Throttle_Err);
-		sys_debug("throttle error\n");
 		return false;
 	}
 	_mc_internal_init(CTRL_MODE_OPEN, false);
@@ -203,7 +200,6 @@ 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;
 	}
@@ -251,7 +247,6 @@ bool mc_is_start(void) {
 }
 
 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;
@@ -259,24 +254,26 @@ bool mc_start_epm_move(EPM_Dir_t dir, bool is_command) {
 	if ((dir == motor.epm_dir) && (is_command == motor.b_epm_cmd_move)) {
 		return true;
 	}
+	u32 mask = cpu_enter_critical();
 	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);
 			pwm_enable_channel();
 		}
-		cpu_exit_critical(mask);
 		float rpm = nv_get_foc_params()->s_maxEpmRPM;
 		if (dir == EPM_Dir_Back) {
 			rpm = -rpm;
 		}
+		sys_debug("rpm %f\n", rpm);
 		PMSM_FOC_Set_Speed(rpm);
 	}else {
 		motor.b_epm_cmd_move = false;
 		PMSM_FOC_Set_Speed(0);
 	}
+	cpu_exit_critical(mask);
 	return true;
 }
 
@@ -501,7 +498,6 @@ void MC_Brake_IRQHandler(void) {
 		motor.b_break = false;
 		PMSM_FOC_Brake(false);
 	}
-	sys_debug("brake %d\n", motor.b_break);
 }
 
 static void _pwm_brake_prot_timer_handler(shark_timer_t *t){
@@ -676,13 +672,12 @@ void Sched_MC_mTask(void) {
 					pwm_disable_channel();
 					cpu_exit_critical(mask);
 				}
-			}else {
-				if (!PMSM_FOC_Is_Start()) {
-					mask = cpu_enter_critical();
-					PMSM_FOC_Start(motor.mode);
-					pwm_enable_channel();
-					cpu_exit_critical(mask);
-				}
+			}
+			if (!PMSM_FOC_Is_Start() && (!mc_throttle_released())) {
+				mask = cpu_enter_critical();
+				PMSM_FOC_Start(motor.mode);
+				pwm_enable_channel();
+				cpu_exit_critical(mask);
 			}
 		}
 		if (runMode != CTRL_MODE_OPEN) {

Applications/libs/circle_buffer.c

@@ -19,7 +19,7 @@ int circle_put_data(c_buffer_t *cbuff, u8 *data, int16_t len){
 	int16_t size = circle_get_write_space(cbuff);
 	int16_t w_len = len;
 	int16_t w1_len = len;
-	if (size < 0){
+	if (size < len){
 		return size;
 	}
 	w_len = min(len, size);
@@ -58,7 +58,7 @@ int circle_get_data(c_buffer_t *cbuff, u8 *data, int16_t len){
 	int16_t size = circle_get_read_space(cbuff);
 	int16_t r_len = len;
 	int16_t r1_len = 0;
-	if (size <= 0){
+	if (size < len){
 		return size;
 	}
 

Applications/libs/utils.h

@@ -5,10 +5,6 @@
 #include "os/os_task.h"
 #include "bsp/delay.h"
 
-static __inline__ void delay_ms(u32 ms) {
-	task_udelay(ms*1000);
-}
-
 static __inline__ u8 decode_u8(u8 *buff) {
 	return buff[0];
 }

Applications/prot/can_message.c

@@ -39,30 +39,7 @@ static can_message_t *get_message_by_id(can_id_t id){
 
 
 s32 can_send_message(uint32_t can_id, u8 *data, int len, s32 timeout){
-	can_id_t id;
-	id.id = can_id;
-	if (id.type != ptype_request || id.retry <= 1) {
-		return shark_can0_send_message(can_id, data, len) == 0?CAN_SEND_SUCCESS:CAN_SEND_ERROR;
-	}
-	s32 s_ret = CAN_SEND_NO_WAIT_QUEUE;
-	s32 index = wait_queue_add(&wait_queue, decoder_can_key(data));
-	if (index >= 0){
-		s_ret = CAN_SEND_TIMEOUT;
-		s32 retry = id.retry;
-		while(retry -- > 0) {
-			s_ret = shark_can0_send_message(can_id, data, len) == 0?CAN_SEND_SUCCESS:CAN_SEND_ERROR;
-			if (s_ret != CAN_SEND_SUCCESS){
-				continue;
-			}
-			s_ret = wait_queue_wait_key(&wait_queue, index, timeout)?CAN_SEND_SUCCESS:CAN_SEND_TIMEOUT;
-			if (s_ret == CAN_SEND_SUCCESS){
-				break;
-			}
-		}
-		wait_queue_delete_key(&wait_queue, index);
-	}
-	return s_ret;
-
+	return shark_can0_send_message(can_id, data, len) == 0?CAN_SEND_SUCCESS:CAN_SEND_ERROR;
 }
 
 static bool handle_can_ext_frame(u32 id, uint8_t *data, int len) {
@@ -97,6 +74,9 @@ void handle_can_frame(can_id_t id, uint8_t *data, int len){
 	if (handle_can_ext_frame(id.id, data, len)) {
 		return;
 	}
+	if (id.dest != CAN_MY_ADDRESS) {
+		return;
+	}
 	can_message_t *message = get_message_by_id(id);
 	if (message == NULL) {
 		return ;
@@ -130,9 +110,6 @@ void handle_can_frame(can_id_t id, uint8_t *data, int len){
 				memcpy(message->data + message->len, data, len);
 				message->len += len;
 				if (idx == total) { //last frame
-					if (message->type == ptype_response) {
-						wait_queue_key_acked(&wait_queue, message->key);
-					}
 					can_process_message(message);
 				}
 				message->idx = (idx + 1);

Applications/prot/can_pc_message.c

@@ -4,7 +4,7 @@
 #include "bsp/gd32_bkp.h"
 #include "libs/logger.h"
 #include "os/os_task.h"
-
+#include "foc/motor/motor.h"
 static void can_send_backtrace(void){
 	set_log_level(MOD_SYSTEM, L_error);
 	
@@ -35,6 +35,11 @@ bool can_process_iap_message(can_message_t *can_message) {
 	rsplen = 3;
 	switch(can_message->key) {
 		case BUILD_CMD_KEY(0xF0):
+			if (mc_is_start()) {
+				response[2] = 1;
+				iap_send_data(can_message->src, response, rsplen);
+				return true;
+			}
 			fmc_write_magic(0xFFFFFFFF);
 			iap_send_data(can_message->src, response, rsplen);
 			delay_ms(100);