数据提交

2.离线系拉低主地/备地为离线地
3.修复仲裁IP配置错误

TSCP/Makefile

@@ -109,12 +109,15 @@ INCLUDES += -I ./src/APP \
             -I ./src/MSCP/SFM \
             -I ./src/MSCP/PFM \
             -I ./src/MSCP_CFG \
-            
+            -I ./src/MSCP/Area\
+            -I ./src/MSCP/OFM\
+            -I ./src/MSCP/Arb
 #LIBS += -L/path/to/my/lib/$(PLATFORM)/usr/lib -lmylib
 #LIBS += -L../mylib/$(OUTPUT_DIR) -lmylib
 
 #Compiler flags for build profiles
-CCFLAGS_release += -O0
+CCFLAGS_release += -O2
+#CCFLAGS_release += -g -O2 
 CCFLAGS_debug += -g -O0 -fno-builtin
 CCFLAGS_coverage += -g -O0 -ftest-coverage -fprofile-arcs -nopipe -Wc,-auxbase-strip,$@
 LDFLAGS_coverage += -ftest-coverage -fprofile-arcs

TSCP/src/APP/APP_API.c

@@ -4,7 +4,6 @@
 */
 #include "APP_API.h"
 #include "MSCP_APP_API.h"
-#include "MSCP_APP_Interface.h"
 #include "2oo2InterfaceDataManage.h"
 #include "2oo2DataTransferManage.h"
 #include "commonQueryStruDef.h"
@@ -227,7 +226,7 @@ void APP_API_Data_Init()
 	UINT8 funcRetVal = 0U;
 	funcRetVal = dquGetFSVersion(DataPath, szFSFILEVersionFS);
 
-#if (kPLATFORM==kVXWORKS)
+#if 0//(kPLATFORM==kVXWORKS)
 	/*文件配置*/
 	STRU_APP_CFG_T AppCfgInterface = {
 			.FS_NAME = "RCI.FS",			/**< FS文件名称 */
@@ -239,16 +238,16 @@ void APP_API_Data_Init()
 			.M_InnetSafe_Enable = 0x55,	/**< 内网安全通信功能开关 */
 			.M_InnetRaw_Enable = 0xAA,	/**< 内网透传通信功能开关 */
 			.M_OutnetSafe_Enable = 0x55,/**< 外网安全通信功能开关 */
-			.M_OutnetRaw_Enable = 0xAA,	/**< 外网透传通信功能开关 */
+			.M_OutnetRaw_Enable = 0x55,	/**< 外网透传通信功能开关 */
 			.M_CpuUsageGet_Enable = 0xAA,/**< 获取cpu使用率功能开关 */
 			.M_RemoteUpdate_Enable = 0x55,/**< 远程部署内网安全通信功能开关 */
 			.ID_Maintenance = DEVICE_TYPE_AIM,
 			.Start_Path = "/emmc1",	/**< 程序启动路径 */
 			.reboot_replycount = 10,	/**< 重启确认报文回复次数 */
-			.M_AutoReboot_Count = 3,	/**< 自动重启次数 */
+			.M_AutoReboot_Count = 0,	/**< 自动重启次数 */
 			.M_AutoClear_Days = 1,		/**< 连续运行多久清空宕机次数的天数 */
 			.CPU[0].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
-			.CPU[0].IP_2x2 = "192.168.1.62",       /**< 2x2通信IP */
+//			.CPU[0].IP_2x2 = "192.168.1.62",       /**< 2x2通信IP */
 			.CPU[0].IP_Out = "192.168.1.62",       /**< 外网通信IP */
 			.CPU[0].IP_Maintain = "192.168.146.101",  /**< 维护通信IP */
 			/*适用透传通道-选配*/
@@ -258,7 +257,7 @@ void APP_API_Data_Init()
 			.CPU[0].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
 			.CPU[1].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
-			.CPU[1].IP_2x2 = "192.168.2.62",       /**< 2x2通信IP */
+//			.CPU[1].IP_2x2 = "192.168.2.62",       /**< 2x2通信IP */
 			.CPU[1].IP_Out = "192.168.2.62",       /**< 外网通信IP */
 			.CPU[1].IP_Maintain = "192.168.18.102",  /**< 维护通信IP */
 			/*适用透传通道-选配*/
@@ -268,7 +267,7 @@ void APP_API_Data_Init()
 			.CPU[1].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
 			.CPU[2].IP_2oo2 = "192.168.0.21",     /**< 2oo2通信IP */
-			.CPU[2].IP_2x2 = "192.168.1.64",       /**< 2x2通信IP */
+//			.CPU[2].IP_2x2 = "192.168.1.64",       /**< 2x2通信IP */
 			.CPU[2].IP_Out = "192.168.1.64",       /**< 外网通信IP */
 			.CPU[2].IP_Maintain = "192.168.146.103",  /**< 维护通信IP */
 			/*适用透传通道-选配*/
@@ -278,7 +277,7 @@ void APP_API_Data_Init()
 			.CPU[2].Logger_PortCiphertext = 55002, 	 /**< 暗文日志记录发送端口 */
 
 			.CPU[3].IP_2oo2 = "192.168.0.22",     /**< 2oo2通信IP */
-			.CPU[3].IP_2x2 = "192.168.2.64",       /**< 2x2通信IP */
+//			.CPU[3].IP_2x2 = "192.168.2.64",       /**< 2x2通信IP */
 			.CPU[3].IP_Out = "192.168.2.64",       /**< 外网通信IP */
 			.CPU[3].IP_Maintain = "192.168.18.104",  /**< 维护通信IP */
 			/*适用透传通道-选配*/
@@ -339,6 +338,204 @@ void APP_API_Data_Init()
 			.INNET_COM_CFG[0].Port_Safe_P = 55003,  /**< 紫网安全端口 */
 	};
 	MSCP_Set_APP_ConfigData(&AppCfgInterface);
+#else
+	    /*↑↑用户初始化代码↑↑*/
+	    /*↓↓基本数据初始化配置示例↓↓*/
+	    STRU_APP_CFG_T AppCfgInterface = {
+	            .FS_NAME = "RCI.FS",         /**< FS文件名称 */
+	            .APP_NAME = "RCOCI",           /**< 应用文件名称 */
+	            .CYC_TIME = 300,            /**< 系统周期（ms） */
+	            .app_num = 1,               /**< app任务数1-4 */
+	            .M_2oo2_Enable = 0x55,      /**< 2oo2功能开关，开0x55，关0xAA */
+	            .M_2x2_Enable = 0x55,       /**< 2x2功能开关，开0x55，关0xAA*/
+	            .M_4x2_Enable = 0x55,       /**< 4x2功能开关，开0x55，关0xAA*/
+				.M_Arb_Enable = 0x55,		/**< 仲裁功能开关 */
+	            .M_2x2_Com_Cfg = 0x00,      /**< 2x2通信功能配置，串口0x00，网卡0x01*/
+	            .M_InnetSafe_Enable = 0x55, /**< 内网安全通信功能开关，开0x55，关0xAA */
+	            .M_InnetRaw_Enable = 0x55,  /**< 内网透传通信功能开关，开0x55，关0xAA */
+	            .M_OutnetSafe_Enable = 0x55,/**< 外网安全通信功能开关，开0x55，关0xAA */
+	            .M_OutnetRaw_Enable = 0x55, /**< 外网透传通信功能开关，开0x55，关0xAA */
+	            .M_CpuUsageGet_Enable = 0xAA,/**< 外网透传通信功能开关，开0x55，关0xAA */
+	            .M_RemoteUpdate_Enable = 0xAA,/**< 远程部署内网安全通信功能开关，开0x55，关0xAA */
+	            .ID_Maintenance = 0xF800,   /**< 设置维护终端ID */
+	            .Start_Path = "./emmc1",    /**< 程序启动路径 */
+	            .reboot_replycount = 10,    /**< 重启确认报文回复次数 */
+	            .M_AutoReboot_Count = 0,    /**< 自动重启次数 */
+	            .M_AutoClear_Days = 1,      /**< 连续运行多久清空宕机次数的天数 */
+	            /*CPU1-1 IP配置*/
+	            .CPU[0].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[0].IP_4x2 = "192.168.1.62",       /**< 2x2通信IP */
+	            .CPU[0].IP_Out = "192.168.1.62",       /**< 外网通信IP */
+	            .CPU[0].IP_Maintain = "192.168.146.101",  /**< 维护通信IP */
+	            .CPU[0].IP_Area = "10.3.1.61",      /**< 4x2通信IP */
+	            .CPU[0].IP_Sync_Time_A = "192.168.1.62",   /**< 时间同步网络A网IP */
+	            .CPU[0].IP_Sync_Time_B = "10.3.1.61",      /**< 时间同步网络B网IP */
+	            /*CPU1-1适用透传通道-选配*/
+	            .CPU[0].IP_Com = "192.168.1.62",       /**< 通用通信IP */
+	            .CPU[0].IP_Com_Extend = "192.168.1.62",/**< 通用通信扩展IP */
+	            .CPU[0].Logger_PortBase = 55011,         /**< 明文日志记录发送端口 */
+	            .CPU[0].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU1-2 IP配置*/
+	            .CPU[1].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[1].IP_4x2 = "192.168.2.62",       /**< 2x2通信IP */
+	            .CPU[1].IP_Out = "192.168.2.62",       /**< 外网通信IP */
+	            .CPU[1].IP_Maintain = "192.168.18.102",  /**< 维护通信IP */
+	            .CPU[1].IP_Area = "10.3.1.63",      /**< 4x2通信IP */
+	            .CPU[1].IP_Sync_Time_A = "192.168.2.62",   /**< 时间同步网络A网IP */
+	            .CPU[1].IP_Sync_Time_B = "10.3.1.63",      /**< 时间同步网络B网IP */
+	            /*CPU1-2适用透传通道-选配*/
+	            .CPU[1].IP_Com = "192.168.2.62",       /**< 通用通信IP */
+	            .CPU[1].IP_Com_Extend = "192.168.2.62",/**< 通用通信扩展IP */
+	            .CPU[1].Logger_PortBase = 55012,         /**< 明文日志记录发送端口 */
+	            .CPU[1].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU2-1 IP配置*/
+	            .CPU[2].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[2].IP_4x2 = "192.168.1.64",       /**< 2x2通信IP */
+	            .CPU[2].IP_Out = "192.168.1.64",       /**< 外网通信IP */
+	            .CPU[2].IP_Maintain = "192.168.146.103",  /**< 维护通信IP */
+	            .CPU[2].IP_Area = "10.4.1.62",      /**< 4x2通信IP */
+	            .CPU[2].IP_Sync_Time_A = "192.168.1.64",   /**< 时间同步网络A网IP */
+	            .CPU[2].IP_Sync_Time_B = "10.4.1.62",      /**< 时间同步网络B网IP */
+	            /*CPU2-1适用透传通道-选配*/
+	            .CPU[2].IP_Com = "192.168.1.64",       /**< 通用通信IP */
+	            .CPU[2].IP_Com_Extend = "192.168.1.64",/**< 通用通信扩展IP */
+	            .CPU[2].Logger_PortBase = 55021,         /**< 明文日志记录发送端口 */
+	            .CPU[2].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU2-2 IP配置*/
+	            .CPU[3].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[3].IP_4x2 = "192.168.2.64",       /**< 2x2通信IP */
+	            .CPU[3].IP_Out = "192.168.2.64",       /**< 外网通信IP */
+	            .CPU[3].IP_Maintain = "192.168.18.104",  /**< 维护通信IP */
+	            .CPU[3].IP_Area = "10.4.1.64",      /**< 4x2通信IP */
+	            .CPU[3].IP_Sync_Time_A = "192.168.2.64",   /**< 时间同步网络A网IP */
+	            .CPU[3].IP_Sync_Time_B = "10.4.1.64",      /**< 时间同步网络B网IP */
+	            /*CPU2-2适用透传通道-选配*/
+	            .CPU[3].IP_Com = "192.168.2.64",       /**< 通用通信IP */
+	            .CPU[3].IP_Com_Extend = "192.168.2.64",/**< 通用通信扩展IP */
+	            .CPU[3].Logger_PortBase = 55022,         /**< 明文日志记录发送端口 */
+	            .CPU[3].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU3-1 IP配置*/
+	            .CPU[4].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[4].IP_4x2 = "192.168.1.162",       /**< 2x2通信IP */
+	            .CPU[4].IP_Out = "192.168.1.162",       /**< 外网通信IP */
+	            .CPU[4].IP_Maintain = "192.168.146.201",  /**< 维护通信IP */
+	            .CPU[4].IP_Area = "10.3.1.161",      /**< 4x2通信IP */
+	            .CPU[4].IP_Sync_Time_A = "192.168.1.162",   /**< 时间同步网络A网IP */
+	            .CPU[4].IP_Sync_Time_B = "10.3.1.161",      /**< 时间同步网络B网IP */
+	            /*CPU3-1适用透传通道-选配*/
+	            .CPU[4].IP_Com = "192.168.1.162",       /**< 通用通信IP */
+	            .CPU[4].IP_Com_Extend = "192.168.1.162",/**< 通用通信扩展IP */
+	            .CPU[4].Logger_PortBase = 55031,         /**< 明文日志记录发送端口 */
+	            .CPU[4].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU3-2 IP配置*/
+	            .CPU[5].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[5].IP_4x2 = "192.168.2.162",       /**< 2x2通信IP */
+	            .CPU[5].IP_Out = "192.168.2.162",       /**< 外网通信IP */
+	            .CPU[5].IP_Maintain = "192.168.18.202",  /**< 维护通信IP */
+	            .CPU[5].IP_Area = "10.3.1.163",      /**< 4x2通信IP */
+	            .CPU[5].IP_Sync_Time_A = "192.168.2.162",   /**< 时间同步网络A网IP */
+	            .CPU[5].IP_Sync_Time_B = "10.3.1.163",      /**< 时间同步网络B网IP */
+	            /*CPU3-2适用透传通道-选配*/
+	            .CPU[5].IP_Com = "192.168.2.162",       /**< 通用通信IP */
+	            .CPU[5].IP_Com_Extend = "192.168.2.162",/**< 通用通信扩展IP */
+	            .CPU[5].Logger_PortBase = 55032,         /**< 明文日志记录发送端口 */
+	            .CPU[5].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU4-1 IP配置*/
+	            .CPU[6].IP_2oo2 = "192.168.0.11",     /**< 2oo2通信IP */
+	            .CPU[6].IP_4x2 = "192.168.1.164",       /**< 2x2通信IP */
+	            .CPU[6].IP_Out = "192.168.1.164",       /**< 外网通信IP */
+	            .CPU[6].IP_Maintain = "192.168.146.203",  /**< 维护通信IP */
+				.CPU[6].IP_Area = "10.4.1.162",      /**< 4x2通信IP */
+	            .CPU[6].IP_Sync_Time_A = "192.168.1.164",   /**< 时间同步网络A网IP */
+	            .CPU[6].IP_Sync_Time_B = "10.4.1.162",      /**< 时间同步网络B网IP */
+	            /*CPU4-1适用透传通道-选配*/
+	            .CPU[6].IP_Com = "192.168.1.164",       /**< 通用通信IP */
+	            .CPU[6].IP_Com_Extend = "192.168.1.164",/**< 通用通信扩展IP */
+	            .CPU[6].Logger_PortBase = 55041,         /**< 明文日志记录发送端口 */
+	            .CPU[6].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*CPU4-2 IP配置*/
+	            .CPU[7].IP_2oo2 = "192.168.0.12",     /**< 2oo2通信IP */
+	            .CPU[7].IP_4x2 = "192.168.2.164",       /**< 2x2通信IP */
+	            .CPU[7].IP_Out = "192.168.2.164",       /**< 外网通信IP */
+	            .CPU[7].IP_Maintain = "192.168.18.204",  /**< 维护通信IP */
+	            .CPU[7].IP_Area = "10.4.1.164",      /**< 4x2通信IP */
+	            .CPU[7].IP_Sync_Time_A = "192.168.2.164",   /**< 时间同步网络A网IP */
+	            .CPU[7].IP_Sync_Time_B = "10.4.1.164",      /**< 时间同步网络B网IP */
+	            /*CPU4-2适用透传通道-选配*/
+	            .CPU[7].IP_Com = "192.168.2.164",       /**< 通用通信IP */
+	            .CPU[7].IP_Com_Extend = "192.168.2.164",/**< 通用通信扩展IP */
+	            .CPU[7].Logger_PortBase = 55042,         /**< 明文日志记录发送端口 */
+	            .CPU[7].Logger_PortCiphertext = 55002,   /**< 暗文日志记录发送端口 */
+	            /*组播地址配置*/
+	            .IP_Area_G_Multicast = "239.0.0.10",       /**< 组播通信IP */
+				.IP_Area_P_Multicast = "239.0.0.20",       /**< 组播通信IP */
+				.Multicast_Flag = 1u,                      /**< 单播：0  组播：1 */
+	            /*通用端口配置，平台固定通信端口禁止使用:51001、51002、51003、52001、52002、52003*/
+	            .Port_Outnet_Safe = 54001,       /**< 外网安全通信端口 */
+	            .Port_Innet_Safe = 53001,        /**< 内网安全通信端口 */
+	            .Port_Outnet_Raw = 54002,        /**< 外网透明传输端口 */
+	            .Port_Remote_Update = 50000,     /**< 远程部署通信端口 */
+	            /*透传配置-选配*/
+	            .Port_Innet_Raw_Num = 1,     /**< 内网透传端口数量0-9 */
+	            .Port_Innet_Raw_Extend_Num = 1, /**< 内网透传扩展端口数量0-9 */
+	            /*透传通道-Number 1根据数量两个通道的数量，按序号累加以此类推（0-17）*/
+	            .Innet_Raw_Parameter[0].Port_Innet_Raw = 3956,           /**< 内网透明传输端口 */
+	            .Innet_Raw_Parameter[0].Port_Type_Enable = RAW_COM_UDP,  /**< 内网透明UDP传输模式 */
+	            .Innet_Raw_Parameter[0].Server_DevId = 0,                /**< 服务端设备类型和id */
+	            .Innet_Raw_Parameter[0].TIME_STAMP_ENABLE = 0XAA,        /**< 2取2乘时间戳使能开关 */
+	            .Innet_Raw_Parameter[0].INNET_2oo2_RAW = 0X55,           /**< 透传通道2取开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[0].INNET_2x2_RAW = 0XAA,            /**< 透传通道2乘开关，开0x55，关0xAA */
+	            .Innet_Raw_Parameter[0].IP_InnetRaw_maddr = "224.0.0.31",/**< 内网透传的组播IP */
+	            /*扩展通道-Number 1 根据数量两个通道的数量，按序号累加以此类推（0-17）*/
+	            .Innet_Raw_Parameter[1].Port_Innet_Raw = 3957,           /**< 内网透明传输端口 */
+	            .Innet_Raw_Parameter[1].Port_Type_Enable = RAW_COM_BROADCAST, /**< 内网透明广播传输模式 */
+	            .Innet_Raw_Parameter[1].Server_DevId = 0,                /**< 服务端设备类型和id */
+	            .Innet_Raw_Parameter[1].TIME_STAMP_ENABLE = 0XAA,        /**< 2取2乘时间戳使能开关 */
+	            .Innet_Raw_Parameter[1].INNET_2oo2_RAW = 0X55,           /**< 透传通道2取开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[1].INNET_2x2_RAW = 0XAA,            /**< 透传通道2乘开关，开0x55，关0xAA  */
+	            .Innet_Raw_Parameter[1].IP_InnetRaw_maddr = "224.0.0.32",/**< 内网透传的组播IP */
+	            /*外网通信配置-红网*/
+	            .OutNetRed.CC_G_IP_A = "192.168.1.60",     /**< 通控的内网IP */
+	            .OutNetRed.CC_P_IP_A = "192.168.2.60",     /**< 通控的内网IP */
+	            .OutNetRed.CC_G_IP_B = "192.168.1.160",     /**< 通控的内网IP */
+	            .OutNetRed.CC_P_IP_B = "192.168.2.160",     /**< 通控的内网IP */
+	            .OutNetRed.EXTEND_G_IP_A = "192.168.1.70", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_P_IP_A = "192.168.2.70", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_G_IP_B = "192.168.1.71", /**< 扩展板卡的内网IP */
+	            .OutNetRed.EXTEND_P_IP_B = "192.168.2.71", /**< 扩展板卡的内网IP */
+	            .OutNetRed.OutnetSafe_Port = 54001,      /**< 外网安全通信端口 */
+	            .OutNetRed.OutnetRaw_Port = 54002,       /**< 外网透传通信端口 */
+	            /*外网通信配置-蓝网*/
+	            .OutNetBlue.CC_G_IP_A = "192.168.1.61",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_P_IP_A = "192.168.2.61",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_G_IP_B = "192.168.1.161",     /**< 通控的内网IP */
+	            .OutNetBlue.CC_P_IP_B = "192.168.2.161",     /**< 通控的内网IP */
+	            .OutNetBlue.EXTEND_G_IP_A = "192.168.1.170", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_P_IP_A = "192.168.2.170", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_G_IP_B = "192.168.1.171", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.EXTEND_P_IP_B = "192.168.2.171", /**< 扩展板卡的内网IP */
+	            .OutNetBlue.OutnetSafe_Port = 54001,      /**< 外网安全通信端口 */
+	            .OutNetBlue.OutnetRaw_Port = 54002,       /**< 外网透传通信端口 */
+	            /*日志记录目标设备IP配置*/
+	            .Logger_G_IP_A = "192.168.146.100",         /**< A地绿网日志记录IP */
+	            .Logger_P_IP_A = "192.168.18.100",          /**< A地紫网日志记录IP */
+				.Logger_G_IP_B = "192.168.146.200",			/**< B地绿网日志记录IP */
+				.Logger_P_IP_B = "192.168.18.200",			/**< B地绿网日志记录IP */
+	            /*内网通信设备注册最大支持0-255，注意：IP配置方式比较特别，与前面配置区分*/
+	            .INNET_COM_NUM = 1,                     /**< 内网通信设备数量0-255 */
+	            .INNET_COM_CFG[0].InnetID = 0xF800,     /**< 内网通信ID */
+	            .INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("172.25.0.100"),/**< 绿网IP*/
+	            .INNET_COM_CFG[0].Port_Raw_G = 55003,   /**< 绿网透传端口 */
+	            .INNET_COM_CFG[0].Port_Safe_G = 55004,  /**< 绿网安全端口 */
+	            .INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("172.17.0.100"),/**< 紫网IP */
+	            .INNET_COM_CFG[0].Port_Raw_P = 55003,   /**< 紫网透传端口 */
+	            .INNET_COM_CFG[0].Port_Safe_P = 55004,  /**< 紫网安全端口 */
+				/*第三方仲裁通信配置*/
+				.Arb_CFG.IP_Arb_G = "10.3.1.200",
+				.Arb_CFG.IP_Arb_P = "10.4.1.200",
+	    };
+	    /*调用参数设置初始化接口*/
+	    MSCP_Set_APP_ConfigData(&AppCfgInterface);
 #endif
 
 	/*组FS版本号*/
@@ -350,10 +547,10 @@ void APP_API_Data_Init()
 
 	/*组软件版本号*/
 	ii = 0U;
-	appVersBuffer[ii++] = VER_INTE_PROJECT;
-	appVersBuffer[ii++] = VER_INTE_PRODUCT >> 2U;
-	appVersBuffer[ii++] = (VER_INTE_PRODUCT << 6U) + (VER_INTE_EXE & (UINT8)0x3F);
-	appVersBuffer[ii++] = VER_INTE_TIME;
+	appVersBuffer[ii++] = VER_SOFT_PRODUCT;
+	appVersBuffer[ii++] = VER_SOFT_MODUAL_APP >> 2U;
+	appVersBuffer[ii++] = (VER_SOFT_MODUAL_APP << 6U) + (VER_SOFT_MIANVERSION & (UINT8)0x3F);
+	appVersBuffer[ii++] = VER_SOFT_SUBVERSION;
 	/*设置平台调用获取外网信息函数*/
 	MSCP_SetSrcId(SetOutNetPara);
 	/*设置内网参数*/
@@ -367,16 +564,16 @@ void APP_API_Data_Init()
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc(void)
 {
-	ENUM_CM_RETURN retVal = ENUM_CM_NULL;
+	ENUM_CM_RETURN retVal = ENUM_CM_FALSE;
 	CM_UINT64 startCycTick = 0u;
 	CM_UINT64 endCycTick = 0u;
 
@@ -394,8 +591,9 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 	endCycTick = MSCP_GetTick();
 	debug_infor_printf("app proc end at %llu us,used %d us\n", endCycTick, (CM_INT32)((endCycTick - startCycTick) / 1000));
 
-	gFollowDataLen = GetCiAppData(gFollowData);
-	MSCP_SetFollowData(gFollowData, gFollowDataLen);
+	//gFollowDataLen = GetCiAppData(gFollowData);
+	memset(gFollowData,0x02,1024*500);
+	MSCP_SetFollowData(gFollowData, 1024*500);
 
 	return retVal;
 }
@@ -406,11 +604,11 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc2(void)
@@ -426,11 +624,11 @@ ENUM_CM_RETURN APP_API_MainFunc2(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc3(void)
@@ -453,11 +651,11 @@ ENUM_CM_RETURN APP_API_MainFunc4(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+* 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
 * 本函数不执行；
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
 * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-* 当本系热备状态为：ENUM_2x2_MASTER，时
+* 当本系热备状态为：ENUM_4x2_MASTER，时
 * 本函数被周期执行，并且所有输出信息被真实输出。
 */
 ENUM_CM_RETURN APP_API_MainFunc5(void)
@@ -495,7 +693,7 @@ ENUM_CM_RETURN APP_API_InputFunc(void)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败（平台立即宕机）
 * @details
-* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_SLAVE，且收到了邻系正确的跟随数据时
+* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_SLAVE，且收到了邻系正确的跟随数据时
 * 本函数将在APP_API_MainFunc()之前执行；
 * 否则，本函数不执行。
 * 应用跟随数据的最大长度不得超过1024*1000字节
@@ -506,7 +704,8 @@ ENUM_CM_RETURN APP_API_FollowUp(IN const CM_UINT8 Data[MSCP_FOLLOW_BUFF_SIZE], I
 	ENUM_CM_RETURN retVal = ENUM_CM_FALSE;
 	UINT8 setRtn = 0u;
 
-	setRtn = SetCiAppData(Data, Len);
+	//setRtn = SetCiAppData(Data, Len);
+	setRtn = 1;
 	if (1u == setRtn)
 	{
 		retVal = ENUM_CM_TRUE;
@@ -560,10 +759,6 @@ ENUM_CM_RECCUSEB Is_Send_ExtendBoard(IN const CM_UINT16 dstDevTypeId)
 		{
 			retVal = ENUM_CM_SEB;
 		}
-		else if (CI_SYSTEM_TYPE_ITE == devType)
-		{
-			retVal = ENUM_CM_CCSEB;
-		}
 		else
 		{
 			retVal = ENUM_CM_CC;
@@ -625,8 +820,8 @@ void SetOutNetPara(UINT8* pRxBuf, UINT32 dwLen, ENUM_OUTNET_CHN_T chOutNetType,
 			tempLen = *pCurLen;
 			if ((TRANSMIT_OBJECT_SUM_MAX * TRANSMIT_OBJECT_DEVICE_SUM_MAX) > (tempLen + objLen))
 			{
-				CommonMemCpy((void*)&pOutBuf[tempLen], objLen * sizeof(UINT16), \
-					(const void*)gTransmitObjTypeId, objLen * sizeof(UINT16));
+				CommonMemCpy(&pOutBuf[tempLen], objLen * sizeof(UINT16), \
+					gTransmitObjTypeId, objLen * sizeof(UINT16));
 				*pCurLen = tempLen + objLen;
 				debug_infor_printf("outnet in type len :%d", chOutNetType, objLen);
 				debug_out_array(0xAA, gTransmitObjTypeId, objLen * sizeof(UINT16));

TSCP/src/APP/APP_API.h

@@ -40,11 +40,11 @@ extern "C" {
     * - ENUM_CM_TRUE 成功
     * - ENUM_CM_FALSE 失败（平台立即宕机）
     * @note
-    * 当本系热备状态为：ENUM_2x2_SHUTDOWN，时
+    * 当本系热备状态为：ENUM_4x2_SHUTDOWN，时
     * 本函数不执行；
-    * 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_PRE_MASTER，ENUM_2x2_SLAVE，时
+    * 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_PRE_MASTER，ENUM_4x2_SLAVE，时
     * 本函数被周期执行，但 ENUM_MSG_OUTNET_SAFE 报文不会真实输出；
-    * 当本系热备状态为：ENUM_2x2_MASTER，时
+    * 当本系热备状态为：ENUM_4x2_MASTER，时
     * 本函数被周期执行，并且所有输出信息被真实输出。
     */
     ENUM_CM_RETURN APP_API_MainFunc(void);

TSCP/src/DRV/imx8_drv_gpio.c

@@ -25,7 +25,7 @@ int imx8_gpio_init(void)
 	gpio_base_0 = mmap_device_io((size_t)0x10, (uint64_t)IMX_GPIO0_BASE);
 	if(gpio_base_0 == MAP_DEVICE_FAILED)
 	{
-		perror("Can't map device base 0 I/O");
+		//perror("Can't map device base 0 I/O");
 		ret = -1;
 	}
 	else

TSCP/src/DRV/imx8_drv_i2c.c

@@ -27,7 +27,7 @@ int16_t temperature_read(int fd, uint8_t reg, uint8_t slave_addr)
 
 	if((devctl(fd, DCMD_I2C_SENDRECV, (void *)&read, sizeof(read),(int *)NULL)) > 0)
 	{
-		perror("Failed to read to temp ! ");
+		//perror("Failed to read to temp ! ");
 	}
 	else
 	{

TSCP/src/MSCP/Arb/Arb.h

@@ -0,0 +1,142 @@
+#ifndef AREA_H_
+#define AREA_H_
+
+#include "Area.h"
+#include "Area_Net.h"
+#include "Arb_Net.h"
+#include "SFM_2x2.h"
+
+#define AREA_BASIC_CFG_PTR       (&g_area_with_arb_cfg.Basic_CFG)       /**< 仲裁模式下使用，区域模块的基本配置（ID） */
+#define AREA_THREAD_CTRL_PTR     (&g_area_with_arb_cfg.Thread_CTRL)     /**< 仲裁模式下使用，区域模块的线程控制（信号量） */
+#define AREA_STATE_CTRL_PTR      (&g_area_with_arb_cfg.State_CTRL)      /**< 仲裁模式下使用，区域模块的状态控制 */
+#define AREA_COMM_STATUS_PTR     (&g_area_with_arb_cfg.Comm_Status)     /**< 仲裁模式下使用，区域模块的通信状态记录 */
+#define AREA_ARB_CTRL_PTR        (&g_area_with_arb_cfg.Arb_CTRL)        /**< 仲裁模式下使用，区域模块的仲裁控制 */
+#define AREA_FLAGS_CTRL_PTR      (&g_area_with_arb_cfg.Flag_CTRL)       /**< 仲裁模式下使用，区域模块使用的标志位 */
+
+/*仲裁模式下，区域间所有通信相关配置*/
+typedef struct 
+{
+    STR_Area_IP_Cfg COMM_CFG_AREA;
+    STRU_ARB_COMM_CFG_T COMM_CFG_ARB;
+    STRU_AREA_MULTICAST_COMM_T COMM_CFG_AREA_MULTICAST;
+}STRU_AREA_WITH_ARB_COMM_CFG_T;
+
+/*仲裁模式下，区域间通信状态记录(接收到的SN号/周期号) */
+typedef struct
+{
+    CM_UINT32 LocalSN;   /**< 本地周期号 */
+    CM_UINT32 PatnerSN;  /**< 接收的对系周期号 */
+    CM_BOOL Patner_RcvFlag; /**< 本周期是否接收到了对系的数据包，CM_TRUE接收到，CM_FALSE未接收到 */
+    CM_UINT32 Area_A_SN; /**< 接收的另一地A系周期号 */
+    CM_BOOL Area_A_RcvFlag; /**< 本周期是否接收到了另一地A系的数据包，CM_TRUE接收到，CM_FALSE未接收到 */
+    CM_UINT32 Area_B_SN; /**< 接收的另一地B系周期号 */
+    CM_BOOL Area_B_RcvFlag; /**< 本周期是否接收到了另一地B系的数据包，CM_TRUE接收到，CM_FALSE未接收到 */
+}STRU_AREA_WITH_ARB_COMM_STATUS_T;
+
+/*仲裁模式下，记录仲裁的回复*/
+typedef struct
+{
+    CM_UINT8 Arb_Send_Flag; /**< 仲裁请求发送标志位，记录本周期是否发送了仲裁请求 */
+    CM_UINT8 Arb_Ack; /**< 记录仲裁的回复 */
+}STRU_AREA_WITH_ARB_REQ_T;
+
+/*仲裁模式下，记录各种同步标志（时间/数据同步） */
+typedef struct
+{
+    CM_BOOL Time_Sync_Flag;     /**< 时间同步标志 */
+    CM_BOOL Sync_Health_Flag;   /**< 同步健康标志 */
+    CM_BOOL Sync_Fail_Flag;     /**< 同步失败标志 CM_FALSE-同步失败 CM_TRUE-同步成功*/
+}STRU_AREA_WITH_ARB_FLAGS_T;
+
+/*仲裁模式下，区域线程控制*/
+typedef struct
+{
+    CM_SEM_T m_AreaWithArbStart;
+    CM_SEM_T m_AreaWithArbStop;
+}STRU_AREA_WITH_ARB_THREAD_CTRL_T;
+
+/*仲裁模式下，区域间所有的基础配置（ID）*/
+typedef struct 
+{
+    CM_UINT8 BoardID;  /**< 板卡ID 插箱id */
+    CM_UINT8 Cpuid;  /**< cpu id */
+    CM_UINT8 Partner_BoardID;  /**< 对系板卡id */
+    CM_UINT8 Partner_Area_A_BoardID;  /**< 对系id */
+    CM_UINT8 Partner_Area_B_BoardID;  /**< 对系id */
+    CM_UINT16 OutnetID; /**<外网ID */
+    CM_UINT8 AreaID; /**< 区域ID，A地或B地 */
+}STRU_AREA_WITH_ARB_BASIC_CFG_T;
+
+/*仲裁模式下，记录2乘状态结构体*/
+typedef struct
+{
+    ENUM_2x2_STATE_T LocalState;   /**< 本系2x状态*/
+    ENUM_2x2_STATE_T PartnerState; /**< 对系2x状态 */
+    ENUM_2x2_STATE_T Area_A_State; /**< 另一地A系2x状态 */
+    ENUM_2x2_STATE_T Area_B_State; /**< 另一地B系2x状态 */
+}STRU_AREA_2X_STATE_T;
+
+/*仲裁模式下，区域状态控制结构体*/
+typedef struct
+{
+    STR_Area_State StateArea;     /**< 区域状态汇总 */
+    STRU_AREA_2X_STATE_T State2x; /**< 2x状态汇总 */
+}STRU_AREA_WITH_ARB_STATE_CTRL_T;
+
+/**仲裁模式下，区域模块的所有配置与控制汇总 */
+typedef struct
+{
+    STRU_AREA_WITH_ARB_BASIC_CFG_T Basic_CFG;  /**< 基础配置(ID) */
+    STRU_AREA_WITH_ARB_COMM_CFG_T COMM_CFG; /**< 通信配置 */
+    STRU_AREA_WITH_ARB_THREAD_CTRL_T Thread_CTRL;   /**< 线程状态控制 */
+    STRU_AREA_WITH_ARB_STATE_CTRL_T State_CTRL; /**<状态控制  */
+    STRU_AREA_WITH_ARB_COMM_STATUS_T Comm_Status; /**<通信状态记录 */
+    STRU_AREA_WITH_ARB_REQ_T Arb_CTRL; /**< 与仲裁的交互 */
+    STRU_AREA_WITH_ARB_FLAGS_T Flag_CTRL; /**< 记录各种标志 */
+}STRU_AREA_WITH_ARB_CFG_ALL_T;
+
+extern STRU_AREA_WITH_ARB_CFG_ALL_T g_area_with_arb_cfg;
+
+
+/**
+ * @brief 区域初始化，包含第三方仲裁的初始化(仲裁模式使用)
+ */
+void Area_With_Arb_Init(void);
+/**
+ * @brief 区域开始
+ * 
+ */
+void Area_Arb_Start();
+/**
+ * @brief 等待区域开始
+ * 
+ */
+void Area_Arb_Wait_Start();
+
+/**
+ * @brief 区域停止
+ * 
+ */
+void Area_Arb_Stop();
+/**
+ * @brief 等待区域停止
+ * 
+ */
+void Area_Arb_Wait_Stop();
+/**
+ * @brief 根据ID设置接收状态
+ */
+void AreaArb_SetCommStatus_byID(CM_UINT8 ID, CM_UINT32 sn, CM_BOOL rcv_flag);
+/**
+ * @brief 根据ID获取接收状态
+ */
+void AreaArb_GetCommStatus_byID(CM_UINT8 ID, CM_UINT32* SN, CM_BOOL* rcv_flag);
+/**
+ * @brief 获取另一地A系的ID
+ */
+CM_UINT8 AreaArb_GetArea_A_ID(void);
+/**
+ * @brief 获取另一地B系的ID
+ */
+CM_UINT8 AreaArb_GetArea_B_ID(void);
+#endif

TSCP/src/MSCP/Arb/Arb_Net.c

@@ -0,0 +1,609 @@
+#include "CM_Types.h"
+#include "CM_Memory.h"
+#include "CM_Socket.h"
+#include "CM_UDP.h"
+#include "CM_Convert.h"
+#include "PFM_Cfg.h"
+#include "CM_Sem.h"
+#include "CM_MultiThread.h"
+#include "CM_MultiThread_Priority.h"
+#include "CM_Time.h"
+#include "DFM_Time.h"
+#include "MSCP_Define.h"
+#include "PFM_LOG.h"
+#include "MSCP_APP_Interface.h"
+#include "CM_MQ.h"
+#include "stdarg.h"
+#include "Arb.h"
+#include "Arb_Net.h"
+#include "Area_2oo2.h"
+
+/*===========↓↓↓↓↓宏定义↓↓↓↓↓=============*/
+#define ARB_MSG_NUM_MAX     20      /*仲裁应答接收队列最大数量*/
+#define ARB_RAW_MSG_SIZE   1400     /*仲裁应答接收数据包最大长度*/
+
+/*区域单播通信配置指针*/
+#define AREA_UNI_COMM_CFG_PTR           (&g_area_with_arb_cfg.COMM_CFG.COMM_CFG_AREA)
+/*仲裁通信配置指针*/
+#define ARB_COMM_CFG_PTR            (&g_area_with_arb_cfg.COMM_CFG.COMM_CFG_ARB)
+/*区域组播通信配置指针*/
+#define AREA_MULTI_COMM_CFG_PTR     (&g_area_with_arb_cfg.COMM_CFG.COMM_CFG_AREA_MULTICAST)
+/*===========↑↑↑↑↑宏定义↑↑↑↑↑=============*/
+
+
+/*===========↓↓↓↓↓全局变量声明&定义↓↓↓↓↓=============*/
+
+/*===========↑↑↑↑↑全局变量声明&定义↑↑↑↑↑=============*/
+
+
+/*===========↓↓↓↓↓静态函数声明↓↓↓↓↓=============*/
+
+/**
+ * @brief 仲裁接收线程
+ * @param STRU_ARB_IP_CFG_T-仲裁相关通信配置
+ */
+static CM_THREAD_FUNC_T t_Area_Arb_UdpRecvThread(IN STRU_ARB_COMM_CFG_T *arg);
+/**
+ * @brief 区域间组播接收线程
+ * @param 
+ */
+static CM_THREAD_FUNC_T t_Area_Multi_UdpRecvThread(IN STRU_AREA_MULTICAST_COMM_T *arg);
+/**
+ * @brief 区域间但播接收线程
+ */
+static CM_THREAD_FUNC_T t_Area_Uni_UdpRecvThread(IN STR_Area_IP_Cfg* arg);
+/**
+ * @brief 从配置中读取仲裁模式下使用的IP
+ */
+static void s_Area_Arb_IP_Init(void);
+
+/*===========↑↑↑↑↑静态函数声明↑↑↑↑↑=============*/
+
+
+/*===========↓↓↓↓↓函数定义↓↓↓↓↓↓=============*/
+/**
+ * @brief 仲裁模式下的网络初始化
+ */
+void Area_Arb_Net_Init(void)
+{
+    CM_UINT32 val = 0u;
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    CM_BOOL rtCheck = CM_FALSE;
+    /**2取初始化 */
+    Area_2oo2_Init();
+    /*获取IP配置*/
+    s_Area_Arb_IP_Init();
+    /** 初始化区域网络通信 */
+    rt = CM_UDP_Socket_Create(&(AREA_UNI_COMM_CFG_PTR->Socket), CM_FALSE, (CM_UINT32)inet_addr(AREA_UNI_COMM_CFG_PTR->IP_Local), AREA_UNI_COMM_CFG_PTR->port, 0u, (CM_UINT8)1);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    val = (CM_INT32)NET_UDP_BUF_MAX;
+    (void)setsockopt(AREA_UNI_COMM_CFG_PTR->Socket, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
+
+
+    rt = CM_MQ_Init(&(AREA_UNI_COMM_CFG_PTR->MsgQ), (CM_UINT16)Area_MSG_NUM_MAX, (CM_UINT16)Area_RAW_MSG_SIZE);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_Area_Uni_UdpRecvThread, "Area_Rx", 0, CM_TASK_PRIORITY_73, (CM_Thread_Arg_Struct_T*)AREA_UNI_COMM_CFG_PTR);
+	CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_24);
+
+    /*初始化仲裁通信*/
+    rt = CM_UDP_Socket_Create(&(ARB_COMM_CFG_PTR->Socket), CM_FALSE, (CM_UINT32)inet_addr(ARB_COMM_CFG_PTR->IP_Local), ARB_COMM_CFG_PTR->port, 0u, (CM_UINT8)1);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    val = (CM_INT32)NET_UDP_BUF_MAX;
+    (void)setsockopt(ARB_COMM_CFG_PTR->Socket, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
+
+
+    rt = CM_MQ_Init(&(ARB_COMM_CFG_PTR->MsgQ), (CM_UINT16)ARB_MSG_NUM_MAX, (CM_UINT16)ARB_RAW_MSG_SIZE);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_Area_Arb_UdpRecvThread, "Arb_Rx", 0, CM_TASK_PRIORITY_73, (CM_Thread_Arg_Struct_T*)ARB_COMM_CFG_PTR);
+	CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_24);
+
+    /** 初始化区域组播网络通信 */
+    rt = CM_UDP_Socket_Create(&(AREA_MULTI_COMM_CFG_PTR->Socket_Send), CM_FALSE, (CM_UINT32)inet_addr(AREA_MULTI_COMM_CFG_PTR->IP_Local), AREA_MULTI_COMM_CFG_PTR->Port_Send, (CM_UINT32)inet_addr(AREA_MULTI_COMM_CFG_PTR->IP_Multicast),ENUM_MULTICAST_SEND);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    rt = CM_UDP_Socket_Create(&AREA_MULTI_COMM_CFG_PTR->Socket_Recv, CM_FALSE, (CM_UINT32)inet_addr(AREA_MULTI_COMM_CFG_PTR->IP_Local), AREA_MULTI_COMM_CFG_PTR->Port_Recv, (CM_UINT32)inet_addr(AREA_MULTI_COMM_CFG_PTR->IP_Multicast),ENUM_MULTICAST_RCV);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    
+    rt = CM_MQ_Init(&(AREA_MULTI_COMM_CFG_PTR->MsgQ), (CM_UINT16)Area_MSG_NUM_MAX, (CM_UINT16)Area_RAW_MSG_SIZE);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_Area_Multi_UdpRecvThread, "Area_Rx", 0, CM_TASK_PRIORITY_73, (CM_Thread_Arg_Struct_T*)AREA_MULTI_COMM_CFG_PTR);
+	CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_24);
+
+}
+
+/**
+* @brief 第三方仲裁请求发送
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_Arb_Req_Send(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
+{
+    /*- 变量初始化 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    /*- 入参指针防空 */
+    if(NULL != pBuf)
+    {
+		/*- 向第三方仲裁发送 */
+    	rt = CM_UDP_Send_Msg(ARB_COMM_CFG_PTR->Socket, pBuf, BufLen, inet_addr(ARB_COMM_CFG_PTR->IP_Arb),ARB_COMM_CFG_PTR->port);
+    }
+    else
+    {
+    	/*空指针返回失败*/
+    }
+    /*- 返回发送结果 */
+    return rt;
+}
+/**
+* @brief 第三方仲裁请求发送接收
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_Arb_Ack_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize)
+{
+	/*- 变量初始化 */
+	CM_UINT16 len = (CM_UINT16)((BufSize > 65535u) ? 65535u : BufSize);
+	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	/*- 指针防空*/
+	/*- 从接收线程获取输入报文 */
+	rt = CM_MQ_Read(&(ARB_COMM_CFG_PTR->MsgQ), pBuf, &len);
+	/*- 是否获取成功 */
+	if (ENUM_CM_TRUE == rt)
+	{
+		/*- 输出接收数据 */
+	}
+	else
+	{
+		/*- 接收长度为0 */
+		len = 0u;
+	}
+	/*- 返回接收长度 */
+	return (CM_INT32)len;
+}
+
+/**
+* @brief 区域状态请求单播发送
+* @param dstID 发送的目的ID
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_State_Send(IN CM_UINT8 dstID, IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
+{
+    /*- 变量初始化 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    /*- 入参指针防空 */
+    if(NULL != pBuf)
+    {
+		/*- 向目的ID发送 */
+        if(dstID == AREA_BASIC_CFG_PTR->Partner_BoardID)
+        {
+            rt = CM_UDP_Send_Msg(AREA_UNI_COMM_CFG_PTR->Socket, pBuf, BufLen, inet_addr(AREA_UNI_COMM_CFG_PTR->IP_Partner),AREA_UNI_COMM_CFG_PTR->port);
+        }
+        else if(dstID == AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID)
+        {
+            rt = CM_UDP_Send_Msg(AREA_UNI_COMM_CFG_PTR->Socket, pBuf, BufLen, inet_addr(AREA_UNI_COMM_CFG_PTR->IP_Partner_Area_A),AREA_UNI_COMM_CFG_PTR->port);
+        }
+        else if(dstID == AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID)
+        {
+            rt = CM_UDP_Send_Msg(AREA_UNI_COMM_CFG_PTR->Socket, pBuf, BufLen, inet_addr(AREA_UNI_COMM_CFG_PTR->IP_Partner_Area_B),AREA_UNI_COMM_CFG_PTR->port);
+        }
+    	else
+        {
+            /**ID查询失败 */
+            rt = ENUM_CM_FALSE;
+        }
+        
+    }
+    else
+    {
+    	/*空指针返回失败*/
+    }
+    /*- 返回发送结果 */
+    return rt;
+}
+
+/**
+* @brief 区域状态请求单播接收（仲裁模式使用）
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @param timeRcv 接收时的时间戳，单位ms
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_State_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize, OUT CM_UINT32* timeRcv)
+{
+	/*- 变量初始化 */
+	CM_UINT8 buf[Area_RAW_MSG_SIZE] = {0};
+	CM_UINT16 len = (CM_UINT16)sizeof(buf);
+	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	/*- 指针防空*/
+	if((NULL == pBuf) || (0u == BufSize))
+	{
+		return 0;
+	}
+	/*- 从接收线程获取输入报文 */
+	rt = CM_MQ_Read(&(AREA_UNI_COMM_CFG_PTR->MsgQ), buf, &len);
+	/*- 是否获取成功 */
+	if ((ENUM_CM_TRUE == rt) && (len > 4u) && ((CM_UINT32)(len - 4u) <= BufSize))
+	{
+		/*- 输出接收数据 */
+        if(NULL != timeRcv)
+        {
+            *timeRcv = CM_LongFromChar(buf);
+        }
+        CM_Memcpy(pBuf, BufSize, &buf[4], len - 4);
+		len -= 4u;
+	}
+	else
+	{
+		/*- 接收长度为0 */
+		len = 0u;
+	}
+	/*- 返回接收长度 */
+	return (CM_INT32)len;
+}
+
+/**
+* @brief 区域状态请求组播发送
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_State_Multi_Send(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
+{
+    /*- 变量初始化 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    /*- 入参指针防空 */
+    if(NULL != pBuf)
+    {
+		/*- 组播发送 */
+    	rt = CM_UDP_Send_Msg(AREA_MULTI_COMM_CFG_PTR->Socket_Send, pBuf, BufLen, inet_addr(AREA_MULTI_COMM_CFG_PTR->IP_Multicast),AREA_MULTI_COMM_CFG_PTR->Port_Recv);
+    }
+    else
+    {
+    	/*空指针返回失败*/
+    }
+    /*- 返回发送结果 */
+    return rt;
+}
+
+/**
+* @brief 区域状态请求组播接收
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @param timeRcv 接收时的时间戳，单位ms
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_State_Multi_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize, OUT CM_UINT32* timeRcv)
+{
+	/*- 变量初始化 */
+	CM_UINT8 buf[Area_RAW_MSG_SIZE] = {0};
+	CM_UINT16 len = (CM_UINT16)sizeof(buf);
+	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	/*- 指针防空*/
+	if((NULL == pBuf) || (0u == BufSize))
+	{
+		return 0;
+	}
+	/*- 从接收线程获取输入报文 */
+	rt = CM_MQ_Read(&(AREA_MULTI_COMM_CFG_PTR->MsgQ), buf, &len);
+	/*- 是否获取成功 */
+	if ((ENUM_CM_TRUE == rt) && (len > 4u) && ((CM_UINT32)(len - 4u) <= BufSize))
+	{
+		/*- 输出接收数据 */
+        if(NULL != timeRcv)
+        {
+            *timeRcv = CM_LongFromChar(buf);
+        }
+        CM_Memcpy(pBuf, BufSize, &buf[4], len - 4);
+		len -= 4u;
+	}
+	else
+	{
+		/*- 接收长度为0 */
+		len = 0u;
+	}
+	/*- 返回接收长度 */
+	return (CM_INT32)len;
+}
+
+/**
+ * @brief 清空接收缓冲区
+ */
+void Area_Arb_ClearMsgQ(void)
+{
+    (void)CM_MQ_Flush(&(AREA_UNI_COMM_CFG_PTR->MsgQ));
+    (void)CM_MQ_Flush(&(ARB_COMM_CFG_PTR->MsgQ));
+    (void)CM_MQ_Flush(&(AREA_MULTI_COMM_CFG_PTR->MsgQ));
+}
+
+/**
+ * @brief 仲裁接收线程
+ * @param STRU_ARB_IP_CFG_T-仲裁相关通信配置
+ */
+static CM_THREAD_FUNC_T t_Area_Arb_UdpRecvThread(IN STRU_ARB_COMM_CFG_T *arg)
+{
+    /*- 变量初始化 */
+    STRU_ARB_COMM_CFG_T *pCtrl = (STRU_ARB_COMM_CFG_T *)arg; /* 线程控制信息 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;               /* 函数返回值 */
+    CM_UINT8 *rcvBuf = NULL;
+    CM_INT32 len;       /* 报文长度 */
+    CM_UINT32 srcIP;    /* 源IP */
+    CM_UINT16 srcPort;  /* 源端口 */
+    CM_SOCKADDR_T addr; /* 地址转换*/
+
+    void* pmask = NULL;
+    pmask = (void*)(0x01u|0x02u);
+    (void)ThreadCtl(_NTO_TCTL_RUNMASK, pmask);
+
+    MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP_Local, pCtrl->port);
+    /*- 循环接收UDP数据 */
+    while (1)
+    {
+        /*- UDP阻塞接收 */
+        rcvBuf = CM_MQ_Get_BufAddr(&pCtrl->MsgQ);
+        if (NULL != rcvBuf)
+        {
+            len = CM_UDP_Recv_Msg(pCtrl->Socket, &rcvBuf[0u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(pCtrl->MsgQ.maxMsgSize), &srcIP, &srcPort);
+            /*- 是否收到有效数据 */
+            if (len > 0)
+            {
+                /*- 源IP端口是否合法 */
+                if ((srcIP != 0) && (srcPort != 0))
+                {
+                    /*- @alias 将收到的报文写入线程接收队列 */
+                    // 					MSCP_LOG_MSG("!!! area recv len = %d \r\n",len);
+                    /*- 保存通信数据 */
+                    rt = CM_MQ_UpData(&pCtrl->MsgQ, (CM_UINT16)CM_SIGNED_INT_EXP(len));
+                    /*- 数据保存是否成功 */
+                    if (ENUM_CM_TRUE == rt)
+                    {
+                        /*成功无操作*/
+                    }
+                    else
+                    {
+                        /*- 防御性清空*/
+                        rt = CM_MQ_Clear(&pCtrl->MsgQ);
+                        CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_1);
+                    }
+                }
+                else
+                {
+                    /*- 来自非预期IP端口的数据*/
+                    addr.sin_addr.s_addr = srcIP;
+                    CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_2);
+                }
+            }
+            else
+            {
+                /*- 接收出错 */
+                MSCP_LOG_MSG("warning ASSERT1103: port %d rx err(len=%d)\n", pCtrl->port, len);
+                (void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1));
+            }
+        }
+        else
+        {
+            /*获取队列指针失败，清空队列*/
+            rt = CM_MQ_Clear(&pCtrl->MsgQ);
+            MSCP_LOG_MSG("buf clear\n");
+            CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_4);
+        }
+    }
+    return NULL;
+}
+
+/**
+ * @brief 区域间组播接收线程
+ * @param 
+ */
+static CM_THREAD_FUNC_T t_Area_Multi_UdpRecvThread(IN STRU_AREA_MULTICAST_COMM_T *arg)
+{
+    /*- 变量初始化 */
+    STRU_AREA_MULTICAST_COMM_T *pCtrl = (STRU_AREA_MULTICAST_COMM_T *)arg; /* 线程控制信息 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;               /* 函数返回值 */
+    CM_UINT8 *rcvBuf = NULL;
+    CM_INT32 len;       /* 报文长度 */
+    CM_UINT32 srcIP;    /* 源IP */
+    CM_UINT16 srcPort;  /* 源端口 */
+    CM_SOCKADDR_T addr; /* 地址转换*/
+
+    void* pmask = NULL;
+    pmask = (void*)(0x01u|0x02u);
+    (void)ThreadCtl(_NTO_TCTL_RUNMASK, pmask);
+    
+    MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP_Multicast, pCtrl->Port_Recv);
+    /*- 循环接收UDP数据 */
+    while (1)
+    {
+        /*- UDP阻塞接收 */
+        rcvBuf = CM_MQ_Get_BufAddr(&pCtrl->MsgQ);
+        if (NULL != rcvBuf)
+        {
+            len = CM_UDP_Recv_Msg(pCtrl->Socket_Recv, &rcvBuf[4u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(pCtrl->MsgQ.maxMsgSize - 4u), &srcIP, &srcPort);
+            /*- 是否收到有效数据 */
+            if (len > 0)
+            {
+                /*- 源IP端口是否合法 */
+                if ((srcIP != 0) && (srcPort != 0))
+                {
+                    /*- @alias 将收到的报文写入线程接收队列 */
+					CM_LongToChar((CM_UINT32)(CM_GetTick()/CM_UNSIGNED_MILLION), rcvBuf);
+                    /*- 保存通信数据 */
+                    rt = CM_MQ_UpData(&pCtrl->MsgQ, (CM_UINT16)CM_SIGNED_INT_EXP(len+4u));
+                    /*- 数据保存是否成功 */
+                    if (ENUM_CM_TRUE == rt)
+                    {
+                        /*成功无操作*/
+                    }
+                    else
+                    {
+                        /*- 防御性清空*/
+                        rt = CM_MQ_Clear(&pCtrl->MsgQ);
+                        CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_1);
+                    }
+                }
+                else
+                {
+                    /*- 来自非预期IP端口的数据*/
+                    addr.sin_addr.s_addr = srcIP;
+                    CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_2);
+                }
+            }
+            else
+            {
+                /*- 接收出错 */
+                AREA_LOG_MSG("warning ASSERT1103: port %d rx err(len=%d)\n", pCtrl->Port_Recv, len);
+                (void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1));
+            }
+        }
+        else
+        {
+            /*获取队列指针失败，清空队列*/
+            rt = CM_MQ_Clear(&pCtrl->MsgQ);
+            AREA_LOG_MSG("buf clear\n");
+            CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_4);
+        }
+    }
+    return NULL;
+}
+/**
+ * @brief 初始化仲裁模式下使用的IP
+ */
+static void s_Area_Arb_IP_Init(void)
+{
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+
+     /** 获取区域网络配置(状态请求) */
+    rt = CM_Memcpy(AREA_UNI_COMM_CFG_PTR->IP_Local, 32, g_PFM_Cfg.Local_Cfg.IP_4x2,32);/**<  本地通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    rt = CM_Memcpy(AREA_UNI_COMM_CFG_PTR->IP_Partner, 32, g_PFM_Cfg.Partner_Cfg.IP_4x2,32);/**<  对系通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    
+    rt = CM_Memcpy(AREA_UNI_COMM_CFG_PTR->IP_Partner_Area_A, 32, g_PFM_Cfg.Partner_Area_A_Cfg.IP_4x2,32);/**<  对地通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    rt = CM_Memcpy(AREA_UNI_COMM_CFG_PTR->IP_Partner_Area_B, 32, g_PFM_Cfg.Partner_Area_B_Cfg.IP_4x2,32);/**<  对地通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    AREA_UNI_COMM_CFG_PTR->port = g_PFM_Cfg.Local_Cfg.Port_Area_State;/**<  端口号 */
+
+    AREA_LOG_MSG("AREA CFG %s, %s %s %s \r\n",g_PFM_Cfg.Local_Cfg.IP_4x2, g_PFM_Cfg.Partner_Cfg.IP_4x2,
+   		 g_PFM_Cfg.Partner_Area_A_Cfg.IP_4x2, g_PFM_Cfg.Partner_Area_B_Cfg.IP_4x2);
+        
+    /*获取仲裁网络配置*/
+    rt = CM_Memcpy(ARB_COMM_CFG_PTR->IP_Local, 32, g_PFM_Cfg.Local_Cfg.IP_Area,32);/**<  对地通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);    
+
+    rt = CM_Memcpy(ARB_COMM_CFG_PTR->IP_Arb, 32, g_PFM_Cfg.Arb_CFG.IP_Arb,32);/**<  对地通信IP */
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);   
+    
+    ARB_COMM_CFG_PTR->port = g_PFM_Cfg.Arb_CFG.Port_Arb;
+
+    MSCP_LOG_MSG("ARB CFG %s:%d->%s:%d\n", ARB_COMM_CFG_PTR->IP_Local, 
+        ARB_COMM_CFG_PTR->port,ARB_COMM_CFG_PTR->IP_Arb,ARB_COMM_CFG_PTR->port);
+
+    /*获取区域间组播通信配置(主地主组播状态)*/
+    rt = CM_Memcpy(AREA_MULTI_COMM_CFG_PTR->IP_Local, 32, g_PFM_Cfg.Local_Cfg.IP_4x2,32);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    rt = CM_Memcpy(AREA_MULTI_COMM_CFG_PTR->IP_Multicast, 32, g_PFM_Cfg.Local_Cfg.IP_Area_Multicast, 32);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+    AREA_MULTI_COMM_CFG_PTR->Port_Recv = g_PFM_Cfg.Local_Cfg.Port_Area_Recv;
+    AREA_MULTI_COMM_CFG_PTR->Port_Send = g_PFM_Cfg.Local_Cfg.Port_Area_Send;
+
+    MSCP_LOG_MSG("AREA MULTICAST CFG %s:%d->%s:%d\n", AREA_MULTI_COMM_CFG_PTR->IP_Local, AREA_MULTI_COMM_CFG_PTR->Port_Send,
+        AREA_MULTI_COMM_CFG_PTR->IP_Multicast,AREA_MULTI_COMM_CFG_PTR->Port_Recv);
+
+}
+/**
+ * @brief 区域间但播接收线程
+ */
+static CM_THREAD_FUNC_T t_Area_Uni_UdpRecvThread(IN STR_Area_IP_Cfg *arg)
+{
+    /*- 变量初始化 */
+    STR_Area_IP_Cfg *pCtrl = (STR_Area_IP_Cfg *)arg; /* 线程控制信息 */
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;               /* 函数返回值 */
+    CM_UINT8 *rcvBuf = NULL;
+    CM_INT32 len;       /* 报文长度 */
+    CM_UINT32 srcIP;    /* 源IP */
+    CM_UINT16 srcPort;  /* 源端口 */
+    CM_SOCKADDR_T addr; /* 地址转换*/
+
+    CM_UINT32 cpu_mask = 0;
+    /*- 本线程锁定在 A53 core 1 */
+    cpu_mask = (0x04u);
+    set_thread_affinity(cpu_mask);
+    MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP_Local, pCtrl->port);
+    /*- 循环接收UDP数据 */
+    while (1)
+    {
+        /*- UDP阻塞接收 */
+        rcvBuf = CM_MQ_Get_BufAddr(&pCtrl->MsgQ);
+        if (NULL != rcvBuf)
+        {
+            len = CM_UDP_Recv_Msg(pCtrl->Socket, &rcvBuf[4u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(pCtrl->MsgQ.maxMsgSize - 4u), &srcIP, &srcPort);
+            /*- 是否收到有效数据 */
+            if (len > 0)
+            {
+                /*- 源IP端口是否合法 */
+                if ((srcIP != 0) && (srcPort != 0))
+                {
+                    /*- @alias 将收到的报文写入线程接收队列 */
+					CM_LongToChar((CM_UINT32)(CM_GetTick()/CM_UNSIGNED_MILLION), rcvBuf);
+                    /*- 保存通信数据 */
+                    rt = CM_MQ_UpData(&pCtrl->MsgQ, (CM_UINT16)CM_SIGNED_INT_EXP(len+4u));
+                    /*- 数据保存是否成功 */
+                    if (ENUM_CM_TRUE == rt)
+                    {
+                        /*成功无操作*/
+                    }
+                    else
+                    {
+                        /*- 防御性清空*/
+                        rt = CM_MQ_Clear(&pCtrl->MsgQ);
+                        CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_1);
+                    }
+                }
+                else
+                {
+                    /*- 来自非预期IP端口的数据*/
+                    addr.sin_addr.s_addr = srcIP;
+                    CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_2);
+                }
+            }
+            else
+            {
+                /*- 接收出错 */
+                AREA_LOG_MSG("warning ASSERT1103: port %d rx err(len=%d)\n", pCtrl->port, len);
+                (void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1));
+            }
+        }
+        else
+        {
+            /*获取队列指针失败，清空队列*/
+            rt = CM_MQ_Clear(&pCtrl->MsgQ);
+            AREA_LOG_MSG("buf clear\n");
+            CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_4);
+        }
+    }
+    return NULL;
+}

TSCP/src/MSCP/Arb/Arb_Net.h

@@ -0,0 +1,99 @@
+#ifndef ARB_NET_H_
+#define ARB_NET_H_
+/*区域间的组播配置*/
+typedef struct
+{
+    CM_CHAR IP_Local[32]; /**< 本地IP */
+    CM_CHAR IP_Multicast[32]; /**< 组播域*/
+
+    CM_UINT16 Port_Send; /**< 组播发送接口 */
+    CM_UINT16 Port_Recv; /**< 组播接收接口 */
+
+    CM_SOCKET Socket_Send; /**< 组播发送socket */
+    CM_SOCKET Socket_Recv; /**< 组播接收socket */
+
+    CM_MQ_Struct_T MsgQ; /**< 接收消息队列 */
+} STRU_AREA_MULTICAST_COMM_T;
+
+/*与第三方仲裁通信的配置*/
+typedef struct
+{
+    CM_CHAR IP_Local[32];
+    CM_CHAR IP_Arb[32];
+    CM_SOCKET Socket;
+    CM_UINT16 port;      /**< 端口号 */
+    CM_MQ_Struct_T MsgQ; /**< 接收消息队列 */
+} STRU_ARB_COMM_CFG_T;
+/**
+ * @brief 仲裁模式下的网络初始化
+ */
+void Area_Arb_Net_Init(void);
+
+/**
+* @brief 第三方仲裁请求发送（仲裁模式使用）
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_Arb_Req_Send(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen);
+
+/**
+* @brief 第三方仲裁请求应答接收（仲裁模式使用）
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_Arb_Ack_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize);
+
+/**
+* @brief 区域状态请求单播发送
+* @param dstID 发送的目的ID
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_State_Send(IN CM_UINT8 dstID, IN const CM_UINT8* pBuf, IN CM_INT32 BufLen);
+
+/**
+* @brief 区域状态请求单播接收（仲裁模式使用）
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @param timeRcv 接收时的时间戳，单位ms(为空指针时不读取)
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_State_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize, OUT CM_UINT32* timeRcv);
+
+/**
+* @brief 区域状态请求组播发送（仲裁模式使用）
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
+* - ENUM_CM_TRUE 成功
+* - ENUM_CM_FALSE 失败
+*/
+ENUM_CM_RETURN Area_State_Multi_Send(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen);
+
+/**
+* @brief 区域状态请求组播接收（仲裁模式使用）
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_INT32 Area_State_Multi_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize, OUT CM_UINT32* timeRcv);
+
+/**
+ * @brief 仲裁模式下所有的接收缓冲区
+ */
+void Area_Arb_ClearMsgQ(void);
+
+#endif

TSCP/src/MSCP/Arb/Arb_Pack.c

@@ -0,0 +1,200 @@
+#include "Arb_Pack.h"
+#include "CM_Convert.h"
+
+/**
+ * @brief 打包仲裁请求/应答帧
+ * @return 成功返回固定报文长度26，入参非法或缓冲区不足返回0。
+ */
+CM_INT32 Area_Arb_Frame_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size,
+    IN STRU_AREA_WITH_ARB_PACK_T* pack)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == buf) || (NULL == pack) || (buf_size < AREA_ARB_FRAME_PACK_LEN))
+    {
+        return 0;
+    }
+
+    /* 按协议字段顺序写入；多字节整数统一使用大端转换函数。 */
+    buf[index++] = pack->Len;
+    buf[index++] = (CM_UINT8)pack->MsgType;
+    CM_LongToChar(pack->ArbSN, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    CM_ShortToChar(pack->OutNet_ID, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT16);
+    buf[index++] = pack->Board_ID;
+    buf[index++] = pack->CPU_ID;
+    buf[index++] = pack->ArbPayLoad;
+    /* 预留区为字节数组，直接复制到报文缓冲区。 */
+    (void)memcpy(&buf[index], pack->Reserver, AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    CM_LongToChar(pack->CRC1, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    CM_LongToChar(pack->CRC2, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+
+    return (CM_INT32)index;
+}
+
+/**
+ * @brief 解包仲裁请求/应答帧
+ * @note 入参非法或报文长度不足时不修改输出结构体。
+ */
+void Area_Arb_Frame_UnPack(OUT STRU_AREA_WITH_ARB_PACK_T* pack,
+    IN CM_UINT8* buf, IN CM_UINT32 buf_len)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == pack) || (NULL == buf) || (buf_len < AREA_ARB_FRAME_PACK_LEN))
+    {
+        return;
+    }
+
+    /* 按打包时相同的字段顺序读取，多字节整数按大端还原。 */
+    pack->Len = buf[index++];
+    pack->MsgType = (ENUM_AREA_ARB_MSG_TYPE_T)buf[index++];
+    pack->ArbSN = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->OutNet_ID = CM_ShortFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT16);
+    pack->Board_ID = buf[index++];
+    pack->CPU_ID = buf[index++];
+    pack->ArbPayLoad = buf[index++];
+    /* 预留区为字节数组，直接复制到输出结构体。 */
+    (void)memcpy(pack->Reserver, &buf[index], AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    pack->CRC1 = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->CRC2 = CM_LongFromChar(&buf[index]);
+}
+
+/**
+ * @brief 打包区域状态组播帧
+ * @return 成功返回固定报文长度25，入参非法或缓冲区不足返回0。
+ */
+CM_INT32 Area_Arb_State_Multi_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size,
+    IN STRU_AREA_WITH_ARB_STATE_MULTI_PACK_T* pack)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == buf) || (NULL == pack) || (buf_size < AREA_ARB_STATE_MULTI_PACK_LEN))
+    {
+        return 0;
+    }
+
+    /* 按协议字段顺序写入；多字节整数统一使用大端转换函数。 */
+    buf[index++] = pack->Len;
+    buf[index++] = (CM_UINT8)pack->MsgType;
+    CM_LongToChar(pack->SN, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    buf[index++] = pack->SrcID;
+    buf[index++] = pack->StateArea;
+    buf[index++] = pack->State2x;
+    /* 预留区为字节数组，直接复制到报文缓冲区。 */
+    (void)memcpy(&buf[index], pack->Reserver, AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    CM_LongToChar(pack->CRC1, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    CM_LongToChar(pack->CRC2, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+
+    return (CM_INT32)index;
+}
+
+/**
+ * @brief 解包区域状态组播帧
+ * @note 入参非法或报文长度不足时不修改输出结构体。
+ */
+void Area_Arb_State_Multi_UnPack(OUT STRU_AREA_WITH_ARB_STATE_MULTI_PACK_T* pack,
+    IN CM_UINT8* buf, IN CM_UINT32 buf_len)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == pack) || (NULL == buf) || (buf_len < AREA_ARB_STATE_MULTI_PACK_LEN))
+    {
+        return;
+    }
+
+    /* 按打包时相同的字段顺序读取，多字节整数按大端还原。 */
+    pack->Len = buf[index++];
+    pack->MsgType = (ENUM_AREA_ARB_MSG_TYPE_T)buf[index++];
+    pack->SN = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->SrcID = buf[index++];
+    pack->StateArea = buf[index++];
+    pack->State2x = buf[index++];
+    /* 预留区为字节数组，直接复制到输出结构体。 */
+    (void)memcpy(pack->Reserver, &buf[index], AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    pack->CRC1 = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->CRC2 = CM_LongFromChar(&buf[index]);
+}
+
+/**
+ * @brief 打包地间状态请求/应答帧
+ * @return 成功返回固定报文长度27，入参非法或缓冲区不足返回0。
+ */
+CM_INT32 Area_Arb_State_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size,
+    IN STRU_AREA_WITH_ARB_STATE_PACK_T* pack)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == buf) || (NULL == pack) || (buf_size < AREA_ARB_STATE_PACK_LEN))
+    {
+        return 0;
+    }
+
+    /* 按协议字段顺序写入；多字节整数统一使用大端转换函数。 */
+    buf[index++] = pack->Len;
+    buf[index++] = (CM_UINT8)pack->MsgType;
+    CM_LongToChar(pack->SN, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    buf[index++] = pack->TimeSyncFlag;
+    buf[index++] = pack->SrcID;
+    buf[index++] = pack->DstID;
+    buf[index++] = pack->StateArea;
+    buf[index++] = pack->State2x;
+    /* 预留区为字节数组，直接复制到报文缓冲区。 */
+    (void)memcpy(&buf[index], pack->Reserver, AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    CM_LongToChar(pack->CRC1, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    CM_LongToChar(pack->CRC2, &buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+
+    return (CM_INT32)index;
+}
+
+/**
+ * @brief 解包地间状态请求/应答帧
+ * @note 入参非法或报文长度不足时不修改输出结构体。
+ */
+void Area_Arb_State_UnPack(OUT STRU_AREA_WITH_ARB_STATE_PACK_T* pack,
+    IN CM_UINT8* buf, IN CM_UINT32 buf_len)
+{
+    CM_UINT32 index = 0u;
+
+    if ((NULL == pack) || (NULL == buf) || (buf_len < AREA_ARB_STATE_PACK_LEN))
+    {
+        return;
+    }
+
+    /* 按打包时相同的字段顺序读取，多字节整数按大端还原。 */
+    pack->Len = buf[index++];
+    pack->MsgType = (ENUM_AREA_ARB_MSG_TYPE_T)buf[index++];
+    pack->SN = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->TimeSyncFlag = buf[index++];
+    pack->SrcID = buf[index++];
+    pack->DstID = buf[index++];
+    pack->StateArea = buf[index++];
+    pack->State2x = buf[index++];
+    /* 预留区为字节数组，直接复制到输出结构体。 */
+    (void)memcpy(pack->Reserver, &buf[index], AREA_ARB_RESERVER_LEN);
+    index += AREA_ARB_RESERVER_LEN;
+    pack->CRC1 = CM_LongFromChar(&buf[index]);
+    index += (CM_UINT32)sizeof(CM_UINT32);
+    pack->CRC2 = CM_LongFromChar(&buf[index]);
+}
+

TSCP/src/MSCP/Arb/Arb_Pack.h

@@ -0,0 +1,132 @@
+#ifndef AREA_PACK_H_
+#define AREA_PACK_H_
+
+#include "CM_Types.h"
+#include "SFM_2x2.h"
+#include "Area.h"
+
+/* 各类报文在线路上的固定长度，不包含结构体对齐字节。 */
+#define AREA_ARB_FRAME_PACK_LEN               (27u)
+#define AREA_ARB_STATE_MULTI_PACK_LEN         (25u)
+#define AREA_ARB_STATE_PACK_LEN               (27u)
+
+#define AREA_ARB_RESERVER_LEN            (8u)
+
+/**< 仲裁模式下，区域通信的消息类型 */
+typedef enum
+{
+    ENUM_AREA_MSG_ARB_REQ = 0x01,    /**< 仲裁请求帧 */
+    ENUM_AREA_MSG_ARB_ACK = 0x81,    /**< 仲裁应答帧 */
+
+    ENUM_AREA_MSG_STATE_REQ = 0x02,  /**< 区域状态请求帧 */
+    ENUM_AREA_MSG_STATE_ACK = 0x82,  /**< 区域状态应答帧 */
+
+    ENUM_AREA_MSG_STATE_MULTI = 0x03, /**< 区域状态组播帧 */
+}ENUM_AREA_ARB_MSG_TYPE_T;
+
+/* 仲裁模式下，仲裁请求与回复的帧格式 */
+typedef struct
+{
+    CM_UINT8 Len;                       /**< 数据包长度 */
+    ENUM_AREA_ARB_MSG_TYPE_T MsgType;   /**< 消息类型 */
+    CM_UINT32 ArbSN;                    /**< 仲裁请求/应答序列号 */
+    CM_UINT16 OutNet_ID;                /**< 外网ID */
+    CM_UINT8 Board_ID;                  /**< 板卡ID */
+    CM_UINT8 CPU_ID;                    /**< CPUID */
+    CM_UINT8 ArbPayLoad;                /**< 仲裁请求/回复的具体内容 */
+    CM_UINT8 Reserver[AREA_ARB_RESERVER_LEN];               /**< 预留8字节 */
+    CM_UINT32 CRC1;                     /**< CRC1 */
+    CM_UINT32 CRC2;                     /**< CRC2 */
+}STRU_AREA_WITH_ARB_PACK_T;
+
+/* 仲裁模式下，组播状态帧格式 */
+typedef struct
+{
+    CM_UINT8 Len;                       /**< 数据包长度 */
+    ENUM_AREA_ARB_MSG_TYPE_T MsgType;   /**< 消息类型 */
+    CM_UINT32 SN;                       /**< 消息SN号(周期号) */
+    CM_UINT8 SrcID;                     /**< 源ID(板卡ID) */
+    ENUM_AREA_STATE StateArea;                 /**< 区域状态 */
+    ENUM_2x2_STATE_T State2x;                   /**< 2x状态 */
+    CM_UINT8 Reserver[AREA_ARB_RESERVER_LEN];               /**< 预留8字节 */
+    CM_UINT32 CRC1;                     /**< CRC1 */
+    CM_UINT32 CRC2;                     /**< CRC2 */
+}STRU_AREA_WITH_ARB_STATE_MULTI_PACK_T;
+
+/**仲裁模式下，地间状态请求与回复帧格式 */
+typedef struct
+{
+    CM_UINT8 Len;                       /**< 数据包长度 */
+    ENUM_AREA_ARB_MSG_TYPE_T MsgType;   /**< 消息类型 */
+    CM_UINT32 SN;                       /**< 消息SN号(周期号) */
+    CM_UINT8 TimeSyncFlag;              /**< 校时标志(用于判断是否需要容忍接收) */
+    CM_UINT8 SrcID;                     /**< 源ID(板卡ID) */
+    CM_UINT8 DstID;                     /**< 目的ID(板卡ID) */
+    ENUM_AREA_STATE StateArea;                 /**< 区域状态 */
+    ENUM_2x2_STATE_T State2x;                   /**< 2x状态 */
+    CM_UINT8 Reserver[AREA_ARB_RESERVER_LEN];               /**< 预留8字节 */
+    CM_UINT32 CRC1;                     /**< CRC1 */
+    CM_UINT32 CRC2;                     /**< CRC2 */   
+}STRU_AREA_WITH_ARB_STATE_PACK_T;
+
+/**
+ * @brief 将仲裁请求结构体的内容写入缓冲区
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_size 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 如果使用该打包函数，解包时也必须使用对应解包函数，避免因为结构体对齐出现问题
+ */
+CM_INT32 Area_Arb_Frame_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size, IN STRU_AREA_WITH_ARB_PACK_T* pack);
+
+/**
+ * @brief 将缓冲区写入仲裁请求结构体的内容
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_len 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 仅对打包函数处理后的数据进行解包
+ */
+void Area_Arb_Frame_UnPack(OUT STRU_AREA_WITH_ARB_PACK_T* pack, IN CM_UINT8* buf, IN CM_UINT32 buf_len);
+
+/**
+ * @brief 将组播状态帧结构体的内容写入缓冲区
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_size 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 如果使用该打包函数，解包时也必须使用对应解包函数，避免因为结构体对齐出现问题
+ */
+CM_INT32 Area_Arb_State_Multi_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size, IN STRU_AREA_WITH_ARB_STATE_MULTI_PACK_T* pack);
+
+/**
+ * @brief 将缓冲区写入组播状态帧结构体
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_len 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 仅对打包函数处理后的数据进行解包
+ */
+void Area_Arb_State_Multi_UnPack(OUT STRU_AREA_WITH_ARB_STATE_MULTI_PACK_T* pack, IN CM_UINT8* buf, IN CM_UINT32 buf_len);
+
+/**
+ * @brief 将地间状态请求结构体的内容写入缓冲区
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_size 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 如果使用该打包函数，解包时也必须使用对应解包函数，避免因为结构体对齐出现问题
+ */
+CM_INT32 Area_Arb_State_Pack(OUT CM_UINT8* buf, IN CM_UINT32 buf_size, IN STRU_AREA_WITH_ARB_STATE_PACK_T* pack);
+
+/**
+ * @brief 将缓冲区写入地间状态请求结构体
+ * @param pack 请求结构体
+ * @param buf  缓冲区
+ * @param buf_len 缓冲区大小
+ * @return CM_INT32 写入的长度
+ * @note 仅对打包函数处理后的数据进行解包
+ */
+void Area_Arb_State_UnPack(OUT STRU_AREA_WITH_ARB_STATE_PACK_T* pack, IN CM_UINT8* buf, IN CM_UINT32 buf_len);
+
+#endif

TSCP/src/MSCP/Arb/Arb_State.c

@@ -0,0 +1,188 @@
+#include "Arb_State.h"
+#include "Arb.h"
+
+/**
+ * @brief 通过ID获取对应板卡区域状态
+ */
+ENUM_AREA_STATE AreaArb_GetState_byID(CM_UINT8 ID)
+{
+    ENUM_AREA_STATE state = ENUM_AREA_SHUTDOWN;
+    if(ID == AREA_BASIC_CFG_PTR->BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->StateArea.Local_state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->StateArea.Partner_state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->StateArea.Partner_Area_A_state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->StateArea.Partner_Area_B_state;
+    }
+    else
+    {
+        AREA_LOG_MSG("AREA_STATE:Get state failed, invalid board ID:%d\n", ID);
+    }
+    return state;
+}
+
+/**
+ * @brief 通过ID设置对应板卡区域状态
+ */
+void AreaArb_SetState_byID(CM_UINT8 ID, ENUM_AREA_STATE state)
+{
+    if((state < ENUM_AREA_SHUTDOWN) || (state > ENUM_AREA_SLAVE))
+    {
+        AREA_LOG_MSG("AREA_STATE:Set invalid area state, ID:%d State:%d\n", ID, state);
+    }
+
+    if(ID == AREA_BASIC_CFG_PTR->BoardID)
+    {
+        AREA_STATE_CTRL_PTR->StateArea.Local_state = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->StateArea.Partner_state = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->StateArea.Partner_Area_A_state = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->StateArea.Partner_Area_B_state = state;
+    }
+    else
+    {
+        AREA_LOG_MSG("AREA_STATE:Set state failed, invalid board ID:%d State:%d\n", ID, state);
+    }
+}
+
+/**
+ * @brief 通过ID获取对应板卡2x状态
+ */
+ENUM_2x2_STATE_T AreaArb_Get2xState_byID(CM_UINT8 ID)
+{
+    ENUM_2x2_STATE_T state = ENUM_2x2_SHUTDOWN;
+    if(ID == AREA_BASIC_CFG_PTR->BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->State2x.LocalState;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->State2x.PartnerState;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->State2x.Area_A_State;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID)
+    {
+        state = AREA_STATE_CTRL_PTR->State2x.Area_B_State;
+    }
+    else
+    {
+        AREA_LOG_MSG("AREA_STATE:Get 2x2 state failed, invalid board ID:%d\n", ID);
+    }
+    return state;
+}
+
+/**
+ * @brief 通过ID设置对应板卡2x状态
+ */
+void AreaArb_Set2xState_byID(CM_UINT8 ID, ENUM_2x2_STATE_T state)
+{
+    if((state < ENUM_2x2_SHUTDOWN) || (state > ENUM_2x2_MASTER))
+    {
+        AREA_LOG_MSG("AREA_STATE:Set invalid 2x2 state, ID:%d State:%d\n", ID, state);
+    }
+
+    if(ID == AREA_BASIC_CFG_PTR->BoardID)
+    {
+        AREA_STATE_CTRL_PTR->State2x.LocalState = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->State2x.PartnerState = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->State2x.Area_A_State = state;
+    }
+    else if(ID == AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID)
+    {
+        AREA_STATE_CTRL_PTR->State2x.Area_B_State = state;
+    }
+    else
+    {
+        AREA_LOG_MSG("AREA_STATE:Set 2x2 state failed, invalid board ID:%d State:%d\n", ID, state);
+    }
+}
+/**
+ * @brief 通过状态获取某个板卡ID
+ */
+CM_UINT8 AreaArb_GetID_byState(ENUM_AREA_STATE state_area, ENUM_2x2_STATE_T state_2x)
+{
+    CM_UINT8 boardID = 0u;
+
+    if(AREA_STATE_CTRL_PTR->StateArea.Local_state == state_area && AREA_STATE_CTRL_PTR->State2x.LocalState == state_2x)
+    {
+        boardID = AREA_BASIC_CFG_PTR->BoardID;
+    }
+    else if(AREA_STATE_CTRL_PTR->StateArea.Partner_state == state_area && AREA_STATE_CTRL_PTR->State2x.PartnerState == state_2x)
+    {
+        boardID = AREA_BASIC_CFG_PTR->Partner_BoardID;
+    }
+    else if(AREA_STATE_CTRL_PTR->StateArea.Partner_Area_A_state == state_area && AREA_STATE_CTRL_PTR->State2x.Area_A_State == state_2x)
+    {
+        boardID = AREA_BASIC_CFG_PTR->Partner_Area_A_BoardID;
+    }
+    else if(AREA_STATE_CTRL_PTR->StateArea.Partner_Area_B_state == state_area && AREA_STATE_CTRL_PTR->State2x.Area_B_State == state_2x)
+    {
+        boardID = AREA_BASIC_CFG_PTR->Partner_Area_B_BoardID;
+    }
+    else
+    {
+        AREA_LOG_MSG("AREA_STATE:Board not found by state, Area:%d 2x2:%d\n", state_area, state_2x);
+    }
+
+    return boardID;
+}
+/**
+ * @brief 仲裁模式下使用，获取所有区域状态
+ */
+void AreaArb_Get_All_State(STR_Area_State *p_all_State)
+{
+	if(NULL == p_all_State)
+	{
+		AREA_LOG_MSG("AREA_STATE:Get all states failed, output is NULL\n");
+	}
+	else
+	{
+		p_all_State->Local_state   =  AREA_STATE_CTRL_PTR->StateArea.Local_state;
+		p_all_State->Partner_state =  AREA_STATE_CTRL_PTR->StateArea.Partner_state;
+		p_all_State->Partner_Area_A_state =  AREA_STATE_CTRL_PTR->StateArea.Partner_Area_A_state;
+		p_all_State->Partner_Area_B_state =  AREA_STATE_CTRL_PTR->StateArea.Partner_Area_B_state;
+	}
+}
+/**
+ * @brief 判断是否存在备地
+ */
+CM_BOOL AreaArb_Slave_Is_Exist()
+{
+	CM_BOOL rt = CM_FALSE;
+	if((ENUM_AREA_SLAVE == AREA_STATE_CTRL_PTR->StateArea.Local_state) || (ENUM_AREA_SLAVE == AREA_STATE_CTRL_PTR->StateArea.Partner_state)
+			|| (ENUM_AREA_SLAVE == AREA_STATE_CTRL_PTR->StateArea.Partner_Area_A_state) || (ENUM_AREA_SLAVE == AREA_STATE_CTRL_PTR->StateArea.Partner_Area_B_state))
+	{
+		rt = CM_TRUE;
+	}
+	else
+	{
+
+	}
+	return rt;
+}

TSCP/src/MSCP/Arb/Arb_State.h

@@ -0,0 +1,41 @@
+#ifndef ARB_STATE_H_
+#define ARB_STATE_H_
+
+#include "SFM_2x2.h"
+
+/**
+ * @brief 仲裁模式下使用，通过ID获取对应板卡区域状态
+ */
+ENUM_AREA_STATE AreaArb_GetState_byID(CM_UINT8 ID);
+
+/**
+ * @brief 仲裁模式下使用，通过ID设置对应板卡区域状态
+ */
+void AreaArb_SetState_byID(CM_UINT8 ID, ENUM_AREA_STATE state);
+
+/**
+ * @brief 仲裁模式下使用，通过ID获取对应板卡2x状态
+ */
+ENUM_2x2_STATE_T AreaArb_Get2xState_byID(CM_UINT8 ID);
+
+/**
+ * @brief 仲裁模式下使用，通过ID设置对应板卡2x状态
+ */
+void AreaArb_Set2xState_byID(CM_UINT8 ID, ENUM_2x2_STATE_T state);
+
+/**
+ * @brief 仲裁模式下使用，通过状态获取某个板卡ID
+ * @return 0表示无该板卡
+ */
+CM_UINT8 AreaArb_GetID_byState(ENUM_AREA_STATE state_area, ENUM_2x2_STATE_T state_2x);
+
+/**
+ * @brief 仲裁模式下使用，获取所有区域状态
+ */
+void AreaArb_Get_All_State(STR_Area_State *p_all_State);
+/**
+ * @brief 判断是否存在备地
+ */
+CM_BOOL AreaArb_Slave_Is_Exist();
+
+#endif

TSCP/src/MSCP/Arb/Arb_State_Vote.c

@@ -0,0 +1,239 @@
+#include "Arb_State_Vote.h"
+#include "Arb_State.h"
+
+/**仅在状态表决时使用，简化宏，只包含区域状态 */
+#define VOTE_STATE_CTRL (&(AREA_STATE_CTRL_PTR->StateArea))
+
+/**
+ * @brief 宕机状态转换
+ */
+void s_Shutdown_vote(void);
+/**
+ * @brief 未知地状态转换
+ */
+void s_Unknown_vote(void);
+/**
+ * @brief 离线地状态转换
+ */
+void s_Offline_vote(void);
+/**
+ * @brief 主地状态转换
+ */
+void s_Master_vote(void);
+/**
+ * @brief 备地状态转换
+ */
+void s_Slave_vote(void);
+
+void Area_With_Arb_State_Vote(void)
+{
+    ENUM_AREA_STATE local_state = VOTE_STATE_CTRL->Local_state;
+    switch(local_state)
+    {
+        case ENUM_AREA_SHUTDOWN:
+            s_Shutdown_vote();
+            break;
+        case ENUM_AREA_UNKNOW:
+            s_Unknown_vote();
+            break;
+        case ENUM_AREA_OFFLINE:
+            s_Offline_vote();
+            break;
+        case ENUM_AREA_MASTER:
+            s_Master_vote();
+            break;
+        case ENUM_AREA_SLAVE:
+            s_Slave_vote();
+            break;
+        default:
+            AREA_LOG_MSG("AREA_STATE_VOTE:Invalid local state:%d\n", local_state);
+            break;
+
+    }
+}
+/**
+ * @brief 宕机状态转换
+ */
+void s_Shutdown_vote(void)
+{
+	VOTE_STATE_CTRL->Local_state = ENUM_AREA_SHUTDOWN;
+    AREA_LOG_MSG("AREA_STATE_VOTE:Local is Shutdown, system will assert\n");
+    CM_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+}
+/**
+ * @brief 未知地状态转换
+ */
+void s_Unknown_vote(void)
+{
+    CM_BOOL Sync_Health_Flag = AREA_FLAGS_CTRL_PTR->Sync_Health_Flag; /**同步成功标志 */
+    /**获取另外三系状态 */
+    ENUM_AREA_STATE Partner_State = VOTE_STATE_CTRL->Partner_state;
+    ENUM_AREA_STATE Area_A_State = VOTE_STATE_CTRL->Partner_Area_A_state;
+    ENUM_AREA_STATE Area_B_State = VOTE_STATE_CTRL->Partner_Area_B_state;
+    /**初始化未知地计数 */
+    static CM_UINT32 s_unkown_cnt = 0u;
+    /**状态转换部分 */
+    if(0x55u == AREA_ARB_CTRL_PTR->Arb_Ack)
+    {
+        /**收到仲裁升主回复 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Master, Arbitration ACK received\n");
+    }
+    else if(ENUM_AREA_MASTER == Partner_State)
+    {
+        /**和主地在同一地 */
+        if(CM_TRUE == Sync_Health_Flag)
+        {
+            VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+            AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Master, Partner is Master, Sync Sucess\n");
+        }
+        else
+        {
+            VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+            AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Offline, Partner is Master, Sync Fail\n");
+        }
+    }
+    else if((ENUM_AREA_UNKNOW == Area_A_State || ENUM_AREA_UNKNOW == Area_B_State) 
+        && (MSCP_AREA_ID_B == AREA_BASIC_CFG_PTR->AreaID))
+    {
+        /**另一地是离线地，本地是B地，降离线 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Offline, A is Unknown, Local is B\n");
+    }
+    else if((ENUM_AREA_SLAVE == Area_A_State || ENUM_AREA_SLAVE == Area_B_State))
+    {
+        /**另一地是备地，降离线（暂不存在改场景，预留转换） */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Offline, Another Area is Slave\n");
+    }
+    else if((ENUM_AREA_MASTER == Area_A_State || ENUM_AREA_MASTER == Area_B_State))
+    {
+        /**另一地是主地，降离线 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Offline, Another Area is Master\n");
+    }
+    else if((MSCP_AREA_ID_A == AREA_BASIC_CFG_PTR->AreaID)
+        && (ENUM_AREA_UNKNOW == Area_A_State || ENUM_AREA_OFFLINE == Area_A_State) 
+        && (ENUM_AREA_UNKNOW == Area_B_State || ENUM_AREA_OFFLINE == Area_B_State))
+    {
+        /**另一地为未知地/离线地，本地是A地，维持10周期升主（另一地是宕机时等待仲裁回复） */
+        s_unkown_cnt++;
+        if(s_unkown_cnt > MSCP_AREA_UNKNOW_COUNT_MAX)
+        {
+            VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+            AREA_LOG_MSG("AREA_STATE_VOTE:Unknow>>>>>Master, Local A tolerated %d cycles\n",
+                s_unkown_cnt);
+            s_unkown_cnt = 0u;
+        }
+    }
+    else
+    {
+        /**维持未知地 */
+    }
+    /**离开未知地，清空计数 */
+    if(ENUM_AREA_UNKNOW != VOTE_STATE_CTRL->Local_state)
+    {
+        s_unkown_cnt = 0u;
+    }
+}
+/**
+ * @brief 离线地状态转换
+ */
+void s_Offline_vote(void)
+{
+    CM_BOOL Sync_Health_Flag = AREA_FLAGS_CTRL_PTR->Sync_Health_Flag; /**同步成功标志 */
+    CM_UINT8 id_mm = AreaArb_GetID_byState(ENUM_AREA_MASTER, ENUM_2x2_MASTER); /**主地主的ID */
+    /**状态转换 */
+    if(CM_TRUE == Sync_Health_Flag)
+    {
+        /**同步成功 */
+        if(ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_state)
+        {
+            /**主地在本地，升主地 */
+            VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+            AREA_LOG_MSG("AREA_STATE_VOTE:Offline>>>>>Master, Partner is Master and sync is healthy\n");
+        }
+        else if(ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_Area_A_state ||
+            ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_Area_B_state)
+        {
+            /**主地在另一地，升备地 */
+            VOTE_STATE_CTRL->Local_state = ENUM_AREA_SLAVE;
+            AREA_LOG_MSG("AREA_STATE_VOTE:Offline>>>>>Slave, Another Area is Master and sync is healthy\n");
+        }
+        else
+        {
+
+        }
+    }
+    else if(0u == id_mm && 0)
+    {
+        /**(预留)主地主ID不存在，认为主地主宕机，离线地降未知地 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_UNKNOW;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Offline>>>>>Unknow, Master board not found\n");
+    }
+    else
+    {
+
+    }
+    
+}
+/**
+ * @brief 主地状态转换
+ */
+void s_Master_vote(void)
+{
+    ENUM_2x2_STATE_T state2x = AREA_STATE_CTRL_PTR->State2x.LocalState;
+
+    if(ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_Area_A_state || ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_Area_B_state)
+    {
+        /**双主宕机 */
+        AREA_LOG_MSG("AREA_STATE_VOTE:Double master detected, Another Area state:%d-%d\n",
+            VOTE_STATE_CTRL->Partner_Area_A_state, VOTE_STATE_CTRL->Partner_Area_B_state);
+        CM_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    }
+    else if(ENUM_2x2_OFFLINE == state2x)
+    {
+        /**与主地主同步失败 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Master>>>>>Offline, Sync failed\n");
+    }
+    else
+    {
+
+    }
+}
+/**
+ * @brief 备地状态转换
+ */
+void s_Slave_vote(void)
+{
+    CM_BOOL flag_comm_mm_status = CM_FALSE; /**与主地主的通信状态 */
+    CM_UINT8 id_mm = AreaArb_GetID_byState(ENUM_AREA_MASTER, ENUM_2x2_MASTER); /**主地主的ID */
+    AreaArb_GetCommStatus_byID(id_mm, NULL, &flag_comm_mm_status);
+
+    ENUM_2x2_STATE_T state2x = AREA_STATE_CTRL_PTR->State2x.LocalState;
+
+    if(0x55u == AREA_ARB_CTRL_PTR->Arb_Ack)
+    {
+        /**收到仲裁升主回复 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Slave>>>>>Master, Arbitration ACK received\n");
+    }
+    else if(ENUM_2x2_OFFLINE == state2x)
+    {
+        /**同步失败 */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_OFFLINE;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Slave>>>>>Offline, Sync failed and Master ID:%d exists\n",
+            id_mm);
+    }
+    else if(ENUM_AREA_MASTER == VOTE_STATE_CTRL->Partner_state)
+    {
+        /**对系是主地，升主地(备地主升主地主后，备地备通过这条逻辑升主地) */
+        VOTE_STATE_CTRL->Local_state = ENUM_AREA_MASTER;
+        AREA_LOG_MSG("AREA_STATE_VOTE:Slave>>>>>Master, Partner is Master\n");
+    }
+    else
+    {
+
+    }
+}

TSCP/src/MSCP/Arb/Arb_State_Vote.h

@@ -0,0 +1,8 @@
+#ifndef ARB_STATE_VOTE_H_
+#define ARB_STATE_VOTE_H_
+
+#include "Arb.h"
+
+void Area_With_Arb_State_Vote(void);
+
+#endif

TSCP/src/MSCP/Area/Area.h

@@ -0,0 +1,75 @@
+/*
+ * Area.h
+ *
+ *  Created on: 2025年12月2日
+ *      Author: adan
+ */
+
+#ifndef AREA_AREA_H_
+#define AREA_AREA_H_
+#include "CM_Types.h"
+#include "Area_State_Vote.h"
+#include "Area_state.h"
+
+typedef struct
+{
+	ENUM_AREA_STATE Local_state;/**< 本系区域状态*/
+    ENUM_AREA_STATE Partner_state;/**< 对系区域状态*/
+    ENUM_AREA_STATE Partner_Area_A_state;/**< 另一地A区域状态*/
+    ENUM_AREA_STATE Partner_Area_B_state;/**< 另一地B区域状态*/
+}STR_Area_State;
+/**
+ * @brief 区域开始
+ * 
+ */
+void Area_Start();
+/**
+ * @brief 等待区域停止
+ * 
+ */
+void Area_Wait_Stop();
+
+/**
+ * @brief 区域停止
+ *
+ */
+void Area_Stop();
+
+/**
+ * @brief 获取区域状态
+ * 
+ * @return ENUM_Area_State 区域状态
+ */
+ENUM_AREA_STATE Area_Get_State();
+/**
+ * @brief 设置区域状态
+ * 
+ * @param State 区域状态
+ */
+void Area_Set_State(ENUM_AREA_STATE State);
+
+/**
+ * @brief 获取区域状态
+ *
+ * @return ENUM_Area_State 区域状态
+ */
+ENUM_AREA_STATE Area_Get_Partner_State();
+
+/**<是否存在区域备地*/
+CM_BOOL Area_Slave_Is_Exist();
+
+void Area_init();
+
+void Area_Clear_MQ();
+
+void Area_Get_All_State(STR_Area_State *p_all_State);
+
+CM_UINT32 Area_GetArea_A_ID(void);
+
+CM_UINT32 Area_GetArea_B_ID(void);
+
+void get_Other_BoardId(CM_UINT8 local_Board_Id, CM_UINT8 *partner_Board_Id, CM_UINT8 *partner_Area_A_Board_Id, CM_UINT8 *partner_Area_B_Board_Id);
+
+/*日志转换*/
+void Area_LOG_Transition(void);
+#endif /* AREA_AREA_H_ */

TSCP/src/MSCP/Area/Area_2oo2.c

@@ -0,0 +1,133 @@
+#include "CM_Types.h"
+#include "CFM_Net.h"
+#include "PFM_Cfg.h"
+#include "CM_Memory.h"
+#include "CM_UDP.h"
+#include "CM_MultiThread_Priority.h"
+#include "CM_MultiThread.h"
+#include "Area_2oo2.h"
+#include "CM_Socket.h"
+#include "PFM_Cfg.h"
+#include "MSCP_Define.h"
+#include "PFM_Log.h"
+
+/*
+ * Area_2oo2.c
+ *
+ *  Created on: 2025年12月2日
+ *      Author: adan
+ */
+
+
+#define Area_2oo2_MSG_NUM_MAX (200u)
+#define Area_INNET_RAW_MSG_SIZE  (2048u)
+
+
+ENUM_CM_RETURN Area_2oo2_Send(IN const CM_UINT8* p_data, IN CM_INT32 len);
+CM_INT32 Area_2oo2_Recv(OUT CM_UINT8* p_data, IN CM_UINT32 BufSize);
+
+
+
+ STR_Area_Net_Cfg g_Area_2oo2_Cfg;
+ /**
+ * @brief 2oo2初始化
+ * 
+ */
+
+void Area_2oo2_Init()
+{
+    CM_UINT32 val= 0;
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    CM_BOOL rtCheck = 0;
+    /** 2oo2网络结构体初始化 */
+    g_Area_2oo2_Cfg.Net_2oo2_Ctl.SN = 0;
+    g_Area_2oo2_Cfg.Net_2oo2_Ctl.DataSend = Area_2oo2_Send;
+    g_Area_2oo2_Cfg.Net_2oo2_Ctl.DataRecv = Area_2oo2_Recv;
+    /** 2oo2网络初始化 */
+    CM_Memcpy(g_Area_2oo2_Cfg.IP_Local, 32 , g_PFM_Cfg.Local_Cfg.IP_2oo2 , 32);
+    CM_Memcpy(g_Area_2oo2_Cfg.IP_Pear,  32 , g_PFM_Cfg.Peer_Cfg.IP_2oo2, 32);
+    g_Area_2oo2_Cfg.Port = g_PFM_Cfg.Local_Cfg.Port_2oo2_Area;
+     /*- 创建socket */
+    rt = CM_UDP_Socket_Create(&g_Area_2oo2_Cfg.Socket, CM_FALSE, (CM_UINT32)inet_addr(g_Area_2oo2_Cfg.IP_Local), g_Area_2oo2_Cfg.Port, 0u, (CM_UINT8)1u);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+        /*- 配置socket */
+    val = (CM_INT32)NET_UDP_BUF_MAX;
+    (void)setsockopt(g_Area_2oo2_Cfg.Socket, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
+
+    /** 2oo2接收消息队列初始化 */
+    rt = CM_MQ_Init(&g_Area_2oo2_Cfg.MsgQ, (CM_UINT16)Area_2oo2_MSG_NUM_MAX, (CM_UINT16)Area_INNET_RAW_MSG_SIZE);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+
+	/*- 启动2oo2接收线程 */
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_Area_2oo2_UdpRecvThread, "Area_2oo2_Rx", 0, CM_TASK_PRIORITY_73, (CM_Thread_Arg_Struct_T*)&g_Area_2oo2_Cfg);
+	CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_24);
+
+
+
+}
+
+/**
+ * @brief 2oo2发送数据
+ * 
+ * @param p_data 指向要发送数据的指针
+ * @param len 要发送数据的长度
+ * @return ENUM_CM_RETURN 发送状态
+ */
+ENUM_CM_RETURN Area_2oo2_Send(IN const CM_UINT8* p_data, IN CM_INT32 len)
+{
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    if(NULL != p_data)
+    {
+        rt = CFM_2oo2_Send_Currency(g_Area_2oo2_Cfg.Socket, p_data, len, g_Area_2oo2_Cfg.Port);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    }
+    else 
+    {
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    }
+    return rt;
+}
+/**
+ * @brief 2oo2接收数据
+ * 
+ * @param p_data 指向接收数据存储的指针
+ * @param BufSize 接收数据存储缓冲区大小
+ * @return CM_INT32 实际接收数据长度
+ */
+CM_INT32 Area_2oo2_Recv(OUT CM_UINT8* p_data, IN CM_UINT32 BufSize)
+{
+    CM_UINT16 rcvlen = 1024;
+    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+    CM_UINT8 buf[1024] = {0};
+    if(NULL != p_data)
+    {
+    	//MSCP_LOG_MSG("2oo2 Qlen %d \r\n", CM_MQ_Get_Msg_Num(&g_Area_2oo2_Cfg.MsgQ));
+        rt = CM_MQ_Read(&g_Area_2oo2_Cfg.MsgQ, buf, &rcvlen);
+        	/*- 是否获取成功 */
+        if ((ENUM_CM_TRUE == rt) && (0u < rcvlen))
+        {
+            /*- 输出接收数据 */
+            rt = CM_Memcpy((void*)p_data, (CM_SIZE_T)BufSize, (void*)buf, (CM_SIZE_T)rcvlen);
+            //CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_39, TSCP_DARK_ASSERT_2);
+        }
+        else
+        {
+        	rcvlen = 0u;
+        }
+
+    }
+    else 
+    {
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    }
+    return rcvlen;
+}
+
+
+
+
+CM_INT32 Area_2oo2_Currency_NoSplit(IN const CM_UINT8 * pMyData, IN CM_INT32 DataLen, OUT CM_UINT8 * pPeerData, IN CM_UINT32 DataSize)
+{
+    return CFM_2oo2_Currency_NoSplit(&g_Area_2oo2_Cfg.Net_2oo2_Ctl, pMyData, DataLen, pPeerData, DataSize);
+}
+

TSCP/src/MSCP/Area/Area_2oo2.h

@@ -0,0 +1,5 @@
+#include "CM_Types.h"
+#include "Area_Net.h"
+
+CM_INT32 Area_2oo2_Currency_NoSplit(IN const CM_UINT8 * pMyData, IN CM_INT32 DataLen, OUT CM_UINT8 * pPeerData, IN CM_UINT32 DataSize);
+void Area_2oo2_Init();

TSCP/src/MSCP/Area/Area_Arb_Common.c

@@ -0,0 +1,78 @@
+#include "Area_Arb_Common.h"
+
+/**
+ * @brief 执行初始化，4线与仲裁模式根据配置区分
+ */
+void Area_Arb_Common_Init(void)
+{
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        Area_With_Arb_Init();
+    }
+    else
+    {
+        Area_init();//区域初始化
+    }
+}
+/**
+ * @brief 获取所有板卡区域状态，4线与仲裁模式根据配置开关从不同结构体获取
+ */
+void Area_Arb_Common_Get_All_State(STR_Area_State *p_all_State)
+{
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        AreaArb_Get_All_State(p_all_State);
+    }
+    else
+    {
+        Area_Get_All_State(p_all_State);
+    }
+}
+/**
+ * @brief 获取另一地A系的ID
+ */
+CM_UINT32 Area_Arb_Common_GetArea_A_ID(void)
+{
+    CM_UINT32 id = 0u;
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        id = (CM_UINT32)AreaArb_GetArea_A_ID();
+    }
+    else
+    {
+        id = Area_GetArea_A_ID();
+    }
+    return id;
+}
+/**
+ * @brief 获取另一地B系的ID
+ */
+CM_UINT32 Area_Arb_Common_GetArea_B_ID(void)
+{
+    CM_UINT32 id = 0u;
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        id = (CM_UINT32)AreaArb_GetArea_B_ID();
+    }
+    else
+    {
+        id = Area_GetArea_B_ID();
+    }
+    return id;
+}
+/**
+ * @brief 判断是否存在备地
+ */
+CM_BOOL Area_Arb_Common_Slave_Is_Exist(void)
+{
+    CM_BOOL rt = ENUM_CM_FALSE;
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        rt = Area_Slave_Is_Exist();
+    }
+    else
+    {
+        rt = AreaArb_Slave_Is_Exist();
+    }
+    return rt;
+}

TSCP/src/MSCP/Area/Area_Arb_Common.h

@@ -0,0 +1,31 @@
+#ifndef AREA_ARB_H_
+#define AREA_ARB_H_
+#include "Area.h"
+#include "Arb.h"
+#include "Arb_State.h"
+/**
+ * 该文件为4线模式和仲裁模式的共用头文件，用于对其他模块的通用接口
+ */
+
+/**
+ * @brief 执行初始化，4线与仲裁模式根据配置区分
+ */
+void Area_Arb_Common_Init(void);
+/**
+ * @brief 获取所有板卡区域状态，4线与仲裁模式根据配置开关从不同结构体获取
+ */
+void Area_Arb_Common_Get_All_State(STR_Area_State *p_all_State);
+/**
+ * @brief 获取另一地A系的ID，执行初始化，4线与仲裁模式根据配置区分
+ */
+CM_UINT32 Area_Arb_Common_GetArea_A_ID(void);
+/**
+ * @brief 获取另一地B系的ID，执行初始化，4线与仲裁模式根据配置区分
+ */
+CM_UINT32 Area_Arb_Common_GetArea_B_ID(void);
+/**
+ * @brief 判断是否存在备地
+ */
+CM_BOOL Area_Arb_Common_Slave_Is_Exist(void);
+
+#endif

TSCP/src/MSCP/Area/Area_Net.c

@@ -0,0 +1,237 @@
+/*
+ * Area.c
+ *
+ *  Created on: 2025年12月2日
+ *      Author: adan
+ */
+#include "CM_Types.h"
+#include "CM_Memory.h"
+#include "CM_Socket.h"
+#include "CM_UDP.h"
+#include "CM_Convert.h"
+#include "PFM_Cfg.h"
+#include "CM_Sem.h"
+#include "CM_MultiThread.h"
+#include "CM_MultiThread_Priority.h"
+#include "CM_Time.h"
+#include "DFM_Time.h"
+#include "MSCP_Define.h"
+#include "PFM_LOG.h"
+#include "DFM_Time.h"
+#include "CM_CRC32.h"
+#include "Area_Net.h"
+#include "MSCP_APP_Interface.h"
+#include "CM_MQ.h"
+#include "stdarg.h"
+
+static CM_MQ_Struct_T s_AreaLogMsgQ;
+ /**
+ * @brief UDP接收线程
+ * @param arg 指向STRU_CFM_RECV_CTRL的指针
+ * @details
+ * 创建本线程之前应先配置好STRU_CFM_RECV_CTRL，包括创建阻塞通信的socket
+ * 本线程将以阻塞方式接收UDP报文并写入线程接收队列
+ */
+ CM_THREAD_FUNC_T t_Area_2oo2_UdpRecvThread(IN CM_Thread_Arg_Struct_T* arg)
+ {
+     /*- 变量初始化 */
+ 	 STR_Area_Net_Cfg* pCtrl = (STR_Area_Net_Cfg*)arg; /* 线程控制信息 */
+     ENUM_CM_RETURN rt = ENUM_CM_FALSE; /* 函数返回值 */
+     CM_UINT8* rcvBuf = NULL;
+     CM_INT32 len; /* 报文长度 */
+     CM_UINT32 srcIP;/* 源IP */
+     CM_UINT16 srcPort;/* 源端口 */
+     CM_SOCKADDR_T addr;/* 地址转换*/
+     CM_UINT32 cpu_mask = 0;
+     /*- 本线程锁定在 A53 core 1 */
+     cpu_mask = (0x04u);
+     set_thread_affinity(cpu_mask);
+     MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP_Local, pCtrl->Port);
+     /*- 循环接收UDP数据 */
+     while (1)
+     {
+     	/*- UDP阻塞接收 */
+ 		rcvBuf = CM_MQ_Get_BufAddr(&pCtrl->MsgQ);
+ 		if(NULL != rcvBuf)
+ 		{
+ 			len = CM_UDP_Recv_Msg(pCtrl->Socket, &rcvBuf[0u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(pCtrl->MsgQ.maxMsgSize), &srcIP, &srcPort);
+ 			/*- 是否收到有效数据 */
+ 			if (len > 0)
+ 			{
+ 				/*- 源IP端口是否合法 */
+ 				if ((srcIP == inet_addr(pCtrl->IP_Pear)) && (srcPort== pCtrl->Port))
+ 				{
+ 					/*- 保存通信数据 */
+ 					rt = CM_MQ_UpData(&pCtrl->MsgQ,(CM_UINT16)CM_SIGNED_INT_EXP(len));
+ 					/*- 数据保存是否成功 */
+ 					if (ENUM_CM_TRUE == rt)
+ 					{
+ 						/*成功无操作*/
+ 					}
+ 					else
+ 					{
+ 						/*- 防御性清空*/
+ 						MSCP_LOG_MSG("port %d rx overflow(msgLen=%d),t\n", pCtrl->Port, len);
+ 						rt = CM_MQ_Clear(&pCtrl->MsgQ);
+ 						CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_1);
+ 					}
+ 				}
+ 				else
+ 				{
+ 					/*- 来自非预期IP端口的数据*/
+ 					addr.sin_addr.s_addr = srcIP;
+ 					MSCP_LOG_MSG("rx err want port:%d src [%s:%d]:%d \n", pCtrl->Port, inet_ntoa(addr.sin_addr), srcPort, len);
+ 					CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_2);
+ 				}
+ 			}
+ 			else
+ 			{
+ 				/*- 接收出错 */
+ 				MSCP_LOG_MSG("warning ASSERT1103: port %d rx err(len=%d)\n", pCtrl->Port, len);
+ 				(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1));
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/*获取队列指针失败，清空队列*/
+ 			rt = CM_MQ_Clear(&pCtrl->MsgQ);
+ 			MSCP_LOG_MSG("buf clear\n");
+ 			CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_4);
+ 		}
+     }
+     return NULL;
+ }
+
+
+ CM_THREAD_FUNC_T t_Area_UdpRecvThread(IN STR_Area_IP_Cfg* arg)
+ {
+     /*- 变量初始化 */
+	 STR_Area_IP_Cfg* pCtrl = (STR_Area_IP_Cfg*)arg; /* 线程控制信息 */
+     ENUM_CM_RETURN rt = ENUM_CM_FALSE; /* 函数返回值 */
+     CM_UINT8* rcvBuf = NULL;
+     CM_INT32 len; /* 报文长度 */
+     CM_UINT32 srcIP;/* 源IP */
+     CM_UINT16 srcPort;/* 源端口 */
+     CM_SOCKADDR_T addr;/* 地址转换*/
+
+     CM_UINT32 cpu_mask = 0;
+     /*- 本线程锁定在 A53 core 1 */
+     cpu_mask = (0x04u);
+     set_thread_affinity(cpu_mask);
+     MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP_Local, pCtrl->port);
+     /*- 循环接收UDP数据 */
+     while (1)
+     {
+     	/*- UDP阻塞接收 */
+ 		rcvBuf = CM_MQ_Get_BufAddr(&pCtrl->MsgQ);
+ 		if(NULL != rcvBuf)
+ 		{
+ 			len = CM_UDP_Recv_Msg(pCtrl->Socket, &rcvBuf[0u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(pCtrl->MsgQ.maxMsgSize), &srcIP, &srcPort);
+ 			/*- 是否收到有效数据 */
+ 			if (len > 0)
+ 			{
+ 				/*- 源IP端口是否合法 */
+ 				if ((srcIP != 0) && (srcPort != 0))
+ 				{
+ 					/*- @alias 将收到的报文写入线程接收队列 */
+// 					MSCP_LOG_MSG("!!! area recv len = %d \r\n",len);
+ 					/*- 保存通信数据 */
+ 					rt = CM_MQ_UpData(&pCtrl->MsgQ,(CM_UINT16)CM_SIGNED_INT_EXP(len));
+ 					/*- 数据保存是否成功 */
+ 					if (ENUM_CM_TRUE == rt)
+ 					{
+ 						/*成功无操作*/
+ 					}
+ 					else
+ 					{
+ 						/*- 防御性清空*/
+ 						rt = CM_MQ_Clear(&pCtrl->MsgQ);
+ 						CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_1);
+ 					}
+
+ 				}
+ 				else
+ 				{
+ 					/*- 来自非预期IP端口的数据*/
+ 					addr.sin_addr.s_addr = srcIP;
+ 					CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_2);
+ 				}
+ 			}
+ 			else
+ 			{
+ 				/*- 接收出错 */
+ 				MSCP_LOG_MSG("warning ASSERT1103: port %d rx err(len=%d)\n", pCtrl->port, len);
+ 				(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1));
+ 			}
+ 		}
+ 		else
+ 		{
+ 			/*获取队列指针失败，清空队列*/
+ 			rt = CM_MQ_Clear(&pCtrl->MsgQ);
+ 			MSCP_LOG_MSG("buf clear\n");
+ 			CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_11, TSCP_DARK_ASSERT_4);
+ 		}
+     }
+     return NULL;
+ }
+
+ ENUM_CM_RETURN Area_LogMQ_Init(void)
+ {
+	 return CM_MQ_Init(&s_AreaLogMsgQ, (CM_UINT16)CFM_INNET_LOG_SIZE, (CM_UINT16)(CFM_INNET_LOG_SIZE));
+ }
+ /**
+ * @brief 平台记录格式化字符串日志
+ * @param filename 文件路径
+ * @param func 函数名
+ * @param line 行号
+ * @param fmt 格式化字符串
+ */
+void Area_LOG_MSG(IN const CM_CHAR *filename, IN CM_INT32 line, IN const CM_CHAR* fmt, ...)
+ {
+     /*- 变量初始化 */
+     va_list argList;
+     CM_CHAR msgBuf[1024];
+     CM_INT32 headLen = 0;
+ 	CM_INT32 msgLen = 0;
+ 	if(NULL == fmt)
+ 	{
+ 		/* 无处理 */
+ 	}
+ 	else
+ 	{
+ 		/*- 记录文件名、函数名、行号 */
+ 		headLen = snprintf(msgBuf, sizeof(msgBuf), "ps_Area:%s:%d:", filename, line);
+ 		va_start(argList, (fmt));
+ 		/*- 记录日志内容 */
+ 		msgLen += vsnprintf(msgBuf + headLen, sizeof(msgBuf) - (CM_SIZE_T)headLen, fmt, argList);
+ 		va_end(argList);
+ #ifdef WIN32
+ 		Bootprintf("%s", msgBuf + headLen);
+ #endif
+ 	    /*printf("%s", msgBuf + headLen);*/
+ 	    /*- 输出日志信息 */
+ 	    CM_MQ_Write((CM_MQ_Struct_T*)&s_AreaLogMsgQ, (CM_UINT8*)msgBuf, (CM_UINT16)headLen + msgLen);
+ 	}
+ }
+ /*日志转换*/
+ void Area_LOG_Transition(void)
+ {
+ 	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+ 	CM_UINT8 buf[1024] = {0};
+ 	CM_UINT16 len = 1024;
+ 	while(1)
+ 	{
+ 		len = 1024;
+ 		rt = CM_MQ_Read(&s_AreaLogMsgQ, buf, (CM_UINT16*)&len);
+ 		if(ENUM_CM_TRUE == rt)
+ 		{
+ 		    /*- 输出日志信息 */
+ 		    (void)CFM_BaseLog_Send((CM_UINT8*)buf, len);
+ 		}
+ 		else
+ 		{
+ 			/*无处理*/
+ 			break;
+ 		}
+ 	}
+ }

TSCP/src/MSCP/Area/Area_Net.h

@@ -0,0 +1,43 @@
+#ifndef AREA_NET_H_
+#define AREA_NET_H_
+#include "CM_Types.h" 
+#include "CFM_Net.h"
+#include "CM_MQ.h"
+#include "PFM_Log.h"
+#include "CM_MultiThread.h"
+
+#define NET_UDP_BUF_MAX    ((1024*256) - (1)) /*UDP协议栈缓冲区大小（用于接收代码）*/
+#define Area_MSG_NUM_MAX (200u)
+#define Area_RAW_MSG_SIZE  (2048u)
+
+  typedef struct
+ {
+    CM_CHAR IP_Local[32];  /**< 本地通信IP */
+    CM_CHAR IP_Pear[32];  /**< 对端通信IP */
+    CM_UINT16 Port;  /**< 通信端口 */
+    CM_SOCKET Socket;  /**< 通信socket */
+    CM_MQ_Struct_T MsgQ; /**< 接收消息队列 */
+    STRU_2OO2_NET_NO_PACK_T Net_2oo2_Ctl; /**< 2oo2网络无包结构体 */
+ }STR_Area_Net_Cfg;
+
+ typedef struct
+ {
+     CM_CHAR IP_Local[32];  /**< 本地通信IP */
+     CM_CHAR IP_Partner[32];  /**< 对系通信IP */
+     CM_CHAR IP_Partner_Area_A[32];  /**< 对地通信IP */
+     CM_CHAR IP_Partner_Area_B[32];  /**< 对地通信IP */
+     CM_SOCKET Socket;  /**< 套接字 */
+     CM_UINT16 port;  /**< 端口号 */
+     CM_MQ_Struct_T MsgQ; /**< 接收消息队列 */
+ }STR_Area_IP_Cfg;
+ 
+
+ CM_THREAD_FUNC_T t_Area_2oo2_UdpRecvThread(IN CM_Thread_Arg_Struct_T* arg);
+ CM_THREAD_FUNC_T t_Area_UdpRecvThread(IN STR_Area_IP_Cfg* arg);
+ ENUM_CM_RETURN Area_LogMQ_Init(void);
+ void Area_LOG_MSG(IN const CM_CHAR *filename, IN CM_INT32 line, IN const CM_CHAR* fmt, ...);
+#define AREA_LOG_MSG(fmt, ...) (Area_LOG_MSG(FILENAME(__FILE__),(CM_INT32)__LINE__,(fmt), ##__VA_ARGS__))
+
+#endif
+
+

TSCP/src/MSCP/Area/Area_State_Vote.c

@@ -0,0 +1,287 @@
+/*
+ * Area_State_Vote.c
+ *
+ *  Created on: 2025年12月9日
+ *      Author: adan
+ */
+
+#include "Area_State_Vote.h"
+#include "PFM_LOG.h"
+#include "Area_Net.h"
+STR_Area_4x_Ctl g_Area_4x_Ctl = {0};
+
+extern STR_Area_State_Ctl g_Area_Status_Ctl[8];
+
+
+void Unknow_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+
+    CM_UINT32 Partner_BoardId = 0;
+    CM_UINT32 Area_A_BoardID = 0;
+    CM_UINT32 Area_B_BoardID = 0;
+
+    get_Other_BoardId(Local_BoardId, &Partner_BoardId, &Area_A_BoardID, &Area_B_BoardID);
+
+   if(NULL == p_Area_Status_Ctl)
+   {
+       /** 宕机 */
+	   CM_ASSERT(0,0,0,0);
+   }
+   else
+   {
+        /** 相邻地是未知地，本地是B地 */
+        if( ( (ENUM_AREA_UNKNOW == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_UNKNOW == g_Area_4x_Ctl.Partner_Area_B_state) )
+         && (MSCP_AREA_ID_B == g_Area_4x_Ctl.Area_ID) )
+        {
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+        	AREA_LOG_MSG("01 ENUM_AREA_UNKNOW >>>> ENUM_AREA_OFFLINE \r\n");
+        }
+        /** 本系上电，判断存在备地。*/
+        else if((ENUM_AREA_SLAVE == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_SLAVE == g_Area_4x_Ctl.Partner_Area_B_state)
+        || (ENUM_AREA_SLAVE == g_Area_4x_Ctl.Partner_state) )
+        {
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+        	AREA_LOG_MSG("02 ENUM_AREA_UNKNOW >>>> ENUM_AREA_OFFLINE \r\n");
+        }
+        /**不存在备地 另一地是主地  */
+        else if((ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_B_state) )
+        {
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+        	AREA_LOG_MSG("03 ENUM_AREA_UNKNOW >>>> ENUM_AREA_OFFLINE \r\n ");
+        }
+        /** 相邻地是未知地，且本地是是A地 */
+        else if( ( (ENUM_AREA_UNKNOW == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_UNKNOW == g_Area_4x_Ctl.Partner_Area_B_state) )
+                && (MSCP_AREA_ID_A == g_Area_4x_Ctl.Area_ID) )
+        {
+        	g_Area_4x_Ctl.Unknow_count++;
+        	if(g_Area_4x_Ctl.Unknow_count > MSCP_AREA_UNKNOW_COUNT_MAX)
+        	{
+        		g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+        		AREA_LOG_MSG("04 ENUM_AREA_UNKNOW >>>> ENUM_AREA_MASTER \r\n");
+        		g_Area_4x_Ctl.Unknow_count = 0;
+        	}
+        }
+        /** 相邻地是宕机 */
+        else if( ( (ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_B_state) ) )
+		{
+			g_Area_4x_Ctl.Unknow_count++;
+			if(g_Area_4x_Ctl.Unknow_count > MSCP_AREA_UNKNOW_COUNT_MAX)
+			{
+				g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+				AREA_LOG_MSG("05 ENUM_AREA_UNKNOW >>>> ENUM_AREA_MASTER \r\n");
+				g_Area_4x_Ctl.Unknow_count = 0;
+			}
+		}
+        /** 相邻地是离线 */
+        else if( ( (ENUM_AREA_OFFLINE == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_OFFLINE == g_Area_4x_Ctl.Partner_Area_B_state) ) )
+		{
+			g_Area_4x_Ctl.Unknow_count++;
+			if(g_Area_4x_Ctl.Unknow_count > MSCP_AREA_UNKNOW_COUNT_MAX)
+			{
+				g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+				AREA_LOG_MSG("06 ENUM_AREA_UNKNOW >>>> ENUM_AREA_MASTER \r\n");
+				g_Area_4x_Ctl.Unknow_count = 0;
+			}
+			else
+			{
+				;
+			}
+		}
+        else
+        {
+
+        }
+   }
+
+
+}
+
+void Offline_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+    CM_UINT32 Partner_BoardId = 0;
+    CM_UINT32 Area_A_BoardID = 0;
+    CM_UINT32 Area_B_BoardID = 0;
+
+    get_Other_BoardId(Local_BoardId, &Partner_BoardId, &Area_A_BoardID, &Area_B_BoardID);
+
+   if(NULL == p_Area_Status_Ctl)
+   {
+       /** 宕机 */
+	   CM_ASSERT(0,0,0,0);
+   }
+   else
+   {
+        /** 时间同步完成 且主用地在本地 */
+        if( ( ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_state)
+         && (1 == g_Area_4x_Ctl.sync_finish_flag) )
+        {
+        	AREA_LOG_MSG("01 ENUM_AREA_OFFLINE >>>> ENUM_AREA_MASTER \r\n");
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+        }
+        /** 本系上电，同步完成 判断存在备地。*/
+        else if((( ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_A_state) || ( ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_B_state) )
+		&& (1 == g_Area_4x_Ctl.sync_finish_flag) /*&& (MSCP_AREA_NET_HEALTH_LOW < p_Area_Status_Ctl->Net_Health)*/)
+	   {
+        	AREA_LOG_MSG("02 ENUM_AREA_OFFLINE >>>> ENUM_AREA_SLAVE \r\n");
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_SLAVE;
+	   }
+        /**不存在备地 另一地是主地  */
+        else if((ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_B_state) )
+        {
+        	AREA_LOG_MSG("03 ENUM_AREA_OFFLINE >>>> ENUM_AREA_OFFLINE \r\n");
+        	g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+        }
+        else
+        {
+        	;
+        }
+   }
+}
+
+
+void Master_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+
+	CM_UINT32 Partner_BoardId = 0;
+	CM_UINT32 Area_A_BoardID = 0;
+	CM_UINT32 Area_B_BoardID = 0;
+
+	get_Other_BoardId(Local_BoardId, &Partner_BoardId, &Area_A_BoardID, &Area_B_BoardID);
+
+   if(NULL == p_Area_Status_Ctl)
+   {
+	   AREA_LOG_MSG("01 AREA BOTH MASTER \r\n");
+	   /** 宕机 */
+	   CM_ASSERT(0,0,0,0);
+
+   }
+   else
+   {
+	   /* 双主地宕机*/
+	   if((ENUM_AREA_MASTER ==   g_Area_4x_Ctl.Partner_Area_A_state) || (ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_Area_B_state))
+	   {
+		   CM_ASSERT(0,0,0,0);
+	   }
+	   /* 预留将来 远程切系*/
+	   else
+	   {
+
+	   }
+   }
+
+
+}
+
+void Salve_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+	CM_UINT32 Partner_BoardId = 0;
+	CM_UINT32 Area_A_BoardID = 0;
+	CM_UINT32 Area_B_BoardID = 0;
+
+	get_Other_BoardId(Local_BoardId, &Partner_BoardId, &Area_A_BoardID, &Area_B_BoardID);
+
+   if(NULL == p_Area_Status_Ctl)
+   {
+	   /** 宕机 */
+	   CM_ASSERT(0,0,0,0);
+   }
+   else
+   {
+		/** 数据同步失败 */
+		if(0 == g_Area_4x_Ctl.Sync_Fail_Flag)
+		{
+			AREA_LOG_MSG("01 ENUM_AREA_SLAVE >>>> ENUM_AREA_OFFLINE \r\n");
+			g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+		}
+#if 0
+		/** 本系上电，判断存在备地。*/
+		else if(MSCP_AREA_NET_HEALTH_LOW > p_Area_Status_Ctl->Net_Health)
+	   {
+			AREA_LOG_MSG("02 ENUM_AREA_SLAVE >>>> ENUM_AREA_OFFLINE \r\n");
+			g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
+	   }
+#endif
+		/**主用主 宕机 且四线同时中断 */
+		else if((ENUM_AREA_SHUTDOWN ==   g_Area_4x_Ctl.Partner_Area_A_state) && (ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_B_state)
+				&&(MSCP_AREA_NET_SYNC_ERR_FLAG ==  g_Area_Status_Ctl[Area_A_BoardID].Net_ERR_FLAG)
+				&& (MSCP_AREA_NET_SYNC_ERR_FLAG == g_Area_Status_Ctl[Area_B_BoardID].Net_ERR_FLAG) )
+		{
+			AREA_LOG_MSG("03 ENUM_AREA_SLAVE >>>> ENUM_AREA_MASTER \r\n");
+			g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+		}
+		/*本地是备地 但是相邻地是主地*/
+		else if((ENUM_AREA_SLAVE == g_Area_4x_Ctl.Local_state) && (ENUM_AREA_MASTER == g_Area_4x_Ctl.Partner_state))
+		{
+			AREA_LOG_MSG("04 ENUM_AREA_SLAVE >>>> ENUM_AREA_MASTER \r\n");
+			g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+		}
+		/**主用主 宕机 且四线非同时中断 */
+		else if((ENUM_AREA_SHUTDOWN ==   g_Area_4x_Ctl.Partner_Area_A_state) && (ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_B_state)
+				&& ( ( MSCP_AREA_NET_ASYNC_ERR_FLAG == g_Area_Status_Ctl[Area_A_BoardID].Net_ERR_FLAG)
+				|| ( MSCP_AREA_NET_ASYNC_ERR_FLAG == g_Area_Status_Ctl[Area_B_BoardID].Net_ERR_FLAG) )/*&& (  四线同事中断)*/)
+		{
+			AREA_LOG_MSG("05 ENUM_AREA_SLAVE >>>> ENUM_AREA_SHUTDOWN \r\n");
+			CM_ASSERT(0,0,0,0);
+		}
+		/* 本系为备地 对地两系都不是主地 备地升主*/
+		else if(((ENUM_AREA_OFFLINE ==   g_Area_4x_Ctl.Partner_Area_A_state) && (ENUM_AREA_OFFLINE == g_Area_4x_Ctl.Partner_Area_B_state))
+				||((ENUM_AREA_OFFLINE == g_Area_4x_Ctl.Partner_Area_A_state)&&((ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_B_state) && (MSCP_AREA_NET_SYNC_ERR_FLAG == g_Area_Status_Ctl[Area_B_BoardID].Net_ERR_FLAG)))
+				||(((ENUM_AREA_SHUTDOWN == g_Area_4x_Ctl.Partner_Area_A_state) && (MSCP_AREA_NET_SYNC_ERR_FLAG == g_Area_Status_Ctl[Area_A_BoardID].Net_ERR_FLAG))&&(ENUM_AREA_OFFLINE == g_Area_4x_Ctl.Partner_Area_B_state)))
+		{
+			AREA_LOG_MSG("06 ENUM_AREA_SLAVE >>>> ENUM_AREA_MASTER \r\n");
+			g_Area_4x_Ctl.Local_state = ENUM_AREA_MASTER;
+		}
+		else
+		{
+			AREA_LOG_MSG("07 ENUM_AREA_SLAVE >>>> ENUM_AREA_SLAVE \r\n");
+		}
+   }
+}
+
+
+void ShtuDown_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+	/* 预留将来 远程切系*/
+	  if(NULL == p_Area_Status_Ctl)
+	   {
+		   /** 宕机 */
+		  CM_ASSERT(0,0,0,0);
+	   }
+	   else
+	   {
+		   g_Area_4x_Ctl.Local_state = ENUM_AREA_UNKNOW;
+	   }
+}
+
+void Area_vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId)
+{
+        /*获取当前通道状态*/
+
+        switch(g_Area_4x_Ctl.Local_state)
+        {
+            case ENUM_AREA_SHUTDOWN:
+            	ShtuDown_Vote(p_Area_Status_Ctl, Local_BoardId);
+                break;
+            case ENUM_AREA_UNKNOW:
+            	Unknow_Vote(p_Area_Status_Ctl, Local_BoardId);
+                break;
+            case ENUM_AREA_OFFLINE:
+            	Offline_Vote(p_Area_Status_Ctl, Local_BoardId);
+                break;
+            case ENUM_AREA_MASTER:
+            	Master_Vote(p_Area_Status_Ctl, Local_BoardId);
+                break;
+            case ENUM_AREA_SLAVE:
+            	Salve_Vote(p_Area_Status_Ctl, Local_BoardId);
+                break;
+
+        }
+
+}
+
+
+
+
+
+
+

TSCP/src/MSCP/Area/Area_State_Vote.h

@@ -0,0 +1,33 @@
+/*
+ * Area_State_Vote.h
+ *
+ *  Created on: 2025年12月9日
+ *      Author: adan
+ */
+
+#ifndef MSCP_AREA_AREA_STATE_VOTE_H_
+#define MSCP_AREA_AREA_STATE_VOTE_H_
+
+#include "CM_Types.h"
+#include "Area_state.h"
+
+
+
+typedef struct
+{
+	ENUM_AREA_STATE Local_state;/**< 区域状态*/
+    ENUM_AREA_STATE Partner_state;/**< 区域状态*/
+    ENUM_AREA_STATE Partner_Area_A_state;/**< 区域状态*/
+    ENUM_AREA_STATE Partner_Area_B_state;/**< 区域状态*/
+    CM_UINT32 Unknow_count;/**< 未知状态计数*/
+    CM_UINT8 Area_ID;/**< 区域ID*/
+    CM_INT32 sync_finish_flag;  /**< 同步完成标识 */
+    CM_INT32 Sync_Fail_Flag;  /**< 同步失败标识 */
+}STR_Area_4x_Ctl;
+
+extern STR_Area_4x_Ctl g_Area_4x_Ctl;
+
+
+void Area_vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId);
+
+#endif /* MSCP_AREA_AREA_STATE_VOTE_H_ */

TSCP/src/MSCP/Area/Area_state.h

@@ -0,0 +1,91 @@
+/*
+ * Area_state.h
+ *
+ *  Created on: 2025年12月9日
+ *      Author: adan
+ */
+
+#ifndef MSCP_AREA_AREA_STATE_H_
+#define MSCP_AREA_AREA_STATE_H_
+#include "CM_Types.h"
+
+#define MSCP_AREA_NET_A 0  /**< 区域通信A网 */
+#define MSCP_AREA_NET_B 1  /**< 区域通信B网 */
+
+#define MSCP_AREA_NET_OK 0x05u  /**< 网络状态正常 */
+#define MSCP_AREA_NET_FILD 0x0au  /**< 网络状态不正常 */
+
+#define MSCP_AREA_DEVICE_MAX   0x04 /**< 区域设备最大数量 */
+
+#define MSCP_AREA_ID_A  0x05  /**< A地区域通信id */
+#define MSCP_AREA_ID_B  0x0A  /**< B地区域通信id */
+
+#define MSCP_AREA_A_BOARD_ID_A  0x01
+#define MSCP_AREA_A_BOARD_ID_B  0x02
+#define MSCP_AREA_B_BOARD_ID_A  0x03
+#define MSCP_AREA_B_BOARD_ID_B  0x04
+
+#define MSCP_AREA_UNKNOW_COUNT_MAX  0x0au
+
+#define MSCP_MSG_BUF_MAX  1024u /**< 区域通信消息最大缓冲区大小 */
+
+#define MSCP_AREA_NET_HEALTH_LOW  0x02u
+#define MSCP_AREA_NET_HEALTH_MAX  0x02u
+
+
+#define MSCP_AREA_TIME_SYNC_OK   0x01u
+
+#define MSCP_AREA_NET_SYNC_ERR_FLAG    0x01u /*网络同时故障宏*/
+#define MSCP_AREA_NET_ASYNC_ERR_FLAG   0x00u /*网络非同时故障宏*/
+/*定义枚举型函数返回值*/
+typedef enum
+{
+	ENUM_AREA_SHUTDOWN 	= 0x00u,
+	ENUM_AREA_UNKNOW  = 0x01u,   /**< 未知地 */
+	ENUM_AREA_OFFLINE = 0x02u,  /**< 离线地 */
+	ENUM_AREA_MASTER  = 0x03u,  /**< 主地 */
+	ENUM_AREA_SLAVE   = 0x04u    /**< 备地 */
+}ENUM_AREA_STATE;
+
+#pragma pack(1) /** 声明为一字节对齐 */
+typedef struct
+{
+    CM_UINT16 len;  /**< 消息长度 */
+    CM_UINT8 msgType;  /**< 消息类型 */
+    CM_UINT64 arqCount;  /**< 区域通信请求序号 */
+    CM_UINT32 srcId;  /**< 源ID */
+    CM_UINT32 destId;  /**< 目的ID */
+    ENUM_AREA_STATE Localstate;  /**< 区域状态 */
+    CM_INT32 sync_finish_flag;  /**< 同步完成标识 */
+    CM_UINT32 crc1;/**< 校验和1 */
+    CM_UINT32 crc2;/**< 校验和2 */
+    CM_UINT8 reserver[8];/**< 保留字段 */
+    CM_UINT32 crc;  /**< 校验和 */
+}STR_Area_Req;
+#pragma pack()
+
+
+typedef struct
+{
+//	ENUM_AREA_STATE state;/**< 区域状态*/
+    CM_UINT8 Area_ID;/**< 区域ID*/
+
+    CM_UINT8 Local_Net_A_state;/**< 本地 A 网网络状态*/
+    CM_UINT32 Local_Net_A_state_ErrCnt;/**< 本地 A 网网络错误状态计数器*/
+    CM_UINT8 Local_Net_B_state;/**< 本地B 网网络状态*/
+    CM_UINT32 Local_Net_B_state_ErrCnt;/**< 本地 B 网网络错误状态计数器*/
+    CM_UINT8 Peer_Net_A_state;/**<  邻机 A 网网络状态*/
+    CM_UINT32 Peer_Net_A_state_ErrCnt;/**< 邻机 A 网网络错误状态计数器*/
+    CM_UINT8 Peer_Net_B_state;/**<  邻机 B 网网络状态*/
+    CM_UINT32 Peer_Net_B_state_ErrCnt;/**< 邻机 B 网网络错误状态计数器*/
+
+    CM_UINT32 Net_Health;/**< 网络健康状态*/
+    CM_UINT32 Net_ERR_FLAG;/**< 网络4线同时中断标志位状态，有3根线。4根线存在认为正常，其余情况都是非同时中断*/
+
+    CM_UINT8 send_buf[MSCP_MSG_BUF_MAX];/**< 发送缓冲区*/
+    CM_UINT8 recv_buf[MSCP_MSG_BUF_MAX];/**< 接收缓冲区*/
+
+    STR_Area_Req Area_Req ;
+}STR_Area_State_Ctl;
+
+#endif /* MSCP_AREA_AREA_STATE_H_ */

TSCP/src/MSCP/CFM/CFM_Net.c

@@ -98,7 +98,8 @@ typedef struct
 
 /** 2乘线程控制*/
 static STRU_CFM_RECV_CTRL_T s_CFM_Rx2x2;         		/**<  2x2数据通信接收线程控制 */
-static STRU_CFM_RECV_CTRL_T s_CFM_State2x2;         		/**<  2x2数据通信接收线程控制 */
+static STRU_CFM_RECV_CTRL_T s_CFM_State2x2;         	/**<  2x2状态数据通信接收线程控制 */
+static STRU_CFM_RECV_CTRL_T s_CFM_State2x2Extend;		/**<  2x2状态数据扩展通信接收线程控制 */
 /** 2取线程控制*/
 static STRU_CFM_RECV_CTRL_T s_CFM_Rx2oo2;        		/**< 2oo2数据通信接收线程控制 */
 static STRU_CFM_RECV_CTRL_T s_CFM_Rx2oo2_App;        /**< 应用2oo2数据通信接收线程控制 */
@@ -119,23 +120,10 @@ static STRU_CFM_SEND_DARKLOG s_Log_CtrlQ;
 
 /*注册透传算法函数指针数组*/
 RAW_ALGORITHM p_ALGORITHM_Fun[INNET_RAW_DOUBLE_PASS_NUM] = {NULL};
-/** 时钟同步控制 */
-typedef struct
-{
-    CM_CHAR IP[32];    /* 本机IP */
-    CM_UINT16 port;    /* 本机端口 */
-    CM_SOCKET* pSock;  /* 本地socket */
-
-    /*
-    * delay和offset受互斥信号量mutex保护，
-    * 读写delay和offset时需要先取得互斥信号量
-    */
-    CM_MUTEX_T mutex;       /* 互斥信号量 */
-    ENUM_CM_RETURN isOK;  /* 校时成功标志 */
-    CM_INT64 delay;       /* 延迟时间 */
-    CM_INT64 offset;      /* 偏移时间 */
-
-}STRU_CFM_TIME_CTRL_T;
+/*发送2x2状态扩展通道数据，注册函数指针*/
+EXTEND_DATA_SEND p_2x2_ExtendDataSend;
+/*接收2x2状态扩展通道数据，注册函数指针*/
+EXTEND_DATA_RECV p_2x2_ExtendDataRecv;
 
 /** 周期同步控制 */
 typedef struct
@@ -155,16 +143,17 @@ typedef struct
 /** 通信层socket管理 */
 typedef struct
 {
-    CM_SOCKET Sock_2oo2_Time;        /**< 2oo2校时socket */
     CM_SOCKET Sock_2oo2_Data;        /**< 2oo2数据通信socket */
 	CM_SOCKET Sock_2oo2_Data_App;    /**< 应用2oo2数据通信socket */
 	CM_SOCKET Sock_2oo2_Maintenance; /**< 2oo2维护模式socket */
 	CM_SOCKET Sock_2oo2_2x2_State;   /**< 2oo2上电同步socket */
 
-    CM_SOCKET Sock_2x2_Time;       /**< 2x2校时socket */
-    CM_SOCKET Sock_2x2_Data;       /**< 2x2数据通信socket */
-    CM_SOCKET Sock_2x2_Syn;        /**< 2x2周期同步socket */
-    CM_SOCKET Sock_2x2_State;      /**< 2x2状态切换socket */
+    CM_SOCKET Sock_4x2_Data_Send;   /**< 4x2数据通信socket */
+    CM_SOCKET Sock_4x2_Data_Rcv;    /**< 4x2数据通信socket */
+    CM_SOCKET Sock_4x2_Syn_Send;    /**< 4x2周期同步socket */
+    CM_SOCKET Sock_4x2_Syn_Rcv;     /**< 4x2周期同步socket */
+    CM_SOCKET Sock_2x2_State;       /**< 2x2状态切换socket */
+    CM_SOCKET Sock_2x2_State_Extend;/**< 2x2状态切换扩展socket */
 
     CM_SOCKET Sock_InnetSafe;      /**< 内网安全通信socket */
     CM_SOCKET Sock_OutnetSafe;     /**< 外网安全通信socket */
@@ -183,8 +172,6 @@ typedef struct
 
 static STRU_CFM_SOCKS_T s_CFM_Sock; /**< 通信层socket管理 */
 
-static STRU_CFM_TIME_CTRL_T s_CFM_2oo2_Time; 	/**< 2oo2时钟同步控制 */
-static STRU_CFM_TIME_CTRL_T s_CFM_2x2_Time;  	/**< 2x2时钟同步控制 */
 static STRU_CFM_SYN_CTRL_T s_CFM_2x2_Syn; 		/**< 2x2周期同步控制 */
 
 static CM_UINT8 s_CFM_UDP_Cache[65535]; /**< 临时缓冲区 */
@@ -197,15 +184,6 @@ STRU_HARDWARE_BOOT_COM_T g_Hardware_boot_com_state;
 * @brief 2oo2相关网络通信初始化
 */
 static void s_NetInit_2oo2(void);
-/**
-* @brief 通用2oo2数据发送
-* @param pBuf 发送报文指针 取值范围：非空
-* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
-* @return 发送结果
-* - ENUM_CM_TRUE 成功
-* - ENUM_CM_FALSE 失败
-*/
-static ENUM_CM_RETURN CFM_2oo2_Send_Currency(IN CM_SOCKET sock,IN const CM_UINT8* pBuf, IN CM_INT32 BufLen,IN CM_UINT16 nPortDest);
 
 /**
 * @brief 2oo2重传请求与应答ACK发送
@@ -233,6 +211,16 @@ static void s_NetInit_2x2(void);
 * @see :: CFM_2x2_SyncRecv
 */
 static CM_THREAD_FUNC_T t_SyncThread(IN CM_Thread_Arg_Struct_T* arg);
+/**
+* @brief 数据接收通用接口
+* @param *ctrl 控制结构体
+* @param pBuf 接收报文指针
+* @param BufLen 接收报文缓冲区大小
+* @return 接收报文长度
+* - 正整数 接收报文长度
+* - 0 接收失败
+*/
+static CM_INT32 CFM_Recv_ComInterface(STRU_CFM_RECV_CTRL_T *pctrl,OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize,CM_UINT16 Offset);
 
 /*********************************内网通信相关*****************************************/
 
@@ -297,20 +285,6 @@ static CM_THREAD_FUNC_T t_UdpRecvThread(IN CM_Thread_Arg_Struct_T* arg);
 */
 static CM_THREAD_FUNC_T t_UdpRecvMaintenanceThread(IN CM_Thread_Arg_Struct_T* arg);
 
-/**
-* @brief 时钟同步线程
-* @param arg 指向STRU_CFM_TIME_CTRL的指针
-* @return 线程函数返回值（实际永远不会返回）
-* @details
-* 创建本线程之前应先配置好STRU_CFM_TIME_CTRL，包括创建阻塞通信的socket
-* 本线程将以阻塞方式接收时钟同步报文并作出应答
-* 收到请求报文时立即给出应答
-* 收到应答报文时记录并计算延迟时间、偏移时间
-* @see :: CFM_2oo2_TimeReq
-* @see :: CFM_2oo2_TimeGet
-*/
-static CM_THREAD_FUNC_T t_TimeThread(IN CM_Thread_Arg_Struct_T* arg);
-
 /**
 * @brief 远程部署接收线程
 * @param arg 指向STRU_CFM_RECV_CTRL的指针
@@ -332,27 +306,25 @@ static void s_NetInit_2oo2(void)
     CM_INT32 val = 0;                   /* 临时变量 */
     CM_BOOL rtCheck = CM_FALSE;         /* 临时变量 */
 
-    /*- 创建时间同步socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Time, 		CM_FALSE,(CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Time, 	0u, (CM_UINT8)0u);
-    CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_1);
     /*- 创建平台数据2取socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Data, 		CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Data, 	0u, (CM_UINT8)0u);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Data, 		CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Data, 	0u, (CM_UINT8)1u);
     CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_2);
     /*- 创建应用数据2取socket */
-	rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Data_App, 	CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Data_App, 0u, (CM_UINT8)0u);
+	rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Data_App, 	CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Data_App, 0u, (CM_UINT8)1u);
 	CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_3);
     /*- 创建2x状态2取socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_2x2_State, 	CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_2x2_State,0u, (CM_UINT8)0u);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_2x2_State, 	CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_2x2_State,0u, (CM_UINT8)1u);
     CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_6);
 
 	if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
 	{
 		/*- 创建维护模式下的2取socket */
-	    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Maintenance, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Maintenance, 0u, (CM_UINT8)0u);
+	    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Maintenance, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Maintenance, 0u, (CM_UINT8)1u);
 	    CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_18);
 	}
 	else
 	{
+
 		/*- 无处理 */
 	}
 
@@ -363,16 +335,6 @@ static void s_NetInit_2oo2(void)
     (void)setsockopt(s_CFM_Sock.Sock_2oo2_Data_App, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
     (void)setsockopt(s_CFM_Sock.Sock_2oo2_Data_App, SOL_SOCKET, SO_SNDBUF, (void*)(&val), (unsigned int)sizeof(val));
     /*- 初始化控制信息 */
-    CM_NM_ASSERT(s_CFM_2oo2_Time.IP != NULL, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_7);
-    (void)sprintf(s_CFM_2oo2_Time.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2oo2);
-    s_CFM_2oo2_Time.port = g_PFM_Cfg.Local_Cfg.Port_2oo2_Time;
-    s_CFM_2oo2_Time.pSock = &s_CFM_Sock.Sock_2oo2_Time;
-    rt = CM_Mutex_Init(&s_CFM_2oo2_Time.mutex);
-    CM_NM_ASSERT(ENUM_CM_TRUE == rt,NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_8);
-
-    /*- 启动2oo2时钟同步线程 */
-    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_TimeThread, "2oo2_T", 0, CM_TASK_PRIORITY_72, (CM_Thread_Arg_Struct_T*)&s_CFM_2oo2_Time);
-    CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_11);
 
     /*- 配置接收线程 */
     CM_NM_ASSERT(s_CFM_Rx2oo2.IP != NULL, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_9);
@@ -486,69 +448,6 @@ ENUM_CM_RETURN CFM_2oo2_InitSync(void)
     return SyncFlag;
 }
 
-/**
-* @brief 发起一次2oo2时钟同步
-* @details
-* 发送一个2oo2时钟同步请求报文
-* 由双方的时钟同步线程完成一次NTP校时操作
-* 操作完成后本方的时钟同步线程会记录到延迟时间和偏移时间
-* @see :: CFM_2oo2_TimeGet
-* @see :: t_TimeThread
-*/
-void CFM_2oo2_TimeReq(void)
-{
-    /*- 变量初始化 */
-    CM_UINT8 buf[100];
-    CM_INT32 len = 0;
-    CM_ATOMIC CM_UINT64 tick = 0u;
-
-    /*- 生成时钟同步请求报文 */
-    len = 9;
-    buf[0] = (CM_UINT8)ENUM_TIME_REQ;
-
-    tick = DFM_GetCycTick();
-
-    CM_64ToChar(tick, buf + 1);
-    /*- 发送时钟同步请求报文 */
-    (void)CM_UDP_Send_Msg(s_CFM_Sock.Sock_2oo2_Time, buf, len, inet_addr(g_PFM_Cfg.Peer_Cfg.IP_2oo2),g_PFM_Cfg.Peer_Cfg.Port_2oo2_Time);
-}
-
-/**
-* @brief 读取时钟同步结果
-* @param pDelay 延迟时间
-* @param pOffset 偏移时间
-* @return 执行结果
-* - ENUM_CM_TRUE 成功
-* - ENUM_CM_FALSE 失败
-*/
-ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
-{
-    /*- 变量初始化 */
-    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-
-    /*- 锁定互斥锁 */
-    rt = CM_Mutex_Lock(s_CFM_2oo2_Time.mutex);
-    CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_1);
-    /*- 是否保存了时钟同步结果 */
-    if (ENUM_CM_TRUE == s_CFM_2oo2_Time.isOK)
-    {
-        /*- 读取时钟同步结果 */
-        *pDelay = s_CFM_2oo2_Time.delay;
-        *pOffset = s_CFM_2oo2_Time.offset;
-        /*- 清除时钟同步结果 */
-        s_CFM_2oo2_Time.isOK = ENUM_CM_FALSE;
-        rt = ENUM_CM_TRUE;
-    }
-    else
-	{
-		/*- 无处理 */
-	}
-    /*- 释放互斥锁 */
-    rt = CM_Mutex_Unlock(s_CFM_2oo2_Time.mutex);
-    CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_15, TSCP_DARK_ASSERT_2);
-    /*- 返回执行结果 */
-    return rt;
-}
 /**
 * @brief 通用2oo2数据发送
 * @param pBuf 发送报文指针 取值范围：非空
@@ -557,7 +456,7 @@ ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败
 */
-static ENUM_CM_RETURN CFM_2oo2_Send_Currency(IN CM_SOCKET sock,IN const CM_UINT8* pBuf, IN CM_INT32 BufLen,IN CM_UINT16 nPortDest)
+ENUM_CM_RETURN CFM_2oo2_Send_Currency(IN CM_SOCKET sock,IN const CM_UINT8* pBuf, IN CM_INT32 BufLen,IN CM_UINT16 nPortDest)
 {
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
@@ -998,76 +897,142 @@ static void s_NetInit_2x2(void)
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE; /* 临时变量 */
     CM_INT32 val = 0;                  /* 临时变量 */
-    CM_BOOL rtCheck = CM_FALSE;         /* 临时变量 */
-    /*- 创建socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_Time, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2x2), g_PFM_Cfg.Local_Cfg.Port_2x2_Time, 0u, (CM_UINT8)0);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+    CM_BOOL rtCheck = CM_FALSE;        /* 临时变量 */
+    /*判断使用组播还是单拨*/
+    if(0 == g_PFM_Cfg.Multicast_Flag)
+    {
+        /*使用单播发送4x2数据*/
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Data_Send, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send, 0, ENUM_UNICAST);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
 
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_Data, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2x2), g_PFM_Cfg.Local_Cfg.Port_2x2_Data, 0u, (CM_UINT8)0);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_2);
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_Syn, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2x2), g_PFM_Cfg.Local_Cfg.Port_2x2_Syn, 0u, (CM_UINT8)0);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_3);
-    /*- 创建2x状态切换独立线程socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_State, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2x2), g_PFM_Cfg.Local_Cfg.Port_2x2_State, 0u, (CM_UINT8)0);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_13);
+        /*使用单播发送4x2同步信息*/
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Syn_Send, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Send, 0, ENUM_UNICAST);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_3);
+        /*- 配置socket */
+        val = (CM_INT32)(NET_UDP_BUF_DOUBLESIZE);
+        (void)setsockopt(s_CFM_Sock.Sock_4x2_Data_Rcv, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
+        (void)setsockopt(s_CFM_Sock.Sock_4x2_Syn_Send,SOL_SOCKET, SO_SNDBUF, (void*)(&val), (unsigned int)sizeof(val));
 
-    /*- 初始化控制信息 */
-    CM_ASSERT(s_CFM_2x2_Time.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_4);
-	(void)sprintf(s_CFM_2x2_Time.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2x2);
-	s_CFM_2x2_Time.port = g_PFM_Cfg.Local_Cfg.Port_2x2_Time;
-	s_CFM_2x2_Time.pSock = &s_CFM_Sock.Sock_2x2_Time;
-	rt = CM_Mutex_Init(&s_CFM_2x2_Time.mutex);
+        /*配置接收同步报文线程参数*/
+        CM_ASSERT(s_CFM_2x2_Syn.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_6);
+        (void)sprintf(s_CFM_2x2_Syn.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_4x2);
+        s_CFM_2x2_Syn.port = g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Send;
+        s_CFM_2x2_Syn.pSock = &s_CFM_Sock.Sock_4x2_Syn_Send;
+        rt = CM_Mutex_Init(&s_CFM_2x2_Syn.mutex);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_7);
+
+        /*- 配置接收线程 */
+        CM_ASSERT(s_CFM_Rx2x2.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_8);
+        (void)sprintf(s_CFM_Rx2x2.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_4x2);
+        s_CFM_Rx2x2.port = g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send;
+        s_CFM_Rx2x2.pSock = &s_CFM_Sock.Sock_4x2_Data_Send;
+        s_CFM_Rx2x2.rmtIP = 0;
+        s_CFM_Rx2x2.rmtPort = g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send;
+        rt = CM_MQ_Init(&s_CFM_Rx2x2.MsgQ, (CM_UINT16)CFM_2X2_MSG_NUM_MAX, (CM_UINT16)NET_UDP_2X2_BUF_SIZE);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_9);
+
+    }
+    else
+    {
+        /*使用组播发送4x2数据*/
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Data_Send, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast), ENUM_MULTICAST_SEND);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1);
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Data_Rcv, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Rcv, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast), ENUM_MULTICAST_RCV);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_2);
+        /*使用组播发送4x2同步信息*/
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Syn_Send, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Send, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast), ENUM_MULTICAST_SEND);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_3);
+        rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_4x2_Syn_Rcv, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Rcv, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast), ENUM_MULTICAST_RCV);
+        CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_4);
+
+        /*- 配置socket */
+       val = (CM_INT32)(NET_UDP_BUF_DOUBLESIZE);
+       (void)setsockopt(s_CFM_Sock.Sock_4x2_Data_Rcv, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
+       (void)setsockopt(s_CFM_Sock.Sock_4x2_Data_Send,SOL_SOCKET, SO_SNDBUF, (void*)(&val), (unsigned int)sizeof(val));
+
+       /*配置接收同步报文线程参数*/
+       CM_ASSERT(s_CFM_2x2_Syn.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_6);
+       (void)sprintf(s_CFM_2x2_Syn.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_4x2);
+       s_CFM_2x2_Syn.port = g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Rcv;
+       s_CFM_2x2_Syn.pSock = &s_CFM_Sock.Sock_4x2_Syn_Rcv;
+       rt = CM_Mutex_Init(&s_CFM_2x2_Syn.mutex);
+       CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_7);
+
+       /*- 配置接收线程 */
+       CM_ASSERT(s_CFM_Rx2x2.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_8);
+       (void)sprintf(s_CFM_Rx2x2.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_4x2);
+       s_CFM_Rx2x2.port = g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Rcv;
+       s_CFM_Rx2x2.pSock = &s_CFM_Sock.Sock_4x2_Data_Rcv;
+       s_CFM_Rx2x2.rmtIP = 0;
+       s_CFM_Rx2x2.rmtPort = g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send;
+       rt = CM_MQ_Init(&s_CFM_Rx2x2.MsgQ, (CM_UINT16)CFM_2X2_MSG_NUM_MAX, (CM_UINT16)NET_UDP_2X2_BUF_SIZE);
+       CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_9);
+    }
+
+
+	/*- 创建2x状态切换独立线程socket */
+	rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_State, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_2x2_State, 0u, ENUM_UNICAST);
 	CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_5);
 
-    /*- 配置socket */
-    val = (CM_INT32)(NET_UDP_BUF_DOUBLESIZE);
-    (void)setsockopt(s_CFM_Sock.Sock_2x2_Data, SOL_SOCKET, SO_RCVBUF, (void*)(&val), (unsigned int)sizeof(val));
-    (void)setsockopt(s_CFM_Sock.Sock_2x2_Data, SOL_SOCKET, SO_SNDBUF, (void*)(&val), (unsigned int)sizeof(val));
-
-    CM_ASSERT(s_CFM_2x2_Syn.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_6);
-    (void)sprintf(s_CFM_2x2_Syn.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2x2);
-    s_CFM_2x2_Syn.port = g_PFM_Cfg.Local_Cfg.Port_2x2_Syn;
-    s_CFM_2x2_Syn.pSock = &s_CFM_Sock.Sock_2x2_Syn;
-    rt = CM_Mutex_Init(&s_CFM_2x2_Syn.mutex);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_7);
-
-    /*- 配置接收线程 */
-    CM_ASSERT(s_CFM_Rx2x2.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_8);
-    (void)sprintf(s_CFM_Rx2x2.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2x2);
-    s_CFM_Rx2x2.port = g_PFM_Cfg.Local_Cfg.Port_2x2_Data;
-    s_CFM_Rx2x2.pSock = &s_CFM_Sock.Sock_2x2_Data;
-    s_CFM_Rx2x2.rmtIP = inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2);
-    s_CFM_Rx2x2.rmtPort = g_PFM_Cfg.Partner_Cfg.Port_2x2_Data;
-    rt = CM_MQ_Init(&s_CFM_Rx2x2.MsgQ, (CM_UINT16)CFM_2X2_MSG_NUM_MAX, (CM_UINT16)NET_UDP_2X2_BUF_SIZE);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_9);
 
     /*-配置状态切换线程 */
-    CM_ASSERT(s_CFM_State2x2.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_14);
-    (void)sprintf(s_CFM_State2x2.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2x2);
+    CM_ASSERT(s_CFM_State2x2.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_10);
+    (void)sprintf(s_CFM_State2x2.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_4x2);
     s_CFM_State2x2.port = g_PFM_Cfg.Local_Cfg.Port_2x2_State;
     s_CFM_State2x2.pSock = &s_CFM_Sock.Sock_2x2_State;
-    s_CFM_State2x2.rmtIP = inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2);
+    s_CFM_State2x2.rmtIP = inet_addr(g_PFM_Cfg.Partner_Cfg.IP_4x2);
     s_CFM_State2x2.rmtPort = g_PFM_Cfg.Partner_Cfg.Port_2x2_State;
     s_CFM_State2x2.threadNumBer = (CM_UINT8)ENUM_THREAD_2x2_StateRecv;
     rt = CM_MQ_Init(&s_CFM_State2x2.MsgQ, (CM_UINT16)CFM_2X2_MSG_NUM_MAX, (CM_UINT16)CFM_2X2_MSG_NUM_MAX);
-    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_15);
+    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_11);
 
-    /*- 启动2x2时钟同步线程 */
-    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_TimeThread, "2x2_T", 0, CM_TASK_PRIORITY_76, (CM_Thread_Arg_Struct_T*)&s_CFM_2x2_Time);
-    CM_ASSERT(CM_TRUE == rtCheck,NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_10);
-    CM_Sleep(100u);/* 延时等待线程启动 */
     /*- 启动2x2周期同步线程 */
     rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_SyncThread, "2x2_Syn", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_2x2_Syn);
-    CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_16);
-    CM_Sleep(100u);/* 延时等待线程启动 */
-
-    /*- 启动2x2平台数据接收线程 */
-    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2x2_Rx", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_Rx2x2);
-    CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_11);
-    /*- 启动2x2平台数据接收线程 */
-    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2x2_RxState", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_State2x2);
     CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_12);
     CM_Sleep(100u);/* 延时等待线程启动 */
+    /*- 启动2x2平台数据接收线程 */
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2x2_Rx", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_Rx2x2);
+    CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_13);
+    /*- 启动2x2状态数据接收线程 */
+    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2x2_RxState", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_State2x2);
+    CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_14);
+    CM_Sleep(100u);/* 延时等待线程启动 */
+	/*初始化以太网*/
+	if(0x01 == g_PFM_Cfg.M_2x2_Com_Cfg)
+	{
+		/*- 创建2x状态切换独立线程socket */
+		rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2x2_State_Extend, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area), g_PFM_Cfg.Local_Cfg.Port_2x2_State, 0u, ENUM_UNICAST);
+		CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_13);
+	    /*-配置状态切换线程 */
+	    CM_ASSERT(s_CFM_State2x2Extend.IP != NULL, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_15);
+	    (void)sprintf(s_CFM_State2x2Extend.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_Area);
+	    s_CFM_State2x2Extend.port = g_PFM_Cfg.Local_Cfg.Port_2x2_State;
+	    s_CFM_State2x2Extend.pSock = &s_CFM_Sock.Sock_2x2_State_Extend;
+	    s_CFM_State2x2Extend.rmtIP = inet_addr(g_PFM_Cfg.Partner_Cfg.IP_Area);
+	    s_CFM_State2x2Extend.rmtPort = g_PFM_Cfg.Partner_Cfg.Port_2x2_State;
+	    s_CFM_State2x2Extend.threadNumBer = (CM_UINT8)ENUM_THREAD_2x2_StateRecv;
+	    rt = CM_MQ_Init(&s_CFM_State2x2Extend.MsgQ, (CM_UINT16)CFM_2X2_MSG_NUM_MAX, (CM_UINT16)CFM_2X2_MSG_NUM_MAX);
+	    CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_16);
+	    /*- 启动2x2状态数据接收线程 */
+	    rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2x2_RxState", 0, CM_TASK_PRIORITY_77, (CM_Thread_Arg_Struct_T*)&s_CFM_State2x2Extend);
+	    CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_17);
+	    CM_Sleep(100u);/* 延时等待线程启动 */
+	    /*注册函数指针*/
+	    p_2x2_ExtendDataSend = CFM_2x2_StateChangeExtend_Send;
+	    p_2x2_ExtendDataRecv = CFM_2x2_StateChangeExtend_Recv;
+	}
+	else/*初始化串口*/
+	{
+#ifdef QNX
+		/*- 串口通信初始化*/
+		(void)CM_COM_INIT(115200u, 8u);
+		/*- 开启临机串口接收线程*/
+		CM_Com_RcvOtherThreadInit();
+		/*注册函数指针*/
+	    p_2x2_ExtendDataSend = CM_Com_LocalDataSend;
+	    p_2x2_ExtendDataRecv = CM_Com_OtherDataRecv;
+#endif /*QNX*/
+	}
 
 }
 
@@ -1087,7 +1052,7 @@ ENUM_CM_RETURN CFM_2x2_StateChange_Send(IN const CM_UINT8* pBuf, IN CM_INT32 Buf
     if(NULL != pBuf)
     {
 		/*- 2x状态切换UDP通信通道向对系发送 */
-    	rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_State, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2),g_PFM_Cfg.Partner_Cfg.Port_2x2_State);
+    	rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_State, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_4x2),g_PFM_Cfg.Partner_Cfg.Port_2x2_State);
     }
     else
     {
@@ -1098,7 +1063,7 @@ ENUM_CM_RETURN CFM_2x2_StateChange_Send(IN const CM_UINT8* pBuf, IN CM_INT32 Buf
 }
 
 /**
-* @brief 通用2x2状态数据接收
+* @brief 2x2状态数据接收
 * @param pBuf 接收报文指针 取值范围：非空
 * @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
 * @return 接收报文长度
@@ -1107,111 +1072,46 @@ ENUM_CM_RETURN CFM_2x2_StateChange_Send(IN const CM_UINT8* pBuf, IN CM_INT32 Buf
 */
 CM_INT32 CFM_2x2_StateChange_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize)
 {
-    /*- 变量初始化 */
-    CM_UINT16 len = (BufSize > 65535u) ? (CM_UINT16)(65535u) : (CM_UINT16)(BufSize);
-    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-    CM_UINT8  tempBuf[200] = {0};
-    CM_RE_ASSERT(NULL != pBuf, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_40, TSCP_DARK_ASSERT_1);
-    /*- 从接收线程获取输入报文 */
-    rt = CM_MQ_Read(&s_CFM_State2x2.MsgQ, tempBuf, &len);
-    /*- 是否获取成功 */
-    if ((rt == ENUM_CM_TRUE) && (len > 6u))
-    {
-        /*- 输出接收数据 */
-        rt = CM_Memcpy((void*)pBuf, (CM_SIZE_T)BufSize, (void*)(tempBuf), (CM_SIZE_T)len);
-        CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_40, TSCP_DARK_ASSERT_2);
-    }
-    else
-    {
-        /*- 接收长度为0 */
-        len = 0u;
-    }
-    /*- 返回接收长度 */
-    return (CM_INT32)len;
+	return CFM_Recv_ComInterface(&s_CFM_State2x2,pBuf,BufSize,0u);
 }
 /**
-* @brief 发起一次2x2时钟同步
-* @details
-* 发送一个2x2时钟同步请求报文
-* 由双方的时钟同步线程完成一次NTP校时操作
-* 操作完成后本方的时钟同步线程会记录到延迟时间和偏移时间
-* @see :: CFM_2x2_TimeGet
-* @see :: t_TimeThread
-*/
-void CFM_2x2_TimeReq(void)
-{
-    /*- 变量初始化 */
-    CM_UINT8 buf[100];
-    CM_INT32 len = 0;
-    CM_ATOMIC CM_UINT64 tick = 0u;
-    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-    /*- 生成时钟同步请求报文 */
-    len = 9;
-    buf[0] = (CM_UINT8)ENUM_TIME_REQ;
-
-    tick = DFM_GetCycTick();
-
-    CM_64ToChar(tick, buf + 1);
-    /*- 发送时钟同步请求报文 */
-    rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_Time, buf, len, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2), g_PFM_Cfg.Partner_Cfg.Port_2x2_Time);
-    if(ENUM_CM_TRUE != rt)
-    {
-    	(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_1));
-    	MSCP_LOG_MSG("CFM_2x2_TimeReq UDP_SEND Error!\n");
-    }
-    else
-    {
-    	 /*- 不处理 */
-    }
-}
-/**
-* @brief 读取2x2时钟同步结果
-* @param pDelay 延迟时间
-* @param pOffset 偏移时间
-* @return 执行结果
+* @brief 2x2状态数据扩展通道发送
+* @param pBuf 发送报文指针 取值范围：非空
+* @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+* @return 发送结果
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败
 */
-ENUM_CM_RETURN CFM_2x2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset)
+ENUM_CM_RETURN CFM_2x2_StateChangeExtend_Send(IN CM_UINT8* pBuf, IN CM_UINT32 BufLen)
 {
-
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-    /*- 指针不为空 */
-	if((NULL != pDelay) && (NULL != pOffset))
-	{
-		/*- 锁定互斥锁 */
-		rt = CM_Mutex_Lock(s_CFM_2x2_Time.mutex);
-		CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_16, TSCP_DARK_ASSERT_1);
-		/*- 是否保存了时钟同步结果 */
-		if (ENUM_CM_TRUE == s_CFM_2x2_Time.isOK)
-		{
-			/*- 读取时钟同步结果 */
-			*pDelay = s_CFM_2x2_Time.delay;
-			*pOffset = s_CFM_2x2_Time.offset;
-			/*- 清除时钟同步结果 */
-			s_CFM_2x2_Time.isOK = ENUM_CM_FALSE;
-			rt = ENUM_CM_TRUE;
-		}
-		else
-		{
-			//TSCP_DARK_CFMNET_2x2TIMEGET_REDERROR
-			(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_1));
-			MSCP_LOG_MSG("s_CFM_2x2_Time.isOK != ENUM_CM_TRUE\n");
-		}
-		/*- 释放互斥锁 */
-		rt = CM_Mutex_Unlock(s_CFM_2x2_Time.mutex);
-		CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_16, TSCP_DARK_ASSERT_2);
-	}
-	else
-	{
-		//TSCP_DARK_CFMNET_2x2TIMEGET_REDNULL
-		(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_2, TSCP_DARK_ASSERT_2));
-		MSCP_LOG_MSG("pDelay == NULL || pOffset == NULL\n");
-	}
-    /*- 返回执行结果 */
+    /*- 入参指针防空 */
+    if(NULL != pBuf)
+    {
+		/*- 2x状态切换UDP通信通道向对系发送 */
+    	rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_State_Extend, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_Area),g_PFM_Cfg.Partner_Cfg.Port_2x2_State);
+    }
+    else
+    {
+    	/*空指针返回失败*/
+    }
+    /*- 返回发送结果 */
     return rt;
 }
+
+/**
+* @brief 2x2状态数据扩展通道接收
+* @param pBuf 接收报文指针 取值范围：非空
+* @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+* @return 接收报文长度
+* - 1~0xFFFFFFFF 接收报文长度
+* - 0 接收失败
+*/
+CM_UINT16 CFM_2x2_StateChangeExtend_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize)
+{
+	return (CM_UINT16)CFM_Recv_ComInterface(&s_CFM_State2x2Extend,pBuf,BufSize,0u);
+}
 /**
 * @brief 周期同步线程
 * @param arg 指向STRU_CFM_SYN_CTRL的指针
@@ -1280,8 +1180,18 @@ ENUM_CM_RETURN CFM_2x2_SyncSend(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
 {
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-    /* UDP方式从2x2周期同步通道发送 */
-    rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_Syn, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2),g_PFM_Cfg.Partner_Cfg.Port_2x2_Syn);
+    if(0 == g_PFM_Cfg.Multicast_Flag)
+    {
+        /*- UDP方式从2x2数据通道发送报文 */
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Area_A_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Area_B_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+    }
+    else
+    {
+        /* UDP方式从2x2周期同步通道发送 */
+        rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Syn_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast),g_PFM_Cfg.Local_Cfg.Port_4x2_Syn_Rcv);
+    }
     /*- 返回发送结果 */
     return rt;
 }
@@ -1340,13 +1250,24 @@ ENUM_CM_RETURN CFM_2x2_DataSend(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
 {
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-    /*- UDP方式从2x2数据通道发送报文 */
-    rt = CM_UDP_Send_Msg(s_CFM_Sock.Sock_2x2_Data, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_2x2), g_PFM_Cfg.Partner_Cfg.Port_2x2_Data);
+    if(0 == g_PFM_Cfg.Multicast_Flag)
+    {
+        /*- UDP方式从2x2数据通道发送报文 */
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Area_A_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Partner_Area_B_Cfg.IP_4x2), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Send);
+    }
+    else
+    {
+        /*- UDP方式从2x2数据通道发送报文 */
+        CM_UDP_Send_Msg(s_CFM_Sock.Sock_4x2_Data_Send, pBuf, BufLen, inet_addr(g_PFM_Cfg.Local_Cfg.IP_Area_Multicast), g_PFM_Cfg.Local_Cfg.Port_4x2_Data_Rcv);
+    }
+
     /*- 返回发送结果 */
     return rt;
 }
 /**
-* @brief 2x2串口数据发送
+* @brief 2x2状态数据扩展通道发送（串口或以太网）
 * @param pBuf 发送报文指针 取值范围(非空)
 * @param BufLen 发送报文长度 取值范围(0~0xffffffff)
 * @param msgType 发送报文类型
@@ -1355,15 +1276,18 @@ ENUM_CM_RETURN CFM_2x2_DataSend(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen)
 * - ENUM_CM_NULL 发送条件不满足
 * - ENUM_CM_FALSE 失败
 */
-ENUM_CM_RETURN CFM_2x2_UartDataSend(IN CM_UINT8* pBuf, IN CM_UINT16 BufLen)
+ENUM_CM_RETURN CFM_2x2_ExtendDataSend(IN CM_UINT8* pBuf, IN CM_UINT16 BufLen)
 {
 	ENUM_CM_RETURN rtnval = ENUM_CM_FALSE;
-#ifdef QNX
-	/*- 返回发送结果 */
-	rtnval = CM_Com_LocalDataSend((CM_UINT8*)pBuf, BufLen);
-#else
-    rtnval = ENUM_CM_TRUE;
-#endif
+	if((NULL != pBuf) && (NULL != p_2x2_ExtendDataSend))
+	{
+		/*- 返回发送结果 */
+		rtnval = (*p_2x2_ExtendDataSend)((CM_UINT8*)pBuf, BufLen);
+	}
+	else
+	{
+		rtnval = ENUM_CM_FALSE;
+	}
     return rtnval;
 }
 /**
@@ -1398,24 +1322,58 @@ CM_INT32 CFM_2x2_DataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize)
     return (CM_INT32)len;
 }
 /**
-* @brief 2x2串口数据接收
+* @brief 2x2状态数据扩展通道接收（串口或以太网）
 * @param pBuf 接收报文指针(非空)
 * @param BufLen 接收报文缓冲区大小(0~0xffffffff)
 * @return 接收报文长度
 * - 正整数 接收报文长度
 * - 0或负数 接收失败
 */
-CM_UINT16 CFM_2x2_UartDataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize)
+CM_UINT16 CFM_2x2_ExtendDataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize)
 {
-#ifdef QNX
-
-    /*- 返回发送结果 */
-    return CM_Com_OtherDataRecv(pBuf, BufSize);
-#else
-    return 0;
-#endif
+	if((NULL != pBuf) && (NULL != p_2x2_ExtendDataRecv))
+	{
+		/*- 返回发送结果 */
+		return (*p_2x2_ExtendDataRecv)(pBuf, BufSize);
+	}
+	else
+	{
+		return 0;
+	}
+}
+/**
+* @brief 数据接收通用接口
+* @param *ctrl 控制结构体
+* @param pBuf 接收报文指针
+* @param BufLen 接收报文缓冲区大小
+* @return 接收报文长度
+* - 正整数 接收报文长度
+* - 0 接收失败
+*/
+static CM_INT32 CFM_Recv_ComInterface(STRU_CFM_RECV_CTRL_T *pctrl,OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize,CM_UINT16 Offset)
+{
+	/*- 变量初始化 */
+	CM_UINT16 len = (CM_UINT16)((BufSize > 65535u) ? 65535u : BufSize);
+	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	/*- 指针防空*/
+	CM_ASSERT_MAINTAIN(NULL != pBuf);
+	/*- 从接收线程获取输入报文 */
+	rt = CM_MQ_Read(&pctrl->MsgQ, pctrl->cache_buf, &len);
+	/*- 是否获取成功 */
+	if ((ENUM_CM_TRUE == rt) && (Offset < len))
+	{
+		/*- 输出接收数据 */
+		len -= Offset;
+		(void)CM_Memcpy((void*)pBuf, (CM_SIZE_T)BufSize, (void*)(&pctrl->cache_buf[Offset]), (CM_SIZE_T)len);
+	}
+	else
+	{
+		/*- 接收长度为0 */
+		len = 0u;
+	}
+	/*- 返回接收长度 */
+	return (CM_INT32)len;
 }
-
 /*********************************内网通信相关*****************************************/
 
 /**
@@ -1436,7 +1394,7 @@ static void s_NetInit_Innet(void)
 	STRU_PFM_INNET_CFG_T *pCom = NULL;
 
     /*- 创建安全通信socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_InnetSafe, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Com), g_PFM_Cfg.Local_Cfg.Port_Innet_Safe, 0u, (CM_UINT8)0);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_InnetSafe, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Com), g_PFM_Cfg.Local_Cfg.Port_Innet_Safe, 0u, (CM_UINT8)1u);
     CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_3, TSCP_DARK_ASSERT_1);
     (void)setsockopt(s_CFM_Sock.Sock_InnetSafe, SOL_SOCKET, SO_RCVBUF, (void*)(&rcv_val), (unsigned int)sizeof(rcv_val));
     (void)setsockopt(s_CFM_Sock.Sock_InnetSafe, SOL_SOCKET, SO_SNDBUF, (void*)(&send_val), (unsigned int)sizeof(send_val));
@@ -1496,11 +1454,11 @@ static void s_NetInit_Innet(void)
 			/*UDP通信*/
 			if (RAW_COM_BROADCAST == g_PFM_Cfg.Local_Cfg.Innet_Raw_Parameter[i].Port_Type_Enable)
 			{
-				bCast = 1;/*广播模式*/
+				bCast = 2;/*广播模式*/
 			}
 			else
 			{
-				bCast = 0;/*默认单播组播模式*/
+				bCast = 1;/*默认单播组播模式*/
 			}
 			rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_InnetRaw[i],
 				CM_FALSE,
@@ -1845,7 +1803,7 @@ static CM_THREAD_FUNC_T t_TcpRecvThread(IN CM_Thread_Arg_Struct_T* arg)
 		tick = CM_GetTick();
 		tick = tick + (CM_UINT64)(100000000u);
 
-		if(ENUM_2x2_MASTER == SFM_2x2_GetLocal2x2State())
+		if(ENUM_4x2_MASTER == SFM_GetLocal4x2State())
 		{
 			/*- 查询套接字状态 */
 			ret = CM_TCP_Msgstate_Query(tcpId, &tcpsock, &TcpState, &ServeraddrIP, &ServerportNumber);
@@ -2179,7 +2137,7 @@ static void s_NetInit_Outnet(void)
     CM_BOOL rtCheck;     /* 临时变量 */
 
     /*- 创建socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetSafe, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Safe, 0u, (CM_UINT8)0);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetSafe, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Safe, 0u, (CM_UINT8)1);
     CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 
     /*- 配置socket */
@@ -2201,7 +2159,7 @@ static void s_NetInit_Outnet(void)
     CM_ASSERT(CM_TRUE == rtCheck, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_4);
 
 	/*- 创建外网心跳socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetHeart, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Heart, 0u, (CM_UINT8)0);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetHeart, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Heart, 0u, (CM_UINT8)1);
     CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_9);
 
     /*- 配置接收线程 */
@@ -2220,7 +2178,7 @@ static void s_NetInit_Outnet(void)
     if(0x55u == (CM_UINT32)g_PFM_Cfg.M_OutnetRaw_Enable)
     {
 		/*- 创建socket */
-		rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetRaw, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Raw, 0u, (CM_UINT8)0);
+		rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_OutnetRaw, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Out), g_PFM_Cfg.Local_Cfg.Port_Outnet_Raw, 0u, (CM_UINT8)1);
 		CM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_5);
 
 	
@@ -2315,11 +2273,11 @@ static void s_NetInit_Maintain(void)
     ENUM_CM_RETURN rt = ENUM_CM_FALSE; /* 临时变量 */
     CM_INT32 val = 0;    /* 临时变量 */
     /*- 创建socket */
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_LogBase, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Log_Base, 0u, (CM_UINT8)0);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_LogBase, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Log_Base, 0u, (CM_UINT8)1);
     CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1);
     s_CFM_Send_LogStr.pSock = &s_CFM_Sock.Sock_LogBase;
 
-    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_LogCiphertext, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Log_Ciphertext, 0u, (CM_UINT8)0);
+    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_LogCiphertext, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Log_Ciphertext, 0u, (CM_UINT8)1);
     CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_2);
 	s_Log_CtrlQ.pSock = &s_CFM_Sock.Sock_LogCiphertext;
 
@@ -2491,6 +2449,10 @@ void CFM_LogCiphertextSend(void)
 			{
 				appType = 7u;
 			}
+			else if(0 == strcmp(g_PFM_Cfg.APP_NAME, "YJP"))
+			{
+				appType = 8u;
+			}
 			else
 			{
 				appType = 0u;
@@ -2774,7 +2736,7 @@ static void s_NetInit_RemoteUpdate(void)
 	    }
 		
 	    /*- 创建socket */
-	    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_Remote_Update, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Remote_Update, 0u, (CM_UINT8)0);
+	    rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_Remote_Update, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_Maintain), g_PFM_Cfg.Local_Cfg.Port_Remote_Update, 0u, (CM_UINT8)1);
 	    CM_NM_ASSERT(ENUM_CM_TRUE == rt,NET_MODE, DARK_FAULT_CODE_FUN_ORDER_9, TSCP_DARK_ASSERT_1);
 
 	    /*- 配置socket */
@@ -2874,6 +2836,12 @@ void CFM_NetworkCard_Init(void)
 	(void)sprintf(str, "ifconfig %s %s", "wm0", g_PFM_Cfg.Local_Cfg.IP_Maintain);
 	(void)printf("%s\n",str);
 	(void)system(str);
+
+	/*- 配置区域通信网卡IP*/
+	(void)memset(str, 0, sizeof(str));
+	(void)sprintf(str, "ifconfig %s %s", "wm1", g_PFM_Cfg.Local_Cfg.IP_Area);
+	(void)printf("%s\n",str);
+	(void)system(str);
 }
 /**
 * @brief UDP接收线程
@@ -3056,115 +3024,7 @@ static CM_THREAD_FUNC_T t_UdpRecvMaintenanceThread(IN CM_Thread_Arg_Struct_T* ar
     }
     return NULL;
 }
-/**
-* @brief 时钟同步线程
-* @param arg 指向STRU_CFM_TIME_CTRL的指针
-* @return 线程函数返回值（实际永远不会返回）
-* @details
-* 创建本线程之前应先配置好STRU_CFM_TIME_CTRL，包括创建阻塞通信的socket
-* 本线程将以阻塞方式接收时钟同步报文并作出应答
-* 收到请求报文时立即给出应答
-* 收到应答报文时记录并计算延迟时间、偏移时间
-* @see :: CFM_2oo2_TimeReq
-* @see :: CFM_2oo2_TimeGet
-*/
-static CM_THREAD_FUNC_T t_TimeThread(IN CM_Thread_Arg_Struct_T* arg)
-{
-    /*- 变量初始化 */
-    STRU_CFM_TIME_CTRL_T* pCtrl = (STRU_CFM_TIME_CTRL_T*)arg;  /* 线程参数 */
-    CM_UINT8 buf[100] = { 0u };  /* 接收缓冲区 */
-    CM_INT32 len;            /* 数据长度 */
-    CM_UINT32 srcIP;         /* 源IP */
-    CM_UINT16 srcPort;       /* 源端口 */
-    CM_UINT64 tick = 0u;     /* 精确时间 */
-    CM_UINT64 T1 = 0u;  /* 时钟同步参数 */
-    CM_UINT64 T2 = 0u;  /* 时钟同步参数 */
-    CM_UINT64 T3 = 0u;  /* 时钟同步参数 */
-    CM_UINT64 T4 = 0u;  /* 时钟同步参数 */
-    ENUM_CM_RETURN rt = ENUM_CM_FALSE;
-#if QNX
-    void* pmask = NULL;
-    /*- 本线程锁定在 A53 core 1 */
-    pmask = (void*)(0x01u|0x02u);
-    (void)ThreadCtl(_NTO_TCTL_RUNMASK, pmask);
-#endif
-    MSCP_LOG_MSG("IP:%s:%d Time Service Start\n", pCtrl->IP, (CM_INT32)pCtrl->port);
-    /*- 循环执行接收线程 */
-    while (1)
-    {
-        /*- 阻塞接收时钟同步报文 */
-        len = CM_UDP_Recv_Msg(*(pCtrl->pSock), buf, (CM_INT32)sizeof(buf), &srcIP, &srcPort);
-        tick = DFM_GetCycTick();
-        /*- 是否收到有效报文 */
-        if (len > 0)
-        {
-            /*- 报文类型 */
-            switch ((ENUM_TIME_MSG_T)buf[0])
-            {
-            case ENUM_TIME_REQ: /*-< 时钟同步请求 */
-                /*- 长度是否合法 */
-                if (9 == len)
-                {
-                    /*- 解析请求报文 */
-                    T1 = CM_64FromChar(buf + 1);
-                    /*- 生成应答报文 */
-                    T2 = tick;
-                    buf[0] = (CM_UINT8)ENUM_TIME_ACK;
-                    CM_64ToChar(T1, buf + 1);
-                    CM_64ToChar(T2, buf + 9);
-                    T3 = DFM_GetCycTick();
-                    CM_64ToChar(T3, buf + 17);
-                    /*- 发送应答报文 */
-                    (void)CM_UDP_Send_Msg(*(pCtrl->pSock), buf, (CM_INT32)25, srcIP, srcPort);
-                }
-                else
-				{
-					/*- 无处理 */
-				}
-                /*- 返回 */
-                break;
-            case ENUM_TIME_ACK:/*-< 时钟同步应答 */
-                /*- 长度是否合法 */
-                if (25 == len)
-                {
-                    /*- 解析应答报文 */
-                    T1 = CM_64FromChar(buf + 1);
-                    T2 = CM_64FromChar(buf + 9);
-                    T3 = CM_64FromChar(buf + 17);
-                    T4 = tick;
-                    /*- 记录延迟时间和偏移时间 */
-                    rt = CM_Mutex_Lock(pCtrl->mutex);
-                    CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_1);
-                    pCtrl->isOK = ENUM_CM_TRUE;
-                    pCtrl->delay = (CM_INT64)((T4 - T1) - (T3 - T2)) / 2;
-                    pCtrl->offset = (CM_INT64)((T2 + T3) - (T4 + T1)) / 2;
-                    rt = CM_Mutex_Unlock(pCtrl->mutex);
-                    CM_RE_ASSERT(ENUM_CM_TRUE == rt, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_2);
 
-                }
-                else
-				{
-					/*- 无处理 */
-				}
-                /*- 返回 */
-                break;
-            case ENUM_TIME_ERROR:/*-< 保留字 */
-                /*- 宕机 */
-            	CM_RE_ASSERT(0, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_3);
-                /*- 返回 */
-                break;
-            default:
-                /*- 返回 */
-                break;
-            }
-        }
-        else
-        {
-            /*- 不处理 */
-        }
-    }
-    return NULL;
-}
 
 /**
 * @brief 远程部署接收线程

TSCP/src/MSCP/CFM/CFM_Net.h

@@ -21,6 +21,7 @@
 #include "MSCP_APP_Interface.h"
 #include "CM_Mutex.h"
 #include "PFM_Cfg.h"
+#include "CM_Socket.h"
 #if QNX
 #include <sys/neutrino.h> /* ThreadCtl BMP绑定CPU*/
 #endif
@@ -47,13 +48,6 @@ extern "C"
 #define DARK_LOG_HEX (0xAAu)
 #define DARK_LOG_DEC (0xFFu)
 
-    /*- 时钟同步报文类型 */
-    typedef enum
-    {
-        ENUM_TIME_ERROR = 0, /**< 保留 */
-        ENUM_TIME_REQ,       /**< 时钟同步请求 */
-        ENUM_TIME_ACK        /**< 时钟同步应答 */
-    }ENUM_TIME_MSG_T;
 
     typedef struct
     {
@@ -105,33 +99,18 @@ extern "C"
     }STRU_HARDWARE_BOOT_COM_T;
 
     extern STRU_HARDWARE_BOOT_COM_T g_Hardware_boot_com_state;
+    /*发送2x2状态扩展通道数据，注册函数指针*/
+    typedef ENUM_CM_RETURN(*EXTEND_DATA_SEND) (CM_UINT8*,CM_UINT32);
+    extern EXTEND_DATA_SEND p_2x2_ExtendDataSend;
+    /*接收2x2状态扩展通道数据，注册函数指针*/
+    typedef CM_UINT16(*EXTEND_DATA_RECV) (CM_UINT8*,CM_UINT32);
+    extern EXTEND_DATA_RECV p_2x2_ExtendDataRecv;
     /**
     * @brief 2oo2上电同步
     * @details
     */
     ENUM_CM_RETURN CFM_2oo2_InitSync(void);
 
-    /**
-    * @brief 发起一次2oo2时钟同步
-    * @details
-    * 发送一个2oo2时钟同步请求报文
-    * 由双方的时钟同步线程完成一次NTP校时操作
-    * 操作完成后本方的时钟同步线程会记录到延迟时间和偏移时间
-    * @see :: CFM_2oo2_TimeGet
-    * @see :: t_TimeThread
-    */
-    void CFM_2oo2_TimeReq(void);
-
-    /**
-    * @brief 读取时钟同步结果
-    * @param pDelay 延迟时间
-    * @param pOffset 偏移时间
-    * @return 执行结果
-    * - ENUM_CM_TRUE 成功
-    * - ENUM_CM_FALSE 失败
-    */
-    ENUM_CM_RETURN CFM_2oo2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset);
-
     /**
     * @brief 2oo2数据发送
     * @param pBuf 发送报文指针
@@ -262,27 +241,24 @@ extern "C"
     * - 0 接收失败
     */
     CM_INT32 CFM_2x2_StateChange_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize);
-
     /**
-    * @brief 发起一次2x2时钟同步
-    * @details
-    * 发送一个2x2时钟同步请求报文
-    * 由双方的时钟同步线程完成一次NTP校时操作
-    * 操作完成后本方的时钟同步线程会记录到延迟时间和偏移时间
-    * @see :: CFM_2x2_TimeGet
-    * @see :: t_TimeThread
-    */
-    void CFM_2x2_TimeReq(void);
-
-    /**
-    * @brief 读取2x2时钟同步结果
-    * @param pDelay 延迟时间
-    * @param pOffset 偏移时间
-    * @return 执行结果
+    * @brief 2x2状态数据扩展通道发送
+    * @param pBuf 发送报文指针 取值范围：非空
+    * @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+    * @return 发送结果
     * - ENUM_CM_TRUE 成功
     * - ENUM_CM_FALSE 失败
     */
-    ENUM_CM_RETURN CFM_2x2_TimeGet(OUT CM_INT64* pDelay, OUT CM_INT64* pOffset);
+    ENUM_CM_RETURN CFM_2x2_StateChangeExtend_Send(IN CM_UINT8* pBuf, IN CM_UINT32 BufLen);
+    /**
+    * @brief 2x2状态数据扩展通道接收
+    * @param pBuf 接收报文指针 取值范围：非空
+    * @param BufLen 接收报文缓冲区大小 取值范围：0~0xFFFFFFFF
+    * @return 接收报文长度
+    * - 1~0xFFFFFFFF 接收报文长度
+    * - 0 接收失败
+    */
+    CM_UINT16 CFM_2x2_StateChangeExtend_Recv(CM_UINT8* pBuf, IN CM_UINT32 BufSize);
 
     /**
     * @brief 2x2同步发送
@@ -316,7 +292,7 @@ extern "C"
     ENUM_CM_RETURN CFM_2x2_DataSend(IN const CM_UINT8* pBuf, IN CM_INT32 BufLen);
 
     /**
-    * @brief 2x2串口数据发送
+    * @brief 2x2状态数据扩展通道发送（串口或以太网）
     * @param pBuf 发送报文指针 取值范围(非空)
     * @param BufLen 发送报文长度 取值范围(0~0xffffffff)
     * @param msgType 发送报文类型
@@ -325,7 +301,7 @@ extern "C"
     * - ENUM_CM_NULL 发送条件不满足
     * - ENUM_CM_FALSE 失败
     */
-    ENUM_CM_RETURN CFM_2x2_UartDataSend(IN CM_UINT8* pBuf, IN CM_UINT16 BufLen);
+    ENUM_CM_RETURN CFM_2x2_ExtendDataSend(IN CM_UINT8* pBuf, IN CM_UINT16 BufLen);
 
     /**
     * @brief 2x2数据接收
@@ -337,15 +313,16 @@ extern "C"
     */
     CM_INT32 CFM_2x2_DataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize);
 
+
     /**
-    * @brief 2x2串口数据接收
+    * @brief 2x2状态数据扩展通道接收（串口或以太网）
     * @param pBuf 接收报文指针(非空)
     * @param BufLen 接收报文缓冲区大小(0~0xffffffff)
     * @return 接收报文长度
     * - 正整数 接收报文长度
     * - 0或负数 接收失败
     */
-    CM_UINT16 CFM_2x2_UartDataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize);
+    CM_UINT16 CFM_2x2_ExtendDataRecv(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize);
 
     /* @brief 内网透传TCP通信数据发送
     * @param ch   内网透传通道序号，[1...n]有效
@@ -656,6 +633,15 @@ extern "C"
     * - ENUM_CM_FALSE 失败
     */
     ENUM_CM_RETURN CFM_OutnetHeart_Send(IN const CM_UINT8* pBuf, IN CM_INT32 Len, IN ENUM_OUTNET_CHN_T Chn);
+    /**
+    * @brief 通用2oo2数据发送
+    * @param pBuf 发送报文指针 取值范围：非空
+    * @param BufLen 发送报文长度 取值范围：0~0x7FFFFFFF
+    * @return 发送结果
+    * - ENUM_CM_TRUE 成功
+    * - ENUM_CM_FALSE 失败
+    */
+    ENUM_CM_RETURN CFM_2oo2_Send_Currency(IN CM_SOCKET sock,IN const CM_UINT8* pBuf, IN CM_INT32 BufLen,IN CM_UINT16 nPortDest);
 
 #ifdef __cplusplus
 }

TSCP/src/MSCP/CFM/CFM_Raw.c

@@ -825,6 +825,7 @@ CM_UINT32 CFM_RxOutnetHeart(OUT CM_UINT8 buf[], IN CM_UINT32 bufSize)
 	CM_UINT8 rcv_2oo2_buf[16] = {0u};
 	CM_INT32 rcv_len = 0;
 	CM_UINT32 cycle = DFM_GetBirthCount();
+	CM_UINT8 cut = 0;
     CM_UINT8 ccState[2] = {0,0};
     CM_UINT8 sebState[2] = {0,0};
     /*- 如果入参指针不为空  */
@@ -903,7 +904,8 @@ CM_UINT32 CFM_RxOutnetHeart(OUT CM_UINT8 buf[], IN CM_UINT32 bufSize)
 	(1u == PFM_CCUSEB_Comstate(2))? (sebState[1] = 0xaau) : (sebState[1] = 0x55u);
 	(1u == PFM_CCUSEB_Comstate(3))? (sebState[0] = 0xaau) : (sebState[0] = 0x55u);
 	MSCP_LOG_MSG("rCC = %d, bCC = %d, rSEB = %d, bSEB = %d\n", ccState[1], ccState[0], sebState[1], sebState[0]);
-
+	/*记录健康度*/
+	SFM_2x2_UpdataLocalCC_Health(ccState,2u);
     /*- 填写暗文日志 */
     (void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_CCSTATE, 2U, &ccState);
     (void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_SEBSTATE, 2U, &sebState);

TSCP/src/MSCP/CFM/CFM_Sync.h

@@ -0,0 +1,148 @@
+/**
+ * @file CFM_Sync.h
+ * @brief 时间和信息同步功能头文件
+ * 
+ * 该头文件定义了系统时间同步和信息同步相关的接口函数、
+ * 数据结构和常量定义，为系统内各模块提供统一的时间同步服务。
+ * 
+ * 主要包含：
+ * - 时间同步接口函数声明
+ * - 信息同步相关数据结构定义
+ * - 同步状态枚举和常量定义
+ * - 错误码定义
+ * 
+ * @author [硬件平台部平台软件组]
+ * @date [2025-12-01]
+ * @version [1.0]
+ */
+#ifndef CFM_SYNC_H
+#define CFM_SYNC_H 
+
+#include "CM_Types.h"
+#include "CM_Mutex.h"
+#include "CM_Socket.h"
+#include "CM_Atomic.h"
+#include "PFM_Cfg.h"
+
+#define CFM_MAX_DEV_NUM 100  /* 最大设备数量 暂定100 个设备 */
+#define CIRCULAR_BUFFER_SIZE    (10)         /* 环形缓冲区大小 */
+#define CFM_TIME_2X_COUNT (10)
+#define CFM_TIME_SYNC_OBJECT   (2) //使用校时服务的功能数量，目前为2
+
+typedef enum
+{
+    ENUM_TIME_ERROR = 0,     /**< 保留 */
+    ENUM_TIME_START,         /**< 时钟同步开始 */
+    ENUM_TIME_REQ,           /**< 时钟同步请求 */
+    ENUM_TIME_ACK,           /**< 时钟同步应答 */
+    ENUM_TIME_RET,           /**< 时钟同步结果返回 */
+    ENUM_TIME_PEER_RESULT    /**< 对端结果 */
+} ENUM_TIME_MSG_T;
+
+/**
+ * @brief 环形数组统计结构体
+ *
+ * 用于维护环形数组的状态信息，包括数组本身、元素计数和插入位置
+ */
+typedef struct
+{
+    CM_INT64 *pBuffer;     /**< 环形数组缓冲区指针 */
+    CM_INT32 size;          /**< 环形数组大小 */
+    CM_INT32 count;          /**< 数组元素计数 */
+    CM_INT32 index;          /**< 当前插入位置 */
+} STRU_CIRCULAR_BUFFER_T;
+
+typedef struct
+{
+    CM_CHAR IP[32];  /* 源IP */
+    CM_UINT16 Port;  /* 目标端口 */
+}STRU_CFM_TIME_MSG_T;
+
+typedef struct
+{
+    STRU_CFM_TIME_MSG_T Local_2oo2_Addr;
+    STRU_CFM_TIME_MSG_T Peer_2oo2_Addr; 
+    STRU_CFM_TIME_MSG_T Local_4x_Addr;
+    STRU_CFM_TIME_MSG_T Partner_Addr;
+    STRU_CFM_TIME_MSG_T Partner_Area_Addr_A;
+    STRU_CFM_TIME_MSG_T Partner_Area_Addr_B;
+}STRU_CFM_TIME_ADDR_T;
+
+/** 时钟同步控制 */
+typedef struct
+{
+    CM_SOCKET pSock;  /* 本地socket */
+
+    CM_UINT8 destDev_Num; /* 目标设备数量 */
+    STRU_CFM_TIME_ADDR_T time_addr; /* 时间同步地址信息 */
+    STRU_CFM_TIME_MSG_T local_addr; /* 本地设备地址信息 */
+    STRU_CFM_TIME_MSG_T destDev_addr[CFM_MAX_DEV_NUM]; /* 目标设备地址信息 */
+    
+    STRU_CIRCULAR_BUFFER_T circular_buf; /* 环形数组统计结构体 */
+
+    CM_UINT8 time_type; /* 时间同步类型 */
+    /*
+    * delay和offset受互斥信号量mutex保护，
+    * 读写offset时需要先取得互斥信号量
+    */
+    CM_MUTEX_T mutex;       /* 互斥信号量 */
+    ENUM_CM_RETURN isOK;  /* 校时成功标志 */
+    CM_INT64 offset;      /* 偏移时间 */
+    CM_ATOMIC CM_UINT8 TimeSyncFlag; /* 时间同步标志 */
+    CM_INT64 cyc_time;   /* 周期时间 */
+}STRU_CFM_TIME_CTRL_T;
+
+/**
+ * @brief 获取时间偏移量并计算校时结果
+ *
+ * 根据时间同步类型获取相应的本地和对端时间偏移量，通过2oo2交换机制获取对端数据，
+ * 并根据系统状态和预设门限计算最终的时间调整值。
+ *
+ * @param[out] p_avg_offset_2x 2x时间同步类型的平均偏移量输出指针
+ * @param[out] p_avg_offset_2oo2 2oo2时间同步类型的平均偏移量输出指针
+ *
+ * @note 该函数会根据主从状态和时间偏移量大小决定是否需要调整时钟
+ * @see CFM_Get_Time
+ * @see SFM_2oo2_Exchange_Currency
+ * @see SFM_GetLocal4x2State
+ */
+void CFM_Get_Offset(CM_INT64 *p_avg_offset_2x, CM_INT64 *p_avg_offset_2oo2);
+/**
+ * @brief 发送时间同步请求消息
+ * 
+ * 向2oo2和2x时间同步通道发送时间同步启动请求消息，触发时间同步过程。
+ * 通过UDP协议向配置的本地地址和端口发送ENUM_TIME_START消息。
+ * 
+ * @param[in] void 无参数
+ * 
+ * @return 无
+ * 
+ * @note 该函数会同时向2oo2和2x两个时间同步通道发送启动请求
+ * @see ENUM_TIME_START
+ * @see s_TimeCtrl
+ */
+void CFM_SendLocalARQ(void);
+/**
+ * @brief 获取时间同步状态标志
+ *
+ * 获取系统时间同步完成状态标志，用于判断时间同步是否已完成且在有效范围内。
+ * 该标志由时间同步算法根据计算出的时间偏移量与预设门限值比较后设置。
+ *
+ * @param[in] void 无参数
+ *
+ * @return CM_BOOL 时间同步状态
+ * @retval CM_TRUE  时间同步完成且在允许误差范围内
+ * @retval CM_FALSE 时间同步未完成或超出允许误差范围
+ *
+ */
+CM_UINT8 CFM_GetTimeSyncFlag(void);
+ENUM_CM_RETURN CFM_TimeSync_Init(IN CM_UINT8 DevNum);
+
+/*获取本地输出比较结果，输出校验与应用跟随比较结果，比较一致返回CM_TRUE,失败返回CM_FALSE*/
+CM_UINT8 CFM_GetSyncFailFlag(void);
+/*获取失步次数，没有收到输出校验与应用跟随数据的周期计数*/
+CM_UINT32 CFM_GetOutOfSync(void);
+/*获取本地同步健康度:全部参数同步成功，离线升备，或升主条件，同步成功返回CM_TRUE,失败返回CM_FALSE*/
+CM_UINT8 CFM_GetSyncHealth(void);
+
+#endif // CFM_SYNC_H

TSCP/src/MSCP/CM/CM_CRC32.c

@@ -1,19 +1,110 @@
-/**
-* @file CM_CRC32.c
-* @brief 计算32位CRC函数
-* @author GT-BU
-* @date 2021.02.01
-* @version V1.1
-* @copyright TCT
-* @par 修改日志
-* <table>
-* <tr><th>Date        <th>Version  <th>Author     <th>Description
-* <tr><td>2017.12.20  <td>V1.0     <td>MSCP项目组 <td>创建初始版本
-* <tr><td>2021.02.01  <td>V1.1     <td>GT-BU      <td>TSCP项目集成、更新
-* </table>
-*/
+
 #include "CM_CRC32.h"
 
+/*CRC32查找表，copy from RSSP(RsspCommon.c) by lmy 20170416*/
+const CM_UINT32 CM_CrcmTab[2][256u] = {
+{
+	0x00000000u,	0x1942B361u,	0x328566C2u,	0x2BC7D5A3u,	0x650ACD84u,	0x7C487EE5u,	0x578FAB46u,	0x4ECD1827u,
+	0xCA159B08u,	0xD3572869u,	0xF890FDCAu,	0xE1D24EABu,	0xAF1F568Cu,	0xB65DE5EDu,	0x9D9A304Eu,	0x84D8832Fu,
+	0x18CE5601u,	0x018CE560u,	0x2A4B30C3u,	0x330983A2u,	0x7DC49B85u,	0x648628E4u,	0x4F41FD47u,	0x56034E26u,
+	0xD2DBCD09u,	0xCB997E68u,	0xE05EABCBu,	0xF91C18AAu,	0xB7D1008Du,	0xAE93B3ECu,	0x8554664Fu,	0x9C16D52Eu,
+	0x319CAC02u,	0x28DE1F63u,	0x0319CAC0u,	0x1A5B79A1u,	0x54966186u,	0x4DD4D2E7u,	0x66130744u,	0x7F51B425u,
+	0xFB89370Au,	0xE2CB846Bu,	0xC90C51C8u,	0xD04EE2A9u,	0x9E83FA8Eu,	0x87C149EFu,	0xAC069C4Cu,	0xB5442F2Du,
+	0x2952FA03u,	0x30104962u,	0x1BD79CC1u,	0x02952FA0u,	0x4C583787u,	0x551A84E6u,	0x7EDD5145u,	0x679FE224u,
+	0xE347610Bu,	0xFA05D26Au,	0xD1C207C9u,	0xC880B4A8u,	0x864DAC8Fu,	0x9F0F1FEEu,	0xB4C8CA4Du,	0xAD8A792Cu,
+	0x63395804u,	0x7A7BEB65u,	0x51BC3EC6u,	0x48FE8DA7u,	0x06339580u,	0x1F7126E1u,	0x34B6F342u,	0x2DF44023u,
+	0xA92CC30Cu,	0xB06E706Du,	0x9BA9A5CEu,	0x82EB16AFu,	0xCC260E88u,	0xD564BDE9u,	0xFEA3684Au,	0xE7E1DB2Bu,
+	0x7BF70E05u,	0x62B5BD64u,	0x497268C7u,	0x5030DBA6u,	0x1EFDC381u,	0x07BF70E0u,	0x2C78A543u,	0x353A1622u,
+	0xB1E2950Du,	0xA8A0266Cu,	0x8367F3CFu,	0x9A2540AEu,	0xD4E85889u,	0xCDAAEBE8u,	0xE66D3E4Bu,	0xFF2F8D2Au,
+	0x52A5F406u,	0x4BE74767u,	0x602092C4u,	0x796221A5u,	0x37AF3982u,	0x2EED8AE3u,	0x052A5F40u,	0x1C68EC21u,
+	0x98B06F0Eu,	0x81F2DC6Fu,	0xAA3509CCu,	0xB377BAADu,	0xFDBAA28Au,	0xE4F811EBu,	0xCF3FC448u,	0xD67D7729u,
+	0x4A6BA207u,	0x53291166u,	0x78EEC4C5u,	0x61AC77A4u,	0x2F616F83u,	0x3623DCE2u,	0x1DE40941u,	0x04A6BA20u,
+	0x807E390Fu,	0x993C8A6Eu,	0xB2FB5FCDu,	0xABB9ECACu,	0xE574F48Bu,	0xFC3647EAu,	0xD7F19249u,	0xCEB32128u,
+	0xC672B008u,	0xDF300369u,	0xF4F7D6CAu,	0xEDB565ABu,	0xA3787D8Cu,	0xBA3ACEEDu,	0x91FD1B4Eu,	0x88BFA82Fu,
+	0x0C672B00u,	0x15259861u,	0x3EE24DC2u,	0x27A0FEA3u,	0x696DE684u,	0x702F55E5u,	0x5BE88046u,	0x42AA3327u,
+	0xDEBCE609u,	0xC7FE5568u,	0xEC3980CBu,	0xF57B33AAu,	0xBBB62B8Du,	0xA2F498ECu,	0x89334D4Fu,	0x9071FE2Eu,
+	0x14A97D01u,	0x0DEBCE60u,	0x262C1BC3u,	0x3F6EA8A2u,	0x71A3B085u,	0x68E103E4u,	0x4326D647u,	0x5A646526u,
+	0xF7EE1C0Au,	0xEEACAF6Bu,	0xC56B7AC8u,	0xDC29C9A9u,	0x92E4D18Eu,	0x8BA662EFu,	0xA061B74Cu,	0xB923042Du,
+	0x3DFB8702u,	0x24B93463u,	0x0F7EE1C0u,	0x163C52A1u,	0x58F14A86u,	0x41B3F9E7u,	0x6A742C44u,	0x73369F25u,
+	0xEF204A0Bu,	0xF662F96Au,	0xDDA52CC9u,	0xC4E79FA8u,	0x8A2A878Fu,	0x936834EEu,	0xB8AFE14Du,	0xA1ED522Cu,
+	0x2535D103u,	0x3C776262u,	0x17B0B7C1u,	0x0EF204A0u,	0x403F1C87u,	0x597DAFE6u,	0x72BA7A45u,	0x6BF8C924u,
+	0xA54BE80Cu,	0xBC095B6Du,	0x97CE8ECEu,	0x8E8C3DAFu,	0xC0412588u,	0xD90396E9u,	0xF2C4434Au,	0xEB86F02Bu,
+	0x6F5E7304u,	0x761CC065u,	0x5DDB15C6u,	0x4499A6A7u,	0x0A54BE80u,	0x13160DE1u,	0x38D1D842u,	0x21936B23u,
+	0xBD85BE0Du,	0xA4C70D6Cu,	0x8F00D8CFu,	0x96426BAEu,	0xD88F7389u,	0xC1CDC0E8u,	0xEA0A154Bu,	0xF348A62Au,
+	0x77902505u,	0x6ED29664u,	0x451543C7u,	0x5C57F0A6u,	0x129AE881u,	0x0BD85BE0u,	0x201F8E43u,	0x395D3D22u,
+	0x94D7440Eu,	0x8D95F76Fu,	0xA65222CCu,	0xBF1091ADu,	0xF1DD898Au,	0xE89F3AEBu,	0xC358EF48u,	0xDA1A5C29u,
+	0x5EC2DF06u,	0x47806C67u,	0x6C47B9C4u,	0x75050AA5u,	0x3BC81282u,	0x228AA1E3u,	0x094D7440u,	0x100FC721u,
+	0x8C19120Fu,	0x955BA16Eu,	0xBE9C74CDu,	0xA7DEC7ACu,	0xE913DF8Bu,	0xF0516CEAu,	0xDB96B949u,	0xC2D40A28u,
+	0x460C8907u,	0x5F4E3A66u,	0x7489EFC5u,	0x6DCB5CA4u,	0x23064483u,	0x3A44F7E2u,	0x11832241u,	0x08C19120u},
+{
+	0x00000000u,	0x1EF09C7Eu,	0x3DE138FCu,	0x2311A482u,	0x7BC271F8u,	0x6532ED86u,	0x46234904u,	0x58D3D57Au,
+	0xF784E3F0u,	0xE9747F8Eu,	0xCA65DB0Cu,	0xD4954772u,	0x8C469208u,	0x92B60E76u,	0xB1A7AAF4u,	0xAF57368Au,
+	0xFF048983u,	0xE1F415FDu,	0xC2E5B17Fu,	0xDC152D01u,	0x84C6F87Bu,	0x9A366405u,	0xB927C087u,	0xA7D75CF9u,
+	0x08806A73u,	0x1670F60Du,	0x3561528Fu,	0x2B91CEF1u,	0x73421B8Bu,	0x6DB287F5u,	0x4EA32377u,	0x5053BF09u,
+	0xEE045D65u,	0xF0F4C11Bu,	0xD3E56599u,	0xCD15F9E7u,	0x95C62C9Du,	0x8B36B0E3u,	0xA8271461u,	0xB6D7881Fu,
+	0x1980BE95u,	0x077022EBu,	0x24618669u,	0x3A911A17u,	0x6242CF6Du,	0x7CB25313u,	0x5FA3F791u,	0x41536BEFu,
+	0x1100D4E6u,	0x0FF04898u,	0x2CE1EC1Au,	0x32117064u,	0x6AC2A51Eu,	0x74323960u,	0x57239DE2u,	0x49D3019Cu,
+	0xE6843716u,	0xF874AB68u,	0xDB650FEAu,	0xC5959394u,	0x9D4646EEu,	0x83B6DA90u,	0xA0A77E12u,	0xBE57E26Cu,
+	0xCC05F4A9u,	0xD2F568D7u,	0xF1E4CC55u,	0xEF14502Bu,	0xB7C78551u,	0xA937192Fu,	0x8A26BDADu,	0x94D621D3u,
+	0x3B811759u,	0x25718B27u,	0x06602FA5u,	0x1890B3DBu,	0x404366A1u,	0x5EB3FADFu,	0x7DA25E5Du,	0x6352C223u,
+	0x33017D2Au,	0x2DF1E154u,	0x0EE045D6u,	0x1010D9A8u,	0x48C30CD2u,	0x563390ACu,	0x7522342Eu,	0x6BD2A850u,
+	0xC4859EDAu,	0xDA7502A4u,	0xF964A626u,	0xE7943A58u,	0xBF47EF22u,	0xA1B7735Cu,	0x82A6D7DEu,	0x9C564BA0u,
+	0x2201A9CCu,	0x3CF135B2u,	0x1FE09130u,	0x01100D4Eu,	0x59C3D834u,	0x4733444Au,	0x6422E0C8u,	0x7AD27CB6u,
+	0xD5854A3Cu,	0xCB75D642u,	0xE86472C0u,	0xF694EEBEu,	0xAE473BC4u,	0xB0B7A7BAu,	0x93A60338u,	0x8D569F46u,
+	0xDD05204Fu,	0xC3F5BC31u,	0xE0E418B3u,	0xFE1484CDu,	0xA6C751B7u,	0xB837CDC9u,	0x9B26694Bu,	0x85D6F535u,
+	0x2A81C3BFu,	0x34715FC1u,	0x1760FB43u,	0x0990673Du,	0x5143B247u,	0x4FB32E39u,	0x6CA28ABBu,	0x725216C5u,
+	0x8806A731u,	0x96F63B4Fu,	0xB5E79FCDu,	0xAB1703B3u,	0xF3C4D6C9u,	0xED344AB7u,	0xCE25EE35u,	0xD0D5724Bu,
+	0x7F8244C1u,	0x6172D8BFu,	0x42637C3Du,	0x5C93E043u,	0x04403539u,	0x1AB0A947u,	0x39A10DC5u,	0x275191BBu,
+	0x77022EB2u,	0x69F2B2CCu,	0x4AE3164Eu,	0x54138A30u,	0x0CC05F4Au,	0x1230C334u,	0x312167B6u,	0x2FD1FBC8u,
+	0x8086CD42u,	0x9E76513Cu,	0xBD67F5BEu,	0xA39769C0u,	0xFB44BCBAu,	0xE5B420C4u,	0xC6A58446u,	0xD8551838u,
+	0x6602FA54u,	0x78F2662Au,	0x5BE3C2A8u,	0x45135ED6u,	0x1DC08BACu,	0x033017D2u,	0x2021B350u,	0x3ED12F2Eu,
+	0x918619A4u,	0x8F7685DAu,	0xAC672158u,	0xB297BD26u,	0xEA44685Cu,	0xF4B4F422u,	0xD7A550A0u,	0xC955CCDEu,
+	0x990673D7u,	0x87F6EFA9u,	0xA4E74B2Bu,	0xBA17D755u,	0xE2C4022Fu,	0xFC349E51u,	0xDF253AD3u,	0xC1D5A6ADu,
+	0x6E829027u,	0x70720C59u,	0x5363A8DBu,	0x4D9334A5u,	0x1540E1DFu,	0x0BB07DA1u,	0x28A1D923u,	0x3651455Du,
+	0x44035398u,	0x5AF3CFE6u,	0x79E26B64u,	0x6712F71Au,	0x3FC12260u,	0x2131BE1Eu,	0x02201A9Cu,	0x1CD086E2u,
+	0xB387B068u,	0xAD772C16u,	0x8E668894u,	0x909614EAu,	0xC845C190u,	0xD6B55DEEu,	0xF5A4F96Cu,	0xEB546512u,
+	0xBB07DA1Bu,	0xA5F74665u,	0x86E6E2E7u,	0x98167E99u,	0xC0C5ABE3u,	0xDE35379Du,	0xFD24931Fu,	0xE3D40F61u,
+	0x4C8339EBu,	0x5273A595u,	0x71620117u,	0x6F929D69u,	0x37414813u,	0x29B1D46Du,	0x0AA070EFu,	0x1450EC91u,
+	0xAA070EFDu,	0xB4F79283u,	0x97E63601u,	0x8916AA7Fu,	0xD1C57F05u,	0xCF35E37Bu,	0xEC2447F9u,	0xF2D4DB87u,
+	0x5D83ED0Du,	0x43737173u,	0x6062D5F1u,	0x7E92498Fu,	0x26419CF5u,	0x38B1008Bu,	0x1BA0A409u,	0x05503877u,
+	0x5503877Eu,	0x4BF31B00u,	0x68E2BF82u,	0x761223FCu,	0x2EC1F686u,	0x30316AF8u,	0x1320CE7Au,	0x0DD05204u,
+	0xA287648Eu,	0xBC77F8F0u,	0x9F665C72u,	0x8196C00Cu,	0xD9451576u,	0xC7B58908u,	0xE4A42D8Au,	0xFA54B1F4u }
+};
+/*反转表，copy from RSSP(RsspCommon.c) by lmy 20170416*/
+const CM_UINT8 CM_Reflected_Byte[256u] = {
+	0x00u,	0x80u,	0x40u,	0xC0u,	0x20u,	0xA0u,	0x60u,	0xE0u,
+	0x10u,	0x90u,	0x50u,	0xD0u,	0x30u,	0xB0u,	0x70u,	0xF0u,
+	0x08u,	0x88u,	0x48u,	0xC8u,	0x28u,	0xA8u,	0x68u,	0xE8u,
+	0x18u,	0x98u,	0x58u,	0xD8u,	0x38u,	0xB8u,	0x78u,	0xF8u,
+	0x04u,	0x84u,	0x44u,	0xC4u,	0x24u,	0xA4u,	0x64u,	0xE4u,
+	0x14u,	0x94u,	0x54u,	0xD4u,	0x34u,	0xB4u,	0x74u,	0xF4u,
+	0x0Cu,	0x8Cu,	0x4Cu,	0xCCu,	0x2Cu,	0xACu,	0x6Cu,	0xECu,
+	0x1Cu,	0x9Cu,	0x5Cu,	0xDCu,	0x3Cu,	0xBCu,	0x7Cu,	0xFCu,
+	0x02u,	0x82u,	0x42u,	0xC2u,	0x22u,	0xA2u,	0x62u,	0xE2u,
+	0x12u,	0x92u,	0x52u,	0xD2u,	0x32u,	0xB2u,	0x72u,	0xF2u,
+	0x0Au,	0x8Au,	0x4Au,	0xCAu,	0x2Au,	0xAAu,	0x6Au,	0xEAu,
+	0x1Au,	0x9Au,	0x5Au,	0xDAu,	0x3Au,	0xBAu,	0x7Au,	0xFAu,
+	0x06u,	0x86u,	0x46u,	0xC6u,	0x26u,	0xA6u,	0x66u,	0xE6u,
+	0x16u,	0x96u,	0x56u,	0xD6u,	0x36u,	0xB6u,	0x76u,	0xF6u,
+	0x0Eu,	0x8Eu,	0x4Eu,	0xCEu,	0x2Eu,	0xAEu,	0x6Eu,	0xEEu,
+	0x1Eu,	0x9Eu,	0x5Eu,	0xDEu,	0x3Eu,	0xBEu,	0x7Eu,	0xFEu,
+	0x01u,	0x81u,	0x41u,	0xC1u,	0x21u,	0xA1u,	0x61u,	0xE1u,
+	0x11u,	0x91u,	0x51u,	0xD1u,	0x31u,	0xB1u,	0x71u,	0xF1u,
+	0x09u,	0x89u,	0x49u,	0xC9u,	0x29u,	0xA9u,	0x69u,	0xE9u,
+	0x19u,	0x99u,	0x59u,	0xD9u,	0x39u,	0xB9u,	0x79u,	0xF9u,
+	0x05u,	0x85u,	0x45u,	0xC5u,	0x25u,	0xA5u,	0x65u,	0xE5u,
+	0x15u,	0x95u,	0x55u,	0xD5u,	0x35u,	0xB5u,	0x75u,	0xF5u,
+	0x0Du,	0x8Du,	0x4Du,	0xCDu,	0x2Du,	0xADu,	0x6Du,	0xEDu,
+	0x1Du,	0x9Du,	0x5Du,	0xDDu,	0x3Du,	0xBDu,	0x7Du,	0xFDu,
+	0x03u,	0x83u,	0x43u,	0xC3u,	0x23u,	0xA3u,	0x63u,	0xE3u,
+	0x13u,	0x93u,	0x53u,	0xD3u,	0x33u,	0xB3u,	0x73u,	0xF3u,
+	0x0Bu,	0x8Bu,	0x4Bu,	0xCBu,	0x2Bu,	0xABu,	0x6Bu,	0xEBu,
+	0x1Bu,	0x9Bu,	0x5Bu,	0xDBu,	0x3Bu,	0xBBu,	0x7Bu,	0xFBu,
+	0x07u,	0x87u,	0x47u,	0xC7u,	0x27u,	0xA7u,	0x67u,	0xE7u,
+	0x17u,	0x97u,	0x57u,	0xD7u,	0x37u,	0xB7u,	0x77u,	0xF7u,
+	0x0Fu,	0x8Fu,	0x4Fu,	0xCFu,	0x2Fu,	0xAFu,	0x6Fu,	0xEFu,
+	0x1Fu,	0x9Fu,	0x5Fu,	0xDFu,	0x3Fu,	0xBFu,	0x7Fu,	0xFFu
+};
 /**
 * @brief CRC32函数
 * @param pData 数据指针
@@ -86,3 +177,92 @@ CM_UINT32 CM_Crc32(IN const CM_UINT8 pData[],IN CM_UINT32 dataLen)
     /*- 返回CRC结果 */
 	return crc;
 }
+/*************************************************************
+*  功能描述： Crc32计算函数，使用CRC32查找表1
+*  参数说明：
+*             pData,    数据指针
+*             DataLen,  数据长度（字节）
+*  返回值：   返回值crc32Result为CRC值
+*  说明：     为保障平台小型化系统处理的安全性增加该CRC算法
+*             add by lmy 20180411
+**************************************************************/
+CM_UINT32 CM_Crc32_1(const CM_UINT8 *pData, CM_UINT32 DataLen)
+{
+	CM_UINT32 crc32Result = 0u;
+
+	/*入口参数检查*/
+	if ((NULL != pData) && (0u < DataLen))
+	{
+		crc32Result = CM_Crc32_common(pData, DataLen, CM_CrcmTab[0u]);/*使用CRC32查找表计算CRC值*/
+	}
+	else
+	{
+		/*入口参数不合法*/
+		crc32Result = 0u;
+	}
+
+	return crc32Result;
+}
+
+/*************************************************************
+*  功能描述： Crc32函数，使用CRC32查找表2
+*  参数说明：
+*             pData,    数据指针
+*             DataLen,  数据长度（字节）
+*  返回值：   返回值crc32Result为CRC值
+*  说明：     为保障平台小型化系统处理的安全性增加该CRC算法
+*             add by lmy 20180411
+**************************************************************/
+CM_UINT32 CM_Crc32_2(const CM_UINT8 *pData, CM_UINT32 DataLen)
+{
+	CM_UINT32 crc32Result = 0u;
+
+	/*入口参数检查*/
+	if ((NULL != pData) && (0u < DataLen))
+	{
+		crc32Result = CM_Crc32_common(pData, DataLen, CM_CrcmTab[1u]);/*使用CRC32查找表计算CRC值*/
+	}
+	else
+	{
+		/*入口参数不合法*/
+		crc32Result = 0u;
+	}
+
+	return crc32Result;
+}
+
+/*************************************************************
+*  功能描述： Crc32计算函数
+*  参数说明：
+*             pData,    	数据指针
+*             DataLen,  	数据长度（字节）
+*			  CRC32Table,	CRC32查找表
+*  返回值：   返回值crc32Result为CRC值
+*  说明：     为保障平台小型化系统处理的安全性增加该CRC算法,
+*			  该函数与RSSP-I协议中的(RsspCommon.c)CRC_Compute_Crc函数功能相同，
+*			  但是参数不一样，需要注意。
+*             add by lmy 20180411
+**************************************************************/
+CM_UINT32 CM_Crc32_common(const CM_UINT8 *pData, CM_UINT32 DataLen, const CM_UINT32 *CRC32Table)
+{
+	CM_UINT32 index = 0u;
+	CM_UINT32 crc32Result = 0u;
+
+	/*入口参数检查*/
+	if ((NULL != pData) && (0u < DataLen) && (NULL != CRC32Table))
+	{
+		/*依据相应的查找表计算CRC*/
+		for(index = 0u; index < DataLen; index++)
+		{
+			crc32Result = (crc32Result >> 8u) ^ CRC32Table[(crc32Result ^ CM_Reflected_Byte[*pData]) & CM_UINT8_MAX];
+			pData++;
+		}
+	}
+	else
+	{
+		/*入口参数不合法*/
+		crc32Result = 0u;
+	}
+
+	return crc32Result;
+}

TSCP/src/MSCP/CM/CM_CRC32.h

@@ -1,17 +1,4 @@
-/**
-* @file CM_CRC32.h
-* @brief 计算32位CRC函数
-* @author GT-BU
-* @date 2021.02.01
-* @version V1.1
-* @copyright TCT
-* @par 修改日志
-* <table>
-* <tr><th>Date        <th>Version  <th>Author     <th>Description
-* <tr><td>2017.12.20  <td>V1.0     <td>MSCP项目组 <td>创建初始版本
-* <tr><td>2021.02.01  <td>V1.1     <td>GT-BU      <td>TSCP项目集成、更新
-* </table>
-*/
+
 
 #ifndef CM_CRC32_H_
 #define CM_CRC32_H_
@@ -26,7 +13,18 @@ extern "C"
 
 	/* 计算CRC */
 	CM_UINT32 CM_Crc32(IN const CM_UINT8 pData[],IN CM_UINT32 dataLen);
-
+	/*************************************************************
+	*  功能描述： Crc32计算函数，使用CRC32查找表1
+	**************************************************************/
+	CM_UINT32 CM_Crc32_1(const CM_UINT8 *pData, CM_UINT32 DataLen);
+	/*************************************************************
+	*  功能描述： Crc32函数，使用CRC32查找表2
+	**************************************************************/
+	CM_UINT32 CM_Crc32_2(const CM_UINT8 *pData, CM_UINT32 DataLen);
+	/*************************************************************
+	*  功能描述： Crc32计算函数
+	**************************************************************/
+	CM_UINT32 CM_Crc32_common(const CM_UINT8 *pData, CM_UINT32 DataLen, const CM_UINT32 *CRC32Table);
 #ifdef __cplusplus
 }
 #endif

TSCP/src/MSCP/CM/CM_Com.c

@@ -360,7 +360,7 @@ static ENUM_CM_RETURN CM_Com_Clear(STRUCT_QNX_FD* pCtrl)
 * - 正整数 接收报文长度
 * - 0 接收失败
 */
-ENUM_CM_RETURN CM_Com_LocalDataSend(OUT CM_UINT8* pBuf, IN CM_UINT16 BufSize)
+ENUM_CM_RETURN CM_Com_LocalDataSend(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize)
 {
 	ENUM_CM_RETURN rtnval = ENUM_CM_FALSE;
 	CM_INT32 cmpval = 0xff;

TSCP/src/MSCP/CM/CM_Com.h

@@ -53,7 +53,7 @@ void CM_Com_RcvOtherThreadInit(void);
 * - ������ ���ձ��ij���
 * - 0 ����ʧ��
 */
-ENUM_CM_RETURN CM_Com_LocalDataSend(OUT CM_UINT8* pBuf, IN CM_UINT16 BufSize);
+ENUM_CM_RETURN CM_Com_LocalDataSend(OUT CM_UINT8* pBuf, IN CM_UINT32 BufSize);
 
 /**
 * @brief ���ڱ������ݽ���

TSCP/src/MSCP/CM/CM_UDP.c

@@ -170,7 +170,7 @@ ENUM_CM_RETURN CM_UDP_Is_Write_Ready(IN CM_SOCKET sock)
 * - ENUM_CM_TRUE 成功
 * - ENUM_CM_FALSE 失败
 */
-ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockMode, IN CM_UINT32 addrIP, IN CM_UINT16 portNumber, IN CM_UINT32 maddr, IN CM_UINT8 broadFlag)
+ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockMode, IN CM_UINT32 addrIP, IN CM_UINT16 portNumber, IN CM_UINT32 maddr, IN ENUM_ETHERENT_TYPE broadType)
 {
     /*- 变量初始化 */
     CM_SOCKADDR_T addrHost;           /* 主机地址 */
@@ -180,6 +180,7 @@ ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockM
     ENUM_CM_RETURN retError = ENUM_CM_FALSE; /* 临时返回值 */
     struct ip_mreq multiCast;         /* 组播配置 */           
     CM_INT32 bCast = 1;
+    CM_UINT8 loop;    /* 0 = disable, 1 = enable (default) */
     /*- 是否UDP服务未初始化或输入非法 */
     if ((CM_TRUE != s_UDP_Initialized) || (NULL == pSock))
     {
@@ -198,54 +199,53 @@ ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockM
         	retError = CM_Memset((void*) &addrHost, (CM_UINT8)0U, (size_t)(sizeof(CM_SOCKADDR_T)), (size_t)(sizeof(CM_SOCKADDR_T)));
             addrHost.sin_family = (CM_INT16)AF_INET;             
             addrHost.sin_port = htons(portNumber);
-#ifdef WIN32
-            addrHost.sin_addr.s_addr = addrIP;
-            if(1 == broadFlag)
+            /*组播发送*/
+            switch(broadType)
             {
-				/*广播*/
-				setsockopt(*pSock, SOL_SOCKET, SO_BROADCAST, (void*)(&bCast), (unsigned int)sizeof(bCast));
-            }
-			else
-			{
-				/*单播-组播*/
-			}
-#else
-            if(1u == broadFlag)
-            {
-            	/*广播*/
-            	addrHost.sin_addr.s_addr = INADDR_ANY;
-            	(void)setsockopt(*pSock, SOL_SOCKET, SO_BROADCAST, (void*)(&bCast), (unsigned int)sizeof(bCast));
-            }
-			else
-			{
-				if (0u != maddr)
-				{
-					/*组播*/
-					addrHost.sin_addr.s_addr = INADDR_ANY;
-					/*设置端口复用*/
-					(void)setsockopt(*pSock,SOL_SOCKET,SO_REUSEPORT ,(void*)(&bCast), (unsigned int)sizeof(bCast));
-					/*- 配置组播地址 */
-					multiCast.imr_interface.s_addr = addrIP;
-					multiCast.imr_multiaddr.s_addr = maddr;
-					ret = setsockopt(*pSock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*)(&multiCast), (unsigned int)sizeof(multiCast));
-				}
-				else
-				{
+				case ENUM_UNICAST:
 					/*单播*/
 					addrHost.sin_addr.s_addr = addrIP;
-				}
-			}
-#endif
+					break;
+				case ENUM_MULTICAST_SEND:
+					/*组播发送*/
+					addrHost.sin_addr.s_addr = addrIP;
+					(void)setsockopt(*pSock, IPPROTO_IP, IP_MULTICAST_IF, &addrHost.sin_addr, sizeof(addrHost.sin_addr));
+                    loop = 0u;
+                    (void)setsockopt(*pSock, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop));
+					break;
+				case ENUM_MULTICAST_RCV:
+					/*组播接收*/
+					if (0u != maddr)
+					{
+						/*组播*/
+						addrHost.sin_addr.s_addr = INADDR_ANY;
+						/*设置端口复用*/
+						(void)setsockopt(*pSock,SOL_SOCKET,SO_REUSEPORT ,(void*)(&bCast), (unsigned int)sizeof(bCast));
+						/*- 配置组播地址 */
+						multiCast.imr_interface.s_addr = addrIP;
+						multiCast.imr_multiaddr.s_addr = maddr;
+						(void)setsockopt(*pSock, IPPROTO_IP, IP_ADD_MEMBERSHIP, (void*)(&multiCast), (unsigned int)sizeof(multiCast));
+					}
+					else
+					{
+						printf("maddr is null!!\n");
+					}
+					break;
+				case ENUM_BROADCAST:
+					/*广播*/
+					addrHost.sin_addr.s_addr = INADDR_ANY;
+					(void)setsockopt(*pSock, SOL_SOCKET, SO_BROADCAST, (void*)(&bCast), (unsigned int)sizeof(bCast));
+					break;
+				default:
+					/*参数错误宕机*/
+					break;
+            }
             ret = (CM_INT32)bind(*pSock, (CM_SOCKADDR*) &addrHost, (unsigned int)sizeof(CM_SOCKADDR));
             /*- 绑定是否成功 */
             if ((ret != CM_SOCKET_ERROR) && (ENUM_CM_TRUE == retError))
             {
             	/*- 设置socket的阻塞模式 */
-#ifdef WIN32
-            	ret = ioctlsocket(*pSock, (long)FIONBIO, (unsigned long *)&isNonBlockMode);
-#else/*Linux Vxworks常用PIOX标准*/
             	ret = ioctl(*pSock, FIONBIO, &isNonBlockMode);
-#endif
                 /*- 设置socket的阻塞模式是否失败 */
                 if (CM_SOCKET_ERROR == ret)
                 {
@@ -270,6 +270,7 @@ ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockM
         else
 		{
 			/*- 无处理 */
+        	printf("socket create fial type = %d\n",broadType);
 		}
     }
     /*- 返回创建结果 */

TSCP/src/MSCP/CM/CM_UDP.h

@@ -28,7 +28,16 @@ extern "C"
     /** @brief UDP传输时分包的大小 */
 #define CM_UDP_LAN_MSG_SIZE_MAX (1472) /**< 局域网下每条UDP消息大小 */
 #define CM_UDP_WAN_MSG_SIZE_MAX (548)  /**< 广域网下每条UDP消息大小 */
-
+	/*定义枚举型函数返回值*/
+	typedef enum
+	{
+		ENUM_DISENABLE      = 0u,  /**< 禁用 */
+		ENUM_UNICAST        = 1u,  /**< 单播 */
+		ENUM_BROADCAST      = 2u,  /**< 广播 */
+		ENUM_MULTICAST_SEND = 3u,  /**< 组播发送 */
+		ENUM_MULTICAST_RCV  = 4u,  /**< 组播接收 */
+		ENUM_COM_TCP        = 5u   /**< TCP协议 */
+	}ENUM_ETHERENT_TYPE;
     /**
     * @brief CM_UDP_Init
     *
@@ -38,17 +47,17 @@ extern "C"
     ENUM_CM_RETURN CM_UDP_Init(void);
 
     /**
-    * @brief CM_UDP_Create_Socket
-    *
-    * Detailed description.
-    * @param[out] pSocket
-    * @param[in] isNonBlockMode
-    * @param[in] pAddrIP
-    * @param[in] portNumber
-    * @param[in] maddr
-    * @return ENUM_CM_RETURN
+    * @brief 创建UDP socket
+    * @param pSock socket指针
+    * @param isNonBlockMode 是否是非阻塞模式 CM_TRUE:非阻塞，CM_FALSE:阻塞
+    * @param addrIP IP地址
+    * @param portNumber 端口号
+    * @param maddr 所属组播地址，0为不加入组播
+    * @return 创建结果
+    * - ENUM_CM_TRUE 成功
+    * - ENUM_CM_FALSE 失败
     */
-    ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockMode, IN CM_UINT32 addrIP, IN CM_UINT16 portNumber, IN CM_UINT32 maddr, IN CM_UINT8 broadFlag);
+    ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockMode, IN CM_UINT32 addrIP, IN CM_UINT16 portNumber, IN CM_UINT32 maddr, IN ENUM_ETHERENT_TYPE broadType);
 
     /**
     * @brief CM_UDP_Send_Msg

TSCP/src/MSCP/DFM/DFM_Time.c

@@ -121,3 +121,5 @@ CM_UINT32 DFM_GetBirthCount(void)
     /*- 返回上电周期号 */
     return g_MSCP_BirthCount;
 }
+
+

TSCP/src/MSCP/MSCP_APP_API.c

@@ -285,10 +285,10 @@ CM_UINT8 MSCP_InnetRaw_AppSend(IN CM_INT32 ch, IN CM_UINT16 dstName, IN const CM
 /*
 * @brief 获取上一周期的本系热备状态
 * @return 本系热备状态
-* - ENUM_2x2_OFFLINE 离线
-* - ENUM_2x2_PRE_MASTER 预升主
-* - ENUM_2x2_MASTER 主系
-* - ENUM_2x2_SLAVE 备系
+* - ENUM_4x2_OFFLINE 离线
+* - ENUM_4x2_PRE_MASTER 预升主
+* - ENUM_4x2_MASTER 主系
+* - ENUM_4x2_SLAVE 备系
 * @note
 * 宕机状态下应用逻辑不会被执行，
 * 所以应用本函数不可能返回“宕机”。
@@ -297,7 +297,7 @@ CM_UINT8 MSCP_InnetRaw_AppSend(IN CM_INT32 ch, IN CM_UINT16 dstName, IN const CM
 * 在“离线”和“备系”状态下且本周期收到有效跟随数据时，
 * 将在周期应用逻辑执行之前进行跟随数据覆盖。
 */
-ENUM_2x2_STATE_T MSCP_GetLastLocal2x2State(void)
+ENUM_4x2_STATE_T MSCP_GetLastLocal2x2State(void)
 {
 	return SFM_2x2_GetLastLocal2x2State();
 }
@@ -305,19 +305,45 @@ ENUM_2x2_STATE_T MSCP_GetLastLocal2x2State(void)
 /**
 * @brief 获取对系上一周期的热备状态
 * @return 对系热备状态
-* - ENUM_2x2_SHUTDOWN 宕机
-* - ENUM_2x2_OFFLINE 离线
-* - ENUM_2x2_PRE_MASTER 预升主
-* - ENUM_2x2_MASTER 主系
-* - ENUM_2x2_SLAVE 备系
+* - ENUM_4x2_SHUTDOWN 宕机
+* - ENUM_4x2_OFFLINE 离线
+* - ENUM_4x2_PRE_MASTER 预升主
+* - ENUM_4x2_MASTER 主系
+* - ENUM_4x2_SLAVE 备系
 * @note
 * 与对系通信中断时默认对系状态为“宕机”
 */
-ENUM_2x2_STATE_T MSCP_GetLastPartner2x2State(void)
+ENUM_4x2_STATE_T MSCP_GetLastPartner2x2State(void)
 {
 	return SFM_2x2_GetLastPartner2x2State();
 }
+/*
+* @brief 获取上一周期的区域A系热备状态
+* @return 本系热备状态
+* - ENUM_4x2_SHUTDOWN 宕机
+* - ENUM_4x2_OFFLINE 离线
+* - ENUM_4x2_MASTER 主系
+* - ENUM_4x2_SLAVE 备系
+*/
+ENUM_4x2_STATE_T MSCP_GetLastArea_A_2x2State(void)
+{
+	return SFM_2x2_GetLastArea_A_2x2State();
+}
 
+/**
+* @brief 获取上一周期的区域B系热备状态
+* @return 对系热备状态
+* - ENUM_4x2_SHUTDOWN 宕机
+* - ENUM_4x2_OFFLINE 离线
+* - ENUM_4x2_MASTER 主系
+* - ENUM_4x2_SLAVE 备系
+* @note
+* 与对系通信中断时默认对系状态为“宕机”
+*/
+ENUM_4x2_STATE_T MSCP_GetLastArea_B_2x2State(void)
+{
+	return SFM_2x2_GetLastArea_B_2x2State();
+}
 /**
 * @brief 设置跟随数据
 * @param[in] Data[] 跟随数据数组

TSCP/src/MSCP/MSCP_APP_API.h

@@ -160,10 +160,9 @@ extern "C"
     /*
 	* @brief 获取上一周期的本系热备状态
 	* @return 本系热备状态
-	* - ENUM_2x2_OFFLINE 离线
-	* - ENUM_2x2_PRE_MASTER 预升主
-	* - ENUM_2x2_MASTER 主系
-	* - ENUM_2x2_SLAVE 备系
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
 	* @note
 	* 宕机状态下应用逻辑不会被执行，
 	* 所以应用本函数不可能返回“宕机”。
@@ -172,21 +171,41 @@ extern "C"
 	* 在“离线”和“备系”状态下且本周期收到有效跟随数据时，
 	* 将在周期应用逻辑执行之前进行跟随数据覆盖。
 	*/
-	ENUM_2x2_STATE_T MSCP_GetLastLocal2x2State(void);
+	ENUM_4x2_STATE_T MSCP_GetLastLocal2x2State(void);
 
 	/**
 	* @brief 获取对系上一周期的热备状态
 	* @return 对系热备状态
-	* - ENUM_2x2_SHUTDOWN 宕机
-	* - ENUM_2x2_OFFLINE 离线
-	* - ENUM_2x2_PRE_MASTER 预升主
-	* - ENUM_2x2_MASTER 主系
-	* - ENUM_2x2_SLAVE 备系
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
 	* @note
 	* 与对系通信中断时默认对系状态为“宕机”
 	*/
-	ENUM_2x2_STATE_T MSCP_GetLastPartner2x2State(void);
+	ENUM_4x2_STATE_T MSCP_GetLastPartner2x2State(void);
 
+	/*
+	* @brief 获取上一周期的区域A系热备状态
+	* @return 本系热备状态
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	*/
+	ENUM_4x2_STATE_T MSCP_GetLastArea_A_2x2State(void);
+
+	/**
+	* @brief 获取上一周期的区域B系热备状态
+	* @return 对系热备状态
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	* @note
+	* 与对系通信中断时默认对系状态为“宕机”
+	*/
+	ENUM_4x2_STATE_T MSCP_GetLastArea_B_2x2State(void);
     /**
     * @brief 设置跟随数据
     * @param[in] Data[] 跟随数据数组

TSCP/src/MSCP/MSCP_APP_Interface.h

@@ -11,6 +11,8 @@ extern "C"
     * @{  */
 #define MSCP_MAIN_A (1u)   /**< 主机板A系 */
 #define MSCP_MAIN_B (2u)   /**< 主机板B系 */
+#define MSCP_MAIN_C (3u)	/**< 主机板C系 */
+#define MSCP_MAIN_D (4u)	/**< 主机板D系 */
 #define MSCP_CC_R   (3u)   /**< 红网通控 */
 #define MSCP_CC_B   (4u)   /**< 蓝网通控 */
     /** @}  */
@@ -39,13 +41,12 @@ typedef ENUM_CM_RETURN(*pSetAppfunc)(void); /* 应用周期调用函数 */
 	extern CM_UINT8  gCpuUsageParaFlag;
      /** 双机热备状态 */
     typedef enum {
-        ENUM_2x2_SHUTDOWN = 0, /**< 宕机 */
-        ENUM_2x2_OFFLINE,      /**< 离线 */
-        ENUM_2x2_PRE_MASTER,   /**< 预升主 */
-        ENUM_2x2_MASTER,       /**< 主系 */
-        ENUM_2x2_SLAVE         /**< 备系 */
-    } ENUM_2x2_STATE_T;
-
+        ENUM_4x2_SHUTDOWN = 0, /**< 宕机 */
+        ENUM_4x2_OFFLINE,      /**< 离线 */
+        ENUM_4x2_PRE_MASTER,   /**< 预升主 */
+		ENUM_4x2_MASTER,       /**< 主系 */
+        ENUM_4x2_SLAVE         /**< 备系 */
+    } ENUM_4x2_STATE_T;
     /** 应用通信通道 */
     typedef enum {
         ENUM_MSG_ERROR = 0,        /**< 保留值，禁止使用 */
@@ -138,7 +139,7 @@ typedef ENUM_CM_RETURN(*pSetAppfunc)(void); /* 应用周期调用函数 */
 	* - ENUM_CM_TRUE 成功
 	* - ENUM_CM_FALSE 失败（平台立即宕机）
 	* @note
-	* 当本系热备状态为：ENUM_2x2_OFFLINE，ENUM_2x2_SLAVE，且收到了邻系正确的跟随数据时
+	* 当本系热备状态为：ENUM_4x2_OFFLINE，ENUM_4x2_SLAVE，且收到了邻系正确的跟随数据时
 	* 本函数将在APP_API_MainFunc()之前执行；
 	* 否则，本函数不执行。
 	* 应用跟随数据的最大长度不得超过1024*1000字节

TSCP/src/MSCP/MSCP_main.c

@@ -39,6 +39,9 @@
 #include "PFM_CPUUsage.h"
 #include "SFM_Prtcl.h"
 #include "PFM_RemoteUpdate.h"
+#include "CFM_Sync.h"
+#include "Arb.h"
+#include "Area_Arb_Common.h"
 #if QNX
 #include <sys/neutrino.h>
 #include <sys/trace.h>
@@ -188,6 +191,8 @@ static void MSCP_Init(void)
     PFM_LOG_SET_STOPTIMER(TSCP_DARK_TSCPINIT);
     /*- 应用版本号初始化，必须在应用软件初始化前 */
     PFM_CFG_RegisterVerson_Init();
+    /*初始化读MainId.ini*/
+    PFM_CFG_MAINID_Init();
     /*- 应用软件初始化内网安全协议参数-以及配置文件参数 */
     APP_API_Data_Init();
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_API_DATA);
@@ -203,15 +208,8 @@ static void MSCP_Init(void)
     /*- 控制流状态监督初始化 */
     PFM_CFC_Init();
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_CFC);
-    /*- 是否开启2x2功能 */
-    if (0x55u == g_PFM_Cfg.M_2x2_Enable)
-    {
-#ifdef QNX
-		/*- 串口通信初始化*/
-		(void)CM_COM_INIT(115200u, 8u);
-		PFM_LOG_SET_INIT_STAGE(ENUM_INIT_COM);
-#endif /*QNX*/
-    }
+
+	PFM_LOG_SET_INIT_STAGE(ENUM_INIT_COM);
     /*- 微周期控制初始化 */
     PFM_Init();
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_MICROCYCLE);
@@ -223,6 +221,7 @@ static void MSCP_Init(void)
     PFM_LOG_SET_STOPTIMER(TSCP_DARK_SOFTTNIT);
     /*- CFM:网络通信初始化 */
     CFM_UpdateAnd2oo2_Net_Init();
+
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_UPDATE_NET);
     /*- 2取数据初始化  */
     SFM_2oo2_DataInit();
@@ -239,22 +238,15 @@ static void MSCP_Init(void)
 	PFM_LOG_SET_INIT_STAGE(ENUM_INIT_APP);
 	/*- 外网安全协议初始化 */
 	SFM_PrtclOutInit();
-
 	PFM_LOG_SET_INIT_STAGE(ENUM_INIT_PRTCL_RSSP);
     /*- 应用调度初始化(必须在应用软件初始化后) */
     s_appCtrlInit();
-
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_APP_CTRL);
-    /*- 是否开启2x2功能 */
-    if (0x55u == g_PFM_Cfg.M_2x2_Enable)
-    {
-#ifdef QNX
+    PFM_LOG_SET_INIT_STAGE(ENUM_INIT_2X2USART);
+    CFM_TimeSync_Init(2);//时间同步初始化
+    /* 区域初始化*/
+    Area_Arb_Common_Init();
 
-		/*- 开启临机串口接收线程*/
-		CM_Com_RcvOtherThreadInit();
-		PFM_LOG_SET_INIT_STAGE(ENUM_INIT_2X2USART);
-#endif
-    }
     /*- 是否开启2oo2功能 */
     if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
     {
@@ -295,13 +287,12 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 {
 	/*- 变量初始化 */
 	CM_UINT64 costlog[20];    /* 耗时记录 */
-	CM_INT32 delayTime = 0;   /* 延迟时间 */
 	CM_UINT64 leftTime = 0u;    /* 剩余时间 */
 	CM_INT64 offset_2oo2 = 0; /* 2oo2时钟修正量 */
 	CM_INT64 offset_2x2 = 0;  /* 2x2时钟修正量 */
 	CM_INT32 i = 0;           /* 循环变量 */
-	ENUM_2x2_STATE_T localState = ENUM_2x2_SHUTDOWN;
-	ENUM_2x2_STATE_T peerState = ENUM_2x2_SHUTDOWN;
+	ENUM_4x2_STATE_T localState = ENUM_4x2_SHUTDOWN;
+	ENUM_4x2_STATE_T peerState = ENUM_4x2_SHUTDOWN;
 	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
 	CM_UINT32 darkInPutTime = 0u;
 	CM_UINT32 darkOutPutTime = 0u;
@@ -332,15 +323,26 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
     PFM_CFC_WatchDog();
     /*- 清空通信缓冲区 */
     CFM_NetFlush();
+    Area_Clear_MQ();
 	/*发送2x状态结束信号量*/
     SFM_2x2_SemPost();
+    /*< 发送区域通信结束信号量*/
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        Area_Arb_Stop();
+    }
+    else
+    {
+        Area_Stop();
+    }
+    
 	(void)DFM_SetIO_OutPut(0x00u);
     /*- 循环执行周期逻辑 */
     while (1)
     {
 		/*- 更新周期号*/
 		g_MSCP_SysCount++;
-		localState = SFM_2x2_GetLocal2x2State();
+		localState = SFM_GetLocal4x2State();
 		peerState = SFM_2x2_GetPartner2x2State();
 		MSCP_LOG_MSG("time left:%lld us\n", leftTime);
 		MSCP_LOG_MSG("==========CPU:%d-%d=CYC=%d==M/S:0x%x==Partner:0x%x============\n",g_PFM_Cfg.BOARD_ID,g_PFM_Cfg.CPU_ID,g_MSCP_SysCount,localState,peerState);
@@ -408,6 +410,7 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 		SFM_2oo2_Reset_AutoRbootCut();
 		MSCP_LOG_MSG("timecurr 19 Time = %lld us\n", NOW_USED_TIME);
 		/*- 空闲微周期：等待新周期开始 */
+		CFM_Get_Offset(&offset_2x2, &offset_2oo2);
 		if (0 != offset_2oo2)
 		{
 			CM_ATOMIC_ADD(&g_CycBaseTick, offset_2oo2); /* parasoft-suppress GJB8114-R_1_7_2 "QNX宏不符合编码规范" */
@@ -445,7 +448,7 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 		PFM_CFC_WatchDog();
 		g_MSCP_BirthCount++;
 		MSCP_LOG_MSG("-----MSCP_BirthCount:%d,M/S:0x%x--Partner:0x%x,N/D:%d/%d-err_cut:%d,err_cyc:%d,apperr_cut:%d,apperr_cyc:%d---version:%d.%d.%d.%d\n",
-			g_MSCP_BirthCount,SFM_2x2_GetLocal2x2State(),SFM_2x2_GetPartner2x2State(),
+			g_MSCP_BirthCount,SFM_GetLocal4x2State(),SFM_2x2_GetPartner2x2State(),
 			MSCP_Get_AutoRbootCut(),g_PFM_Cfg.M_AutoReboot_Count,
 			s_2oo2_Ctrl.FrameCtrl.err_cut,s_2oo2_Ctrl.FrameCtrl.err_cyc,
 			s_2oo2_Ctrl_App.FrameCtrl.err_cut,s_2oo2_Ctrl_App.FrameCtrl.err_cyc,
@@ -453,33 +456,18 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 		DFM_Drv_CycLog();
 		/*TODO 发送2x状态起始信号量*/
 		SFM_2x2_Thread_PostStart();
+		/* 发送区域线程开始信号*/
+        if(0x55 != g_PFM_Cfg.M_Arb_Enable)
+        {
+            Area_Start();
+        }
+		
 		PFM_CFC_Check(24);
-		/*- @alias 2oo2周期校时 */
-		if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
-		{
-			MSCP_LOG_MSG("2oo2start time left:%lld us\n",leftTime);
-			costlog[0] = SFM_2oo2_Sync(&offset_2oo2);
-		}
-		else
-		{
-			costlog[0] = CM_GetTick();
-		}
+		/*- 发起校时请求*/
+		CFM_SendLocalARQ();
+		SFM_4x2_Sync();
 		PFM_CFC_Check(25);
-		/*- @alias 2x2周期校时 */
-		if (0x55u == g_PFM_Cfg.M_2x2_Enable)
-		{
-			MSCP_LOG_MSG("2x2start\n");
-			SFM_2x2_Sync(g_CycTick, &offset_2x2);
-		}
-		else
-		{
-			/* 无处理 */
-		}
-		costlog[1] = CM_GetTick();
 /**************↑↑↑↑↑禁止添加代码，包括打印！***************/
-		delayTime = (CM_INT32)CM_UNSIGNED_LONG_INT_EXP((costlog[0] - g_CycTick) / 1000u);
-		MSCP_LOG_MSG("2oo2 sync delay = %d us\n", delayTime);
-		MSCP_LOG_MSG("2x2 sync delay = %lld us\n", (costlog[1] - costlog[0]) / 1000u);
 		MSCP_LOG_MSG("BASE_CYC_CTRL_SYNC = %lld us\n", NOW_USED_TIME);
 /*- ***********数据输入阶段*/
 		/*#############输入微周期#############*/
@@ -656,7 +644,7 @@ static void SelfCheckInit(void)
 {
 #ifdef QNX
     /*- 文件自检初始化 */
-    PFM_FileInit();
+    //PFM_FileInit();
 	/*- 内存自检初始化*/
     PFM_MemCheck_Init();
 	/*- CPU自检初始化*/
@@ -669,16 +657,8 @@ static void SelfCheckInit(void)
 	PFM_BoardCheck_TolerateThreetimes();
 	selfCheckSemPost();
 	selfCheckSemWait();
-    /*- 是否开启2x2功能 */
-    if (0x55u == g_PFM_Cfg.M_2x2_Enable)
-    {
-		/*- 串口自检*/
-		PFM_UartComCheck();
-    }
-    else
-    {
-    	;
-    }
+	/*- 串口自检*/
+	PFM_UartComCheck();
 
 }
 
@@ -851,14 +831,14 @@ static void s_LogicProc(ENUM_CM_RETURN(*pAppfunc)(void))
 {
     /*- 变量初始化 */
     ENUM_CM_RETURN ret = ENUM_CM_FALSE;
-    ENUM_2x2_STATE_T localState = SFM_2x2_GetLocal2x2State();
+    ENUM_4x2_STATE_T localState = SFM_GetLocal4x2State();
     
 
     /*- 是否关闭了2x2功能 */
     if (0xAAu == g_PFM_Cfg.M_2x2_Enable)
     {
     	/*- 本系默认为主 */
-        localState = ENUM_2x2_MASTER;
+        localState = ENUM_4x2_MASTER;
     }
     else
     {
@@ -869,26 +849,26 @@ static void s_LogicProc(ENUM_CM_RETURN(*pAppfunc)(void))
     /*- 本系热备状态 */
     switch (localState)
     {
-    case ENUM_2x2_SHUTDOWN: /*-< 宕机 */
-        /*- 什么都不做*/
+    case ENUM_4x2_SHUTDOWN: /*-< 宕机 */
+    	ret = ENUM_CM_TRUE;
         /*- 返回 */
         break;
-    case ENUM_2x2_OFFLINE: /*-< 离线 */
+    case ENUM_4x2_OFFLINE: /*-< 离线 */
         /*- 执行周期逻辑(但不会被输出) */
         ret = (*pAppfunc)();
         /*- 返回 */
         break;
-    case ENUM_2x2_PRE_MASTER: /*-< 预升主 */
+    case ENUM_4x2_PRE_MASTER: /*-< 预升主 */
         /*- 执行周期逻辑(但不会被输出) */
         ret = (*pAppfunc)();
         /*- 返回 */
         break;
-    case ENUM_2x2_MASTER: /*-< 主系 */
+    case ENUM_4x2_MASTER: /*-< 主系 */
         /*- 执行周期逻辑(会被输出) */
         ret = (*pAppfunc)();
         /*- 返回 */
         break;
-    case ENUM_2x2_SLAVE:/*-< 备系 */
+    case ENUM_4x2_SLAVE:/*-< 备系 */
         /*- 执行应用周期逻辑(但不会被输出) */
         ret = (*pAppfunc)();
         /*- 返回 */

TSCP/src/MSCP/OFM/OFM_Base.c

@@ -0,0 +1,148 @@
+/*
+ * vos_Base.c
+ *
+ *  Created on: 2025年9月8日
+ *      Author: adan
+ */
+#include "CM_Types.h"
+#include "OFM_Base.h"
+#include "MSCP_Define.h"
+#include "CM_Socket.h"
+#include <pthread.h>
+
+#define CPU_MAX   16u
+
+/*
+ *设置cpu亲和力
+ * */
+void set_thread_affinity(CM_UINT32 mask_bits)
+{
+#if QNX
+    void* pmask = (void*)mask_bits;
+
+    ThreadCtl(_NTO_TCTL_RUNMASK, pmask) ;
+#elif LINUX
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    for (int i = 0; mask_bits; i++)
+    {
+        /*根据输入参数掩码设置cpu*/
+        if (mask_bits & (1UL << i))
+        {
+            CPU_SET(i, &mask);
+        }
+    }
+    sched_setaffinity(0, sizeof(cpu_set_t), &mask);
+
+#elif SylixOS
+    cpu_set_t mask;
+    CPU_ZERO(&mask);
+    for (int i = 0; i < CPU_MAX; i++)
+    {
+        /*根据输入参数掩码设置cpu*/
+        if (mask_bits & (1UL << i))
+        {
+            CPU_SET(i, &mask);
+        }
+    }
+    sched_setaffinity(0, sizeof(cpu_set_t), &mask);
+
+#elif ReWorks
+    cpuset_t affinity;
+    CM_THREAD_T tid;
+    CPUSET_ZERO(affinity);
+    /*根据输入参数掩码设置cpu*/
+    for (int i = 0; i < CPU_MAX; i++)
+    {
+        /*根据输入参数掩码设置cpu*/
+        if (mask_bits & (1UL << i))
+        {
+            CPUSET_SET(affinity, i);
+        }
+    }
+
+    tid = pthread_self();
+    pthread_affinity_set(tid, affinity);
+
+#else
+
+#endif
+}
+
+#if 0
+/*
+ * 设置网卡ip
+ * */
+void set_network_ip(CM_UINT8 *p_ifname, CM_UINT8 *p_ifaddr, CM_UINT8 *p_netmask, CM_UINT8 *p_gateway)
+{
+    const char *ifname  = NULL;//需要设置的网卡名
+    const char *ipaddr  = NULL;//需要设置的ip地址
+    const char *netmask = NULL;//需要设置的子网掩码
+    const char *gateway = NULL;//需要设置的网关
+
+
+    CM_SOCKET sockfd = 0;
+    struct ifreq ifr = {0};
+    int ret;
+    CM_SOCKADDR_T *sin = NULL;
+
+
+    if((NULL !=p_ifname)&&(NULL !=p_ifaddr)&&(NULL !=p_netmask)&&(NULL !=p_gateway))
+    {
+        ifname  =    p_ifname;
+        ipaddr  =    p_ifaddr;
+        netmask =    p_netmask;
+        gateway =    p_gateway;
+
+        //创建一个socket
+        sockfd = socket(AF_INET, SOCK_DGRAM, 0);
+        if(sockfd < 0)
+        {
+
+        }
+        else
+        {
+             memset(&ifr, 0, sizeof(struct ifreq));
+
+             strcpy(ifr.ifr_name, (const char *)ifname);
+             sin = (struct sockaddr_in *)&ifr.ifr_addr;
+             sin->sin_family = AF_INET;
+
+             /* IP地址设置 */
+             /*将点分十进制 转换为网络字节序*/
+             inet_aton(ipaddr, &(sin->sin_addr));
+             ret = ioctl(sockfd, SIOCSIFADDR, &ifr);
+             if(ret < 0)
+             {
+                 close(sockfd);
+                 /*设置ip失败*/
+
+             }
+             else
+             {
+                 /* 子网掩码设置 */
+                 inet_aton(netmask, &(sin->sin_addr));
+                 ret = ioctl(sockfd, SIOCSIFNETMASK, &ifr);
+                 if(ret < 0)
+                 {
+                     /*设置子网掩码失败*/
+                     close(sockfd);
+                 }
+                 else
+                 {
+
+                     /*暂不设置网关*/
+                 }
+             }
+
+        }
+    }
+    else
+    {
+        //CM_ASSERT(0,MAIN_MODE, DARK_FAULT_CODE_FUN_ORDER_3, TSCP_DARK_ASSERT_1);
+    }
+}
+
+#endif
+
+

TSCP/src/MSCP/OFM/OFM_Base.h

@@ -0,0 +1,83 @@
+
+/*
+ * vos_Base.h
+ *
+ *  Created on: 2025年9月8日
+ *      Author: adan
+ */
+
+#ifndef SRC_VOS_VOS_BASE_H_
+#define SRC_VOS_VOS_BASE_H_
+
+#include "CM_Types.h"
+
+#if QNX
+#include <sys/neutrino.h>
+#include <sys/trace.h>
+#include <sys/neutrino.h> /* ThreadCtl BMP绑定CPU*/
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <atomic.h>
+#include <stdatomic.h>
+#include <sys/types.h>
+
+#endif
+
+#if LINUX
+#include <pthread.h>
+#define _GNU_SOURCE
+#include <sched.h>
+#include <stdatomic.h>
+#endif
+
+#if SylixOS
+#include <pthread.h>
+#include <sched.h>
+#include <sys/socket.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <stdatomic.h>
+#include <sys/ioctl.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#endif
+
+#if ReWorks
+#include <cpuset.h>
+#include <stdatomic.h>
+#include <net_ioctl.h>
+#include <socket.h>
+#include <sockLib.h>
+#include <netinet/in.h>
+#include <arpa/inet.h>
+#include <net/if.h>
+#include <arpa/inet.h>
+#include <ioctl.h>
+#include <net/route.h>
+#include <netinet\tcp.h>
+#endif
+
+
+typedef fd_set vos_fd_set;/*将描述符集合更名为 vos_fd_set*/
+
+/*
+ * 设置线程亲和性
+ * */
+void set_thread_affinity(CM_UINT32 mask_bits);
+
+/*
+ * 设置网卡ip
+ * */
+void set_network_ip(CM_UINT8 *p_ifname, CM_UINT8 *p_ifaddr, CM_UINT8 *p_netmask, CM_UINT8 *p_gateway);
+
+
+/*
+ * 封装描述符集合
+ * */
+#define VOS_FD_ZERO(fd)      FD_ZERO(fd)
+#define VOS_FD_SET(sock,fd)  FD_SET(sock, fd)
+/* 将FD_ISSET封装成布尔语义：返回 0 或 1 1在集合中,0不在集合中*/
+#define VOS_FD_ISSET(sock, fd) ((FD_ISSET(sock, fd)) ? 1 : 0)
+
+#endif /* SRC_VOS_VOS_BASE_H_ */

TSCP/src/MSCP/PFM/PFM_Cfg.c

@@ -40,7 +40,7 @@
 CM_CHAR FS_FILE_PATH[100];
 
 /** 平台软件版本号 */
-const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 1u, 1u, 51u };
+const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 14u, 0u, 1u };
 /** 驱动软件版本号 */
 CM_UINT8 MSCP_DRV_VERION[4] = {0};
 /** 与维护一体机接口文档版本号(接口文档发生改变时升级版本号) */
@@ -63,6 +63,38 @@ static STRU_APP_CFG_T g_AppCfgInterface;
 static void s_str2md5(IN const CM_CHAR* str, OUT CM_UINT8 md5[16]);
 static void PFM_CFG_Check_BoardID(void);
 /**
+* @brief 确认其他CPUID
+*/
+static void PFM_CFG_Another_CPUID(CPUID_TYPE Local_CpuId,CPUID_TYPE *Peer_CpuId,CPUID_TYPE *Partner_CpuId,CPUID_TYPE *Partner_Area_A_CpuId,CPUID_TYPE *Partner_Area_B_CpuId);
+/**
+ * @brief 初始化读取mainid
+ */
+void PFM_CFG_MAINID_Init(void)
+{
+	/*- 读取ID信息 */
+	g_PFM_Cfg.CPU_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI,"ID","CPU_ID");
+	CM_NM_ASSERT(0u != g_PFM_Cfg.CPU_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_1);
+	g_PFM_Cfg.BOARD_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI, "ID", "BOARD_ID");
+	CM_NM_ASSERT(0u != g_PFM_Cfg.BOARD_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_2);
+
+	/*检查配置文件ID与硬件ID是否一致*/
+	PFM_CFG_Check_BoardID();
+
+	g_PFM_Cfg.OUTNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "OUTNET_ID");
+	CM_NM_ASSERT(0u != g_PFM_Cfg.OUTNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_3);
+	g_PFM_Cfg.INNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID");
+	CM_NM_ASSERT(0u != g_PFM_Cfg.INNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_4);
+
+	g_PFM_Cfg.INNET_ID_RM = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID_RM");
+	MSCP_LOG_MSG("Remote Update INNET_ID_RM = 0x%.2x",g_PFM_Cfg.INNET_ID_RM);
+	(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_INIT1, 5, \
+						sizeof(CM_UINT8),g_PFM_Cfg.CPU_ID,
+						sizeof(CM_UINT8),g_PFM_Cfg.BOARD_ID,
+						sizeof(CM_UINT16),g_PFM_Cfg.OUTNET_ID,
+						sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID,
+						sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID_RM);
+}
+/**
 * @brief 平台配置文件初始化
 */
 void PFM_CFG_Init(void)
@@ -70,6 +102,10 @@ void PFM_CFG_Init(void)
     /*- 变量初始化 */
     CM_INT32 cpuID = 0;  /* CPU ID*/
     CM_INT32 i = 0;      /* 循环变量 */
+    CPUID_TYPE Peer_CpuId 			= ENUM_CPUID_ERR;/*2oo2邻机CPUID*/
+    CPUID_TYPE Partner_CpuId 		= ENUM_CPUID_ERR;/*2x2对系CPUID*/
+    CPUID_TYPE Partner_Area_A_CpuId = ENUM_CPUID_ERR;/*4x2异地A系CPUID*/
+    CPUID_TYPE Partner_Area_B_CpuId = ENUM_CPUID_ERR;/*4x2异地B系CPUID*/
     ENUM_CM_RETURN rt = 0;     /* 函数返回值 */
 	CM_UINT64 tickstart = 0; /* 上电时间计时 */
 	CM_CHAR buf[100];    /* 临时缓冲区 */
@@ -78,28 +114,7 @@ void PFM_CFG_Init(void)
         MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3], __DATE__, __TIME__);
     (void)printf("MSCP start version:%d.%d.%d.%d \n",
             MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3]);
-    /*- 读取ID信息 */
-    g_PFM_Cfg.CPU_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI,"ID","CPU_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.CPU_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_1);
-    g_PFM_Cfg.BOARD_ID = (CM_UINT8)CM_GetProfileInt(MAIN_ID_INI, "ID", "BOARD_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.BOARD_ID, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_2);
 
-    /*检查配置文件ID与硬件ID是否一致*/
-    PFM_CFG_Check_BoardID();
-
-    g_PFM_Cfg.OUTNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "OUTNET_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.OUTNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_3);
-    g_PFM_Cfg.INNET_ID = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID");
-    CM_NM_ASSERT(0u != g_PFM_Cfg.INNET_ID,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_4);
-
-    g_PFM_Cfg.INNET_ID_RM = (CM_UINT16)CM_GetProfileHex(MAIN_ID_INI, "ID", "INNET_ID_RM");
-    MSCP_LOG_MSG("Remote Update INNET_ID_RM = 0x%.2x",g_PFM_Cfg.INNET_ID_RM);
-    (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_INIT1, 5, \
-    					sizeof(CM_UINT8),g_PFM_Cfg.CPU_ID,
-    					sizeof(CM_UINT8),g_PFM_Cfg.BOARD_ID,
-						sizeof(CM_UINT16),g_PFM_Cfg.OUTNET_ID,
-    					sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID,
-						sizeof(CM_UINT16),g_PFM_Cfg.INNET_ID_RM);
     (void)strcpy(FS_FILE_PATH,g_AppCfgInterface.FS_NAME);
     (void)strcpy(g_PFM_Cfg.APP_NAME,g_AppCfgInterface.APP_NAME);
     MSCP_LOG_MSG("FS_NAME:%s\n",FS_FILE_PATH);
@@ -123,6 +138,9 @@ void PFM_CFG_Init(void)
     g_PFM_Cfg.CC_VER = 0u;
     g_PFM_Cfg.M_2oo2_Enable = g_AppCfgInterface.M_2oo2_Enable;
     g_PFM_Cfg.M_2x2_Enable = g_AppCfgInterface.M_2x2_Enable;
+    g_PFM_Cfg.M_4x2_Enable = g_AppCfgInterface.M_4x2_Enable;
+	g_PFM_Cfg.M_Arb_Enable = g_AppCfgInterface.M_Arb_Enable;
+    g_PFM_Cfg.M_2x2_Com_Cfg = g_AppCfgInterface.M_2x2_Com_Cfg;
     g_PFM_Cfg.M_InnetSafe_Enable = g_AppCfgInterface.M_InnetSafe_Enable;
     g_PFM_Cfg.M_InnetRaw_Enable = g_AppCfgInterface.M_InnetRaw_Enable;
     g_PFM_Cfg.M_OutnetSafe_Enable = g_AppCfgInterface.M_OutnetSafe_Enable;
@@ -133,11 +151,16 @@ void PFM_CFG_Init(void)
 	g_PFM_Cfg.reboot_replycount = g_AppCfgInterface.reboot_replycount;
 	g_PFM_Cfg.M_AutoReboot_Count = g_AppCfgInterface.M_AutoReboot_Count;
 	g_PFM_Cfg.M_AutoClear_Days = g_AppCfgInterface.M_AutoClear_Days;
+	g_PFM_Cfg.Multicast_Flag = g_AppCfgInterface.Multicast_Flag;/* 组播通信标志位，如果是0 则为单拨，否则为组播*/
+
 	MSCP_LOG_MSG("CYC_TIME:%d\n",g_PFM_Cfg.CYC_TIME);
 	MSCP_LOG_MSG("app_num:%d\n",g_PFM_Cfg.app_num);
 	MSCP_LOG_MSG("CC_VER:%d\n",g_PFM_Cfg.CC_VER);
 	MSCP_LOG_MSG("M_2oo2_Enable:0x%x\n",g_PFM_Cfg.M_2oo2_Enable);
 	MSCP_LOG_MSG("M_2x2_Enable:0x%x\n",g_PFM_Cfg.M_2x2_Enable);
+	MSCP_LOG_MSG("M_4x2_Enable:0x%x\n",g_PFM_Cfg.M_4x2_Enable);
+	MSCP_LOG_MSG("M_Arb_Enable:0x%x\n",g_PFM_Cfg.M_Arb_Enable);
+	MSCP_LOG_MSG("M_2x2_Com_Cfg:0x%x\n",g_PFM_Cfg.M_2x2_Com_Cfg);
 	MSCP_LOG_MSG("M_InnetSafe_Enable:0x%x\n",g_PFM_Cfg.M_InnetSafe_Enable);
 	MSCP_LOG_MSG("M_InnetRaw_Enable:0x%x\n",g_PFM_Cfg.M_InnetRaw_Enable);
 	MSCP_LOG_MSG("M_OutnetSafe_Enable:0x%x\n",g_PFM_Cfg.M_OutnetSafe_Enable);
@@ -160,27 +183,50 @@ void PFM_CFG_Init(void)
 	{
 		
 	}
-    /*- @alias 读取2x2oo2平台各CPU的通信配置 */
-    for (cpuID = 1; cpuID <= 4; cpuID++)
+    /*- @alias 读取4x2oo2平台各CPU的通信配置 */
+    for (cpuID = 1; cpuID <= 8; cpuID++)
     {
     	(void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_2oo2,g_AppCfgInterface.CPU[cpuID-1].IP_2oo2);
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data         = 51001;
-		g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data_App     = 51005;
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_2x2_State    = 51006;
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data         = 51001;	/*主线程2取端口*/
+		g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data_App     = 51002;
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_2x2_State    = 51003;
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Sync_Time    = 51004;	/*2取校时交互端口*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Sync_Req     = 51005;	/*2取校时发送请求端口*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Maintenance  = 51006;	/*维护模式2取端口*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Area  		= 51007;	/*区域2取端口*/
+        //g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Assert       = 51008;	/*宕机2取端口*/
 
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Time         = 51002;
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Maintenance  = 51004;
+        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_4x2,g_AppCfgInterface.CPU[cpuID-1].IP_4x2);
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_State         = 52001;/*2x独立线程通信端口，双网卡共用*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Data_Send     = 52002;/*加入组播发送*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Data_Rcv      = 52003;/*加入组播接收*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Syn_Send      = 52004;/*加入组播发送*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Syn_Rcv       = 52005;/*加入组播接收*/
 
-        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_2x2,g_AppCfgInterface.CPU[cpuID-1].IP_2x2);
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Data          = 52001;
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Time          = 52002;
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Syn           = 52003;
-        g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_State         = 52004;
+        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Area,g_AppCfgInterface.CPU[cpuID-1].IP_Area);
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_Area_State       	= 52010;/*4x2区域通信端口，双网卡共用*/
+		g_PFM_Cfg.CPU_CFG[cpuID].Port_Area_Send			= 52011;/*主地组播发送端口*/
+		g_PFM_Cfg.CPU_CFG[cpuID].Port_Area_Recv			= 52012;/*主地组播接收端口*/
 
+        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Sync_Time_A,	g_AppCfgInterface.CPU[cpuID-1].IP_Sync_Time_A);
+        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Sync_Time_B,	g_AppCfgInterface.CPU[cpuID-1].IP_Sync_Time_B);
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Sync_Time     = 52021;/*4x区域校时端口，双网卡可共用*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Sync_Req_A    = 52022;/*4x区域校时A请求端口*/
+        g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Sync_Req_B    = 52023;/*4x区域校时B请求端口*/
+
+        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Out,			g_AppCfgInterface.CPU[cpuID-1].IP_Out);
         (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Maintain,	g_AppCfgInterface.CPU[cpuID-1].IP_Maintain);
         (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Com,			g_AppCfgInterface.CPU[cpuID-1].IP_Com);
-        (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Out,			g_AppCfgInterface.CPU[cpuID-1].IP_Out);
         (void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Com_Extend,	g_AppCfgInterface.CPU[cpuID-1].IP_Com_Extend);
+        /*配置组播地址*/
+        if (1u == g_PFM_Cfg.CPU_ID)
+        {
+        	(void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Area_Multicast,g_AppCfgInterface.IP_Area_G_Multicast);
+        }
+        else
+        {
+        	(void)strcpy(g_PFM_Cfg.CPU_CFG[cpuID].IP_Area_Multicast,g_AppCfgInterface.IP_Area_P_Multicast);
+        }
 
         /*读取内网透传参数*/
         g_PFM_Cfg.CPU_CFG[cpuID].Port_Innet_Raw_Num = g_AppCfgInterface.Port_Innet_Raw_Num;
@@ -211,21 +257,26 @@ void PFM_CFG_Init(void)
         g_PFM_Cfg.CPU_CFG[cpuID].Port_Log_Ciphertext = g_AppCfgInterface.CPU[cpuID-1].Logger_PortCiphertext;
 		g_PFM_Cfg.CPU_CFG[cpuID].Port_Remote_Update = g_AppCfgInterface.Port_Remote_Update;
 		MSCP_LOG_MSG("CPU[%d]IP_2oo2:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_2oo2);
-		MSCP_LOG_MSG("CPU[%d]IP_2x2:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_2x2);
+		MSCP_LOG_MSG("CPU[%d]IP_4x2:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_4x2);
 		MSCP_LOG_MSG("CPU[%d]IP_Maintain:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_Maintain);
 		MSCP_LOG_MSG("CPU[%d]IP_Com:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_Com);
 		MSCP_LOG_MSG("CPU[%d]IP_Out:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_Out);
 		MSCP_LOG_MSG("CPU[%d]IP_Com_Extend:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_Com_Extend);
+		MSCP_LOG_MSG("CPU[%d]IP_Area:%s\n",cpuID,g_PFM_Cfg.CPU_CFG[cpuID].IP_Area);
 
-	    (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, (TSCP_DARK_PFMCFG_INIT2 + cpuID - 1), 18, \
+	    (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, (TSCP_DARK_PFMCFG_INIT2 + cpuID - 1), 22, \
 	    					sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data,
 	    					sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Data_App,
 							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_2x2_State,
-							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Time,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Sync_Time,
 							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Maintenance,
-							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Data,
-							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Time,
-							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_Syn,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Area,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2oo2_Assert,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_State,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Data_Send,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Data_Rcv,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Syn_Send,
+							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_4x2_Syn_Rcv,
 							sizeof(CM_UINT16),g_PFM_Cfg.CPU_CFG[cpuID].Port_2x2_State,
 							sizeof(CM_INT32),g_PFM_Cfg.CPU_CFG[cpuID].Port_Innet_Raw_Num,
 							sizeof(CM_INT32),g_PFM_Cfg.CPU_CFG[cpuID].Port_Innet_Raw_Extend_Num,
@@ -239,35 +290,71 @@ void PFM_CFG_Init(void)
     }
 
     /*- 确定本机通信配置 */
-    cpuID = (CM_INT32)CM_UNSIGNED_INT_EXP((((CM_UINT32)g_PFM_Cfg.BOARD_ID - 1u) * 2u) + (CM_UINT32)g_PFM_Cfg.CPU_ID);
-    rt = CM_Memcpy(&g_PFM_Cfg.Local_Cfg, sizeof(STRU_PFM_CPU_CFG_T), &g_PFM_Cfg.CPU_CFG[cpuID], sizeof(STRU_PFM_CPU_CFG_T));
-    CM_NM_ASSERT(ENUM_CM_TRUE == rt, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_9);
+	cpuID = (CM_INT32)CM_UNSIGNED_INT_EXP((((CM_UINT32)g_PFM_Cfg.BOARD_ID - 1u) * 2u) + (CM_UINT32)g_PFM_Cfg.CPU_ID);
+	rt = CM_Memcpy(&g_PFM_Cfg.Local_Cfg, sizeof(STRU_PFM_CPU_CFG_T), &g_PFM_Cfg.CPU_CFG[cpuID], sizeof(STRU_PFM_CPU_CFG_T));
+	CM_NM_ASSERT(ENUM_CM_TRUE == rt, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_9);
+	PFM_CFG_Another_CPUID(cpuID,&Peer_CpuId,&Partner_CpuId,&Partner_Area_A_CpuId,&Partner_Area_B_CpuId);
+	/*- 确定2oo2邻机通信配置 */
+	rt = CM_Memcpy(&g_PFM_Cfg.Peer_Cfg, sizeof(STRU_PFM_CPU_CFG_T), 			&g_PFM_Cfg.CPU_CFG[Peer_CpuId], sizeof(STRU_PFM_CPU_CFG_T));
+	/*- 确定2x2对系通信配置 */
+	rt = CM_Memcpy(&g_PFM_Cfg.Partner_Cfg, sizeof(STRU_PFM_CPU_CFG_T), 			&g_PFM_Cfg.CPU_CFG[Partner_CpuId], sizeof(STRU_PFM_CPU_CFG_T));
+	/*- 确定4x2异地A系通信配置 */
+	rt = CM_Memcpy(&g_PFM_Cfg.Partner_Area_A_Cfg, sizeof(STRU_PFM_CPU_CFG_T), 	&g_PFM_Cfg.CPU_CFG[Partner_Area_A_CpuId], sizeof(STRU_PFM_CPU_CFG_T));
+	/*- 确定4x2异地B系通信配置 */
+	rt = CM_Memcpy(&g_PFM_Cfg.Partner_Area_B_Cfg, sizeof(STRU_PFM_CPU_CFG_T), 	&g_PFM_Cfg.CPU_CFG[Partner_Area_B_CpuId], sizeof(STRU_PFM_CPU_CFG_T));
 
-    /*- 确定2oo2邻机通信配置 */
-    cpuID = (CM_INT32)CM_UNSIGNED_INT_EXP((((CM_UINT32)g_PFM_Cfg.BOARD_ID - 1u) * 2u) + (3u - (CM_UINT32)g_PFM_Cfg.CPU_ID));
-    rt = CM_Memcpy(&g_PFM_Cfg.Peer_Cfg, sizeof(STRU_PFM_CPU_CFG_T), &g_PFM_Cfg.CPU_CFG[cpuID], sizeof(STRU_PFM_CPU_CFG_T));
-    CM_NM_ASSERT(ENUM_CM_TRUE == rt,CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_10);
 
-    /*- 确定2x2对机（对系）通信配置 */
-    cpuID = (CM_INT32)CM_UNSIGNED_INT_EXP(((2u - (CM_UINT32)g_PFM_Cfg.BOARD_ID) * 2u) + (CM_UINT32)g_PFM_Cfg.CPU_ID);
-    rt = CM_Memcpy(&g_PFM_Cfg.Partner_Cfg, sizeof(STRU_PFM_CPU_CFG_T), &g_PFM_Cfg.CPU_CFG[cpuID], sizeof(STRU_PFM_CPU_CFG_T));
-    CM_NM_ASSERT(ENUM_CM_TRUE == rt, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_11);
+    /*- @alias 读取日志记录的IP配置 和通控配置 */
+	if (((CM_UINT8)1u == g_PFM_Cfg.CPU_ID) && (((CM_UINT8)1u == g_PFM_Cfg.BOARD_ID) || ((CM_UINT8)2u == g_PFM_Cfg.BOARD_ID)))
+	{
+		/*- 日志IP配置*/
+		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_G_IP_A);
+		/*- 通控IP配置*/
+    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_G_IP_A);
+    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_G_IP_A);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_G_IP_A);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_G_IP_A);
+		(void)strcpy(g_PFM_Cfg.Arb_CFG.IP_Arb,g_AppCfgInterface.Arb_CFG.IP_Arb_G);
+
+	}
+	else if(((CM_UINT8)2u == g_PFM_Cfg.CPU_ID) && (((CM_UINT8)1u == g_PFM_Cfg.BOARD_ID) || ((CM_UINT8)2u == g_PFM_Cfg.BOARD_ID)))
+	{
+		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_P_IP_A);
+		/*- 通控IP配置*/
+    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_P_IP_A);
+    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_P_IP_A);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_P_IP_A);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_P_IP_A);
+		(void)strcpy(g_PFM_Cfg.Arb_CFG.IP_Arb,g_AppCfgInterface.Arb_CFG.IP_Arb_P);
+	}
+	else if(((CM_UINT8)1u == g_PFM_Cfg.CPU_ID) && (((CM_UINT8)3u == g_PFM_Cfg.BOARD_ID) || ((CM_UINT8)4u == g_PFM_Cfg.BOARD_ID)))
+	{
+		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_G_IP_B);
+		/*- 通控IP配置*/
+    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_G_IP_B);
+    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_G_IP_B);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_G_IP_B);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_G_IP_B);
+		(void)strcpy(g_PFM_Cfg.Arb_CFG.IP_Arb,g_AppCfgInterface.Arb_CFG.IP_Arb_G);
+	}
+	else if(((CM_UINT8)2u == g_PFM_Cfg.CPU_ID) && (((CM_UINT8)3u == g_PFM_Cfg.BOARD_ID) || ((CM_UINT8)4u == g_PFM_Cfg.BOARD_ID)))
+	{
+		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_P_IP_B);
+		/*- 通控IP配置*/
+    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_P_IP_B);
+    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_P_IP_B);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_P_IP_B);
+    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_P_IP_B);
+		(void)strcpy(g_PFM_Cfg.Arb_CFG.IP_Arb,g_AppCfgInterface.Arb_CFG.IP_Arb_P);
+	}
+	else
+	{
+		MSCP_LOG_MSG("PFM Get Logger and CC IP fail\n");
+		CM_ASSERT(0,0,0,0);
+	}
+	MSCP_LOG_MSG("Logger_IP:%s\n CC_R_IP:%s\n CC_B_IP:%s\n EXTEND_R_IP:%s\n EXTEND_B_IP:%s\n, ARB_IP:%s",g_PFM_Cfg.Logger_IP,\
+			g_PFM_Cfg.CC_R_IP, g_PFM_Cfg.CC_B_IP, g_PFM_Cfg.EXTEND_R_IP, g_PFM_Cfg.EXTEND_B_IP, g_PFM_Cfg.Arb_CFG.IP_Arb);
 
-    /*- @alias 读取通控(CC)的IP配置 */
-    if (1u == g_PFM_Cfg.CPU_ID)
-    {
-    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_G_IP);
-    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_G_IP);
-    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_G_IP);
-    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_G_IP);
-    }
-    else
-    {
-    	(void)strcpy(g_PFM_Cfg.CC_R_IP,g_AppCfgInterface.OutNetRed.CC_P_IP);
-    	(void)strcpy(g_PFM_Cfg.CC_B_IP,g_AppCfgInterface.OutNetBlue.CC_P_IP);
-    	(void)strcpy(g_PFM_Cfg.EXTEND_R_IP,g_AppCfgInterface.OutNetRed.EXTEND_P_IP);
-    	(void)strcpy(g_PFM_Cfg.EXTEND_B_IP,g_AppCfgInterface.OutNetBlue.EXTEND_P_IP);
-    }    
     /*- 读取通控的端口配置 */
     g_PFM_Cfg.CC_R_OutnetSafe_Port = g_AppCfgInterface.OutNetRed.OutnetSafe_Port;
 	g_PFM_Cfg.CC_R_OutnetRaw_Port = g_AppCfgInterface.OutNetRed.OutnetRaw_Port;
@@ -278,6 +365,7 @@ void PFM_CFG_Init(void)
 	g_PFM_Cfg.CC_B_OutnetRaw_Port = g_AppCfgInterface.OutNetBlue.OutnetRaw_Port;
     g_PFM_Cfg.CC_B_InnetRaw_Port = g_AppCfgInterface.OutNetBlue.InnetRaw_Port;
     g_PFM_Cfg.CC_B_Heart_Port = 53003;
+	g_PFM_Cfg.Arb_CFG.Port_Arb = 56001;
     MSCP_LOG_MSG("CC_R_IP:%s\n",g_PFM_Cfg.CC_R_IP);
     MSCP_LOG_MSG("CC_B_IP:%s\n",g_PFM_Cfg.CC_B_IP);
     MSCP_LOG_MSG("EXTEND_R_IP:%s\n",g_PFM_Cfg.EXTEND_R_IP);
@@ -288,6 +376,7 @@ void PFM_CFG_Init(void)
     MSCP_LOG_MSG("CC_B_OutnetSafe_Port:%d\n",g_PFM_Cfg.CC_B_OutnetSafe_Port);
     MSCP_LOG_MSG("CC_B_OutnetRaw_Port:%d\n",g_PFM_Cfg.CC_B_OutnetRaw_Port);
     MSCP_LOG_MSG("CC_B_InnetRaw_Port:%d\n",g_PFM_Cfg.CC_B_InnetRaw_Port);
+	MSCP_LOG_MSG("ARB_Port:%d\n", g_PFM_Cfg.Arb_CFG.Port_Arb);
 
     (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_INIT3, 8, \
     					sizeof(CM_UINT16),g_PFM_Cfg.CC_R_OutnetSafe_Port,
@@ -298,17 +387,6 @@ void PFM_CFG_Init(void)
 						sizeof(CM_UINT16),g_PFM_Cfg.CC_B_OutnetRaw_Port,
 						sizeof(CM_UINT16),g_PFM_Cfg.CC_B_InnetRaw_Port,
 						sizeof(CM_UINT16),g_PFM_Cfg.CC_B_Heart_Port);
-
-    /*- @alias 读取日志记录的IP配置 */
-	if ((CM_UINT8)1u == g_PFM_Cfg.CPU_ID)
-	{
-		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_G_IP);
-	}
-	else
-	{
-		(void)strcpy(g_PFM_Cfg.Logger_IP,g_AppCfgInterface.Logger_P_IP);
-	}
-	MSCP_LOG_MSG("Logger_IP:%s\n",g_PFM_Cfg.Logger_IP);
     /*读取内网通信设备的通信配置*/
     /*- 读取内通信设备数量 */
     g_PFM_Cfg.INNET_COM_NUM = g_AppCfgInterface.INNET_COM_NUM;
@@ -648,6 +726,10 @@ void PFM_CFG_IfconfigIp(void)
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.145.101");
 		/*- 跳出 */
 		break;
+	case 0x03U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.147.101");
+		/*- 跳出 */
+		break;
 	/*1-2*/
 	case 0x55U:
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.16.102");
@@ -661,6 +743,10 @@ void PFM_CFG_IfconfigIp(void)
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.17.102");
 		/*- 跳出 */
 		break;
+	case 0x05U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.19.102");
+		/*- 跳出 */
+		break;
 	/*2-1*/
 	case 0xA6U:
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.144.103");
@@ -674,6 +760,10 @@ void PFM_CFG_IfconfigIp(void)
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.145.103");
 		/*- 跳出 */
 		break;
+	case 0xF6U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.147.103");
+		/*- 跳出 */
+		break;
 	/*2-2*/
 	case 0xAAU:
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.16.104");
@@ -687,6 +777,46 @@ void PFM_CFG_IfconfigIp(void)
 		sprintf(str, "ifconfig %s %s", "wm0", "192.168.17.104");
 		/*- 跳出 */
 		break;
+	case 0xFAU:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.19.104");
+		/*- 跳出 */
+		break;
+	/*3-1*/
+	case 0x83U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.146.201");
+		/*- 跳出 */
+		break;
+	case 0x23U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.144.201");
+		/*- 跳出 */
+		break;
+	/*3-2*/
+	case 0x85U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.18.202");
+		/*- 跳出 */
+		break;
+	case 0x25U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.16.202");	
+		/*- 跳出 */
+		break;
+	/*4-1*/
+	case 0x76U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.146.203");
+		/*- 跳出 */
+		break;
+	case 0xD6U:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.144.203");
+		/*- 跳出 */
+		break;
+	/*4-2*/
+	case 0x7AU:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.18.204");
+		/*- 跳出 */
+		break;
+	case 0xDAU:
+		sprintf(str, "ifconfig %s %s", "wm0", "192.168.16.204");
+		/*- 跳出 */
+		break;
 	default:
 		MSCP_LOG_MSG("drv_boardidErr:0x%x,ini:0x%x,0x%x\r\n",DrvBoard_ID,g_PFM_Cfg.BOARD_ID,g_PFM_Cfg.CPU_ID);
 		/*- 跳出 */
@@ -758,30 +888,54 @@ static void PFM_CFG_Check_BoardID(void)
 	case 0x53U:
 	case 0x33U:
 	case 0x63U:
-		CM_NM_ASSERT(((CM_UINT8)1U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+	case 0x03U:
+		CM_NM_ASSERT((((CM_UINT8)1U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 		/*- 跳出 */
 		break;
 	/*1-2*/
 	case 0x55U:
 	case 0x35U:
 	case 0x65U:
-		CM_NM_ASSERT(((CM_UINT8)1U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+	case 0x05U:
+		CM_NM_ASSERT((((CM_UINT8)1U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 		/*- 跳出 */
 		break;
 	/*2-1*/
 	case 0xA6U:
 	case 0xC6U:
 	case 0x96U:
-		CM_NM_ASSERT(((CM_UINT8)2U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+	case 0xF6U:
+		CM_NM_ASSERT((((CM_UINT8)2U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 		/*- 跳出 */
 		break;
 	/*2-2*/
 	case 0xAAU:
 	case 0xCAU:
 	case 0x9AU:
-		CM_NM_ASSERT(((CM_UINT8)2U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+	case 0xFAU:
+		CM_NM_ASSERT((((CM_UINT8)2U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 		/*- 跳出 */
 		break;
+	/*3-1*/
+	case 0x83U:
+	case 0x23U:
+		CM_NM_ASSERT((((CM_UINT8)3U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+		break;
+	/*3-2*/
+	case 0x85U:
+	case 0x25U:
+		CM_NM_ASSERT((((CM_UINT8)3U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+		break;
+	/*4-1*/
+	case 0x76U:
+	case 0xD6U:
+		CM_NM_ASSERT((((CM_UINT8)4U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)1U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+		break;
+	/*4-2*/
+	case 0x7AU:
+	case 0xDAU:
+		CM_NM_ASSERT((((CM_UINT8)4U == g_PFM_Cfg.BOARD_ID) && ((CM_UINT8)2U == g_PFM_Cfg.CPU_ID)), CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
+		break;
 	default:
 		MSCP_LOG_MSG("drv_boardidErr:0x%x,ini:0x%x,0x%x\r\n",DrvBoard_ID,g_PFM_Cfg.BOARD_ID,g_PFM_Cfg.CPU_ID);
 		CM_NM_ASSERT(0, CFG_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
@@ -790,7 +944,66 @@ static void PFM_CFG_Check_BoardID(void)
 	}
 #endif /*QNX*/
 }
-
+/**
+* @brief 确认其他CPUID
+*/
+static void PFM_CFG_Another_CPUID(CPUID_TYPE Local_CpuId,CPUID_TYPE *Peer_CpuId,CPUID_TYPE *Partner_CpuId,CPUID_TYPE *Partner_Area_A_CpuId,CPUID_TYPE *Partner_Area_B_CpuId)
+{
+	switch(Local_CpuId)
+	{
+	case ENUM_CPUID_A_A_1:
+		*Peer_CpuId 		  = ENUM_CPUID_A_A_2;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_A_B_1;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_B_A_1;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_B_B_1;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_A_A_2:
+		*Peer_CpuId 		  = ENUM_CPUID_A_A_1;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_A_B_2;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_B_A_2;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_B_B_2;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_A_B_1:
+		*Peer_CpuId 		  = ENUM_CPUID_A_B_2;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_A_A_1;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_B_A_1;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_B_B_1;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_A_B_2:
+		*Peer_CpuId 		  = ENUM_CPUID_A_B_1;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_A_A_2;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_B_A_2;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_B_B_2;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_B_A_1:
+		*Peer_CpuId 		  = ENUM_CPUID_B_A_2;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_B_B_1;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_A_A_1;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_A_B_1;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_B_A_2:
+		*Peer_CpuId 		  = ENUM_CPUID_B_A_1;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_B_B_2;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_A_A_2;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_A_B_2;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_B_B_1:
+		*Peer_CpuId 		  = ENUM_CPUID_B_B_2;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_B_A_1;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_A_A_1;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_A_B_1;/*4x2异地B系CPUID*/
+		break;
+	case ENUM_CPUID_B_B_2:
+		*Peer_CpuId 		  = ENUM_CPUID_B_B_1;/*2oo2邻机CPUID*/
+		*Partner_CpuId 		  = ENUM_CPUID_B_A_2;/*2x2对系CPUID*/
+		*Partner_Area_A_CpuId = ENUM_CPUID_A_A_2;/*4x2异地A系CPUID*/
+		*Partner_Area_B_CpuId = ENUM_CPUID_A_B_2;/*4x2异地B系CPUID*/
+		break;
+	default:
+		/*此处宕机*/
+		break;
+	}
+}
 void PFM_CFG_SendDarkCfg(void)
 {
     (void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_PFMCFG_SENDDARKCFG, 14u, \

TSCP/src/MSCP/PFM/PFM_Cfg.h

@@ -38,7 +38,19 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 #define MSCP_DOUBLE_PASS_ALL_NUM (INNET_RAW_DOUBLE_PASS_NUM + 5u)
 
 #define TSCP_CYC_DATAMAX_LEN (40000u)
-
+	/** CPUID */
+	typedef enum
+	{
+		ENUM_CPUID_ERR   = 0,  /**< 错误的CPUID */
+		ENUM_CPUID_A_A_1 = 1,  /**< A地A系cpu1*/
+		ENUM_CPUID_A_A_2 = 2,  /**< A地A系cpu2*/
+		ENUM_CPUID_A_B_1 = 3,  /**< A地B系cpu1*/
+		ENUM_CPUID_A_B_2 = 4,  /**< A地B系cpu2*/
+		ENUM_CPUID_B_A_1 = 5,  /**< B地A系cpu1*/
+		ENUM_CPUID_B_A_2 = 6,  /**< B地A系cpu2*/
+		ENUM_CPUID_B_B_1 = 7,  /**< B地B系cpu1*/
+		ENUM_CPUID_B_B_2 = 8,  /**< B地B系cpu2*/
+	}CPUID_TYPE;
     /** 网络通信开关类型 */
 	typedef enum
 	{
@@ -65,20 +77,36 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
         CM_CHAR IP_2oo2[32];      		  /**< 2oo2通信IP */
         CM_UINT16 Port_2oo2_Data; 		  /**< 2oo2数据通信端口 */
 		CM_UINT16 Port_2oo2_Data_App; 	  /**< 应用2oo2数据通信端口 */
-        CM_UINT16 Port_2oo2_Time; 		  /**< 2oo2校时端口 */
+        CM_UINT16 Port_2oo2_Sync_Time; 	  /**< 2oo2交互校时offset端口 */
+        CM_UINT16 Port_2oo2_Sync_Req; 	  /**< 2oo2校时请求端口 */
         CM_UINT16 Port_2oo2_Maintenance;  /**< 2oo2维护端口 */
         CM_UINT16 Port_2oo2_2x2_State;    /**< 2oo2 2x状态交互端口 */
+        CM_UINT16 Port_2oo2_Area;    	  /**< 2oo2 区域状态交互端口 */
+        CM_UINT16 Port_2oo2_Assert;    	  /**< 2oo2 宕机状态交互端口 */
 
-        CM_CHAR IP_2x2[32];       /**< 2x2通信IP */
-        CM_UINT16 Port_2x2_Data;  /**< 2x2数据通信端口 */
-        CM_UINT16 Port_2x2_Time;  /**< 2x2校时端口 */
-        CM_UINT16 Port_2x2_Syn;   /**< 2x2同步端口 */
-        CM_UINT16 Port_2x2_State;   /**< 2x2状态交互端口 */
+        CM_CHAR IP_4x2[32];       		/**< 4x2通信IP */
+        CM_UINT16 Port_4x2_Data_Send;   /**< 4x2组播数据发送端口 */
+        CM_UINT16 Port_4x2_Data_Rcv;	/**< 4x2组播数据接收端口 */
+        CM_UINT16 Port_4x2_Syn_Send;    /**< 4x2组播同步发送端口 */
+        CM_UINT16 Port_4x2_Syn_Rcv;     /**< 4x2组播同步接收端口 */
+        CM_UINT16 Port_2x2_State;   	/**< 2x2状态交互端口 */
+
+        CM_CHAR IP_Area[32];  	  		/**< 区域通信IP */
+        CM_UINT16 Port_Area_State;      /**< 4x2区域状态交互端口 */
+        CM_UINT16 Port_Area_Send;       /**< 组播发送端口 */
+        CM_UINT16 Port_Area_Recv;       /**< 组播接收端口 */
+
+		CM_CHAR IP_Sync_Time_A[32];  	/**< 校时A通信IP */
+		CM_CHAR IP_Sync_Time_B[32];  	/**< 校时B通信IP */
+		CM_UINT16 Port_4x2_Sync_Time;  	/**< 4x2校时端口 */
+		CM_UINT16 Port_4x2_Sync_Req_A; 	/**< 4x2校时A请求端口 */
+		CM_UINT16 Port_4x2_Sync_Req_B; 	/**< 4x2校时B请求端口 */
 
         CM_CHAR IP_Com[32];           /**< 通用通信IP */
 		CM_CHAR IP_Out[32];           /**< 外网通信IP */
  		CM_CHAR IP_Com_Extend[32];    /**< 通用通信扩展IP */
  		CM_CHAR IP_Maintain[32];      /**< 维护通信IP */
+ 		CM_CHAR IP_Area_Multicast[32];/**< 组播通信IP */
         CM_UINT16 Port_Outnet_Safe;   /**< 外网安全通信端口 */
         CM_UINT16 Port_Innet_Safe;    /**< 内网安全通信端口 */    
         CM_UINT16 Port_Outnet_Raw;    /**< 外网透明传输端口 */
@@ -93,6 +121,18 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		CM_UINT16 Port_Remote_Update;   /**< 远程部署通信端口 */
     }STRU_PFM_CPU_CFG_T;
 
+    typedef struct
+    {
+        CM_CHAR IP_Arb_G[32];
+        CM_CHAR IP_Arb_P[32];
+    }STRU_APP_ARB_CFG_T;
+
+    typedef struct
+    {
+        CM_CHAR IP_Arb[32];
+        CM_UINT16 Port_Arb;
+    }STRU_PFM_ARB_CFG_T;
+
     /** 内网通信配置 */
     typedef struct
     {
@@ -118,6 +158,8 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
         CM_UINT16 OUTNET_ID;       /**< 外网通信ID */
         CM_UINT16 INNET_ID;        /**< 内网通信ID */
 		CM_UINT16 INNET_ID_RM;        /**< 远程部署内网通信ID */
+
+		CM_UINT8 Multicast_Flag;        /**< 通信组播标志位 */
         
         CM_UINT32 CYC_TIME;          /**< 系统周期 */
         CM_INT32 app_num;            /**< app任务数 */
@@ -125,12 +167,15 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
         CM_UINT32 OutnetSafePack_Len;/**< 外网安全通信最大数据长度(根据周期长度计算) */
         CM_UINT32 M_2oo2_Enable;      /**< 2oo2功能开关 */
         CM_UINT32 M_2x2_Enable;       /**< 2x2功能开关*/
+		CM_UINT32 M_4x2_Enable;       	/**< 4x2功能开关*/
+		CM_UINT32 M_2x2_Com_Cfg;       	/**< 2x2配置功能开关*/
         CM_UINT32 M_InnetSafe_Enable; /**< 内网安全通信功能开关 */
         CM_UINT32 M_InnetRaw_Enable;  /**< 内网透传通信功能开关 */
         CM_UINT32 M_OutnetSafe_Enable;/**< 外网安全通信功能开关 */
 		CM_UINT32 M_OutnetRaw_Enable;/**< 外网透传通信功能开关 */
 		CM_UINT8 M_CpuUsageGet_Enable;	  /**< CPU使用率获取功能开关 */
 		CM_UINT32 M_RemoteUpdate_Enable; /**< 远程部署内网安全通信功能开关 */
+        CM_UINT8 M_Arb_Enable;      /**< 仲裁功能开关 */
 		CM_CHAR Start_Path[32];      /**< 程序启动路径 */
 		CM_INT32 reboot_replycount;            /**< 重启确认报文回复次数 */
 		CM_UINT8 M_AutoReboot_Count;	  /**< 自动重启次数 */
@@ -139,6 +184,8 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
         STRU_PFM_CPU_CFG_T Local_Cfg;   /*本机通信配置*/
         STRU_PFM_CPU_CFG_T Peer_Cfg;    /*2oo2邻机通信配置*/
         STRU_PFM_CPU_CFG_T Partner_Cfg; /*2x2对机（对系）通信配置*/
+        STRU_PFM_CPU_CFG_T Partner_Area_A_Cfg; /*4x2异地(A系）通信配置*/
+        STRU_PFM_CPU_CFG_T Partner_Area_B_Cfg; /*4x2异地（B系）通信配置*/
         
         CM_CHAR CC_R_IP[32];       /**< 红网通控的内网IP */
         CM_CHAR EXTEND_R_IP[32];       /**< 红网扩展板卡的内网IP */        
@@ -154,12 +201,14 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
         CM_UINT16 CC_B_InnetRaw_Port;   /**< 蓝网CC的内网透传通信端口 */
         CM_UINT16 CC_B_Heart_Port;    /**< 蓝网CC的内网透传通信端口 */
 
+        STRU_PFM_ARB_CFG_T Arb_CFG;
+
         CM_CHAR Logger_IP[32];         /**< 日志记录IP */
         CM_UINT16 Logger_PortBase;     /**< 明文日志对端端口 */
 		CM_UINT16 Logger_PortCiphertext; /**< 暗文日志对端端口 */
 
         /*以下通常仅PFM_CFG内部使用*/
-        STRU_PFM_CPU_CFG_T CPU_CFG[5]; /**< 各CPU的通信配置，数组1-4有效 */
+        STRU_PFM_CPU_CFG_T CPU_CFG[9]; /**< 各CPU的通信配置，数组1-4有效 */
         CM_UINT16 INNET_COM_NUM;     /**< 内网通信设备数量 */
         STRU_PFM_INNET_CFG_T INNET_COM_CFG[256]; /**< 内网通信设备通信配置(数组1-INNET_COM_NUM有效) */
     }STRU_PFM_CFG_T;
@@ -188,9 +237,12 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 	{
 		/*注意IP字段必须为32字节*/
 		CM_CHAR IP_2oo2[32];      /**< 2oo2通信IP */
-		CM_CHAR IP_2x2[32];       /**< 2x2通信IP */
+		CM_CHAR IP_4x2[32];       /**< 2x2通信IP */
 		CM_CHAR IP_Out[32];       /**< 外网通信IP */
 		CM_CHAR IP_Maintain[32];  /**< 维护通信IP */
+		CM_CHAR IP_Area[32];  	  /**< 区域通信IP */
+		CM_CHAR IP_Sync_Time_A[32];  /**< 校时A通信IP */
+		CM_CHAR IP_Sync_Time_B[32];  /**< 校时B通信IP */
 		/*适用透传通道-选配*/
 		CM_CHAR IP_Com[32];       /**< 通用通信IP */
 		CM_CHAR IP_Com_Extend[32];/**< 通用通信扩展IP */
@@ -200,10 +252,14 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 	/** 应用外网配置数据 */
 	typedef struct
 	{
-		CM_CHAR CC_G_IP[32];       		/**< 通控的内网IP */
-		CM_CHAR CC_P_IP[32];       		/**< 通控的内网IP */
-		CM_CHAR EXTEND_G_IP[32];       	/**< 扩展板卡的内网IP */
-		CM_CHAR EXTEND_P_IP[32];       	/**< 扩展板卡的内网IP */
+		CM_CHAR CC_G_IP_A[32];       		/**< 通控的内网IP */
+		CM_CHAR CC_P_IP_A[32];       		/**< 通控的内网IP */
+		CM_CHAR CC_G_IP_B[32];       		/**< 通控的内网IP */
+		CM_CHAR CC_P_IP_B[32];       		/**< 通控的内网IP */
+		CM_CHAR EXTEND_G_IP_A[32];       	/**< 扩展板卡的内网IP */
+		CM_CHAR EXTEND_P_IP_A[32];       	/**< 扩展板卡的内网IP */
+		CM_CHAR EXTEND_G_IP_B[32];       	/**< 扩展板卡的内网IP */
+		CM_CHAR EXTEND_P_IP_B[32];       	/**< 扩展板卡的内网IP */
 		CM_UINT16 OutnetSafe_Port; 		/**< 外网安全通信端口 */
 		CM_UINT16 OutnetRaw_Port; 		/**< 外网透传通信端口 */
 		CM_UINT16 InnetRaw_Port;   		/**< 内网透传通信端口 */
@@ -219,6 +275,9 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		CM_INT32  app_num;            	/**< app任务数 */
 		CM_UINT32 M_2oo2_Enable;      	/**< 2oo2功能开关 */
 		CM_UINT32 M_2x2_Enable;       	/**< 2x2功能开关*/
+		CM_UINT32 M_4x2_Enable;       	/**< 4x2功能开关*/
+        CM_UINT8  M_Arb_Enable;          /**< 仲裁功能开关 */
+		CM_UINT32 M_2x2_Com_Cfg;       	/**< 2x2配置功能开关*/
 		CM_UINT32 M_InnetSafe_Enable; 	/**< 内网安全通信功能开关 */
 		CM_UINT32 M_InnetRaw_Enable;  	/**< 内网透传通信功能开关 */
 		CM_UINT32 M_OutnetSafe_Enable;	/**< 外网安全通信功能开关 */
@@ -231,7 +290,9 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		CM_UINT8 M_AutoReboot_Count;	 /**< 自动重启次数 */
 		CM_UINT16 M_AutoClear_Days;	  	 /**< 连续运行多久清空宕机次数的天数 */
 		/*IP配置*/
-		STRU_APP_CPU_CFG_T CPU[4];		 /*每个CPU的IP配置*/
+		STRU_APP_CPU_CFG_T CPU[8];		 /*每个CPU的IP配置*/
+		CM_CHAR IP_Area_G_Multicast[32];	 /**< 绿网区域组播通信端口 */
+		CM_CHAR IP_Area_P_Multicast[32];	 /**< 紫网区域组播通信端口 */
 		/*通用端口配置*/
 		CM_UINT16 Port_Outnet_Safe;   	 /**< 外网安全通信端口 */
 		CM_UINT16 Port_Innet_Safe;    	 /**< 内网安全通信端口 */
@@ -245,11 +306,19 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		STRU_APP_CC_CFG_T OutNetRed; 	/*外网红网通信配置*/
 		STRU_APP_CC_CFG_T OutNetBlue; 	/*外网蓝网通信配置*/
 		/*日志记录目标设备IP配置*/
-		CM_CHAR Logger_G_IP[32];         /**< 绿网日志记录IP */
-		CM_CHAR Logger_P_IP[32];         /**< 紫网日志记录IP */
+		CM_CHAR Logger_G_IP_A[32];         /**< A地绿网日志记录IP */
+		CM_CHAR Logger_P_IP_A[32];         /**< A地紫网日志记录IP */
+		CM_CHAR Logger_G_IP_B[32];         /**< B地绿网日志记录IP */
+		CM_CHAR Logger_P_IP_B[32];         /**< B地紫网日志记录IP */
+
+        /* 第三方仲裁通信配置*/
+        STRU_APP_ARB_CFG_T Arb_CFG;
+
 		/*内网通信设备注册最大支持0-254*/
 		CM_UINT16 INNET_COM_NUM;     /**< 内网通信设备数量 */
 		STRU_PFM_INNET_CFG_T INNET_COM_CFG[255]; /**< 内网通信设备通信配置(数组0-254有效) */
+
+		CM_UINT8 Multicast_Flag;  /*组播通信标志位*/
 	}STRU_APP_CFG_T;
 
     typedef struct

TSCP/src/MSCP/PFM/PFM_InputOutput.c

@@ -94,9 +94,9 @@ static void s_input_2x2sync(void)
 {
     /*- 变量初始化 */
     CM_INT32 i = 0;
-    ENUM_2x2_STATE_T state_2x2 = SFM_2x2_GetLocal2x2State(); /* 本系热备状态 */
+    ENUM_4x2_STATE_T state_2x2 = SFM_GetLocal4x2State(); /* 本系热备状态 */
     /*- 本机是否为主系 */
-    if (ENUM_2x2_MASTER == state_2x2)
+    if (ENUM_4x2_MASTER == state_2x2)
     {
         /*- 从第一个2x2oo2通信队列开始|是否遍历完成|下一个队列 */
         for (i = 1; i <= g_2x2oo2_data_num; i++)
@@ -455,7 +455,7 @@ void PFM_InputProc(void)
 {
     /*- 变量初始化 */
     CM_INT32 i = 0;
-    ENUM_2x2_STATE_T p_state_2x2 = ENUM_2x2_SHUTDOWN; /* 对系热备状态 */
+    ENUM_4x2_STATE_T p_state_2x2 = ENUM_4x2_SHUTDOWN; /* 对系热备状态 */
 
     /************************平台数据接收*************************/
     /*- 外网安全数据接收 */
@@ -557,7 +557,7 @@ void PFM_InputProc(void)
     	SFM_WriteInnetSafeRmInput(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_RemoteUpdate].p_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_RemoteUpdate].peer_len, ENUM_INNET_GREEN);
     	
     	
-        if (ENUM_2x2_MASTER == p_state_2x2)
+        if (ENUM_4x2_MASTER == p_state_2x2)
         {
             /* 对系为主系，只使用主系输入 */
             PFM_CFC_Check(40);
@@ -570,8 +570,6 @@ void PFM_InputProc(void)
             s_RxOutnetToSFM(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_rmt_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].rmt_mine_len);
             PFM_CFC_Check(43);
             s_RxOutnetToSFM(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_rmt_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].rmt_peer_len);
-            (void)CM_Memcpy(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].buf_size, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_rmt_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].rmt_mine_len);
-            (void)CM_Memcpy(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].buf_size, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_rmt_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].rmt_peer_len);
         }
         else
         {            
@@ -594,7 +592,7 @@ void PFM_InputProc(void)
     	SFM_WriteInnetSafeRmInput(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_RemoteUpdate].p_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_RemoteUpdate].mine_len, ENUM_INNET_PURPLE);
     	
     	
-        if (ENUM_2x2_MASTER == p_state_2x2)
+        if (ENUM_4x2_MASTER == p_state_2x2)
         {
             /* 对系为主系，只使用主系输入 */
             PFM_CFC_Check(40);
@@ -605,8 +603,7 @@ void PFM_InputProc(void)
             s_RxOutnetToSFM(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_rmt_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].rmt_peer_len);
             PFM_CFC_Check(43);
             s_RxOutnetToSFM(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_rmt_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].rmt_mine_len);
-            (void)CM_Memcpy(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].buf_size, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_rmt_mine_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].rmt_mine_len);
-            (void)CM_Memcpy(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].buf_size, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].p_rmt_peer_buf, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetRaw].rmt_peer_len);
+
         }
         else
         {
@@ -645,7 +642,7 @@ void PFM_OutputProc(void)
     CM_INT32 i = 0;                 /* 循环变量 */
     CM_UINT8 buf_peer[500] = { 0u }; /* 邻机接收缓冲区 */
     CM_INT32 ret = 0;               /* 临时变量 */
-    ENUM_2x2_STATE_T state_2x2 = ENUM_2x2_SHUTDOWN; /* 本系热备状态 */
+    ENUM_4x2_STATE_T state_2x2 = ENUM_4x2_SHUTDOWN; /* 本系热备状态 */
 
 
     /*########################从协议适配层获取输出数据########################*/
@@ -727,7 +724,7 @@ void PFM_OutputProc(void)
     if (0x55u == g_PFM_Cfg.M_2x2_Enable)
     {
 		/*热备状态切换*/
-		SFM_2x2_ChangeState();
+		SFM_4x2_ChangeState();
     }
     else
     {
@@ -735,11 +732,11 @@ void PFM_OutputProc(void)
     }
     PFM_CFC_Check(16);
     /*- 获取当前热备状态 */
-    state_2x2 = SFM_2x2_GetLocal2x2State();
+    state_2x2 = SFM_GetLocal4x2State();
     MSCP_LOG_MSG("SFM_2x2_GetSysCount() = %d, s_txSn = %d\n", SFM_2x2_GetSysCount(), SFM_GetTxSn());
     MSCP_LOG_MSG("timecurr 16.1 = %lld us\n", NOW_USED_TIME);
     /*- 本系是否为主 */
-    if (ENUM_2x2_MASTER == state_2x2)
+    if (ENUM_4x2_MASTER == state_2x2)
     {
     	MSCP_LOG_MSG("Out:innetSafe = %d, innetRaw = %d, outnetSafe = %d\n", (CM_UINT32)g_2x2oo2_tx[g_2x2oo2_base][s_2x2oo2_InnetSafe].buf_len, (CM_UINT32)PFM_RAW_TX(i).buf_len, (CM_UINT32)g_2x2oo2_tx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].buf_len);
         /*- 发送内网安全输出数据 */
@@ -806,9 +803,8 @@ void PFM_EndProc(void)
     if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
     {
         /*- 生成跟随数据的特征信息 */
-        crc = CM_Crc32(g_TxAppFollow, (CM_UINT32)g_TxAppFollow_len);
         CM_LongToChar((CM_UINT32)g_TxAppFollow_len, mybuf);
-        CM_LongToChar(crc, mybuf + 4);
+        CM_Memcpy(mybuf + 4, 4, g_TxAppFollow, 4);
         /*- 2oo2交换特征信息 */
         len = SFM_2oo2_Exchange_Currency(mybuf, 8, peerbuf, 8u, ENUM_2oo2_OUTPUT_CHECK);
         /*- 2oo2严格比较特征信息 */
@@ -1021,44 +1017,67 @@ CM_UINT32 PFM_OutnetRaw_AppRecv(OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize)
     CM_UINT32 msgLen = 0u; /* 消息长度 */
     CM_UINT32 rt = 0u;     /* 函数返回值 */
     ENUM_CM_RETURN ret = ENUM_CM_FALSE;
+    ENUM_4x2_STATE_T state_2x2 = SFM_2x2_GetLastPartner2x2State(); /*获取上周期对系热备状态*/
 	g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_index_log++;/*记录应用调用次数，每周期清零*/
+    CM_UINT8   *p_Mine_Buf  = NULL;
+    CM_UINT32  Mine_len     = 0u;
+    CM_UINT8   *p_Peer_Buf  = NULL;
+    CM_UINT32  Peer_len     = 0u;
+    CM_MUTEX_T *p_mutex     = NULL;
+    /*根据主备状态分配缓冲区 */
+    if(ENUM_4x2_MASTER != state_2x2)
+    {
+        p_Mine_Buf  = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_mine_buf;
+        Mine_len    = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].mine_len;
+        p_Peer_Buf  = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_peer_buf;
+        Peer_len    = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].peer_len;
+        p_mutex     = &g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex;
+    }
+    else
+    {
+        p_Mine_Buf  = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_rmt_mine_buf;
+        Mine_len    = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].rmt_mine_len;
+        p_Peer_Buf  = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_rmt_peer_buf;
+        Peer_len    = g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].rmt_peer_len;
+        p_mutex     = &g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex;
+    }
     /*- 入参检查 */
-    CM_ASSERT(NULL != rxBuf, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_21);
+    CM_ASSERT(((NULL != rxBuf) && (NULL != p_Mine_Buf) && (NULL != p_Peer_Buf) && (NULL != p_mutex)) , IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_21);
     /*- 自己是否是CPU1 */
     if (1u == g_PFM_Cfg.CPU_ID)
     {
         /*- 本机通道是否有数据未取走 */
-        if ((s_OutnetRaw_Mine_AppReadIndex + 4u) <= (CM_UINT32)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].mine_len))
+        if ((s_OutnetRaw_Mine_AppReadIndex + 4u) <= (CM_UINT32)Mine_len)
         {
-            msgLen = CM_LongFromChar(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_mine_buf + s_OutnetRaw_Mine_AppReadIndex);
+            msgLen = CM_LongFromChar(p_Mine_Buf + s_OutnetRaw_Mine_AppReadIndex);
             CM_RE_ASSERT(msgLen > 0u, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_1);
-            CM_RE_ASSERT((s_OutnetRaw_Mine_AppReadIndex + 4u + msgLen) <= (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].mine_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_2);
+            CM_RE_ASSERT((s_OutnetRaw_Mine_AppReadIndex + 4u + msgLen) <= (CM_UINT32)Mine_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_2);
             CM_RE_ASSERT((msgLen) <= rxSize, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_3);
             rt = msgLen;
             /*- 锁定接收通道 */
-			ret = CM_Mutex_Lock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_4);
-            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_mine_buf + s_OutnetRaw_Mine_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
+            ret = CM_Mutex_Lock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_4);
+            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(p_Mine_Buf + s_OutnetRaw_Mine_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
             /*- 解锁接收通道 */
-			ret = CM_Mutex_Unlock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_5);
+            ret = CM_Mutex_Unlock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_5);
             s_OutnetRaw_Mine_AppReadIndex += (CM_UINT32)msgLen + 4u;
         }
         /*- 邻机通道是否有数据未取走 */
-        else if ((s_OutnetRaw_Peer_AppReadIndex + 4u) < (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].peer_len)
+        else if ((s_OutnetRaw_Peer_AppReadIndex + 4u) < (CM_UINT32)Peer_len)
         {
-			msgLen = CM_LongFromChar(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_peer_buf + s_OutnetRaw_Peer_AppReadIndex);
+            msgLen = CM_LongFromChar(p_Peer_Buf + s_OutnetRaw_Peer_AppReadIndex);
             CM_RE_ASSERT(msgLen > 0u, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_6);
-            CM_RE_ASSERT((s_OutnetRaw_Peer_AppReadIndex + 4u + msgLen) <= (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].peer_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_7);
+            CM_RE_ASSERT((s_OutnetRaw_Peer_AppReadIndex + 4u + msgLen) <= (CM_UINT32)Peer_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_7);
             CM_RE_ASSERT((msgLen) <= rxSize, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_8);
             rt = msgLen;
             /*- 锁定接收通道 */
-			ret = CM_Mutex_Lock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_9);
-            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_peer_buf + s_OutnetRaw_Peer_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
+            ret = CM_Mutex_Lock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_9);
+            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(p_Peer_Buf + s_OutnetRaw_Peer_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
             /*- 解锁接收通道 */
-			ret = CM_Mutex_Unlock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_10);
+            ret = CM_Mutex_Unlock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_10);
             s_OutnetRaw_Peer_AppReadIndex += (CM_UINT32)msgLen + 4u;
         }
         else
@@ -1071,38 +1090,38 @@ CM_UINT32 PFM_OutnetRaw_AppRecv(OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize)
     {
 
         /*- 邻机通道是否有数据未取走 */
-        if ((s_OutnetRaw_Peer_AppReadIndex + 4u) < (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].peer_len)
+        if ((s_OutnetRaw_Peer_AppReadIndex + 4u) < (CM_UINT32)Peer_len)
         {
-			msgLen = CM_LongFromChar(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_peer_buf + s_OutnetRaw_Peer_AppReadIndex);
+            msgLen = CM_LongFromChar(p_Peer_Buf + s_OutnetRaw_Peer_AppReadIndex);
             CM_RE_ASSERT(msgLen > 0u, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_11);
-            CM_RE_ASSERT((s_OutnetRaw_Peer_AppReadIndex + 4u + msgLen) <= (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].peer_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_12);
+            CM_RE_ASSERT((s_OutnetRaw_Peer_AppReadIndex + 4u + msgLen) <= (CM_UINT32)Peer_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_12);
             CM_RE_ASSERT((msgLen) <= rxSize, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_13);
             rt = msgLen;
             /*- 锁定接收通道 */
-			ret = CM_Mutex_Lock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_14);
-            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_peer_buf + s_OutnetRaw_Peer_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
+            ret = CM_Mutex_Lock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_14);
+            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(p_Peer_Buf + s_OutnetRaw_Peer_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
             /*- 解锁接收通道 */
-			ret = CM_Mutex_Unlock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_15);
+            ret = CM_Mutex_Unlock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_15);
             s_OutnetRaw_Peer_AppReadIndex += (CM_UINT32)msgLen + 4u;
 
         }
         /*- 本机通道是否有数据未取走 */
-        else if ((s_OutnetRaw_Mine_AppReadIndex + 4u) <= (CM_UINT32)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].mine_len))
+        else if ((s_OutnetRaw_Mine_AppReadIndex + 4u) <= (CM_UINT32)Mine_len)
         {
-            msgLen = CM_LongFromChar(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_mine_buf + s_OutnetRaw_Mine_AppReadIndex);
+            msgLen = CM_LongFromChar(p_Mine_Buf + s_OutnetRaw_Mine_AppReadIndex);
             CM_RE_ASSERT(msgLen > 0u, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_16);
-            CM_RE_ASSERT((s_OutnetRaw_Mine_AppReadIndex + 4u + msgLen) <= (CM_UINT32)g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].mine_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_17);
+            CM_RE_ASSERT((s_OutnetRaw_Mine_AppReadIndex + 4u + msgLen) <= (CM_UINT32)Mine_len, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_17);
             CM_RE_ASSERT((msgLen) <= rxSize, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_18);
             rt = msgLen;
             /*- 锁定接收通道 */
-			ret = CM_Mutex_Lock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_19);
-            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].p_mine_buf + s_OutnetRaw_Mine_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
+            ret = CM_Mutex_Lock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_19);
+            (void)CM_Memcpy((void*)rxBuf, (CM_SIZE_T)rxSize, (void*)(p_Mine_Buf + s_OutnetRaw_Mine_AppReadIndex + 4u), (CM_SIZE_T)(msgLen));
             /*- 解锁接收通道 */
-			ret = CM_Mutex_Unlock(g_2x2oo2_rx[s_2x2oo2_app][s_2x2oo2_OutnetRaw].app_mutex);
-			CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_20);
+            ret = CM_Mutex_Unlock(*p_mutex);
+            CM_RE_ASSERT(ENUM_CM_TRUE == ret, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_8, TSCP_DARK_ASSERT_20);
             s_OutnetRaw_Mine_AppReadIndex += (CM_UINT32)msgLen + 4u;
 
         }
@@ -1110,8 +1129,7 @@ CM_UINT32 PFM_OutnetRaw_AppRecv(OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize)
         {
             /*- 双网都取完了，返回true */
         }
-
-    }			
+    }
     /*- 返回接收结果 */
     /* MSCP_LOG_MSG("PFM_OutnetRaw_AppRecv msgLen =%d\n",msgLen); */
 	/* MSCP_LOG_MSG("PFM_OutnetRaw_AppRecv rt =%d\n",rt); */
@@ -1501,7 +1519,7 @@ CM_UINT32 PFM_OutnetHeart_AppRecv(OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize)
     /*- 入参检查 */
     CM_ASSERT(NULL != rxBuf, IN_OUT_MODE, DARK_FAULT_CODE_FUN_ORDER_17, TSCP_DARK_ASSERT_1);
     /*- 本系是否为主系 */
-    if(ENUM_2x2_MASTER == SFM_2x2_GetLastLocal2x2State())
+    if(ENUM_4x2_MASTER == SFM_2x2_GetLastLocal2x2State())
     {
 		/*- 自己是否是CPU1 */
 		if (1u == g_PFM_Cfg.CPU_ID)
@@ -1594,7 +1612,7 @@ CM_UINT32 PFM_OutnetHeart_AppRecv(OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize)
 		}
     }
     /*- 对系是否是主系 */
-    else if(ENUM_2x2_MASTER == SFM_2x2_GetLastPartner2x2State())
+    else if(ENUM_4x2_MASTER == SFM_2x2_GetLastPartner2x2State())
     {
     	/*- 自己是否是CPU1 */
 		if (1u == g_PFM_Cfg.CPU_ID)

TSCP/src/MSCP/PFM/PFM_Log.c

@@ -132,7 +132,7 @@ void MSCP_PFM_LOG_MSG(IN const CM_CHAR *filename, IN CM_INT32 line, IN const CM_
 #ifdef WIN32
         Bootprintf("%s", msgBuf + headLen);
 #endif
-        /* printf("%s", msgBuf + headLen);*/
+        //printf("%s", msgBuf + headLen);
         /*- 输出日志信息 */
         (void)CFM_BaseLog_Send((CM_UINT8*)msgBuf, headLen + msgLen);
     }
@@ -246,7 +246,7 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
     CM_INT32 rxLen = 0;
 	/*- 填充暗文故障码*/
     CM_UINT32 darkBuf = (Mode<<16u)|(faultCode<<8u)|funNum;
-	ENUM_2x2_STATE_T  localState = ENUM_2x2_SHUTDOWN;
+	ENUM_4x2_STATE_T  localState = ENUM_4x2_SHUTDOWN;
 	CM_UINT8 countFalse = 0xff;
 	CM_UINT8 tmepIndex = 0u;
 	/*- 全局宕机标志是否有效 */
@@ -270,6 +270,7 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
     	/*- 置位全局宕机标志 */
     	s_stopflag = 0x55u;
     	SFM_2x2_LOG_Transition();
+    	Area_LOG_Transition();
 		/*- 控制台输出断言失效信息 */
 		MSCP_LOG_MSG("ASSERT: %s:%s:%d,version:%d.%d.%d.%d,Cyc = %d,DefaultNum:0x%x\n", filename, func, line,MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3],g_MSCP_SysCount,darkBuf);
 		(void)printf("ASSERT: %s:%s:%d,version:%d.%d.%d.%d,Cyc = %d,DefaultNum:0x%x\n", filename, func, line,MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3],g_MSCP_SysCount,darkBuf);
@@ -329,7 +330,7 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
 		(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_INFO_ERR_TYPE, 4u, &darkBuf);/*发送暗文故障编码*/
 		/*- 更改热备状态为宕机,通过暗文再次发送热备状态帧(要保证这个帧是该暗文日志最后一个热备状态帧) */
 		SFM_2x2_SetLocal2x2State(localState);
-		localState = SFM_2x2_GetLocal2x2State();
+		localState = SFM_GetLocal4x2State();
 		(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_LOCAL, 1U, &localState);
 		/*- 暗文标志位至为发送 */
 		if(ENUM_INIT_MAIN_NET <= PFM_LOG_GET_INIT_STAGE())
@@ -381,6 +382,8 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
 		PFM_LOG_MaintenanceMode(MaintenanceFlag, darkBuf);
     }
 }
+
+
 /**
 * @brief 自动重启断言
 * @param x 断言结果
@@ -398,7 +401,7 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
 	CM_UINT8 AutoReboot_Flag = 0u;
 	/*- 填充暗文故障码*/
     CM_UINT32 darkBuf = (Mode<<16u)|(faultCode<<8u)|funNum;
-	ENUM_2x2_STATE_T  localState = ENUM_2x2_SHUTDOWN;
+	ENUM_4x2_STATE_T  localState = ENUM_4x2_SHUTDOWN;
 	CM_UINT8 lightPs = 0x55;
 	/*- 全局宕机标志是否有效 */
 	if(0x55u == s_stopflag)
@@ -421,6 +424,7 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
     	/*- 置位全局宕机标志 */
     	s_stopflag = 0x55u;
     	SFM_2x2_LOG_Transition();
+		Area_LOG_Transition();
 		/*- 控制台输出断言失效信息 */
 		MSCP_LOG_MSG("MSCP_REBOOT_ASSERT: %s:%s:%d,version:%d.%d.%d.%d,Cyc = %d,DefaultNum:0x%x\n", filename, func, line,MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3],g_MSCP_SysCount,darkBuf);
 		(void)printf("MSCP_REBOOT_ASSERT: %s:%s:%d,version:%d.%d.%d.%d,Cyc = %d,DefaultNum:0x%x\n", filename, func, line,MSCP_SW_VERION[0], MSCP_SW_VERION[1], MSCP_SW_VERION[2], MSCP_SW_VERION[3],g_MSCP_SysCount,darkBuf);
@@ -445,7 +449,7 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
 		(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_PSLIGHT, 1U, &lightPs);
 		/*- 更改热备状态为宕机,通过暗文再次发送热备状态帧(要保证这个帧是该暗文日志最后一个热备状态帧) */
 		SFM_2x2_SetLocal2x2State(localState);
-		localState = SFM_2x2_GetLocal2x2State();
+		localState = SFM_GetLocal4x2State();
 		(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_LOCAL, 1U, &localState);
 		/*- 暗文标志位至为发送 */
 		if(ENUM_INIT_MAIN_NET <= PFM_LOG_GET_INIT_STAGE())
@@ -831,7 +835,7 @@ static void PFM_LOG_MaintenanceMode(CM_UINT32 MaintenanceFlag, CM_UINT32 darkBuf
 	CM_UINT64 s_count = 0;
 	ENUM_BOARD_STATE_T boardState = PFM_GetBoardState();
 	CM_UINT8 lightPs = 0x55;
-	ENUM_2x2_STATE_T localState = SFM_2x2_GetLocal2x2State();
+	ENUM_4x2_STATE_T localState = SFM_GetLocal4x2State();
 	CM_UINT64 costlog[2] = {0};
 	/*- 清空2取缓冲区数据 */
 	SFM_2oo2_CtrlInit();

TSCP/src/MSCP/PFM/PFM_RemoteUpdate.c

@@ -1051,7 +1051,7 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
 		CM_ShortToChar(g_RMUP_Cfg.OUTNET_ID, &txBuf[offset]);
 		offset += 2u;
 		/* 本系热备状态 */
-		m2x2State = SFM_2x2_GetLocal2x2State();
+		m2x2State = SFM_GetLocal4x2State();
 		txBuf[offset] = m2x2State;
 		offset += 1u;
 		/* 板卡类型(主机板\通控板\串口板) */
@@ -1178,7 +1178,7 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
 			txLen = offset - 2u;
 			CM_ShortToChar(txLen, &txBuf[0]);
 	        ret = Prtcl_InnetSafe_RmSend(dstName, txBuf, offset);
-			MSCP_LOG_MSG("offset = %d\n",offset);
+			MSCP_LOG_MSG("offset = %d send ret =%d\n",offset, ret);
 		}
 		else
 		{
@@ -1192,7 +1192,7 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
 			rxLen = offset - 2u;
 			CM_ShortToChar(rxLen, &rxBuf[0]);
 	        ret = Prtcl_InnetSafe_RmSend(dstName, rxBuf, offset);
-			MSCP_LOG_MSG("offset = %d\n",offset);
+			MSCP_LOG_MSG("offset = %d send ret = %d\n",offset, ret);
 		}
 	}
 	else
@@ -1881,7 +1881,7 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
 	CM_UINT8 boottype = 0u;/**<临时 重启请求命令  0x55:未更新重启  0xaa:升级重启 0xd1~d7:硬重启 */
 	static CM_UINT8 s_boottype = 0u;/**<静态 重启请求命令  0x55:未更新重启  0xaa:升级重启 ,0xd1~d7:硬重启 */
 	CM_UINT8 recvType = 0u;
-	ENUM_2x2_STATE_T localState = SFM_2x2_GetLocal2x2State();
+	ENUM_4x2_STATE_T localState = SFM_GetLocal4x2State();
 	/*- 如果帧类型是一次请求确认 */
 	if(0xa5u == packType)
 	{
@@ -1939,7 +1939,7 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
 			(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_2));
 			MSCP_LOG_MSG("error pack 0xa5 boottype=%d\n",boottype);
 		}
-		else if((ENUM_2x2_SLAVE == localState) && ((boottype == 0xd1) || (boottype == 0xd7)))
+		else if((ENUM_4x2_SLAVE == localState) && ((boottype == 0xd1) || (boottype == 0xd7)))
 		{
 			/*- 非法包丢弃 */
 			s_boottype = 0u;
@@ -2064,9 +2064,9 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 	CM_UINT8 boardId = 0u;
 	CM_UINT32 packSwitchCrc = 0u; /*重启请求命令crc*/
 	CM_UINT8 recvType = 0u;
-	ENUM_2x2_STATE_T localState = SFM_2x2_GetLocal2x2State();
-	ENUM_2x2_STATE_T partnerState = SFM_2x2_GetPartner2x2State();
-	static ENUM_2x2_STATE_T s_firstState = ENUM_2x2_SHUTDOWN;
+	ENUM_4x2_STATE_T localState = SFM_GetLocal4x2State();
+	ENUM_4x2_STATE_T partnerState = SFM_2x2_GetPartner2x2State();
+	static ENUM_4x2_STATE_T s_firstState = ENUM_4x2_SHUTDOWN;
 
 	/*- 如果帧类型是一次请求确认 */
 	if(0xa7u == packType)
@@ -2111,7 +2111,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 					,s_switch2xFlag,s_switchRmFlag,g_iostate);
 			(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_14, TSCP_DARK_ASSERT_2));
 		}
-		else if(((localState + partnerState) != (ENUM_2x2_SLAVE + ENUM_2x2_MASTER)) || (1u == SFM_2x2_Get_LeastDoubleCom_State()))
+		else if(((localState + partnerState) != (ENUM_4x2_SLAVE + ENUM_4x2_MASTER)) || (1u == SFM_2x2_Get_LeastDoubleCom_State()))
 		{
 			/*- 切系状态未满足切系条件丢弃错误包  */
 			s_packSwitchAccredit = 1u;
@@ -2123,7 +2123,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 		{
 			s_packSwitchAccredit = 0u;
 			s_switchAuthorization = 0u;
-			s_firstState = SFM_2x2_GetLocal2x2State();
+			s_firstState = SFM_GetLocal4x2State();
 		}
 		/*首次应答*/
 		recvType = 0x57u;
@@ -2194,7 +2194,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 				二次请求 主离线 离线放，一次主回失败，一次时候得备回允许(兼容网络延迟 同上)
 				二次请求 备离线 同上
 			*/
-			if(ENUM_2x2_MASTER == s_firstState)
+			if(ENUM_4x2_MASTER == s_firstState)
 			{
 				/*- 而此请求热备状态不一致  */
 				s_packSwitchAccredit = 1u;
@@ -2211,7 +2211,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 			}
 		}
 		/*- 切换条件是否正确 */
-		else if(((localState + partnerState) != (ENUM_2x2_SLAVE + ENUM_2x2_MASTER)) || (1u == SFM_2x2_Get_LeastDoubleCom_State()))
+		else if(((localState + partnerState) != (ENUM_4x2_SLAVE + ENUM_4x2_MASTER)) || (1u == SFM_2x2_Get_LeastDoubleCom_State()))
 		{
 			/*- 切系状态未满足切系条件丢弃错误包  */
 			s_packSwitchAccredit = 1u;
@@ -2228,7 +2228,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
 		}
 		/*再次应答*/
 		recvType = 0x58u;
-		s_firstState = ENUM_2x2_SHUTDOWN;
+		s_firstState = ENUM_4x2_SHUTDOWN;
 	}
 	/*- 切系命令请求回复 */
 	PFM_RemoteSwitch_Send(recvType,packTimer,s_packSwitchAccredit,s_switchAuthorization);
@@ -2337,7 +2337,7 @@ void PFM_HardWareBoot_OutPut(void)
 		{
 			case 0xd1:
 				/*- 1100:PUB&IOB*/
-				if(ENUM_2x2_MASTER == SFM_2x2_GetLocal2x2State())
+				if(ENUM_4x2_MASTER == SFM_GetLocal4x2State())
 				{
 					MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 1\n");
 					checkselfret = PFM_HardWareBoot_CheckSelf(0x0Cu,ENUM_TYPE_PUB,type);
@@ -2378,7 +2378,7 @@ void PFM_HardWareBoot_OutPut(void)
 			case 0xd7:
 				/*- 1111:ALL*/
 				MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 8\n");
-				if(ENUM_2x2_MASTER == SFM_2x2_GetLocal2x2State())
+				if(ENUM_4x2_MASTER == SFM_GetLocal4x2State())
 				{
 					MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 9\n");
 					checkselfret = PFM_HardWareBoot_CheckSelf(0x0Fu,ENUM_TYPE_ALL,type);
@@ -2930,19 +2930,19 @@ CM_UINT8 PFM_CCUSEB_Comstate(CM_UINT8 type)
 	{
 	case 0:
 		/*- 判断红通控是否通信中断 */
-		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.CCU_A_Count) > 1)?1u:0u;
+		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.CCU_A_Count) > 3)?1u:0u;
 		break;
 	case 1:
 		/*- 判断蓝通控是否通信中断 */
-		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.CCU_B_Count) > 1)?1u:0u;
+		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.CCU_B_Count) > 3)?1u:0u;
 		break;
 	case 2:
 		/*- 判断红串口是否通信中断 */
-		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.SEB_A_Count) > 1)?1u:0u;
+		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.SEB_A_Count) > 3)?1u:0u;
 		break;
 	case 3:
 		/*- 判断蓝串口是否通信中断 */
-		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.SEB_B_Count) > 1)?1u:0u;
+		ret = ((g_Hardware_boot_com_state.SYS_Count - g_Hardware_boot_com_state.SEB_B_Count) > 3)?1u:0u;
 		break;
 	default:
 		ret = 1u;

TSCP/src/MSCP/PFM/PFM_SelfCheck.c

@@ -247,23 +247,30 @@ void PFM_UartComCheck(void)
 	CM_UINT16 offset = 2u;
 	CM_UINT8 SendBuf[20u] = {0u};
 	CM_UINT32 crc = 0u;
-
-	/*自检发送组包 2字节长度+1字节类型+1字节板卡ID+1字节CPUID+4字节CRC*/
-	SendBuf[offset] = (CM_UINT8)ENUM_COM_SelfCheck;
-	offset++;
-	SendBuf[offset] = g_PFM_Cfg.BOARD_ID;
-	offset++;
-	SendBuf[offset] = g_PFM_Cfg.CPU_ID;
-	offset++;
-	CM_ShortToChar((offset - (CM_UINT16)2u),&SendBuf[0u]);
-	crc = CM_Crc32(SendBuf,(CM_UINT32)offset);
-	CM_LongToChar(crc,&SendBuf[offset]);
-	len = offset + 4u;
+    /*- 是否开启2x2功能 */
+    if ((0x55u == g_PFM_Cfg.M_2x2_Enable) && (0x00 == g_PFM_Cfg.M_2x2_Com_Cfg))
+    {
+		/*自检发送组包 2字节长度+1字节类型+1字节板卡ID+1字节CPUID+4字节CRC*/
+		SendBuf[offset] = (CM_UINT8)ENUM_COM_SelfCheck;
+		offset++;
+		SendBuf[offset] = g_PFM_Cfg.BOARD_ID;
+		offset++;
+		SendBuf[offset] = g_PFM_Cfg.CPU_ID;
+		offset++;
+		CM_ShortToChar((offset - (CM_UINT16)2u),&SendBuf[0u]);
+		crc = CM_Crc32(SendBuf,(CM_UINT32)offset);
+		CM_LongToChar(crc,&SendBuf[offset]);
+		len = offset + 4u;
 #ifdef QNX
-	/*串口数据发送*/
-	ret = CM_Com_LocalDataSend(SendBuf,len);
-	CM_NM_ASSERT(ENUM_CM_TRUE == ret, SELF_CHECK_MODE, DARK_FAULT_CODE_FUN_ORDER_5, TSCP_DARK_ASSERT_1);
+		/*串口数据发送*/
+		ret = CM_Com_LocalDataSend(SendBuf,len);
+		CM_NM_ASSERT(ENUM_CM_TRUE == ret, SELF_CHECK_MODE, DARK_FAULT_CODE_FUN_ORDER_5, TSCP_DARK_ASSERT_1);
 #endif
+    }
+    else
+    {
+
+    }
 }
 
 /**

TSCP/src/MSCP/SFM/SFM_2oo2.c

@@ -604,151 +604,6 @@ CM_INT32 SFM_2oo2_Currency_App(IN const CM_UINT8 pMyData[], IN CM_INT32 DataLen,
     return rxLen;
 }
 
-/**
-* @brief 2oo2同步
-* @param pOffset 本机时钟调整量
-* @return 2oo2同步完成的时刻
-* @details
-* 通过互发时钟同步报文并检查接收的方式实现2oo2同步
-* 互发的同步报文同时交换了上一次时钟同步的结果
-* 每次2oo2同步之后都会发起一次新的时钟同步（由时钟同步线程接收、处理）
-*/
-CM_UINT64 SFM_2oo2_Sync(OUT CM_INT64 *pOffset)
-{
-    /*- 变量初始化 */
-	static CM_INT64 s_tm_mysum = 0;
-	static CM_INT64 s_tm_peersum = 0;
-	static CM_UINT32 s_tm_count = 0u;
-	static CM_UINT32 s_tm_nadd = 0u;
-	static CM_UINT32 s_tm_nsub = 0u;
-    CM_INT32 rxLen = 0;            /* 接收数据长度 */
-    CM_UINT8 myBuf[100] = { 0u };   /* 本机报文缓冲区 */
-    CM_UINT8 peerBuf[100] = { 0u }; /* 邻机报文缓冲区 */
-    CM_INT64 myDelay = 0;          /* 本机延迟时间 */
-    CM_INT64 myOffset = 0;         /* 本机偏移时间 */
-    CM_INT64 peerDelay = 0;
-    CM_INT64 peerOffset = 0;
-    CM_INT64 val = 0;
-    CM_INT64 aveOffset = 0;
-    CM_INT64 tempval = 0;       /*临时变量*/
-    CM_UINT64 rxTick = 0u;
-    CM_UINT64 costlog[20];    /* 耗时记录 */
-    ENUM_CM_RETURN ret = ENUM_CM_FALSE;
-    if(NULL != pOffset)
-    {
-    	costlog[0] = CM_GetTick();
-		/*- 取得上一次校时结果 */
-		ret = CFM_2oo2_TimeGet(&myDelay, &myOffset);
-		/*- 是否成功取得校时结果 */
-		if (ENUM_CM_TRUE == ret)
-		{
-			/*- 无处理 */
-		}
-		else
-		{
-			/*- 校时结果置为无效值 */
-			myDelay = (CM_INT64)CM_SIGNED_INT_EXP(100 * CM_MILLION);
-			myOffset = (CM_INT64)CM_SIGNED_INT_EXP(100 * CM_MILLION);
-		}
-
-		/*- 2oo2同步，并交换校时结果 */
-		CM_64ToChar(myDelay, myBuf);
-		CM_64ToChar(myOffset, myBuf + 8);
-		costlog[1] = CM_GetTick();
-		MSCP_LOG_MSG("SFM_2oo2_Sync1 = %d us\n", (costlog[1] - costlog[0]) / 1000u);
-		rxLen = SFM_2oo2_Exchange_Currency(myBuf, (CM_INT32)16, peerBuf, (CM_UINT32)16, ENUM_2oo2_SYNC);
-		costlog[2] = CM_GetTick();
-		MSCP_LOG_MSG("SFM_2oo2_Sync2 = %d us\n", (costlog[2] - costlog[1]) / 1000u);
-		/*- 记录同步完成时间 */
-		rxTick = CM_GetTick();
-
-		/*- 检查同步数据长度是否一致 */
-		CM_ASSERT(16 == rxLen, SFM_2oo2_MODE, DARK_FAULT_CODE_FUN_ORDER_10, TSCP_DARK_ASSERT_1);
-
-		/*- 发起下一次校时备用*/
-		CFM_2oo2_TimeReq();
-		costlog[3] = CM_GetTick();
-		MSCP_LOG_MSG("SFM_2oo2_Sync3 = %d us\n", (costlog[3] - costlog[2]) / 1000u);
-		(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_2OO2_SYNC_TIME,3u,
-								sizeof(CM_UINT64),(costlog[1] - costlog[0]) / 1000u,
-								sizeof(CM_UINT64),(costlog[2] - costlog[1]) / 1000u,
-								sizeof(CM_UINT64),(costlog[3] - costlog[2]) / 1000u);
-		peerDelay = (CM_INT64)CM_64FromChar(peerBuf);
-		peerOffset = (CM_INT64)CM_64FromChar(peerBuf + 8);
-		*pOffset = 0;
-		/*- 本次测得的偏移量是否在合理范围内 */
-		if ((CM_ABS(myOffset) < (10 * CM_MILLION)) && (CM_ABS(peerOffset) < (10 * CM_MILLION)))
-		{
-			/*- 更新环形队列和累计数据 */
-			(void)CM_RB_Get(&s_2oo2_TmRing, (CM_UINT16)SFM_2oo2_TM_RING_SIZE, &val);
-			s_tm_mysum -= val;
-			(void)CM_RB_Write(&s_2oo2_TmRing, myOffset);
-			s_tm_mysum += myOffset;
-			(void)CM_RB_Get(&s_2oo2_TmRing, (CM_UINT16)SFM_2oo2_TM_RING_SIZE, &val);
-			s_tm_peersum -= val;
-			(void)CM_RB_Write(&s_2oo2_TmRing, peerOffset);
-			s_tm_peersum += peerOffset;
-			/*- 累加同步次数 */
-			s_tm_count += 2u;
-			/*- 是否累计了足够多的数据 */
-			if (s_tm_count >= SFM_2oo2_TM_RING_SIZE)
-			{
-				/*- 计算平均偏移量 */
-				aveOffset = (s_tm_mysum - s_tm_peersum) / (CM_INT64)CM_UNSIGNED_INT_EXP(SFM_2oo2_TM_RING_SIZE);
-				/*- 本机时钟是否过慢 */
-				if (aveOffset > (SFM_2oo2_TM_FIX_VAL * CM_MILLION))
-				{
-					/*- 缩短本周期时间1ms */
-					*pOffset = -CM_MILLION;
-					s_tm_nsub++;
-					s_tm_count = 0u;
-				}
-				/*- 本机时钟是否过快 */
-				else if (aveOffset < (-SFM_2oo2_TM_FIX_VAL * CM_MILLION))
-				{
-					/*- 延长本周期时间 1ms */
-					*pOffset = CM_MILLION;
-					s_tm_nadd++;
-					s_tm_count = 0u;
-				}
-				else
-				{
-					MSCP_LOG_MSG("aveOffset = %d\n", aveOffset);
-				}
-			}
-			else
-			{
-				MSCP_LOG_MSG("s_tm_count = %d\n", s_tm_count);
-			}
-			/*- 记录同步结果 */
-            tempval = (CM_INT64)CM_UNSIGNED_INT_EXP(SFM_2oo2_TM_RING_SIZE / 2u);
-			MSCP_LOG_MSG("2oo2 sync:%lld,%lld,%lld,%lld(us)\n", myDelay / tempval, myOffset / tempval, peerDelay / tempval, peerOffset / tempval);
-			MSCP_LOG_MSG("2oo2 offset_sum:%lld,%lld(us),%d,%d\n", s_tm_mysum / tempval, s_tm_peersum / tempval ,s_tm_nadd,s_tm_nsub);
-			(void)CFM_DarkLog_Multiple(DARK_LOG_HEX, TSCP_DARK_2OO2_ALIGN_TIME,8u,
-			                						sizeof(CM_INT64),myDelay / tempval,
-			                						sizeof(CM_INT64),myOffset / tempval,
-			                						sizeof(CM_INT64),peerDelay / tempval,
-													sizeof(CM_INT64),peerOffset / tempval,
-													sizeof(CM_INT64),s_tm_mysum / tempval,
-													sizeof(CM_INT64),s_tm_peersum / tempval,
-													sizeof(CM_UINT32),s_tm_nadd,
-													sizeof(CM_UINT32),s_tm_nsub);
-		}
-		else
-		{
-			/*- 无处理 */
-			/* 上电初始化阶段尚未校准周期定时器，此时获取的offset无效 */
-			MSCP_LOG_MSG("tm sync fail:%lld,%lld\n", myOffset,peerOffset);
-		}
-    }
-    else
-    {
-    	MSCP_LOG_MSG("pOffset = NULL\n");
-    }
-    /*- 返回同步完成时间 */
-    return rxTick;
-}
-
 /**
 * @brief 2oo2发送(用于维护模式下的2取发送)
 * @param Data    发送报文指针

TSCP/src/MSCP/SFM/SFM_2x2.h

@@ -22,6 +22,7 @@
 #include "CM_MultiThread.h"
 #include "CM_MQ.h"
 #include "PFM_Cfg.h"
+#include "Area.h"
 #ifdef __cplusplus
 extern "C"
 {
@@ -30,7 +31,7 @@ extern CM_UINT32 g_MSCP_SysCount;
 #define SFM_FOLLOW_BUFF_SIZE (1024u*1024u*2u)      /* 主备系间通信通道UDP缓冲区大小 1024k*2，应用许用量为1500k */
 
 /*双机热备参数*/
-#define MSCP_2x2_OFFLINE_WAIT (5)    /**< 离线保持时间（单位：ms）在离线状态保持大于等该时间长度之后才会进入预升主状态*/
+//#define MSCP_2x2_OFFLINE_WAIT (5)    /**< 离线保持时间（单位：ms）在离线状态保持大于等该时间长度之后才会进入预升主状态*/
 #define MSCP_2x2_PREMASTER_WAIT (5)  /**< 预升主等待时间（单位：ms）在预升主状态保持大于等于该时间长度之后才会进入主状态*/
 
 #define MSCP_2X2_COM_FAIL_CYC     (1u)  /**< 主备通信中断的判断时间（单位：周期），双网均收不到对系数据的周期数大于等于该值时视为通信中断*/
@@ -74,7 +75,24 @@ extern CM_UINT32 g_MSCP_SysCount;
         ENUM_2x2_MSG_OUTCHECK = 25,    /**< 输出校验报文 */
 		ENUM_2x2_MSG_APP_FOLLOW_CRC = 26 /**< 应用跟随报文 CRC比较 */
     }ENUM_2x2_MSG_T;
-
+    /** 双机热备状态 */
+   typedef enum {
+       ENUM_2x2_SHUTDOWN = 0, /**< 宕机 */
+	   ENUM_2x2_INIT, 		   /**< 初始化 */
+       ENUM_2x2_OFFLINE,      /**< 跟随 */
+       ENUM_2x2_PRE_MASTER,   /**< 预升主 */
+       ENUM_2x2_SLAVE,        /**< 备系-已同步 */
+       ENUM_2x2_MASTER        /**< 主系-已同步 */
+   } ENUM_2x2_STATE_T;
+   /** 通信状态枚举 */
+      typedef enum {
+          ENUM_2x2_COM_LOG = 0, 		/**< 日志输出 */
+		  ENUM_2x2_COM_VAGUE_STATE, 	/**< 模糊状态4线断线检测 */
+		  ENUM_2x2_COM_EXIST_1_LINE,    /**<存在1线通信正常*/
+		  ENUM_2x2_COM_ALL_DIS,   		/**< 是否全部中断 */
+		  ENUM_2x2_COM_TOGETHER_DIS,    /**< 是否同时中断 */
+		  ENUM_2x2_COM_SWITCH_CONDITION,/**< 是否满足至少一个以太网和任一通道*/
+      } ENUM_2x2_COM_STATE_T;
     /** 2x2oo2的接收通道 */
     typedef struct
     {
@@ -151,17 +169,23 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    CM_UINT32 TxSN;      /**< 发送序列号 */
 	    CM_UINT32 RxSN;      /**< 接收序列号 */
 	    CM_UINT32 SysCycSync;/**< 系统周期号 */
-
-	    ENUM_2x2_STATE_T LocalState;  /**< 本系热备状态，2oo2比较 */
-	    ENUM_2x2_STATE_T PartnerState;    /**< 收到的对系热备状态，2oo2交换 */
-	    ENUM_2x2_STATE_T LastLocalState;  	  /**< 本系上一周期的热备状态，2oo2比较 */
-	    ENUM_2x2_STATE_T LastPartnerState;    /**< 收到的对系上一周期热备状态，2oo2交换 */
+		CM_UINT32 MasterID;   /**< 综合主系ID */
+		
+	    ENUM_4x2_STATE_T LocalState;  		/**< 本系热备状态 */
+	    ENUM_4x2_STATE_T PartnerState;    	/**< 收到的对系热备状态 */
+		ENUM_4x2_STATE_T Area_A_State;  	/**< 区域A热备状态*/
+	    ENUM_4x2_STATE_T Area_B_State;     	/**< 区域B热备状态 */
+	    ENUM_4x2_STATE_T LastLocalState;  	/**< 本系上一周期的热备状态 */
+	    ENUM_4x2_STATE_T LastPartnerState;  /**< 收到的对系上一周期热备状态*/
+		ENUM_4x2_STATE_T LastArea_A_State;  /**< 区域A上一周期的热备状态*/
+	    ENUM_4x2_STATE_T LastArea_B_State; 	/**< 区域B上一周期热备状态 */
 		/*通信状态  */
 		CM_BOOL MineComState;   /**< 本机通信状态，2oo2交换 */
 		CM_BOOL PeerComState;   /**< 邻机通信状态，2oo2交换 */
-		CM_BOOL MineUartState;  /**< 本机串口通信状态，2oo2交换 */
-		CM_BOOL PeerUartState;  /**< 邻机串口通信状态，2oo2交换 */
-
+		CM_BOOL MineExtendState;  /**< 本机扩展通信状态，2oo2交换 */
+		CM_BOOL PeerExtendState;  /**< 邻机扩展通信状态，2oo2交换 */
+		/*健康度参数*/
+		CM_UINT8 LocalCC_Health;	/**< 本系与通控通信健康度0:无通信;1:有通信;2:通信正常 */
 	    /*输入数据*/
 	    CM_UINT32 RxInputSysCyc;        /**< 收到的对系输入数据的周期号，2oo2交换 */
 	    CM_UINT32 InputMineSysCyc;		/**< 当周期从对系收到的本cpu输入数据标志 */
@@ -177,12 +201,14 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    /*跟随数据*/
 	    CM_UINT32 RxBaseFollowSysCyc; /**< 收到的对系跟随数据的周期号，2oo2交换 */
 	    CM_UINT32 RxAppFollowSysCyc;  /**< 收到的对系应用跟随数据的周期号，2oo2交换 */
+	    CM_UINT32 RxAppFollowSysCrcCyc; /**< 收到主系发来的周期号-主系发送的是CRC数据*/
 	    CM_UINT32 LastFollowCyc;      /**< 上次进行平台跟随的时间，2oo2比较，*/
-
+	    CM_UINT32 LastAppFollowCyc;   /**< 上次进行应用跟随的时间，2oo2比较，*/
+	    CM_UINT32 RxBaseFollowSyncFlag; /**< 本周期接收平台跟随数据成功标志位*/
 	    /*输出比较信息*/
 	    CM_UINT32 LastCheckOKCount;     /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较  (这个标志用来判断如果未收到主系的数据,则停止更新,后将为离线)*/
 	    CM_UINT32 OutPutCheckFailFlag;  /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较  (这个标志用来判断收到输出数据后是否比较成功, 比较失败则降级)*/
-	    CM_UINT32 AppFollowCmpFlag; /**< 上次应用跟随数据比较结果，只有备系使用 (这个标志用来判断备系和主系应用跟随数据是否比较成功, 比较失败则降级)*/
+	    CM_UINT32 AppFollowCmpFailFlag; /**< 上次应用跟随数据比较结果，只有备系使用 (这个标志用来判断备系和主系应用跟随数据是否比较成功, 比较失败则降级)*/
 	    CM_UINT32 RxCheckSysCyc;        /**< 收到的输出校验帧的周期号，2oo2交换 */
 	    CM_INT32 RxCheckLen;            /**< 收到的输出校验帧长度，2oo2交换 */
 	    CM_UINT8 RxCheckFrame[100];     /**< 收到的输出校验帧报文，2oo2交换 */
@@ -201,18 +227,20 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    CM_UINT32 RxSN;      	/**< 接收序列号 */
 
 	    /*双系热备状态*/
-	    ENUM_2x2_STATE_T LocalState;  	   /**< 本系热备状态，2oo2比较 */
-		ENUM_2x2_STATE_T PartnerState;     /**< 收到的对系热备状态，2oo2交换 */
-		ENUM_2x2_STATE_T LastLocalState;   /**< 本系上一周期的热备状态，2oo2比较 */
-		ENUM_2x2_STATE_T LastPartnerState; /**< 收到的对系上一周期热备状态，2oo2交换 */
+	    ENUM_2x2_STATE_T LocalState;  	    /**< 本系热备状态，2oo2比较 */
+	    ENUM_2x2_STATE_T PartnerState;     /**< 收到的对系热备状态，2oo2交换 */
+	    ENUM_2x2_STATE_T LastLocalState;   /**< 本系上一周期的热备状态，2oo2比较 */
+	    ENUM_2x2_STATE_T LastPartnerState; /**< 收到的对系上一周期热备状态，2oo2交换 */
+
+	    ENUM_AREA_STATE LocalAreaState;		/**< 本系区域状态 */
+	    CM_BOOL  Area_Slave_Is_Exist;		/**<是否存在区域备地*/
 
-		CM_UINT32 offLineCounter;   	   /**< 离线计时器，2oo2比较 */
 		CM_UINT32 preMasterCounter; 	   /**< 预升主计时器，2oo2比较 */
 		/*通信状态        ABS((B-A)*5-ABS(b-a)),大小周期计算,考虑结构体数组*/
 		STRU_2X2_COM_STATE_RECORD_T MineComOKCount[3u];   /**< 本机通信状态计数，2oo2交换 */
 		STRU_2X2_COM_STATE_RECORD_T PeerComOKCount[3u];   /**< 邻机通信状态计数，2oo2交换 */
-		STRU_2X2_COM_STATE_RECORD_T MineUartOKCount[3u];   /**< 本机串口通信状态计数，2oo2交换 */
-		STRU_2X2_COM_STATE_RECORD_T PeerUartOKCount[3u];   /**< 邻机串口通信状态计数，2oo2交换 */
+		STRU_2X2_COM_STATE_RECORD_T MineExtendOKCount[3u];   /**< 本机串口通信状态计数，2oo2交换 */
+		STRU_2X2_COM_STATE_RECORD_T PeerExtendOKCount[3u];   /**< 邻机串口通信状态计数，2oo2交换 */
 
 	    CM_UINT8  MineInputIoState[10];		/*IO数据同步*/
 	    CM_UINT8  PeerInputIoState[10];		/*IO数据同步*/
@@ -220,22 +248,17 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    CM_UINT8  RmtPeerInputIoState[10];	/*IO数据同步*/
 
 		 /*状态信息*/
-		CM_UINT32 LastStateCount;       /**< 上次收到对系状态的时间，2oo2交换 */
 		CM_UINT32 RxStateSysCyc;        /**< 收到的状态帧的周期号，2oo2交换 */
 		CM_UINT32 RxStateMicroCyc;        /**< 收到的状态帧的周期号，2oo2交换 */
 
-	    /*输入数据*/
-	    CM_UINT32 LastRxInputSysCyc;  /**< 收到的对系输入数据的周期号，2oo2交换 */
-	    /*跟随数据*/
-	    CM_UINT32 LastFollowCyc;      /**< 上次进行平台跟随的时间，2oo2比较，*/
-	    CM_UINT32 AppFollowCmpFlag; /**< 上次应用跟随数据比较结果，只有备系使用 (这个标志用来判断备系和主系应用跟随数据是否比较成功, 比较失败则降级)*/
-
-	    /*输出比较信息*/
-		CM_UINT32 LastCheckOKCount;     /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较  (这个标志用来判断如果未收到主系的数据,则停止更新,后将为离线)*/
-		CM_UINT32 OutPutCheckFailFlag;     /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较  (这个标志用来判断收到输出数据后是否比较成功, 比较失败则降级)*/
-
-		/*时间同步完成标志*/
-		CM_UINT8 TimeSyncFlag;
+		/*健康度参数*/
+		CM_UINT8 LocalCC_Health;	/**< 本系与通控通信健康度0:无通信;1:有通信;2:通信正常 */
+		CM_UINT8 PartnerCC_Health;	/**< 对系与通控通信健康度0:无通信;1:有通信;2:通信正常 */
+		CM_BOOL  LocalSync_Health;	/**< 本系4x同步健康度CM_TRUE:同步成功;CM_FALSE:同步失败  跟随升备 主系健康度切系使用*/
+		CM_BOOL  PartnerSync_Health;/**< 对系4x同步健康度CM_TRUE:同步成功;CM_FALSE:同步失败*/
+		/*失步次数*/
+		CM_UINT32 LocalOutOfSync;	/**< 本系失步次数 ，与应用跟随数据和输出比较有关*/
+		CM_BOOL   LocalSyncFailFlag;	/**< 本系输出或应用跟随比较失败 */
 	    /*主动切系状态*/
 	    ENUM_2x2_SWITCH_STATE  LocalSwitchState; /**< 自己的主动切系按钮状态 */
 	    ENUM_2x2_SWITCH_STATE  PeerSwitchState; /**< 邻机的主动切系按钮状态 */
@@ -247,6 +270,7 @@ extern CM_UINT32 g_MSCP_SysCount;
 	    ENUM_2x2_AID_SWITCH_STATE  PartnerAIDSwitchState; /**< 对系的主动切系按钮状态 */
 	    ENUM_2x2_AID_SWITCH_STATE  PartPeerAIDSwitchState; /**< 对系的邻机的主动切系按钮状态 */
 	    CM_UINT8 aidSwitchFlag; /**< aid切系控制标志 */
+
 	}STRU_2X2_STATE_CTRL_T;
 	/*2x状态切换线程参数*/
 	typedef struct
@@ -285,8 +309,11 @@ extern CM_UINT32 g_MSCP_SysCount;
     */
     void SFM_2x2_UartSend(IN const CM_UINT8 *Data, IN CM_UINT32 DataLen, IN ENUM_2x2_MSG_T msgType);
 
-    /* 2x2周期同步 */
-    void SFM_2x2_Sync(IN CM_UINT64 cycTick, OUT CM_INT64* pOffset);
+    /**
+    * @brief 4x2周期同步对比参数
+    * @param
+    */
+    void SFM_4x2_Sync(void);
 	/**
 	* @brief 获取本系热备状态
 	* @return 本系热备状态
@@ -302,7 +329,7 @@ extern CM_UINT32 g_MSCP_SysCount;
 	* 在“离线”和“备系”状态下且本周期收到有效跟随数据时，
 	* 将在周期应用逻辑执行之前进行跟随数据覆盖。
 	*/
-	ENUM_2x2_STATE_T SFM_2x2_GetLocal2x2State(void);
+	ENUM_4x2_STATE_T SFM_GetLocal4x2State(void);
 	/**
 	* @brief 获取对系热备状态
 	* @return 对系热备状态
@@ -314,7 +341,7 @@ extern CM_UINT32 g_MSCP_SysCount;
 	* @note
 	* 与对系通信中断时默认对系状态为“宕机”
 	*/
-	ENUM_2x2_STATE_T SFM_2x2_GetPartner2x2State(void);
+	ENUM_4x2_STATE_T SFM_2x2_GetPartner2x2State(void);
 
 	/*
 	* @brief 获取上一周期的本系热备状态
@@ -331,7 +358,7 @@ extern CM_UINT32 g_MSCP_SysCount;
 	* 在“离线”和“备系”状态下且本周期收到有效跟随数据时，
 	* 将在周期应用逻辑执行之前进行跟随数据覆盖。
 	*/
-	ENUM_2x2_STATE_T SFM_2x2_GetLastLocal2x2State(void);
+	ENUM_4x2_STATE_T SFM_2x2_GetLastLocal2x2State(void);
 	/**
 	* @brief 获取对系上一周期的热备状态
 	* @return 对系热备状态
@@ -343,7 +370,50 @@ extern CM_UINT32 g_MSCP_SysCount;
 	* @note
 	* 与对系通信中断时默认对系状态为“宕机”
 	*/
-	ENUM_2x2_STATE_T SFM_2x2_GetLastPartner2x2State(void);
+	ENUM_4x2_STATE_T SFM_2x2_GetLastPartner2x2State(void);
+	/**
+	* @brief 获取区域A系热备状态
+	* @return 本系热备状态
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	* @details
+	*/
+	ENUM_4x2_STATE_T SFM_2x2_GetArea_A_2x2State(void);
+
+	/**
+	* @brief 获取区域B系热备状态
+	* @return 对系热备状态
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	* @details
+	* 与对系通信中断时默认对系状态为“宕机”
+	*/
+	ENUM_4x2_STATE_T SFM_2x2_GetArea_B_2x2State(void);
+
+	/*
+	* @brief 获取上一周期的区域A系热备状态
+	* @return 本系热备状态
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	*/
+	ENUM_4x2_STATE_T SFM_2x2_GetLastArea_A_2x2State(void);
+
+	/**
+	* @brief 获取上一周期的区域B系热备状态
+	* @return 对系热备状态
+	* - ENUM_4x2_SHUTDOWN 宕机
+	* - ENUM_4x2_OFFLINE 离线
+	* - ENUM_4x2_MASTER 主系
+	* - ENUM_4x2_SLAVE 备系
+	* @note
+	* 与对系通信中断时默认对系状态为“宕机”
+	*/
+	ENUM_4x2_STATE_T SFM_2x2_GetLastArea_B_2x2State(void);
 
 	/**
 	* @brief 设置跟随数据
@@ -359,6 +429,8 @@ extern CM_UINT32 g_MSCP_SysCount;
 	* @see :: APP_API_FollowUp
 	*/
 	CM_UINT8 SFM_2x2_SetFollowData(IN const CM_UINT8 Data[], IN CM_UINT32 Len);
+	/*设置综合主系ID*/
+	void SFM_2x2_SetMasterID(CM_UINT32 master_id);
 	/**
 	* @brief 获取系统周期号
 	* @return 当前的系统周期号
@@ -427,8 +499,9 @@ extern CM_UINT32 g_MSCP_SysCount;
     CM_UINT8 SFM_2x2_GetSwitchFlag(void);
 
     /* 设置本系热备状态 */
-    void SFM_2x2_SetLocal2x2State(ENUM_2x2_STATE_T localState);
-
+    void SFM_2x2_SetLocal2x2State(ENUM_4x2_STATE_T localState);
+    /*更新本机通控健康度*/
+    void SFM_2x2_UpdataLocalCC_Health(CM_UINT8 *buf,CM_UINT8 len);
     /**
     * @brief 获取2x切系标志位
     * @return s_2x2_Ctrl.ctrSwitchFlag 切系标志位  取值范围：1正在切系 0不在切系
@@ -454,11 +527,48 @@ extern CM_UINT32 g_MSCP_SysCount;
     /*获取AID切系状态*/
     ENUM_2x2_AID_SWITCH_STATE SFM_2x2_Get_AIDSwitchStart(void);
     /*输出处理与发送阶段之前的等待2x逻辑结束的最后处理函数*/
-    void SFM_2x2_ChangeState(void);
+    void SFM_4x2_ChangeState(void);
+    /*状态决策*/
+    ENUM_4x2_STATE_T SFM_2x2_StateDecision(ENUM_AREA_STATE Area,ENUM_2x2_STATE_T State_2x2);
+    /**
+     * @brief 决策区域4x2状态
+     */
+    ENUM_4x2_STATE_T SFM_2x2_AreaDecision(ENUM_AREA_STATE PartnerAreaState,CM_BOOL isA);
+
     /*时间同步失败清空消息队列*/
     void SFM_2x2_ClearRcvMsgQ(void);
 
     void SFM_2x2_SemPost(void);
+
+    CM_BOOL SFM_2x2_Master_Is_Change(void);
+    /**
+    * @brief 获取其他三系热备状态
+    * @param 无
+    * @details
+    * 通过其他三系的地的状态 判断是否为备或者宕机
+    * @ return  0 其他但系存在离线系  1 其三系都是备系
+    */
+    CM_UINT8 SFM_GetAppFollowType(void);
+
+    CM_BOOL SFM_GetLocalSyncHealth(void);
+
+
+    CM_BOOL SFM_GetLocalSyncFailFlag(void);
+
+
+    CM_UINT32 SFM_GetLocalOutOfSync(void);
+
+    /*获取通控健康度 >0 为健康*/
+    CM_UINT8 SFM_GetLocalCCHealth(void);
+
+	/**
+	 * @brief 获取2乘线程中的（s_2x2_state_ctrl）中的2乘状态
+	 * @param localstate 获取到的本系状态
+	 * @param partnerstate 获取到的另一系状态
+	 */
+	void SFM_2x2_GetStateAfterStateChange(OUT ENUM_2x2_STATE_T *localstate, OUT ENUM_2x2_STATE_T *partnerstate);
+
+
 #ifdef __cplusplus
 }
 #endif

TSCP/src/MSCP/SFM/SFM_4x2.c

@@ -0,0 +1,163 @@
+/*
+ * SFM_4x2.c
+ *
+ *  Created on: 2025年12月20日
+ *      Author: 14284
+ */
+
+#include "SFM_4x2.h"
+#include "CM_MQ.h"
+#include "CM_Types.h"
+#include "SFM_2x2.h"
+
+#if 0
+ENUM_CM_RETURN SFM_4x2_Get_2xStat(STRU_4x_CTRL_T *pCtrl);
+
+#define SFM_LOG_SIZE (1024u * 5u) //状态汇总模块日志大小
+ENUM_4x2_STATE_T s_4x2_State = ENUM_4x2_SHUTDOWN;	
+static CM_UINT8 g_SendAppFollowType = 0u; //应用跟随类型
+
+
+
+
+
+/**
+* @brief 获取其他三系热备状态
+* @param 无
+* @details
+* 通过其他三系的地的状态 判断是否为备或者宕机
+* @ return  0 其他但系存在离线系  1 其三系都是备系
+*/
+static CM_UINT8 SFM_GetAreaPartnerState(void);
+/**
+ * @brief 初始化区域日志消息队列
+ * @param 无
+ * @details
+ * 初始化用于4x2状态管理模块的日志消息队列，分配指定大小的内存空间
+ * 队列大小由SFM_LOG_SIZE宏定义确定
+ * @return ENUM_CM_RETURN 操作结果
+ *         - ENUM_CM_TRUE: 初始化成功
+ *         - ENUM_CM_FALSE: 初始化失败
+ */
+ ENUM_CM_RETURN Area_LogMQ_Init(void)
+ {
+	 return CM_MQ_Init(&s_4x2_LogMsgQ, (CM_UINT16)SFM_LOG_SIZE, (CM_UINT16)(SFM_LOG_SIZE));
+ }
+
+/**
+ * @brief 处理并转发4x2模块日志
+ * @param 无
+ * @details
+ * 从日志消息队列中读取日志数据，并通过基础日志发送接口进行输出
+ * 循环处理直到队列为空为止
+ * @return 无
+ */
+void SFM_4x2_LOG_Transition(void)
+{
+	ENUM_CM_RETURN rt = ENUM_CM_FALSE;
+	CM_UINT8 buf[1024] = {0};
+	CM_UINT16 len = 1024;
+	while(1)
+	{
+		len = 1024;
+		rt = CM_MQ_Read(&s_4x2_LogMsgQ, buf, (CM_UINT16*)&len);
+		if(ENUM_CM_TRUE == rt)
+		{
+		    /*- 输出日志信息 */
+		    (void)CFM_BaseLog_Send((CM_UINT8*)buf, len);
+		}
+		else
+		{
+			/*无处理*/
+			break;
+		}
+	}
+}
+/**
+ * @brief 更新4x2状态
+ * @param 无
+ * @details
+ * 执行状态更新流程：
+ * 1. 调用2x2状态变更处理
+ * 2. 获取本地2x2状态
+ * 3. 获取区域状态
+ * 4. 进行状态决策计算
+ * 5. 获取伙伴区域状态
+ * @return 无
+ */
+void SFM_4x2_ChangeState(void)
+{
+	ENUM_AREA_STATE State_Area = 0; //区域状态
+	ENUM_4x2_STATE_T State_2x2 = 0; //2x2状态
+
+	SFM_2x2_ChangeState();
+	/*获取2乘状态*/
+	State_2x2 = SFM_GetLocal4x2State();
+	/*获取地的状态*/
+	State_Area = Area_Get_State();
+
+	/*状态决策*/
+	s_4x2_State = SFM_4x2_StateDecision(State_Area, State_2x2);
+
+	SFM_GetAreaPartnerState();
+
+
+}
+
+/**
+ * @brief 决策4x2状态
+ * @details 根据区域状态和2x2临时状态，决定最终的4x2状态。
+ *          如果区域为主且2x2临时状态为主，则为4x2主；
+ *          如果区域为主且2x2临时状态为备，则为4x2备；
+ *          如果区域为备且2x2临时状态为主或备，则为4x2备；
+ *          如果区域为初始化或2x2临时状态为宕机，则为4x2宕机；
+ *          其他情况，如果2x2临时状态为离线且区域状态高于离线，则将区域状态设为离线，并返回4x2离线。
+ * @param[in] Area 区域状态
+ * @param[in] State_2x2 2x2临时状态
+ * @return 最终的4x2状态(主线程状态)
+ *         - ENUM_4x2_MASTER: 主系状态
+ *         - ENUM_4x2_SLAVE: 备系状态
+ *         - ENUM_4x2_PRE_MASTER: 预主系状态
+ *         - ENUM_4x2_SHUTDOWN: 关闭状态
+ *         - ENUM_4x2_OFFLINE: 离线状态
+ */
+ENUM_4x2_STATE_T SFM_4x2_StateDecision(ENUM_AREA_STATE Area, ENUM_4x2_STATE_T State_2x2)
+{
+    ENUM_4x2_STATE_T rtn_state = ENUM_4x2_SHUTDOWN;  /* 默认返回关闭状态 */
+
+    /* 如果区域为主且2x2临时状态为主，则返回4x2主 */
+    if ((ENUM_AREA_MASTER == Area) && (ENUM_2x2_TEMP_MASTER == State_2x2))
+    {
+        rtn_state = ENUM_4x2_MASTER;
+    }
+    /* 如果区域为主且2x2临时状态为备，则返回4x2备 */
+    else if ((ENUM_AREA_MASTER == Area) && (ENUM_4x2_SLAVE == State_2x2))
+    {
+        rtn_state = ENUM_4x2_SLAVE;
+    }
+    /* 如果区域为备且2x2临时状态为主或备，则返回4x2备 */
+    else if ((ENUM_AREA_SLAVE == Area) && ((ENUM_2x2_TEMP_MASTER == State_2x2) || (ENUM_2x2_TEMP_SLAVE == State_2x2)))
+    {
+        rtn_state = ENUM_4x2_SLAVE;
+    }
+    /* 如果区域为初始化或2x2临时状态为宕机，则返回4x2宕机 */
+    else if ((ENUM_AREA_SHUTDOWN == Area) || (ENUM_2x2_TEMP_SHUTDOWN == State_2x2))
+    {
+        rtn_state = ENUM_4x2_SHUTDOWN;
+    }
+    else if(ENUM_2x2_TEMP_PRE_MASTER == State_2x2)
+    {
+        rtn_state = ENUM_4x2_PRE_MASTER;
+    }
+    else
+    {
+        /* 返回4x2离线状态 */
+        rtn_state = ENUM_4x2_OFFLINE;
+    }
+
+    MSCP_LOG_MSG("Local Area state = %d  2x = %d Final = %d\n",Area, State_2x2,rtn_state);
+    return rtn_state;
+}
+#endif
+
+

TSCP/src/MSCP/SFM/SFM_4x2.h

@@ -0,0 +1,48 @@
+/*
+ * @Author: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
+ * @Date: 2025-12-20 15:59:31
+ * @LastEditors: error: error: git config user.name & please set dead value or install git && error: git config user.email & please set dead value or install git & please set dead value or install git
+ * @LastEditTime: 2025-12-20 17:25:50
+ * @FilePath: \TSCP\src\MSCP\SFM\SFM_4x2.h
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+
+/*
+ * SFM_4x2.h
+ *
+ *  Created on: 2025年12月20日
+ *      Author: 14284
+ */
+
+#ifndef MSCP_SFM_SFM_4X2_H_
+#define MSCP_SFM_SFM_4X2_H_
+#include "CM_MQ.h"
+#include "CM_Types.h"
+#include "SFM_2x2.h"
+#if 0
+     /** 四机热备状态 */
+    typedef enum {
+        ENUM_4x2_SHUTDOWN = 0, /**< 宕机 */
+        ENUM_4x2_OFFLINE,      /**< 离线 */
+        ENUM_4x2_PRE_MASTER,   /**< 预升主 需要次状态 在预升主时候 不接收主的同步数据*/
+        ENUM_4x2_SLAVE,         /**< 备系 */
+		ENUM_4x2_MASTER       /**< 主系 */
+    } ENUM_4x2_STATE_T;
+
+    	/** 2x2控制 */
+	typedef struct
+	{
+	    STRU_2X2_CTRL_T state_2x2;
+        STR_Area_State state_area;
+	}STRU_4x_CTRL_T;
+#endif
+
+	/**
+	* @brief 获取其他三系热备状态
+	* @param 无
+	* @details
+	* 通过其他三系的地的状态 判断是否为备或者宕机
+	* @ return  0 其他但系存在离线系  1 其三系都是备系
+	*/
+	CM_UINT8 SFM_GetAppFollowType(void);
+#endif /* MSCP_SFM_SFM_4X2_H_ */

TSCP/src/MSCP/SFM/SFM_Prtcl.c

@@ -1506,6 +1506,7 @@ void SFM_TxInnetSafeRm(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
     CM_UINT16 msgLen = 0u;         /* 外网输出帧长度 */
     CM_UINT16 dstID = 0u;          /* 目的设备ID */
     STRU_PFM_INNET_CFG_T* pCom = NULL;/* 通信配置 */
+    ENUM_CM_RETURN ret = ENUM_CM_FALSE;
 
 	if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
 	{
@@ -1549,13 +1550,14 @@ void SFM_TxInnetSafeRm(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
 					if (1u == g_PFM_Cfg.CPU_ID)
 					{
 						/*- 从绿网通道发送 */
-						(void)CFM_InnetRemoteUpdate_Send(&Buf[i + 7u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(msgLen - 5u), pCom->IP_G, pCom->Port_Safe_G);   /* parasoft-suppress MISRA2004-17_1 "指针运算提高代码执行效率" */
+						ret = CFM_InnetRemoteUpdate_Send(&Buf[i + 7u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(msgLen - 5u), pCom->IP_G, pCom->Port_Safe_G);   /* parasoft-suppress MISRA2004-17_1 "指针运算提高代码执行效率" */
 					}
 					else
 					{
 						/*- 从紫网通道发送 */
-						(void)CFM_InnetRemoteUpdate_Send(&Buf[i + 7u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(msgLen - 5u), pCom->IP_P, pCom->Port_Safe_P);   /* parasoft-suppress MISRA2004-17_1 "指针运算提高代码执行效率" */
+						ret = CFM_InnetRemoteUpdate_Send(&Buf[i + 7u], (CM_INT32)CM_UNSIGNED_SHORT_EXP(msgLen - 5u), pCom->IP_P, pCom->Port_Safe_P);   /* parasoft-suppress MISRA2004-17_1 "指针运算提高代码执行效率" */
 					}
+					MSCP_LOG_MSG("plafm send innetsafeRm data ret = %#x\n",ret);
 				}
 				else
 				{
@@ -1564,6 +1566,7 @@ void SFM_TxInnetSafeRm(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
 			}
 			else
 			{
+				MSCP_LOG_MSG("Get dest IP and port fial!\n");
 					/*- 无处理*/
 			}
 			i += (CM_UINT32)CM_UNSIGNED_SHORT_EXP(msgLen + 2u);