1.4线模式和仲裁模式的通用接口封装

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);

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,198 @@
+#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->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->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,131 @@
+#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               (26u)
+#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 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_UINT8 BoardID;  /**< 板卡ID 插箱id */
-    CM_UINT32 Cpuid;  /**< cpu id */
+    CM_UINT8 Cpuid;  /**< cpu id */
-    CM_UINT32 Partner_BoardID;  /**< 对系板卡id */
+    CM_UINT8 Partner_BoardID;  /**< 对系板卡id */
-    CM_UINT32 Partner_Area_A_BoardID;  /**< 对系id */
+    CM_UINT8 Partner_Area_A_BoardID;  /**< 对系id */
-    CM_UINT32 Partner_Area_B_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 Local_state;/**< 本系区域状态*/
-    ENUM_AREA_STATE Partner_state;/**< 区域状态*/
+    ENUM_AREA_STATE Partner_state;/**< 对系区域状态*/
-    ENUM_AREA_STATE Partner_Area_A_state;/**< 区域状态*/
+    ENUM_AREA_STATE Partner_Area_A_state;/**< 另一地A区域状态*/
-    ENUM_AREA_STATE Partner_Area_B_state;/**< 区域状态*/
+    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
  {
@@ -26,10 +31,13 @@
      CM_MQ_Struct_T MsgQ; /**< 接收消息队列 */
  }STR_Area_IP_Cfg;
  
+
  CM_THREAD_FUNC_T t_Area_2oo2_UdpRecvThread(IN CM_Thread_Arg_Struct_T* arg);
  CM_THREAD_FUNC_T t_Area_UdpRecvThread(IN STR_Area_IP_Cfg* arg);
  ENUM_CM_RETURN Area_LogMQ_Init(void);
  void Area_LOG_MSG(IN const CM_CHAR *filename, IN CM_INT32 line, IN const CM_CHAR* fmt, ...);
 #define AREA_LOG_MSG(fmt, ...) (Area_LOG_MSG(FILENAME(__FILE__),(CM_INT32)__LINE__,(fmt), ##__VA_ARGS__))
 
+#endif
+
 

TSCP/src/MSCP/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,6 +180,7 @@ ENUM_CM_RETURN CM_UDP_Socket_Create(OUT CM_SOCKET* pSock, IN CM_BOOL isNonBlockM
     ENUM_CM_RETURN retError = ENUM_CM_FALSE; /* 临时返回值 */
     struct ip_mreq multiCast;         /* 组播配置 */           
     CM_INT32 bCast = 1;
+    CM_UINT8 loop;    /* 0 = disable, 1 = enable (default) */
     /*- 是否UDP服务未初始化或输入非法 */
     if ((CM_TRUE != s_UDP_Initialized) || (NULL == pSock))
     {
@@ -209,6 +210,8 @@ 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 = 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>
@@ -242,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)
@@ -324,7 +327,15 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 	/*发送2x状态结束信号量*/
     SFM_2x2_SemPost();
     /*< 发送区域通信结束信号量*/
+    if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+    {
+        Area_Arb_Stop();
+    }
+    else
+    {
         Area_Stop();
+    }
+    
 	(void)DFM_SetIO_OutPut(0x00u);
     /*- 循环执行周期逻辑 */
     while (1)
@@ -446,7 +457,11 @@ static CM_THREAD_FUNC_T MSCP_CycBase(void)
 		/*TODO 发送2x状态起始信号量*/
 		SFM_2x2_Thread_PostStart();
 		/* 发送区域线程开始信号*/
+        if(0x55 != g_PFM_Cfg.M_Arb_Enable)
+        {
             Area_Start();
+        }
+		
 		PFM_CFC_Check(24);
 		/*- 发起校时请求*/
 		CFM_SendLocalARQ();
@@ -629,7 +644,7 @@ static void SelfCheckInit(void)
 {
 #ifdef QNX
     /*- 文件自检初始化 */
-    PFM_FileInit();
+    //PFM_FileInit();
 	/*- 内存自检初始化*/
     PFM_MemCheck_Init();
 	/*- CPU自检初始化*/

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,\
+	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.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_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"
 
 /*通信中断时间和同步超时时间可以相同，此时优先执行通信中断切系*/
 
@@ -1060,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;
@@ -1160,8 +1168,15 @@ void SFM_4x2_ChangeState(void)
 	/*- 等待2x结束信号量*/
 	CM_Sem_Wait(s_2x2_thread_Ctrl.m_Stop);
 	/*- 等待Area结束信号量*/
+	if(0x55u == g_PFM_Cfg.M_Arb_Enable)
+	{
+		Area_Arb_Wait_Stop();
+	}
+	else
+	{
 		Area_Wait_Stop();
-	Area_LOG_Transition();
+	}
+	
 	MSCP_LOG_MSG("SFM_4x2_ChangeState start\n");
 	/*- 执行最后的切系逻辑*/
 	s_2x2_Ctrl.MineComState  = MSCP_Get_2X_VagueCom_State(&s_2x2_state_Ctrl.MineComOKCount[0]);   /**< 本机通信状态，2oo2交换 */
@@ -1169,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)
 	{
@@ -1252,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);
@@ -1318,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");
 }
@@ -1393,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:
@@ -1550,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);
 
@@ -3612,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,6 +561,13 @@ extern CM_UINT32 g_MSCP_SysCount;
     /*获取通控健康度 >0 为健康*/
     CM_UINT8 SFM_GetLocalCCHealth(void);
 
+	/**
+	 * @brief 获取2乘线程中的（s_2x2_state_ctrl）中的2乘状态
+	 * @param localstate 获取到的本系状态
+	 * @param partnerstate 获取到的另一系状态
+	 */
+	void SFM_2x2_GetStateAfterStateChange(OUT ENUM_2x2_STATE_T *localstate, OUT ENUM_2x2_STATE_T *partnerstate);
+
 
 #ifdef __cplusplus
 }