CAN消息处理

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

Applications/app/nv_storage.c

@@ -134,6 +134,19 @@ void nv_get_pid(u8 id, pid_conf_t *pid) {
 	*pid = foc_params.pid_conf[id];
 }
 
+void nv_set_hwbrake_mode(u8 mode) {
+	foc_params.n_brkShutPower = mode;
+}
+
+void nv_set_throttle_vol(float min, float max) {
+	foc_params.n_minThroVol = min;
+	foc_params.n_maxThroVol = max;
+}
+
+void nv_set_ebrake_current(float phase_curr, float dc_curr) {
+	foc_params.s_PhaseCurreBrkLim = phase_curr;
+	foc_params.s_iDCeBrkLim = dc_curr;
+}
 
 void nv_storage_init(void) {
 	nv_read_motor_params();

Applications/app/nv_storage.h

@@ -20,6 +20,8 @@ typedef struct {
 	float n_modulation;
 	float n_PhaseFilterCeof;
 	float n_currentBand; //电流环带宽
+	float n_minThroVol;
+	float n_maxThroVol;
 	u8    n_brkShutPower;
 	pid_conf_t pid_conf[PID_Max_id];
 	u16   crc16;
@@ -66,5 +68,9 @@ void nv_read_foc_params(void);
 void nv_save_hall_table(s32 *hall_table);
 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);
+void nv_set_ebrake_current(float phase_curr, float dc_curr);
+
 #endif /* _NV_Storage_H__ */
 

Applications/foc/commands.c

@@ -48,6 +48,8 @@ static void conf_foc_pid(u8 id, pid_conf_t *pid) {
 
 static void process_foc_command(foc_cmd_body_t *command) {
 	u8 erroCode = 0;
+	u8 response[32];
+	int len = 3;
 	sys_debug("command %d\n", command->cmd);
 	switch (command->cmd) {
 		case Foc_Start_Motor:
@@ -75,20 +77,56 @@ static void process_foc_command(foc_cmd_body_t *command) {
 			
 			break;
 		}
+		case Foc_Set_Ctrl_Mode:
+		{
+			u8 mode = decode_u8(command->data);
+			if (!PMSM_FOC_SetCtrlMode(mode)) {
+				erroCode = PMSM_FOC_GetErrCode();
+			}
+			response[len++] = PMSM_FOC_GetCtrlMode();
+			break;
+		}
+		case Foc_Set_Gear_Limit:
+		{
+			if (command->len < 5) {
+				erroCode = FOC_Param_Err;
+			}else {
+				u16 maxRPM = decode_u16(command->data);
+				u16 maxPhaseCurr = decode_u8((u8 *)command->data + 2);
+				u8  maxiDC = decode_u8((u8 *)command->data + 4);
+				PMSM_FOC_SpeedLimit((float)maxRPM);
+				PMSM_FOC_PhaseCurrLim((float)maxPhaseCurr);
+				PMSM_FOC_iBusLimit((float)maxiDC);
+				encode_u16(response + 3, (u16)PMSM_FOC_GetSpeedLimit());
+				encode_u16(response + 5, (u16)PMSM_FOC_GetPhaseCurrLim());
+				encode_u8(response + 7, (u8)PMSM_FOC_GetiBusLimit());
+				len += 5;
+			}
+			break;
+		}
 		case Foc_Set_Speed_Limit:
 		{
 			s16 speed = decode_s16(((u8 *)command->data));
 			PMSM_FOC_SpeedLimit(speed);
+			encode_u16(response + 3, (u16)PMSM_FOC_GetSpeedLimit());
+			len += 2;
+			break;
 		}
 		case Foc_Set_iDC_Limit:
 		{
-			s16 current = decode_s16(((u8 *)command->data));
-			PMSM_FOC_iBusLimit(current);
+			u8 current = decode_u8(((u8 *)command->data));
+			PMSM_FOC_iBusLimit((float)current);
+			encode_u8(response + 3, (u8)PMSM_FOC_GetiBusLimit());
+			len += 1;
+			break;
 		}
 		case Foc_Set_Phase_Current:
 		{
 			s16 curr = decode_s16(((u8 *)command->data));
 			PMSM_FOC_PhaseCurrLim((float)curr);
+			encode_u16(response + 3, (u16)PMSM_FOC_GetPhaseCurrLim());
+			len += 2;
+			break;
 		}
 		case Foc_Cali_Hall_Phase:
 		{
@@ -110,6 +148,15 @@ static void process_foc_command(foc_cmd_body_t *command) {
 			u8 id =   decode_u8((u8 *)command->data);
 			memcpy((char *)&pid, (char *)command->data + 1, sizeof(pid_conf_t));
 			conf_foc_pid(id, &pid);
+			break;
+		}
+		case Foc_Set_EPM_Mode:
+		{
+			bool mode = decode_u8((u8 *)command->data) == 0?false:true;
+			if (!PMSM_FOC_Set_epmMode(mode)) {
+				erroCode = PMSM_FOC_GetErrCode();
+			}
+			break;
 		}
 		case Foc_Start_EPM_Move:
 		{
@@ -126,7 +173,10 @@ static void process_foc_command(foc_cmd_body_t *command) {
 			break;
 		}
 	}
-	//can_send_ack(command->can_src, CMD_2_CAN_KEY(command->cmd), (u8)erroCode);
+	response[0] = command->cmd;
+	response[1] = command->can_src;
+	response[2] = erroCode;
+	can_send_response(command->can_src, response, len);
 }
 
 

Applications/foc/commands.h

@@ -13,6 +13,11 @@ typedef enum {
 	Foc_Set_Cruise_Speed,    //u32, set the speed for curise riding
 	Foc_Set_Cruise_Mode,
 	Foc_Set_Phase_Current,
+	Foc_Set_Ctrl_Mode,
+	Foc_Set_Gear_Limit,
+	Foc_Set_Open_Dq_Vol,		//u32, u32, 114d000000000a000000, 114d0000000000000000
+	Foc_Set_EPM_Mode,
+	Foc_Start_EPM_Move,
 	Foc_Conf_Pid,
 	Foc_Hall_Phase_Cali_Result,
 	Foc_Hall_Offset_Cali_Result,
@@ -23,8 +28,7 @@ typedef enum {
 	Foc_Report_Vbus_Vol,		//u32
 	Foc_Report_Phase_Vol,		//u32,u32,u32
 	Foc_Report_Dq_Vol,			//u32, u32
-	Foc_Set_Open_Dq_Vol,  		//u32, u32, 114d000000000a000000, 114d0000000000000000
-	Foc_Start_EPM_Move,
+	Foc_Report_Power,
 	Foc_Cmd_Max
 }foc_cmd_t;
 #define CMD_2_CAN_KEY(cmd) ((u16)(((u16)cmd) | (CAN_MY_ADDRESS<<8)))
@@ -36,6 +40,7 @@ typedef enum {
 typedef struct {
 	foc_cmd_t cmd;
 	u8        can_src;
+	u8        len;
 	void      *data;
 }foc_cmd_body_t;
 

Applications/foc/core/PMSM_FOC_Core.c

@@ -485,6 +485,11 @@ void PMSM_FOC_iBusLimit(float ibusLimit) {
 	_gFOC_Ctrl.userLim.s_iDCLim = (ibusLimit);
 }
 
+float PMSM_FOC_GetiBusLimit(void) {
+	return _gFOC_Ctrl.userLim.s_iDCLim;
+}
+
+
 void PMSM_FOC_SpeedLimit(float speedLimit) {
 	if (speedLimit > _gFOC_Ctrl.hwLim.s_motRPMMax) {
 		speedLimit = _gFOC_Ctrl.hwLim.s_motRPMMax;
@@ -518,8 +523,13 @@ void PMSM_FOC_VbusVoltage(float vbusVol) {
 	_gFOC_Ctrl.in.s_vDC = vbusVol;
 }
 
-void PMSM_FOC_SetCtrlMode(u8 mode) {
+bool PMSM_FOC_SetCtrlMode(u8 mode) {
+	if (mode > CTRL_MODE_CURRENT_BRK) {
+		PMSM_FOC_SetErrCode(FOC_Param_Err);
+		return false;
+	}
 	_gFOC_Ctrl.in.n_ctlMode = mode;
+	return true;
 }
 
 u8 PMSM_FOC_GetCtrlMode(void) {

Applications/foc/core/PMSM_FOC_Core.h

@@ -196,7 +196,7 @@ void PMSM_FOC_iBusLimit(float ibusLimit);
 void PMSM_FOC_SpeedLimit(float speedLimit);
 float PMSM_FOC_GetSpeedLimit(void);
 void PMSM_FOC_VbusVoltage(float vbusVol);
-void PMSM_FOC_SetCtrlMode(u8 mode);
+bool PMSM_FOC_SetCtrlMode(u8 mode);
 u8 PMSM_FOC_GetCtrlMode(void);
 void PMSM_FOC_SetOpenVdq(float vd, float vq);
 bool PMSM_FOC_EnableCruise(bool enable);
@@ -229,6 +229,7 @@ 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_GetiBusLimit(void);
 
 #endif /* _PMSM_FOC_Core_H__ */
 

Applications/libs/utils.h

@@ -93,6 +93,27 @@ static __inline__ void encode_s32(u8 *buff, s32 value)
 	encode_s08(buff+3,value >> 24);
 }
 
+static __inline__ void encode_float(u8 *buff, float value)
+{
+	u8 *p_f = (u8 *)&value;
+	buff[0] = p_f[0];
+	buff[1] = p_f[1];
+	buff[2] = p_f[2];
+	buff[3] = p_f[3];
+}
+
+static __inline__ float decode_float(const u8 *buff)
+{
+	float value;
+	u8 *p_f = (u8 *)&value;
+	p_f[0] = buff[0];
+	p_f[1] = buff[1];
+	p_f[2] = buff[2];
+	p_f[3] = buff[3];
+	return value;
+}
+
+
 
 #define ARRAY_SIZE(a) (sizeof(a)/sizeof(a[0]))
 #define min(a,b) ((a)>(b)?(b):(a))

Applications/prot/can_foc_msg.c

@@ -3,44 +3,54 @@
 #include "prot/can_foc_msg.h"
 #include "foc/commands.h"
 
-void can_report_speed(int can, int rpm) {
+void can_report_speed(u8 can, s16 rpm) {
 	u8 data[6];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Speed));
-	encode_u32(data + 2, rpm);
-	can_send_message(get_request_can_id(can, 1), data, sizeof(data), 100);
+	encode_s16(data + 2, rpm);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
 }
 
-void can_report_phase_current(int can, int iA, int iB, int iC) {
+void can_report_power(u8 can, s16 rpm, s16 vDC, s16 iDC) {
+	u8 data[8];
+	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Power));
+	encode_s16(data + 2, rpm);
+	encode_s16(data + 4, vDC);
+	encode_s16(data + 6, iDC);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
+}
+
+
+void can_report_phase_current(u8 can, float iA, float iB, float iC) {
 	u8 data[14];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Phase_Current));
-	encode_u32(data + 2, iA);
-	encode_u32(data + 6, iB);
-	encode_u32(data + 10, iC);
-	can_send_message(get_request_can_id(can, 1), data, sizeof(data), 100);
+	encode_float(data + 2, iA);
+	encode_float(data + 6, iB);
+	encode_float(data + 10, iC);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
 }
 
-void can_report_phase_voltage(int can, int vA, int vB, int vC) {
+void can_report_phase_voltage(u8 can, float vA, float vB, float vC) {
 	u8 data[14];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Phase_Vol));
-	encode_u32(data + 2, vA);
-	encode_u32(data + 6, vB);
-	encode_u32(data + 10, vC);
-	can_send_message(get_request_can_id(can, 1), data, sizeof(data), 100);
+	encode_float(data + 2, vA);
+	encode_float(data + 6, vB);
+	encode_float(data + 10, vC);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
 
 }
 
-void can_report_dq_current(int can, int id, int iq) {
+void can_report_dq_current(u8 can, float id, float iq) {
 	u8 data[10];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Report_Dq_Current));
-	encode_u32(data + 2, id);
-	encode_u32(data + 6, iq);
-	can_send_message(get_request_can_id(can, 1), data, sizeof(data), 100);
+	encode_float(data + 2, id);
+	encode_float(data + 6, iq);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
 }
 
-void can_response_hall_offset(int can, int offset) {
+void can_response_hall_offset(u8 can, int offset) {
 	u8 data[7];
 	encoder_can_key(data, CMD_2_CAN_KEY(Foc_Cali_Hall_Offset));
 	encode_u8(data + 2, 1);
 	encode_u32(data + 3, offset);
-	can_send_message(get_reponse_can_id(can), data, sizeof(data), 100);
+	can_send_message(get_indicator_can_id(can), data, sizeof(data), 0);
 }

Applications/prot/can_foc_msg.h

@@ -1,11 +1,13 @@
 #ifndef _Can_Foc_Msg_H__
 #define _Can_Foc_Msg_H__
+#include "os/os_types.h"
 
-void can_report_speed(int can, int rpm);
-void can_report_phase_current(int can, int iA, int iB, int iC);
-void can_report_phase_voltage(int can, int vA, int vB, int vC);
-void can_report_dq_current(int can, int id, int iq);
-void can_response_hall_offset(int can, int offset);
+void can_report_speed(u8 can, s16 rpm);
+void can_report_phase_current(u8 can, float iA, float iB, float iC);
+void can_report_phase_voltage(u8 can, float vA, float vB, float vC);
+void can_report_dq_current(u8 can, float id, float iq);
+void can_response_hall_offset(u8 can, int offset);
+void can_report_power(u8 can, s16 rpm, s16 vDC, s16 iDC);
 
 #endif	/*_Can_Foc_Msg_H__ */
 

Applications/prot/can_message.c

@@ -122,6 +122,7 @@ static void can_process_message(can_message_t *message){
 			foc_cmd_body_t command;
 			command.cmd = (foc_cmd_t)(message->key & 0xFF);
 			command.can_src = message->src;
+			command.len = message->len;
 			command.data = os_alloc(message->len);
 			if (command.data) {
 				memcpy(command.data, message->data, message->len);

Project/MC100.uvoptx

@@ -117,10 +117,6 @@
         <pMon>Segger\JL2CM3.dll</pMon>
       </DebugOpt>
       <TargetDriverDllRegistry>
-        <SetRegEntry>
-          <Number>0</Number>
-          <Key>DLGUARM</Key>
-        </SetRegEntry>
         <SetRegEntry>
           <Number>0</Number>
           <Key>ARMRTXEVENTFLAGS</Key>