1. 温度限流可以通过工具设置

2. 挡位设置，加入每1000rpm的最大扭矩百分比

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

Applications/app/app.c

@@ -127,16 +127,16 @@ static u32 _app_report_task(void *p) {
 		//sys_debug("modulation %f, %f\n", PMSM_FOC_Get()->out.f_vdqRation, PMSM_FOC_Get()->rtLim.rpmLimRamp.interpolation);
 		//sys_debug("Slow: %d - %d\n", g_meas_MCTask.intval_time, g_meas_MCTask.exec_time);
 		//sys_debug("Fast: %d - %d, err: %d-%d-%d\n", g_meas_foc.intval_time, g_meas_foc.exec_time, g_meas_foc.intval_hi_err, g_meas_foc.intval_low_err, g_meas_foc.exec_max_error_time);
-		sys_debug("FOC time err %d %d\n", g_meas_foc.intval_time_h_error, g_meas_foc.intval_time_l_error);
-		sys_debug("acc vol %d\n", get_acc_vol());
-		sys_debug("throttle %f\n", get_throttle_float());
-		sys_debug("ADC Vref %f, %f\n", get_adc_vref(), adc_5vref_compesion());
-		sys_debug("Vdq in %f, %f\n", PMSM_FOC_Get()->in.s_targetVdq.d, PMSM_FOC_Get()->in.s_targetVdq.q);
-		sys_debug("Vdq out %f, %f\n", PMSM_FOC_Get()->out.s_OutVdq.d, PMSM_FOC_Get()->out.s_OutVdq.q);
+		//sys_debug("FOC time err %d %d\n", g_meas_foc.intval_time_h_error, g_meas_foc.intval_time_l_error);
+		//sys_debug("acc vol %d\n", get_acc_vol());
+		//sys_debug("throttle %f\n", get_throttle_float());
+		//sys_debug("ADC Vref %f, %f\n", get_adc_vref(), adc_5vref_compesion());
+		//sys_debug("Vdq in %f, %f\n", PMSM_FOC_Get()->in.s_targetVdq.d, PMSM_FOC_Get()->in.s_targetVdq.q);
+		//sys_debug("Vdq out %f, %f\n", PMSM_FOC_Get()->out.s_OutVdq.d, PMSM_FOC_Get()->out.s_OutVdq.q);
 		//sys_debug("target current %f\n", PMSM_FOC_Get()->in.s_targetCurrent);
 		//thro_torque_log();
 		//sys_debug("fan rpm %d, %d\n", mc_params()->fan[0].rpm, mc_params()->fan[1].rpm);
-		encoder_log();
+		//encoder_log();
 		///PMSM_FOC_LogDebug();
 		//eCtrl_debug_log();
 		//err_code_log();

Applications/app/nv_storage.c

@@ -9,7 +9,6 @@ static motor_params_t m_params;
 static foc_params_t   foc_params;
 static mc_gear_config_t gear_config;
 static mc_limit_t limiter;
-static int _write_position = 0;
 #define NV_MAGIC 0x5AA5
 
 motor_params_t *nv_get_motor_params(void) {
@@ -54,21 +53,21 @@ static void nv_default_limter(void) {
 	limiter.motor[0].enter_pointer = 120;
 	limiter.motor[0].exit_pointer = 110;
 	limiter.motor[0].limit_value = 0;
-	limiter.motor[1].enter_pointer = 107;
+	limiter.motor[1].enter_pointer = 110;
 	limiter.motor[1].exit_pointer = 97;
 	limiter.motor[1].limit_value = CONFIG_MAX_MOTOR_TORQUE/3;
-	limiter.motor[2].enter_pointer = 94;
+	limiter.motor[2].enter_pointer = 97;
 	limiter.motor[2].exit_pointer = 85;
 	limiter.motor[2].limit_value = CONFIG_MAX_MOTOR_TORQUE*2/3;
 
 	limiter.mos[0].enter_pointer = 110;
 	limiter.mos[0].exit_pointer = 100;
 	limiter.mos[0].limit_value = 0;
-	limiter.mos[1].enter_pointer = 97;
-	limiter.mos[1].exit_pointer = 87;
+	limiter.mos[1].enter_pointer = 100;
+	limiter.mos[1].exit_pointer = 90;
 	limiter.mos[1].limit_value = CONFIG_MAX_MOTOR_TORQUE/3;
-	limiter.mos[2].enter_pointer = 84;
-	limiter.mos[2].exit_pointer = 78;
+	limiter.mos[2].enter_pointer = 90;
+	limiter.mos[2].exit_pointer = 80;
 	limiter.mos[2].limit_value = CONFIG_MAX_MOTOR_TORQUE*2/3;
 
 	limiter.vbus.enter_pointer = 76;
@@ -92,7 +91,6 @@ static void nv_default_foc_params(void) {
 	foc_params.n_startThroVol = CONFIG_THROTTLE_START_VALUE;
 	foc_params.n_endThroVol = CONFIG_THROTTLE_END_VALUE;
 	foc_params.n_autoHold = CONFIG_AUTOHOLD_ENABLE;
-	foc_params.n_acc_time = CONFIG_ACC_TIME;
 	foc_params.n_dec_time = CONFIG_DEC_TIME;
 	foc_params.n_ebrk_time = CONFIG_EBRK_RAMP_TIME;
 	foc_params.n_FwEnable  = CONFIG_DEFAULT_FW_ENABLE;
@@ -124,60 +122,26 @@ static void nv_default_foc_params(void) {
 }
 
 static void nv_default_gear_config(void) {
-	/* 48v 模式 */
-	gear_config.gears_48[0].u_maxRPM = 1430;
-	gear_config.gears_48[0].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM * 0.5f;
-	gear_config.gears_48[0].u_maxIdc = 25;
-	gear_config.gears_48[0].u_accTime = 50;
-
-	gear_config.gears_48[1].u_maxRPM = 2100;
-	gear_config.gears_48[1].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM * 0.8f;
-	gear_config.gears_48[1].u_maxIdc = 30;
-	gear_config.gears_48[1].u_accTime = 80;
-
-	gear_config.gears_48[2].u_maxRPM = 2850;
-	gear_config.gears_48[2].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_48[2].u_maxIdc = 40;
-	gear_config.gears_48[2].u_accTime = 80;
-
-	gear_config.gears_48[3].u_maxRPM = 2850;
-	gear_config.gears_48[3].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_48[3].u_maxIdc = 40;
-	gear_config.gears_48[3].u_accTime = 80;
-
-	gear_config.gears_48[4].u_maxRPM = 2850;
-	gear_config.gears_48[4].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_48[4].u_maxIdc = 40;
-	gear_config.gears_48[4].u_accTime = 80;
-
-	/* 96v 模式 */
-	gear_config.gears_96[0].u_maxRPM = 2850;
-	gear_config.gears_96[0].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM * 0.5f;
-	gear_config.gears_96[0].u_maxIdc = 25;
-	gear_config.gears_96[0].u_accTime = 50;
-
-	gear_config.gears_96[1].u_maxRPM = 4300;
-	gear_config.gears_96[1].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM * 0.8f;
-	gear_config.gears_96[1].u_maxIdc = 30;
-	gear_config.gears_96[1].u_accTime = 80;
-
-	gear_config.gears_96[2].u_maxRPM = 5500;
-	gear_config.gears_96[2].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_96[2].u_maxIdc = 35;
-	gear_config.gears_96[2].u_accTime = 100;
-
-	gear_config.gears_96[3].u_maxRPM = 5500;
-	gear_config.gears_96[3].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_96[3].u_maxIdc = 45;
-	gear_config.gears_96[3].u_accTime = 100;
-
-	gear_config.gears_96[4].u_maxRPM = 5500;
-	gear_config.gears_96[4].u_maxTorque = CONFIG_DEFAULT_PHASE_CURR_LIM;
-	gear_config.gears_96[4].u_maxIdc = 45;
-	gear_config.gears_96[4].u_accTime = 100;
-}
-
+	for (int i = 0; i < CONFIG_MAX_GEAR_NUM; i++) {
+		gear_config.gears_48[i].n_max_speed = 4000;
+		gear_config.gears_48[i].n_max_trq = 200;
+		gear_config.gears_48[i].n_max_idc = 60;
+		gear_config.gears_48[i].n_zero_accl = 1500;
+		gear_config.gears_48[i].n_accl_time = 500;
+
+		gear_config.gears_96[i].n_max_speed = 8000;
+		gear_config.gears_96[i].n_max_trq = 400;
+		gear_config.gears_96[i].n_max_idc = 100;
+		gear_config.gears_96[i].n_zero_accl = 1500;
+		gear_config.gears_96[i].n_accl_time = 400;
+
+		for (int j = 0; j < GEAR_SPEED_TRQ_NUM; j++) {
+			gear_config.gears_48[i].n_torque[j] = 60+j;
+			gear_config.gears_96[i].n_torque[j] = 80+j;
+		}
+	}
 
+}
 
 void nv_save_motor_params(void) {
 	u16 crc = crc16_get((u8 *)&m_params, sizeof(m_params) - 2);
@@ -209,9 +173,27 @@ void nv_read_motor_params(void) {
 	}
 }
 
+bool nv_set_limit_config(u8 *config, int len) {
+	int config_len = sizeof(nv_limter_t) * (2 * TEMP_LIMITER_NUM + 1);
+	if (len < config_len) {
+		return false;
+	}
+	memcpy(&limiter.motor[0], config, len);
+	sys_debug("lim %d %d %d\n", limiter.motor[0].enter_pointer, limiter.motor[0].exit_pointer, limiter.motor[0].limit_value);
+	nv_save_limit_config();
+	return true;
+}
+
+void* nv_get_limit_config(int *len) {
+	if (len) {
+		*len = sizeof(nv_limter_t) * (2 * TEMP_LIMITER_NUM + 1);
+	}
+	return &limiter.motor[0];
+}
+
 void nv_save_limit_config(void) {
-	u16 crc = crc16_get((u8 *)&limiter, sizeof(limiter) - 2);
 	limiter.magic = NV_MAGIC;
+	u16 crc = crc16_get((u8 *)&limiter, sizeof(limiter) - 2);
 	limiter.crc16 = crc;
 	fmc_write_data(limiter_cfg_idx_0, (u8 *)&limiter, sizeof(limiter));
 	fmc_write_data(limiter_cfg_idx_1, (u8 *)&limiter, sizeof(limiter));
@@ -276,6 +258,7 @@ void nv_read_foc_params(void) {
 }
 
 void nv_save_gear_configs(void) {
+	gear_config.magic = NV_MAGIC;
 	u16 crc = crc16_get((u8 *)&gear_config, sizeof(gear_config) - 2);
 	gear_config.crc16 = crc;
 	fmc_write_data(gear_config_idx_0, (u8 *)&gear_config, sizeof(gear_config));
@@ -290,6 +273,7 @@ void nv_read_gear_configs(void) {
 		fmc_read_data(gear_config_idx_1, (u8 *)&gear_config, sizeof(gear_config));
 		crc0 = crc16_get((u8 *)&gear_config, sizeof(gear_config) - 2);
 		if (crc0 != gear_config.crc16) {
+			sys_debug("default gear\n");
 			nv_default_gear_config();
 			nv_save_gear_configs();
 			return;
@@ -306,6 +290,7 @@ void nv_read_gear_configs(void) {
 	}
 }
 
+#if 0
 bool nv_set_gear_config(u8 mode4896, u8 gear, u16 rpm, u16 torque, u16 idc, u16 acc) {
 	mc_gear_t *gear_cfg;
 	if (gear >= CONFIG_MAX_GEAR_NUM) {
@@ -344,106 +329,102 @@ bool nv_get_gear_config(u8 mode4896, u8 gear, u16 *rpm, u16 *torque, u16 *idc, u
 
 	return true;
 }
+#endif
 
 
-void nv_set_pid(u8 id, pid_conf_t *pid) {
-	foc_params.pid_conf[id] = *pid;
-	nv_save_foc_params();
-}
-
-void nv_get_pid(u8 id, pid_conf_t *pid) {
-	*pid = foc_params.pid_conf[id];
-}
+bool nv_set_gear_config(u8 mode96, u8 *config, int len) {
+	int config_len = sizeof(mc_gear_t) * CONFIG_MAX_GEAR_NUM;
+	if (len < config_len) {
+		return false;
+	}
+	if (mode96) {
+		memcpy(&gear_config.gears_96[0], config, len);
+	}else {
+		memcpy(&gear_config.gears_48[0], config, len);
+	}
+	for (int i = 0; i < CONFIG_MAX_GEAR_NUM; i++) {
+		if (gear_config.gears_48[i].n_max_speed > CONFIG_MAX_MOT_RPM) {
+			gear_config.gears_48[i].n_max_speed = CONFIG_MAX_MOT_RPM;
+		}
 
-void nv_set_hwbrake_mode(u8 mode) {
-	foc_params.n_brkShutPower = mode;
-}
+		if (gear_config.gears_48[i].n_max_trq > CONFIG_MAX_TORQUE) {
+			gear_config.gears_48[i].n_max_trq = CONFIG_MAX_TORQUE;
+		}
 
-void nv_set_throttle_vol(float min, float max) {
-	foc_params.n_startThroVol = min;
-	foc_params.n_endThroVol = max;
-}
+		if (gear_config.gears_48[i].n_max_idc > CONFIG_MAX_VBUS_CURRENT) {
+			gear_config.gears_48[i].n_max_idc = CONFIG_MAX_VBUS_CURRENT;
+		}
+		if (gear_config.gears_48[i].n_zero_accl == 0) {
+			gear_config.gears_48[i].n_zero_accl = 100;
+		}
+		if (gear_config.gears_48[i].n_accl_time == 0) {
+			gear_config.gears_48[i].n_accl_time = 1;
+		}
 
-trq2dq_table_t *_trq2dq_table(int idx) {
-	trq2dq_table_t *tbl = (trq2dq_table_t *)fmc_get_addr(idx);
+		if (gear_config.gears_96[i].n_max_speed > CONFIG_MAX_MOT_RPM) {
+			gear_config.gears_96[i].n_max_speed = CONFIG_MAX_MOT_RPM;
+		}
 
-	if (tbl->magic != NV_MAGIC) {
-		sys_error("trq tlb %d magic error, 0x%x\n", idx, tbl->magic);
-		return NULL;
-	}
-	u16 crc = crc16_get((u8 *)tbl, sizeof(trq2dq_table_t) - 4);
-	if (crc != tbl->crc16) {
-		sys_error("trq tlb %d crc16 error\n", idx);
-		return NULL;
-	}
-	return tbl;
-}
+		if (gear_config.gears_96[i].n_max_trq > CONFIG_MAX_TORQUE) {
+			gear_config.gears_96[i].n_max_trq = CONFIG_MAX_TORQUE;
+		}
 
-trq2dq_table_t *nv_get_trq2dq_table(void) {
-	trq2dq_table_t *tbl = _trq2dq_table(trq_Tbl_idx0);
-	if (tbl == NULL) {
-		tbl = _trq2dq_table(trq_Tbl_idx1);
+		if (gear_config.gears_96[i].n_max_idc > CONFIG_MAX_VBUS_CURRENT) {
+			gear_config.gears_96[i].n_max_idc = CONFIG_MAX_VBUS_CURRENT;
+		}
+		if (gear_config.gears_96[i].n_zero_accl == 0) {
+			gear_config.gears_96[i].n_zero_accl = 100;
+		}
+		if (gear_config.gears_96[i].n_accl_time == 0) {
+			gear_config.gears_96[i].n_accl_time = 1;
+		}
+		for (int j = 0; j < GEAR_SPEED_TRQ_NUM; j++) {
+			if (gear_config.gears_48[i].n_torque[j] > 100) {
+				gear_config.gears_48[i].n_torque[j] = 100;
+			}
+
+			if (gear_config.gears_96[i].n_torque[j] > 100) {
+				gear_config.gears_96[i].n_torque[j] = 100;
+			}
+		}
 	}
-	return tbl;
-}
 
-void nv_write_trq_table_begin(int index) {
-	fmc_write_trq_table_begin(fmc_get_addr(index==0?trq_Tbl_idx0:trq_Tbl_idx1));
-	_write_position = 0;
+	nv_save_gear_configs();
+	return true;
 }
 
-int nv_write_trq_table_continue(uint8_t *data, int len){
-	int w_pos = decode_u24(data);
-	if ((_write_position + len - 3) > one_page_size * trq_Tbl_size) {
-		return -1;
+void* nv_get_gear_config(u8 mode96, int *len) {
+	if (len) {
+		*len = sizeof(mc_gear_t) * CONFIG_MAX_GEAR_NUM;
 	}
-	if (w_pos == _write_position && len > 3) {
-		fmc_write_trq_table_continue(data + 3, len - 3);
-		_write_position += len - 3;
+	sys_debug("gear0 %d %d\n", mode96, gear_config.gears_96[0].n_max_speed);
+	if (mode96) {
+		return &gear_config.gears_96[0];
+	}else {
+		return &gear_config.gears_48[0];
 	}
-
-	return _write_position;
 }
 
-static int nv_write_trq_table1(void) {
-	u8 cache[16];
-	int remain = sizeof(trq2dq_table_t);
-	u32 faddr = fmc_get_addr(trq_Tbl_idx0);
-	fmc_write_trq_table_begin(fmc_get_addr(trq_Tbl_idx1));
-
-	while(remain > 0) {
-		int len = min(16, sizeof(trq2dq_table_t));
-		memcpy(cache, (void *)faddr, len);
-		fmc_write_trq_table_continue(cache, len);
-		remain -= len;
-		faddr  += len;
-	}
-	
-	fmc_write_trq_table_end();
 
-	return _trq2dq_table(trq_Tbl_idx1) == NULL ? 1: 0;
+void nv_set_pid(u8 id, pid_conf_t *pid) {
+	foc_params.pid_conf[id] = *pid;
+	nv_save_foc_params();
 }
 
-int nv_write_trq_table_check(u8 *data, int len, int index) {
-	uint32_t size, checksum;
-	size = decode_u24(data);
-	checksum = decode_u32(data + 3);
-	u16 magic = NV_MAGIC;
-	fmc_write_trq_table_continue((u8 *)&magic, sizeof(magic));
-	fmc_write_trq_table_continue((u8 *)&checksum, sizeof(checksum));
-	fmc_write_trq_table_end();
-
-	u16 fmc_checksum = crc16_get((const u8 *)fmc_get_addr(index==0?trq_Tbl_idx0:trq_Tbl_idx1), size);
-	if ((checksum == fmc_checksum) && (NULL != _trq2dq_table(index==0?trq_Tbl_idx0:trq_Tbl_idx1))) {
-		if (nv_write_trq_table1()) { //write back error
-			return 1;
-		}
-		return 0;
-	}
+void nv_get_pid(u8 id, pid_conf_t *pid) {
+	*pid = foc_params.pid_conf[id];
+}
 
-	return 1;
+void nv_set_hwbrake_mode(u8 mode) {
+	foc_params.n_brkShutPower = mode;
 }
 
+void nv_set_throttle_vol(float min, float max) {
+	foc_params.n_startThroVol = min;
+	foc_params.n_endThroVol = max;
+}
+
+
 int nv_write_sn(u8 *data, int len) {
 	mc_sn_t sn;
 	memset(&sn, 0, sizeof(sn));

Applications/app/nv_storage.h

@@ -21,14 +21,13 @@ typedef struct {
 	float n_endThroVol;
 	u8    n_brkShutPower;
 	u8    n_autoHold;
-	u32   n_acc_time;
 	u32   n_dec_time;
 	u32   n_ebrk_time;
 	u8    n_FwEnable;
 	pid_conf_t pid_conf[PID_Max_id];
 	float f_minThroVol;
 	float f_maxThroVol;
-	u8    res[2048 - 161];
+	u8    res[2048 - 157];
 	u16   crc16;
 }foc_params_t;
 
@@ -48,50 +47,39 @@ typedef struct {
 }motor_params_t;
 
 typedef struct {
-	u16 limit_value;
 	s16 enter_pointer;
 	s16 exit_pointer;
+	s16 limit_value;
 }nv_limter_t;
 
+#define TEMP_LIMITER_NUM 3
 typedef struct {
 	u16  magic;
-	nv_limter_t motor[3];
-	nv_limter_t mos[3];
+	nv_limter_t motor[TEMP_LIMITER_NUM];
+	nv_limter_t mos[TEMP_LIMITER_NUM];
 	nv_limter_t vbus;
 	u8    res[2048 - 46];
 	u16 crc16;
 }mc_limit_t;
 
+#define GEAR_SPEED_TRQ_NUM 10
 typedef struct {
-	u16 u_maxRPM;
-	u16 u_maxTorque;
-	u16 u_maxIdc;
-	u16 u_accTime;//加速曲线
+	u16 n_max_speed; //最大速度, rpm
+	u16 n_max_trq;   //最大扭矩
+	u16 n_max_idc;   //最大母线电流
+	u16 n_zero_accl; //零速启动扭矩给定时间，防止翘头
+	u16 n_accl_time; //加速的扭矩斜坡时间
+	u8  n_torque[GEAR_SPEED_TRQ_NUM]; //1000, 2000, 3000... RPM 最大给定扭矩的百分比（最大扭矩的百分比）
 }mc_gear_t;
 
-#define CONFIG_MAX_GEAR_NUM 5
+#define CONFIG_MAX_GEAR_NUM 4
 typedef struct {
 	mc_gear_t gears_48[CONFIG_MAX_GEAR_NUM];
 	mc_gear_t gears_96[CONFIG_MAX_GEAR_NUM];
-	u16   crc16;
+	u16  	  magic;
+	u16       crc16;
 }mc_gear_config_t;
 
-#define MAX_TRQ_POINTS 20
-#define MAX_SPD_POINTS 40
-#define TBL_SPD_INTVAL 250
-
-typedef struct trq2dq {
-	s16 torque;
-	s16 d;
-	s16 q;
-}trq2dq_t;
-
-typedef struct {
-	struct trq2dq tdq[MAX_SPD_POINTS][MAX_TRQ_POINTS];
-	u16  magic;
-	u16  crc16;
-}trq2dq_table_t;
-
 #pragma pack(pop)
 
 typedef struct {
@@ -133,13 +121,15 @@ void nv_set_pid(u8 id, pid_conf_t *pid);
 void nv_get_pid(u8 id, pid_conf_t *pid);
 void nv_set_hwbrake_mode(u8 mode);
 void nv_set_throttle_vol(float min, float max);
-bool nv_set_gear_config(u8 mode4896, u8 gear, u16 rpm, u16 torque, u16 idc, u16 acc);
-bool nv_get_gear_config(u8 mode4896, u8 gear, u16 *rpm, u16 *torque, u16 *idc, u16 *acc);
-trq2dq_table_t *nv_get_trq2dq_table(void);
-void nv_write_trq_table_begin(int index);
-int nv_write_trq_table_continue(uint8_t *data, int len);
-int nv_write_trq_table_check(u8 *data, int len, int index);
 int nv_write_sn(u8 *data, int len);
 int nv_read_sn(u8 *data, int len);
+bool nv_set_limit_config(u8 *config, int len);
+void nv_save_limit_config(void);
+void* nv_get_limit_config(int *len);
+
+bool nv_set_gear_config(u8 mode96, u8 *config, int len);
+void nv_save_gear_configs(void);
+void* nv_get_gear_config(u8 mode96, int *len);
+
 #endif /* _NV_Storage_H__ */
 

Applications/foc/commands.c

@@ -117,7 +117,7 @@ static void process_ext_command(foc_cmd_body_t *command) {
 	
 }
 
-static u8 ignore_with_speed[] = {Foc_Set_Gear_Limit, Foc_Conf_Pid, Foc_Set_Throttle_throld, Foc_Set_Config, Foc_Set_eBrake_Throld, Foc_Start_Write_TRQ_Table, Foc_Write_TRQ_Table, Foc_End_Write_TRQ_Table, Foc_SN_Write};
+static u8 ignore_with_speed[] = {Foc_Set_Gear_Limit, Foc_Conf_Pid, Foc_Set_Throttle_throld, Foc_Set_Config, Foc_Set_eBrake_Throld, Foc_Set_Limiter_Config, Foc_End_Write_TRQ_Table, Foc_SN_Write};
 
 static bool _can_process_with_speed(u8 cmd) {
 	int size = ARRAY_SIZE(ignore_with_speed);
@@ -223,40 +223,25 @@ static void process_foc_command(foc_cmd_body_t *command) {
 		case Foc_Set_Gear_Limit:
 		{
 			sys_debug("len = %d\n", command->len);
-			if (command->len < 9) {
+			u8 mode = decode_u8(command->data);
+			if (!nv_set_gear_config(mode, (u8 *)command->data+1, command->len-1)){
 				erroCode = FOC_Param_Err;
-			}else {
-				u8  gear = decode_u8(command->data);
-				u16 maxRPM = decode_u16((u8 *)command->data + 1);
-				u16 maxPhaseCurr = decode_u16((u8 *)command->data + 3);
-				u16 maxiDC = decode_u16((u8 *)command->data + 5);
-				u16 accline = decode_u16((u8 *)command->data + 7);
-				sys_debug("gear 0x%x, rpm %d, phase %d idc %d acc %d\n", gear, maxRPM, maxPhaseCurr, maxiDC, accline);
-				if (!nv_set_gear_config((gear>>4 & 0xF), (gear & 0xF), maxRPM, maxPhaseCurr, maxiDC, accline)){
-					erroCode = FOC_Param_Err;
-				}
 			}
 			break;
 		}
 		case Foc_Get_Gear_Limit:
 		{
-			u8  gear = decode_u8(command->data);
-			u16 maxRPM;
-			u16 maxPhaseCurr;
-			u16 maxiDC;
-			u16 accline;
-			sys_debug("gear = 0x%x\n", gear);
-			if (!nv_get_gear_config((gear>>4 & 0xF), (gear & 0xF), &maxRPM, &maxPhaseCurr, &maxiDC, &accline)){
-				erroCode = FOC_Param_Err;
-			}else {
-				encode_u8(response + 3, gear);
-				encode_u16(response + 4, maxRPM);
-				encode_u16(response + 6, maxPhaseCurr);
-				encode_u16(response + 8, maxiDC);
-				encode_u16(response + 10, accline);
-				len += 9;
-			}
-			break;
+			u8  mode = decode_u8(command->data);
+			int config_len = 0;
+			void *config = nv_get_gear_config(mode, &config_len);
+			u8 *data = os_alloc(config_len + 3);
+			data[0] = command->cmd;
+			data[1] = CAN_MY_ADDRESS;
+			data[2] = 0;
+			memcpy(data + 3, config, config_len);
+			can_send_response(command->can_src, data, config_len + 3);
+			os_free(data);
+			return;
 		}
 		case Foc_Set_Speed_Limit:
 		{
@@ -440,15 +425,49 @@ static void process_foc_command(foc_cmd_body_t *command) {
 		}
 		case Foc_Get_Config:
 		{
-			len = sizeof(foc_params_t) + 2 - sizeof(pid_conf_t) * PID_Max_id - 2;
-			u8 *config = os_alloc(len);
+			int config_len = 128;
+			int len = 0;
+			u8 *config = os_alloc(config_len);
 			if (config == NULL) {
 				erroCode = FOC_MEM_Err;
 				break;
 			}
-			memcpy((void *)(config + 2), (void *)nv_get_foc_params(), sizeof(foc_params_t) - sizeof(pid_conf_t) * PID_Max_id - 2);
 			config[0] = command->cmd;
 			config[1] = CAN_MY_ADDRESS;
+			config[2] = 0;
+			len = 3;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_PhaseCurrLim);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_maxDCVol);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_minDCVol);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_maxRPM);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_maxEpmRPM);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_maxEpmTorqueLim);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_maxTorque);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_TorqueBrkLim);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_iDCeBrkLim);
+			len += 2;
+			encode_s16(config+len, (s16)nv_get_foc_params()->s_LimitiDC);
+			len += 2;
+			encode_s16(config+len, (s16)(nv_get_foc_params()->n_startThroVol * 100.0f));
+			len += 2;
+			encode_s16(config+len, (s16)(nv_get_foc_params()->n_endThroVol * 100.0f));
+			len += 2;
+			encode_u8(config+len, (u8)nv_get_foc_params()->n_brkShutPower);
+			len += 1;
+			encode_u8(config+len, (u8)nv_get_foc_params()->n_autoHold);
+			len += 1;
+			encode_u32(config+len, nv_get_foc_params()->n_dec_time);
+			len += 4;
+			encode_u32(config+len, nv_get_foc_params()->n_ebrk_time);
+			len += 4;
 			can_send_response(command->can_src, config, len);
 			os_free(config);
 			return;
@@ -457,23 +476,20 @@ static void process_foc_command(foc_cmd_body_t *command) {
 		{
 			if (mc_is_start()) {
 				erroCode = FOC_NotAllowed;
-			}else if (command->len < 32) {
+			}else if (command->len < 24) {
 				erroCode = FOC_Param_Err;
 			}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_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;
-				nv_get_foc_params()->n_endThroVol = (float)decode_s16((u8 *)command->data + 12)/100.0f;
-				nv_get_foc_params()->s_maxEpmRPM = decode_s16((u8 *)command->data + 14);
-				nv_get_foc_params()->s_maxEpmTorqueLim = decode_s16((u8 *)command->data + 16);
-				nv_get_foc_params()->n_brkShutPower = decode_u8((u8 *)command->data + 18);
-				nv_get_foc_params()->n_autoHold = decode_u8((u8 *)command->data + 19);
-				nv_get_foc_params()->n_acc_time = decode_u32((u8 *)command->data + 20);
-				nv_get_foc_params()->n_dec_time = decode_u32((u8 *)command->data + 24);
-				nv_get_foc_params()->n_ebrk_time = decode_u32((u8 *)command->data + 28);
+				nv_get_foc_params()->s_TorqueBrkLim = decode_s16((u8 *)command->data);
+				nv_get_foc_params()->s_iDCeBrkLim = decode_s16((u8 *)command->data + 2);
+				nv_get_foc_params()->s_LimitiDC = decode_s16((u8 *)command->data + 4);
+				nv_get_foc_params()->n_startThroVol = (float)decode_s16((u8 *)command->data + 6)/100.0f;
+				nv_get_foc_params()->n_endThroVol = (float)decode_s16((u8 *)command->data + 8)/100.0f;
+				nv_get_foc_params()->s_maxEpmRPM = decode_s16((u8 *)command->data + 10);
+				nv_get_foc_params()->s_maxEpmTorqueLim = decode_s16((u8 *)command->data + 12);
+				nv_get_foc_params()->n_brkShutPower = decode_u8((u8 *)command->data + 14);
+				nv_get_foc_params()->n_autoHold = decode_u8((u8 *)command->data + 15);
+				nv_get_foc_params()->n_dec_time = decode_u32((u8 *)command->data + 16);
+				nv_get_foc_params()->n_ebrk_time = decode_u32((u8 *)command->data + 20);
 				nv_save_foc_params();
 				shark_timer_post(&_reboot_timer, 200);
 			}
@@ -507,26 +523,26 @@ static void process_foc_command(foc_cmd_body_t *command) {
 			}
 			break;
 		}
-		case Foc_Start_Write_TRQ_Table:
+		case Foc_Set_Limiter_Config:
 		{
-			nv_write_trq_table_begin(0);
-			break;
-		}
-		case Foc_Write_TRQ_Table:
-		{
-			int pos = nv_write_trq_table_continue((u8 *)command->data, command->len);
-			if (pos < 0) {
-				erroCode = FOC_NotAllowed;
-			}else {
-				encode_u24(response+3, pos);
-				len += 3;
+			sys_debug("limter %d\n", command->len);
+			if (!nv_set_limit_config((u8 *)command->data, command->len)) {
+				erroCode = FOC_Param_Err;
 			}
 			break;
 		}
-		case Foc_End_Write_TRQ_Table:
+		case Foc_Get_Limiter_Config:
 		{
-			erroCode = nv_write_trq_table_check((u8 *)command->data, command->len, 0)?FOC_CRC_Err:FOC_Success;
-			break;
+			int config_len;
+			u8 *config = nv_get_limit_config(&config_len);
+			u8 *data = os_alloc(config_len + 3);
+			data[0] = command->cmd;
+			data[1] = CAN_MY_ADDRESS;
+			data[2] = 0;
+			memcpy(data + 3, config, config_len);
+			can_send_response(command->can_src, data, config_len+3);
+			os_free(data);
+			return;
 		}
 		case Foc_SN_Write:
 		{

Applications/foc/commands.h

@@ -35,8 +35,8 @@ typedef enum {
 	Foc_Use_SensorLess_Angle,
 	Foc_Force_Open_Run,
 	Foc_Enc_Zero_Cali_Result,
-	Foc_Start_Write_TRQ_Table,
-	Foc_Write_TRQ_Table,
+	Foc_Set_Limiter_Config,
+	Foc_Get_Limiter_Config,
 	Foc_End_Write_TRQ_Table,
 	Foc_SN_Write, //66
 	Foc_SN_Read,

Applications/foc/core/e_ctrl.c

@@ -17,12 +17,7 @@ static void _eCtrl_process_eBrake(void);
 void eCtrl_init(u16 accl_time, u16 dec_time){
 	g_eCtrl.dec_time = dec_time;
 	g_eCtrl.accl_time = accl_time;
-	if (g_eCtrl.accl_time == 0) {
-		g_eCtrl.accl_time = nv_get_foc_params()->n_acc_time;
-	}
-	if (g_eCtrl.dec_time == 0) {
-		g_eCtrl.dec_time = nv_get_foc_params()->n_dec_time;
-	}
+
 	g_eCtrl.ebrk_time = nv_get_foc_params()->n_ebrk_time;
 	
 	g_eCtrl.ebrk_time_shadow = g_eCtrl.ebrk_time;

Applications/foc/core/thro_torque.c

@@ -9,19 +9,6 @@
 #include "prot/can_foc_msg.h"
 
 static thro_torque_t _torque;
-static motor_map_t gear_torques[4][5] = {
-#if 0
-	[0] = {{500,  10}, {1200, 10}, {1700, 10}, {2200, 10}, {8000, 10},},
-	[1] = {{800,  10}, {1600, 10}, {2400, 10}, {3200, 10}, {8000, 10},},
-	[2] = {{1200, 10}, {2200, 10}, {3200, 10}, {4200, 10}, {8000, 10},},
-	[3] = {{3000, 10}, {4740, 10}, {5050, 11}, {5200, 10}, {8000, 10},},
-#else
-	[0] = {{3000,  400}, {5000, 246}, {6000, 220}, {7000, 208}, {8000, 193},},
-	[1] = {{3000,  400}, {5000, 246}, {6000, 220}, {7000, 208}, {8000, 193},},
-	[2] = {{3000,  400}, {5000, 246}, {6000, 220}, {7000, 208}, {8000, 193},},
-	[3] = {{3000,  400}, {5000, 246}, {6000, 220}, {7000, 208}, {8000, 193},},
-#endif
-};
 
 void thro_torque_reset(void) {
 	_torque.accl = false;
@@ -35,23 +22,30 @@ void thro_torque_init(void) {
 	_torque.spd_filted = 0.0f;
 }
 
+static __INLINE float gear_rpm_torque(u8 trq, s16 max) {
+	return (float)trq/100.0f * max;
+}
+
 static float thro_torque_gear_map(void) {
-	u8 gear = mc_get_gear();
-	if (gear > 3) {
-		gear = 0;
+	mc_gear_t *_current_gear = mc_get_gear_config();
+	if (_current_gear == NULL) {
+		return 0;
 	}
-	motor_map_t *map = &gear_torques[gear][0];
+
 	s16 rpm = (s16)_torque.spd_filted;
-	if (rpm <= map[0].rpm) {
-		return (float)map[0].torque;
-	}
-	int map_size = 5;
-	for (int i = 1; i < map_size; i++) {
-		if (rpm <= map[i].rpm) { //线性插值
-			float trq1 = map[i-1].torque;
-			float min_rpm = map[i-1].rpm;
-			float trq2 = map[i].torque;
-			float max_rpm = map[i].rpm;
+	if (rpm > _current_gear->n_max_speed) {
+		rpm = _current_gear->n_max_speed;
+	}
+	if (rpm <= 1000) {
+		return gear_rpm_torque(_current_gear->n_torque[0], _current_gear->n_max_trq);
+	}
+
+	for (int i = 1; i < GEAR_SPEED_TRQ_NUM; i++) {
+		if (rpm <= 1000 * (i + 1)) { //线性插值
+			float trq1 = gear_rpm_torque(_current_gear->n_torque[i-1], _current_gear->n_max_trq);
+			float min_rpm = (i * 1000);
+			float trq2 = gear_rpm_torque(_current_gear->n_torque[i], _current_gear->n_max_trq);
+			float max_rpm = (i + 1) * 1000;
 			if (trq1 > trq2) {
 				return f_map_inv((float)rpm, min_rpm, max_rpm, trq2, trq1);
 			}else {
@@ -59,7 +53,7 @@ static float thro_torque_gear_map(void) {
 			}
 		}
 	}
-	return (float)map[map_size-1].torque;	
+	return gear_rpm_torque(_current_gear->n_torque[GEAR_SPEED_TRQ_NUM-1], _current_gear->n_max_trq);
 }
 
 /* 获取油门开度 */

Applications/foc/core/thro_torque.h

@@ -17,6 +17,5 @@ void thro_torque_init(void);
 float thro_ration_to_voltage(float r);
 void thro_torque_process(u8 run_mode, float f_throttle);
 float get_user_request_torque(void);
-
 #endif /* _THRO_TORQUE_H__ */
 

Applications/foc/foc_config.h

@@ -3,8 +3,8 @@
 #include "math/fast_math.h"
 #include "bsp/bsp.h"
 
-#define CONFIG_DEFAULT_IDC_LIM 45
-#define CONFIG_DEFAULT_RPM_LIM       CONFIG_MAX_MOT_RPM
+#define CONFIG_DEFAULT_IDC_LIM CONFIG_MAX_VBUS_CURRENT
+#define CONFIG_DEFAULT_RPM_LIM CONFIG_MAX_MOT_RPM
 
 #define CONFIG_DEFAULT_EPM_PHASE_CURR 50
 #define CONFIG_DEFAULT_EPM_RPM        200

Applications/foc/limit.c

@@ -10,14 +10,10 @@ static limter_t motor_temp_lim[3];
 static limter_t mos_temp_lim[3];
 static limter_t vol_under_lim[1];
 static bool _inited = false;
-void limter_set_under_voltage(s16 und_vol) {
-	vol_under_lim[0].enter_pointer = und_vol;
-	vol_under_lim[0].exit_pointer = und_vol + 8;
-}
 
 static void limiter_init(void) {
 	mc_limit_t *limiter = nv_get_limter();
-	for (int i = 0; i < 3; i++) {
+	for (int i = 0; i < TEMP_LIMITER_NUM; i++) {
 		motor_temp_lim[i].enter_pointer = limiter->motor[i].enter_pointer;
 		motor_temp_lim[i].exit_pointer = limiter->motor[i].exit_pointer;
 		motor_temp_lim[i].limit_value = limiter->motor[i].limit_value;

Applications/foc/limit.h

@@ -13,7 +13,6 @@ typedef struct {
 
 u16 torque_temp_high_limit(void);
 u16 vbus_current_vol_lower_limit(void);
-void limter_set_under_voltage(s16 und_vol);
 
 #endif /* _Limit_H__ */
 

Applications/foc/motor/motor.c

@@ -174,24 +174,19 @@ static void _led_off_timer_handler(shark_timer_t *t) {
 
 
 static void mc_gear_vmode_changed(void) {
-	mc_gear_t *gears;
+	mc_gear_t *gears = mc_get_gear_config();
 	
-	if (motor.b_is96Mode) {
-		gears = &nv_get_gear_configs()->gears_96[0];
-	}else {
-		gears = &nv_get_gear_configs()->gears_48[0];
-	}
 	//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);
+	PMSM_FOC_SpeedLimit(gears->n_max_speed);
+	PMSM_FOC_DCCurrLimit(gears->n_max_idc);
+	PMSM_FOC_TorqueLimit(gears->n_max_trq);
 }
 
 static s16 mc_get_gear_idc_limit(void) {
 	if (motor.b_is96Mode) {
-		return nv_get_gear_configs()->gears_96[motor.n_gear].u_maxIdc;
+		return nv_get_gear_configs()->gears_96[motor.n_gear].n_max_idc;
 	}else {
-		return nv_get_gear_configs()->gears_48[motor.n_gear].u_maxIdc;
+		return nv_get_gear_configs()->gears_48[motor.n_gear].n_max_idc;
 	}
 }
 
@@ -205,9 +200,8 @@ void mc_init(void) {
 	thro_torque_init();
 	mc_detect_vbus_mode();
 	PMSM_FOC_CoreInit();
-	eCtrl_init(nv_get_foc_params()->n_acc_time, nv_get_foc_params()->n_dec_time);
+	eCtrl_init(CONFIG_ACC_TIME, nv_get_foc_params()->n_dec_time);
 	mc_gpio_init();
-	limter_set_under_voltage(nv_get_foc_params()->s_minDCVol);
 	MC_Check_MosVbusThrottle();
 	sched_timer_enable(CONFIG_SPD_CTRL_US);
 	shark_task_create(_self_check_task, NULL);
@@ -224,6 +218,17 @@ void mc_need_update(void) {
 	motor.b_updated = true;
 }
 
+mc_gear_t *mc_get_gear_config(void) {
+	mc_gear_t *gears;
+
+	if (motor.b_is96Mode) {
+		gears = &nv_get_gear_configs()->gears_96[0];
+	}else {
+		gears = &nv_get_gear_configs()->gears_48[0];
+	}
+	return &gears[motor.n_gear];
+}
+
 bool mc_unsafe_critical_error(void) {
 	u32 err = motor.n_CritiCalErrMask & (~(FOC_Cri_Err_Mask(FOC_CRIT_Fan1_Err)));
 	err = err & (~(FOC_Cri_Err_Mask(FOC_CRIT_Fan2_Err)));
@@ -281,7 +286,7 @@ bool mc_start(u8 mode) {
 #else
 	thro_torque_reset();
 #endif
-	eCtrl_init(nv_get_foc_params()->n_acc_time, nv_get_foc_params()->n_dec_time);
+	eCtrl_init(CONFIG_ACC_TIME, nv_get_foc_params()->n_dec_time);
 	motor_encoder_start(true);
 	PMSM_FOC_Start(mode);
 	PMSM_FOC_RT_LimInit();

Applications/foc/motor/motor.h

@@ -79,6 +79,7 @@ bool mc_enable_cruise(bool enable);
 bool mc_is_cruise_enabled(void);
 bool mc_set_cruise_speed(bool rpm_abs, float target_rpm);
 void mc_set_idc_limit(s16 limit);
+mc_gear_t *mc_get_gear_config(void);
 
 static __INLINE float motor_encoder_get_angle(void) {
 #ifdef USE_ENCODER_HALL