1、版本发布

Inc/soft_p_2_c.h

@@ -83,6 +83,8 @@ enum vklink_MSGID_SET
 	MSGID_SET_PUMP_ID = 32,       // 设置CAN水泵ID
 	MSGID_SET_PNCANID   = 55,	  // 设置EFT水泵电调CAN ID
 	MSGID_SET_RESIWIRE_BLOWN = 60,// 熔断电阻丝
+	MSGID_SET_WEIGHT_RESETK = 62,// 称重恢复出厂
+	MSGID_SET_WEIGHTFAC_CAL = 63,// 称重出厂标定K
 	MSGID_SET_FRADAR_SN = 98,     // 设置雷达SN号
 	MSGID_SET_BRADAR_SN = 99,     // 设置雷达SN号
 	MSGID_SET_TRADAR_SN = 100,    // 设置雷达SN号

Inc/soft_poweramp.h

@@ -7,178 +7,178 @@
 #include "common.h"
 ///////////////////
 
-#define POWERAMP_CRC8_KEY (0x2A)
-/*
-Number Item Data Index Remark
-1 电池总电压 Data[0-1] unsigned int, 16bits， mV,Range: 0 – 60000mV
-2 充放电电流 Data[2-3] signed int， 16bits， 10mA
-                Range: – 300000 to 80000mA
-                Positive for charging
-                Negative for discharging.
-3 Max allowable charging current
-                Data[4-5] signed int， 16bits， 10mA
-                Range: – 300000 to 80000mA
-                Positive for charging
-                Negative for discharging.
-                Remark:
-                If communicating with UAV, this value
-                will be 0.
-4 最大电芯温度 Data[6-7] signed int， 16bits， 0.1 Degree C, range: -40 to 125 degree C
-5 最小电芯温度 Data[8-9] signed int， 16bits， 0.1 Degree C, range: -40 to 125 degree C
-6 相对充电状态 Data[10-11] unsigned int， 16bits， 0.1% 0 to 1000 (0 to 1000‰)
-7 绝对充电状态 Data[12-13] unsigned int， 16bits， 0.1% 0 to 1000 (0 to 1000‰)
-8 剩余容量 Data[14-15] unsigned int， 16bits， mAH 0 mA to 20000 mAH
-9 最大电芯压差 Data[16-17] unsigned int， 16bits， mV, 0mV to 1000mV
-10 Cell 1 电压 Data[18-19] unsigned int， 16bits， mV 0 to 4500mV
-11 Cell 2 电压 Data[20-21] unsigned int， 16bits， mV 0 to 4500mV
-12 Cell 3 电压 Data[22-23] unsigned int， 16bits， mV 0 to 4500mV
-13 Cell 4 电压 Data[24-25] unsigned int， 16bits， mV 0 to 4500mV
-14 Cell 5 电压 Data[26-27] unsigned int， 16bits， mV 0 to 4500mV
-15 Cell 6 电压 Data[28-29] unsigned int， 16bits， mV 0 to 4500mV
-16 Cell 7 电压 Data[30-31] unsigned int， 16bits， mV 0 to 4500mV
-17 Cell 8 电压 Data[32-33] unsigned int， 16bits， mV 0 to 4500mV
-18 Cell 9 电压 Data[34-35] unsigned int， 16bits， mV 0 to 4500mV
-19 Cell 10 电压 Data[36-37] unsigned int， 16bits， mV 0 to 4500mV
-20 Cell 11 电压 Data[38-39] unsigned int， 16bits， mV 0 to 4500mV
-21 Cell 12 电压 Data[40-41] unsigned int， 16bits， mV 0 to 4500mV
-22 Cell 13 电压 Data[42-43] unsigned int， 16bits， mV 0 to 4500mV
-23 Warning level Data[44-45] Unsigned char, 8 bits,
-                            Value:
-                            0: no warning
-                            1: level 1 warning, UAV shall return
-                            2: level 2 warning, UAV shall land
-24 系统状态 Data[46-47] unsigned int, 16 bits
-                        Permanent Fault Alarm:
-                        Bit0: 1:电芯压差大, 0: 正常
-                        Bit1: 1:循环寿命结束， 0: 正常
-                        Bit2: 1:电芯温度高， 0: 正常
-                        Bit3: 1:其他失效， 0: 正常
-                        Cell Fault Alarm：
-                        Bit4: 1： 电芯压差较大, 0: 正常
-                        Discharging Alarm:
-                        Bit5: 1:电池放电过温, 0: 正常
-                        Bit6: 1:电池放电低温, 0: 正常
-                        Bit7, Bit8: 放电低压告警
-                        value: 0: 正常
-                        value: 1: level 1, 电芯电压 3.4V 或
-                        SOC 30%, See Spec for details.
-                        value: 2: level 2, 电芯电压 3.0V 或
-                        SOC 20%, See Spec for details.
-                        value: 3: level 3, 电芯电压 2.8V 或
-                        SOC 10%, See Spec for details.
-                        Bit9: 1:放电过流， 0: 正常
-                        Charging Alarm:
-                        Bit10: 1:充电过温， 0: 正常
-                        Bit11: 1:充电低温， 0: 正常
-                        Bit12: 1:充电过压， 0: 正常
-                        Bit13: 1:充电过流， 0: 正常
-                        Bit14: 1:充电满， 0: 正常
-                        Remark:
-                        For charger: when BMS encounters
-                        the Charging Alarm or Cell fault
-                        alarm, BMS will turn off the charging
-                        MOSFET to stop charging.For UAV: when BMS encounters the
-                        Discharging Alarm or Cell fault alarm
-                        (UAV not in operation), BMS will turn
-                        off the discharging MOSFET.
-*/
-#pragma pack(1)
-typedef struct
-{
-    short amp_data[24];  //
-}_POWERAMP_INF;
-#pragma pack()
-extern _POWERAMP_INF poweramp_inf;
-
-
-
-
-/*
-Number Item Data Index Remark
-1 软件版本号 Data[0-1] unsigned char, 2 bytes.
-            Data[0]: major version
-            Data[1]: minor version
-            e.g.: v02.60, Data [0]=2, Data[1]=60
-2 硬件版本号 Data[2-3] unsigned char, 2 bytes.
-            Data[0]: major version
-            Data[1]: minor version
-            e.g.: v02.60, Data [0]=2, Data[1]=60
-3 通信协议版本号 Data[4-5] unsigned char, 2 bytes.
-            Data[0]: major version
-            Data[1]: minor version
-            e.g.: v02.60, Data [0]=2, Data[1]=60
-*/
-#pragma pack(1)
-typedef struct
-{
-    unsigned char amp_ver[6];  //
-}_POWERAMP_VER;
-#pragma pack()
-extern _POWERAMP_VER poweramp_ver;
-
-
-
-
-
-/*
-Number Item Data Index Remark
-1 BMS 设计容量 Data[0-1] unsigned int， 16bits， 0.1AH Max value 6553.5 AH
-2 电池串数 Data[2] unsigned char, 8bits, unit: 1 Value: 13
-3 电池健康度 Data[3-4] unsigned int， 16bits， 0.1% Range: 0 to 1000 (0 to 1000‰)
-4 电池循环次数 Data[5-6] unsigned int, 16bits, unit: 1 time
-5 电池过充次数 Data[7-8] unsigned int, 16bits, unit: 1 time
-6 电池过放次数 Data[9-10] unsigned int, 16bits, unit: 1 time
-7 电池过温次数 Data[11-12] unsigned int, 16bits, unit: 1 time
-8 电池过流次数 Data[13-14] unsigned int, 16bits, unit: 1 time
-9 单体电池满充电压 Data[15-16] unsigned int, 16bits, mV
-10 单体电池过放电压 Data[17-18] unsigned int, 16bits, mV
-11 电池编号 Data[19-25] 7 bytes,
-                        Data [19-20]: ‘J’’M’
-                        Data [21]: year, 19-50, offset 2000,
-                        2019-2050
-                        Data [22]: month, 0-12
-                        Data [23]: day,0-31max
-                        Data [24-25]: unsigned int, production
-                        line SN
-12 年 Data[26] unsigned char, 8 bits, offset 2000 E.g.: 19+2000 = 2019
-13 月 Data[27] unsigned char, 8 bitsRange: 0 - 12
-14 日 Data[28] unsigned char, 8 bitsRange: 0 – 31 max
-15 时 Data[29] unsigned char, 8 bitsRange: 0 - 23
-16 分 Data[20] unsigned char, 8 bitsRange: 0 - 59
-17 秒 Data[31] unsigned char, 8 bitsRang
-*/
-
-#pragma pack(1)
-typedef struct
-{
-    uint16_t amp_cap; //容量
-    uint8_t amp_cellnum; //串数
-    uint16_t amp_soh; //健康度
-    uint16_t amp_cycle; //循环次数
-    uint16_t amp_chg_count; //
-    uint16_t amp_dsg_count;
-    uint16_t amp_otp_count;
-    uint16_t amp_ocp_count;
-    uint16_t amp_fullchg_cellvolt;
-    uint16_t amp_uvd_cellvolt;
-    uint8_t amp_sn[14]; //编号
-    uint8_t amp_year;
-    uint8_t amp_month;
-    uint8_t amp_day;
-    uint8_t amp_hour;
-    uint8_t amp_min;
-    uint8_t amp_sencond;
-}_POWERAMP_SYS;
-#pragma pack()
-extern _POWERAMP_SYS poweramp_sys;
-
-extern Connect_check Poweramp_Link;
-void PowerAmpCanRecvHookFunction(uint32_t cellCanID, uint8_t* data, uint8_t len);
-
-void send_msg_to_poweramp(void);
-void check_poweramp_link(void);
-
-
-extern uint32_t time_poweramp_lastrecv;
+// #define POWERAMP_CRC8_KEY (0x2A)
+// /*
+// Number Item Data Index Remark
+// 1 锟斤拷锟斤拷艿锟窖� Data[0-1] unsigned int, 16bits锟斤拷 mV,Range: 0 锟紺 60000mV
+// 2 锟斤拷诺锟斤拷锟斤拷 Data[2-3] signed int锟斤拷 16bits锟斤拷 10mA
+//                 Range: 锟紺 300000 to 80000mA
+//                 Positive for charging
+//                 Negative for discharging.
+// 3 Max allowable charging current
+//                 Data[4-5] signed int锟斤拷 16bits锟斤拷 10mA
+//                 Range: 锟紺 300000 to 80000mA
+//                 Positive for charging
+//                 Negative for discharging.
+//                 Remark:
+//                 If communicating with UAV, this value
+//                 will be 0.
+// 4 锟斤拷锟斤拷芯锟铰讹拷 Data[6-7] signed int锟斤拷 16bits锟斤拷 0.1 Degree C, range: -40 to 125 degree C
+// 5 锟斤拷小锟斤拷芯锟铰讹拷 Data[8-9] signed int锟斤拷 16bits锟斤拷 0.1 Degree C, range: -40 to 125 degree C
+// 6 锟斤拷猿锟斤拷状态 Data[10-11] unsigned int锟斤拷 16bits锟斤拷 0.1% 0 to 1000 (0 to 1000锟斤拷)
+// 7 锟斤拷锟皆筹拷锟阶刺� Data[12-13] unsigned int锟斤拷 16bits锟斤拷 0.1% 0 to 1000 (0 to 1000锟斤拷)
+// 8 剩锟斤拷锟斤拷锟斤拷 Data[14-15] unsigned int锟斤拷 16bits锟斤拷 mAH 0 mA to 20000 mAH
+// 9 锟斤拷锟斤拷芯压锟斤拷 Data[16-17] unsigned int锟斤拷 16bits锟斤拷 mV, 0mV to 1000mV
+// 10 Cell 1 锟斤拷压 Data[18-19] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 11 Cell 2 锟斤拷压 Data[20-21] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 12 Cell 3 锟斤拷压 Data[22-23] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 13 Cell 4 锟斤拷压 Data[24-25] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 14 Cell 5 锟斤拷压 Data[26-27] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 15 Cell 6 锟斤拷压 Data[28-29] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 16 Cell 7 锟斤拷压 Data[30-31] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 17 Cell 8 锟斤拷压 Data[32-33] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 18 Cell 9 锟斤拷压 Data[34-35] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 19 Cell 10 锟斤拷压 Data[36-37] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 20 Cell 11 锟斤拷压 Data[38-39] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 21 Cell 12 锟斤拷压 Data[40-41] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 22 Cell 13 锟斤拷压 Data[42-43] unsigned int锟斤拷 16bits锟斤拷 mV 0 to 4500mV
+// 23 Warning level Data[44-45] Unsigned char, 8 bits,
+//                             Value:
+//                             0: no warning
+//                             1: level 1 warning, UAV shall return
+//                             2: level 2 warning, UAV shall land
+// 24 系统状态 Data[46-47] unsigned int, 16 bits
+//                         Permanent Fault Alarm:
+//                         Bit0: 1:锟斤拷芯压锟斤拷锟�, 0: 锟斤拷锟斤拷
+//                         Bit1: 1:循锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷 0: 锟斤拷锟斤拷
+//                         Bit2: 1:锟斤拷芯锟铰度高ｏ拷 0: 锟斤拷锟斤拷
+//                         Bit3: 1:锟斤拷锟斤拷失效锟斤拷 0: 锟斤拷锟斤拷
+//                         Cell Fault Alarm锟斤拷
+//                         Bit4: 1锟斤拷 锟斤拷芯压锟斤拷洗锟�, 0: 锟斤拷锟斤拷
+//                         Discharging Alarm:
+//                         Bit5: 1:锟斤拷胤诺锟斤拷锟斤拷, 0: 锟斤拷锟斤拷
+//                         Bit6: 1:锟斤拷胤诺锟斤拷锟斤拷, 0: 锟斤拷锟斤拷
+//                         Bit7, Bit8: 锟脚碉拷锟窖癸拷婢�
+//                         value: 0: 锟斤拷锟斤拷
+//                         value: 1: level 1, 锟斤拷芯锟斤拷压 3.4V 锟斤拷
+//                         SOC 30%, See Spec for details.
+//                         value: 2: level 2, 锟斤拷芯锟斤拷压 3.0V 锟斤拷
+//                         SOC 20%, See Spec for details.
+//                         value: 3: level 3, 锟斤拷芯锟斤拷压 2.8V 锟斤拷
+//                         SOC 10%, See Spec for details.
+//                         Bit9: 1:锟脚碉拷锟斤拷锟斤拷锟� 0: 锟斤拷锟斤拷
+//                         Charging Alarm:
+//                         Bit10: 1:锟斤拷锟斤拷锟铰ｏ拷 0: 锟斤拷锟斤拷
+//                         Bit11: 1:锟斤拷锟斤拷锟铰ｏ拷 0: 锟斤拷锟斤拷
+//                         Bit12: 1:锟斤拷锟斤拷压锟斤拷 0: 锟斤拷锟斤拷
+//                         Bit13: 1:锟斤拷锟斤拷锟斤拷锟斤拷 0: 锟斤拷锟斤拷
+//                         Bit14: 1:锟斤拷锟斤拷锟斤拷锟� 0: 锟斤拷锟斤拷
+//                         Remark:
+//                         For charger: when BMS encounters
+//                         the Charging Alarm or Cell fault
+//                         alarm, BMS will turn off the charging
+//                         MOSFET to stop charging.For UAV: when BMS encounters the
+//                         Discharging Alarm or Cell fault alarm
+//                         (UAV not in operation), BMS will turn
+//                         off the discharging MOSFET.
+// */
+// #pragma pack(1)
+// typedef struct
+// {
+//     short amp_data[24];  //
+// }_POWERAMP_INF;
+// #pragma pack()
+// extern _POWERAMP_INF poweramp_inf;
+
+
+
+
+// /*
+// Number Item Data Index Remark
+// 1 锟斤拷锟斤拷锟芥本锟斤拷 Data[0-1] unsigned char, 2 bytes.
+//             Data[0]: major version
+//             Data[1]: minor version
+//             e.g.: v02.60, Data [0]=2, Data[1]=60
+// 2 硬锟斤拷锟芥本锟斤拷 Data[2-3] unsigned char, 2 bytes.
+//             Data[0]: major version
+//             Data[1]: minor version
+//             e.g.: v02.60, Data [0]=2, Data[1]=60
+// 3 通锟斤拷协锟斤拷姹撅拷锟� Data[4-5] unsigned char, 2 bytes.
+//             Data[0]: major version
+//             Data[1]: minor version
+//             e.g.: v02.60, Data [0]=2, Data[1]=60
+// */
+// #pragma pack(1)
+// typedef struct
+// {
+//     unsigned char amp_ver[6];  //
+// }_POWERAMP_VER;
+// #pragma pack()
+// extern _POWERAMP_VER poweramp_ver;
+
+
+
+
+
+// /*
+// Number Item Data Index Remark
+// 1 BMS 锟斤拷锟斤拷锟斤拷锟� Data[0-1] unsigned int锟斤拷 16bits锟斤拷 0.1AH Max value 6553.5 AH
+// 2 锟斤拷卮锟斤拷锟� Data[2] unsigned char, 8bits, unit: 1 Value: 13
+// 3 锟斤拷亟锟斤拷锟斤拷锟� Data[3-4] unsigned int锟斤拷 16bits锟斤拷 0.1% Range: 0 to 1000 (0 to 1000锟斤拷)
+// 4 锟斤拷锟窖�拷锟斤拷锟斤拷锟� Data[5-6] unsigned int, 16bits, unit: 1 time
+// 5 锟斤拷毓锟斤拷锟斤拷锟斤拷 Data[7-8] unsigned int, 16bits, unit: 1 time
+// 6 锟斤拷毓锟斤拷糯锟斤拷锟� Data[9-10] unsigned int, 16bits, unit: 1 time
+// 7 锟斤拷毓锟斤拷麓锟斤拷锟� Data[11-12] unsigned int, 16bits, unit: 1 time
+// 8 锟斤拷毓锟斤拷锟斤拷锟斤拷锟� Data[13-14] unsigned int, 16bits, unit: 1 time
+// 9 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟窖� Data[15-16] unsigned int, 16bits, mV
+// 10 锟斤拷锟斤拷锟截癸拷锟脚碉拷压 Data[17-18] unsigned int, 16bits, mV
+// 11 锟斤拷乇锟斤拷 Data[19-25] 7 bytes,
+//                         Data [19-20]: 锟斤拷J锟斤拷锟斤拷M锟斤拷
+//                         Data [21]: year, 19-50, offset 2000,
+//                         2019-2050
+//                         Data [22]: month, 0-12
+//                         Data [23]: day,0-31max
+//                         Data [24-25]: unsigned int, production
+//                         line SN
+// 12 锟斤拷 Data[26] unsigned char, 8 bits, offset 2000 E.g.: 19+2000 = 2019
+// 13 锟斤拷 Data[27] unsigned char, 8 bitsRange: 0 - 12
+// 14 锟斤拷 Data[28] unsigned char, 8 bitsRange: 0 锟紺 31 max
+// 15 时 Data[29] unsigned char, 8 bitsRange: 0 - 23
+// 16 锟斤拷 Data[20] unsigned char, 8 bitsRange: 0 - 59
+// 17 锟斤拷 Data[31] unsigned char, 8 bitsRang
+// */
+
+// #pragma pack(1)
+// typedef struct
+// {
+//     uint16_t amp_cap; //锟斤拷锟斤拷
+//     uint8_t amp_cellnum; //锟斤拷锟斤拷
+//     uint16_t amp_soh; //锟斤拷锟斤拷锟斤拷
+//     uint16_t amp_cycle; //循锟斤拷锟斤拷锟斤拷
+//     uint16_t amp_chg_count; //
+//     uint16_t amp_dsg_count;
+//     uint16_t amp_otp_count;
+//     uint16_t amp_ocp_count;
+//     uint16_t amp_fullchg_cellvolt;
+//     uint16_t amp_uvd_cellvolt;
+//     uint8_t amp_sn[14]; //锟斤拷锟�
+//     uint8_t amp_year;
+//     uint8_t amp_month;
+//     uint8_t amp_day;
+//     uint8_t amp_hour;
+//     uint8_t amp_min;
+//     uint8_t amp_sencond;
+// }_POWERAMP_SYS;
+// #pragma pack()
+// extern _POWERAMP_SYS poweramp_sys;
+
+// extern Connect_check Poweramp_Link;
+// void PowerAmpCanRecvHookFunction(uint32_t cellCanID, uint8_t* data, uint8_t len);
+
+// void send_msg_to_poweramp(void);
+// void check_poweramp_link(void);
+
+
+// extern uint32_t time_poweramp_lastrecv;
 
 #endif

Inc/soft_seed_device.h

@@ -111,6 +111,10 @@ enum FACID
     FAC_QX_BMS = 30,  //协氢电池
     FAC_DM_CHECKLOW = 31,//电目断料计
 
+    FAC_DM_RT_4D = 36,  //DM 4d防地
+    FAC_DM_RF_4D = 37,  //DM 4d前避障
+    FAC_DM_RB_4D = 38, //DM  4d后避障
+
 };
 typedef struct
 {
@@ -384,12 +388,14 @@ enum CalEnum
     Weight_Peer = 1,
     Weight_Kg = 2,
     Weight_Reserve = 3,
-    Weight_Bcak = 4,
+    Seed_Bcak = 4,
     Weight_Set_K = 5,
     Weight_Mode = 6,
-    Weight_Drug_Rate = 7
+    Weight_Drug_Rate = 7,
+    Weight_Bcak = 8,
+    Weight_Fac_cal = 9
 };
-
+extern bool weight_factory_cal_flag;
 void can_sendmsg_VK(void);
 void seed_init_send_info(uint8_t device_type, char *factory);
 void Set_Seed_Weight_Par(uint8_t device_type, char *factory);

Inc/soft_terrain.h

@@ -14,6 +14,7 @@ extern UAVH30 uavh30_dist;
 
 extern bool terrain_is_link;
 extern uint16_t terrain_height;
+extern bool F4d_send_flag;
 
 void can_recv_enzhao_terrain(uint32_t CanID, uint8_t data[], uint8_t len);
 

Src/soft_bms.c

@@ -38,7 +38,7 @@ void update_bms_data( void )
     Check_dev_link(&tattu_device1.Tattu_Link,5000,(char *)&tattu_device1.ttu_inf,sizeof(_TATTU_INFO));
     Check_dev_link(&tattu_device2.Tattu_Link,5000,(char *)&tattu_device2.ttu_inf,sizeof(_TATTU_INFO));
     //极目电池
-    check_poweramp_link();
+    //check_poweramp_link();
     //海盈电池
     Check_dev_link(&Herewin_Link,5000,(char *)&herewin_info,sizeof(herewin_bms));
     //VK电池
@@ -254,38 +254,38 @@ void update_bms_data( void )
             memset( &bms_data2, 0, sizeof( bms_data2 ) );
         }
     }
-    else if ( Poweramp_Link.connect_status == COMP_NORMAL )
-    {
-        Dev.Bms_Link.connect_status = COMP_NORMAL;
-        group_num = 1;
-
-        //ID不足12位的从buf[0]开始存放
-        bms_data.bms_cycle = poweramp_sys.amp_cycle;
-        bms_data.bms_volt = ((uint16_t)poweramp_inf.amp_data[0]) / 10;
-        bms_data.bms_temp = poweramp_inf.amp_data[3];
-        bms_data.bms_vs = poweramp_inf.amp_data[5] / 10;
-        bms_data.bms_ss = poweramp_inf.amp_data[22];
-        bms_data.bms_num = 13;
-        bms_data.bms_v1 = poweramp_inf.amp_data[9];
-        bms_data.bms_v2 = poweramp_inf.amp_data[10];
-        bms_data.bms_v3 = poweramp_inf.amp_data[11];
-        bms_data.bms_v4 = poweramp_inf.amp_data[12];
-        bms_data.bms_v5 = poweramp_inf.amp_data[13];
-        bms_data.bms_v6 = poweramp_inf.amp_data[14];
-        bms_data.bms_v7 = poweramp_inf.amp_data[15];
-        bms_data.bms_v8 = poweramp_inf.amp_data[16];
-        bms_data.bms_v9 = poweramp_inf.amp_data[17];
-        bms_data.bms_v10 = poweramp_inf.amp_data[18];
-        bms_data.bms_v11 = poweramp_inf.amp_data[19];
-        bms_data.bms_v12 = poweramp_inf.amp_data[20];
-        bms_data.bms_v13 = poweramp_inf.amp_data[21];
-        memcpy( bms_data.bms_ids, "poweramp", 8 );
-        bms_data.bms_ac = poweramp_inf.amp_data[1];
-        bms_data.serial_num = FAC_POWERAMP;
-
-        if(dev_bms1.regist.dev == false)
-            regist_dev_info(&dev_bms1,DEVICE_BMS1,false,NULL,0,NULL,0,NULL,0,"poweramp",9);
-    }
+    // else if ( Poweramp_Link.connect_status == COMP_NORMAL )
+    // {
+    //     Dev.Bms_Link.connect_status = COMP_NORMAL;
+    //     group_num = 1;
+
+    //     //ID不足12位的从buf[0]开始存放
+    //     bms_data.bms_cycle = poweramp_sys.amp_cycle;
+    //     bms_data.bms_volt = ((uint16_t)poweramp_inf.amp_data[0]) / 10;
+    //     bms_data.bms_temp = poweramp_inf.amp_data[3];
+    //     bms_data.bms_vs = poweramp_inf.amp_data[5] / 10;
+    //     bms_data.bms_ss = poweramp_inf.amp_data[22];
+    //     bms_data.bms_num = 13;
+    //     bms_data.bms_v1 = poweramp_inf.amp_data[9];
+    //     bms_data.bms_v2 = poweramp_inf.amp_data[10];
+    //     bms_data.bms_v3 = poweramp_inf.amp_data[11];
+    //     bms_data.bms_v4 = poweramp_inf.amp_data[12];
+    //     bms_data.bms_v5 = poweramp_inf.amp_data[13];
+    //     bms_data.bms_v6 = poweramp_inf.amp_data[14];
+    //     bms_data.bms_v7 = poweramp_inf.amp_data[15];
+    //     bms_data.bms_v8 = poweramp_inf.amp_data[16];
+    //     bms_data.bms_v9 = poweramp_inf.amp_data[17];
+    //     bms_data.bms_v10 = poweramp_inf.amp_data[18];
+    //     bms_data.bms_v11 = poweramp_inf.amp_data[19];
+    //     bms_data.bms_v12 = poweramp_inf.amp_data[20];
+    //     bms_data.bms_v13 = poweramp_inf.amp_data[21];
+    //     memcpy( bms_data.bms_ids, "poweramp", 8 );
+    //     bms_data.bms_ac = poweramp_inf.amp_data[1];
+    //     bms_data.serial_num = FAC_POWERAMP;
+
+    //     if(dev_bms1.regist.dev == false)
+    //         regist_dev_info(&dev_bms1,DEVICE_BMS1,false,NULL,0,NULL,0,NULL,0,"poweramp",9);
+    // }
     else if ( Herewin_Link.connect_status == COMP_NORMAL )
     {
         Dev.Bms_Link.connect_status = COMP_NORMAL;

Src/soft_can.c

@@ -59,9 +59,9 @@ void Can_decode_data_function(CAN_RxHeaderTypeDef Rxhead)
         break;
 
       //极目电池
-      case CAN_POWERAMP:
-        PowerAmpCanRecvHookFunction(RxHeader.StdId, RxData, RxHeader.DLC);
-        break;
+      // case CAN_POWERAMP:
+      //   PowerAmpCanRecvHookFunction(RxHeader.StdId, RxData, RxHeader.DLC);
+      //   break;
 
       //恩曌360雷达 新协议
       // case CAN_360MIMO_1ID ... CAN_360MIMO_2ID:
@@ -104,10 +104,6 @@ void Can_decode_data_function(CAN_RxHeaderTypeDef Rxhead)
       case GEELY_ENGINE_START_ID2 ... GEELY_ENGINE_END_ID2:
         EngGeelyCanRecvHookFunction(RxHeader.StdId, RxData, RxHeader.DLC);
         break;  
-      //莫之比前后避障雷达(多点)
-      case CAN_UAVRH_FOBS_ID1 ... CAN_UAVRH_BOBS_ID3: 
-        can_recv_mocib_obstacle(RxHeader.StdId, RxData, RxHeader.DLC);
-        break;
       case CAN_EZ_R_UPDATE:
         EZ_Radar_UpdateCanRecvHookFunction(RxHeader.StdId, RxData, RxHeader.DLC);
         break;

Src/soft_obstacle.c

@@ -592,99 +592,7 @@ void can_recv_mocib_B_obstacle(uint8_t *data)
     uavr12_info.Link.connect_status = COMP_NORMAL;
     uavr12_info.Link.recv_time = HAL_GetTick();
 }
-/**
-  * @file    can_recv_mocib_obstacle
-  * @brief   莫之比避障解析(多点)
-  * @param   none
-  * @details 
-  * @author  biao 
- **/
-void can_recv_mocib_obstacle(uint32_t cellCanID, uint8_t data[], uint8_t len)
-{
-    switch (cellCanID)
-    {
-    case CAN_UAVRH_FOBS_ID1:
-        memcpy(&F_radar[0], data, 8);
-        recv_comF_flag = recv_comF_flag | 1;
-        Dev.Radar.facid_F = FAC_MOCIB_RF;
-        Dev.Part_Fradar_Link.connect_status = COMP_NORMAL;
-        Dev.Part_Fradar_Link.recv_time = HAL_GetTick();
-        break;
-    case CAN_UAVRH_FOBS_ID2:
-        memcpy(&F_radar[1], data, 8);
-        recv_comF_flag = recv_comF_flag | 2;
-        break;
-    case CAN_UAVRH_FOBS_ID3:
-        memcpy(&F_radar[2], data, 8);
-        recv_comF_flag = recv_comF_flag | 4;
-        break;
-    case CAN_UAVRH_BOBS_ID1:
-        memcpy(&B_radar[0], data, 8);
-        recv_comB_flag = recv_comB_flag | 1;
-        Dev.Radar.facid_B= FAC_MOCIB_RB;
-        Dev.Part_Bradar_Link.connect_status = COMP_NORMAL;
-        Dev.Part_Bradar_Link.recv_time = HAL_GetTick();
-        break;
-    case CAN_UAVRH_BOBS_ID2:
-        memcpy(&B_radar[1], data, 8);
-        recv_comB_flag = recv_comB_flag | 2;
-        break;
-    case CAN_UAVRH_BOBS_ID3:
-        memcpy(&B_radar[2], data, 8);
-        recv_comB_flag = recv_comB_flag | 4;
-        break;
-    default:
-        break;
-    }
-
-    if(recv_comF_flag == 7)
-    {
-        recv_comF_flag = 0;      
-        mimomocib_buf_sort(&F_radar[0], 3);
-
-        for (uint8_t i = 0; i < 3; i++)
-        {
-            //X轴小于4M内数据
-            if (/*(abs(F_radar[i].Distance * 0.05f * 100 * sin(F_radar[i].Amuzith * 0.1f / RAD)) < 400) &&*/ F_radar[i].Distance > 0)
-            {
-                uavr11_info.distance_x  = F_radar[i].Distance * 0.05f * 100 * sin(F_radar[i].Amuzith * 0.1f / RAD);
-                uavr11_info.distance_y = F_radar[i].Distance * 0.05f * 100 * cos(F_radar[i].Amuzith * 0.1f / RAD);
-                break;
-            }
-            if(i == 2)
-            {
-                uavr11_info.distance_x = 0;
-                uavr11_info.distance_y = 0;
-            }
-        }
-        uavr11_info.Link.connect_status = COMP_NORMAL;
-        uavr11_info.Link.recv_time = HAL_GetTick();
-    }
-    
-    if(recv_comB_flag == 7)
-    {
-        recv_comB_flag = 0;
-        mimomocib_buf_sort(&B_radar[0], 3);
 
-        for (uint8_t i = 0; i < 3; i++)
-        {
-            //X轴小于4M内数据
-            if (/*(abs(B_radar[i].Distance * 0.05f * 100 * sin(B_radar[i].Amuzith * 0.1f / RAD)) < 400) &&*/ B_radar[i].Distance > 0)
-            {
-                uavr12_info.distance_x  = B_radar[i].Distance * 0.05f * 100 * sin(B_radar[i].Amuzith * 0.1f / RAD);
-                uavr12_info.distance_y = B_radar[i].Distance * 0.05f * 100 * cos(B_radar[i].Amuzith * 0.1f / RAD);
-                break; 
-            }
-            if(i == 2)
-            {
-                uavr12_info.distance_x = 0;
-                uavr12_info.distance_y = 0;
-            }
-        }
-        uavr12_info.Link.recv_time = HAL_GetTick();
-        uavr12_info.Link.connect_status = COMP_NORMAL;
-    }
-}
 uint32_t uavr20_ver_time = 0;
 
 uint32_t uavr20_sensi_time = 0;

Src/soft_p_2_c.c

@@ -510,6 +510,25 @@ void pmu_to_con_engine_data(void)
   * @details 
   * @author  Zhang Sir 
  **/
+/**
+ * 计算需要的包数
+ * @param total_points 总点数 M
+ * @param points_per_package 每包最大点数 n
+ * @return 需要的包数
+ */
+int calculate_packages(int total_points, int points_per_package) {
+    if (points_per_package <= 0) {
+        return 0; // 每包容量必须大于0
+    }
+    
+    if (total_points == 0) {
+        return 1; // 没有点不需要包
+    }
+    
+    // 使用整数除法向上取整的技巧：(a + b - 1) / b
+    return (total_points + points_per_package - 1) / points_per_package;
+}
+
 void pmu_to_con_DMradar_data(void)
 {
     uint8_t index = 0;
@@ -543,69 +562,67 @@ void pmu_to_con_DMradar_data(void)
 
         uart2_send_msg(msg_buf, index);
     }
+
+
+}
+
+void pmu_to_con_DM4DFradar_data(void)
+{
+    uint8_t index = 0;
+    int8_t pack_count = 0;//需要发送包数
+    int8_t remain_lastcount = 0; //余数
+    uint8_t send_bytes = 0; //需要发送字节
+    uint8_t send_pack = 1; //当前发送包数
+    int16_t remain_target_num = 0; //剩余发送目标点
+    int16_t complete_bytes_i= 0;
     
-    if(DM_4dstatus.connect_status == COMP_NORMAL && DM4d_to_fmu_flag == 1)
+    DM4d_recv_flag = 1;
+
+    remain_target_num = FMU_4D_info.target_num;
+    pack_count = calculate_packages(remain_target_num,48);
+    while (remain_target_num > 0)
     {
-        int8_t pack_count = 0;//需要发送包数
-        int8_t remain_lastcount = 0; //余数
-        uint8_t send_bytes = 0; //需要发送字节
-        uint8_t send_pack = 1; //当前发送包数
-        int16_t remain_target_num = 0; //剩余发送目标点
-        int16_t complete_bytes_i= 0;
-        
-        DM4d_recv_flag = 1;
+        index = 0;
+        msg_buf[index++] = 0xFE;
+        msg_buf[index++] = 0;
+        msg_buf[index++] = 0;
+        msg_buf[index++] = 0x00;
+        msg_buf[index++] = 0x00;
+        msg_buf[index++] = _MSGID_F4DRADAR;
 
-        remain_target_num = FMU_4D_info.target_num;
-        while (remain_target_num >= 0)
-        {
-            index = 0;
-            msg_buf[index++] = 0xFE;
-            msg_buf[index++] = 0;
-            msg_buf[index++] = 0;
-            msg_buf[index++] = 0x00;
-            msg_buf[index++] = 0x00;
-            msg_buf[index++] = _MSGID_F4DRADAR;
-
-            remain_lastcount = remain_target_num % 48;
-            if( remain_lastcount != 0)
-            {
-                pack_count = remain_target_num / 48 + 1;
-                if(pack_count == 1)
-                    send_bytes = remain_lastcount * 5;
-                else
-                    send_bytes = 48 * 5;
-            }
-            else
-            {
-                if(remain_target_num == 0)
-                    send_bytes = 0;
-                else
-                    send_bytes = 48 * 5;
-            }
+        remain_lastcount = remain_target_num % 48;
+        if(remain_target_num > 0 && remain_lastcount == 0)
+            remain_lastcount = 48;
 
-            msg_buf[index++] = send_pack; 
-            msg_buf[index++] = FMU_4D_info.target_num;
+        if(pack_count > send_pack)
+            send_bytes = 48 * 5;
+        else
+            send_bytes = remain_lastcount * 5;
 
-            memcpy(&msg_buf[index],&FMU_4D_info.buf[complete_bytes_i],send_bytes);
-            index += send_bytes;
-            complete_bytes_i += send_bytes;
+        msg_buf[index++] = send_pack; 
+        msg_buf[index++] = FMU_4D_info.target_num;
+        memcpy(&msg_buf[index],&DM_F4d.time_delay,2);
+        index += 2;
 
-            msg_buf[1] = index - 6;
+        memcpy(&msg_buf[index],&FMU_4D_info.buf[complete_bytes_i],send_bytes);
+        index += send_bytes;
+        complete_bytes_i += send_bytes;
 
-            crc = Get_Crc16(msg_buf, index);
-            msg_buf[index++] = crc;
-            msg_buf[index++] = (crc >> 8) & 0xff;
+        msg_buf[1] = index - 6;
 
-            uart2_send_msg(msg_buf, index);
+        crc = Get_Crc16(msg_buf, index);
+        msg_buf[index++] = crc;
+        msg_buf[index++] = (crc >> 8) & 0xff;
 
-            remain_target_num -= send_bytes / 5;
-            if(send_bytes < 48 * 5)
-                break;
-            send_pack++;
-        }
-        DM4d_recv_flag = 0;
-        DM4d_to_fmu_flag = 0;
+        uart2_send_msg(msg_buf, index);
+
+        remain_target_num -= send_bytes / 5;
+        if(send_bytes < 48 * 5)
+            break;
+        send_pack++;
     }
+    DM4d_recv_flag = 0;
+    
 }
 
 
@@ -1205,6 +1222,11 @@ void pmu_to_fcu()
             pmu_to_con_heart_data();
             pmu_heart_flag = false;
         }
+        if(F4d_send_flag == true)
+        {
+            pmu_to_con_DM4DFradar_data();
+            F4d_send_flag = false;
+        }
     }
 }
 
@@ -1671,7 +1693,7 @@ void uart_recv_con_msg()
                     weight_order.order_con3 =  msgidset.content3;
                     break;
                 case Cal_Seed_Back:
-                    weight_order.type = Weight_Bcak;
+                    weight_order.type = Seed_Bcak;
                     break;
                 default:
                     break;
@@ -1685,6 +1707,13 @@ void uart_recv_con_msg()
                 weight_order.type = Weight_Drug_Rate;
                 weight_order.order_con1 = msgidset.content1;
                 break;    
+            case MSGID_SET_WEIGHT_RESETK:
+                weight_order.type = Weight_Bcak;
+                break;
+            case MSGID_SET_WEIGHTFAC_CAL:
+                weight_order.type = Weight_Fac_cal;
+                weight_factory_cal_flag = true; //一直发送
+                break;
             case MSGID_SET_PMU_SERIAL:
                 set_pmu_serail = msgidset.content1 + ((msgidset.content2 << 16) & 0xffff0000);
                 if(serial.num == PMU_SERIAL || set_pmu_serail == PMU_SERIAL)

Src/soft_poweramp.c

@@ -7,509 +7,509 @@
 #include "soft_okcell.h"
 #include "soft_crc.h"
 
-//在数组中array查找是否存在字符串str
-//不能使用strstr函数，数组中存在'\0'的话会被结束
-int findStrInArray(uint8_t *array, int aLen, const char *str);
+// //锟斤拷锟斤拷锟斤拷锟斤拷array锟斤拷锟斤拷锟角凤拷锟斤拷锟斤拷址锟斤拷锟絪tr
+// //锟斤拷锟斤拷使锟斤拷strstr锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟叫达拷锟斤拷'\0'锟侥伙拷锟结被锟斤拷锟斤拷
+// int findStrInArray(uint8_t *array, int aLen, const char *str);
 
-short Poweramp_recv_index = 0;
-//获取到起始标志位
-bool Poweramp_get_s = false;
+// short Poweramp_recv_index = 0;
+// //锟斤拷取锟斤拷锟斤拷始锟斤拷志位
+// bool Poweramp_get_s = false;
 
-#define POWERAMP_MAXLEN 100
-unsigned char Poweramp_recv_buf[POWERAMP_MAXLEN] = {0};
+// #define POWERAMP_MAXLEN 100
+// unsigned char Poweramp_recv_buf[POWERAMP_MAXLEN] = {0};
 
-Connect_check Poweramp_Link;
+// Connect_check Poweramp_Link;
 
-_POWERAMP_INF poweramp_inf = {0};
-_POWERAMP_VER poweramp_ver = {0};
-_POWERAMP_SYS poweramp_sys = {0};
+// _POWERAMP_INF poweramp_inf = {0};
+// _POWERAMP_VER poweramp_ver = {0};
+// _POWERAMP_SYS poweramp_sys = {0};
 
 
-bool get_poweramp_handle_ack = false;
-bool get_poweramp_pair_data = false;
+// bool get_poweramp_handle_ack = false;
+// bool get_poweramp_pair_data = false;
 
-bool get_poweramp_ver = false;
-bool get_poweramp_sys = false;
+// bool get_poweramp_ver = false;
+// bool get_poweramp_sys = false;
 
-void PowerAmpCanRecvHookFunction(uint32_t cellCanID, uint8_t data[], uint8_t len)
-{
+// void PowerAmpCanRecvHookFunction(uint32_t cellCanID, uint8_t data[], uint8_t len)
+// {
 
-    Poweramp_Link.recv_time = HAL_GetTick();
+//     Poweramp_Link.recv_time = HAL_GetTick();
     
-    //找到开头，开始接收
-    //strncmp比较字符串，遇到'\0'会结束，所以不适合用字数组比较
-    if(memcmp(data,"{",1) == 0){
-        Poweramp_recv_index = 0;
-        Poweramp_get_s = true;
-    }
+//     //锟揭碉拷锟斤拷头锟斤拷锟斤拷始锟斤拷锟斤拷
+//     //strncmp锟饺斤拷锟街凤拷锟斤拷锟斤拷锟斤拷锟斤拷'\0'锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷圆锟斤拷屎锟斤拷锟斤拷锟斤拷锟斤拷锟饺斤拷
+//     if(memcmp(data,"{",1) == 0){
+//         Poweramp_recv_index = 0;
+//         Poweramp_get_s = true;
+//     }
     
-    //溢出检测
-    if(Poweramp_recv_index + len > POWERAMP_MAXLEN)
-    {
-        memset(Poweramp_recv_buf,0,Poweramp_recv_index);
-        Poweramp_recv_index = 0;
-        Poweramp_get_s = false;
-    }
+//     //锟斤拷锟斤拷锟斤拷
+//     if(Poweramp_recv_index + len > POWERAMP_MAXLEN)
+//     {
+//         memset(Poweramp_recv_buf,0,Poweramp_recv_index);
+//         Poweramp_recv_index = 0;
+//         Poweramp_get_s = false;
+//     }
     
-    //接收到起始标志后开始存数组
-    if(Poweramp_get_s == true){
-        //复制数据
-        memcpy(&Poweramp_recv_buf[Poweramp_recv_index], data, len);
-        Poweramp_recv_index += len;
-    }
+//     //锟斤拷锟秸碉拷锟斤拷始锟斤拷志锟斤拷始锟斤拷锟斤拷锟斤拷
+//     if(Poweramp_get_s == true){
+//         //锟斤拷锟斤拷锟斤拷锟斤拷
+//         memcpy(&Poweramp_recv_buf[Poweramp_recv_index], data, len);
+//         Poweramp_recv_index += len;
+//     }
 
     
-    //找到结尾，开始解析,不能用strstr
-    if(Poweramp_get_s == true && findStrInArray(Poweramp_recv_buf, Poweramp_recv_index, "}") != 0
-        && Poweramp_recv_buf[1] == Poweramp_recv_index - 4)
-    {
-        Poweramp_get_s = false;
+//     //锟揭碉拷锟斤拷尾锟斤拷锟斤拷始锟斤拷锟斤拷,锟斤拷锟斤拷锟斤拷strstr
+//     if(Poweramp_get_s == true && findStrInArray(Poweramp_recv_buf, Poweramp_recv_index, "}") != 0
+//         && Poweramp_recv_buf[1] == Poweramp_recv_index - 4)
+//     {
+//         Poweramp_get_s = false;
         
-        unsigned char powamplength = Poweramp_recv_buf[1];
-        unsigned char powampcommand = Poweramp_recv_buf[2];
+//         unsigned char powamplength = Poweramp_recv_buf[1];
+//         unsigned char powampcommand = Poweramp_recv_buf[2];
         
-        //字节数是否正确
-        if(powamplength == Poweramp_recv_index-4)
-        {
-            unsigned char powerampCheck = Poweramp_recv_buf[powamplength+2];
-            //校验通过,测试没通过
-            if((poweramp_CRC8(&Poweramp_recv_buf[1], powamplength+1, POWERAMP_CRC8_KEY)) == powerampCheck)
-            {
-                time_poweramp_lastrecv = HAL_GetTick();
+//         //锟街斤拷锟斤拷锟角凤拷锟斤拷确
+//         if(powamplength == Poweramp_recv_index-4)
+//         {
+//             unsigned char powerampCheck = Poweramp_recv_buf[powamplength+2];
+//             //校锟斤拷通锟斤拷,锟斤拷锟斤拷没通锟斤拷
+//             if((poweramp_CRC8(&Poweramp_recv_buf[1], powamplength+1, POWERAMP_CRC8_KEY)) == powerampCheck)
+//             {
+//                 time_poweramp_lastrecv = HAL_GetTick();
                 
-                switch(powampcommand)
-                {
-                    case 0x00:
-                        //握手索引，0-握手反馈，1-加密数据反馈
-                        switch(Poweramp_recv_buf[3])
-                        {
-                            case 0x00:
-                                if(Poweramp_recv_buf[4] == 0x00)
-                                    get_poweramp_handle_ack = true;
-                                break;
-                            case 0x01:
-                                get_poweramp_pair_data = true;
-                                break;
-                            default:
-                                break;
-                        }
-                        break;
-                    case 0x01:
-                        //前面握手阶段不能识别为连接状态，
-                        Poweramp_Link.connect_status = COMP_NORMAL;
+//                 switch(powampcommand)
+//                 {
+//                     case 0x00:
+//                         //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷0-锟斤拷锟街凤拷锟斤拷锟斤拷1-锟斤拷锟斤拷锟斤拷锟捷凤拷锟斤拷
+//                         switch(Poweramp_recv_buf[3])
+//                         {
+//                             case 0x00:
+//                                 if(Poweramp_recv_buf[4] == 0x00)
+//                                     get_poweramp_handle_ack = true;
+//                                 break;
+//                             case 0x01:
+//                                 get_poweramp_pair_data = true;
+//                                 break;
+//                             default:
+//                                 break;
+//                         }
+//                         break;
+//                     case 0x01:
+//                         //前锟斤拷锟斤拷锟街阶段诧拷锟斤拷识锟斤拷为锟斤拷锟斤拷状态锟斤拷
+//                         Poweramp_Link.connect_status = COMP_NORMAL;
                 
-                        //避免电池厂家私自增加协议造成的数组溢出
-                        if(powamplength-1 <= sizeof(_POWERAMP_INF))
-                        {
-                            memcpy((void *)&poweramp_inf, &Poweramp_recv_buf[3], powamplength-1);
-                        }
-                        break;
-                    case 0x20:
-                        get_poweramp_ver = true;
-                        //避免电池厂家私自增加协议造成的数组溢出
-                        if(powamplength-1 <= sizeof(_POWERAMP_VER))
-                        {
-                            memcpy((void *)&poweramp_ver, &Poweramp_recv_buf[3], powamplength-1);
-                        }
-                        break;
-                    case 0x21:
-                        get_poweramp_sys = true;
-                        //避免电池厂家私自增加协议造成的数组溢出
-                        if(powamplength-1 <= sizeof(_POWERAMP_SYS))
-                        {
-                            memcpy((void *)&poweramp_sys, &Poweramp_recv_buf[3], powamplength-1);
-                        }
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
+//                         //锟斤拷锟斤拷锟截筹拷锟斤拷私锟斤拷锟斤拷锟斤拷协锟斤拷锟斤拷傻锟斤拷锟斤拷锟斤拷锟斤拷
+//                         if(powamplength-1 <= sizeof(_POWERAMP_INF))
+//                         {
+//                             memcpy((void *)&poweramp_inf, &Poweramp_recv_buf[3], powamplength-1);
+//                         }
+//                         break;
+//                     case 0x20:
+//                         get_poweramp_ver = true;
+//                         //锟斤拷锟斤拷锟截筹拷锟斤拷私锟斤拷锟斤拷锟斤拷协锟斤拷锟斤拷傻锟斤拷锟斤拷锟斤拷锟斤拷
+//                         if(powamplength-1 <= sizeof(_POWERAMP_VER))
+//                         {
+//                             memcpy((void *)&poweramp_ver, &Poweramp_recv_buf[3], powamplength-1);
+//                         }
+//                         break;
+//                     case 0x21:
+//                         get_poweramp_sys = true;
+//                         //锟斤拷锟斤拷锟截筹拷锟斤拷私锟斤拷锟斤拷锟斤拷协锟斤拷锟斤拷傻锟斤拷锟斤拷锟斤拷锟斤拷
+//                         if(powamplength-1 <= sizeof(_POWERAMP_SYS))
+//                         {
+//                             memcpy((void *)&poweramp_sys, &Poweramp_recv_buf[3], powamplength-1);
+//                         }
+//                         break;
+//                     default:
+//                         break;
+//                 }
+//             }
+//         }
         
-        //清理buff
-        memset(Poweramp_recv_buf,0,Poweramp_recv_index);
+//         //锟斤拷锟斤拷buff
+//         memset(Poweramp_recv_buf,0,Poweramp_recv_index);
         
-        //包数完整重新计数
-        Poweramp_recv_index = 0;
-    }
-}
+//         //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟铰硷拷锟斤拷
+//         Poweramp_recv_index = 0;
+//     }
+// }
 
 
 
 
-/*
+// /*
 
-上电前10s持续发送握手数据给智能电池，用于启动供电
-*/
+// 锟较碉拷前10s锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟捷革拷锟斤拷锟杰碉拷兀锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+// */
 
-#define CAN_POWERAMP_SEND_ID    (0x188)
+// #define CAN_POWERAMP_SEND_ID    (0x188)
 
-#pragma pack(1)
-struct Poweramp_Handshake{
+// #pragma pack(1)
+// struct Poweramp_Handshake{
 
-    char amp_sof;
-    char amp_length;
-    char amp_command;
-    char amp_data[14];
-    char amp_crc;
-    char amp_eof;
-};
-#pragma pack()
-struct Poweramp_Handshake poweramp_handshake;
+//     char amp_sof;
+//     char amp_length;
+//     char amp_command;
+//     char amp_data[14];
+//     char amp_crc;
+//     char amp_eof;
+// };
+// #pragma pack()
+// struct Poweramp_Handshake poweramp_handshake;
 
 
 
-#pragma pack(1)
-struct Poweramp_Handpair{
+// #pragma pack(1)
+// struct Poweramp_Handpair{
 
-    char amp_sof;
-    char amp_length;
-    char amp_command;
-    char amp_data[2];
-    char amp_crc;
-    char amp_eof;
-};
-#pragma pack()
-struct Poweramp_Handpair poweramp_handpair;
+//     char amp_sof;
+//     char amp_length;
+//     char amp_command;
+//     char amp_data[2];
+//     char amp_crc;
+//     char amp_eof;
+// };
+// #pragma pack()
+// struct Poweramp_Handpair poweramp_handpair;
 
 
 
 
-#pragma pack(1)
-struct Poweramp_Uavheart{
+// #pragma pack(1)
+// struct Poweramp_Uavheart{
 
-    char amp_sof;
-    char amp_length;
-    char amp_command;
-    char amp_data[6];
-    char amp_crc;
-    char amp_eof;
-};
-#pragma pack()
-struct Poweramp_Uavheart poweramp_uavheart;
+//     char amp_sof;
+//     char amp_length;
+//     char amp_command;
+//     char amp_data[6];
+//     char amp_crc;
+//     char amp_eof;
+// };
+// #pragma pack()
+// struct Poweramp_Uavheart poweramp_uavheart;
 
 
 
-#pragma pack(1)
-struct Poweramp_Ver{
+// #pragma pack(1)
+// struct Poweramp_Ver{
 
-    char amp_sof;
-    char amp_length;
-    char amp_command;
-    char amp_crc;
-    char amp_eof;
-};
-#pragma pack()
-struct Poweramp_Ver poweramp_sver;
+//     char amp_sof;
+//     char amp_length;
+//     char amp_command;
+//     char amp_crc;
+//     char amp_eof;
+// };
+// #pragma pack()
+// struct Poweramp_Ver poweramp_sver;
 
 
 
-#pragma pack(1)
-struct Poweramp_Sys{
+// #pragma pack(1)
+// struct Poweramp_Sys{
 
-    char amp_sof;
-    char amp_length;
-    char amp_command;
-    char amp_crc;
-    char amp_eof;
-};
-#pragma pack()
-struct Poweramp_Sys poweramp_ssys;
+//     char amp_sof;
+//     char amp_length;
+//     char amp_command;
+//     char amp_crc;
+//     char amp_eof;
+// };
+// #pragma pack()
+// struct Poweramp_Sys poweramp_ssys;
 
 
 
-uint32_t time_poweramp_handle = 0;
-bool send_poweramp_handle = false;
+// uint32_t time_poweramp_handle = 0;
+// bool send_poweramp_handle = false;
 
-uint32_t time_poweramp_pairack = 0;
-bool send_poweramp_pairack = false;
+// uint32_t time_poweramp_pairack = 0;
+// bool send_poweramp_pairack = false;
 
-uint32_t time_poweramp_uavheart = 0;
-bool send_poweramp_uavheart = false;
+// uint32_t time_poweramp_uavheart = 0;
+// bool send_poweramp_uavheart = false;
 
-uint32_t time_poweramp_ver = 0;
-bool send_poweramp_ver = false;
+// uint32_t time_poweramp_ver = 0;
+// bool send_poweramp_ver = false;
 
-uint32_t time_poweramp_sys = 0;
-bool send_poweramp_sys = false;
+// uint32_t time_poweramp_sys = 0;
+// bool send_poweramp_sys = false;
 
-//上次发送时间，做延时间隔
-uint32_t time_poweramp_lastsend = 0;
+// //锟较次凤拷锟斤拷时锟戒，锟斤拷锟斤拷时锟斤拷锟�
+// uint32_t time_poweramp_lastsend = 0;
 
 
-//极目电池485半双工，收到信息后最好延迟100ms再发送下一次
-uint32_t time_poweramp_lastrecv = 0;
+// //锟斤拷目锟斤拷锟�485锟斤拷双锟斤拷锟斤拷锟秸碉拷锟斤拷息锟斤拷锟斤拷锟斤拷映锟�100ms锟劫凤拷锟斤拷锟斤拷一锟斤拷
+// uint32_t time_poweramp_lastrecv = 0;
 
-char send_poweramp_uavheart_counts = 0;
-//握手发送次数
-char send_poweramp_handle_counts = 0;
-char send_poweramp_pairack_counts = 0;
-char send_poweramp_ver_counts = 0;
-char send_poweramp_sys_counts = 0;
+// char send_poweramp_uavheart_counts = 0;
+// //锟斤拷锟街凤拷锟酵达拷锟斤拷
+// char send_poweramp_handle_counts = 0;
+// char send_poweramp_pairack_counts = 0;
+// char send_poweramp_ver_counts = 0;
+// char send_poweramp_sys_counts = 0;
 
 
-#define HANDLE_COUNTS_MAX 5
-#define PAIRACK_COUNTS_MAX 2
-#define UAVHEART_COUNTS_MAX 5
-#define VERSYS_COUNTS_MAX 5
+// #define HANDLE_COUNTS_MAX 5
+// #define PAIRACK_COUNTS_MAX 2
+// #define UAVHEART_COUNTS_MAX 5
+// #define VERSYS_COUNTS_MAX 5
 
 
-void send_msg_to_poweramp(void)
-{   
-    //程序不关闭发握手不反馈，电池热插拔无法正常握手，发心跳才回复实时信息
-    if((Poweramp_Link.connect_status == COMP_NOEXIST || Poweramp_Link.connect_status == COMP_RECON) && HAL_GetTick() > 5000)
-    {
-        //极目电池开机需要发送握手信息来启动通信。
-        if(send_poweramp_handle == false && 
-            get_poweramp_handle_ack == false && send_poweramp_handle_counts < HANDLE_COUNTS_MAX && 
-            HAL_GetTick() - time_poweramp_handle > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
-        {
-            send_poweramp_handle_counts++;
+// void send_msg_to_poweramp(void)
+// {   
+//     //锟斤拷锟津不关闭凤拷锟斤拷锟街诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷炔锟斤拷锟睫凤拷锟斤拷锟斤拷锟斤拷锟街ｏ拷锟斤拷锟斤拷锟斤拷锟脚回革拷实时锟斤拷息
+//     if((Poweramp_Link.connect_status == COMP_NOEXIST || Poweramp_Link.connect_status == COMP_RECON) && HAL_GetTick() > 5000)
+//     {
+//         //锟斤拷目锟斤拷乜锟斤拷锟斤拷锟揭�拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�拷锟斤拷锟斤拷锟酵�拷拧锟�
+//         if(send_poweramp_handle == false && 
+//             get_poweramp_handle_ack == false && send_poweramp_handle_counts < HANDLE_COUNTS_MAX && 
+//             HAL_GetTick() - time_poweramp_handle > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
+//         {
+//             send_poweramp_handle_counts++;
             
-            time_poweramp_handle = HAL_GetTick();
-            time_poweramp_pairack = HAL_GetTick();
-            time_poweramp_uavheart = HAL_GetTick();
+//             time_poweramp_handle = HAL_GetTick();
+//             time_poweramp_pairack = HAL_GetTick();
+//             time_poweramp_uavheart = HAL_GetTick();
 
-            poweramp_handshake.amp_sof = '{';
-            poweramp_handshake.amp_length = 15;
-            poweramp_handshake.amp_command = 0;
+//             poweramp_handshake.amp_sof = '{';
+//             poweramp_handshake.amp_length = 15;
+//             poweramp_handshake.amp_command = 0;
             
-            poweramp_handshake.amp_data[0] = 1;
-            poweramp_handshake.amp_data[1] = 0;
-            poweramp_handshake.amp_data[2] = 'E';
-            poweramp_handshake.amp_data[3] = 'A';
-            poweramp_handshake.amp_data[4] = 'V';
-            poweramp_handshake.amp_data[5] = 'i';
-            poweramp_handshake.amp_data[6] = 's';
-            poweramp_handshake.amp_data[7] = 'i';
-            poweramp_handshake.amp_data[8] = 'o';
-            poweramp_handshake.amp_data[9] = 'n';
-            poweramp_handshake.amp_data[10] = 't';
-            poweramp_handshake.amp_data[11] = 'e';
-            poweramp_handshake.amp_data[12] = 'c';
-            poweramp_handshake.amp_data[13] = 'h';
+//             poweramp_handshake.amp_data[0] = 1;
+//             poweramp_handshake.amp_data[1] = 0;
+//             poweramp_handshake.amp_data[2] = 'E';
+//             poweramp_handshake.amp_data[3] = 'A';
+//             poweramp_handshake.amp_data[4] = 'V';
+//             poweramp_handshake.amp_data[5] = 'i';
+//             poweramp_handshake.amp_data[6] = 's';
+//             poweramp_handshake.amp_data[7] = 'i';
+//             poweramp_handshake.amp_data[8] = 'o';
+//             poweramp_handshake.amp_data[9] = 'n';
+//             poweramp_handshake.amp_data[10] = 't';
+//             poweramp_handshake.amp_data[11] = 'e';
+//             poweramp_handshake.amp_data[12] = 'c';
+//             poweramp_handshake.amp_data[13] = 'h';
             
-            poweramp_handshake.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_handshake.amp_length,poweramp_handshake.amp_length+1,POWERAMP_CRC8_KEY);
-            
-            poweramp_handshake.amp_eof = '}';
-            
-            send_poweramp_handle = true;
-        }            
-        //发送握手后电池回复握手并回复加密数据，收到极目电池的加密数据后回复确认信息,然后开始通信（回复确认消息时没有反馈的所以发送两次）
-        else if(get_poweramp_pair_data == true && send_poweramp_pairack_counts < PAIRACK_COUNTS_MAX && 
-           send_poweramp_pairack == false && HAL_GetTick() - time_poweramp_pairack > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
-        {
-            send_poweramp_pairack_counts++;
+//             poweramp_handshake.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_handshake.amp_length,poweramp_handshake.amp_length+1,POWERAMP_CRC8_KEY);
+            
+//             poweramp_handshake.amp_eof = '}';
+            
+//             send_poweramp_handle = true;
+//         }            
+//         //锟斤拷锟斤拷锟斤拷锟街猴拷锟截回革拷锟斤拷锟街诧拷锟截革拷锟斤拷锟斤拷锟斤拷锟捷ｏ拷锟秸碉拷锟斤拷目锟斤拷氐募锟斤拷锟斤拷锟斤拷莺锟截革拷确锟斤拷锟斤拷息,然锟斤拷始通锟脚ｏ拷锟截革拷确锟斤拷锟斤拷息时没锟叫凤拷锟斤拷锟斤拷锟斤拷锟皆凤拷锟斤拷锟斤拷锟轿ｏ拷
+//         else if(get_poweramp_pair_data == true && send_poweramp_pairack_counts < PAIRACK_COUNTS_MAX && 
+//            send_poweramp_pairack == false && HAL_GetTick() - time_poweramp_pairack > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
+//         {
+//             send_poweramp_pairack_counts++;
             
-            time_poweramp_pairack = HAL_GetTick();
-            time_poweramp_uavheart = HAL_GetTick();
-            
-            poweramp_handpair.amp_sof = '{';
-            poweramp_handpair.amp_length = 3;
-            poweramp_handpair.amp_command = 0;
-            
-            poweramp_handpair.amp_data[0] = 1;
-            poweramp_handpair.amp_data[1] = 0;
-            
-            poweramp_handpair.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_handpair.amp_length, poweramp_handpair.amp_length+1, POWERAMP_CRC8_KEY);
-            
-            poweramp_handpair.amp_eof = '}';
+//             time_poweramp_pairack = HAL_GetTick();
+//             time_poweramp_uavheart = HAL_GetTick();
+            
+//             poweramp_handpair.amp_sof = '{';
+//             poweramp_handpair.amp_length = 3;
+//             poweramp_handpair.amp_command = 0;
+            
+//             poweramp_handpair.amp_data[0] = 1;
+//             poweramp_handpair.amp_data[1] = 0;
+            
+//             poweramp_handpair.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_handpair.amp_length, poweramp_handpair.amp_length+1, POWERAMP_CRC8_KEY);
+            
+//             poweramp_handpair.amp_eof = '}';
             
-            send_poweramp_pairack = true;
-        }
-        //握手完成以及握手失败后直接发心跳，避免热插拔无法握手而通信失败
-        else if(((get_poweramp_handle_ack == false && send_poweramp_handle_counts == HANDLE_COUNTS_MAX) || (get_poweramp_pair_data == true && send_poweramp_pairack_counts == PAIRACK_COUNTS_MAX)) && 
-            send_poweramp_uavheart_counts < UAVHEART_COUNTS_MAX &&  
-            send_poweramp_uavheart == false && HAL_GetTick() - time_poweramp_uavheart > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
-        {
-            send_poweramp_uavheart_counts++;
-            
-            time_poweramp_uavheart = HAL_GetTick();
-            time_poweramp_lastsend = HAL_GetTick();
-            
-            poweramp_uavheart.amp_sof = '{';
-            poweramp_uavheart.amp_length = 7;
-            poweramp_uavheart.amp_command = 0x25;
-            
-            poweramp_uavheart.amp_data[0] = 0x08;
-            
-            poweramp_uavheart.amp_data[1] = 0;
-            poweramp_uavheart.amp_data[2] = 1;
-            poweramp_uavheart.amp_data[3] = 2;
-            poweramp_uavheart.amp_data[4] = 3;
-            
-            poweramp_uavheart.amp_data[5] = 2;
-            
-            poweramp_uavheart.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_uavheart.amp_length, poweramp_uavheart.amp_length+1, POWERAMP_CRC8_KEY);
-            
-            poweramp_uavheart.amp_eof = '}';
-            
-            send_poweramp_uavheart = true;
-        }
-    }
-    //极目电池的需要发送心跳信息才会回复电池信息,在握手后的状态再次发握手电池不反馈，此时电池还不吐数据，比较难判断
-    else if(Poweramp_Link.connect_status == COMP_NORMAL || Poweramp_Link.connect_status == COMP_LOST)
-    {
-        //读取版本信息
-        if(get_poweramp_ver == false && send_poweramp_ver_counts < VERSYS_COUNTS_MAX && HAL_GetTick() - time_poweramp_ver > 500 && 
-           HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
-        {
-            send_poweramp_ver_counts++;
-            time_poweramp_ver = HAL_GetTick();
-            time_poweramp_sys = HAL_GetTick();
-            time_poweramp_lastsend = HAL_GetTick();
-            
-            poweramp_sver.amp_sof = '{';
-            poweramp_sver.amp_length = 1;
-            poweramp_sver.amp_command = 0x20;
-            
-            poweramp_sver.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_sver.amp_length, poweramp_sver.amp_length+1, POWERAMP_CRC8_KEY);
-            
-            poweramp_sver.amp_eof = '}';
-            
-            send_poweramp_ver = true;
-        }
-        //获取系统信息
-        else if((get_poweramp_ver == true || send_poweramp_ver_counts >= VERSYS_COUNTS_MAX) && get_poweramp_sys == false && 
-                send_poweramp_sys_counts < VERSYS_COUNTS_MAX && HAL_GetTick() - time_poweramp_sys > 500 && 
-                HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
-        {
-            send_poweramp_sys_counts++;
-            time_poweramp_sys = HAL_GetTick();
-            time_poweramp_lastsend = HAL_GetTick();
-            
-            poweramp_ssys.amp_sof = '{';
-            poweramp_ssys.amp_length = 1;
-            poweramp_ssys.amp_command = 0x21;
-            
-            poweramp_ssys.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_ssys.amp_length, poweramp_ssys.amp_length+1, POWERAMP_CRC8_KEY);
-            
-            poweramp_ssys.amp_eof = '}';
+//             send_poweramp_pairack = true;
+//         }
+//         //锟斤拷锟斤拷锟斤拷锟斤拷约锟斤拷锟斤拷锟绞э拷芎锟街憋拷臃锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷炔锟斤拷锟睫凤拷锟斤拷锟街讹拷通锟斤拷失锟斤拷
+//         else if(((get_poweramp_handle_ack == false && send_poweramp_handle_counts == HANDLE_COUNTS_MAX) || (get_poweramp_pair_data == true && send_poweramp_pairack_counts == PAIRACK_COUNTS_MAX)) && 
+//             send_poweramp_uavheart_counts < UAVHEART_COUNTS_MAX &&  
+//             send_poweramp_uavheart == false && HAL_GetTick() - time_poweramp_uavheart > 300 && HAL_GetTick() - time_poweramp_lastrecv > 100)
+//         {
+//             send_poweramp_uavheart_counts++;
+            
+//             time_poweramp_uavheart = HAL_GetTick();
+//             time_poweramp_lastsend = HAL_GetTick();
+            
+//             poweramp_uavheart.amp_sof = '{';
+//             poweramp_uavheart.amp_length = 7;
+//             poweramp_uavheart.amp_command = 0x25;
+            
+//             poweramp_uavheart.amp_data[0] = 0x08;
+            
+//             poweramp_uavheart.amp_data[1] = 0;
+//             poweramp_uavheart.amp_data[2] = 1;
+//             poweramp_uavheart.amp_data[3] = 2;
+//             poweramp_uavheart.amp_data[4] = 3;
+            
+//             poweramp_uavheart.amp_data[5] = 2;
+            
+//             poweramp_uavheart.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_uavheart.amp_length, poweramp_uavheart.amp_length+1, POWERAMP_CRC8_KEY);
+            
+//             poweramp_uavheart.amp_eof = '}';
+            
+//             send_poweramp_uavheart = true;
+//         }
+//     }
+//     //锟斤拷目锟斤拷氐锟斤拷锟揭�拷锟斤拷锟斤拷锟斤拷锟斤拷锟较�拷呕锟截革拷锟斤拷锟斤拷锟较�,锟斤拷锟斤拷锟街猴拷锟阶刺�拷俅畏锟斤拷锟斤拷值锟截诧拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷鼗锟斤拷锟斤拷锟斤拷锟斤拷荩锟斤拷冉锟斤拷锟斤拷卸锟�
+//     else if(Poweramp_Link.connect_status == COMP_NORMAL || Poweramp_Link.connect_status == COMP_LOST)
+//     {
+//         //锟斤拷取锟芥本锟斤拷息
+//         if(get_poweramp_ver == false && send_poweramp_ver_counts < VERSYS_COUNTS_MAX && HAL_GetTick() - time_poweramp_ver > 500 && 
+//            HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
+//         {
+//             send_poweramp_ver_counts++;
+//             time_poweramp_ver = HAL_GetTick();
+//             time_poweramp_sys = HAL_GetTick();
+//             time_poweramp_lastsend = HAL_GetTick();
+            
+//             poweramp_sver.amp_sof = '{';
+//             poweramp_sver.amp_length = 1;
+//             poweramp_sver.amp_command = 0x20;
+            
+//             poweramp_sver.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_sver.amp_length, poweramp_sver.amp_length+1, POWERAMP_CRC8_KEY);
+            
+//             poweramp_sver.amp_eof = '}';
+            
+//             send_poweramp_ver = true;
+//         }
+//         //锟斤拷取系统锟斤拷息
+//         else if((get_poweramp_ver == true || send_poweramp_ver_counts >= VERSYS_COUNTS_MAX) && get_poweramp_sys == false && 
+//                 send_poweramp_sys_counts < VERSYS_COUNTS_MAX && HAL_GetTick() - time_poweramp_sys > 500 && 
+//                 HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
+//         {
+//             send_poweramp_sys_counts++;
+//             time_poweramp_sys = HAL_GetTick();
+//             time_poweramp_lastsend = HAL_GetTick();
+            
+//             poweramp_ssys.amp_sof = '{';
+//             poweramp_ssys.amp_length = 1;
+//             poweramp_ssys.amp_command = 0x21;
+            
+//             poweramp_ssys.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_ssys.amp_length, poweramp_ssys.amp_length+1, POWERAMP_CRC8_KEY);
+            
+//             poweramp_ssys.amp_eof = '}';
             
-            send_poweramp_sys = true;
-        }
+//             send_poweramp_sys = true;
+//         }
         
-        //每一秒钟发送心跳包
-        if(send_poweramp_uavheart == false && HAL_GetTick() - time_poweramp_uavheart > 1000 && 
-           HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
-        {
-            time_poweramp_uavheart = HAL_GetTick();
-            time_poweramp_lastsend = HAL_GetTick();
-            
-            poweramp_uavheart.amp_sof = '{';
-            poweramp_uavheart.amp_length = 7;
-            poweramp_uavheart.amp_command = 0x25;
-            
-            poweramp_uavheart.amp_data[0] = 0x08;
-            
-            poweramp_uavheart.amp_data[1] = 0;
-            poweramp_uavheart.amp_data[2] = 1;
-            poweramp_uavheart.amp_data[3] = 2;
-            poweramp_uavheart.amp_data[4] = 3;
-            
-            poweramp_uavheart.amp_data[5] = 2;
-            
-            poweramp_uavheart.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_uavheart.amp_length, poweramp_uavheart.amp_length+1, POWERAMP_CRC8_KEY);
-            
-            poweramp_uavheart.amp_eof = '}';
-            
-            send_poweramp_uavheart = true;
-        }
-    }    
-
-    //发送心跳
-    if(send_poweramp_uavheart == true){
-        send_poweramp_uavheart = false;
-        can_send_msg_normalstd((unsigned char *)&poweramp_uavheart,sizeof(poweramp_uavheart),CAN_POWERAMP_SEND_ID);
-    }
-    //放在外部发送。不能放在条件内部，当条件不成立时会造成发送不完整。
-    else if(send_poweramp_handle == true){
-        send_poweramp_handle =false;
-        can_send_msg_normalstd((unsigned char *)&poweramp_handshake,sizeof(poweramp_handshake),CAN_POWERAMP_SEND_ID);
-    }
-    //放在外部发送。不能放在条件内部，当条件不成立时会造成发送不完整。
-    else if(send_poweramp_pairack == true){
-        send_poweramp_pairack = false;
-        can_send_msg_normalstd((unsigned char *)&poweramp_handpair,sizeof(poweramp_handpair),CAN_POWERAMP_SEND_ID);
-    }
-    //放在外部发送。不能放在条件内部，当条件不成立时会造成发送不完整。
-    else if(send_poweramp_ver == true){
-        send_poweramp_ver = false;
-        can_send_msg_normalstd((unsigned char *)&poweramp_sver,sizeof(poweramp_sver),CAN_POWERAMP_SEND_ID);
-    }
-    //放在外部发送。不能放在条件内部，当条件不成立时会造成发送不完整。
-    else if(send_poweramp_sys == true){
-        send_poweramp_sys = false;
-        can_send_msg_normalstd((unsigned char *)&poweramp_ssys,sizeof(poweramp_ssys),CAN_POWERAMP_SEND_ID);
-    }
-}
-
-
-
-
-/**
-  * @brief 智能电池连接监测
-  */
-unsigned int poweramp_reconnent_time = 0;
-
-void check_poweramp_link(void)
-{
-    static short poweramp_lostcounts = 0;
-
-    Poweramp_Link.error_time = HAL_GetTick() - Poweramp_Link.recv_time;
-
-    // 如果存在且超过5s没有收到正确雷达数据，则表示智能电池连接有问题
-    // 不是优先级非常高的，给予充足的时间来判断断开
-    // 便于区分是最开始就没连接还是连接后断开了。
-    if (Poweramp_Link.connect_status == COMP_NORMAL && (Poweramp_Link.error_time > 5000))
-    {
-        poweramp_lostcounts++;
-        if(poweramp_lostcounts >= 50)
-        {
-            poweramp_lostcounts = 50;
-            
-            Poweramp_Link.connect_status = COMP_LOST;
-            
-            //清空电池信息数据
-            //memset(&poweramp_inf, 0, sizeof(poweramp_inf));
-            
-            send_poweramp_uavheart_counts = 0;
-            send_poweramp_handle_counts = 0;
-            send_poweramp_pairack_counts = 0;
-            send_poweramp_ver_counts = 0;
-            send_poweramp_sys_counts = 0;
-            
-            //不重新回去版本及系统信息
-            //get_poweramp_sys = false;
-            //get_poweramp_ver = false;
-            get_poweramp_handle_ack = false;
-            get_poweramp_pair_data = false;
-        }
-    }
-    else if((Poweramp_Link.connect_status == COMP_NORMAL && (Poweramp_Link.error_time < 5000)))
-    {
-        poweramp_lostcounts = 0;
-    }
-    //超过200s，电池会休眠
-    else if((Poweramp_Link.connect_status == COMP_LOST && (Poweramp_Link.error_time > 200000)))
-    {
-        Poweramp_Link.connect_status = COMP_RECON;
-    }
-    //不存在或者重连状态是定时握手
-    else if((Poweramp_Link.connect_status == COMP_RECON || Poweramp_Link.connect_status == COMP_NOEXIST) && 
-            HAL_GetTick() - poweramp_reconnent_time > 10000)
-    {
-        poweramp_reconnent_time = HAL_GetTick();
+//         //每一锟斤拷锟接凤拷锟斤拷锟斤拷锟斤拷锟斤拷
+//         if(send_poweramp_uavheart == false && HAL_GetTick() - time_poweramp_uavheart > 1000 && 
+//            HAL_GetTick() - time_poweramp_lastrecv > 100 && HAL_GetTick() - time_poweramp_lastsend > 200)
+//         {
+//             time_poweramp_uavheart = HAL_GetTick();
+//             time_poweramp_lastsend = HAL_GetTick();
+            
+//             poweramp_uavheart.amp_sof = '{';
+//             poweramp_uavheart.amp_length = 7;
+//             poweramp_uavheart.amp_command = 0x25;
+            
+//             poweramp_uavheart.amp_data[0] = 0x08;
+            
+//             poweramp_uavheart.amp_data[1] = 0;
+//             poweramp_uavheart.amp_data[2] = 1;
+//             poweramp_uavheart.amp_data[3] = 2;
+//             poweramp_uavheart.amp_data[4] = 3;
+            
+//             poweramp_uavheart.amp_data[5] = 2;
+            
+//             poweramp_uavheart.amp_crc = poweramp_CRC8((uint8_t *)&poweramp_uavheart.amp_length, poweramp_uavheart.amp_length+1, POWERAMP_CRC8_KEY);
+            
+//             poweramp_uavheart.amp_eof = '}';
+            
+//             send_poweramp_uavheart = true;
+//         }
+//     }    
+
+//     //锟斤拷锟斤拷锟斤拷锟斤拷
+//     if(send_poweramp_uavheart == true){
+//         send_poweramp_uavheart = false;
+//         can_send_msg_normalstd((unsigned char *)&poweramp_uavheart,sizeof(poweramp_uavheart),CAN_POWERAMP_SEND_ID);
+//     }
+//     //锟斤拷锟斤拷锟解部锟斤拷锟酵★拷锟斤拷锟杰凤拷锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷煞锟斤拷筒锟斤拷锟斤拷锟斤拷锟�
+//     else if(send_poweramp_handle == true){
+//         send_poweramp_handle =false;
+//         can_send_msg_normalstd((unsigned char *)&poweramp_handshake,sizeof(poweramp_handshake),CAN_POWERAMP_SEND_ID);
+//     }
+//     //锟斤拷锟斤拷锟解部锟斤拷锟酵★拷锟斤拷锟杰凤拷锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷煞锟斤拷筒锟斤拷锟斤拷锟斤拷锟�
+//     else if(send_poweramp_pairack == true){
+//         send_poweramp_pairack = false;
+//         can_send_msg_normalstd((unsigned char *)&poweramp_handpair,sizeof(poweramp_handpair),CAN_POWERAMP_SEND_ID);
+//     }
+//     //锟斤拷锟斤拷锟解部锟斤拷锟酵★拷锟斤拷锟杰凤拷锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷煞锟斤拷筒锟斤拷锟斤拷锟斤拷锟�
+//     else if(send_poweramp_ver == true){
+//         send_poweramp_ver = false;
+//         can_send_msg_normalstd((unsigned char *)&poweramp_sver,sizeof(poweramp_sver),CAN_POWERAMP_SEND_ID);
+//     }
+//     //锟斤拷锟斤拷锟解部锟斤拷锟酵★拷锟斤拷锟杰凤拷锟斤拷锟斤拷锟斤拷锟节诧拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷煞锟斤拷筒锟斤拷锟斤拷锟斤拷锟�
+//     else if(send_poweramp_sys == true){
+//         send_poweramp_sys = false;
+//         can_send_msg_normalstd((unsigned char *)&poweramp_ssys,sizeof(poweramp_ssys),CAN_POWERAMP_SEND_ID);
+//     }
+// }
+
+
+
+
+// /**
+//   * @brief 锟斤拷锟杰碉拷锟斤拷锟斤拷蛹锟斤拷
+//   */
+// unsigned int poweramp_reconnent_time = 0;
+
+// void check_poweramp_link(void)
+// {
+//     static short poweramp_lostcounts = 0;
+
+//     Poweramp_Link.error_time = HAL_GetTick() - Poweramp_Link.recv_time;
+
+//     // 锟斤拷锟斤拷锟斤拷锟斤拷页锟斤拷锟�5s没锟斤拷锟秸碉拷锟斤拷确锟阶达拷锟斤拷锟捷ｏ拷锟斤拷锟绞撅拷锟斤拷艿锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+//     // 锟斤拷锟斤拷锟斤拷锟饺硷拷锟角筹拷锟竭的ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷锟斤拷锟叫断断匡拷
+//     // 锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟筋开始锟斤拷没锟斤拷锟接伙拷锟斤拷锟斤拷锟接猴拷峡锟斤拷恕锟�
+//     if (Poweramp_Link.connect_status == COMP_NORMAL && (Poweramp_Link.error_time > 5000))
+//     {
+//         poweramp_lostcounts++;
+//         if(poweramp_lostcounts >= 50)
+//         {
+//             poweramp_lostcounts = 50;
+            
+//             Poweramp_Link.connect_status = COMP_LOST;
+            
+//             //锟斤拷盏锟斤拷锟斤拷息锟斤拷锟斤拷
+//             //memset(&poweramp_inf, 0, sizeof(poweramp_inf));
+            
+//             send_poweramp_uavheart_counts = 0;
+//             send_poweramp_handle_counts = 0;
+//             send_poweramp_pairack_counts = 0;
+//             send_poweramp_ver_counts = 0;
+//             send_poweramp_sys_counts = 0;
+            
+//             //锟斤拷锟斤拷锟铰伙拷去锟芥本锟斤拷系统锟斤拷息
+//             //get_poweramp_sys = false;
+//             //get_poweramp_ver = false;
+//             get_poweramp_handle_ack = false;
+//             get_poweramp_pair_data = false;
+//         }
+//     }
+//     else if((Poweramp_Link.connect_status == COMP_NORMAL && (Poweramp_Link.error_time < 5000)))
+//     {
+//         poweramp_lostcounts = 0;
+//     }
+//     //锟斤拷锟斤拷200s锟斤拷锟斤拷鼗锟斤拷锟斤拷锟�
+//     else if((Poweramp_Link.connect_status == COMP_LOST && (Poweramp_Link.error_time > 200000)))
+//     {
+//         Poweramp_Link.connect_status = COMP_RECON;
+//     }
+//     //锟斤拷锟斤拷锟节伙拷锟斤拷锟斤拷锟斤拷状态锟角讹拷时锟斤拷锟斤拷
+//     else if((Poweramp_Link.connect_status == COMP_RECON || Poweramp_Link.connect_status == COMP_NOEXIST) && 
+//             HAL_GetTick() - poweramp_reconnent_time > 10000)
+//     {
+//         poweramp_reconnent_time = HAL_GetTick();
         
-        get_poweramp_handle_ack = false;
-        get_poweramp_pair_data = false;
+//         get_poweramp_handle_ack = false;
+//         get_poweramp_pair_data = false;
         
-        send_poweramp_uavheart_counts = 0;
-        //握手发送次数
-        send_poweramp_handle_counts = 0;
-        send_poweramp_pairack_counts = 0;
-    }
-}
+//         send_poweramp_uavheart_counts = 0;
+//         //锟斤拷锟街凤拷锟酵达拷锟斤拷
+//         send_poweramp_handle_counts = 0;
+//         send_poweramp_pairack_counts = 0;
+//     }
+// }
 
 
 

Src/soft_seed_device.c

@@ -19,7 +19,7 @@ seed seed_vkinfo;
 send_seed_device seed_dev;
 
 Weight_cal weight_order;
-
+bool weight_factory_cal_flag = false;
 /**
   * @file    Weight_recieved_hookfuction
   * @brief   VK协议称重传感器
@@ -58,7 +58,7 @@ void Weight_recieved_hookfuction(uint32_t CanID, uint8_t data[], uint8_t len)
             break;
         //恢复出厂设置ack
         case 0xf4:
-            pmu_set_ack(_MSGID_SET,25,Cal_Seed_Back,0);
+            pmu_set_ack(_MSGID_SET,MSGID_SET_WEIGHT_RESETK,0,0);
             break;
         case 0xf5:
             break;
@@ -127,7 +127,10 @@ void Weight_recieved_hookfuction(uint32_t CanID, uint8_t data[], uint8_t len)
         case 0xe6:
             pmu_set_ack(_MSGID_EFT_CON,Cal_Set_Doserate,0,0);
             weight_vkinfo.dose_rate = data[1] + (data[2] << 8);
-            break;            
+            break;     
+        case 0xe7:
+            pmu_set_ack(_MSGID_EFT_CON,MSGID_SET_WEIGHTFAC_CAL,0,0);
+            break;       
         default:
             break;
         }
@@ -355,7 +358,7 @@ void Set_Seed_Weight_Par(uint8_t device_type,char *factory)
                 case Weight_Reserve:
                     break;
                 //恢复出厂设置
-                case Weight_Bcak:
+                case Seed_Bcak:
                     can_buf[0] = 0xF4;
                     break;
                 //称重传感器K值
@@ -377,6 +380,12 @@ void Set_Seed_Weight_Par(uint8_t device_type,char *factory)
                     can_buf[1] = weight_order.order_con1 & 0xff;
                     can_buf[2] = (weight_order.order_con1 >> 8) & 0xff;
                     break;
+                case Weight_Bcak:
+                    can_buf[0] = 0xF4;
+                    break;
+                case Weight_Fac_cal:
+                    can_buf[0] = 0xE7;
+                    break;
                 default:
                     break;
                 }
@@ -449,7 +458,7 @@ void Set_Seed_Weight_Par(uint8_t device_type,char *factory)
                 case Weight_Reserve:
                     break;
                 //恢复出厂设置
-                case Weight_Bcak:
+                case Seed_Bcak:
                     can_buf[0] = 0xF4;
                     break;
                 //称重传感器K值 
@@ -497,7 +506,7 @@ void Set_Seed_Weight_Par(uint8_t device_type,char *factory)
                         break;
                     case Weight_Reserve:
                         break;
-                    case Weight_Bcak:
+                    case Seed_Bcak:
                         can_buf[0] = 0xF5;
                         break;
                     case Weight_Set_K:
@@ -639,7 +648,7 @@ void check_dev_type_link(void )
 
 void DM_obs_test( void )
 {
-    if((Dev.Part_Fradar_Link.connect_status != COMP_NORMAL) || (Dev.Part_radarF.facid != FAC_DM_RF))
+    if((Dev.Part_Fradar_Link.connect_status != COMP_NORMAL) || (Dev.Part_radarF.facid != FAC_DM_RF_4D))
         return;
 
     static uint32_t time_50hz = 0;

Src/soft_terrain.c

@@ -106,7 +106,6 @@ uint8_t DM4d_recv_flag = 0;
 Connect_check DM_status;
 Connect_check DM_4dstatus;
 uavr_terrain DM_ter_info; 
-uint8_t DM4d_to_fmu_flag = 0;
 void DM_terrain_recieved_hookfuction(uint32_t cellCanID,uint8_t data[], uint8_t len)
 {
     if(cellCanID == 0x901300) //多点协议
@@ -221,6 +220,8 @@ int16_t F_4DRadar[3][3]={0};  // X Y Z
 DM_4dFRADAR DM_F4d;
 int dm_4df_i = 0;
 DM_4DRADAR FMU_4D_info;
+bool F4d_send_flag = false;
+
 void DM_Fobs_recieved_hookfuction(uint32_t cellCanID,uint8_t data[], uint8_t len)
 {
     if (cellCanID == 0XA01300) // 多点协议
@@ -280,7 +281,7 @@ void DM_Fobs_recieved_hookfuction(uint32_t cellCanID,uint8_t data[], uint8_t len
     {
         DM_4dstatus.connect_status = COMP_NORMAL;
         DM_status.recv_time = HAL_GetTick();
-        Dev.Part_radarF.facid = FAC_DM_RF;
+        Dev.Part_radarF.facid = FAC_DM_RF_4D;
 
         DM_F4d.byte7.frame_flag = data[7];
 
@@ -313,8 +314,9 @@ void DM_Fobs_recieved_hookfuction(uint32_t cellCanID,uint8_t data[], uint8_t len
             {
                 FMU_4D_info.target_num = DM_F4d.target_num;
                 memcpy(&FMU_4D_info.buf, &DM_F4d.RawData, DM_F4d.target_num * 5);
-                DM4d_to_fmu_flag = 1;
+                F4d_send_flag = true;
             }
+            
         }
         else
         {
@@ -335,7 +337,7 @@ void DM_Fobs_recieved_hookfuction(uint32_t cellCanID,uint8_t data[], uint8_t len
 
         Dev.Part_Fradar_Link.recv_time = HAL_GetTick();
         Dev.Part_Fradar_Link.connect_status = COMP_NORMAL;
-        Dev.Part_radarF.facid = FAC_DM_RF;
+        Dev.Part_radarF.facid = FAC_DM_RF_4D;
     }
     else if(cellCanID == 0XA01303)
     {

Src/soft_timer.c

@@ -67,7 +67,7 @@ void timer_function()
     {
         vol_flag = true;
         mimo360_radar_flag = true;
-        DM_radar_flag = true;
+        
         devinfo_time.weight = true;
         devinfo_time.L_pump1 = true;
         devinfo_time.L_pump2 = true;
@@ -80,7 +80,7 @@ void timer_function()
     }
     if ( Check_Timer_Ready(&time_50hz,_50_HZ_) )
     {
-        
+        DM_radar_flag = true;
     }
     if(Check_Timer_Ready(&time_100hz,_100_HZ_))
     {

Src/soft_uart.c

@@ -420,8 +420,7 @@ void check_uart_data(rkfifo_t *fifo)
 				//莫之比雷达升级
 				else if(((vk_data.group_id == GROUP_ID_F_UPDATE && uavr11_info.Link.connect_status != COMP_NOEXIST) ||
 					 	(vk_data.group_id == GROUP_ID_B_UPDATE && uavr12_info.Link.connect_status != COMP_NOEXIST) ||
-					    (vk_data.group_id == GROUP_ID_T_UPDATE && uavr56_info.Link.connect_status != COMP_NOEXIST)) && 
-						(Dev.Part_Bradar_Link.connect_status == COMP_NOEXIST && Dev.Part_Fradar_Link.connect_status == COMP_NOEXIST))
+					    (vk_data.group_id == GROUP_ID_T_UPDATE && uavr56_info.Link.connect_status != COMP_NOEXIST)))
 				{	
 					if(uart_info.use_update_buf_flag == false)
 					{

Src/soft_update.c

@@ -90,7 +90,7 @@ void Vk_Update_Device_Protocol(void)
             {
                 memcpy(&can_buf[5],"MZB",3);
             }
-            else if(Dev.Part_radarF.facid == FAC_DM_RF)
+            else if(Dev.Part_radarF.facid == FAC_DM_RF_4D)
             {
                 memcpy(&can_buf[5],"D4F",3);
             }
@@ -173,7 +173,7 @@ void Vk_Update_Device_Protocol(void)
         uart_info.vk_dev_update_flag = false;
         if(dev_id == UPDATE_OBS_F)
         {
-            if(Dev.Radar.facid_F == FAC_DM_RF)
+            if(Dev.Radar.facid_F == FAC_DM_RF || Dev.Part_radarF.facid == FAC_DM_RF_4D)
                 DM_f_info.get_radar_ver_flag = false;
             memset(&dev_obsf,0,sizeof(dev_version_content));
         }
@@ -231,7 +231,7 @@ void Update_Dev_Bootversion_Function(uint8_t data[])
             {
                 Dev.Part_Fradar_Link.recv_time = HAL_GetTick();
                 Dev.Part_Fradar_Link.connect_status = COMP_NORMAL;
-                Dev.Part_radarF.facid = FAC_DM_RF;
+                Dev.Part_radarF.facid = FAC_DM_RF_4D;
             }
             else
             {
@@ -301,7 +301,7 @@ void Update_Dev_Bootversion_Function(uint8_t data[])
             {
                 Dev.Part_Tradar_Link.recv_time = HAL_GetTick();
                 Dev.Part_Tradar_Link.connect_status = COMP_NORMAL;
-                Dev.Part_radarT.facid = FAC_DM_RF;
+                Dev.Part_radarT.facid = FAC_DM_RF_4D;
             }
             else
             {