数据提交

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

TSCP/Makefile

@@ -111,6 +111,7 @@ INCLUDES += -I ./src/APP \
             -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
 

TSCP/src/APP/APP_API.c

@@ -349,6 +349,7 @@ void APP_API_Data_Init()
 	            .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 */
@@ -529,6 +530,9 @@ void APP_API_Data_Init()
 	            .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);
@@ -588,8 +592,8 @@ ENUM_CM_RETURN APP_API_MainFunc(void)
 	debug_infor_printf("app proc end at %llu us,used %d us\n", endCycTick, (CM_INT32)((endCycTick - startCycTick) / 1000));
 
 	//gFollowDataLen = GetCiAppData(gFollowData);
-	memset(gFollowData,0x00,1024*1500);
-	MSCP_SetFollowData(gFollowData, 1024*1500 - 1);
+	memset(gFollowData,0x02,1024*500);
+	MSCP_SetFollowData(gFollowData, 1024*500);
 
 	return retVal;
 }

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.c

@@ -28,18 +28,15 @@
 #define MSCP_MSG_AREA_RSP_TYPE 0x02  /**< 区域通信响应消息类型 */
 #define MSCP_MSG_DEST_ALL 0xFF  /**< 所有设备接收消息类型 */
 
-#define Area_MSG_NUM_MAX (200u)
-#define Area_RAW_MSG_SIZE  (2048u)
-
 #define AREA_TIME_MAX  30u
 
 typedef struct
 { 
-    CM_UINT32 BoardID;  /**< 板卡ID 插箱id */
-    CM_UINT32 Cpuid;  /**< cpu id */
-    CM_UINT32 Partner_BoardID;  /**< 对系板卡id */
-    CM_UINT32 Partner_Area_A_BoardID;  /**< 对系id */
-    CM_UINT32 Partner_Area_B_BoardID;  /**< 对系id */
+    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 */
     STR_Area_IP_Cfg IP_Cfg_Area_A;  /**< IP配置 */
     STR_Area_IP_Cfg IP_Cfg_Area_B;  /**< IP配置 */
 }STR_Area_Cfg;
@@ -80,7 +77,6 @@ void net_state_cal();
  */
 void Area_Req_Pack(STR_Area_Req *p_Area_Req, CM_UINT8 *p_buf, CM_UINT16 BufSize, CM_UINT16 *p_len);
 
-void get_Other_BoardId(CM_UINT32 local_Board_Id, CM_UINT32 *partner_Board_Id, CM_UINT32 *partner_Area_A_Board_Id, CM_UINT32 *partner_Area_B_Board_Id);
 
 STR_Area_State_Ctl g_Area_Status_Ctl[8] = {0};
 static STR_Area_Ctl g_Area_Ctl ={0};
@@ -121,7 +117,7 @@ void Area_init()
     CM_Thread_Create(NULL, (CM_THREAD_FUNC_T)Area_Work_Thread, "Area_Work_Thread", 4096*100, CM_TASK_PRIORITY_73, NULL);
 }
 
-void get_Other_BoardId(CM_UINT32 local_Board_Id, CM_UINT32 *partner_Board_Id, CM_UINT32 *partner_Area_A_Board_Id, CM_UINT32 *partner_Area_B_Board_Id)
+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)
 {
     if(NULL == partner_Board_Id || NULL == partner_Area_A_Board_Id || NULL == partner_Area_B_Board_Id)
     {

TSCP/src/MSCP/Area/Area.h

@@ -13,10 +13,10 @@
 
 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;/**< 区域状态*/
+	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 区域开始
@@ -68,6 +68,8 @@ 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_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.h

@@ -1,9 +1,14 @@
+#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
  {
@@ -25,6 +30,7 @@
      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);
@@ -32,4 +38,6 @@
  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

@@ -118,7 +118,7 @@ void Offline_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId
         	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)*/)
 	   {
@@ -131,6 +131,10 @@ void Offline_Vote(STR_Area_State_Ctl *p_Area_Status_Ctl, CM_UINT32 Local_BoardId
         	AREA_LOG_MSG("03 ENUM_AREA_OFFLINE >>>> ENUM_AREA_OFFLINE \r\n");
         	g_Area_4x_Ctl.Local_state = ENUM_AREA_OFFLINE;
         }
+        else
+        {
+        	;
+        }
    }
 }
 

TSCP/src/MSCP/CFM/CFM_Net.c

@@ -304,7 +304,6 @@ static void s_NetInit_2oo2(void)
     /*- 变量初始化 */
     ENUM_CM_RETURN rt = ENUM_CM_FALSE;  /* 临时变量 */
     CM_INT32 val = 0;                   /* 临时变量 */
-    unsigned int optLen = 0u;           /* socket选项值长度 */
     CM_BOOL rtCheck = CM_FALSE;         /* 临时变量 */
 
     /*- 创建平台数据2取socket */
@@ -335,47 +334,6 @@ static void s_NetInit_2oo2(void)
     (void)setsockopt(s_CFM_Sock.Sock_2oo2_Data, SOL_SOCKET, SO_SNDBUF, (void*)(&val), (unsigned int)sizeof(val));
     (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));
-
-    /*- 读取并打印socket实际生效的接收、发送缓冲区大小 */
-    optLen = (unsigned int)sizeof(val);
-    if (0 == getsockopt(s_CFM_Sock.Sock_2oo2_Data, SOL_SOCKET, SO_RCVBUF, (void*)(&val), &optLen))
-    {
-        (void)printf("Sock_2oo2_Data SO_RCVBUF = %d bytes\n", val);
-    }
-    else
-    {
-        (void)printf("Sock_2oo2_Data SO_RCVBUF getsockopt failed\n");
-    }
-
-    optLen = (unsigned int)sizeof(val);
-    if (0 == getsockopt(s_CFM_Sock.Sock_2oo2_Data, SOL_SOCKET, SO_SNDBUF, (void*)(&val), &optLen))
-    {
-        (void)printf("Sock_2oo2_Data SO_SNDBUF = %d bytes\n", val);
-    }
-    else
-    {
-        (void)printf("Sock_2oo2_Data SO_SNDBUF getsockopt failed\n");
-    }
-
-    optLen = (unsigned int)sizeof(val);
-    if (0 == getsockopt(s_CFM_Sock.Sock_2oo2_Data_App, SOL_SOCKET, SO_RCVBUF, (void*)(&val), &optLen))
-    {
-        (void)printf("Sock_2oo2_Data_App SO_RCVBUF = %d bytes\n", val);
-    }
-    else
-    {
-        (void)printf("Sock_2oo2_Data_App SO_RCVBUF getsockopt failed\n");
-    }
-
-    optLen = (unsigned int)sizeof(val);
-    if (0 == getsockopt(s_CFM_Sock.Sock_2oo2_Data_App, SOL_SOCKET, SO_SNDBUF, (void*)(&val), &optLen))
-    {
-        (void)printf("Sock_2oo2_Data_App SO_SNDBUF = %d bytes\n", val);
-    }
-    else
-    {
-        (void)printf("Sock_2oo2_Data_App SO_SNDBUF getsockopt failed\n");
-    }
     /*- 初始化控制信息 */
 
     /*- 配置接收线程 */
@@ -1502,7 +1460,6 @@ static void s_NetInit_Innet(void)
 			{
 				bCast = 1;/*默认单播组播模式*/
 			}
-			printf("InnetRaw_%d_%s %d\n",i,g_PFM_Cfg.Local_Cfg.Innet_Raw_Parameter[i].IP_InnetRaw_maddr, bCast);
 			rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_InnetRaw[i],
 				CM_FALSE,
 				(CM_UINT32)inet_addr(p_tmpIPCom),

TSCP/src/MSCP/CFM/CFM_Net.h

@@ -35,7 +35,7 @@ extern "C"
 #define NET_UDP_MAINTENANCE_BUF_SIZE    ((1024*5)-(1)) /*2OO2UDP协议栈缓冲区大小（维护模式下用于接收代码）*/
 #define NET_UDP_2X2_BUF_SIZE    ((1024*64)-(1)) /*2X2UDP协议栈缓冲区大小（用于接收代码）*/
 #define NET_UDP_BUF_SIZE    ((1024*64)-(1)) /*UDPsocket消息队列缓冲区（用于接收代码）*/
-#define NET_UDP_BUF_DOUBLESIZE    ((2*1024*1024) - (1)) /*UDP协议栈缓冲区大小（用于接收代码）*/
+#define NET_UDP_BUF_DOUBLESIZE    ((1024*256) - (1)) /*UDP协议栈缓冲区大小（用于接收代码）*/
 
 #define NET_50K_SIZE    (50000u) /*实际允许使用的应用帧大小（用于发送代码）*/
 #define NET_20K_SIZE    (20000u) /*实际允许使用的应用帧大小（用于发送代码）*/

TSCP/src/MSCP/CFM/CFM_Sync.c

@@ -36,7 +36,7 @@
 #define TIME_OFFSET_PEER  (1) //对端时间偏移量
 static STRU_CFM_TIME_CTRL_T s_TimeCtrl[10] = {0};
 #define SFM_2oo2_TM_FIX_VAL_NS       (3 * CM_MILLION)     /* 2oo2校时门限，单位:ns */
-#define SFM_2x2_TM_FIX_VAL_NS        (10 * CM_MILLION)    /* 2x最小调整偏差，单位:ns */
+#define SFM_2x2_TM_FIX_VAL_NS        (5 * CM_MILLION)    /* 2x最小调整偏差，单位:ns */
 #define SFM_TIME_SYNC_TOLERANCE_COUNT (5u)                /* 时间同步切换， 丢失容忍次数*/
 
 static CM_THREAD_FUNC_T t_Sync_TimeThread(IN CM_Thread_Arg_Struct_T* arg);

TSCP/src/MSCP/CM/CM_UDP.c

@@ -180,7 +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;
-    u_char loop;    /* 0 = disable, 1 = enable (default) */
+    CM_UINT8 loop;    /* 0 = disable, 1 = enable (default) */
     /*- 是否UDP服务未初始化或输入非法 */
     if ((CM_TRUE != s_UDP_Initialized) || (NULL == pSock))
     {
@@ -210,7 +210,7 @@ ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockM
 					/*组播发送*/
 					addrHost.sin_addr.s_addr = addrIP;
 					(void)setsockopt(*pSock, IPPROTO_IP, IP_MULTICAST_IF, &addrHost.sin_addr, sizeof(addrHost.sin_addr));
-                    loop = 0;
+                    loop = 0u;
                     (void)setsockopt(*pSock, IPPROTO_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop));
 					break;
 				case ENUM_MULTICAST_RCV:

TSCP/src/MSCP/MSCP_main.c

@@ -40,6 +40,8 @@
 #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>
@@ -196,7 +198,6 @@ static void MSCP_Init(void)
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_API_DATA);
     /*- 平台配置文件管理初始化 */
     PFM_CFG_Init();
-    save_to_file("A new startup ******************************\r\n");
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_CFG);
     /*- 网卡初始化 */
     CFM_NetworkCard_Init();
@@ -243,7 +244,8 @@ static void MSCP_Init(void)
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_APP_CTRL);
     PFM_LOG_SET_INIT_STAGE(ENUM_INIT_2X2USART);
     CFM_TimeSync_Init(2);//时间同步初始化
-    Area_init();//区域初始化
+    /* 区域初始化*/
+    Area_Arb_Common_Init();
 
     /*- 是否开启2oo2功能 */
     if (0x55u == g_PFM_Cfg.M_2oo2_Enable)
@@ -325,7 +327,15 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 	/*发送2x状态结束信号量*/
     SFM_2x2_SemPost();
     /*< 发送区域通信结束信号量*/
-    Area_Stop();
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        Area_Arb_Stop();
+    }
+    else
+    {
+        Area_Stop();
+    }
+    
 	(void)DFM_SetIO_OutPut(0x00u);
     /*- 循环执行周期逻辑 */
     while (1)
@@ -447,7 +457,11 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 		/*TODO 发送2x状态起始信号量*/
 		SFM_2x2_Thread_PostStart();
 		/* 发送区域线程开始信号*/
-		Area_Start();
+        if(0x55 != g_PFM_Cfg.M_Arb_Enable)
+        {
+            Area_Start();
+        }
+		
 		PFM_CFC_Check(24);
 		/*- 发起校时请求*/
 		CFM_SendLocalARQ();

TSCP/src/MSCP/PFM/PFM_Cfg.c

@@ -139,6 +139,7 @@ void PFM_CFG_Init(void)
     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;
@@ -158,6 +159,7 @@ void PFM_CFG_Init(void)
 	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);
@@ -203,6 +205,8 @@ void PFM_CFG_Init(void)
 
         (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);
@@ -310,6 +314,7 @@ void PFM_CFG_Init(void)
     	(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)))
@@ -320,6 +325,7 @@ void PFM_CFG_Init(void)
     	(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)))
 	{
@@ -329,6 +335,7 @@ void PFM_CFG_Init(void)
     	(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)))
 	{
@@ -338,14 +345,15 @@ void PFM_CFG_Init(void)
     	(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",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);
+	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);
 
     /*- 读取通控的端口配置 */
     g_PFM_Cfg.CC_R_OutnetSafe_Port = g_AppCfgInterface.OutNetRed.OutnetSafe_Port;
@@ -357,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);
@@ -367,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,

TSCP/src/MSCP/PFM/PFM_Cfg.h

@@ -93,6 +93,8 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 
         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 */
@@ -119,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
     {
@@ -161,6 +175,7 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		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;	  /**< 自动重启次数 */
@@ -186,6 +201,8 @@ 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; /**< 暗文日志对端端口 */
@@ -259,6 +276,7 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		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;  	/**< 内网透传通信功能开关 */
@@ -293,6 +311,9 @@ extern CM_UINT8 TSCP_QNX_VERION[10];       /** 操作系统版本号 */
 		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有效) */

TSCP/src/MSCP/PFM/PFM_InputOutput.c

@@ -461,8 +461,6 @@ void PFM_InputProc(void)
     /*- 外网安全数据接收 */
     PFM_CFC_Check(26);
     g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].mine_len = (CM_UINT32)SFM_RxOutnetSafe(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_mine_buf, (CM_UINT32)g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].buf_size);
-    g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].mine_len = g_PFM_Cfg.OutnetSafePack_Len;
-    CM_Memset(g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].p_mine_buf, 0x00u, g_PFM_Cfg.OutnetSafePack_Len, g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].buf_size);
     MSCP_LOG_MSG("g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].mine_len = %d\n",g_2x2oo2_rx[g_2x2oo2_base][s_2x2oo2_OutnetSafe].mine_len);
     /*判断外网透传使能开关*/
     if((CM_UINT32)0x55u == g_PFM_Cfg.M_OutnetRaw_Enable)

TSCP/src/MSCP/PFM/PFM_Log.c

@@ -424,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);

TSCP/src/MSCP/SFM/SFM_2x2.c

@@ -33,6 +33,9 @@
 #include "CFM_Sync.h"
 #include "stdarg.h"
 #include "Area_state.h"
+#include "Arb_State.h"
+#include "Arb.h"
+#include "Area_Arb_Common.h"
 
 /*通信中断时间和同步超时时间可以相同，此时优先执行通信中断切系*/
 
@@ -129,52 +132,6 @@ static void SFM_2x2_Input2oo2Exchange(STRU_2X2_CTRL_T *peerCtrl);
 static void SFM_2x2_Eth422StateDark(void);
 
 
-
-// 主要实现函数
-void save_to_file(const char *format, ...)
-{
-	return;
-    FILE *fp = NULL;
-    va_list args;
-    int result = 0;
-
-    // 检查参数有效性
-    if (format == NULL) {
-        fprintf(stderr, "Error: Invalid parameters\n");
-    }
-
-    // 以追加模式打开文件，如果文件不存在则创建
-    fp = fopen("2xStateChange", "a");
-    if (fp == NULL) {
-        fprintf(stderr, "Error: Cannot open file \n");
-    }
-
-    // 获取可变参数
-    va_start(args, format);
-
-    // 将格式化的字符串写入文件
-    result = vfprintf(fp, format, args);
-
-    // 添加时间戳（可选）
-//    if (result >= 0) {
-//        time_t now;
-//        struct tm *timeinfo;
-//        char timestamp[64];
-//
-//        time(&now);
-//        timeinfo = localtime(&now);
-//        strftime(timestamp, sizeof(timestamp), "\n[%Y-%m-%d %H:%M:%S]\n", timeinfo);
-//        fputs(timestamp, fp);
-//    }
-
-    // 清理可变参数列表
-    va_end(args);
-
-    // 关闭文件
-    fclose(fp);
-
-}
-
 /* 输入周期号同步函数 */
 static void SFM_2x2_InputSysCycSyn(STRU_2X2_CTRL_T *peerCtrl){
     if(s_2x2_Ctrl.RxInputSysCyc > peerCtrl->RxInputSysCyc)
@@ -748,14 +705,12 @@ static void s_State_Transition(void)
 			/*- 健康度正常切换为预升主 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_PRE_MASTER;
 			SFM_LOG_MSG_2X("Transition:2x2:INIT>>>>>>>PRE_MASTER\n");
-			save_to_file("Transition:2x2:INIT>>>>>>>PRE_MASTER\n");
 		}
 
 		else
 		{
 			/*保持初始化状态*/
 			SFM_LOG_MSG_2X("Transition:2x2:INIT>>>>>>>INIT(LocalCC_Health = %d)\n",s_2x2_state_Ctrl.LocalCC_Health);
-			save_to_file("Transition:2x2:INIT>>>>>>>INIT(LocalCC_Health = %d)\n",s_2x2_state_Ctrl.LocalCC_Health);
 		}
 		break;
 	case ENUM_2x2_OFFLINE: /*-< 离线 */
@@ -768,13 +723,11 @@ static void s_State_Transition(void)
 			{
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_SLAVE;
 				SFM_LOG_MSG_2X("Transition:2x2:OFFLINE>>>>>>>SLAVE(PartnerState is MASTER)\n");
-				save_to_file("Transition:2x2:OFFLINE>>>>>>>SLAVE(PartnerState is MASTER)\n");
 			}
 			else
 			{
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_PRE_MASTER;
 				SFM_LOG_MSG_2X("Transition:2x2:OFFLINE>>>>>>>PRE_MASTER(PartnerState !=  MASTER)\n");
-				save_to_file("Transition:2x2:OFFLINE>>>>>>>PRE_MASTER(PartnerState !=  MASTER)\n");
 			}
 		}
 		else
@@ -792,7 +745,6 @@ static void s_State_Transition(void)
 			/*- 本系转离线 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 			SFM_LOG_MSG_2X("Transition:2x2:PRE_MASTER>>>>>>>OFFLINE(Other Master)\n");
-			save_to_file("Transition:2x2:PRE_MASTER>>>>>>>OFFLINE(Other Master)\n");
 		}
 		/*- 是否是本系为B系且对系预升主 */
 		else if ((ENUM_2x2_PRE_MASTER == s_2x2_state_Ctrl.PartnerState) && ((MSCP_MAIN_B == boardID) || (MSCP_MAIN_D == boardID)))
@@ -801,7 +753,6 @@ static void s_State_Transition(void)
 			/*- 本系转离线 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 			SFM_LOG_MSG_2X("Transition:2x2:PRE_MASTER>>>>>>>OFFLINE(Other A will Master)\n");
-			save_to_file("Transition:2x2:PRE_MASTER>>>>>>>OFFLINE(Other A will Master)\n");
 		}
 		/*- 预升主计时是否达到了预升主等待时间 */
 		else if (s_2x2_state_Ctrl.preMasterCounter >= (MSCP_2x2_PREMASTER_WAIT * (s_2x2_thread_Ctrl.number_Cyc - 1u)))
@@ -810,13 +761,11 @@ static void s_State_Transition(void)
 			/*- 本系升主 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
 			SFM_LOG_MSG_2X("Transition:2x2:PRE_MASTER>>>>>>>MASTER！！！(Will Master Success)\n");
-			save_to_file("Transition:2x2:PRE_MASTER>>>>>>>MASTER！！！(Will Master Success)\n");
 		}
 		else
 		{
 			/*- 保持预升主 */
 			SFM_LOG_MSG_2X("Transition:2x2:PRE_MASTER>>>>>>>PRE_MASTER(keep count = %d)\n",s_2x2_state_Ctrl.preMasterCounter);
-			save_to_file("Transition:2x2:PRE_MASTER>>>>>>>PRE_MASTER(keep count = %d)\n",s_2x2_state_Ctrl.preMasterCounter);
 		}
 
 		/*- @alias 更新预升主计时器 */
@@ -848,8 +797,6 @@ static void s_State_Transition(void)
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 				SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>OFFLINE!!!(Old Data PartnerState = %d Rx:MyMicroCyc  %d  %d Rx:MyCyc %d %d)\n",s_2x2_state_Ctrl.PartnerState, s_2x2_state_Ctrl.RxStateMicroCyc, \
 						s_2x2_state_Ctrl.MicroCyc, s_2x2_state_Ctrl.RxStateSysCyc, s_2x2_state_Ctrl.SysCyc );
-				save_to_file("Transition:2x2:MASTER>>>>>>>OFFLINE!!!(Old Data PartnerState = %d Rx:MyMicroCyc  %d  %d Rx:MyCyc %d %d)\n",s_2x2_state_Ctrl.PartnerState, s_2x2_state_Ctrl.RxStateMicroCyc, \
-										s_2x2_state_Ctrl.MicroCyc, s_2x2_state_Ctrl.RxStateSysCyc, s_2x2_state_Ctrl.SysCyc );
 				/* CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_4); */
 		}
 		else if(ENUM_2x2_MASTER == s_2x2_state_Ctrl.PartnerState)
@@ -860,14 +807,12 @@ static void s_State_Transition(void)
 				/*- 检测到对系是主系，本系宕机*/
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_SHUTDOWN;
 				SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>Double MASTER!!!(Shut Down)\n");
-				save_to_file("Transition:2x2:MASTER>>>>>>>Double MASTER!!!(Shut Down)\n");
 				CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_3);
 			}
 			else
 			{
 				/*恢复上周期状态*/
 				SFM_LOG_MSG_2X("Transition:2x2:Double MASTER Recovery!!!(Last State)\n");
-				save_to_file("Transition:2x2:Double MASTER Recovery!!!(Last State)\n");
 				s_2x2_state_Ctrl.LocalState = s_2x2_state_Ctrl.LastLocalState;
 				TempState = s_2x2_state_Ctrl.LastPartnerState;
 				s_2x2_state_Ctrl.LastPartnerState = s_2x2_state_Ctrl.PartnerState;
@@ -884,7 +829,6 @@ static void s_State_Transition(void)
 				/*- 检测到对系是备系，且同步成功，主系同步失败降为跟随*/
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 				SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>OFFLINE(Health not enough)\n");
-				save_to_file("Transition:2x2:MASTER>>>>>>>OFFLINE(Health not enough)\n");
 
 			}
 			/*健康度切系2:本机通控通信异常*/
@@ -892,14 +836,12 @@ static void s_State_Transition(void)
 			{
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 				SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>OFFLINE(Local CC_Health not enough)\n");
-				save_to_file("Transition:2x2:MASTER>>>>>>>OFFLINE(Local CC_Health not enough)\n");
 			}
 			/*健康度切系3:本机通控通信异常，区域健康度切系,存在备地即降跟随*/
 			else if((0 == s_2x2_state_Ctrl.LocalCC_Health) && (CM_TRUE == s_2x2_state_Ctrl.Area_Slave_Is_Exist))
 			{
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 				SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>OFFLINE(Area CC_Health not enough)\n");
-				save_to_file("Transition:2x2:MASTER>>>>>>>OFFLINE(Area CC_Health not enough)\n");
 			}
 			/*手动切系*/
 			else if((ENUM_2x2_SLAVE == s_2x2_state_Ctrl.PartnerState) && ((1u == s_2x2_state_Ctrl.ctrSwitchFlag) || (1u == s_2x2_state_Ctrl.aidSwitchFlag)))
@@ -911,16 +853,12 @@ static void s_State_Transition(void)
 					/*- 检测到对系是备系，且允许切系，主系降为备系*/
 					s_2x2_state_Ctrl.LocalState = ENUM_2x2_SLAVE;
 					SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>SLAVE(SWITCH:0x%x,AID:0x%x)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag);
-					save_to_file("Transition:2x2:MASTER>>>>>>>SLAVE(SWITCH:0x%x,AID:0x%x)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag);
 				}
 				else
 				{
 					SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>Do Not Change(SWITCH:0x%x,AID:0x%x,COM:0x%x,LSH:%d,PSH:%d,LCCH:%d,PCCH:%d)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag,
 							s_State_Get_CommunicationState(ENUM_2x2_COM_SWITCH_CONDITION),s_2x2_state_Ctrl.LocalSync_Health,s_2x2_state_Ctrl.PartnerSync_Health,
 							s_2x2_state_Ctrl.LocalCC_Health,s_2x2_state_Ctrl.PartnerCC_Health);
-					save_to_file("Transition:2x2:MASTER>>>>>>>Do Not Change(SWITCH:0x%x,AID:0x%x,COM:0x%x,LSH:%d,PSH:%d,LCCH:%d,PCCH:%d)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag,
-												s_State_Get_CommunicationState(ENUM_2x2_COM_SWITCH_CONDITION),s_2x2_state_Ctrl.LocalSync_Health,s_2x2_state_Ctrl.PartnerSync_Health,
-												s_2x2_state_Ctrl.LocalCC_Health,s_2x2_state_Ctrl.PartnerCC_Health);
 				}
 				s_State_SwitchState_Init();
 			}
@@ -953,15 +891,13 @@ static void s_State_Transition(void)
 				/*通信SN号清空-防止对系重新上电后不接收新的SN号*/
 				s_2x2_state_Ctrl.RxSN = 0u;
 				s_2x2_state_Ctrl.RxStateSysCyc = 0u;
-				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER！！！(ALL interrupt)\n");
-				save_to_file("Transition:2x2:SLAVE>>>>>>>MASTER！！！(ALL interrupt) PartnerSync_Health = %d\n",s_2x2_state_Ctrl.PartnerSync_Health);
+				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER！！！(ALL interrupt) PartnerSync_Health = %d\n",s_2x2_state_Ctrl.PartnerSync_Health);
 			}
 			else
 			{
 				/*- 存在断线-宕机 */
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_SHUTDOWN;
-				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>SHUTDOWN  ALL interrupt\n");
-				save_to_file("Transition:2x2:SLAVE>>>>>>>SHUTDOWN  ALL interrupt PartnerSync_Health = %d\n", s_2x2_state_Ctrl.PartnerSync_Health);
+				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>SHUTDOWN  ALL interrupt PartnerSync_Health = %d\n", s_2x2_state_Ctrl.PartnerSync_Health);
 				CM_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_5);
 			}
 		}
@@ -972,14 +908,12 @@ static void s_State_Transition(void)
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
 			s_State_SwitchState_Init();
 			SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER(ROLLBACK PartnerState = %d LastLocalState = %d)\n",s_2x2_state_Ctrl.PartnerState,s_2x2_state_Ctrl.LastLocalState);
-			save_to_file("Transition:2x2:SLAVE>>>>>>>MASTER(ROLLBACK PartnerState = %d LastLocalState = %d)\n",s_2x2_state_Ctrl.PartnerState,s_2x2_state_Ctrl.LastLocalState);
 		}
 		/*- 与主系输出不一致 或应用跟随数据不一致*/
 		else if(CM_FALSE == s_2x2_state_Ctrl.LocalSyncFailFlag)
 		{
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 			SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>OFFLINE(OutPut failed or appflow failed)\n");
-			save_to_file("Transition:2x2:SLAVE>>>>>>>OFFLINE(OutPut failed or appflow failed)\n");
 			s_State_SwitchState_Init();
 		}
 		else if((ENUM_2x2_MASTER == s_2x2_state_Ctrl.PartnerState) &&
@@ -993,7 +927,6 @@ static void s_State_Transition(void)
 			{
 				s_2x2_state_Ctrl.LocalState = ENUM_2x2_MASTER;
 				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>MASTER((SWITCH:0x%x,AID:0x%x)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag);
-				save_to_file("Transition:2x2:SLAVE>>>>>>>MASTER((SWITCH:0x%x,AID:0x%x)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag);
 			}
 			else
 			{
@@ -1001,9 +934,6 @@ static void s_State_Transition(void)
 				SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>Do Not Change(SWITCH:0x%x,AID:0x%x,COM:0x%x,LSH:%d,PSH:%d,LCCH:%d,PCCH:%d)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag,
 											s_State_Get_CommunicationState(ENUM_2x2_COM_SWITCH_CONDITION),s_2x2_state_Ctrl.LocalSync_Health,s_2x2_state_Ctrl.PartnerSync_Health,
 											s_2x2_state_Ctrl.LocalCC_Health,s_2x2_state_Ctrl.PartnerCC_Health);
-				save_to_file("Transition:2x2:SLAVE>>>>>>>Do Not Change(SWITCH:0x%x,AID:0x%x,COM:0x%x,LSH:%d,PSH:%d,LCCH:%d,PCCH:%d)\n",s_2x2_state_Ctrl.ctrSwitchFlag,s_2x2_state_Ctrl.aidSwitchFlag,
-															s_State_Get_CommunicationState(ENUM_2x2_COM_SWITCH_CONDITION),s_2x2_state_Ctrl.LocalSync_Health,s_2x2_state_Ctrl.PartnerSync_Health,
-															s_2x2_state_Ctrl.LocalCC_Health,s_2x2_state_Ctrl.PartnerCC_Health);
 			}
 			s_State_SwitchState_Init();
 		}
@@ -1017,7 +947,6 @@ static void s_State_Transition(void)
 			/*- 本系离线 */
 			s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
 			SFM_LOG_MSG_2X("Transition:2x2:SLAVE>>>>>>>OFFLINE(Lose Sync)\n");
-			save_to_file("Transition:2x2:SLAVE>>>>>>>OFFLINE(Lose Sync)\n");
 		}
 		else
 		{
@@ -1102,14 +1031,12 @@ static CM_THREAD_FUNC_T  SFM_2x2_StateChange_Thread(void)
 						/*- 检测到对系是主系，本系宕机*/
 						s_2x2_state_Ctrl.LocalState = ENUM_2x2_SHUTDOWN;
 						SFM_LOG_MSG_2X("Transition:2x2:MASTER>>>>>>>Double MASTER!!!(Shut Down)\n");
-						save_to_file("Transition:2x2:MASTER>>>>>>>Double MASTER!!!(Shut Down)\n");
 						CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_4, TSCP_DARK_ASSERT_1);
 					}
 					else
 					{
 						/*恢复上周期状态*/
 						SFM_LOG_MSG_2X("Transition:2x2:Double MASTER Recovery!!!(Last State)\n");
-						save_to_file("Transition:2x2:Double MASTER Recovery!!!(Last State)\n");
 						s_2x2_state_Ctrl.LocalState = s_2x2_state_Ctrl.LastLocalState;
 						TempState = s_2x2_state_Ctrl.LastPartnerState;
 						s_2x2_state_Ctrl.LastPartnerState = s_2x2_state_Ctrl.PartnerState;
@@ -1136,6 +1063,11 @@ static CM_THREAD_FUNC_T  SFM_2x2_StateChange_Thread(void)
 
 		/*发送2x状态结束信号量*/
 		CM_Sem_Post(s_2x2_thread_Ctrl.m_Stop);
+		if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+		{
+			Area_Arb_Start();
+		}
+
 	}
 
 	return NULL;
@@ -1236,8 +1168,15 @@ void SFM_4x2_ChangeState(void)
 	/*- 等待2x结束信号量*/
 	CM_Sem_Wait(s_2x2_thread_Ctrl.m_Stop);
 	/*- 等待Area结束信号量*/
-	Area_Wait_Stop();
-	Area_LOG_Transition();
+	if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+	{
+		Area_Arb_Wait_Stop();
+	}
+	else
+	{
+		Area_Wait_Stop();
+	}
+	
 	MSCP_LOG_MSG("SFM_4x2_ChangeState start\n");
 	/*- 执行最后的切系逻辑*/
 	s_2x2_Ctrl.MineComState  = MSCP_Get_2X_VagueCom_State(&s_2x2_state_Ctrl.MineComOKCount[0]);   /**< 本机通信状态，2oo2交换 */
@@ -1245,7 +1184,8 @@ void SFM_4x2_ChangeState(void)
 	s_2x2_Ctrl.MineExtendState = MSCP_Get_2X_VagueCom_State(&s_2x2_state_Ctrl.MineExtendOKCount[0]);  /**< 本机串口通信状态，2oo2交换 */
 	s_2x2_Ctrl.PeerExtendState = MSCP_Get_2X_VagueCom_State(&s_2x2_state_Ctrl.PeerExtendOKCount[0]);  /**< 邻机串口通信状态，2oo2交换 */
 	/**获取区域状态 */	
-	Area_Get_All_State(&Area_State);
+	Area_Arb_Common_Get_All_State(&Area_State);
+	
 	/*- 切系完成*/
 	if(ENUM_2x2_AIDSWITCH_OVER == s_2x2_state_Ctrl.LocalAIDSwitchState)
 	{
@@ -1328,13 +1268,14 @@ void SFM_4x2_ChangeState(void)
 	/**< 本系区域状态 */
 	s_2x2_state_Ctrl.LocalAreaState = Area_State.Local_state;
 	MSCP_LOG_MSG("s_2x2_state_Ctrl.LocalAreaState = %d  2x2 = %d\n",Area_State.Local_state, s_2x2_state_Ctrl.LocalState);
+	printf("AreaState = %d  2x2 = %d\n",Area_State.Local_state, s_2x2_state_Ctrl.LocalState);
 	/**<是否存在区域备地*/
-	s_2x2_state_Ctrl.Area_Slave_Is_Exist = Area_Slave_Is_Exist();
+	s_2x2_state_Ctrl.Area_Slave_Is_Exist = Area_Arb_Common_Slave_Is_Exist();
 	/*- 2x线程->更新主线程热备状态*/
 	s_2x2_Ctrl.LocalState = SFM_2x2_StateDecision(s_2x2_state_Ctrl.LocalAreaState,s_2x2_state_Ctrl.LocalState);
     /* 判断3乘是离线则将地状态设置为离线，
      * （通控健康度2乘、数据同步失败导致离线需要将地的状态拉下来） */
-    if ((ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.LocalState) && ((ENUM_AREA_MASTER == s_2x2_state_Ctrl.LocalAreaState) || (ENUM_AREA_SLAVE == s_2x2_state_Ctrl.LocalAreaState)))
+    if ((0x55u != g_PFM_Cfg.M_Arb_Enable) && (ENUM_2x2_OFFLINE == s_2x2_state_Ctrl.LocalState) && ((ENUM_AREA_MASTER == s_2x2_state_Ctrl.LocalAreaState) || (ENUM_AREA_SLAVE == s_2x2_state_Ctrl.LocalAreaState)))
     {
         Area_Set_State(ENUM_AREA_OFFLINE);
         MSCP_LOG_MSG("2x state is %d set area offline\n",s_2x2_state_Ctrl.LocalAreaState);
@@ -1394,6 +1335,7 @@ void SFM_4x2_ChangeState(void)
 	(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_PARTNER, 1U, &s_2x2_Ctrl.PartnerState);
 
 	SFM_2x2_LOG_Transition();
+	Area_LOG_Transition();
 	MSCP_LOG_MSG("timecurr 16.0.4 = %lld us\n", NOW_USED_TIME);
 	MSCP_LOG_MSG("SFM_4x2_ChangeState stop\n");
 }
@@ -1469,12 +1411,12 @@ ENUM_4x2_STATE_T SFM_2x2_AreaDecision(ENUM_AREA_STATE PartnerAreaState,CM_BOOL i
             if (isA == CM_TRUE)
             {
                 // A系主备配对：0x01<->0x03
-                rtn_state = (masterHighByte == Area_GetArea_A_ID())? ENUM_4x2_MASTER : ENUM_4x2_SLAVE;
+                rtn_state = (masterHighByte == Area_Arb_Common_GetArea_A_ID())? ENUM_4x2_MASTER : ENUM_4x2_SLAVE;
             }
             else
             {
                 // B系主备配对：0x02<->0x04
-                rtn_state = (masterHighByte == Area_GetArea_B_ID())? ENUM_4x2_MASTER : ENUM_4x2_SLAVE;
+                rtn_state = (masterHighByte == Area_Arb_Common_GetArea_B_ID())? ENUM_4x2_MASTER : ENUM_4x2_SLAVE;
             }
             break;
         default:
@@ -1626,6 +1568,10 @@ void SFM_2x2_Init(IN const CM_UINT8 *VitalBuf, IN CM_UINT16 VitalLen, INOUT CM_U
         /*独立线程参数初始化*/
         s_2x2_thread_Ctrl.number_Cyc = (g_PFM_Cfg.CYC_TIME - 60U) / MSCP_2X2_THREAD_TIME;/*根据周期计算,预留60ms*/
         (s_2x2_thread_Ctrl.number_Cyc > 1u)?(s_2x2_thread_Ctrl.number_Cyc) : (s_2x2_thread_Ctrl.number_Cyc = 1u);
+		if(0x55u == g_PFM_Cfg.M_Arb_Enable && 2u < s_2x2_thread_Ctrl.number_Cyc)
+		{
+			s_2x2_thread_Ctrl.number_Cyc -= 2u;
+		}
         CM_Sem_Init(&s_2x2_thread_Ctrl.m_Start);
         CM_Sem_Init(&s_2x2_thread_Ctrl.m_Stop);
 
@@ -1866,7 +1812,7 @@ static void s_2x2_Recv(void)
     ENUM_CM_RETURN ret = ENUM_CM_FALSE;          /* 临时变量 */
     PFM_LOG_SET_STOPTIMER(TSCP_DARK_2x2);
     /*- 以太网循环接收2x2数据 */
-    if(CM_TRUE == CFM_GetTimeSyncFlag())
+    if(CM_TRUE == s_2x2_Ctrl.TimeSyncFlag)
     {
 		do
 		{
@@ -2464,7 +2410,6 @@ void SFM_2x2_OutputProc(IN const CM_UINT8 *CheckBuf, CM_INT32 CheckLen)
         {
             /*- 进行输出比较 */
             ret = CM_Memcmp((const void*)CheckBuf, (void*)s_2x2_Ctrl.RxCheckFrame, (CM_SIZE_T)CheckLen);
-            ret = 0;//qap
             /*- 输出比较是否一致 */
             if (0 == ret)
             {
@@ -2597,7 +2542,7 @@ static CM_UINT8 SFM_2x2_RecvAppFollowData(CM_UINT32 sysCyc)
 			else if(s_2x2_Ctrl.RxAppFollowSysCrcCyc < peerCtrl.RxAppFollowSysCrcCyc)
 			{
 				MSCP_LOG_MSG("B-A:g_RxAppFollowCrc_len:%lld\n",g_RxAppFollowCrc_len);
-				g_RxAppFollow_len = SFM_2oo2_Exchange_Currency(g_RxAppFollowCrc, 0, g_RxAppFollowCrc, sizeof(g_RxAppFollowCrc), ENUM_2oo2_END_EX);
+				g_RxAppFollowCrc_len = SFM_2oo2_Exchange_Currency(g_RxAppFollowCrc, 0, g_RxAppFollowCrc, sizeof(g_RxAppFollowCrc), ENUM_2oo2_END_EX);
 				s_2x2_Ctrl.RxAppFollowSysCrcCyc = peerCtrl.RxAppFollowSysCrcCyc;
 				/**用于记录综合主系ID */
 				SFM_2x2_SetMasterID(peerCtrl.MasterID);
@@ -2636,7 +2581,6 @@ void SFM_2x2_EndProc(void)
 	CM_UINT8 type = 0u;  /*接收到的跟随数据类型 1 CRC  2 全数据*/
 	static CM_UINT8 debounce = 0u; /*防抖计数*/
 	CM_UINT8 SendFollowDataType = 0u;
-	CM_UINT32 i = 0u;
 
 
 	if(ENUM_4x2_MASTER == stat)
@@ -2645,7 +2589,6 @@ void SFM_2x2_EndProc(void)
 		curTickTest[0] = CM_GetTick();
 		/* 条件  本地对系是备或者宕机 && 对地A是备或者宕机 && 对地B是备或者宕机*/
 		SendFollowDataType = SFM_GetAppFollowType();
-		SendFollowDataType = 0;
 		if(1u == SendFollowDataType)
 		{
 			/*- 发送跟随数据 */
@@ -2655,7 +2598,7 @@ void SFM_2x2_EndProc(void)
         		SFM_2x2_Send(g_TxAppFollow, (CM_UINT32)8, ENUM_2x2_MSG_APP_FOLLOW_CRC);
                 MSCP_LOG_MSG("Iam master partner is slave send appfollowcrc\n");
                 debounce = 3u;
-                //MSCP_LOG_BIN(g_TxAppFollow + 8, g_TxAppFollow_len - 4);//qap
+                //MSCP_LOG_BIN(g_TxAppFollow + 8, g_TxAppFollow_len - 4);
     		}
     		else
     		{
@@ -2699,20 +2642,14 @@ void SFM_2x2_EndProc(void)
     	{
     		/*- 是否收到了最新的应用跟随数据 */
 			/*- 调用应用API覆盖应用关键数据 */
-
-			//retFollowUp = APP_API_FollowUp(g_RxAppFollow, (CM_UINT32)g_RxAppFollow_len);
-			//CM_RE_ASSERT(ENUM_CM_TRUE == retFollowUp, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_9, TSCP_DARK_ASSERT_2);
-			for(i = 0u; i < g_RxAppFollow_len; i++)
-			{
-				g_RxAppFollow[i] = 0;
-			}
+			retFollowUp = APP_API_FollowUp(g_RxAppFollow, (CM_UINT32)g_RxAppFollow_len);
+			CM_RE_ASSERT(ENUM_CM_TRUE == retFollowUp, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_9, TSCP_DARK_ASSERT_2);
 			s_2x2_Ctrl.AppFollowCmpFailFlag = 0u;
     	}
     	else
     	{
     		MSCP_LOG_MSG("no follow data\n");
     	}
-		curTickTest[1] = CM_GetTick();
 	}
 	else
 	{
@@ -3697,5 +3634,21 @@ CM_UINT8 SFM_GetLocalCCHealth(void)
 {
 	return s_2x2_state_Ctrl.LocalCC_Health;
 }
+/**
+ * @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)
+{
+	if(NULL != localstate)
+	{
+		*localstate = s_2x2_state_Ctrl.LocalState;
+	}
+	if(NULL != partnerstate)
+	{
+		*partnerstate = s_2x2_state_Ctrl.PartnerState;
+	}
+}
 
 

TSCP/src/MSCP/SFM/SFM_2x2.h

@@ -561,7 +561,13 @@ extern CM_UINT32 g_MSCP_SysCount;
     /*获取通控健康度 >0 为健康*/
     CM_UINT8 SFM_GetLocalCCHealth(void);
 
-    void save_to_file(const char *format, ...);//qap test
+	/**
+	 * @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
 }