lih/TSCP
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: lih/TSCP:9.9
Branches Tags
lih/TSCP:master lih/TSCP:stable/新加坡分支 lih/TSCP:dev/9.11 lih/TSCP:test/四乘压力测试 lih/TSCP:dev/9.3.101.3 lih/TSCP:stable/9.4.1分支 lih/TSCP:test/轨旁IP化测试 lih/TSCP:debug/9.4.2应用跟随调试 lih/TSCP:stable/迪士尼分支
lih/TSCP:分支9.3.1 lih/TSCP:9.10 lih/TSCP:9.9 lih/TSCP:9.8 lih/TSCP:分支9.4.2 lih/TSCP:9.7 lih/TSCP:9.6 lih/TSCP:9.5 lih/TSCP:9.3 lih/TSCP:9.2 lih/TSCP:9.1
...
compare: lih/TSCP:dev/9.11
Branches Tags
lih/TSCP:stable/新加坡分支 lih/TSCP:dev/9.11 lih/TSCP:test/四乘压力测试 lih/TSCP:master lih/TSCP:dev/9.3.101.3 lih/TSCP:stable/9.4.1分支 lih/TSCP:test/轨旁IP化测试 lih/TSCP:debug/9.4.2应用跟随调试 lih/TSCP:stable/迪士尼分支
lih/TSCP:分支9.3.1 lih/TSCP:9.10 lih/TSCP:9.9 lih/TSCP:9.8 lih/TSCP:分支9.4.2 lih/TSCP:9.7 lih/TSCP:9.6 lih/TSCP:9.5 lih/TSCP:9.3 lih/TSCP:9.2 lih/TSCP:9.1

12 Commits
9.9 ... dev/9.11

Author SHA1 Message Date
lh 57e7dbd2cc 每周期都执行切系原因的重置 2026-08-14 11:29:57 +08:00
lh e71ced450f 1.修改远程重启授权原因bug 
2.增加暗文日志记录切系原因
3.版本号+1
 2026-08-13 18:35:02 +08:00
lh 4608905392 IP配置使用ioctl，宕机后日志发送时判断初始化阶段 2026-08-05 18:30:22 +08:00
lh 50225f68cf 修改2取重传限制次数，根据周期时间决定 2026-08-05 16:04:23 +08:00
lh d718b121de 限制主线程和2乘独立线程2取重传次数 2026-08-03 18:03:35 +08:00
lh f09be247b4 9.11第一次提交，备系非安全升主和限制两个维护终端，待调试 2026-07-30 16:43:19 +08:00
lh e1b5126cd9 Merge branch 'dev/9.10' 2026-07-30 11:20:12 +08:00
lh 66937f1160 变更会后提交，删除重启命令源id的2取校验 2026-07-20 17:59:31 +08:00
lh b7b0dac7d8 修改协议状态信息和指令分开发送逻辑 2026-07-20 16:34:21 +08:00
lh 3a9ff37074 AIM发送重启回复与状态信息分开发送，二次请求源ID不一致返回失败原因6（重启命令错误） 2026-07-17 14:34:10 +08:00
lh 7e69b7c395 AID重启功能不受影响，待与AIM调试 2026-07-15 16:31:39 +08:00
lh 34a4ef5569 同时建链两条成功，待调试 2026-07-14 17:47:43 +08:00
17 changed files with 907 additions and 156 deletions
Expand all files Collapse all files
TSCP/src/APP/APP_API.c
+14 -3
View File
@@ -29,7 +29,7 @@ extern UINT8 LocalCiId; /*系
const CM_UINT8 g_SfpInnetParam[] =
{
0,5,/*不同设备通信关系表记录个数*/
0,7,/*不同设备通信关系表记录个数*/
/*记录的格式如下:*/
/* 发起方 发起方发送数据 发起方报文 发起方报文 发起方接收Ack 跟随方 跟随方发送数据 跟随方运行 跟随方报文 此通信关系中成功发送 */
/* 设备类型 通信类型 发送周期长度 最大延时 报文最大延时差 设备类型 通信类型 周期长度 最大延时 一包数据所需最小周期数 */
@@ -37,7 +37,9 @@ const CM_UINT8 g_SfpInnetParam[] =
/*AOM->TIAS*/ 0x15, 0x55, 0x00,0xC8, 0x00,0xC8, 0x00,0xC8, 0x03, 0x55, 0x00,0xC8, 0x00,0xC8, 0x02,
/*AOM->ATP*/ 0x14, 0x55, 0x00,0xC8, 0x00,0xC8, 0x00,0xC8, 0x15, 0x55, 0x00,0xC8, 0x00,0xC8, 0x02,
/*RC主机->维护机*/ 0xD9, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0xf8, 0x55, 0x00,0xc8, 0x00,0xc8, 0x02,
/*RC主机->维护机*/ 0xD9, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0x30, 0x55, 0x01,0x2c, 0x01,0x2C, 0x02,
/*CI主机->维护机*/ 0xDE, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0xf8, 0x55, 0x00,0xc8, 0x00,0xc8, 0x02,
/*CI主机->维护机*/ 0xDE, 0x55, 0x01,0x2c, 0x01,0x2C, 0x01,0x2C, 0x30, 0x55, 0x01,0x2c, 0x01,0x2C, 0x02,
0,2,/*相同设备通信关系表记录个数*/
/*记录的格式如下:*/
/* 发起方 发起方 发起方发送数据 发起方报文 发起方报文 发起方接收Ack 跟随方 跟随方 跟随方发送数据 跟随方运行 跟随方报文 此通信关系中成功发送 */
@@ -301,7 +303,7 @@ void APP_API_Data_Init()
.M_OutnetRaw_Enable = 0xAA, /**< 外网透传通信功能开关 */
.M_CpuUsageGet_Enable = 0x55,/**< 获取cpu使用率功能开关 */
.M_RemoteUpdate_Enable = 0x55,/**< 远程部署内网安全通信功能开关 */
.ID_Maintenance = DEVICE_TYPE_AIM,
.ID_Maintenance = {2, DEVICE_TYPE_AIM, 0x3001U},
.Start_Path = "/emmc1", /**< 程序启动路径 */
.reboot_replycount = 10, /**< 重启确认报文回复次数 */
.M_AutoReboot_Count = 3, /**< 自动重启次数 */
@@ -369,12 +371,17 @@ void APP_API_Data_Init()
.OutNetBlue.OutnetRaw_Port = 54002, /**< 外网透传通信端口 */
.OutNetBlue.InnetRaw_Port = 53003, /**< 内网透传通信端口 */
.INNET_COM_NUM = 1, /**< 内网通信设备数量 */
.INNET_COM_NUM = 2, /**< 内网通信设备数量 */
.INNET_COM_CFG[0].InnetID = DEVICE_TYPE_AIM, /**< 内网通信ID */
.INNET_COM_CFG[0].Port_Raw_G = 55004, /**< 绿网透传端口 */
.INNET_COM_CFG[0].Port_Safe_G = 55003, /**< 绿网安全端口 */
.INNET_COM_CFG[0].Port_Raw_P = 55004, /**< 紫网透传端口 */
.INNET_COM_CFG[0].Port_Safe_P = 55003, /**< 紫网安全端口 */
.INNET_COM_CFG[1].InnetID = 0X3001U, /**< 内网通信ID */
.INNET_COM_CFG[1].Port_Safe_G = 55005, /**< 绿网安全端口 */
.INNET_COM_CFG[1].Port_Raw_G = 0XFFFF,
.INNET_COM_CFG[1].Port_Safe_P = 55005, /**< 紫网安全端口 */
.INNET_COM_CFG[1].Port_Raw_P = 0XFFFF,
};
@@ -442,6 +449,8 @@ void APP_API_Data_Init()
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.18.100"), (UINT32)sizeof("192.168.18.100"));
AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.146.100");
AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.18.100");
AppCfgInterface.INNET_COM_CFG[1].IP_G = (CM_UINT32)inet_addr("192.168.146.100");
AppCfgInterface.INNET_COM_CFG[1].IP_P = (CM_UINT32)inet_addr("192.168.18.100");
}
else
@@ -506,6 +515,8 @@ void APP_API_Data_Init()
(void)CommonMemCpy((void*)(AppCfgInterface.Logger_P_IP), (UINT32)sizeof(CM_CHAR) * 32, (const void*)("192.168.20.100"), (UINT32)sizeof("192.168.20.100"));
AppCfgInterface.INNET_COM_CFG[0].IP_G = (CM_UINT32)inet_addr("192.168.148.100");
AppCfgInterface.INNET_COM_CFG[0].IP_P = (CM_UINT32)inet_addr("192.168.20.100");
AppCfgInterface.INNET_COM_CFG[1].IP_G = (CM_UINT32)inet_addr("192.168.148.100");
AppCfgInterface.INNET_COM_CFG[1].IP_P = (CM_UINT32)inet_addr("192.168.20.100");
}
if(SYSTEM_WORK_MODE_ONLY == cSystemWorkType)
TSCP/src/MSCP/CFM/CFM_Net.c
+36 -41
View File
@@ -37,8 +37,15 @@
#include "PFM_RemoteUpdate.h"
#include "MSCP_Define.h"
#include "CFM_Raw.h"
#include "CM_IP.h"
#include <stdarg.h>
/** @brief 网卡名 */
#define CFM_IP_INTERFACE_2oo2 "fec0"
#define CFM_IP_INTERFACE_2x2 "fec1"
#define CFM_IP_INTERFACE_MAINTAIN "wm0"
#define CFM_IP_NETMASK "255.255.255.0"
#define CFM_2oo2_MSG_NUM_MAX (200u)
#define CFM_2X2_MSG_NUM_MAX (200u)
#define CFM_OUTNET_MSG_NUM_MAX (5000u)
@@ -406,7 +413,7 @@ static void s_SockInit_2oo2(void)
rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Assert, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Assert,0u, ENUM_UNICAST);
CM_NM_ASSERT(ENUM_CM_TRUE == rt, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_26);
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 创建维护模式下的2取socket */
rt = CM_UDP_Socket_Create(&s_CFM_Sock.Sock_2oo2_Maintenance, CM_FALSE, (CM_UINT32)inet_addr(g_PFM_Cfg.Local_Cfg.IP_2oo2), g_PFM_Cfg.Local_Cfg.Port_2oo2_Maintenance, 0u, ENUM_UNICAST);
@@ -475,7 +482,7 @@ static void s_NetInit_2oo2(void)
rtCheck = CM_Thread_Create((CM_THREAD_T*)NULL, (CM_THREAD_FUNC_T)t_UdpRecvThread, "2oo2_Rx", 0, CM_TASK_PRIORITY_73, (CM_Thread_Arg_Struct_T*)&s_CFM_Rx2oo2_Assert);
CM_NM_ASSERT(CM_TRUE == rtCheck, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_29);
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
CM_NM_ASSERT(s_CFM_Rx2oo2Mainteance.IP != NULL, NET_MODE,DARK_FAULT_CODE_FUN_ORDER_1, TSCP_DARK_ASSERT_19);
(void)sprintf(s_CFM_Rx2oo2Mainteance.IP, "%s", g_PFM_Cfg.Local_Cfg.IP_2oo2);
@@ -1031,6 +1038,7 @@ CM_INT32 CFM_2oo2_Currency_NoSplit(STRU_2OO2_NET_NO_PACK_T *p_2oo2_Ctrl,IN const
/*发送相关*/
CM_UINT8 sendBuf[1500] = {0u};
CM_UINT32 sysCyc = DFM_GetBirthCount(); /*平台周期号*/
CM_UINT16 ARQ_Cut = 0u; /* 记录重传请求次数 */
CM_UINT64 curTick = 0u; /* 当前时刻 */
CM_UINT64 sTick = 0u; /* 起始Tick */
@@ -1118,6 +1126,7 @@ CM_INT32 CFM_2oo2_Currency_NoSplit(STRU_2OO2_NET_NO_PACK_T *p_2oo2_Ctrl,IN const
{
/*发送重传请求*/
(void)CFM_2oo2_SendARQ_Currency(p_2oo2_Ctrl,ENUM_2oo2_NET_ARQ);
ARQ_Cut++;
/*- 重置起始时间*/
sTick = CM_GetTick();
}
@@ -1126,6 +1135,10 @@ CM_INT32 CFM_2oo2_Currency_NoSplit(STRU_2OO2_NET_NO_PACK_T *p_2oo2_Ctrl,IN const
/*- 无处理 */
}
}
if(ENUM_BOARDSTATE_RUN == PFM_GetBoardState() && SFM_2oo2_ARQ_MAX_CNT <= ARQ_Cut)
{
CM_ASSERT(0,NET_MODE, DARK_FAULT_CODE_FUN_ORDER_53, TSCP_DARK_ASSERT_1);
}
if((CM_TRUE == mineRcvFlag) && (CM_TRUE == peerRcvFlag))
{
/*- 结束接收 */
@@ -3199,7 +3212,7 @@ static void s_NetInit_RemoteUpdate(void)
CM_BOOL rtCheck; /* 临时变量 */
CM_INT32 i = 0; /* 循环变量 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/* 维护模式下用到的cfg全局变量数据拷贝，防护内存自检宕机引起的维护模式下使用cfg全局变量异常 */
g_RMUP_Cfg.CPU_ID=g_PFM_Cfg.CPU_ID;
@@ -3319,24 +3332,17 @@ void CFM_Net_Init(void)
void CFM_NetworkCard_Init(void)
{
/*- 变量初始化 */
CM_CHAR str[1024] = {0};
ENUM_CM_RETURN ret = ENUM_CM_FALSE;
/*- 配置2取网卡ip */
(void)memset(str, 0, sizeof(str));
(void)sprintf(str, "ifconfig %s %s", "fec0", g_PFM_Cfg.Local_Cfg.IP_2oo2);
(void)printf("%s\n",str);
(void)system(str);
/*- 配置2取网卡ip */
ret = CM_IP_TrySetIpAddrRetry(CFM_IP_INTERFACE_2oo2, g_PFM_Cfg.Local_Cfg.IP_2oo2, CFM_IP_NETMASK, 2);
CM_NM_ASSERT(ENUM_CM_TRUE == ret, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_42, TSCP_DARK_ASSERT_1);
/*- 配置通用网卡ip */
(void)memset(str, 0, sizeof(str));
(void)sprintf(str, "ifconfig %s %s", "fec1", g_PFM_Cfg.Local_Cfg.IP_Com);
(void)printf("%s\n",str);
(void)system(str);
ret = CM_IP_TrySetIpAddrRetry(CFM_IP_INTERFACE_2x2, g_PFM_Cfg.Local_Cfg.IP_Com, CFM_IP_NETMASK, 2);
CM_NM_ASSERT(ENUM_CM_TRUE == ret, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_42, TSCP_DARK_ASSERT_2);
/*- 配置维护网卡ip */
(void)memset(str, 0, sizeof(str));
(void)sprintf(str, "ifconfig %s %s", "wm0", g_PFM_Cfg.Local_Cfg.IP_Maintain);
(void)printf("%s\n",str);
(void)system(str);
ret = CM_IP_TrySetIpAddrRetry(CFM_IP_INTERFACE_MAINTAIN, g_PFM_Cfg.Local_Cfg.IP_Maintain, CFM_IP_NETMASK, 2);
CM_NM_ASSERT(ENUM_CM_TRUE == ret, NET_MODE, DARK_FAULT_CODE_FUN_ORDER_42, TSCP_DARK_ASSERT_3);
}
/**
* @brief UDP接收线程
@@ -3779,6 +3785,7 @@ static CM_THREAD_FUNC_T t_RemoteUpdateThread(IN CM_Thread_Arg_Struct_T* arg)
CM_UINT16 rmtPort_raw;/* 对方透传端口 */
struct in_addr serveraddr;/* 源ip */
CM_UINT8 Result = 0x0u;/* 请求处理结果 */
CM_UINT16 innetID = 0U;
#if QNX
void* pmask = NULL;
/*- 本线程锁定在 A53 core 1 */
@@ -3786,25 +3793,7 @@ static CM_THREAD_FUNC_T t_RemoteUpdateThread(IN CM_Thread_Arg_Struct_T* arg)
(void)ThreadCtl(_NTO_TCTL_RUNMASK, pmask);
#endif
MSCP_LOG_MSG("IP:%s:%d UDP recv Start\n", pCtrl->IP, pCtrl->port);
/*- 获取目的IP端口 */
pCom = PFM_INI_InnetID2Addr(g_Maintenance_Id);
if (NULL != pCom)
{
/*- 本机是否为CPU1 */
if (1u == g_PFM_Cfg.CPU_ID)
{
rmtIP = pCom->IP_G;
rmtPort_safe = pCom->Port_Safe_G;
rmtPort_raw = pCom->Port_Raw_G;
}
else
{
rmtIP = pCom->IP_P;
rmtPort_safe = pCom->Port_Safe_P;
rmtPort_raw = pCom->Port_Raw_P;
}
}
else
if(0u == g_Maintenance_Ids[0])
{
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(NET_MODE, DARK_FAULT_CODE_FUN_ORDER_9, TSCP_DARK_ASSERT_1));
MSCP_LOG_MSG("Map Value From g_Maintenance_Id Error!!!\n");
@@ -3821,10 +3810,16 @@ static CM_THREAD_FUNC_T t_RemoteUpdateThread(IN CM_Thread_Arg_Struct_T* arg)
if (len > 0)
{
MSCP_LOG_DATALEN(rcvBuf, len, "t_RemoteUpdateThread rcvBuflen");
/*- 源IP端口是否合法 */
if ((srcIP == rmtIP) && ((srcPort== rmtPort_safe) || (srcPort == rmtPort_raw)))
pCom = PFM_INI_InnetIP2Addr(srcIP, srcPort);
rt = ENUM_CM_FALSE;
if(NULL != pCom)
{
if (srcPort== rmtPort_safe)
rt = PFM_MaintenanceID_Search(pCom->InnetID);
}
/*- 源IP端口是否合法 */
if (ENUM_CM_TRUE == rt)
{
if (srcPort== pCom->Port_Safe_G || srcPort == pCom->Port_Safe_P)
{
/*- @alias 需要解sfp协议的远程部署命令 */
/*- @alias 将收到的完整帧写入线程接收队列 */
@@ -4039,7 +4034,7 @@ void CFM_NetFlush(void)
{
/*无处理 */
}
if((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 内网远程部署接收缓冲区清空 */
rt = CM_MQ_Flush(&s_CFM_RxRemoteUpdate.MsgQ);
TSCP/src/MSCP/CFM/CFM_Net.h
+2
View File
@@ -41,6 +41,8 @@ extern "C"
#define CFM_INNET_RAW_MSG_NUM_MAX (7000u)
#define CFM_OUTNET_RAW_MSG_NUM_MAX (1000u)
#define SFM_2oo2_ARQ_MAX_CNT ((ENUM_INIT_OVER<=PFM_LOG_GET_INIT_STAGE())?(g_PFM_Cfg.CYC_TIME/50u+1u):6000u)
/*暗文类型宏定义*/
#define DARK_LOG_STRING (0x55u)
TSCP/src/MSCP/CM/CM_IP.c
+437
View File
@@ -0,0 +1,437 @@
#include "CM_IP.h"
#include "CM_Memory.h"
#include "PFM_Log.h"
#include <arpa/inet.h>
#include <net/if.h>
#include <netinet/in.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <unistd.h>
/**
* @brief 检查设置IP接口的输入参数
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4地址字符串
* @param[in] pNetMask 子网掩码字符串
* @return 参数检查结果
*/
static ENUM_CM_RETURN CM_IP_SetIpAddrParamCheck(IN const CM_CHAR *pNetCardName,
IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
/* 按使用顺序检查参数，避免在空指针上执行strlen等操作。 */
if (NULL == pNetCardName)
{
printf("CM_IP_SetIpAddr netcard name is NULL.\n");
}
else if (strlen(pNetCardName) >= IFNAMSIZ)
{
printf("CM_IP_SetIpAddr netcard name is too long: %s.\n", pNetCardName);
}
else if (NULL == pIpAddr)
{
printf("CM_IP_SetIpAddr ipAddr is NULL.\n");
}
else if (NULL == pNetMask)
{
printf("CM_IP_SetIpAddr netMask is NULL.\n");
}
else
{
rt = ENUM_CM_TRUE;
}
return rt;
}
/**
* @brief 检查读取IP接口的输入参数
* @param[in] pNetCardName 网卡名
* @param[out] pIpAddr IPv4地址输出缓存
* @param[in] ipAddrLen IPv4地址输出缓存长度
* @param[out] pNetMask 子网掩码输出缓存
* @param[in] netMaskLen 子网掩码输出缓存长度
* @return 参数检查结果
*/
static ENUM_CM_RETURN CM_IP_GetIpAddrParamCheck(IN const CM_CHAR *pNetCardName,
OUT CM_CHAR *pIpAddr,
IN CM_UINT32 ipAddrLen,
OUT CM_CHAR *pNetMask,
IN CM_UINT32 netMaskLen)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
/* 输出缓存需要能够容纳最长IPv4字符串及结尾字符。 */
if (NULL == pNetCardName)
{
printf("CM_IP_GetIpAddr netcard name is NULL.\n");
}
else if (strlen(pNetCardName) >= IFNAMSIZ)
{
printf("CM_IP_GetIpAddr netcard name is too long: %s.\n", pNetCardName);
}
else if (NULL == pIpAddr)
{
printf("CM_IP_GetIpAddr ipAddr is NULL.\n");
}
else if (CM_IP_ADDR_STR_LEN > ipAddrLen)
{
printf("CM_IP_GetIpAddr ipAddr buffer is too small.\n");
}
else if (NULL == pNetMask)
{
printf("CM_IP_GetIpAddr netMask is NULL.\n");
}
else if (CM_IP_ADDR_STR_LEN > netMaskLen)
{
printf("CM_IP_GetIpAddr netMask buffer is too small.\n");
}
else
{
rt = ENUM_CM_TRUE;
}
return rt;
}
/**
* @brief 设置网卡IPv4地址
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串
* @param[in] pNetMask 子网掩码点分十进制字符串
* @return 设置结果
*/
ENUM_CM_RETURN CM_IP_SetIpAddr(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
ENUM_CM_RETURN retMem = ENUM_CM_FALSE;
ENUM_CM_RETURN paramCheckRt = ENUM_CM_FALSE;
CM_INT32 sock = -1;
CM_INT32 ret = 0;
CM_INT32 ipConvertRet = 0;
CM_INT32 netMaskConvertRet = 0;
struct ifreq ifReq;
struct sockaddr_in *pSockAddr = NULL;
struct in_addr netMaskAddr;
/* 参数检查失败时不创建socket，也不修改网卡配置。 */
paramCheckRt = CM_IP_SetIpAddrParamCheck(pNetCardName, pIpAddr, pNetMask);
if (ENUM_CM_TRUE == paramCheckRt)
{
/* ifreq在本函数中只初始化一次，网卡名和地址族供两个ioctl共用。 */
retMem = CM_Memset((void*)&ifReq, (CM_UINT8)0U, (CM_SIZE_T)sizeof(struct ifreq),
(CM_SIZE_T)sizeof(struct ifreq));
if (ENUM_CM_TRUE != retMem)
{
printf("CM_IP_SetIpAddr memset ifreq failed.\n");
}
else
{
(void)strncpy(ifReq.ifr_name, pNetCardName, IFNAMSIZ - 1);
pSockAddr = (struct sockaddr_in*)&ifReq.ifr_addr;
#ifdef QNX
pSockAddr->sin_len = sizeof(struct sockaddr_in);
#endif
pSockAddr->sin_family = AF_INET;
/* 先完成IP和掩码格式转换，任一格式错误都不执行ioctl。 */
ipConvertRet = (CM_INT32)inet_pton(AF_INET, pIpAddr, &pSockAddr->sin_addr);
netMaskConvertRet = (CM_INT32)inet_pton(AF_INET, pNetMask, &netMaskAddr);
if (1 != ipConvertRet)
{
if (0 == ipConvertRet)
{
printf("CM_IP_SetIpAddr invalid ip address: %s.\n", pIpAddr);
}
else
{
perror("CM_IP_SetIpAddr inet_pton");
}
}
else if (1 != netMaskConvertRet)
{
if (0 == netMaskConvertRet)
{
printf("CM_IP_SetIpAddr invalid netmask: %s.\n", pNetMask);
}
else
{
perror("CM_IP_SetIpAddr netmask inet_pton");
}
}
else
{
sock = (CM_INT32)socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
{
perror("CM_IP_SetIpAddr socket");
}
else
{
/*- 通过临时UDP socket设置指定网卡IP */
ret = (CM_INT32)ioctl(sock, SIOCSIFADDR, &ifReq);
if (0 != ret)
{
perror("CM_IP_SetIpAddr ioctl SIOCSIFADDR");
MSCP_LOG_MSG("CM_IP_SetIpAddr ioctl SIOCSIFADDR, %s:%s:%s\n",pNetCardName, pIpAddr, strerror(errno));
}
else
{
/* 保留网卡名和地址族，只清除已使用的IP地址字段后写入掩码。 */
retMem = CM_Memset((void*)&pSockAddr->sin_addr, (CM_UINT8)0U,
(CM_SIZE_T)sizeof(struct in_addr),
(CM_SIZE_T)sizeof(struct in_addr));
if (ENUM_CM_TRUE != retMem)
{
printf("CM_IP_SetIpAddr memset address failed.\n");
}
else
{
pSockAddr->sin_addr = netMaskAddr;
ret = (CM_INT32)ioctl(sock, SIOCSIFNETMASK, &ifReq);
if (0 != ret)
{
perror("CM_IP_SetIpAddr ioctl SIOCSIFNETMASK");
MSCP_LOG_MSG("CM_IP_SetIpAddr ioctl SIOCSIFNETMASK, %s:%s:%s\n",
pNetCardName, pNetMask, strerror(errno));
}
else
{
rt = ENUM_CM_TRUE;
}
}
}
(void)close(sock);
}
}
}
}
return rt;
}
/**
* @brief 尝试设置网卡IPv4地址并读回校验
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串
* @param[in] pNetMask 子网掩码点分十进制字符串
* @return 设置和校验结果
*/
ENUM_CM_RETURN CM_IP_TrySetIpAddr(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
ENUM_CM_RETURN setRt = ENUM_CM_FALSE;
ENUM_CM_RETURN getRt = ENUM_CM_FALSE;
CM_CHAR ipAddrRead[CM_IP_ADDR_STR_LEN] = { 0 };
CM_CHAR netMaskRead[CM_IP_ADDR_STR_LEN] = { 0 };
/* 设置成功后立即读回，IP和掩码均一致才认为配置成功。 */
setRt = CM_IP_SetIpAddr(pNetCardName, pIpAddr, pNetMask);
if (ENUM_CM_TRUE != setRt)
{
printf("CM_IP_TrySetIpAddr set ip failed.\n");
}
else
{
getRt = CM_IP_GetIpAddr(pNetCardName, ipAddrRead, (CM_UINT32)sizeof(ipAddrRead),
netMaskRead, (CM_UINT32)sizeof(netMaskRead));
if (ENUM_CM_TRUE != getRt)
{
printf("CM_IP_TrySetIpAddr get ip failed.\n");
}
else if (0 != strcmp(ipAddrRead, pIpAddr))
{
printf("CM_IP_TrySetIpAddr ip mismatch, set:%s, read:%s.\n", pIpAddr, ipAddrRead);
}
else if (0 != strcmp(netMaskRead, pNetMask))
{
printf("CM_IP_TrySetIpAddr netmask mismatch, set:%s, read:%s.\n", pNetMask, netMaskRead);
}
else
{
rt = ENUM_CM_TRUE;
}
}
return rt;
}
/**
* @brief 尝试设置网卡IPv4地址，失败时重复尝试
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串
* @param[in] pNetMask 子网掩码点分十进制字符串
* @param[in] retryTimes 失败后的重试次数，总尝试次数为retryTimes + 1
* @return 设置和校验结果
*/
ENUM_CM_RETURN CM_IP_TrySetIpAddrRetry(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask, IN CM_UINT32 retryTimes)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
CM_UINT32 tryIndex = 0u;
CM_CHAR log_buf[1024] = {0};
/* retryTimes表示首次尝试失败后的额外重试次数。 */
while (CM_TRUE)
{
if (0u != tryIndex)
{
printf("CM_IP_TrySetIpAddrRetry retry %u.\n", tryIndex);
}
else
{
/* No action. */
}
rt = CM_IP_TrySetIpAddr(pNetCardName, pIpAddr, pNetMask);
if (ENUM_CM_TRUE == rt)
{
break;
}
else if (tryIndex >= retryTimes)
{
break;
}
else
{
tryIndex++;
}
}
if (ENUM_CM_TRUE == rt)
{
(void)snprintf(log_buf, sizeof(log_buf), "IP Set Success, Interface:%s, IP:%s, NetMask:%s, retryTimes:%u.\n",
(NULL != pNetCardName) ? pNetCardName : "NULL",
(NULL != pIpAddr) ? pIpAddr : "NULL",
(NULL != pNetMask) ? pNetMask : "NULL", tryIndex);
}
else
{
(void)snprintf(log_buf, sizeof(log_buf), "IP Set Failed, Interface:%s, IP:%s, NetMask:%s, retryTimes:%u.\n",
(NULL != pNetCardName) ? pNetCardName : "NULL",
(NULL != pIpAddr) ? pIpAddr : "NULL",
(NULL != pNetMask) ? pNetMask : "NULL", tryIndex);
}
printf("%s", log_buf);
MSCP_LOG_MSG("%s", log_buf);
return rt;
}
/**
* @brief 读取网卡IPv4地址
* @param[in] pNetCardName 网卡名
* @param[out] pIpAddr IPv4点分十进制字符串输出缓存
* @param[in] ipAddrLen pIpAddr缓存长度
* @param[out] pNetMask 子网掩码字符串输出缓存
* @param[in] netMaskLen pNetMask缓存长度
* @return 读取结果
*/
ENUM_CM_RETURN CM_IP_GetIpAddr(IN const CM_CHAR *pNetCardName, OUT CM_CHAR *pIpAddr,
IN CM_UINT32 ipAddrLen, OUT CM_CHAR *pNetMask,
IN CM_UINT32 netMaskLen)
{
ENUM_CM_RETURN rt = ENUM_CM_FALSE;
ENUM_CM_RETURN retMem = ENUM_CM_FALSE;
ENUM_CM_RETURN paramCheckRt = ENUM_CM_FALSE;
CM_INT32 sock = -1;
CM_INT32 ret = 0;
struct ifreq ifReq;
struct sockaddr_in *pSockAddr = NULL;
const CM_CHAR *pRetIpAddr = NULL;
/* 参数合法后再清空输出，防止空指针或短缓存被写入。 */
paramCheckRt = CM_IP_GetIpAddrParamCheck(pNetCardName, pIpAddr, ipAddrLen,
pNetMask, netMaskLen);
if (ENUM_CM_TRUE == paramCheckRt)
{
pIpAddr[0] = '\0';
pNetMask[0] = '\0';
/* ifreq在本函数中只初始化一次，随后仅复用其中的地址字段。 */
retMem = CM_Memset((void*)&ifReq, (CM_UINT8)0U, (CM_SIZE_T)sizeof(struct ifreq),
(CM_SIZE_T)sizeof(struct ifreq));
if (ENUM_CM_TRUE != retMem)
{
printf("CM_IP_GetIpAddr memset ifreq failed.\n");
}
else
{
(void)strncpy(ifReq.ifr_name, pNetCardName, IFNAMSIZ - 1);
pSockAddr = (struct sockaddr_in*)&ifReq.ifr_addr;
#ifdef QNX
pSockAddr->sin_len = sizeof(struct sockaddr_in);
#endif
pSockAddr->sin_family = AF_INET;
sock = (CM_INT32)socket(AF_INET, SOCK_DGRAM, 0);
if (sock < 0)
{
perror("CM_IP_GetIpAddr socket");
}
else
{
/*- 通过临时UDP socket读取指定网卡IP */
ret = (CM_INT32)ioctl(sock, SIOCGIFADDR, &ifReq);
if (0 != ret)
{
perror("CM_IP_GetIpAddr ioctl SIOCGIFADDR");
MSCP_LOG_MSG("CM_IP_GetIpAddr ioctl SIOCGIFADDR, %s:%s:%s\n",pNetCardName, pIpAddr, strerror(errno));
}
else
{
/*- 将二进制地址转换为点分十进制IP字符串 */
pRetIpAddr = (const CM_CHAR*)inet_ntop(AF_INET, &pSockAddr->sin_addr, pIpAddr, ipAddrLen);
if (NULL == pRetIpAddr)
{
perror("CM_IP_GetIpAddr inet_ntop");
}
else
{
/* 保留网卡名和地址族，只清除IP查询写入的地址字段。 */
retMem = CM_Memset((void*)&pSockAddr->sin_addr, (CM_UINT8)0U,
(CM_SIZE_T)sizeof(struct in_addr),
(CM_SIZE_T)sizeof(struct in_addr));
if (ENUM_CM_TRUE != retMem)
{
printf("CM_IP_GetIpAddr memset address failed.\n");
}
else
{
ret = (CM_INT32)ioctl(sock, SIOCGIFNETMASK, &ifReq);
if (0 != ret)
{
perror("CM_IP_GetIpAddr ioctl SIOCGIFNETMASK");
MSCP_LOG_MSG("CM_IP_GetIpAddr ioctl SIOCGIFNETMASK, %s:%s\n",
pNetCardName, strerror(errno));
}
else
{
pRetIpAddr = (const CM_CHAR*)inet_ntop(AF_INET, &pSockAddr->sin_addr,
pNetMask, netMaskLen);
if (NULL == pRetIpAddr)
{
perror("CM_IP_GetIpAddr netmask inet_ntop");
}
else
{
rt = ENUM_CM_TRUE;
}
}
}
}
}
(void)close(sock);
}
}
}
return rt;
}
TSCP/src/MSCP/CM/CM_IP.h
+65
View File
@@ -0,0 +1,65 @@
/**
* @file CM_IP.h
* @brief 获取网卡IP地址
*/
#ifndef CM_IP_H_
#define CM_IP_H_
#include "CM_Types.h"
/** @brief IPv4点分十进制字符串长度，包含字符串结束符 */
#define CM_IP_ADDR_STR_LEN (16u)
/**
* @brief 设置网卡IPv4地址
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串，例如"192.168.1.10"
* @param[in] pNetMask 子网掩码点分十进制字符串，例如"255.255.255.0"
* @return 设置结果
* - ENUM_CM_TRUE 成功
* - ENUM_CM_FALSE 失败
*/
ENUM_CM_RETURN CM_IP_SetIpAddr(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask);
/**
* @brief 尝试设置网卡IPv4地址并读回校验
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串，例如"192.168.1.10"
* @param[in] pNetMask 子网掩码点分十进制字符串
* @return 设置和校验结果
* - ENUM_CM_TRUE 设置成功且读回一致
* - ENUM_CM_FALSE 设置失败或读回不一致
*/
ENUM_CM_RETURN CM_IP_TrySetIpAddr(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask);
/**
* @brief 尝试设置网卡IPv4地址，失败时重复尝试
* @param[in] pNetCardName 网卡名
* @param[in] pIpAddr IPv4点分十进制字符串，例如"192.168.1.10"
* @param[in] pNetMask 子网掩码点分十进制字符串
* @param[in] retryTimes 失败后的重试次数，总尝试次数为retryTimes + 1
* @return 设置和校验结果
* - ENUM_CM_TRUE 设置成功且读回一致
* - ENUM_CM_FALSE 全部尝试失败或读回不一致
*/
ENUM_CM_RETURN CM_IP_TrySetIpAddrRetry(IN const CM_CHAR *pNetCardName, IN const CM_CHAR *pIpAddr,
IN const CM_CHAR *pNetMask, IN CM_UINT32 retryTimes);
/**
* @brief 读取网卡IPv4地址
* @param[in] pNetCardName 网卡名
* @param[out] pIpAddr IPv4点分十进制字符串输出缓存
* @param[in] ipAddrLen pIpAddr缓存长度，至少为CM_IP_ADDR_STR_LEN
* @param[out] pNetMask 子网掩码字符串输出缓存
* @param[in] netMaskLen pNetMask缓存长度，至少为CM_IP_ADDR_STR_LEN
* @return 读取结果
* - ENUM_CM_TRUE 成功
* - ENUM_CM_FALSE 失败
*/
ENUM_CM_RETURN CM_IP_GetIpAddr(IN const CM_CHAR *pNetCardName, OUT CM_CHAR *pIpAddr,
IN CM_UINT32 ipAddrLen, OUT CM_CHAR *pNetMask,
IN CM_UINT32 netMaskLen);
#endif
TSCP/src/MSCP/MSCP_APP_API.c
+1 -1
View File
@@ -160,7 +160,7 @@ CM_UINT8 MSCP_AppSendMsg(IN ENUM_MSCP_MSG_CHN_T ch, IN CM_UINT16 dstName,
/*- 返回 */
break;
case ENUM_MSG_INNET_MAINTENANCE: /*-< 远程部署内网安全通信 */
rt = Prtcl_InnetSafe_AppRmSend(txBuf, txLen);
rt = Prtcl_InnetSafe_AppRmSend(dstName, txBuf, txLen);
MSCP_LOG_MSG("MSCP_AppSendMsg txLen = %d \n",txLen);
MSCP_LOG_BIN(txBuf,txLen);
/*- 返回 */
TSCP/src/MSCP/PFM/PFM_Cfg.c
+2 -2
View File
@@ -40,11 +40,11 @@
CM_CHAR FS_FILE_PATH[100];
/** 平台软件版本号 */
const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 1u, 1u, 63u };
const CM_UINT8 MSCP_SW_VERION[4] = { 93u, 1u, 1u, 66u };
/** 驱动软件版本号 */
CM_UINT8 MSCP_DRV_VERION[4] = {0};
/** 与维护一体机接口文档版本号(接口文档发生改变时升级版本号) */
CM_UINT16 TSCP_DOC_VERION[2] = {38u,0u};
CM_UINT16 TSCP_DOC_VERION[2] = {40u,0u};
/** 操作系统版本号 */
CM_UINT8 TSCP_QNX_VERION[10] = {0u};
TSCP/src/MSCP/PFM/PFM_Cfg.h
+1 -1
View File
@@ -262,7 +262,7 @@ extern CM_UINT8 TSCP_QNX_VERION[10]; /** 操作系统版本号 */
CM_UINT32 M_RemoteUpdate_Enable;/**< 远程部署内网安全通信功能开关 */
CM_UINT8 M_Area_Enable; /**< 倒切配置，0x00为兼容的主线版本，0x55为CI，0xAA为RC */
CM_UINT8 M_AREA_SEB_Enable; /**< 区域串口板卡使能开关 */
CM_UINT16 ID_Maintenance; /*维护终端ID*/
CM_UINT16 ID_Maintenance[257]; /*维护终端ID,可能有多个，固定下标0表示ID个数, 下标1表示主要ID*/
CM_CHAR Start_Path[32]; /**< 程序启动路径 */
CM_INT32 reboot_replycount; /**< 重启确认报文回复次数 */
CM_UINT8 M_AutoReboot_Count; /**< 自动重启次数 */
TSCP/src/MSCP/PFM/PFM_Log.c
+23 -21
View File
@@ -401,15 +401,14 @@ void MSCP_ASSERT(unsigned int x, unsigned int MaintenanceFlag, unsigned short Mo
if(ENUM_INIT_MAIN_NET <= PFM_LOG_GET_INIT_STAGE())
{
CFM_LogCiphertextSend();
}
/*- 等待日志队列全部发送*/
LogQisEmpty = CFM_LogQ_isEmpty();
while (ENUM_CM_FALSE == LogQisEmpty)
{
CFM_LogCiphertextSend();
CM_Sleep(5u);
/*- 等待日志队列全部发送*/
LogQisEmpty = CFM_LogQ_isEmpty();
while (ENUM_CM_FALSE == LogQisEmpty)
{
CFM_LogCiphertextSend();
CM_Sleep(5u);
LogQisEmpty = CFM_LogQ_isEmpty();
}
}
/*- 退出运营故障码*/
@@ -538,14 +537,14 @@ void MSCP_REBOOT_ASSERT(unsigned int x, unsigned int MaintenanceFlag,unsigned sh
if(ENUM_INIT_MAIN_NET <= PFM_LOG_GET_INIT_STAGE())
{
CFM_LogCiphertextSend();
}
/*- 等待日志队列全部发送*/
LogQisEmpty = CFM_LogQ_isEmpty();
while (ENUM_CM_FALSE == LogQisEmpty)
{
CFM_LogCiphertextSend();
CM_Sleep(5u);
/*- 等待日志队列全部发送*/
LogQisEmpty = CFM_LogQ_isEmpty();
while (ENUM_CM_FALSE == LogQisEmpty)
{
CFM_LogCiphertextSend();
CM_Sleep(5u);
LogQisEmpty = CFM_LogQ_isEmpty();
}
}
/* 启动跟踪录制 */
@@ -940,7 +939,7 @@ static void PFM_LOG_MaintenanceMode(ENUM_BOARD_STATE_T MaintenanceFlag, CM_UINT3
while (1)
{
/*- 远程部署功能开关开启，并且维护id应用已设置不是初始值0 是否允许进入维护模式*/
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) && (0x00u != g_Maintenance_Id) && (0x55 == MaintenanceFlag) && ((ENUM_BOARDSTATE_EXIT == boardState) || (ENUM_BOARDSTATE_UPDATE == boardState) || (ENUM_BOARDSTATE_DEFAULT == boardState)))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) && (0u < g_Maintenance_Ids[0]) && (0x55 == MaintenanceFlag) && ((ENUM_BOARDSTATE_EXIT == boardState) || (ENUM_BOARDSTATE_UPDATE == boardState) || (ENUM_BOARDSTATE_DEFAULT == boardState)))
{
MSCP_LOG_MSG("----------Maintenance Mode count = %d----------\n",s_count);
@@ -989,8 +988,8 @@ static void PFM_LOG_MaintenanceMode(ENUM_BOARD_STATE_T MaintenanceFlag, CM_UINT3
}
else
{
MSCP_LOG_MSG("MaintenanceFlag = %d, g_Maintenance_Id = %d, g_RMUP_Cfg.M_RemoteUpdate_Enable = %d, boardState = %d\n", \
MaintenanceFlag,g_Maintenance_Id,g_RMUP_Cfg.M_RemoteUpdate_Enable,boardState);
MSCP_LOG_MSG("MaintenanceFlag = %d, g_Maintenance_Id nums = %d, g_RMUP_Cfg.M_RemoteUpdate_Enable = %d, boardState = %d\n", \
MaintenanceFlag,g_Maintenance_Ids[0],g_RMUP_Cfg.M_RemoteUpdate_Enable,boardState);
CM_Sleep(CM_UINT32_MAX);
}
}
@@ -1112,7 +1111,10 @@ CM_UINT32 *PFM_DarkLogGenerate(CM_UINT16 mode, CM_UINT16 fault, CM_UINT16 num)
/* 宕机前向通控发送状态为宕机的心跳 连续发送三包*/
static void s_OutnetHeart_Send(void)
{
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
if(ENUM_INIT_NET <= PFM_LOG_GET_INIT_STAGE())
{
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
CFM_TxOutnetHeart(ENUM_2x2_SHUTDOWN);
}
}
TSCP/src/MSCP/PFM/PFM_Log.h
+2
View File
@@ -117,6 +117,8 @@ extern "C"
/*分帧接收*/
#define TSCP_DARK_SFM_2OO2FRAME (0x80u)
#define TSCP_DARK_SFM_2X2FRAME (0x81u)
/*2乘切系原因*/
#define TSCP_DARK_2X2_SWITCH_REASON (0x82u)
/*警告标志定义*/
#define TSCP_DARK_WARNING (0x1FFEu)
/** 初始化阶段标志 */
TSCP/src/MSCP/PFM/PFM_RemoteUpdate.c
+130 -54
View File
@@ -34,7 +34,7 @@
#define WAIT_TIME_2S (2000u/g_PFM_Cfg.CYC_TIME + 1u)
#define WAIT_TIME_10S (10000u/g_PFM_Cfg.CYC_TIME + 1u)
#define WAIT_TIME_120S (120000u/g_PFM_Cfg.CYC_TIME + 1u)
CM_UINT16 g_Maintenance_Id = 0x00u;/* 维护终端内网id */
CM_UINT16 g_Maintenance_Ids[256] = {0};/* 维护终端内网id */
CM_UINT8 g_RemoteUpdate_State = 0x00u;/* 远程部署过程状态 */
ENUM_BOARD_STATE_T g_boardState = ENUM_BOARDSTATE_ERROR;
@@ -44,11 +44,13 @@ static CM_UINT32 s_packTimer = 0u; /**< 请求命令时间戳 */
static CM_UINT32 s_packFirstSendTimer = 0u; /**< 第一次回复重启确认的周期号 */
static CM_UINT32 s_packFirstRecvTimer = 0u; /**< 收到aid第一次回复重启确认的周期号 */
static CM_UINT8 reboottype = 0u;/**< 重启请求命令 0x55:未更新重启 0xaa:升级重启 0xd1~d7:硬重启 */
static CM_UINT16 s_rebootSrcid = 0u;
extern CM_UINT32 g_MSCP_SysCount; /**< 系统周期号 */
static CM_UINT8 s_countres = 0u;/**重启确认报文回复次数计数 */
static CM_UINT8 packAccredit = 2u; /**授权状态 (当变量置为0或者1,则需要处理远程重启请求报文)*/
static CM_UINT8 reasonAuthorization = 0u; /*授权原因*/
static CM_UINT8 s_HardReboottype = 0u;/**<0xd1~d7:硬重启 */
static CM_UINT16 s_HardRebootSrcid = 0u;/*接收到的重启命令的源ID*/
static CM_UINT8 s_packHardAccredit = 2u; /**硬重启授权状态 (当变量置为0或者1,则需要处理远程重启请求报文)*/
static CM_UINT8 s_reasonHardAuthorization = 0u; /*硬重启授权原因*/
@@ -100,7 +102,7 @@ static void PFM_DataReastart_SendTwo(void);
static void PFM_RM_File(IN CM_UINT8 pathname[]);
/*- 远程硬件重启命令接收处理 */
static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16 packLen,CM_UINT8 packType);
static void PFM_Data_HardWareReastart(CM_UINT16 srcName, CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16 packLen,CM_UINT8 packType);
/*- 远程切系命令接收处理 */
static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16 packLen,CM_UINT8 packType);
@@ -109,7 +111,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
static void PFM_RemoteSwitch_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UINT8 accredit,CM_UINT8 reason);
/*- 硬件重启确认帧组包发送 */
static void PFM_HardWareReastart_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UINT8 accredit,CM_UINT8 reason);
static void PFM_HardWareReastart_Send(CM_UINT8 type,CM_UINT16 dstName, CM_UINT32 rcv_packTime,CM_UINT8 accredit,CM_UINT8 reason);
/*- 继电器检测 */
static ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_Realy_Check(ENUM_HARDWARE_BOOT_SELFCHECK_T s_selfcheck_state,CM_UINT32 s_OutPutTime, CM_UINT8 comResult);
@@ -284,7 +286,7 @@ ENUM_CM_RETURN PFM_InnetRemoteUpdate_Send(IN CM_UINT8 ResponseBuf[],IN CM_UINT16
STRU_PFM_INNET_CFG_T* pCom = NULL;/* 通信配置 */
/*- 获取目的IP端口 */
pCom = PFM_INI_InnetID2Addr(g_Maintenance_Id);
pCom = PFM_INI_InnetID2Addr(g_Maintenance_Ids[1]);
/*- 是否获取成功 */
if ((NULL != ResponseBuf) && (NULL != pCom))
{
@@ -796,7 +798,7 @@ ENUM_CM_RETURN PFM_FileVerity_Response(IN CM_UINT32 TimeStamp,IN STRU_FILE_UPDAT
CM_UINT8 PFM_RmUp_Check(void)
{
/*- 变量初始化 */
CM_UINT8 rt = 0u; /* 函数返回值为成功 */
CM_UINT8 rt = packAccredit; /* 函数返回值为授权原因 */
/*- 如果crc计算错误 */
if((1 == reasonAuthorization) && (1 == packAccredit))
{
@@ -1034,7 +1036,7 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
CM_UINT8 i = 0;
MSCP_LOG_MSG("Maintenance Mode DevStateSendIndex = %d\n",DevStateSendIndex);
if((0x00u != g_Maintenance_Id) && (0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) && (0x55u == g_RMUP_Cfg.M_2oo2_Enable))
if((0u < g_Maintenance_Ids[0]) && (0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) && (0x55u == g_RMUP_Cfg.M_2oo2_Enable))
{
/* 总长度(临时添加) */
txLen = 0u;
@@ -1164,7 +1166,6 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
/*- 检查2oo2双机的输出校验帧是否一致 */
CM_ASSERT_MAINTAIN(offset == rxLen);
/*- 设置设备id */
dstName = g_Maintenance_Id;
if(1u == g_RMUP_Cfg.CPU_ID)
{
(void)CM_Memcpy(txBuf+offset,1000u-offset,rxBuf+3u,rxLen-3u);
@@ -1177,8 +1178,12 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
/* 填入长度,总长是offset-自身2字节 */
txLen = offset - 2u;
CM_ShortToChar(txLen, &txBuf[0]);
ret = Prtcl_InnetSafe_RmSend(dstName, txBuf, offset);
MSCP_LOG_MSG("offset = %d send ret =%d\n",offset, ret);
for(i = 1; i <= g_Maintenance_Ids[0]; i++)
{
dstName = g_Maintenance_Ids[i];
ret = Prtcl_InnetSafe_RmSend(dstName, txBuf, offset);
MSCP_LOG_MSG("INNET RM dst id %04x offset = %d send ret =%d\n",dstName, offset, ret);
}
}
else
{
@@ -1191,8 +1196,12 @@ ENUM_CM_RETURN PFM_DevStateSend(CM_UINT8 ifCyc)
/* 填入长度,总长是offset-自身2字节 */
rxLen = offset - 2u;
CM_ShortToChar(rxLen, &rxBuf[0]);
ret = Prtcl_InnetSafe_RmSend(dstName, rxBuf, offset);
MSCP_LOG_MSG("offset = %d send ret = %d\n",offset, ret);
for(i = 1; i <= g_Maintenance_Ids[0]; i++)
{
dstName = g_Maintenance_Ids[i];
ret = Prtcl_InnetSafe_RmSend(dstName, rxBuf, offset);
MSCP_LOG_MSG("INNET RM dst id %04x offset = %d send ret =%d\n",dstName, offset, ret);
}
}
}
else
@@ -1229,6 +1238,7 @@ static CM_UINT8 PFM_DataReastart_Recv(void)
CM_UINT8 boardType = 0u;
CM_UINT8 boardId = 0u;
CM_UINT32 packRestartCrc = 0u; /*重启请求命令crc*/
static CM_BOOL flag_first_request = CM_FALSE;
do
{
/*- 从内网安全协议读取应用接收报文 */
@@ -1306,15 +1316,17 @@ static CM_UINT8 PFM_DataReastart_Recv(void)
{
/*- 无处理 */
}
flag_first_request = CM_TRUE;
packAccredit = 0u;
reasonAuthorization = 0u;
MSCP_LOG_MSG("0xa5 reboottype = %d\n",reboottype);
}
}
/*- 如果帧类型是二次请求确认 */
else if(0xa6 == packType)
else if(0xa6 == packType && CM_TRUE == flag_first_request)
{
/*- 按照二次请求确认帧继续解包 */
flag_first_request = CM_FALSE;
boardType = mData[dataOffset];
dataOffset +=1u;
MSCP_LOG_MSG("boardType = %d\n",boardType);
@@ -1460,7 +1472,7 @@ static void PFM_DataReastart_Send(void)
CM_ShortToChar(packLen, &mData[0]);
/*- 发送远程重启确认报文 */
MSCP_LOG_MSG("shut down dateOffset = %d, packLen = %d\n",dataOffset,packLen);
(void)Prtcl_InnetSafe_AppRmSend(mData, dataOffset);
(void)Prtcl_InnetSafe_AppRmSend(g_Maintenance_Ids[1], mData, dataOffset);
}
else
{
@@ -1533,7 +1545,7 @@ static void PFM_DataReastart_SendTwo(void)
CM_ShortToChar(packLen, &mData[0]);
/*- 发送远程重启确认报文 */
MSCP_LOG_MSG("shut down dateOffset = %d, packLen = %d\n",dataOffset,packLen);
(void)Prtcl_InnetSafe_AppRmSend(mData, dataOffset);
(void)Prtcl_InnetSafe_AppRmSend(g_Maintenance_Ids[1], mData, dataOffset);
}
else
{
@@ -1674,39 +1686,74 @@ void PFM_MaintenanceMode(void)
* @brief 设置维护终端内网id
* @param dstName 维护终端内网id
*/
void PFM_SetMaintenanceId(IN CM_UINT16 dstName )
void PFM_SetMaintenanceId(IN CM_UINT16* dstNames )
{
/*- 变量初始化 */
CM_INT32 i = 0;
CM_INT32 i = 0, j = 0, index = 1;
CM_UINT8 FindFlag = 0u;
CM_UINT32 dstNums= 0u;
/*- 开始遍历内网通信配置:是否遍历完成:下一条配置 */
for (i = 1; i <= (CM_INT32)g_PFM_Cfg.INNET_COM_NUM; i++)
{
/*- 是否找到了目标内网ID */
if (dstName == g_PFM_Cfg.INNET_COM_CFG[i].InnetID)
{
/*- 设置维护终端内网id */
g_Maintenance_Id = dstName;
FindFlag = 1u;
/*- 返回 */
break;
}
else
{
/*- 无处理 */
}
}
if(NULL != dstNames)
{
dstNums = dstNames[0];
if(MAINTAIN_ID_MAX_NUM < dstNums)
{
dstNums = MAINTAIN_ID_MAX_NUM;
}
for (i = 1; i <= (CM_INT32)dstNums; i++)
{
for(j = 1; j <= (CM_INT32)g_PFM_Cfg.INNET_COM_NUM; j++)
{
/*- 是否找到了目标内网ID */
if (dstNames[i] == g_PFM_Cfg.INNET_COM_CFG[j].InnetID)
{
/*- 设置维护终端内网id */
g_Maintenance_Ids[index++] = dstNames[i];
FindFlag = 1u;
break;
/*- 返回 */
}
else
{
/*- 无处理 */
}
}
}
}
g_Maintenance_Ids[0] = index - 1;
if (1u != FindFlag)
{
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_10, TSCP_DARK_ASSERT_1));
MSCP_LOG_MSG("MSCP_SetMaintenanceId Error!!! dstName not find in INNET_COM_CFG InnetID\n",dstName);
MSCP_LOG_MSG("MSCP_SetMaintenanceId Error!!! dstName not find in INNET_COM_CFG InnetID\n");
}
else
{
}
}
/**
* @brief 查询维护ID是否存在
* @param id 待查询的ID
* @return
* ENUM_CM_TRUE-存在
* ENUM_CM_FALSE-不存在
*/
ENUM_CM_RETURN PFM_MaintenanceID_Search(IN CM_UINT16 id)
{
ENUM_CM_RETURN ret = ENUM_CM_FALSE;
CM_UINT32 i = 0;
for(i = 1u; i <= g_Maintenance_Ids[0]; i++)
{
if(id == g_Maintenance_Ids[i])
{
ret = ENUM_CM_TRUE;
break;
}
}
return ret;
}
/**
* @brief 硬件重启确认帧组包发送
* @param type 发送数据类型 取值范围：0x55或0x56
@@ -1715,7 +1762,7 @@ void PFM_SetMaintenanceId(IN CM_UINT16 dstName )
* @param reason 授权原因 取值范围：0~0xff
* @return 无
*/
static void PFM_HardWareReastart_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UINT8 accredit,CM_UINT8 reason)
static void PFM_HardWareReastart_Send(CM_UINT8 type,CM_UINT16 dstName, CM_UINT32 rcv_packTime,CM_UINT8 accredit,CM_UINT8 reason)
{
/*- 变量初始化 */
CM_UINT8 mData[1000] = { 0u };
@@ -1769,7 +1816,7 @@ static void PFM_HardWareReastart_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UI
dataOffset += 4u;
packLen = dataOffset - 2u;
CM_ShortToChar(packLen, &mData[0]);
ret = Prtcl_InnetSafe_AppRmSend(mData,dataOffset);
ret = Prtcl_InnetSafe_AppRmSend(dstName, mData,dataOffset);
if(ret == 0)
{
/*输出异常警告*/
@@ -1845,7 +1892,7 @@ static void PFM_RemoteSwitch_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UINT8
dataOffset += 4u;
packLen = dataOffset - 2u;
CM_ShortToChar(packLen, &mData[0]);
ret = Prtcl_InnetSafe_AppRmSend(mData,dataOffset);
ret = Prtcl_InnetSafe_AppRmSend(g_Maintenance_Ids[1],mData,dataOffset);
if(ret == 0)
{
/*输出异常警告*/
@@ -1867,7 +1914,7 @@ static void PFM_RemoteSwitch_Send(CM_UINT8 type,CM_UINT32 rcv_packTime,CM_UINT8
* @param packLen 帧长度 取值范围：0~0xffff
* @param packType 帧类型 取值范围：0~0xff
*/
static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16 packLen,CM_UINT8 packType)
static void PFM_Data_HardWareReastart(CM_UINT16 srcName,CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16 packLen,CM_UINT8 packType)
{
/*- 变量初始化 */
CM_UINT32 packTimer = 0u;
@@ -1880,6 +1927,7 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
CM_UINT32 packRestartCrc = 0u; /*重启请求命令crc*/
CM_UINT8 boottype = 0u;/**<临时 重启请求命令 0x55:未更新重启 0xaa:升级重启 0xd1~d7:硬重启 */
static CM_UINT8 s_boottype = 0u;/**<静态 重启请求命令 0x55:未更新重启 0xaa:升级重启 ,0xd1~d7:硬重启 */
static CM_UINT16 s_srcid = 0u;
CM_UINT8 recvType = 0u;
ENUM_2x2_STATE_T localState = SFM_2x2_GetLocal2x2State();
/*- 如果帧类型是一次请求确认 */
@@ -1912,7 +1960,9 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- 非法包丢弃 */
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 1u;
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_1));
@@ -1922,6 +1972,7 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- 非法包丢弃 */
s_boottype = 0u;
s_srcid = 0u;
/* s_HardReboottype = 0u; */
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 5u;
@@ -1933,7 +1984,9 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- 非法包丢弃 */
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 6u;
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_2));
@@ -1943,7 +1996,9 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- 非法包丢弃 */
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 7u;
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_3));
@@ -1952,9 +2007,10 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
else
{
s_boottype = boottype;
s_srcid = srcName;
s_packHardAccredit = 0u;
s_reasonHardAuthorization = 0u;
MSCP_LOG_MSG("0xa5 boottype = %d\n",boottype);
MSCP_LOG_MSG("0xa5 boottype = %d, srcid = %04x\n",boottype, s_srcid);
}
/*首次应答*/
recvType = 0x55u;
@@ -1992,7 +2048,9 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- crc计算失败丢弃错误包 */
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 1u;
MSCP_LOG_MSG("error pack 0xa6 packSwitchCrc=%d,calcCrc1=%d,packCrc=%d,calcCrc2=%d\n",packRestartCrc,calcCrc1,packCrc,calcCrc2);
@@ -2003,6 +2061,7 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
{
/*- 正在执行其它命令 */
s_boottype = 0u;
s_srcid = 0u;
/* s_HardReboottype = 0u; */
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 5u;
@@ -2010,11 +2069,20 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
,s_switch2xFlag,s_switchRmFlag,g_iostate);
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_5));
}
else if(s_srcid != srcName)
{
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 6u;
MSCP_LOG_MSG("error pack 0xa6 s_srcid = %04x srcName = %04x\n", s_srcid, srcName);
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_WARNING, 4U, DARK_FAULT_CODE_MERGE(REMOTE_UPDATE, DARK_FAULT_CODE_FUN_ORDER_13, TSCP_DARK_ASSERT_8));
}
/*- 切系命令一次回复到二次请求接收时间是否小于两分钟 */
else if(((g_MSCP_SysCount - s_packFirstRecvTimer)*g_RMUP_Cfg.CYC_TIME) >= 120000u)
{
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 7u;
MSCP_LOG_MSG("error pack 0xa6 g_MSCP_SysCount = %d s_packFirstRecvTimer = %d\n", g_MSCP_SysCount, s_packFirstRecvTimer);
@@ -2023,7 +2091,9 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
else if((boottype <= 0xd0u) || (boottype >= 0xd8u ) || (s_boottype != boottype))
{
s_boottype = 0u;
s_srcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0U;
s_packHardAccredit = 1u;
s_reasonHardAuthorization = 6u;
MSCP_LOG_MSG("error pack 0xa6 s_boottype = %d boottype = %d\n", s_boottype, boottype);
@@ -2032,17 +2102,18 @@ static void PFM_Data_HardWareReastart(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UI
else
{
s_HardReboottype = s_boottype;
s_HardRebootSrcid = s_srcid;
s_packHardAccredit = 0u;
s_reasonHardAuthorization = 0u;
g_iostate = 0x1u;
MSCP_LOG_MSG("0xa6 boottype = %d, s_boottype = %d\n",boottype, s_boottype);
MSCP_LOG_MSG("0xa6 boottype = %d, s_boottype = %d, s_srcid = %04x\n",boottype, s_boottype, s_srcid);
}
/*再次应答*/
recvType = 0x56u;
}
/*- 硬重启命令请求回复 */
PFM_HardWareReastart_Send(recvType,packTimer,s_packHardAccredit,s_reasonHardAuthorization);
PFM_HardWareReastart_Send(recvType,srcName,packTimer,s_packHardAccredit,s_reasonHardAuthorization);
}
/**
@@ -2253,7 +2324,7 @@ static void PFM_Data_RemoteSwitch(CM_UINT8* mData,CM_UINT32 dataOffset,CM_UINT16
* - 0xa7首次切系请求
* - 0xa8二次切系请求
*/
CM_UINT8 PFM_RemoteRun_Data(CM_UINT8 *mData,CM_UINT32 dataLen)
CM_UINT8 PFM_RemoteRun_Data(CM_UINT16 srcName, CM_UINT8 *mData,CM_UINT32 dataLen)
{
/*- 变量初始化 */
CM_UINT32 dataOffset = 0u;
@@ -2273,7 +2344,7 @@ CM_UINT8 PFM_RemoteRun_Data(CM_UINT8 *mData,CM_UINT32 dataLen)
{
if((0xA5u == packType) || (0xA6u == packType))
{
PFM_Data_HardWareReastart(mData,dataOffset,packLen,packType);
PFM_Data_HardWareReastart(srcName,mData,dataOffset,packLen,packType);
}
else if((0xA7u == packType) || (0xA8u == packType))
{
@@ -2308,7 +2379,8 @@ void PFM_HardWareBoot_UpData(void)
g_boardState = g_AppSetboardState;
/*- 更新硬重启模式 */
reboottype = s_HardReboottype;
MSCP_LOG_MSG("reboottype = %d, s_HardReboottype = %d\n",reboottype,s_HardReboottype);
s_rebootSrcid = s_HardRebootSrcid;
MSCP_LOG_MSG("reboottype = %d, s_HardReboottype = %d, s_HardRebootSrcid = %04x\n",reboottype,s_HardReboottype,s_HardRebootSrcid);
/*- 更新切系状态 */
if(0x55 == s_switchRmFlag)
{
@@ -2335,11 +2407,13 @@ void PFM_HardWareBoot_OutPut(void)
/*- 变量初始化 */
CM_INT32 ret = 0;
CM_UINT8 type = 0u;
CM_UINT16 srcID = 0u;
static ENUM_HARDWARE_BOOT_SELFCHECK_T checkselfret = ENUM_RELAY_1ST_OUTPUT;
/*- 重启命令为硬重启命令 */
if((0xd0u < reboottype) && (0xd8u > reboottype))
{
type = reboottype;
srcID = s_rebootSrcid;
/*- @alias 执行硬重启 */
switch(type)
{
@@ -2348,7 +2422,7 @@ void PFM_HardWareBoot_OutPut(void)
if(ENUM_2x2_MASTER == SFM_2x2_GetLocal2x2State())
{
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 1\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Cu,ENUM_TYPE_PUB,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Cu,ENUM_TYPE_PUB,type,srcID);
}
else
{
@@ -2360,22 +2434,22 @@ void PFM_HardWareBoot_OutPut(void)
case 0xd2:
/*- 1010:CCU*/
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 3\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Au,ENUM_TYPE_CCU,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Au,ENUM_TYPE_CCU,type,srcID);
break;
case 0xd3:
/*- 0110:SEB*/
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 4\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x06u,ENUM_TYPE_SEB,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x06u,ENUM_TYPE_SEB,type,srcID);
break;
case 0xd4:
/*- 1001:ESB*/
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 5\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x09u,ENUM_TYPE_ESB,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x09u,ENUM_TYPE_ESB,type,srcID);
break;
case 0xd5:
/*- 0101:EEB*/
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 6\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x05u,ENUM_TYPE_OTHER,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x05u,ENUM_TYPE_OTHER,type,srcID);
break;
case 0xd6:
/*- 0011:OCIO预留，硬件不支持禁止打开*/
@@ -2389,7 +2463,7 @@ void PFM_HardWareBoot_OutPut(void)
if(ENUM_2x2_MASTER == SFM_2x2_GetLocal2x2State())
{
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 9\n");
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Fu,ENUM_TYPE_ALL,type);
checkselfret = PFM_HardWareBoot_CheckSelf(0x0Fu,ENUM_TYPE_ALL,type,srcID);
}
else
{
@@ -2410,7 +2484,9 @@ void PFM_HardWareBoot_OutPut(void)
MSCP_LOG_MSG("PFM_HardWareBoot_OutPut 12\n");
/*- 恢复运营状态*/
reboottype = 0u;
s_rebootSrcid = 0u;
s_HardReboottype = 0u;
s_HardRebootSrcid = 0u;
g_iostate = 0x0u;
}
}
@@ -2433,7 +2509,7 @@ void PFM_HardWareBoot_OutPut(void)
* @param reboottype 重启命令类型 取值范围：0xD1~0xD7
* @return ENUM_HARDWARE_BOOT_SELFCHECK_T 当前检测步骤 取值范围：0~11
*/
ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_HardWareBoot_CheckSelf(CM_UINT8 level,ENUM_BOARD_TYPE_T board_type,CM_UINT8 reboottype)
ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_HardWareBoot_CheckSelf(CM_UINT8 level,ENUM_BOARD_TYPE_T board_type,CM_UINT8 reboottype, CM_UINT16 srcName)
{
/*- 变量初始化 */
static ENUM_HARDWARE_BOOT_SELFCHECK_T s_selfcheck_state = ENUM_RELAY_1ST_OUTPUT;
@@ -2703,8 +2779,8 @@ ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_HardWareBoot_CheckSelf(CM_UINT8 level,ENUM_BO
/*- 反馈执行结果 */
case ENUM_OUTPUT_RESULT:
/*- 发送结果至AID */
MSCP_LOG_MSG("s_relay_default[0] = %d,s_relay_default[1] = %d,s_relay_default[2] = %d,s_relay_default[3] = %d\n",s_relay_default[0],s_relay_default[1],s_relay_default[2],s_relay_default[3]);
PFM_HardWareBoot_CheckSelf_Response(s_boot_result,s_relay_default,reboottype);
MSCP_LOG_MSG("s_relay_default[0] = %d,s_relay_default[1] = %d,s_relay_default[2] = %d,s_relay_default[3] = %d, srcName = %04x\n",s_relay_default[0],s_relay_default[1],s_relay_default[2],s_relay_default[3], srcName);
PFM_HardWareBoot_CheckSelf_Response(s_boot_result,s_relay_default,reboottype, srcName);
/*- 清空所有标志位 */
s_selfcheck_state = ENUM_RELAY_1ST_OUTPUT;
s_OutPutTime = 0u;
@@ -2866,7 +2942,7 @@ CM_UINT8 PFM_HardWareBoot_CheckSelf_ComState(ENUM_BOARD_TYPE_T type, CM_UINT8 s_
* @param reboottype 重启命令类型 取值范围：0xd1~0xd7
* @return 无
*/
void PFM_HardWareBoot_CheckSelf_Response(CM_UINT8 boot_result,CM_UINT8 *defaultbuf,CM_UINT8 reboottype)
void PFM_HardWareBoot_CheckSelf_Response(CM_UINT8 boot_result,CM_UINT8 *defaultbuf,CM_UINT8 reboottype,CM_UINT16 dstName)
{
/*- 变量初始化 */
CM_UINT8 mData[1000] = { 0u };
@@ -2911,7 +2987,7 @@ void PFM_HardWareBoot_CheckSelf_Response(CM_UINT8 boot_result,CM_UINT8 *defaultb
dataOffset += 4u;
packLen = dataOffset - 2u;
CM_ShortToChar(packLen, &mData[0]);
ret = Prtcl_InnetSafe_AppRmSend(mData,dataOffset);
ret = Prtcl_InnetSafe_AppRmSend(dstName,mData,dataOffset);
if(ret == 0)
{
/*- 输出异常警告 */
TSCP/src/MSCP/PFM/PFM_RemoteUpdate.h
+13 -5
View File
@@ -12,7 +12,9 @@ extern "C"
#define FAULT_REBOOT_CUT_MAX (3u) /*故障重启次数限制*/
extern CM_UINT16 g_Maintenance_Id;/* 维护终端内网id */
#define MAINTAIN_ID_MAX_NUM (2u) /*同时通信的维护终端的最大个数*/
extern CM_UINT16 g_Maintenance_Ids[256];/* 维护终端内网id */
extern CM_UINT8 g_RemoteUpdate_State;/* 远程部署过程状态 */
extern CM_UINT8 s_switch2xFlag;
@@ -115,12 +117,16 @@ void PFM_MaintenanceMode(void);
* @brief 设置维护终端内网id
* @param dstName 维护终端内网id
*/
void PFM_SetMaintenanceId(IN CM_UINT16 dstName);
void PFM_SetMaintenanceId(IN CM_UINT16* dstNames);
/**
* @brief 查询维护ID是否存在
*/
ENUM_CM_RETURN PFM_MaintenanceID_Search(IN CM_UINT16 id);
/**
* @brief 远程硬件重启\切系命令接收处理
*/
CM_UINT8 PFM_RemoteRun_Data(CM_UINT8 *mData,CM_UINT32 dataLen);
CM_UINT8 PFM_RemoteRun_Data(CM_UINT16 srcName, CM_UINT8 *mData,CM_UINT32 dataLen);
/*硬件重启IO更新*/
void PFM_HardWareBoot_UpData(void);
/*执行硬件重启IO输出*/
@@ -133,9 +139,10 @@ CM_UINT8 PFM_GetBoardRebootState(void);
* @param level 待输出IO 取值范围：0x00~0x0F
* @param board_type 当前命令目标重启板卡类型 取值范围：ENUM_BOARD_TYPE_T
* @param reboottype 重启命令类型 取值范围：0xD1~0xD7
* @param srcName 重启命令的源ID
* @return ENUM_HARDWARE_BOOT_SELFCHECK_T 当前检测步骤
*/
ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_HardWareBoot_CheckSelf(CM_UINT8 level,ENUM_BOARD_TYPE_T board_type,CM_UINT8 reboottype);
ENUM_HARDWARE_BOOT_SELFCHECK_T PFM_HardWareBoot_CheckSelf(CM_UINT8 level,ENUM_BOARD_TYPE_T board_type,CM_UINT8 reboottype, CM_UINT16 srcName);
/**
* @brief 识别AB系通信需要计算的板卡通信状态(对系)
* @param type 当前判断板卡通信状态类型 取值范围：ENUM_BOARD_TYPE_T
@@ -149,9 +156,10 @@ CM_UINT8 PFM_HardWareBoot_CheckSelf_ComState(ENUM_BOARD_TYPE_T type, CM_UINT8 s_
* @param boot_result 硬重启结果 取值范围：0x55成功，0xAA失败
* @param *defaultbuf 继电器检测结果数组 取值范围：0x55成功，0xAA故障
* @param reboottype 重启命令类型 取值范围：0xd1~0xd7
* @param dstName 回复的目的ID
* @return 无
*/
void PFM_HardWareBoot_CheckSelf_Response(CM_UINT8 boot_result,CM_UINT8 *defaultbuf,CM_UINT8 reboottype);
void PFM_HardWareBoot_CheckSelf_Response(CM_UINT8 boot_result,CM_UINT8 *defaultbuf,CM_UINT8 reboottype,CM_UINT16 dstName);
/**
* @brief 识别AB系通信需要计算的板卡通信状态
TSCP/src/MSCP/SFM/SFM_2oo2.c
+2 -2
View File
@@ -566,11 +566,11 @@ static CM_INT32 s_2oo2_ARQ_Recv(OUT CM_UINT8 *RxData, IN CM_UINT32 RxSize, OUT E
}
}
/*本机与邻机接收成功或重传次数超过1分钟（6000次）退出重传 */
if(((CM_TRUE == MineRcvSuccessFlag) && (CM_TRUE == PeerRcvSuccessFlag)) || (ARQ_Cut >= 6000))
if(((CM_TRUE == MineRcvSuccessFlag) && (CM_TRUE == PeerRcvSuccessFlag)) || (ARQ_Cut >= SFM_2oo2_ARQ_MAX_CNT))
{
/*- 结束接收 */
/*- 结束接收 重传超过6000次日志记录 */
if(ARQ_Cut >= 6000)
if(ARQ_Cut >= SFM_2oo2_ARQ_MAX_CNT)
{
MSCP_LOG_MSG("2oo2 failed break ARQ_Cut = %d, MineRcvSuccessFlag = %d, PeerRcvSuccessFlag = %d\n", ARQ_Cut, MineRcvSuccessFlag, PeerRcvSuccessFlag);
CM_ASSERT(0,SFM_2oo2_MODE, DARK_FAULT_CODE_FUN_ORDER_6, TSCP_DARK_ASSERT_2);
TSCP/src/MSCP/SFM/SFM_2x2.c
+91
View File
@@ -172,6 +172,16 @@ static void SFM_2x2_Input2oo2Exchange(STRU_2X2_CTRL_T *peerCtrl);
static void SFM_2x2_Eth422StateDark(void);
/* 返回4线中通信正常的数量*/
static CM_UINT8 s_2x2_CommNormalNum(void);
/**
* @brief 备系设置切系原因
* @details 这个函数会设置所有可能的原因（按钮/AID/自动）
* */
static void s_2x2_SlaveGetSwitchReason(void);
/**
* @brief 备系发送切系原因
* @details 实际切系原因只会有一种，发送时按照优先级发送（宕机自动切系>按钮>AID>其他自动切系）
* */
static void s_2x2_SlaveSendSwitchReason(void);
/* 输入周期号同步函数 */
static void SFM_2x2_InputSysCycSyn(STRU_2X2_CTRL_T *peerCtrl){
@@ -1355,6 +1365,8 @@ static CM_THREAD_FUNC_T SFM_2x2_StateChange_Thread(void)
/*二取本机热备状态、按钮状态、通信状态等、确保双CPU数据一致*/
s_State_2xAfter_2oo2Sync(&ctrl_2oo2_2xstate,&partner_state);
curTick[3] = CM_GetTick();
/* 尝试获取切系相关状态*/
s_2x2_SlaveGetSwitchReason();
/*带着双cpu一致的双系数据做状态机切换*/
if(s_2x2_state_Ctrl.MicroCyc < (s_2x2_thread_Ctrl.number_Cyc - 1u))
{
@@ -1536,12 +1548,24 @@ void SFM_2x2_ChangeState(void)
s_2x2_Ctrl.LastFollowCyc = SFM_2x2_GetSysCount() - 1u;
s_2x2_Ctrl.LastCheckOKCount = SFM_2x2_GetSysCount();
s_2x2_Ctrl.OutPutCheckFailFlag = 0u;
s_2x2_Ctrl.AppFollowRcvFlag = CM_TRUE;
s_2x2_Ctrl.AppFollowCmpFlag = 0u;
}
else
{
/*无处理*/
}
if(1u == s_2x2_Ctrl.AppFollowCmpFlag && CM_TRUE == s_2x2_Ctrl.AppFollowRcvFlag && ENUM_2x2_MASTER == s_2x2_state_Ctrl.LocalState)
{
if(ENUM_2x2_SLAVE == s_2x2_state_Ctrl.PartnerState)
{
s_2x2_state_Ctrl.LocalState = ENUM_2x2_OFFLINE;
}
else
{
CM_RE_ASSERT(0, SFM_2x2_MODE, DARK_FAULT_CODE_FUN_ORDER_24, TSCP_DARK_ASSERT_7);
}
}
MSCP_LOG_MSG("timecurr 16.0.0 = %lld us\n", NOW_USED_TIME);
/*- 记录上周期状态用于回滚*/
s_2x2_state_Ctrl.LastLocalState = s_2x2_Ctrl.LocalState;
@@ -1630,6 +1654,8 @@ void SFM_2x2_ChangeState(void)
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_AREA, 1U, &s_2x2_Ctrl.LocalAreaState);
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_AREA_SWITCH, 1U, &s_2x2_Ctrl.AreaSwitchMode);
}
/* 如果发生了备系升主，暗文发送原因*/
s_2x2_SlaveSendSwitchReason();
SFM_2x2_LOG_Transition();
SFM_AREA_LOG_Transition();
@@ -1672,6 +1698,7 @@ void SFM_2x2_Init(IN const CM_UINT8 *VitalBuf, IN CM_UINT16 VitalLen, INOUT CM_U
s_2x2_Ctrl.LocalState = ENUM_2x2_OFFLINE;
s_2x2_Ctrl.PartnerState = ENUM_2x2_SHUTDOWN;
s_2x2_Ctrl.AppFollowCmpFlag = 1u;
s_2x2_Ctrl.AppFollowRcvFlag = CM_FALSE;
/*- 更新上一周期的主备状态为这周期的主备状态(给应用用) */
s_2x2_Ctrl.LastLocalState = s_2x2_Ctrl.LocalState;
@@ -1690,6 +1717,7 @@ void SFM_2x2_Init(IN const CM_UINT8 *VitalBuf, IN CM_UINT16 VitalLen, INOUT CM_U
s_2x2_state_Ctrl.LocalAIDSwitchState = ENUM_2x2_AIDSWITCH_DISABLE;
s_2x2_state_Ctrl.PartnerAIDSwitchState = ENUM_2x2_AIDSWITCH_DISABLE;
s_2x2_state_Ctrl.switchReason = ENUM_2x2_SWITCH_REASON_NULL;
s_2x2_state_Ctrl.LocalID =s_2x2_Ctrl.LocalID;
s_2x2_state_Ctrl.PartnerID = s_2x2_Ctrl.PartnerID;
@@ -3045,10 +3073,12 @@ void SFM_2x2_EndProc(void)
curTickTest[0] = CM_GetTick();
if (s_2x2_Ctrl.RxAppFollowSysCyc >= sysCyc)
{
s_2x2_Ctrl.AppFollowRcvFlag = CM_TRUE;
s_2x2_AppFollow_SyncCheck();
}
else
{
s_2x2_Ctrl.AppFollowRcvFlag = CM_FALSE;
/*没有收到数据 将离线*/
s_2x2_Ctrl.AppFollowCmpFlag = 1u;
}
@@ -3063,12 +3093,14 @@ void SFM_2x2_EndProc(void)
if (s_2x2_Ctrl.RxAppFollowSysCyc >= sysCyc)
{
/*- 调用应用API覆盖应用关键数据 */
s_2x2_Ctrl.AppFollowRcvFlag = CM_TRUE;
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.AppFollowCmpFlag = 0u;
}
else
{
s_2x2_Ctrl.AppFollowRcvFlag = CM_FALSE;
s_2x2_Ctrl.AppFollowCmpFlag = 1u;
}
curTickTest[1] = CM_GetTick();
@@ -4417,4 +4449,63 @@ static void s_2x2_BaseFollow_Sync(void)
offset += 1u;
s_2x2_Ctrl.AreaTimeOffset = (CM_INT64)CM_64FromChar(&g_RxBaseFollow[offset]);
offset += 8u;
}
/**
* @brief 备系设置切系原因
* @details 这个函数会设置所有可能的原因（按钮/AID/自动）
* */
static void s_2x2_SlaveGetSwitchReason(void)
{
if(ENUM_2x2_SLAVE == s_2x2_state_Ctrl.LocalState)
{
if(1 == s_2x2_state_Ctrl.ctrSwitchFlag)
{
s_2x2_state_Ctrl.switchReason |= ENUM_2x2_SWITCH_REASON_CTR;
}
if(1u == s_2x2_state_Ctrl.aidSwitchFlag)
{
s_2x2_state_Ctrl.switchReason |= ENUM_2x2_SWITCH_REASON_AID;
}
}
}
/**
* @brief 备系发送切系原因
* @details 实际切系原因只会有一种，发送时按照优先级发送（宕机自动切系>按钮>AID>其他自动切系）
* */
static void s_2x2_SlaveSendSwitchReason(void)
{
CM_UINT8 reason = 0x00u;
if(ENUM_2x2_MASTER == s_2x2_Ctrl.LocalState && ENUM_2x2_SLAVE == s_2x2_Ctrl.LastLocalState)
{
/* 执行了切系*/
if(ENUM_2x2_SHUTDOWN == s_2x2_Ctrl.PartnerState)
{
/* 另一系宕机，一定是自动切系（因为备系升主逻辑中宕机升主优先级最高）*/
reason = 0x00u;
}
else if(ENUM_2x2_SWITCH_REASON_CTR == (ENUM_2x2_SWITCH_REASON_CTR & s_2x2_state_Ctrl.switchReason))
{
/* 人工按钮切系*/
reason = 0x55u;
}
else if(ENUM_2x2_SWITCH_REASON_AID == (ENUM_2x2_SWITCH_REASON_AID & s_2x2_state_Ctrl.switchReason))
{
/* 人工AID切系*/
reason = 0xAAu;
}
else if(ENUM_2x2_SWITCH_REASON_AUTO == (ENUM_2x2_SWITCH_REASON_AUTO & s_2x2_state_Ctrl.switchReason))
{
/* 自动切系*/
reason = 0x00u;
}
else
{
/* 其他情况，默认自动切系*/
reason = 0x00u;
}
(void)CFM_DarkLog_Storage(DARK_LOG_HEX, TSCP_DARK_2X2_SWITCH_REASON, 1U, &reason);
}
s_2x2_state_Ctrl.switchReason = ENUM_2x2_SWITCH_REASON_NULL;
}
TSCP/src/MSCP/SFM/SFM_2x2.h
+13
View File
@@ -45,6 +45,15 @@ extern CM_UINT32 g_MSCP_SysCount;
#define MSCP_2X2_THREAD_TIME (40U) /*2x线程运行时间*/
#define MSCP_2X2_STATE_OVER_TIME (MSCP_2X2_THREAD_TIME + 25U) /*2x线程判断数据超时时间*/
#define MSCP_2X2_STATE_RCV_WITETIME (MSCP_2X2_THREAD_TIME - 20U) /*2x线程等待对系数据时间*/
/* 切系原因*/
typedef enum
{
ENUM_2x2_SWITCH_REASON_NULL = 0x00u, /* 没有切系*/
ENUM_2x2_SWITCH_REASON_AUTO = 0x01u, /* 自动切系*/
ENUM_2x2_SWITCH_REASON_CTR = 0x02u, /* 按钮切系*/
ENUM_2x2_SWITCH_REASON_AID = 0x04u /* AID切系*/
}ENUM_2x2_SWITCH_REASON_T;
/** 2x2消息类型 */
typedef enum
{
@@ -190,6 +199,7 @@ extern CM_UINT32 g_MSCP_SysCount;
/*输出比较信息*/
CM_UINT32 LastCheckOKCount; /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较 (这个标志用来判断如果未收到主系的数据,则停止更新,后将为离线)*/
CM_UINT32 OutPutCheckFailFlag; /**< 上次输出比较成功(跟随成功)的本地时间，2oo2比较 (这个标志用来判断收到输出数据后是否比较成功, 比较失败则降级)*/
CM_BOOL AppFollowRcvFlag; /* 上次应用跟随数据的接收结果，只判断是否是否成功接收*/
CM_UINT32 AppFollowCmpFlag; /**< 上次应用跟随数据比较结果，只有备系使用 (这个标志用来判断备系和主系应用跟随数据是否比较成功, 比较失败则降级)*/
CM_UINT32 RxCheckSysCyc; /**< 收到的输出校验帧的周期号，2oo2交换 */
CM_INT32 RxCheckLen; /**< 收到的输出校验帧长度，2oo2交换 */
@@ -241,6 +251,7 @@ extern CM_UINT32 g_MSCP_SysCount;
CM_UINT32 LastRxInputSysCyc; /**< 收到的对系输入数据的周期号，2oo2交换 */
/*跟随数据*/
CM_UINT32 LastFollowCyc; /**< 上次进行平台跟随的时间，2oo2比较，*/
CM_BOOL AppFollowRcvFlag; /* 上次应用跟随数据的接收结果，只判断是否是否成功接收*/
CM_UINT32 AppFollowCmpFlag; /**< 上次应用跟随数据比较结果，只有备系使用 (这个标志用来判断备系和主系应用跟随数据是否比较成功, 比较失败则降级)*/
/*输出比较信息*/
@@ -261,6 +272,8 @@ extern CM_UINT32 g_MSCP_SysCount;
ENUM_2x2_AID_SWITCH_STATE PartPeerAIDSwitchState; /**< 对系的邻机的主动切系按钮状态 */
CM_UINT8 aidSwitchFlag; /**< aid切系控制标志 */
ENUM_2x2_SWITCH_REASON_T switchReason; /*记录切系原因*/
/*脉冲*/
ENUM_PULSE_TYPE_T pulse[5][2]; /* [][0]A系, [][1]B系, [0]四个CPU一致的脉冲，[1]1-1, [2]1-2, [3]2-1, [4]2-2(TODO 下标使用宏定义)*/
ENUM_PULSE_TYPE_T pulseFeedBack; /*本系回读*/
TSCP/src/MSCP/SFM/SFM_Prtcl.c
+74 -25
View File
@@ -189,7 +189,7 @@ void SFM_PrtclInInit(CM_UINT8* p_SfpInnetPara)
}
/*- 入参是否为空 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id) && (NULL != p_SfpInnetPara))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]) && (NULL != p_SfpInnetPara))
{
/*- 远程部署内网安全协议初始化*/
CM_NM_ASSERT(0u != InnetID, PRTCL_MODE, DARK_FAULT_CODE_FUN_ORDER_17, TSCP_DARK_ASSERT_1);
@@ -658,7 +658,7 @@ void SFM_UnPrtclProc(void)
}
PFM_CFC_Check(46);
/*- @alias 远程部署内网安全通信协议解析 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
(void)QueueClear(&s_InnetPrtcl_RM.DataToApp);
s_InnetPrtcl_RM.RadamSN = SFM_2x2_GetSysCount();
@@ -962,7 +962,7 @@ CM_UINT32 Prtcl_InnetSafe_RmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLifeTim
CM_UINT32 rt_len = 0u; /* 函数返回长度值 */
CM_UINT8 rt = 0u; /* 函数返回值 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 锁定接收队列 */
(void)CM_Mutex_Lock(s_Innet_RmRecv_M);
@@ -994,7 +994,7 @@ CM_UINT32 Prtcl_InnetSafe_RmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLifeTim
(void)CM_QueueRead(rt_len, rxBuf, &s_Innet_RmRecvQ);
/*- 解析通信协议，如果是重启或切系命令，执行重启或切系逻辑*/
rt = PFM_RemoteRun_Data(rxBuf,rt_len);
rt = PFM_RemoteRun_Data(*pSrcName,rxBuf,rt_len);
/*- 如果是重启命令*/
if((0xA5 <= rt) && (0xA8 >= rt))
{
@@ -1053,7 +1053,7 @@ CM_UINT32 Prtcl_InnetSafe_PlatRmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLif
CM_UINT16 msgLen = 0u; /* 报文长度 */
CM_UINT32 qStatus = 0u; /* 队列状态 */
CM_UINT32 rt_len = 0u; /* 函数返回长度值 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 锁定接收队列 */
(void)CM_Mutex_Lock(s_Innet_RmRecv_M);
@@ -1114,7 +1114,7 @@ CM_UINT32 Prtcl_InnetSafe_PlatRmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLif
* - 0 失败(输入非法)
* @details
*/
CM_UINT8 Prtcl_InnetSafe_AppRmSend(IN const CM_UINT8* txBuf, IN CM_UINT32 txLen)
CM_UINT8 Prtcl_InnetSafe_AppRmSend(IN CM_UINT16 dstName, IN const CM_UINT8* txBuf, IN CM_UINT32 txLen)
{
/*- 变量初始化 */
CM_UINT8 buf[2u] = { 0u }; /* 临时变量 */
@@ -1122,18 +1122,21 @@ CM_UINT8 Prtcl_InnetSafe_AppRmSend(IN const CM_UINT8* txBuf, IN CM_UINT32 txLen)
ENUM_CM_RETURN temprt = ENUM_CM_TRUE; /* 临时返回值 */
CM_ASSERT_MAINTAIN(txBuf != NULL);
/*- 输入长度检查 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*
2字节 长度(不含自身)
2字节 目的ID
n字节 数据
*/
/*- 锁定发送队列 */
(void)CM_Mutex_Lock(s_Innet_AppRmSend_M);
/*- 填写协议输出帧头 */
CM_ShortToChar(txLen, buf);
CM_ShortToChar(txLen + 2, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_AppRmSendQ);/*长度*/
CM_ShortToCharLE(dstName, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_AppRmSendQ);/*目的ID*/
/*- 填写应用输出报文 */
temprt &= CM_QueueWrite(txLen, txBuf, &s_Innet_AppRmSendQ);
if(ENUM_CM_TRUE == temprt)
@@ -1174,26 +1177,54 @@ CM_UINT8 Prtcl_InnetSafe_RmSend(IN CM_UINT16 dstName, IN const CM_UINT8* txBuf,
{
/*- 变量初始化 */
CM_UINT16 len = 0u; /* 长度 */
CM_UINT16 applen = 0u; /* 长度 */
CM_UINT16 applen = 0u, tmplen = 0u; /* 长度 */
CM_BOOL flag_split = CM_FALSE; /*是否将平台帧和应用帧分开发送*/
CM_UINT8 buf[2u] = { 0u }; /* 临时变量 */
CM_UINT8 buf4[4u] = {0u}; /* 临时变量*/
CM_UINT8 Buftmp[128] = { 0u }; /* 临时变量 */
CM_UINT8 rt = 0u; /* 函数返回值 */
ENUM_CM_RETURN temprt = ENUM_CM_TRUE; /* 临时返回值 */
CM_UINT16 appDstID = 0xffffu;
/*- 输入长度检查 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 锁定发送队列 */
(void)CM_Mutex_Lock(s_Innet_AppRmSend_M);
/*- 读取应用帧头 */
/*
2字节 长度(不含自身)
2字节 目的ID
n字节 数据
*/
(void)CM_QueueRead(2u, buf, &s_Innet_AppRmSendQ);/*长度*/
(void)CM_QueueScan(2u, buf, &s_Innet_AppRmSendQ);/*长度*/
applen = CM_ShortFromChar(buf);
(void)CM_QueueRead(applen, Buftmp, &s_Innet_AppRmSendQ);/*长度*/
if(applen >= 2u)
{
(void)CM_QueueScan(4u, buf4, &s_Innet_AppRmSendQ);/*长度*/
appDstID = CM_ShortFromCharLE(&buf4[2]);
temprt = PFM_MaintenanceID_Search(appDstID);
applen -= 2u;
}
if(appDstID == dstName || ENUM_CM_FALSE == temprt)
{
(void)CM_QueueRead(2u, buf, &s_Innet_AppRmSendQ);
(void)CM_QueueRead(2u, buf, &s_Innet_AppRmSendQ);
(void)CM_QueueRead(applen, Buftmp, &s_Innet_AppRmSendQ);/*长度*/
if(appDstID == g_Maintenance_Ids[1])
{
tmplen = applen;
flag_split = CM_FALSE;
}
else
{
flag_split = CM_TRUE;
tmplen = 0u;
}
}
else
{
}
/*- 解锁发送队列 */
(void)CM_Mutex_Unlock(s_Innet_AppRmSend_M);
@@ -1206,7 +1237,7 @@ CM_UINT8 Prtcl_InnetSafe_RmSend(IN CM_UINT16 dstName, IN const CM_UINT8* txBuf,
(void)CM_Mutex_Lock(s_Innet_RmSend_M);
/*- 填写协议输出帧头 */
len = (CM_UINT16)(txLen + 4u)+applen;
len = (CM_UINT16)(txLen + 4u)+tmplen;
CM_ShortToChar(len, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_RmSendQ);/*长度*/
CM_ShortToCharLE(0u, buf);
@@ -1217,7 +1248,22 @@ CM_UINT8 Prtcl_InnetSafe_RmSend(IN CM_UINT16 dstName, IN const CM_UINT8* txBuf,
temprt &= CM_QueueWrite(txLen, txBuf, &s_Innet_RmSendQ);
if(ENUM_CM_TRUE == temprt)
{
temprt &= CM_QueueWrite(applen, Buftmp, &s_Innet_RmSendQ);
if(CM_TRUE == flag_split)
{
len = applen + 4u;
CM_ShortToChar(len, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_RmSendQ);/*长度*/
CM_ShortToCharLE(0u, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_RmSendQ);/*2字节预留*/
CM_ShortToCharLE(dstName, buf);
temprt &= CM_QueueWrite(2u, buf, &s_Innet_RmSendQ);/*目的ID*/
temprt &= CM_QueueWrite(applen, Buftmp, &s_Innet_RmSendQ);
}
else
{
temprt &= CM_QueueWrite(tmplen, Buftmp, &s_Innet_RmSendQ);
}
if(ENUM_CM_TRUE == temprt)
{
rt = 1u;/*成功*/
@@ -1312,7 +1358,7 @@ void SFM_EnPrtclProc(void)
}
/*- 远程部署内网安全协议封装 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
CM_LongToChar(0u, s_InnetPrtcl_RM.PrtclSndBuff);
CM_LongToChar(0u, s_InnetPrtcl_RM.RecordArray);
@@ -1382,7 +1428,7 @@ CM_UINT32 SFM_ReadInnetRmCodedOutput(OUT CM_UINT8 Buf[], IN CM_UINT32 BufSize)
*/
/*- 获取输出报文总长度 */
CM_UINT32 len = 0u;
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
len = CM_LongFromChar(s_InnetPrtcl_RM.PrtclSndBuff);
CM_RE_ASSERT(BufSize >= 4u,PRTCL_MODE, DARK_FAULT_CODE_FUN_ORDER_21, TSCP_DARK_ASSERT_1);
@@ -1538,7 +1584,7 @@ void SFM_TxInnetSafeRm(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
STRU_PFM_INNET_CFG_T* pCom = NULL;/* 通信配置 */
ENUM_CM_RETURN ret = ENUM_CM_FALSE;
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
allLen = CM_LongFromChar(Buf); /*外网输出帧报文总长度*/
CM_RE_ASSERT((allLen + 4u) == Len,PRTCL_MODE,DARK_FAULT_CODE_FUN_ORDER_20, TSCP_DARK_ASSERT_1);
@@ -1573,7 +1619,8 @@ void SFM_TxInnetSafeRm(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
/*- 是否获取成功 */
if (NULL != pCom)
{
if (g_Maintenance_Id == dstID)
ret = PFM_MaintenanceID_Search(dstID);
if (ret == ENUM_CM_TRUE)
{
/*- 远程部署维护终端设备 */
/*- 本机是否为CPU1 */
@@ -1624,6 +1671,7 @@ void SFM_TxInnetSafeRemoteUpdate(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
CM_UINT16 msgLen = 0u; /* 外网输出帧长度 */
CM_UINT16 dstID = 0u; /* 目的设备ID */
STRU_PFM_INNET_CFG_T* pCom = NULL;/* 通信配置 */
ENUM_CM_RETURN ret = ENUM_CM_FALSE;
if ((allLen + 4u) == Len)
{
@@ -1658,7 +1706,8 @@ void SFM_TxInnetSafeRemoteUpdate(IN CM_UINT8 Buf[], IN CM_UINT32 Len)
/*- 是否获取成功 */
if (NULL != pCom)
{
if (g_Maintenance_Id == dstID)
ret = PFM_MaintenanceID_Search(dstID);
if (ret == ENUM_CM_TRUE)
{
/*- 远程部署维护终端设备 */
/*- 本机是否为CPU1 */
@@ -1989,7 +2038,7 @@ void SFM_PrtclBufSwitch(void)
}
/*- 是否开启远程部署内网安全通信 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 读取远程部署内网发送缓冲 */
len = CM_QueueStatus(&s_Innet_RmSendQ);
@@ -2173,7 +2222,7 @@ void SFM_UnPrtclProc_Crash(void)
{
CM_UINT8 ret = 0;
/*- @alias 内网安全通信协议解析 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
g_PFM_Check = PFM_CFC_PROC_NUM + 6;
CM_UINT32 QueuelenA = QueueStatus(&s_InnetPrtcl_RM.OutnetQueueA);
@@ -2215,7 +2264,7 @@ void SFM_EnPrtclProc_Crash(void)
SFM_AppToPrtclBuf_InnetSafeCrash();
/*- 内网安全协议封装 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
MSCP_LOG_MSG("SFM_EnPrtclProc_Crash Queuelen1 = %d\n",QueueStatus(&s_InnetPrtcl_RM.OutputDataQueue));
CM_LongToChar(0u, s_InnetPrtcl_RM.PrtclSndBuff);
@@ -2254,7 +2303,7 @@ void SFM_PrtclBufToApp_InnetSafeCrash(void)
ENUM_CM_RETURN ret = ENUM_CM_FALSE;
CM_UINT8 rslt = 0u;
/*- 是否开启内网安全通信 */
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_RMUP_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 清空应用内网接收缓冲区 */
(void)CM_QueueClear(&s_Innet_RmRecvQ);
@@ -2292,7 +2341,7 @@ void SFM_AppToPrtclBuf_InnetSafeCrash(void)
CM_UINT8 rslt = 0u;
CM_UINT32 Queuelen = 0u;
/*- 是否开启内网安全通信 */
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0x00u != g_Maintenance_Id))
if ((0x55u == g_PFM_Cfg.M_RemoteUpdate_Enable) &&(0u < g_Maintenance_Ids[0]))
{
/*- 读取应用内网发送缓冲 */
len = CM_QueueStatus(&s_Innet_RmSendQ);
TSCP/src/MSCP/SFM/SFM_Prtcl.h
+1 -1
View File
@@ -171,7 +171,7 @@ extern "C"
/* 发送内网远程部署安全通信数据 */
void SFM_TxInnetSafeRemoteUpdate(IN CM_UINT8 Buf[], IN CM_UINT32 Len);
CM_UINT8 Prtcl_InnetSafe_AppRmSend(IN const CM_UINT8* txBuf, IN CM_UINT32 txLen);
CM_UINT8 Prtcl_InnetSafe_AppRmSend(IN CM_UINT16 dstName, IN const CM_UINT8* txBuf, IN CM_UINT32 txLen);
CM_UINT32 Prtcl_InnetSafe_RmRecv(OUT CM_UINT16* pSrcName, OUT CM_UINT8* pLifeTime, OUT CM_UINT8* rxBuf, IN CM_UINT32 rxSize);