diff --git a/product/src/fes/fes/DebugMbCommunicator.cpp b/product/src/fes/fes/DebugMbCommunicator.cpp new file mode 100644 index 00000000..faf0cf9a --- /dev/null +++ b/product/src/fes/fes/DebugMbCommunicator.cpp @@ -0,0 +1,117 @@ +#include "DebugMbCommunicator.h" +#include "czmq.h" +#include "common/Common.h" +#include "pub_logger_api/logger.h" +#include "pub_utility_api/CharUtil.h" + +#define ZMQ_FES_CLIENT_IDENTITY "fes" + +using namespace std; +using namespace iot_public; + +class CDebugMbCommunicatorInfo +{ +public: + CDebugMbCommunicatorInfo() { + m_pServer = NULL; + m_pPoller = NULL; + } + + zsock_t *m_pServer; + zpoller_t *m_pPoller; +}; + + +CDebugMbCommunicator::CDebugMbCommunicator() +{ + m_pCommInfo = new CDebugMbCommunicatorInfo(); +} + +CDebugMbCommunicator::~CDebugMbCommunicator() +{ + if(m_pCommInfo != NULL) + { + closeServer(); + delete m_pCommInfo; + m_pCommInfo = NULL; + } +} + +bool CDebugMbCommunicator::init(const int &nPort) +{ + if(iotSuccess != initServer(nPort)) + { + return false; + } + + return true; +} + +bool CDebugMbCommunicator::recvMsg(std::string &strMsg, const int &nTimeoutMs) +{ + zsock_t *pReader = (zsock_t *)zpoller_wait(m_pCommInfo->m_pPoller,nTimeoutMs); + if(pReader == NULL) + { + return false; + } + + zmsg_t *msg = zmsg_recv (m_pCommInfo->m_pServer); + zframe_t *last = zmsg_last(msg); + strMsg.append((char*)zframe_data(last),zframe_size(last)); + zmsg_destroy(&msg); + + return true; +} + +bool CDebugMbCommunicator::sendMsg(const string &strMsg) +{ + zmsg_t *sendMsg = zmsg_new (); + zmsg_addstr(sendMsg,ZMQ_FES_CLIENT_IDENTITY); + zmsg_addmem(sendMsg,(void*)strMsg.data(),strMsg.size()); + int nRet = zmsg_send(&sendMsg,m_pCommInfo->m_pServer); + zmsg_destroy(&sendMsg); + + return (nRet >=0); +} + +int CDebugMbCommunicator::initServer(const int &nPort) +{ + m_pCommInfo->m_pServer = zsock_new(ZMQ_ROUTER); + if(m_pCommInfo->m_pServer == NULL) + { + LOGERROR("CFesSimServerThread: 创建ROUTER失败"); + return iotFailed; + } + + string strEndpoints = "tcp://*:" + IntToString(nPort); + int nRet = zsock_bind(m_pCommInfo->m_pServer,strEndpoints.c_str()); + if(nRet < 0) + { + LOGERROR("CFesSimServerThread: bind failed. endpoints=%s",strEndpoints.c_str()); + closeServer(); + return iotFailed; + } + + m_pCommInfo->m_pPoller = zpoller_new (m_pCommInfo->m_pServer, NULL); + zpoller_set_nonstop (m_pCommInfo->m_pPoller, true); + + LOGINFO("CFesSimServerThread: 绑定成功. endpoints=%s",strEndpoints.c_str()); + return iotSuccess; +} + +int CDebugMbCommunicator::closeServer() +{ + if(m_pCommInfo->m_pPoller != NULL) + { + zpoller_destroy(&m_pCommInfo->m_pPoller); + m_pCommInfo->m_pPoller = NULL; + } + + if(m_pCommInfo->m_pServer != NULL) + { + zsock_destroy(&m_pCommInfo->m_pServer); + m_pCommInfo->m_pServer = NULL; + } + + return iotSuccess; +} diff --git a/product/src/fes/fes/DebugMbCommunicator.h b/product/src/fes/fes/DebugMbCommunicator.h new file mode 100644 index 00000000..03d741a5 --- /dev/null +++ b/product/src/fes/fes/DebugMbCommunicator.h @@ -0,0 +1,26 @@ +#ifndef DEBUGMBCOMMUNICATOR_H +#define DEBUGMBCOMMUNICATOR_H + +#include + +class CDebugMbCommunicatorInfo; + +class CDebugMbCommunicator +{ +public: + CDebugMbCommunicator(); + virtual ~CDebugMbCommunicator(); + + bool init(const int &nPort); + bool recvMsg(std::string &strMsg,const int &nTimeoutMs); + bool sendMsg(const std::string &strMsg); + int closeServer(); + +private: + int initServer(const int &nPort); + +private: + CDebugMbCommunicatorInfo *m_pCommInfo; +}; + +#endif // DEBUGMBCOMMUNICATOR_H diff --git a/product/src/fes/fes/DebugThread.cpp b/product/src/fes/fes/DebugThread.cpp new file mode 100644 index 00000000..61f69d1e --- /dev/null +++ b/product/src/fes/fes/DebugThread.cpp @@ -0,0 +1,3595 @@ +#include "DebugThread.h" +#include "common/Common.h" +#include "pub_logger_api/logger.h" + +using namespace std; +using namespace iot_public; +using namespace iot_idl; + +const int CN_TIMEOUT_WaitMsg = 500; //消息等待超时时间 +const int CN_Heartbeat_Timeout = 60 * MSEC_PER_SEC; //心跳超时时间，用来判断调试工具断开连接清理资源 + +CDebugThread::CDebugThread(CFesBase *pFesBase) : + iot_public::CTimerThreadBase("CDebugThread",0,15*60*1000), + m_pFesBase(pFesBase), + m_lLastSimScanTime(0L), + m_bAiSimRunning(false), + m_bDiSimRunning(false), + m_bMiSimRunning(false), + m_bAccSimRunning(false), + m_lAiLastSimTime(0L), + m_lDiLastSimTime(0L), + m_lMiLastSimTime(0L), + m_lAccLastSimTime(0L), + m_fLastAiSimValue(0.0f), + m_nLastDiSimValue(0), + m_nLastMiSimValue(0), + m_dLastAccSimValue(0.0), + m_fAiSimStepValue(0.0f), + m_nMiSimStepValue(0), + m_dAccSimStepValue(0.0), + m_lLastHeartbeatTime(0L), + m_bHasClient(false) +{ + +} + +CDebugThread::~CDebugThread() +{ + quit(); + stopRefreshMonData(); + + m_objMbComm.closeServer(); +} + +void CDebugThread::execute() +{ + if(m_bHasClient && getMonotonicMsec() - m_lLastHeartbeatTime > CN_Heartbeat_Timeout) + { + //心跳超时，认为客户端断开 + m_bHasClient = false; + stopRefreshMonData(); + } + + handleMessage(); + + oneTimeSimulate(); + + if(getMonotonicMsec() - m_lLastSimScanTime > CN_TIMEOUT_WaitMsg) + { + periodSimulate(); + m_lLastSimScanTime = getMonotonicMsec(); + } + + if(m_nCurMonChanNo != - 1) + { + reportChanMonInfo(); + } +} + +int CDebugThread::init(const int &nPort) +{ + if(!m_objMbComm.init(nPort)) + { + return iotFailed; + } + + CTimerThreadBase::resume(); + return iotSuccess; +} + +void CDebugThread::stopRefreshMonData() +{ + m_pFesBase->m_FesSimSoeEventBuf.RefreshFlag = 0; + m_pFesBase->m_FesSimRtuEventBuf.RefreshFlag = 0; + m_pFesBase->m_FesSimChanEventBuf.RefreshFlag = 0; + m_pFesBase->m_FesSimChanMonBuf.ChanNo = -1; + m_pFesBase->m_FesSimChanMonBuf.RefreshFlag = 0; + m_bAiSimRunning = 0; //1:start 0 stop + m_bDiSimRunning = 0; //1:start 0 stop + m_bAccSimRunning = 0; //1:start 0 stop + m_bMiSimRunning = 0; //1:start 0 stop + m_nCurMonChanNo = -1; +} + +void CDebugThread::handleMessage() +{ + string strMsg; + if(!m_objMbComm.recvMsg(strMsg,CN_TIMEOUT_WaitMsg)) + { + return; + } + + FesDebugToolReqMsg stMsg; + if(!stMsg.ParseFromString(strMsg)) + { + LOGERROR("CDebugThread:反序列化消息失败.msg_size=%d",strMsg.size()); + return; + } + + switch (stMsg.type()) + { + case MT_FESDBG_HeartBeat: + return onRecvHeartbeatReq(stMsg); + case MT_FESDBG_CONNECT: + return onRecvConnectReq(stMsg); + case MT_FESDBG_DISCONNECT: + return onRecvDisconnectReq(stMsg); + case MT_FESDBG_ChanParam: + return onRecvChanParamReq(stMsg); + case MT_FESDBG_RtuParam: + return onRecvRtuParamReq(stMsg); + case MT_FESDBG_AI_RtuInfo: + case MT_FESDBG_DI_RtuInfo: + case MT_FESDBG_ACC_RtuInfo: + case MT_FESDBG_MI_RtuInfo: + case MT_FESDBG_SimAI_RtuInfo: + case MT_FESDBG_SimDI_RtuInfo: + case MT_FESDBG_SimMI_RtuInfo: + case MT_FESDBG_SimACC_RtuInfo: + case MT_FESDBG_SimEvent_RtuInfo: + case MT_FESDBG_SimAO_RtuInfo: + case MT_FESDBG_SimDO_RtuInfo: + case MT_FESDBG_SimMO_RtuInfo: + return onRecvRtuInfoReq(stMsg); + case MT_FESDBG_AI_Param: + case MT_FESDBG_SimAI_Param: + case MT_FESDBG_SimAO_Param: + return onRecvAiParamReq(stMsg); + case MT_FESDBG_AI_Value: + case MT_FESDBG_SimAI_Value: + return onRecvAiValueReq(stMsg); + case MT_FESDBG_DI_Param: + case MT_FESDBG_SimDI_Param: + case MT_FESDBG_SimEvent_DiParam: + case MT_FESDBG_SimDO_Param: + return onRecvDiParamReq(stMsg); + case MT_FESDBG_DI_Value: + case MT_FESDBG_SimDI_Value: + return onRecvDiValueReq(stMsg); + case MT_FESDBG_ACC_Param: + case MT_FESDBG_SimACC_Param: + return onRecvAccParamReq(stMsg); + case MT_FESDBG_ACC_Value: + case MT_FESDBG_SimACC_Value: + return onRecvAccValueReq(stMsg); + case MT_FESDBG_MI_Param: + case MT_FESDBG_SimMI_Param: + case MT_FESDBG_SimMO_Param: + return onRecvMiParamReq(stMsg); + case MT_FESDBG_MI_Value: + case MT_FESDBG_SimMI_Value: + return onRecvMiValueReq(stMsg); + case MT_FESDBG_SimAI_StartSim: + return onRecvSimAiStartSimReq(stMsg); + case MT_FESDBG_SimAI_StopSim: + return onRecvSimAiStopSimReq(stMsg); + case MT_FESDBG_SimDI_StartSim: + return onRecvSimDiStartSimReq(stMsg); + case MT_FESDBG_SimDI_StopSim: + return onRecvSimDiStopSimReq(stMsg); + case MT_FESDBG_SimMI_StartSim: + return onRecvSimMiStartSimReq(stMsg); + case MT_FESDBG_SimMI_StopSim: + return onRecvSimMiStopSimReq(stMsg); + case MT_FESDBG_SimACC_StartSim: + return onRecvSimAccStartSimReq(stMsg); + case MT_FESDBG_SimACC_StopSim: + return onRecvSimAccStopSimReq(stMsg); + case MT_FESDBG_SimEvent_Create: + return onRecvSimEventCreateReq(stMsg); + case MT_FESDBG_SimAO_Control: + return onRecvSimAoControlReq(stMsg); + case MT_FESDBG_SimDO_Control: + return onRecvSimDoControlReq(stMsg); + case MT_FESDBG_SimMO_Control: + return onRecvSimMoControlReq(stMsg); + case MT_FESDBG_FWAI_RtuInfo: + case MT_FESDBG_FWDI_RtuInfo: + case MT_FESDBG_FWDDI_RtuInfo: + case MT_FESDBG_FWMI_RtuInfo: + case MT_FESDBG_FWACC_RtuInfo: + return onRecvFwRtuInfoReq(stMsg); + case MT_FESDBG_FWAI_Param: + return onRecvFwAiParamReq(stMsg); + case MT_FESDBG_FWAI_Value: + return onRecvFwAiValueReq(stMsg); + case MT_FESDBG_FWDI_Param: + return onRecvFwDiParamReq(stMsg); + case MT_FESDBG_FWDI_Value: + return onRecvFwDiValueReq(stMsg); + case MT_FESDBG_FWDDI_Param: + return onRecvFwDDiParamReq(stMsg); + case MT_FESDBG_FWDDI_Value: + return onRecvFwDDiValueReq(stMsg); + case MT_FESDBG_FWMI_Param: + return onRecvFwMiParamReq(stMsg); + case MT_FESDBG_FWMI_Value: + return onRecvFwMiValueReq(stMsg); + case MT_FESDBG_FWACC_Param: + return onRecvFwAccParamReq(stMsg); + case MT_FESDBG_FWACC_Value: + return onRecvFwAccValueReq(stMsg); + case MT_FESDBG_Event_SOE: + return onRecvSoeEventReq(stMsg); + case MT_FESDBG_Event_Channel: + return onRecvChanEventReq(stMsg); + case MT_FESDBG_Event_SOEMemory: + return onRecvSoeMemEventReq(stMsg); + case MT_FESDBG_Mon_ChanStart: + return onRecvChanMonStartReq(stMsg); + case MT_FESDBG_Mon_ChanStop: + return onRecvChanMonStopReq(stMsg); + case MT_FESDBG_Mon_ChanClear: + return onRecvChanMonClearReq(stMsg); + default: + break; + } +} + +void CDebugThread::onRecvHeartbeatReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objMsg; + objMsg.set_success(true); + objMsg.set_type(objRecvMsg.type()); + objMsg.set_body(""); + + m_objMbComm.sendMsg(objMsg.SerializeAsString()); + + m_lLastHeartbeatTime = getMonotonicMsec(); +} + +void CDebugThread::oneTimeSimulate() +{ + oneTimeSimulateAi(); + oneTimeSimulateDi(); + oneTimeSimulateMi(); + oneTimeSimulateAcc(); +} + +void CDebugThread::periodSimulate() +{ + periodSimulateAi(); + periodSimulateDi(); + periodSimulateMi(); + periodSimulateAcc(); +} + +void CDebugThread::oneTimeSimulateAi() +{ + FesDebugToolValueSimSetReqMsg simParam; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bAiSimRunning) + { + return; + } + + if(m_stAiSimParam.sim_mode() != MT_FESDBG_SM_ValueSet) //单次设置，直接执行 + { + return; + } + simParam = m_stAiSimParam; + m_bAiSimRunning = false; //执行一次就结束 + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleAi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuAi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllAi(simParam); + default: + break; + } +} + +void CDebugThread::oneTimeSimulateDi() +{ + FesDebugToolValueSimSetReqMsg simParam; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bDiSimRunning) + { + return; + } + + if(m_stDiSimParam.sim_mode() != MT_FESDBG_SM_ValueSet) //单次设置，直接执行 + { + return; + } + simParam = m_stDiSimParam; + m_bDiSimRunning = false; //执行一次就结束 + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleDi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuDi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllDi(simParam); + default: + break; + } +} + +void CDebugThread::oneTimeSimulateMi() +{ + FesDebugToolValueSimSetReqMsg simParam; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bMiSimRunning) + { + return; + } + + if(m_stMiSimParam.sim_mode() != MT_FESDBG_SM_ValueSet) //单次设置，直接执行 + { + return; + } + simParam = m_stMiSimParam; + m_bMiSimRunning = false; //执行一次就结束 + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleMi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuMi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllMi(simParam); + default: + break; + } +} + +void CDebugThread::oneTimeSimulateAcc() +{ + FesDebugToolValueSimSetReqMsg simParam; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bAccSimRunning) + { + return; + } + + if(m_stAccSimParam.sim_mode() != MT_FESDBG_SM_ValueSet) //单次设置，直接执行 + { + return; + } + simParam = m_stAccSimParam; + m_bAccSimRunning = false; //执行一次就结束 + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleAcc(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuAcc(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllAcc(simParam); + default: + break; + } +} + +void CDebugThread::periodSimulateAi() +{ + FesDebugToolValueSimSetReqMsg simParam; + int nPeriodMs = SEC_PER_MIN * MSEC_PER_SEC; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bAiSimRunning) + { + return; + } + + if(m_stAiSimParam.sim_mode() == MT_FESDBG_SM_ValueSet) //单次设置，已经直接执行，跳过 + { + return; + } + + simParam = m_stAiSimParam; + + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_LineSet: + nPeriodMs = simParam.line_set_param().period() * MSEC_PER_SEC; + break; + case MT_FESDBG_SM_RandSet: + nPeriodMs = simParam.rand_set_param().period() * MSEC_PER_SEC; + break; + default: + break; + } + + //检查是否到变化周期 + if(getMonotonicMsec() - m_lAiLastSimTime < nPeriodMs) + { + return; + } + + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleAi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuAi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllAi(simParam); + default: + break; + } + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_lAiLastSimTime = getMonotonicMsec(); + } +} + +void CDebugThread::periodSimulateDi() +{ + FesDebugToolValueSimSetReqMsg simParam; + int nPeriodMs = SEC_PER_MIN * MSEC_PER_SEC; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bDiSimRunning) + { + return; + } + + if(m_stDiSimParam.sim_mode() == MT_FESDBG_SM_ValueSet) //单次设置，已经直接执行，跳过 + { + return; + } + + simParam = m_stDiSimParam; + + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_LineSet: + nPeriodMs = simParam.line_set_param().period() * MSEC_PER_SEC; + break; + case MT_FESDBG_SM_RandSet: + nPeriodMs = simParam.rand_set_param().period() * MSEC_PER_SEC; + break; + default: + break; + } + + //检查是否到变化周期 + if(getMonotonicMsec() - m_lDiLastSimTime < nPeriodMs) + { + return; + } + + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleDi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuDi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllDi(simParam); + default: + break; + } + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_lDiLastSimTime = getMonotonicMsec(); + } +} + +void CDebugThread::periodSimulateMi() +{ + FesDebugToolValueSimSetReqMsg simParam; + int nPeriodMs = SEC_PER_MIN * MSEC_PER_SEC; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bMiSimRunning) + { + return; + } + + if(m_stMiSimParam.sim_mode() == MT_FESDBG_SM_ValueSet) //单次设置，已经直接执行，跳过 + { + return; + } + + simParam = m_stDiSimParam; + + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_LineSet: + nPeriodMs = simParam.line_set_param().period() * MSEC_PER_SEC; + break; + case MT_FESDBG_SM_RandSet: + nPeriodMs = simParam.rand_set_param().period() * MSEC_PER_SEC; + break; + default: + break; + } + + //检查是否到变化周期 + if(getMonotonicMsec() - m_lMiLastSimTime < nPeriodMs) + { + return; + } + + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleMi(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuMi(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllMi(simParam); + default: + break; + } + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_lMiLastSimTime = getMonotonicMsec(); + } +} + +void CDebugThread::periodSimulateAcc() +{ + FesDebugToolValueSimSetReqMsg simParam; + int nPeriodMs = SEC_PER_MIN * MSEC_PER_SEC; + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_bAccSimRunning) + { + return; + } + + if(m_stAccSimParam.sim_mode() == MT_FESDBG_SM_ValueSet) //单次设置，已经直接执行，跳过 + { + return; + } + + simParam = m_stAccSimParam; + + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_LineSet: + nPeriodMs = simParam.line_set_param().period() * MSEC_PER_SEC; + break; + case MT_FESDBG_SM_RandSet: + nPeriodMs = simParam.rand_set_param().period() * MSEC_PER_SEC; + break; + default: + break; + } + + //检查是否到变化周期 + if(getMonotonicMsec() - m_lAccLastSimTime < nPeriodMs) + { + return; + } + + } + + //使用临时变量传递仿真参数 + switch (simParam.sim_range()) + { + case MT_FESDBG_RT_SinglePoint: + simulateSingleAcc(simParam); + break; + case MT_FESDBG_RT_RtuPoint: + simulateRtuAcc(simParam); + break; + case MT_FESDBG_RT_AllPoint: + simulateAllAcc(simParam); + default: + break; + } + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_lAccLastSimTime = getMonotonicMsec(); + } +} + +float CDebugThread::getAiSimValue(const FesDebugToolValueSimSetReqMsg &simParam) +{ + boost::mutex::scoped_lock lock(m_mutexSimParam); + float fValue = 0; + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_ValueSet: + fValue = static_cast(simParam.value_set_param().value()); + break; + case MT_FESDBG_SM_LineSet: + fValue = m_fLastAiSimValue + m_fAiSimStepValue; + if(fValue > simParam.line_set_param().max_value()) + { + fValue = static_cast(simParam.line_set_param().max_value()); + m_fAiSimStepValue = -m_fAiSimStepValue; + } + else if(fValue < simParam.line_set_param().min_value()) + { + fValue = static_cast(simParam.line_set_param().min_value()); + m_fAiSimStepValue = -m_fAiSimStepValue; + } + m_fLastAiSimValue = fValue; + break; + case MT_FESDBG_SM_RandSet: + fValue = static_cast(rand()%10000); + break; + default: + break; + } + + return fValue; +} + +void CDebugThread::simulateSingleAi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no() || !simParam.has_pnt_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesAi *pAi = ptrRtu->GetAiByPointNo(simParam.pnt_no()); + if(pAi == NULL) + { + return; + } + + float fSimValue = getAiSimValue(simParam); + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + SFesRtuAiValue AiValue; + SFesChgAi ChgAiValue; + + AiValue.PointNo = simParam.pnt_no(); + AiValue.Status = status; + AiValue.Value = fSimValue; + AiValue.time = getUTCTimeMsec(); + ChgAiValue.Status = AiValue.Status; + //ChgAiValue.Value = AiValue.Value; + ChgAiValue.time = AiValue.time; + memcpy(ChgAiValue.TableName,pAi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAiValue.ColumnName,pAi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAiValue.TagName,pAi->TagName,CN_FesMaxTagSize); + /* + pRtu->WriteRtuAiValue(1,&AiValue); + ChgAiValue.Value = pAi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAiValue(1,&ChgAiValue); + ChgAiValue.RtuNo = m_SimAi.RtuNo;//2022-03-31 thxiao + ChgAiValue.PointNo = AiValue.PointNo; + m_ptrCFesBase->WriteChgAiValue(pRtu, 1, &ChgAiValue); + */ + //2022-09-09 thxiao 仿真程序的值也需要像采集程序判断变化后，值才更新。 + int ChgCount = 0; + ptrRtu->WriteRtuAiValueAndRetChg(1, &AiValue, &ChgCount, &ChgAiValue); + if(ChgCount > 0) + { + m_pFesBase->WriteChgAiValue(ptrRtu, 1, &ChgAiValue); + } +} + +void CDebugThread::simulateRtuAi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesRtuAiValue AiValue; + SFesChgAi ChgAiValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + AiValue.Value = getAiSimValue(simParam); + AiValue.Status = status; + AiValue.time = getUTCTimeMsec(); + ChgAiValue.Status = AiValue.Status; + //ChgAiValue.Value = AiValue.Value; + ChgAiValue.time = AiValue.time; + for(int i = 0; i < ptrRtu->m_MaxAiPoints;i++) + { + SFesAi *pAi = ptrRtu->GetAiByPointNo(i); + if(pAi == NULL || pAi->Used == 0) + { + continue; + } + + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + AiValue.Value = getAiSimValue(simParam); + } + + AiValue.PointNo = i; + memcpy(ChgAiValue.TableName,pAi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAiValue.ColumnName,pAi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAiValue.TagName,pAi->TagName,CN_FesMaxTagSize); + /* + pRtu->WriteRtuAiValue(1,&AiValue); + ChgAiValue.Value = pAi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAiValue(1,&ChgAiValue); + ChgAiValue.RtuNo = m_SimAi.RtuNo;//2022-03-31 thxiao + ChgAiValue.PointNo = AiValue.PointNo; + m_ptrCFesBase->WriteChgAiValue(pRtu, 1, &ChgAiValue); + */ + //2022-09-09 thxiao 仿真程序的值也需要像采集程序判断变化后，值才更新。 + int ChgCount = 0; + ptrRtu->WriteRtuAiValueAndRetChg(1, &AiValue, &ChgCount, &ChgAiValue); + if (ChgCount > 0) + { + m_pFesBase->WriteChgAiValue(ptrRtu, 1, &ChgAiValue); + } + } +} + +void CDebugThread::simulateAllAi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + SFesRtuAiValue AiValue; + SFesChgAi ChgAiValue; + + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + AiValue.Value = getAiSimValue(simParam); + AiValue.Status = status; + AiValue.time = getUTCTimeMsec(); + ChgAiValue.Status = AiValue.Status; + //ChgAiValue.Value = AiValue.Value; + ChgAiValue.time = AiValue.time; + for(int i=0; i < m_pFesBase->m_RtuNum;i++) + { + CFesRtuPtr ptrRtu = m_pFesBase->m_vectCFesRtuPtr[i]; + if(ptrRtu == NULL) + { + continue; + } + + for(int j=0;j < ptrRtu->m_MaxAiPoints;j++) + { + SFesAi* pAi=ptrRtu->GetAiByPointNo(j); + if(pAi == NULL) + { + continue; + } + + AiValue.PointNo = j; + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + AiValue.Value = getAiSimValue(simParam); + } + + memcpy(ChgAiValue.TableName,pAi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAiValue.ColumnName,pAi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAiValue.TagName,pAi->TagName,CN_FesMaxTagSize); + /* + pRtu->WriteRtuAiValue(1,&AiValue); + ChgAiValue.Value = pAi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAiValue(1,&ChgAiValue); + ChgAiValue.RtuNo = m_SimAi.RtuNo;//2022-03-31 thxiao + ChgAiValue.PointNo = AiValue.PointNo; + m_ptrCFesBase->WriteChgAiValue(pRtu,1,&ChgAiValue); + */ + //2022-09-09 thxiao 仿真程序的值也需要像采集程序判断变化后，值才更新。 + int ChgCount = 0; + ptrRtu->WriteRtuAiValueAndRetChg(1, &AiValue, &ChgCount, &ChgAiValue); + if (ChgCount > 0) + { + m_pFesBase->WriteChgAiValue(ptrRtu, 1, &ChgAiValue); + } + } + } +} + +int CDebugThread::getDiSimValue(const FesDebugToolValueSimSetReqMsg &simParam) +{ + boost::mutex::scoped_lock lock(m_mutexSimParam); + int nValue = 0; + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_ValueSet: + nValue = static_cast(simParam.value_set_param().value()); + break; + case MT_FESDBG_SM_LineSet: + if(m_nLastDiSimValue > 0) + { + nValue = 0; + } + else + { + nValue = 1; + } + m_nLastDiSimValue = nValue; + break; + case MT_FESDBG_SM_RandSet: + if((rand()%100)>50) + { + nValue = 1; + } + else + { + nValue = 0; + } + break; + default: + break; + } + + return nValue; +} + +void CDebugThread::simulateSingleDi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no() || !simParam.has_pnt_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesDi *pDi = ptrRtu->GetDiByPointNo(simParam.pnt_no()); + if(pDi == NULL) + { + return; + } + + int nSimValue = getDiSimValue(simParam); + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + SFesRtuDiValue DiValue; + SFesChgDi ChgDiValue; + + DiValue.PointNo = simParam.pnt_no(); + DiValue.Status = status; + DiValue.Value = nSimValue; + DiValue.time = getUTCTimeMsec(); + ChgDiValue.Status = DiValue.Status; + ChgDiValue.Value = DiValue.Value; + ChgDiValue.time = DiValue.time; + memcpy(ChgDiValue.TableName,pDi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgDiValue.ColumnName,pDi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgDiValue.TagName,pDi->TagName,CN_FesMaxTagSize); + + ptrRtu->WriteRtuDiValue(1,&DiValue); + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgDiValue(1,&ChgDiValue); + ChgDiValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgDiValue.PointNo = DiValue.PointNo; + m_pFesBase->WriteChgDiValue(ptrRtu,1,&ChgDiValue); + + ////2022-03-31 thxiao 增加SOE + SFesSoeEvent SoeEvent; + SoeEvent.Status = DiValue.Status; + SoeEvent.Value = DiValue.Value; + SoeEvent.time = DiValue.time; + memcpy(SoeEvent.TableName, pDi->TableName, CN_FesMaxTableNameSize); + memcpy(SoeEvent.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); + memcpy(SoeEvent.TagName, pDi->TagName, CN_FesMaxTagSize); + SoeEvent.FaultNum = 0; + SoeEvent.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + SoeEvent.PointNo = DiValue.PointNo; + m_pFesBase->WriteSoeEventBuf(ptrRtu, 1, &SoeEvent); +} + +void CDebugThread::simulateRtuDi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + CFesRtuPtr ptrRtu= m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesRtuDiValue DiValue; + SFesChgDi ChgDiValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + DiValue.Value = getDiSimValue(simParam); + DiValue.Status = status; + DiValue.time = getUTCTimeMsec(); + ChgDiValue.Status = DiValue.Status; + ChgDiValue.time = DiValue.time; + for(int i=0;i < ptrRtu->m_MaxDiPoints;i++) + { + SFesDi *pDi = ptrRtu->GetDiByPointNo(i); + if(pDi == NULL || pDi->Used == 0) + { + continue; + } + + DiValue.PointNo = i; + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + DiValue.Value = getDiSimValue(simParam); + } + + ChgDiValue.Value = DiValue.Value; + memcpy(ChgDiValue.TableName,pDi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgDiValue.ColumnName,pDi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgDiValue.TagName,pDi->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuDiValue(1,&DiValue); + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgDiValue(1,&ChgDiValue); + ChgDiValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgDiValue.PointNo = DiValue.PointNo; + m_pFesBase->WriteChgDiValue(ptrRtu, 1, &ChgDiValue); + + ////2022-03-31 thxiao 增加SOE + SFesSoeEvent SoeEvent; + SoeEvent.Status = DiValue.Status; + SoeEvent.Value = DiValue.Value; + SoeEvent.time = DiValue.time; + memcpy(SoeEvent.TableName, pDi->TableName, CN_FesMaxTableNameSize); + memcpy(SoeEvent.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); + memcpy(SoeEvent.TagName, pDi->TagName, CN_FesMaxTagSize); + SoeEvent.FaultNum = 0; + SoeEvent.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + SoeEvent.PointNo = DiValue.PointNo; + m_pFesBase->WriteSoeEventBuf(ptrRtu, 1, &SoeEvent); + } +} + +void CDebugThread::simulateAllDi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + SFesRtuDiValue DiValue; + SFesChgDi ChgDiValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + DiValue.Value = getDiSimValue(simParam); + DiValue.Status = status; + DiValue.time = getUTCTimeMsec(); + ChgDiValue.time = DiValue.time; + for(int i=0;i < m_pFesBase->m_RtuNum;i++) + { + CFesRtuPtr ptrRtu = m_pFesBase->m_vectCFesRtuPtr[i]; + if(ptrRtu == NULL) + { + continue; + } + + for(int j=0; j < ptrRtu->m_MaxDiPoints;j++) + { + SFesDi *pDi = ptrRtu->GetDiByPointNo(j); + if(pDi == NULL || pDi->Used == 0) + { + continue; + } + + DiValue.PointNo = j; + + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + DiValue.Value = getDiSimValue(simParam); + } + + ChgDiValue.Value = DiValue.Value; + memcpy(ChgDiValue.TableName,pDi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgDiValue.ColumnName,pDi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgDiValue.TagName,pDi->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuDiValue(1,&DiValue); + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgDiValue(1,&ChgDiValue); + ChgDiValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgDiValue.PointNo = DiValue.PointNo; + m_pFesBase->WriteChgDiValue(ptrRtu, 1, &ChgDiValue); + + ////2022-03-31 thxiao 增加SOE + SFesSoeEvent SoeEvent; + SoeEvent.Status = DiValue.Status; + SoeEvent.Value = DiValue.Value; + SoeEvent.time = DiValue.time; + memcpy(SoeEvent.TableName, pDi->TableName, CN_FesMaxTableNameSize); + memcpy(SoeEvent.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); + memcpy(SoeEvent.TagName, pDi->TagName, CN_FesMaxTagSize); + SoeEvent.FaultNum = 0; + SoeEvent.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + SoeEvent.PointNo = DiValue.PointNo; + m_pFesBase->WriteSoeEventBuf(ptrRtu, 1, &SoeEvent); + } + } +} + +int CDebugThread::getMiSimValue(const FesDebugToolValueSimSetReqMsg &simParam) +{ + boost::mutex::scoped_lock lock(m_mutexSimParam); + int nValue = 0; + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_ValueSet: + nValue = static_cast(simParam.value_set_param().value()); + break; + case MT_FESDBG_SM_LineSet: + nValue = m_nLastMiSimValue + m_nMiSimStepValue; + if(nValue > static_cast(simParam.line_set_param().max_value())) + { + nValue = static_cast(simParam.line_set_param().max_value()); + m_nMiSimStepValue = -m_nMiSimStepValue; + } + else if(nValue < static_cast(simParam.line_set_param().min_value())) + { + nValue = static_cast(simParam.line_set_param().min_value()); + m_nMiSimStepValue = -m_nMiSimStepValue; + } + m_nLastMiSimValue = nValue; + break; + case MT_FESDBG_SM_RandSet: + nValue = rand()%100000; + break; + default: + break; + } + + return nValue; +} + +void CDebugThread::simulateSingleMi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no() || !simParam.has_pnt_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesMi *pMi = ptrRtu->GetMiByPointNo(simParam.pnt_no()); + if(pMi == NULL) + { + return; + } + + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + SFesRtuMiValue MiValue; + SFesChgMi ChgMiValue; + + MiValue.PointNo = simParam.pnt_no(); + MiValue.Status = status; + MiValue.Value = getMiSimValue(simParam); + MiValue.time = getUTCTimeMsec(); + ChgMiValue.Status = MiValue.Status; + ChgMiValue.Value = MiValue.Value; + ChgMiValue.time = MiValue.time; + memcpy(ChgMiValue.TableName,pMi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgMiValue.ColumnName,pMi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgMiValue.TagName,pMi->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuMiValue(1,&MiValue); + ChgMiValue.Value = pMi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgMiValue(1,&ChgMiValue); + m_pFesBase->WriteChgMiValue(ptrRtu,1,&ChgMiValue); +} + +void CDebugThread::simulateRtuMi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + CFesRtuPtr ptrRtu= m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesRtuMiValue MiValue; + SFesChgMi ChgMiValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + MiValue.Status = status; + MiValue.Value = getMiSimValue(simParam); + MiValue.time = getUTCTimeMsec(); + ChgMiValue.Status = MiValue.Status; + //ChgMiValue.Value = MiValue.Value; + ChgMiValue.time = MiValue.time; + for(int i=0;i < ptrRtu->m_MaxMiPoints;i++) + { + SFesMi *pMi = ptrRtu->GetMiByPointNo(i); + if(pMi == NULL || pMi->Used == 0) + { + continue; + } + + MiValue.PointNo = i; + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + MiValue.Value = getDiSimValue(simParam); + } + + memcpy(ChgMiValue.TableName,pMi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgMiValue.ColumnName,pMi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgMiValue.TagName,pMi->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuMiValue(1,&MiValue); + ChgMiValue.Value = pMi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgMiValue(1,&ChgMiValue); + m_pFesBase->WriteChgMiValue(ptrRtu,1,&ChgMiValue); + } +} + +void CDebugThread::simulateAllMi(const FesDebugToolValueSimSetReqMsg &simParam) +{ + SFesRtuMiValue MiValue; + SFesChgMi ChgMiValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + MiValue.Status = status; + MiValue.Value = getMiSimValue(simParam); + MiValue.time = getUTCTimeMsec(); + ChgMiValue.Status = MiValue.Status; + ChgMiValue.time = MiValue.time; + + for(int i=0;i < m_pFesBase->m_RtuNum;i++) + { + CFesRtuPtr ptrRtu = m_pFesBase->m_vectCFesRtuPtr[i]; + for(int j=0;j < ptrRtu->m_MaxMiPoints;j++) + { + SFesMi *pMi = ptrRtu->GetMiByPointNo(j); + if(pMi == NULL || pMi->Used == 0) + { + continue; + } + + MiValue.PointNo = j; + + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + MiValue.Value = getMiSimValue(simParam); + } + + //ChgMiValue.Value = MiValue.Value; + memcpy(ChgMiValue.TableName,pMi->TableName,CN_FesMaxTableNameSize); + memcpy(ChgMiValue.ColumnName,pMi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgMiValue.TagName,pMi->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuMiValue(1,&MiValue); + ChgMiValue.Value = pMi->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgMiValue(1,&ChgMiValue); + m_pFesBase->WriteChgMiValue(ptrRtu,1,&ChgMiValue); + } + } +} + +double CDebugThread::getAccSimValue(const FesDebugToolValueSimSetReqMsg &simParam) +{ + boost::mutex::scoped_lock lock(m_mutexSimParam); + double dValue = 0.0; + switch (simParam.sim_mode()) + { + case MT_FESDBG_SM_ValueSet: + dValue = simParam.value_set_param().value(); + break; + case MT_FESDBG_SM_LineSet: + dValue = m_dLastAccSimValue + m_dAccSimStepValue; + if(dValue > simParam.line_set_param().max_value()) + { + dValue = simParam.line_set_param().max_value(); + m_dAccSimStepValue = -m_dAccSimStepValue; + } + else if(dValue < simParam.line_set_param().min_value()) + { + dValue = simParam.line_set_param().min_value(); + m_dAccSimStepValue = -m_dAccSimStepValue; + } + m_dLastAccSimValue = dValue; + break; + case MT_FESDBG_SM_RandSet: + dValue = rand()%100000; + break; + default: + break; + } + + return dValue; +} + +void CDebugThread::simulateSingleAcc(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no() || !simParam.has_pnt_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesAcc *pAcc = ptrRtu->GetAccByPointNo(simParam.pnt_no()); + if(pAcc == NULL) + { + return; + } + + double dSimValue = getAccSimValue(simParam); + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + SFesRtuAccValue AccValue; + SFesChgAcc ChgAccValue; + + AccValue.PointNo = simParam.pnt_no(); + AccValue.Status = status; + AccValue.Value = dSimValue; + AccValue.time = getUTCTimeMsec(); + ChgAccValue.Status = AccValue.Status; + //ChgAccValue.Value = AccValue.Value; + ChgAccValue.time = AccValue.time; + memcpy(ChgAccValue.TableName,pAcc->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAccValue.ColumnName,pAcc->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAccValue.TagName,pAcc->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuAccValue(1,&AccValue); + ChgAccValue.Value = pAcc->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAccValue(1,&ChgAccValue); + ChgAccValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgAccValue.PointNo = AccValue.PointNo; + m_pFesBase->WriteChgAccValue(ptrRtu, 1, &ChgAccValue); +} + +void CDebugThread::simulateRtuAcc(const FesDebugToolValueSimSetReqMsg &simParam) +{ + if(!simParam.has_rtu_no()) + { + return; + } + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(simParam.rtu_no()); + if(ptrRtu == NULL) + { + return; + } + + SFesRtuAccValue AccValue; + SFesChgAcc ChgAccValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + AccValue.Value = getAccSimValue(simParam); + AccValue.Status = status; + AccValue.time = getUTCTimeMsec(); + ChgAccValue.Status = AccValue.Status; + ChgAccValue.time = AccValue.time; + for(int i=0;i < ptrRtu->m_MaxAccPoints;i++) + { + SFesAcc *pAcc = ptrRtu->GetAccByPointNo(i); + if(pAcc == NULL || pAcc->Used == 0) + { + continue; + } + + AccValue.PointNo = i; + + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + AccValue.Value = getAccSimValue(simParam); + } + + //ChgAccValue.Value = AccValue.Value; + memcpy(ChgAccValue.TableName,pAcc->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAccValue.ColumnName,pAcc->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAccValue.TagName,pAcc->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuAccValue(1,&AccValue); + ChgAccValue.Value = pAcc->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAccValue(1,&ChgAccValue); + ChgAccValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgAccValue.PointNo = AccValue.PointNo; + m_pFesBase->WriteChgAccValue(ptrRtu, 1, &ChgAccValue); + } +} + +void CDebugThread::simulateAllAcc(const FesDebugToolValueSimSetReqMsg &simParam) +{ + SFesRtuAccValue AccValue; + SFesChgAcc ChgAccValue; + uint32 status = simParam.has_status() ? simParam.status() : CN_FesValueUpdate; + + AccValue.Status = status; + AccValue.Value = getAccSimValue(simParam); + AccValue.time = getUTCTimeMsec(); + ChgAccValue.Status = AccValue.Status; + ChgAccValue.time = AccValue.time; + + for(int i=0;i < m_pFesBase->m_RtuNum;i++) + { + CFesRtuPtr ptrRtu = m_pFesBase->m_vectCFesRtuPtr[i]; + for(int j=0; j < ptrRtu->m_MaxAccPoints;j++) + { + SFesAcc *pAcc = ptrRtu->GetAccByPointNo(j); + if(pAcc == NULL || pAcc->Used == 0) + { + continue; + } + + AccValue.PointNo = j; + + if(simParam.sim_mode() == MT_FESDBG_SM_RandSet) + { + AccValue.Value = getAccSimValue(simParam); + } + + //ChgAccValue.Value = AccValue.Value; + memcpy(ChgAccValue.TableName,pAcc->TableName,CN_FesMaxTableNameSize); + memcpy(ChgAccValue.ColumnName,pAcc->ColumnName,CN_FesMaxColumnNameSize); + memcpy(ChgAccValue.TagName,pAcc->TagName,CN_FesMaxTagSize); + ptrRtu->WriteRtuAccValue(1,&AccValue); + ChgAccValue.Value = pAcc->Value; + //2022-03-30 lj 仿真转发变化数据 + //pRtu->WriteChgAccValue(1,&ChgAccValue); + ChgAccValue.RtuNo = simParam.rtu_no();//2022-03-31 thxiao + ChgAccValue.PointNo = AccValue.PointNo; + m_pFesBase->WriteChgAccValue(ptrRtu, 1, &ChgAccValue); + } + } +} + +void CDebugThread::onRecvConnectReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg) +{ + boost::ignore_unused_variable_warning(objRecvMsg); + + LOGINFO("CDebugThread:接收到调试工具连接指令"); + + FesDebugToolRepMsg objMsg; + objMsg.set_success(true); + objMsg.set_type(MT_FESDBG_CONNECT); + objMsg.set_body("CONNECT SUCCESS"); + m_objMbComm.sendMsg(objMsg.SerializeAsString()); + + m_bHasClient = true; + m_lLastHeartbeatTime = getMonotonicMsec(); +} + +void CDebugThread::onRecvDisconnectReq(const FesDebugToolReqMsg &objRecvMsg) +{ + boost::ignore_unused_variable_warning(objRecvMsg); + + m_bHasClient = false; + stopRefreshMonData(); +} + +void CDebugThread::onRecvChanParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + boost::ignore_unused_variable_warning(objRecvMsg); + + int nChanCount = static_cast(m_pFesBase->m_vectCFesChanPtr.size()); + + FesDebugToolChanParamRepMsg chanParamMsg; + chanParamMsg.mutable_chan_param()->Reserve(nChanCount); + for(int nChanIdx = 0; nChanIdx < nChanCount; nChanIdx++) + { + FesDebugToolChanParam* chanParam = chanParamMsg.add_chan_param(); + CFesChanPtr ptrFesChan = m_pFesBase->m_vectCFesChanPtr[nChanIdx]; + chanParam->set_chan_no(ptrFesChan->m_Param.ChanNo); + chanParam->set_tag_name(ptrFesChan->m_Param.TagName); + chanParam->set_chan_name(ptrFesChan->m_Param.ChanName); + chanParam->set_used(ptrFesChan->m_Param.Used); + + //2020-12-28 thxiao 改为通道链路状态作为通道状态 + int nChanStatus = (ptrFesChan->m_LinkStatus == CN_FesChanConnect) ? CN_FesChanRun : CN_FesChanStop; + chanParam->set_chan_status(nChanStatus); + chanParam->set_comm_type(ptrFesChan->m_Param.CommType); + chanParam->set_chan_mode(ptrFesChan->m_Param.ChanMode); + chanParam->set_protocol_id(ptrFesChan->m_Param.ProtocolId); + + chanParam->mutable_net_route()->Reserve(CN_FesMaxNetRouteNum); + for(int nNetIdx = 0; nNetIdx < CN_FesMaxNetRouteNum; nNetIdx++) + { + FesDebugToolNetRoute* pNetRoute = chanParam->add_net_route(); + pNetRoute->set_desc(ptrFesChan->m_Param.NetRoute[nNetIdx].NetDesc); + pNetRoute->set_port_no(ptrFesChan->m_Param.NetRoute[nNetIdx].PortNo); + } + + chanParam->set_connect_wait_sec(ptrFesChan->m_Param.ConnectWaitSec); + chanParam->set_connect_timeout(ptrFesChan->m_Param.ConnectTimeout); + chanParam->set_retry_times(ptrFesChan->m_Param.RetryTimes); + chanParam->set_recv_timeout(ptrFesChan->m_Param.RecvTimeout); + chanParam->set_resp_timeout(ptrFesChan->m_Param.RespTimeout); + chanParam->set_max_rx_size(ptrFesChan->m_Param.MaxRxSize); + chanParam->set_max_tx_size(ptrFesChan->m_Param.MaxTxSize); + chanParam->set_err_rate_limit(ptrFesChan->m_Param.ErrRateLimit); + + for(int nBackupChanIdx = 0; nBackupChanIdx < CN_FesMaxChangeChanNum - 1; nBackupChanIdx++) + { + chanParam->add_backup_chan_no(ptrFesChan->m_Param.BackupChanNo[nBackupChanIdx]); + } + } + + string *pStrMsg = new string; + chanParamMsg.SerializeToString(pStrMsg); + + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_success(true); + objSendMsg.set_type(MT_FESDBG_ChanParam); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvRtuParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + boost::ignore_unused_variable_warning(objRecvMsg); + + int nRtuCount = static_cast(m_pFesBase->m_vectCFesRtuPtr.size()); + + FesDebugToolRtuParamRepMsg rtuParamMsg; + rtuParamMsg.mutable_rtu_param()->Reserve(nRtuCount); + + for(int nIdx = 0; nIdx < nRtuCount; nIdx++) + { + CFesRtuPtr ptrRtu = m_pFesBase->m_vectCFesRtuPtr[nIdx]; + FesDebugToolRtuParam *pParam = rtuParamMsg.add_rtu_param(); + pParam->set_rtu_no(ptrRtu->m_Param.RtuNo); + pParam->set_rtu_desc(ptrRtu->m_Param.RtuDesc); + pParam->set_rtu_name(ptrRtu->m_Param.RtuName); + pParam->set_used(ptrRtu->m_Param.Used); + pParam->set_rtu_status(ptrRtu->m_Status); + pParam->set_rtu_addr(ptrRtu->m_Param.RtuAddr); + pParam->set_chan_no(ptrRtu->m_Param.ChanNo); + pParam->set_max_ai_num(ptrRtu->m_MaxAiPoints); + pParam->set_max_di_num(ptrRtu->m_MaxDiPoints); + pParam->set_max_acc_num(ptrRtu->m_MaxAccPoints); + pParam->set_recv_fail_limit(ptrRtu->m_Param.RecvFailLimit); + } + + string *pStrMsg = new string; + rtuParamMsg.SerializeToString(pStrMsg); + + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_success(true); + objSendMsg.set_type(MT_FESDBG_RtuParam); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvRtuInfoReq(const FesDebugToolReqMsg &objRecvMsg) +{ + int nTotalNum = static_cast(m_pFesBase->m_vectCFesRtuPtr.size()); + FesDebugToolRtuInfoRepMsg rtuInfoMsg; + rtuInfoMsg.mutable_rtu_info()->Reserve(nTotalNum); + + for(int nIdx = 0; nIdx < nTotalNum; nIdx++) + { + CFesRtuPtr ptrFesRtu = m_pFesBase->m_vectCFesRtuPtr[nIdx]; + if(ptrFesRtu->m_RtuProperty != CN_Fes_RTU_Collect) + { + continue; + } + + FesDebugToolRtuInfo *pInfo = rtuInfoMsg.add_rtu_info(); + pInfo->set_rtu_no(ptrFesRtu->m_Param.RtuNo); + pInfo->set_used(ptrFesRtu->m_Param.Used); + pInfo->set_rtu_desc(ptrFesRtu->m_Param.RtuDesc); + } + + string *pStrMsg = new string; + rtuInfoMsg.SerializeToString(pStrMsg); + + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_success(true); + objSendMsg.set_type(objRecvMsg.type()); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvAiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvAiParamReq反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvAiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolPntParamRepMsg aiParamRepMsg; + aiParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + aiParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxAiPoints); + aiParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxAiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxAiPoints; nIdx++) + { + SFesAi *pAi = ptrFesRtu->m_pAi + nIdx; + if(pAi->Used == 0) + { + continue; + } + + FesDebugToolPntParam *pParam = aiParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pAi->PointNo); + pParam->set_used(pAi->Used); + pParam->set_pnt_desc(pAi->PointDesc); + } + + string *pStrMsg = new string; + aiParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvAiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvAccValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvAiDataReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxAiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxAiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxAiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxAiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_float_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesAi *pAi = ptrFesRtu->m_pAi + i; + if(pAi->Used == 0) + { + continue; + } + + FesDebugToolFloatPntValue *pData = repMsg.add_float_values(); + pData->set_pnt_no(pAi->PointNo); + pData->set_value(pAi->Value); + pData->set_status(pAi->Status); + pData->set_time(pAi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvDiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvDiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvDiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolPntParamRepMsg diParamRepMsg; + diParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + diParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxDiPoints); + diParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxDiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxDiPoints; nIdx++) + { + SFesDi *pDi = ptrFesRtu->m_pDi + nIdx; + if(pDi->Used == 0) + { + continue; + } + + FesDebugToolPntParam *pParam = diParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pDi->PointNo); + pParam->set_used(pDi->Used); + pParam->set_pnt_desc(pDi->PointDesc); + } + + string *pStrMsg = new string; + diParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvDiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwDiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwDiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxDiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxDiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxDiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxDiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_int_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesDi *pDi = ptrFesRtu->m_pDi + i; + if(pDi->Used == 0) + { + continue; + } + + FesDebugToolIntPntValue *pData = repMsg.add_int_values(); + pData->set_pnt_no(pDi->PointNo); + pData->set_value(pDi->Value); + pData->set_status(pDi->Status); + pData->set_time(pDi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvAccParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvAccParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvAccParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolPntParamRepMsg accParamRepMsg; + accParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + accParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxAccPoints); + accParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxAccPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxAccPoints; nIdx++) + { + SFesAcc *pAcc = ptrFesRtu->m_pAcc + nIdx; + if(pAcc->Used == 0) + { + continue; + } + + FesDebugToolPntParam *pParam = accParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pAcc->PointNo); + pParam->set_used(pAcc->Used); + pParam->set_pnt_desc(pAcc->PointDesc); + } + + string *pStrMsg = new string; + accParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvAccValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvAccValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvAccValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxAccPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxAccPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxAccPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxAccPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_double_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesAcc *pAcc = ptrFesRtu->m_pAcc + i; + if(pAcc->Used == 0) + { + continue; + } + + FesDebugToolDoublePntValue *pData = repMsg.add_double_values(); + pData->set_pnt_no(pAcc->PointNo); + pData->set_value(pAcc->Value); + pData->set_status(pAcc->Status); + pData->set_time(pAcc->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvMiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvMiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvMiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolPntParamRepMsg miParamRepMsg; + miParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + miParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxMiPoints); + miParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxMiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxMiPoints; nIdx++) + { + SFesMi *pMi = ptrFesRtu->m_pMi + nIdx; + if(pMi->Used == 0) + { + continue; + } + + FesDebugToolPntParam *pParam = miParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pMi->PointNo); + pParam->set_used(pMi->Used); + pParam->set_pnt_desc(pMi->PointDesc); + } + + string *pStrMsg = new string; + miParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvMiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvMiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvMiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxMiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxMiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxMiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxMiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_int_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesMi *pMi = ptrFesRtu->m_pMi + i; + if(pMi->Used == 0) + { + continue; + } + + FesDebugToolIntPntValue *pData = repMsg.add_int_values(); + pData->set_pnt_no(pMi->PointNo); + pData->set_value(pMi->Value); + pData->set_status(pMi->Status); + pData->set_time(pMi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimAiStartSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_stAiSimParam.ParseFromString(objRecvMsg.body())) + { + m_bAiSimRunning = false; //解析失败则停止仿真 + + LOGERROR("CDebugThread::onRecvSimAiStartSimReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + m_bAiSimRunning = true; + m_lAiLastSimTime = 0L; + + if(m_stAiSimParam.sim_mode() == MT_FESDBG_SM_LineSet) + { + m_fLastAiSimValue = static_cast(m_stAiSimParam.line_set_param().min_value()); + m_fAiSimStepValue = static_cast(m_stAiSimParam.line_set_param().step_value()); + } + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stAiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimAiStopSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_bAiSimRunning = false; + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stAiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimDiStartSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_stDiSimParam.ParseFromString(objRecvMsg.body())) + { + m_bDiSimRunning = false; //解析失败则停止仿真 + + LOGERROR("CDebugThread::onRecvSimDiStartSimReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + m_bDiSimRunning = true; + m_lDiLastSimTime = 0L; + m_nLastDiSimValue = 0; + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stDiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimDiStopSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_bDiSimRunning = false; + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stDiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimMiStartSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_stMiSimParam.ParseFromString(objRecvMsg.body())) + { + m_bMiSimRunning = false; //解析失败则停止仿真 + + LOGERROR("CDebugThread::onRecvSimMiStartSimReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + m_bMiSimRunning = true; + m_lMiLastSimTime = 0L; + + if(m_stMiSimParam.sim_mode() == MT_FESDBG_SM_LineSet) + { + m_nLastMiSimValue = static_cast(m_stMiSimParam.line_set_param().min_value()); + m_nMiSimStepValue = static_cast(m_stMiSimParam.line_set_param().step_value()); + } + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stMiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimMiStopSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_bMiSimRunning = false; + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stMiSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimAccStartSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + if(!m_stAccSimParam.ParseFromString(objRecvMsg.body())) + { + m_bAccSimRunning = false; //解析失败则停止仿真 + + LOGERROR("CDebugThread::onRecvSimAccStartSimReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + m_bAccSimRunning = true; + m_lAccLastSimTime = 0L; + + if(m_stAccSimParam.sim_mode() == MT_FESDBG_SM_LineSet) + { + m_dLastAccSimValue = m_stAccSimParam.line_set_param().min_value(); + m_dAccSimStepValue = m_stAccSimParam.line_set_param().step_value(); + } + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stAccSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimAccStopSimReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + { + boost::mutex::scoped_lock lock(m_mutexSimParam); + m_bAccSimRunning = false; + } + + FesDebugToolValueSimSetRepMsg repMsg; + repMsg.set_sim_mode(m_stAccSimParam.sim_mode()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimEventCreateReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolSimEventCreateReqMsg stEventReq; + if(!stEventReq.ParseFromString(objRecvMsg.body()) || !stEventReq.has_event() || + stEventReq.mutable_event()->fault_num() != stEventReq.mutable_event()->fault_type_size() || + stEventReq.mutable_event()->fault_num() != stEventReq.mutable_event()->fault_value_size() || + stEventReq.mutable_event()->fault_num() > CN_FesMaxFaultNum) + { + LOGERROR("CDebugThread::onRecvSimEventCreateReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + bool bRet = false; + FesDebugToolSimEventRtuSoe *pEvent = stEventReq.mutable_event(); + + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(pEvent->rtu_no()); + if(ptrRtu != NULL) + { + SFesDi *pDi = ptrRtu->GetDiByPointNo(pEvent->pnt_no()); + if(pDi != NULL && pDi->Used) + { + bRet = true; + SFesSoeEvent SoeEvent; + memcpy(SoeEvent.TableName,pDi->TableName,CN_FesMaxTableNameSize); + memcpy(SoeEvent.ColumnName,pDi->ColumnName,CN_FesMaxColumnNameSize); + memcpy(SoeEvent.TagName,pDi->TagName,CN_FesMaxTagSize); + SoeEvent.Status = pEvent->status(); + SoeEvent.Value = pEvent->value(); + SoeEvent.time = getUTCTimeMsec(); + SoeEvent.FaultNum = pEvent->fault_num(); + + for(int i = 0; i < pEvent->fault_num(); i++) + { + SoeEvent.FaultValTag[i] = pEvent->fault_type(i); + SoeEvent.FaultVal[i] = pEvent->fault_value(i); + } + + for(int i = pEvent->fault_num(); i < CN_FesMaxFaultNum;i++) + { + SoeEvent.FaultValTag[i] = 0; + SoeEvent.FaultVal[i] = 0; + } + + ptrRtu->WriteSoeEventBuf(1,&SoeEvent); + + //保存FesSim监视数据 + m_pFesBase->FesSimServerWriteSoeEvent(1,&SoeEvent); + } + } + + if(bRet) + { + FesDebugToolSimEventCreateRepMsg repMsg; + repMsg.set_event_type(stEventReq.event_type()); + repMsg.set_body(""); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + } + else + { + LOGERROR("CDebugThread::onRecvSimEventCreateReq 找不到rtu_no=%d",pEvent->rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + } +} + +void CDebugThread::onRecvSimAoControlReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolSimControlReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body()) || !reqMsg.has_float_value()) + { + LOGERROR("CDebugThread::onRecvSimAoControlReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + bool bRet = false; + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrRtu != NULL) + { + SFesAo *pAo = ptrRtu->GetAoByPointNo(reqMsg.pnt_no()); + if(pAo != NULL && pAo->Used) + { + bRet = true; + SFesRxAoCmd cmd; + cmd.RtuNo = ptrRtu->m_Param.RtuNo; + cmd.PointID = reqMsg.pnt_no(); + cmd.fValue = reqMsg.float_value(); + cmd.CtrlActType = reqMsg.ctrl_type(); + sprintf(cmd.ColumnName,"%s","aoColumnName"); + sprintf(cmd.TableName,"%s","aoTableName"); + strcpy(cmd.TagName,pAo->PointTagName); + strcpy(cmd.RtuName,ptrRtu->m_Param.RtuName); + ptrRtu->WriteRxAoCmdBuf(1,&cmd); + } + } + + FesDebugToolSimControlRepMsg repMsg; + repMsg.set_ctrl_type(reqMsg.ctrl_type()); + repMsg.set_seq_no(reqMsg.seq_no()); + repMsg.set_success(bRet); + if(!bRet) + { + repMsg.set_err_msg("cannot find the point"); + } + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimDoControlReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolSimControlReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body()) || !reqMsg.has_int_value()) + { + LOGERROR("CDebugThread::onRecvSimDoControlReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + bool bRet = false; + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrRtu != NULL) + { + SFesDo *pDo = ptrRtu->GetDoByPointNo(reqMsg.pnt_no()); + if(pDo != NULL && pDo->Used) + { + bRet = true; + SFesRxDoCmd cmd; + cmd.RtuNo = ptrRtu->m_Param.RtuNo; + cmd.PointID = reqMsg.pnt_no(); + cmd.iValue = reqMsg.int_value(); + cmd.CtrlActType = reqMsg.ctrl_type(); + cmd.CtrlDir = 0; + strcpy(cmd.TableName,"TableName"); + strcpy(cmd.ColumnName,"ColumnName"); + strcpy(cmd.TagName,pDo->PointTagName); + strcpy(cmd.RtuName,ptrRtu->m_Param.RtuName); + ptrRtu->WriteRxDoCmdBuf(1,&cmd); + } + } + + FesDebugToolSimControlRepMsg repMsg; + repMsg.set_ctrl_type(reqMsg.ctrl_type()); + repMsg.set_seq_no(reqMsg.seq_no()); + repMsg.set_success(bRet); + if(!bRet) + { + repMsg.set_err_msg("cannot find the point"); + } + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSimMoControlReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolSimControlReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body()) || !reqMsg.has_int_value()) + { + LOGERROR("CDebugThread::onRecvSimMoControlReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + bool bRet = false; + CFesRtuPtr ptrRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrRtu != NULL) + { + SFesMo *pMo = ptrRtu->GetMoByPointNo(reqMsg.pnt_no()); + if(pMo != NULL && pMo->Used) + { + bRet = true; + SFesRxMoCmd cmd; + cmd.RtuNo = ptrRtu->m_Param.RtuNo; + cmd.PointID = reqMsg.pnt_no(); + cmd.iValue = reqMsg.int_value(); + cmd.CtrlActType = reqMsg.ctrl_type(); + sprintf(cmd.ColumnName,"%s","MoColumnName"); + sprintf(cmd.TableName,"%s","MoTableName"); + strcpy(cmd.TagName,pMo->PointTagName); + strcpy(cmd.RtuName,ptrRtu->m_Param.RtuName); + ptrRtu->WriteRxMoCmdBuf(1,&cmd); + } + } + + FesDebugToolSimControlRepMsg repMsg; + repMsg.set_ctrl_type(reqMsg.ctrl_type()); + repMsg.set_seq_no(reqMsg.seq_no()); + repMsg.set_success(bRet); + if(!bRet) + { + repMsg.set_err_msg("cannot find the point"); + } + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwRtuInfoReq(const FesDebugToolReqMsg &objRecvMsg) +{ + int nTotalNum = static_cast(m_pFesBase->m_vectCFesRtuPtr.size()); + FesDebugToolRtuInfoRepMsg rtuInfoMsg; + rtuInfoMsg.mutable_rtu_info()->Reserve(nTotalNum); + + for(int nIdx = 0; nIdx < nTotalNum; nIdx++) + { + CFesRtuPtr ptrFesRtu = m_pFesBase->m_vectCFesRtuPtr[nIdx]; + if(ptrFesRtu->m_RtuProperty != CN_Fes_RTU_Forward) + { + continue; + } + + FesDebugToolRtuInfo *pInfo = rtuInfoMsg.add_rtu_info(); + pInfo->set_rtu_no(ptrFesRtu->m_Param.RtuNo); + pInfo->set_used(ptrFesRtu->m_Param.Used); + pInfo->set_rtu_desc(ptrFesRtu->m_Param.RtuDesc); + } + + string *pStrMsg = new string; + rtuInfoMsg.SerializeToString(pStrMsg); + + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_success(true); + objSendMsg.set_type(objRecvMsg.type()); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwAiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvFwAiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwAiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolFwPntParamRepMsg aiParamRepMsg; + aiParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + aiParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxFwAiPoints); + aiParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxFwAiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxFwAiPoints; nIdx++) + { + SFesFwAi *pFwAi = ptrFesRtu->m_pFwAi + nIdx; + if(pFwAi->Used == 0) + { + continue; + } + + FesDebugToolFwPntParam *pParam = aiParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pFwAi->RemoteNo); + pParam->set_used(pFwAi->Used); + pParam->set_fes_rtu_no(pFwAi->FesRtuNo); + pParam->set_fes_pnt_no(pFwAi->FesPointNo); + pParam->set_pnt_desc(pFwAi->PointDesc); + } + + string *pStrMsg = new string; + aiParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwAiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwAiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwAiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxFwAiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxFwAiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxFwAiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxFwAiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_float_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesFwAi *pFwAi = ptrFesRtu->m_pFwAi + i; + if(pFwAi->Used == 0) + { + continue; + } + + FesDebugToolFloatPntValue *pData = repMsg.add_float_values(); + pData->set_pnt_no(pFwAi->RemoteNo); + pData->set_value(pFwAi->Value); + pData->set_status(pFwAi->Status); + pData->set_time(pFwAi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwDiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvFwDiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwDiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolFwPntParamRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + repMsg.set_max_pnt_num(ptrFesRtu->m_MaxFwDiPoints); + repMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxFwDiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxFwDiPoints; nIdx++) + { + SFesFwDi *pFwDi = ptrFesRtu->m_pFwDi + nIdx; + if(pFwDi->Used == 0) + { + continue; + } + + FesDebugToolFwPntParam *pParam = repMsg.add_pnt_param(); + pParam->set_pnt_no(pFwDi->RemoteNo); + pParam->set_used(pFwDi->Used); + pParam->set_fes_rtu_no(pFwDi->FesRtuNo); + pParam->set_fes_pnt_no(pFwDi->FesPointNo); + pParam->set_pnt_desc(pFwDi->PointDesc); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwDiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwDiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwDiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxFwDiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxFwDiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxFwDiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxFwDiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_int_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesFwDi *pFwDi = ptrFesRtu->m_pFwDi + i; + if(pFwDi->Used == 0) + { + continue; + } + + FesDebugToolIntPntValue *pData = repMsg.add_int_values(); + pData->set_pnt_no(pFwDi->RemoteNo); + pData->set_value(pFwDi->Value); + pData->set_status(pFwDi->Status); + pData->set_time(pFwDi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwDDiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvFwDDiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwDDiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolFwPntParamRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + repMsg.set_max_pnt_num(ptrFesRtu->m_MaxFwDDiPoints); + repMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxFwDDiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxFwDDiPoints; nIdx++) + { + SFesFwDi *pFwDDi = ptrFesRtu->m_pFwDDi + nIdx; + if(pFwDDi->Used == 0) + { + continue; + } + + FesDebugToolFwPntParam *pParam = repMsg.add_pnt_param(); + pParam->set_pnt_no(pFwDDi->RemoteNo); + pParam->set_used(pFwDDi->Used); + pParam->set_fes_rtu_no(pFwDDi->FesRtuNo); + pParam->set_fes_pnt_no(pFwDDi->FesPointNo); + pParam->set_pnt_desc(pFwDDi->PointDesc); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwDDiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwDDiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwDDiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxFwDDiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxFwDDiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxFwDDiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxFwDDiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_int_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesFwDi *pFwDDi = ptrFesRtu->m_pFwDDi + i; + if(pFwDDi->Used == 0) + { + continue; + } + + FesDebugToolIntPntValue *pData = repMsg.add_int_values(); + pData->set_pnt_no(pFwDDi->RemoteNo); + pData->set_value(pFwDDi->Value); + pData->set_status(pFwDDi->Status); + pData->set_time(pFwDDi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwMiParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvFwMiParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwMiParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolFwPntParamRepMsg miParamRepMsg; + miParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + miParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxFwMiPoints); + miParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxFwMiPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxFwMiPoints; nIdx++) + { + SFesFwMi *pFwMi = ptrFesRtu->m_pFwMi + nIdx; + if(pFwMi->Used == 0) + { + continue; + } + + FesDebugToolFwPntParam *pParam = miParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pFwMi->RemoteNo); + pParam->set_used(pFwMi->Used); + pParam->set_fes_rtu_no(pFwMi->FesRtuNo); + pParam->set_fes_pnt_no(pFwMi->FesPointNo); + pParam->set_pnt_desc(pFwMi->PointDesc); + } + + string *pStrMsg = new string; + miParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwMiValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwMiValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwMiValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxFwMiPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxFwMiPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxFwMiPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxFwMiPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_int_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesFwMi *pFwMi = ptrFesRtu->m_pFwMi + i; + if(pFwMi->Used == 0) + { + continue; + } + + FesDebugToolIntPntValue *pData = repMsg.add_int_values(); + pData->set_pnt_no(pFwMi->RemoteNo); + pData->set_value(pFwMi->Value); + pData->set_status(pFwMi->Status); + pData->set_time(pFwMi->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwAccParamReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntParamReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvFwAccParamReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwAccParamReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolFwPntParamRepMsg accParamRepMsg; + accParamRepMsg.set_rtu_no(reqMsg.rtu_no()); + accParamRepMsg.set_max_pnt_num(ptrFesRtu->m_MaxFwAccPoints); + accParamRepMsg.mutable_pnt_param()->Reserve(ptrFesRtu->m_MaxFwAccPoints); + + for(int nIdx = 0; nIdx < ptrFesRtu->m_MaxFwAccPoints; nIdx++) + { + SFesFwAcc *pFwAcc = ptrFesRtu->m_pFwAcc + nIdx; + if(pFwAcc->Used == 0) + { + continue; + } + + FesDebugToolFwPntParam *pParam = accParamRepMsg.add_pnt_param(); + pParam->set_pnt_no(pFwAcc->RemoteNo); + pParam->set_used(pFwAcc->Used); + pParam->set_fes_rtu_no(pFwAcc->FesRtuNo); + pParam->set_fes_pnt_no(pFwAcc->FesPointNo); + pParam->set_pnt_desc(pFwAcc->PointDesc); + } + + string *pStrMsg = new string; + accParamRepMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvFwAccValueReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolPntValueReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread::onRecvFwAccValueReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + CFesRtuPtr ptrFesRtu = m_pFesBase->GetRtuDataByRtuNo(reqMsg.rtu_no()); + if(ptrFesRtu == NULL) + { + LOGERROR("CDebugThread::onRecvFwAccValueReq 找不到rtu_no=%d",reqMsg.rtu_no()); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + int nStartIndex = 0; + int nEndIndex = 0; + + if((reqMsg.start_index() == -1) && (reqMsg.end_index() == -1))//all data + { + nStartIndex = 0; + nEndIndex = ptrFesRtu->m_MaxFwAccPoints - 1; + } + else//section data + { + if(reqMsg.start_index() >= 0 && reqMsg.start_index() < ptrFesRtu->m_MaxFwAccPoints) + { + nStartIndex = reqMsg.start_index(); + } + else + { + nStartIndex = 0; + } + + if(reqMsg.end_index() >= 0 && reqMsg.end_index() < ptrFesRtu->m_MaxFwAccPoints) + { + nEndIndex = reqMsg.end_index(); + } + else + { + nEndIndex = ptrFesRtu->m_MaxFwAccPoints - 1; + } + } + + FesDebugToolPntValueRepMsg repMsg; + repMsg.set_rtu_no(reqMsg.rtu_no()); + + repMsg.mutable_double_values()->Reserve(nEndIndex - nStartIndex + 1); + for(int i = nStartIndex; i <= nEndIndex; i++) + { + SFesFwAcc *pFwAcc = ptrFesRtu->m_pFwAcc + i; + if(pFwAcc->Used == 0) + { + continue; + } + + FesDebugToolDoublePntValue *pData = repMsg.add_double_values(); + pData->set_pnt_no(pFwAcc->RemoteNo); + pData->set_value(pFwAcc->Value); + pData->set_status(pFwAcc->Status); + pData->set_time(pFwAcc->time); + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSoeEventReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + SFesSimServerSoeEventBuf &soeBuf = m_pFesBase->m_FesSimSoeEventBuf; + soeBuf.RefreshFlag = 1; + + FesDebugToolSoeEventRepMsg repMsg; + repMsg.set_over_flow(soeBuf.Overflow); + soeBuf.Overflow = 0; + + int eventSize = (soeBuf.Writex + CN_FesSimSoeEventMaxBufSize - soeBuf.Readx) %CN_FesSimSoeEventMaxBufSize; + if(eventSize > 0) + { + repMsg.mutable_event()->Reserve(eventSize); + } + + while(soeBuf.Readx != soeBuf.Writex) + { + SFesSoeEvent &srcEvent = soeBuf.Event[soeBuf.Readx]; + FesDebugToolSoeEvent *pDstEvent = repMsg.add_event(); + pDstEvent->set_table_name(srcEvent.TableName); + pDstEvent->set_col_name(srcEvent.ColumnName); + pDstEvent->set_tag_name(srcEvent.TagName); + pDstEvent->set_status(srcEvent.Status); + pDstEvent->set_value(srcEvent.Value); + pDstEvent->set_time(srcEvent.time); + pDstEvent->set_fault_num(srcEvent.FaultNum); + + pDstEvent->mutable_fault_type()->Reserve(srcEvent.FaultNum); + pDstEvent->mutable_fault_value()->Reserve(srcEvent.FaultNum); + for(int i = 0; i < srcEvent.FaultNum; i++) + { + pDstEvent->add_fault_type(srcEvent.FaultValTag[i]); + pDstEvent->add_fault_value(srcEvent.FaultVal[i]); + } + + soeBuf.Readx = (soeBuf.Readx+1)%CN_FesSimSoeEventMaxBufSize; + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvChanEventReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + SFesSimServerChanEventBuf &chanBuf = m_pFesBase->m_FesSimChanEventBuf; + chanBuf.RefreshFlag = 1; + + FesDebugToolChanEventRepMsg repMsg; + repMsg.set_over_flow(chanBuf.Overflow); + chanBuf.Overflow = 0; + + int eventSize = (chanBuf.Writex + CN_FesSimChanEventMaxBufSize - chanBuf.Readx) %CN_FesSimChanEventMaxBufSize; + if(eventSize > 0) + { + repMsg.mutable_event()->Reserve(eventSize); + } + + while(chanBuf.Readx != chanBuf.Writex) + { + SFesChanEvent &srcEvent = chanBuf.Event[chanBuf.Readx]; + FesDebugToolChanEvent *pDstEvent = repMsg.add_event(); + pDstEvent->set_tag_name(srcEvent.ChanTagName); + pDstEvent->set_status(srcEvent.Status); + pDstEvent->set_err_rate(srcEvent.ErrRate); + pDstEvent->set_time(srcEvent.time); + + chanBuf.Readx = (chanBuf.Readx+1)%CN_FesSimChanEventMaxBufSize; + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvSoeMemEventReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + SFesSimServerSoeEventBuf &soeBuf = m_pFesBase->m_FesSimSoeEventBuf; + soeBuf.RefreshFlag = 1; + + FesDebugToolSoeEventRepMsg repMsg; + repMsg.set_over_flow(0); + repMsg.mutable_event()->Reserve(CN_FesSimSoeEventMaxBufSize); + + for(int i = 0; i < CN_FesSimSoeEventMaxBufSize; i++) + { + SFesSoeEvent &srcEvent = soeBuf.Event[i]; + if(srcEvent.time == 0 || strlen(srcEvent.TagName) == 0) + { + continue; + } + + FesDebugToolSoeEvent *pDstEvent = repMsg.add_event(); + pDstEvent->set_table_name(srcEvent.TableName); + pDstEvent->set_col_name(srcEvent.ColumnName); + pDstEvent->set_tag_name(srcEvent.TagName); + pDstEvent->set_status(srcEvent.Status); + pDstEvent->set_value(srcEvent.Value); + pDstEvent->set_time(srcEvent.time); + pDstEvent->set_fault_num(srcEvent.FaultNum); + + if(srcEvent.FaultNum <= 0) + { + continue; + } + + pDstEvent->mutable_fault_type()->Reserve(srcEvent.FaultNum); + pDstEvent->mutable_fault_value()->Reserve(srcEvent.FaultNum); + for(int i = 0; i < srcEvent.FaultNum; i++) + { + pDstEvent->add_fault_type(srcEvent.FaultValTag[i]); + pDstEvent->add_fault_value(srcEvent.FaultVal[i]); + } + } + + string *pStrMsg = new string; + repMsg.SerializeToString(pStrMsg); + + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvChanMonStartReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolChanMonCmdReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvChanMonStartReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + FesDebugToolChanMonCmdRepMsg repMsg; + repMsg.set_chan_no(reqMsg.chan_no()); + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); //响应Start请求 + + //先发送一次通道消息 + { + boost::mutex::scoped_lock lock(m_pFesBase->m_ChanMonMutex); + m_nCurMonChanNo = reqMsg.chan_no(); + m_pFesBase->SetMonChanNo(m_nCurMonChanNo); + + SFesSimServerChanMonBuf &chanBuf = m_pFesBase->m_FesSimChanMonBuf; + chanBuf.RefreshFlag = 1; + + string *pStrMsg = buildChanMonInfo(chanBuf); + chanBuf.Overflow = 0; + + objSendMsg.set_type(MT_FESDBG_Mon_ChanInfo); + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + } + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +void CDebugThread::onRecvChanMonStopReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolChanMonCmdReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvChanMonStopReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + m_nCurMonChanNo = -1; + m_pFesBase->SetMonChanNo(-1);//clear chanNo + { + boost::mutex::scoped_lock lock(m_pFesBase->m_ChanMonMutex);//加上锁。 + SFesSimServerChanMonBuf &chanBuf = m_pFesBase->m_FesSimChanMonBuf; + chanBuf.RefreshFlag = 0; + chanBuf.Readx = 0; + chanBuf.Writex = 0;//clear buffer + } + + FesDebugToolChanMonCmdRepMsg repMsg; + repMsg.set_chan_no(reqMsg.chan_no()); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); //响应Stop请求 +} + +void CDebugThread::onRecvChanMonClearReq(const FesDebugToolReqMsg &objRecvMsg) +{ + FesDebugToolRepMsg objSendMsg; + objSendMsg.set_type(objRecvMsg.type()); + + FesDebugToolChanMonCmdReqMsg reqMsg; + if(!reqMsg.ParseFromString(objRecvMsg.body())) + { + LOGERROR("CDebugThread:onRecvChanMonStopReq 反序列化失败"); + objSendMsg.set_success(false); + objSendMsg.set_body(""); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); + return; + } + + SFesChanStatistics statis; + m_pFesBase->ResetChanStatisticsByChanNo(reqMsg.chan_no()); + m_pFesBase->GetChanStatisticsByChanNo(reqMsg.chan_no(),&statis); + + FesDebugToolChanMonCmdRepMsg repMsg; + repMsg.set_chan_no(reqMsg.chan_no()); + repMsg.set_rx_num(statis.RxNum); + repMsg.set_tx_num(statis.TxNum); + repMsg.set_err_num(statis.ErrNum); + + objSendMsg.set_success(true); + objSendMsg.set_body(repMsg.SerializeAsString()); + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); //响应Stop请求 +} + +void CDebugThread::reportChanMonInfo() +{ + FesDebugToolRepMsg objSendMsg; + { + boost::mutex::scoped_lock lock(m_pFesBase->m_ChanMonMutex); + + SFesSimServerChanMonBuf &chanBuf = m_pFesBase->m_FesSimChanMonBuf; + if(chanBuf.Readx == chanBuf.Writex) + { + return; + } + + string *pStrMsg = buildChanMonInfo(chanBuf); + + objSendMsg.set_type(MT_FESDBG_Mon_ChanInfo); + objSendMsg.set_success(true); + objSendMsg.set_allocated_body(pStrMsg); + } + + m_objMbComm.sendMsg(objSendMsg.SerializeAsString()); +} + +std::string* CDebugThread::buildChanMonInfo(SFesSimServerChanMonBuf &chanBuf) +{ + SFesChanStatistics statis; + m_pFesBase->GetChanStatisticsByChanNo(m_nCurMonChanNo,&statis); + + FesDebugToolChanMonInfoMsg infoMsg; + infoMsg.set_chan_no(m_nCurMonChanNo); + infoMsg.set_rx_num(statis.RxNum); + infoMsg.set_tx_num(statis.TxNum); + infoMsg.set_err_num(statis.ErrNum); + infoMsg.set_over_flow(chanBuf.Overflow); + + int frameSize = (chanBuf.Writex + CN_FesSimChanMonMaxBufSize - chanBuf.Readx) %CN_FesSimChanMonMaxBufSize; + if(frameSize > 0) + { + infoMsg.mutable_frame()->Reserve(frameSize); + } + + while (chanBuf.Readx != chanBuf.Writex) + { + SFesChanFrame &srcFrame = chanBuf.Frame[chanBuf.Readx]; + FesDebugToolChanMonFrame *dstFrame = infoMsg.add_frame(); + dstFrame->set_frame_type(srcFrame.FrameType); + dstFrame->set_data_type(srcFrame.DataType); + dstFrame->set_time(srcFrame.Time); + dstFrame->set_data(srcFrame.Data,srcFrame.FrameLen); + + chanBuf.Readx = (chanBuf.Readx + 1)%CN_FesSimChanMonMaxBufSize; + } + + string *pStrMsg = new string; + infoMsg.SerializeToString(pStrMsg); + + return pStrMsg; +} diff --git a/product/src/fes/fes/DebugThread.h b/product/src/fes/fes/DebugThread.h new file mode 100644 index 00000000..6d265260 --- /dev/null +++ b/product/src/fes/fes/DebugThread.h @@ -0,0 +1,175 @@ +#ifndef DEBUGTHREAD_H +#define DEBUGTHREAD_H + +#include "pub_utility_api/TimerThreadBase.h" +#include "DebugMbCommunicator.h" +#include "FesDebugTool.pb.h" +#include "FesBase.h" + +class CDebugThread : public iot_public::CTimerThreadBase +{ +public: + CDebugThread(CFesBase *pFesBase); + virtual ~CDebugThread(); + + virtual void execute(); + + int init(const int &nPort); + +private: + //客户端断开后停止刷新数据 + void stopRefreshMonData(); + + void handleMessage(); + + void onRecvHeartbeatReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvConnectReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvDisconnectReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvChanParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvRtuParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvRtuInfoReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvAiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvAiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvDiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvDiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvAccParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvAccValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvMiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvMiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //模拟量仿真 + void onRecvSimAiStartSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimAiStopSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //数字量仿真 + void onRecvSimDiStartSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimDiStopSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //混合量仿真 + void onRecvSimMiStartSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimMiStopSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //累积量仿真 + void onRecvSimAccStartSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimAccStopSimReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //事件仿真 + void onRecvSimEventCreateReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //控制仿真 + void onRecvSimAoControlReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimDoControlReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSimMoControlReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //数据转发 + void onRecvFwRtuInfoReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwAiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwAiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvFwDiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwDiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvFwDDiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwDDiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvFwMiParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwMiValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + void onRecvFwAccParamReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvFwAccValueReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //事件监视 + void onRecvSoeEventReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvChanEventReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvSoeMemEventReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + + //通道监视 + void onRecvChanMonStartReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvChanMonStopReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void onRecvChanMonClearReq(const iot_idl::FesDebugToolReqMsg &objRecvMsg); + void reportChanMonInfo(); + std::string* buildChanMonInfo(SFesSimServerChanMonBuf &chanBuf); + + void simulate(); + void periodSimulate(); + + //单次模拟 + void oneTimeSimulate(); + void oneTimeSimulateAi(); + void oneTimeSimulateDi(); + void oneTimeSimulateMi(); + void oneTimeSimulateAcc(); + //周期性模拟 + void periodSimulateAi(); + void periodSimulateDi(); + void periodSimulateMi(); + void periodSimulateAcc(); + + float getAiSimValue(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateSingleAi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateRtuAi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateAllAi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + + int getDiSimValue(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateSingleDi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateRtuDi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateAllDi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + + int getMiSimValue(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateSingleMi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateRtuMi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateAllMi(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + + double getAccSimValue(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateSingleAcc(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateRtuAcc(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + void simulateAllAcc(const iot_idl::FesDebugToolValueSimSetReqMsg &simParam); + +private: + CDebugMbCommunicator m_objMbComm; + CFesBase* m_pFesBase; + + int64 m_lLastSimScanTime; //上一次执行仿真的时间，单位毫秒 + boost::mutex m_mutexSimParam; //保护仿真参数 + + //模拟量仿真相关参数 + bool m_bAiSimRunning; //模拟量正在仿真标识 + float m_fLastAiSimValue; //上一次仿真值，用于线性仿真中 + float m_fAiSimStepValue; //步进值 + int64 m_lAiLastSimTime; //最后一次仿真数据变化的时间，单位毫秒 + iot_idl::FesDebugToolValueSimSetReqMsg m_stAiSimParam; //模拟量仿真参数 + + //数字量仿真相关参数 + bool m_bDiSimRunning; //数字量正在仿真标识 + int m_nLastDiSimValue; //上一次仿真值，用于线性仿真中 +// int m_nDiSimStepValue; //步进值 + int64 m_lDiLastSimTime; //最后一次仿真数据变化的时间，单位毫秒 + iot_idl::FesDebugToolValueSimSetReqMsg m_stDiSimParam; //数字量仿真参数 + + //混合量仿真相关参数 + bool m_bMiSimRunning; //混合量正在仿真标识 + int m_nLastMiSimValue; //上一次仿真值，用于线性仿真中 + int m_nMiSimStepValue; //步进值 + int64 m_lMiLastSimTime; //最后一次仿真数据变化的时间，单位毫秒 + iot_idl::FesDebugToolValueSimSetReqMsg m_stMiSimParam; //混合量仿真参数 + + //累计量仿真相关参数 + bool m_bAccSimRunning; //累计量正在仿真标识 + double m_dLastAccSimValue; //上一次仿真值，用于线性仿真中 + double m_dAccSimStepValue; //步进值 + int64 m_lAccLastSimTime; //最后一次仿真数据变化的时间，单位毫秒 + iot_idl::FesDebugToolValueSimSetReqMsg m_stAccSimParam; //累计量仿真参数 + + //通道监视 + int m_nCurMonChanNo; //当前监视的通道 + int64 m_lLastHeartbeatTime; //最后一次心跳包时间 + bool m_bHasClient; //当前是否有客户端在连接 +}; + +typedef boost::shared_ptr CDebugThreadPtr; + +#endif // DEBUGTHREAD_H diff --git a/product/src/fes/fes/FesApp.cpp b/product/src/fes/fes/FesApp.cpp index bf2577ad..4d773e37 100644 --- a/product/src/fes/fes/FesApp.cpp +++ b/product/src/fes/fes/FesApp.cpp @@ -9,7 +9,6 @@ 2020-12-30 thxiao StopThread() 在调用m_ptrFesChanManageThread->quit()前，以最快速度通知规约退出 2021-12-02 thxiao 加载DLL的文件名改为绝对路径 2022-07-11 thxiao 修改实例的名字为"fes" - 2023-11-25 thxiao 转发数据处理改为分多个线程处理数据 */ //#include @@ -45,6 +44,7 @@ int g_FesChgAnaSendCyc=200; //变化数据发送周期 int g_FesChgAccSendCyc=300; //变化数据发送周期 int g_FesChgMixSendCyc=200; //变化数据发送周期 int g_FesEventSendCyc =500; //变化数据发送周期 +const int CN_FES_DebugPort_Offset = 100; //当前为了2种调试端口并存，增加一个偏移量 CFesApp::CFesApp() { @@ -52,13 +52,7 @@ CFesApp::CFesApp() m_ptrProcManage = NULL; m_ptrReduSwitchManage = NULL; m_ptrRedundantMng = NULL; - - m_ptrFesRxFesDataThread = NULL; - m_ptrFesRxDPDataThread = NULL; - m_ptrAnaWorkThread = NULL; - m_ptrDigWorkThread = NULL; - m_ptrAccWorkThread = NULL; - m_ptrMixWorkThread = NULL; + m_ptrFesSimServerThread = NULL; } CFesApp::~CFesApp() @@ -241,27 +235,14 @@ bool CFesApp::start(int argc, char *argv[], int &/*nStatus*/) Param.ptrFesFwTxControlCmdThread = m_ptrFesFwTxControlCmdThread; if (m_CFesBase.FesRxFesDataThreadFlag) - { Param.ptrFesRxFesDataThread = m_ptrFesRxFesDataThread; - Param.ptrAnaWorkThread = m_ptrAnaWorkThread; - Param.ptrDigWorkThread = m_ptrDigWorkThread; - Param.ptrAccWorkThread = m_ptrAccWorkThread; - Param.ptrMixWorkThread = m_ptrMixWorkThread; - } else - { Param.ptrFesRxFesDataThread = NULL; - Param.ptrAnaWorkThread = NULL; - Param.ptrDigWorkThread = NULL; - Param.ptrAccWorkThread = NULL; - Param.ptrMixWorkThread = NULL; - } + if (m_CFesBase.FesRxDPDataThreadFlag) Param.ptrFesRxDPDataThread = m_ptrFesRxDPDataThread; else Param.ptrFesRxDPDataThread = NULL; - - /******转发相关线程*************************************************/ m_ptrReduSwitchManage->Init(Param); @@ -421,12 +402,25 @@ bool CFesApp::InitThread() return false; } + /* 使用CDebugThread替代CFesSimServerThread，停止使用旧的调试类 m_ptrFesSimServerThread = boost::make_shared(&m_CFesBase); if (m_ptrFesSimServerThread == NULL) { LOGERROR("m_ptrFesSimServerThread 创建失败"); return false; } + LOGINFO("FesSimServerThread AppName=%s AppId=%d NetPortNo=%d",m_strAppLabel.c_str(),m_ProcessInfo.nAppId,FesSimServerPortNo); + m_ptrFesSimServerThread->Init(FesSimServerPortNo,CN_FesServerMaxConnects);//Init Server net PortNo + */ + + int FesSimServerPortNo = CN_FesSimServerBasePortNo+m_ProcessInfo.nAppId; + + m_ptrDebugThread = boost::make_shared(&m_CFesBase); + if(m_ptrDebugThread == NULL) + { + LOGERROR("m_ptrDebugThread 创建失败"); + return false; + } m_ptrFesFwRxControlCmdThread = boost::make_shared(m_ProcessInfo.nDomainId, m_ProcessInfo.nAppId,&m_CFesBase); if (m_ptrFesFwRxControlCmdThread == NULL) @@ -442,101 +436,30 @@ bool CFesApp::InitThread() return false; } - if(m_CFesBase.FesRxFesDataThreadFlag) + m_ptrFesRxFesDataThread = boost::make_shared(m_ProcessInfo.nDomainId, m_ProcessInfo.nAppId,&m_CFesBase); + if (m_ptrFesRxFesDataThread == NULL) { - - //创建数据接收缓冲； - //============================================================================================== - m_ptrPacketQueue = boost::make_shared(); - if (m_ptrPacketQueue == NULL) - { - LOGERROR("CPacketQueue::initialize(), make_shared fail!\n"); - return false; - } - - m_ptrFesRxFesDataThread = boost::make_shared(m_ProcessInfo.nDomainId, m_ProcessInfo.nAppId, &m_CFesBase, m_ptrPacketQueue); - if (m_ptrFesRxFesDataThread == NULL) - { - LOGERROR("m_ptrFesRxFesDataThread 创建失败"); - return false; - } - - //初始化模拟量数据处理线程 - //============================================================================================== - m_ptrAnaWorkThread = boost::make_shared(&m_CFesBase, m_ptrPacketQueue); - if (m_ptrAnaWorkThread == NULL) - { - LOGERROR("m_ptrAnaWorkThread,创建模拟量工作线程失败!"); - return false; - } - if (false == m_ptrAnaWorkThread->initialize()) - { - LOGERROR("初始化模拟量工作线程失败!"); - return false; - } - - //初始化数字量数据处理线程 - //============================================================================================== - m_ptrDigWorkThread = boost::make_shared(&m_CFesBase, m_ptrPacketQueue); - if (m_ptrDigWorkThread == NULL) - { - LOGERROR("m_ptrDigWorkThread,创建数字量工作线程失败!"); - return false; - } - if (false == m_ptrDigWorkThread->initialize()) - { - LOGERROR("初始化数字量工作线程失败!"); - return false; - } - - //初始化累计量数据处理线程 - //============================================================================================== - m_ptrAccWorkThread = boost::make_shared(&m_CFesBase, m_ptrPacketQueue); - if (m_ptrAccWorkThread == NULL) - { - LOGERROR("m_ptrAnaWorkThread,创建累计量工作线程失败!"); - return false; - } - if (false == m_ptrAccWorkThread->initialize()) - { - LOGERROR("初始化累计量工作线程失败!"); - return false; - } - - //初始化混合量数据处理线程 - //============================================================================================== - m_ptrMixWorkThread = boost::make_shared(&m_CFesBase, m_ptrPacketQueue); - if (m_ptrMixWorkThread == NULL) - { - LOGERROR("m_ptrMixWorkThread,创建混合量工作线程失败!"); - return false; - } - if (false == m_ptrMixWorkThread->initialize()) - { - LOGERROR("初始化混合量工作线程失败!"); - return false; - } + LOGERROR("m_ptrFesRxFesDataThread 创建失败"); + return false; } - if (m_CFesBase.FesRxDPDataThreadFlag) + m_ptrFesRxDPDataThread = boost::make_shared(m_ProcessInfo.nDomainId, m_ProcessInfo.nAppId,&m_CFesBase); + if (m_ptrFesRxDPDataThread == NULL) { - m_ptrFesRxDPDataThread = boost::make_shared(m_ProcessInfo.nDomainId, m_ProcessInfo.nAppId, &m_CFesBase); - if (m_ptrFesRxDPDataThread == NULL) - { - LOGERROR("m_ptrFesRxDPDataThread 创建失败"); - return false; - } - if (m_ptrFesRxDPDataThread->initialize() == iotFailed) - { - LOGERROR("m_ptrFesRxDPDataThread ::initialize() fail!\n"); - return false; - } + LOGERROR("m_ptrFesRxDPDataThread 创建失败"); + return false; + } + if (m_ptrFesRxDPDataThread->initialize() == iotFailed) + { + LOGERROR("m_ptrFesRxDPDataThread ::initialize() fail!\n"); + return false; } - int FesSimServerPortNo = CN_FesSimServerBasePortNo+m_ProcessInfo.nAppId; - LOGINFO("FesSimServerThread AppName=%s AppId=%d NetPortNo=%d",m_strAppLabel.c_str(),m_ProcessInfo.nAppId,FesSimServerPortNo); - m_ptrFesSimServerThread->Init(FesSimServerPortNo,CN_FesServerMaxConnects);//Init Server net PortNo - // m_ptrFesSimServerThread->resume(); + if(m_ptrDebugThread->init(FesSimServerPortNo + CN_FES_DebugPort_Offset) != iotSuccess) + { + LOGERROR("m_ptrDebugThread initialize fail"); + return false; + } LOGINFO("InitThread() 创建成功！"); @@ -608,6 +531,13 @@ void CFesApp::StopThread() LOGDEBUG("CFesApp::StopThread m_ptrFesSimServerThread stop ok"); } + if(m_ptrDebugThread != NULL) + { + m_ptrDebugThread->quit(); + m_ptrDebugThread.reset(); + LOGDEBUG("CFesApp::StopThread m_ptrDebugThread stop ok"); + } + if (m_ptrFesFwRxControlCmdThread != NULL) { m_ptrFesFwRxControlCmdThread->quit(); @@ -644,31 +574,6 @@ void CFesApp::StopThread() m_ptrAlmApiForApp = NULL; LOGINFO("CFesApp::StopThread()：释放报警处理工作线程成功! \n"); } - - if (m_ptrAnaWorkThread != NULL) - { - m_ptrAnaWorkThread->quit(); - m_ptrAnaWorkThread.reset(); - LOGDEBUG("CFesApp::StopThread m_ptrAnaWorkThread stop ok"); - } - if (m_ptrDigWorkThread != NULL) - { - m_ptrDigWorkThread->quit(); - m_ptrDigWorkThread.reset(); - LOGDEBUG("CFesApp::StopThread m_ptrDigWorkThread stop ok"); - } - if (m_ptrAccWorkThread != NULL) - { - m_ptrAccWorkThread->quit(); - m_ptrAccWorkThread.reset(); - LOGDEBUG("CFesApp::StopThread m_ptrAccWorkThread stop ok"); - } - if (m_ptrMixWorkThread != NULL) - { - m_ptrMixWorkThread->quit(); - m_ptrMixWorkThread.reset(); - LOGDEBUG("CFesApp::StopThread m_ptrMixWorkThread stop ok"); - } } diff --git a/product/src/fes/fes/FesApp.h b/product/src/fes/fes/FesApp.h index 8e080b37..af11309c 100644 --- a/product/src/fes/fes/FesApp.h +++ b/product/src/fes/fes/FesApp.h @@ -14,19 +14,13 @@ #include "FesDataSyncThread.h" #include "FesChanManageThread.h" #include "FesRedundantManage.h" +#include "DebugThread.h" #include "FesSimServerThread.h" #include "FesWaveFormThread.h" #include "FesFwRxControlCmdThread.h" #include "FesFwTxControlCmdThread.h" #include "FesRxFesDataThread.h" #include "FesRxDPDataThread.h" -#include "PacketQueue.h" -#include "AnaWorkThread.h" -#include "DigWorkThread.h" -#include "AccWorkThread.h" -#include "MixWorkThread.h" - - class CFesApp:public iot_public::CBaseService,iot_sys::CProcessQuitInterface { @@ -35,7 +29,6 @@ public: ~CFesApp(); CFesBase m_CFesBase; - CPacketQueuePtr m_ptrPacketQueue; //消息缓存类 /* @brief 解析命令行参数 CMsgQueueBuffer; @@ -85,16 +78,12 @@ private: CFesDataSyncThreadPtr m_PtrFesDataSyncThread; CFesChanManageThreadPtr m_ptrFesChanManageThread; CFesSimServerThreadPtr m_ptrFesSimServerThread; + CDebugThreadPtr m_ptrDebugThread; CFesWaveFormThreadPtr m_ptrFesWaveFormThread; CFesFwRxControlCmdThreadPtr m_ptrFesFwRxControlCmdThread; CFesFwTxControlCmdThreadPtr m_ptrFesFwTxControlCmdThread; CFesRxFesDataThreadPtr m_ptrFesRxFesDataThread; CFesRxDPDataThreadPtr m_ptrFesRxDPDataThread; - CAnaWorkThreadPtr m_ptrAnaWorkThread; - CDigWorkThreadPtr m_ptrDigWorkThread; - CAccWorkThreadPtr m_ptrAccWorkThread; - CMixWorkThreadPtr m_ptrMixWorkThread; - /** * @brief CFesApp::InitThread diff --git a/product/src/fes/fes/FesBase.cpp b/product/src/fes/fes/FesBase.cpp index d82cd45d..2d573cb1 100644 --- a/product/src/fes/fes/FesBase.cpp +++ b/product/src/fes/fes/FesBase.cpp @@ -1,5165 +1,5196 @@ -/*FwSoeEventBuf overflow - @file fesbase.cpp - @brief fes基础类 - @author thxiao - @history - 2019-06-05 thxiao SFesRtuParam 增加车站描述，方便保存录波按“车站\设备”保存 - 2019-06-14 thxiao CRdbAccessEx selectOneOrder()默认方式由倒序变为顺序，所有有关实时库的读取方式全变了，使用默认方式。 - 2019-08-23 thxiao 通用配置的文本定义不应该叫“SOE故障相”，应该叫“保护故障”。 - 2019-08-30 thxiao InitBaseData() 增加AI转换后的突变比较范围. - 2019-10-18 thxiao 增加读取RTU保留参数及定值配置。 - 2020-01-05 thxaio - 1、RtuPtr->m_Param.LocationDesc,pDevParam->DevDesc,去掉空格 - 2、InitBaseData() 读取条件由"rtu_no"变为"rtu_tag",但BLOCK除外 - 2020-02-27 thxiao WriteRtuSatus()增加通信状态点 - 2020-03-12 thxiao 配置增加录波使能 - 2020-03-24 thxiao 为测试增加m_SoeCount、m_DiChgCount参数。 - 2020-05-06 thxiao 操作串口监视缓冲区时增加锁，保护读取的数据不受到破坏。 - 2020-05-21 thxiao 增加SetOfflineFlag(),实现串口通信异常时能够重新打开串口。 - 2020-06-01 thxiao - 1、InitProtocolPointMapping()当规约参数1为负数时处理不能越限。 - 2、当通信状态为1后，才开始判断通信状态发生变化 - 3、不再报告RTU事件 - 2020-08-18 thxiao 通信中断的延时判断时间最小值为5S - 2020-09-10 thxiao InitBaseData() 点初始状态为通信中断. - 2020-12-17 thxiao AI,DI,ACC,MI增加DevId - 2021-03-04 thxiao DO AO MO DZ增加DevId - 2021-04-28 thxiao - 1、InitBaseData()读取数据块配置“自定义参数"有问题 - 2、InitProtocolPointMapping() 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - 2021-06-04 thxiao 增加通道事件队列的读写操作 - 2021-08-04 thxiao InitProtocolPointMapping() SFesXXIndex增加Param5\Param6 - 2021-08-12 thxiao 删除部分LOG - 2021-11-05 thxiao InitBaseData() 在某种情况下，配置通道接收发送缓冲区会被清零，导致FES异常。避免这种情况给配置赋非零最小值。 - 2021-12-01 thxiao InitBaseData() 备用通道配置中遇到第一个“-1”,则认为以下的备用通道都无效 - 2021-12-02 thxiao 与规约名称相关的函数，不再区分WIN和LINUX - 2022-04-14 thxiao 所有转发RTU映射表初始化。增加“所有数据转发”通道类型；不需要配置转发点，所有的数据自动转发。 - 2022-06-08 thxiao 删除2022-04-14“所有数据转发”通道类型相关处理。改为使用配置，调用SetFwDiData()来初始化转发DI。 - 2022-06-16 thxiao 增加DI SOE的LOG信息 - 2022-09-06 thxiao 自动分配块序号,供MODBUSTCPV3内部使用 - 2022-10-13 thxiao 2022-09-06修改不完善，需要考虑同一通道下所有RTU块序号统一排列序号。 - 2022-10-24 thxiao 读取ACC配置的顺序错了，改正。原程序不影响外部的程序。 - - */ -#include -#include "FesBase.h" -#include "dbms/rdb_api/CRdbAccessEx.h" -#include "dbms/rdb_api/CRdbAccess.h" -#include "pub_logger_api/logger.h" - -#include "FesForwardConfig.h" - -using namespace std; -using namespace iot_public; -using namespace iot_dbms; - -CFesBase::CFesBase() -{ - int i; - - m_LocationNum = 0; - m_gOfflineTimeReset = 0; - m_gSetTimeReset = 0; - m_gPollWaveTimeReset = 0; - m_gOfflineCountReset = 0; - m_RtuNum = 0; - m_ChanNum = 0; - m_MonChanNo = -1; - m_ptrProtocolBaseDll = NULL; - m_ProtocolNum = 0; - forwarding = new CFesForwarding; - - for(i=0;i condInfo; - std::vector VecFaultCode; - std::vector vecFaultColumn; - - //2019-08-23 thxiao 通用配置的文本定义不应该叫“SOE故障相”，应该叫“保护故障” - iot_dbms::CRdbPublic::addCondInfo(condInfo,"class_name","保护故障"); - vecFaultColumn.push_back("actual_value"); - vecFaultColumn.push_back("display_name"); - - ret = RdbFaultCodeTable.selectAllVec(condInfo,VecFaultCode,vecFaultColumn); - if (ret==false) - { - RdbFaultCodeTable.close(); - LOGERROR("CFesBase::InitBaseData, dict_text_define.selectNoCondition error!"); - return iotFailed; - } - for(i=0;i<(int)VecFaultCode.size();i++) - { - mapFaultCode.insert(pair(VecFaultCode[i].nFaultCode,VecFaultCode[i].FaultName)); - } - RdbFaultCodeTable.close(); - - //读取实时库LOCATION配置 - ret = RdbLocationTable.open(m_strAppLabel.c_str(),RT_FES_LOCATION_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbocationTable::Open error"); - return iotFailed; - } - std::vector VecLocationParam; - std::vector vecLocationColumn; - vecLocationColumn.push_back("location_id"); - vecLocationColumn.push_back("description"); - ret = RdbLocationTable.selectNoCondition(VecLocationParam, vecLocationColumn, "location_id");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbLocationTable.selectNoCondition error!"); - return iotFailed; - } - m_LocationNum = VecLocationParam.size(); - if(m_LocationNum>0) - { - for(i=0;i VecRtuParam; - std::vector vecColumn; - vecColumn.push_back("rtu_no"); - vecColumn.push_back("tag_name"); - vecColumn.push_back("rtu_name"); - vecColumn.push_back("description"); - vecColumn.push_back("location_id"); - vecColumn.push_back("sub_system"); - vecColumn.push_back("is_used"); - vecColumn.push_back("rtu_addr"); - vecColumn.push_back("chan_no"); - vecColumn.push_back("recv_fail_num"); - vecColumn.push_back("alarm_enable"); - vecColumn.push_back("res_para_int1"); - vecColumn.push_back("res_para_int2"); - vecColumn.push_back("res_para_int3"); - vecColumn.push_back("res_para_str1"); - vecColumn.push_back("is_used_lb"); - vecColumn.push_back("controldisable"); - vecColumn.push_back("cleardataenable"); - - ret = RdbRtuTable.selectNoCondition(VecRtuParam, vecColumn, "rtu_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbRtuTable.selectNoCondition error!"); - return iotFailed; - } - m_RtuNum = VecRtuParam.size(); - if(m_RtuNum>0) - { - for(i=0;i(); - if (RtuPtr == NULL) - { - LOGERROR("fesbase.cpp RtuIndex:%d CFesRtuPtr create failed.\n",i); - continue; - } - RtuPtr->m_Param.RtuNo = VecRtuParam[i].RtuNo; - strcpy(RtuPtr->m_Param.TagName,VecRtuParam[i].TagName); - strcpy(RtuPtr->m_Param.RtuName,VecRtuParam[i].RtuName); - strcpy(RtuPtr->m_Param.RtuDesc,VecRtuParam[i].RtuDesc); - RtuPtr->m_Param.nLocationId =VecRtuParam[i].nLocationId; - RtuPtr->m_Param.nSubSystem =VecRtuParam[i].nSubSystem; - RtuPtr->m_Param.Used =VecRtuParam[i].Used; - RtuPtr->m_Param.RtuAddr=VecRtuParam[i].RtuAddr; - RtuPtr->m_Param.ChanNo = VecRtuParam[i].ChanNo; - RtuPtr->m_Param.RecvFailLimit = VecRtuParam[i].RecvFailLimit; - RtuPtr->m_Param.AlarmEnable = VecRtuParam[i].AlarmEnable; - RtuPtr->m_Param.ResParam1 = VecRtuParam[i].ResParam1; - RtuPtr->m_Param.ResParam2 = VecRtuParam[i].ResParam2; - RtuPtr->m_Param.ResParam3 = VecRtuParam[i].ResParam3; - memcpy(RtuPtr->m_Param.DevType,VecRtuParam[i].DevType,CN_FesMaxTagSize); - RtuPtr->m_Param.WaveEnable = VecRtuParam[i].WaveEnable; - RtuPtr->m_Param.ControlDisable = VecRtuParam[i].ControlDisable; - RtuPtr->m_Param.ClearDataEnable = VecRtuParam[i].ClearDataEnable; - RtuPtr->m_CurrentChanNo = VecRtuParam[i].ChanNo; - RtuPtr->m_RtuIndex=i; - - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - //con.conditionval = RtuPtr->m_Param.RtuNo; - //strcpy(con.name, "rtu_no"); - //2020-01-06 thxiao 使用rtu_tag更为可靠 - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - - //读取DEV INFO - std::vector VecDevInfo; - std::vector vecDevInfoColumn; - vecDevInfoColumn.push_back("rtu_no");//RTUNO - vecDevInfoColumn.push_back("dev_id");//DEVID - vecDevInfoColumn.push_back("dev_desc"); //DEV DESC - vecDevInfoColumn.push_back("tag_name"); //DEV tagname - ret = RdbDevInfoTable.open(m_strAppLabel.c_str(), RT_FES_DEV_INFO_TBL); - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData,RdbDevInfoTable::Open error"); - return iotFailed; - } - ret = RdbDevInfoTable.selectOneOrder(con, VecDevInfo, vecDevInfoColumn, "rtu_no");//默认顺序 - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData, RdbDevInfoTable.selectOneCondition error!"); - return iotFailed; - } - RtuPtr->m_DevInfo.RtuNo = RtuPtr->m_Param.RtuNo; - if (VecDevInfo.size() > 0) - { - RtuPtr->m_DevInfo.DevNum = VecDevInfo.size(); - RtuPtr->m_DevInfo.pDev = (SFesRtuDevParam*)malloc(RtuPtr->m_DevInfo.DevNum * sizeof(SFesRtuDevParam)); - if (RtuPtr->m_DevInfo.pDev == NULL) - { - RtuPtr->m_DevInfo.DevNum = 0; - } - else - { - memset(RtuPtr->m_DevInfo.pDev, 0, RtuPtr->m_DevInfo.DevNum * sizeof(SFesRtuDevParam)); - SFesRtuDevParam *pDevParam; - for (j = 0; j < RtuPtr->m_DevInfo.DevNum; j++) - { - pDevParam = RtuPtr->m_DevInfo.pDev + j; - pDevParam->DevId = VecDevInfo[j].DevID; - memcpy(pDevParam->TagName, VecDevInfo[j].TagName, CN_FesMaxTagSize); - memcpy(pDevParam->DevDesc, VecDevInfo[j].DevDesc, CN_FesMaxNameSize); - //把描述中的“.”更换成“_”。 - char *pChar; - pChar = strchr(pDevParam->DevDesc, '.'); - while (pChar != NULL) - { - *pChar = '_'; - pChar = strchr(pDevParam->DevDesc, '.'); - } - - //2020-01-05 把右边空格去掉 - //LOGDEBUG("1 pDevParam->DevDesc=%s!!!!!!", pDevParam->DevDesc); - int len = strlen(pDevParam->DevDesc); - char *p = pDevParam->DevDesc + len - 1; - while ((p >= pDevParam->DevDesc) && (*p == ' ')) - { - *p = '\0'; --p; - } - //LOGDEBUG("2 pDevParam->DevDesc=%s!!!!!!", pDevParam->DevDesc); - - } - } - } - ret = RdbDevInfoTable.close(); - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData,RdbDevInfoTable::close error"); - return iotFailed; - } - - - //READ AI TABLE - std::vector VecAiParam; - std::vector vecAiColumn; - - vecAiColumn.push_back("rtu_no"); - vecAiColumn.push_back("dot_no"); - vecAiColumn.push_back("app_table_name"); - vecAiColumn.push_back("app_column_name"); - vecAiColumn.push_back("app_tag_name"); - vecAiColumn.push_back("tag_name"); - vecAiColumn.push_back("description"); - vecAiColumn.push_back("dev_tag"); - vecAiColumn.push_back("is_filter"); - vecAiColumn.push_back("percent"); - vecAiColumn.push_back("deadband_type"); - vecAiColumn.push_back("deadband"); - vecAiColumn.push_back("zeroband"); - vecAiColumn.push_back("base"); - vecAiColumn.push_back("coeff"); - vecAiColumn.push_back("max_range"); - vecAiColumn.push_back("min_range"); - vecAiColumn.push_back("res_para_int1"); - vecAiColumn.push_back("res_para_int2"); - vecAiColumn.push_back("res_para_int3"); - vecAiColumn.push_back("res_para_int4"); - vecAiColumn.push_back("res_para_int5"); - vecAiColumn.push_back("res_para_int6"); - vecAiColumn.push_back("res_para_int7"); - vecAiColumn.push_back("res_para_int8"); - - ret = RdbAiTable.open(m_strAppLabel.c_str(),RT_FES_AI_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAiTable::Open error"); - return iotFailed; - } - ret = RdbAiTable.selectOneOrder(con,VecAiParam,vecAiColumn,"dot_no");//默认顺序 - //LOGDEBUG("vecAiColumn.size:%d %d",vecAiColumn.size(),ret); - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbAiTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxAiPoints = 0; - count = VecAiParam.size(); - //LOGDEBUG("RTU%d VecAiParam.size():%d",RtuPtr->m_Param.RtuNo,count); - if(count>0) - { - RtuPtr->m_MaxAiPoints = VecAiParam[count-1].PointNo+1; - if (RtuPtr->m_MaxAiPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pAi = (SFesAi*)malloc(RtuPtr->m_MaxAiPoints * sizeof(SFesAi)); - if (RtuPtr->m_pAi != NULL) - { - memset(RtuPtr->m_pAi, 0, RtuPtr->m_MaxAiPoints * sizeof(SFesAi)); - for (j = 0; j < count; j++) - { - if ((VecAiParam[j].PointNo>=0)&&(VecAiParam[j].PointNo < RtuPtr->m_MaxAiPoints)) - { - pAi = RtuPtr->m_pAi + VecAiParam[j].PointNo; - pAi->PointNo = VecAiParam[j].PointNo; - strcpy(pAi->TableName, VecAiParam[j].TableName); - strcpy(pAi->ColumnName, VecAiParam[j].ColumnName); - strcpy(pAi->TagName, VecAiParam[j].TagName); - strcpy(pAi->PointTagName, VecAiParam[j].PointTagName); - strcpy(pAi->PointDesc, VecAiParam[j].PointDesc); - pAi->DevId = GetDevIdByDevTag(RtuPtr,VecAiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId - pAi->IsFilter = VecAiParam[j].IsFilter; - pAi->Percent = VecAiParam[j].Percent; - pAi->DeadBandType = VecAiParam[j].DeadBandType; - pAi->DeadBand = (float)VecAiParam[j].DeadBand; - pAi->ZeroBand = (float)VecAiParam[j].ZeroBand; - - if (pAi->ZeroBand > CN_FesFloatCompare) - pAi->IsZeroBand = 1; - else - pAi->IsZeroBand = 0; - - pAi->Base = (float)VecAiParam[j].Base; - pAi->Coeff = (float)VecAiParam[j].Coeff; - pAi->MaxRange = (float)VecAiParam[j].MaxRange; - pAi->MinRange = (float)VecAiParam[j].MinRange; - //2019-08-30 thxiao 增加转换后的突变比较范围 - if (pAi->IsFilter) - { - if (pAi->Percent == 0) - pAi->IsFilter = 0;//值为0，不做突变处理 - else - { - pAi->fPercentValue = (pAi->MaxRange - pAi->MinRange)*pAi->Percent; - pAi->fPercentValue = pAi->fPercentValue / 100; - } - } - pAi->Param1 = VecAiParam[j].Param1; - pAi->Param2 = VecAiParam[j].Param2; - pAi->Param3 = VecAiParam[j].Param3; - pAi->Param4 = VecAiParam[j].Param4; - pAi->Param5 = VecAiParam[j].Param5; - pAi->Param6 = VecAiParam[j].Param6; - pAi->Param7 = VecAiParam[j].Param7; - pAi->Param8 = VecAiParam[j].Param8; - - pAi->JudgeFlag = CN_SFesAiJudge_Limit | CN_SFesAiJudge_Deadband; - if (pAi->DeadBandType == CN_FesDeadbandType_Percent) - { - if (pAi->MaxRange - pAi->MinRange > CN_FesFloatCompare) - pAi->DeadBandValue = (pAi->MaxRange - pAi->MinRange)*pAi->DeadBand / 100; - else - { - pAi->DeadBandValue = 0.0; - pAi->JudgeFlag &= ~CN_SFesAiJudge_Limit; - } - } - else - pAi->DeadBandValue = pAi->DeadBand; - - if (pAi->DeadBandValue == 0.0) - pAi->JudgeFlag &= ~CN_SFesAiJudge_Deadband; - pAi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 - pAi->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Ai PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAiParam[j].PointNo, RtuPtr->m_MaxAiPoints); - } - } - } - else - { - RtuPtr->m_MaxAiPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pAi create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - ret = RdbAiTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAiTable::close error"); - return iotFailed; - } - - //READ DI TABLE - std::vector VecDiParam; - std::vector vecDiColumn; - vecDiColumn.push_back("rtu_no"); - vecDiColumn.push_back("dot_no"); - vecDiColumn.push_back("app_table_name"); - vecDiColumn.push_back("app_column_name"); - vecDiColumn.push_back("app_tag_name"); - vecDiColumn.push_back("tag_name"); - vecDiColumn.push_back("description"); - vecDiColumn.push_back("dev_tag"); - vecDiColumn.push_back("filter_err"); - vecDiColumn.push_back("filter_disturb"); - vecDiColumn.push_back("disturb_time"); - vecDiColumn.push_back("revers"); - vecDiColumn.push_back("res_para_int1"); - vecDiColumn.push_back("res_para_int2"); - vecDiColumn.push_back("res_para_int3"); - vecDiColumn.push_back("res_para_int4"); - vecDiColumn.push_back("res_para_int5"); - vecDiColumn.push_back("res_para_int6"); - vecDiColumn.push_back("res_para_int7"); - vecDiColumn.push_back("res_para_int8"); - vecDiColumn.push_back("attr"); - vecDiColumn.push_back("ass_dig"); - ret = RdbDiTable.open(m_strAppLabel.c_str(), RT_FES_DI_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDiTable::Open error"); - return iotFailed; - } - ret = RdbDiTable.selectOneOrder(con,VecDiParam, vecDiColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbDiTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxDiPoints = 0; - count = VecDiParam.size(); - //LOGDEBUG("RTU%d VecDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); - if (count > 0) - { - RtuPtr->m_MaxDiPoints = VecDiParam[count - 1].PointNo + 1; - if (RtuPtr->m_MaxDiPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pDi = (SFesDi*)malloc(RtuPtr->m_MaxDiPoints * sizeof(SFesDi)); - if (RtuPtr->m_pDi != NULL) - { - memset(RtuPtr->m_pDi, 0, RtuPtr->m_MaxDiPoints * sizeof(SFesDi)); - for (j = 0; j < count; j++) - { - if ((VecDiParam[j].PointNo>=0)&&(VecDiParam[j].PointNo < RtuPtr->m_MaxDiPoints)) - { - pDi = RtuPtr->m_pDi + VecDiParam[j].PointNo; - pDi->PointNo = VecDiParam[j].PointNo; - strcpy(pDi->TableName, VecDiParam[j].TableName); - strcpy(pDi->ColumnName, VecDiParam[j].ColumnName); - strcpy(pDi->TagName, VecDiParam[j].TagName); - strcpy(pDi->PointTagName, VecDiParam[j].PointTagName); - strcpy(pDi->PointDesc, VecDiParam[j].PointDesc); - pDi->DevId = GetDevIdByDevTag(RtuPtr, VecDiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId - pDi->IsFilterErr = VecDiParam[j].IsFilterErr; - pDi->IsFilterDisturb = VecDiParam[j].IsFilterDisturb; - pDi->DisturbTime = VecDiParam[j].DisturbTime; - pDi->Revers = VecDiParam[j].Revers; - pDi->Param1 = VecDiParam[j].Param1; - pDi->Param2 = VecDiParam[j].Param2; - pDi->Param3 = VecDiParam[j].Param3; - pDi->Param4 = VecDiParam[j].Param4; - pDi->Param5 = VecDiParam[j].Param5; - pDi->Param6 = VecDiParam[j].Param6; - pDi->Param7 = VecDiParam[j].Param7; - pDi->Param8 = VecDiParam[j].Param8; - pDi->Attribute = VecDiParam[j].Attribute; - pDi->RelateDI = VecDiParam[j].RelateDI; - pDi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 - pDi->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Di PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDiParam[j].PointNo, RtuPtr->m_MaxDiPoints); - } - } - } - else - { - RtuPtr->m_MaxDiPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pDi create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbDiTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDiTable::Open error"); - return iotFailed; - } - - - //READ ACC TABLE - std::vector VecAccParam; - std::vector vecAccColumn; - vecAccColumn.push_back("rtu_no"); - vecAccColumn.push_back("dot_no"); - vecAccColumn.push_back("app_table_name"); - vecAccColumn.push_back("app_column_name"); - vecAccColumn.push_back("app_tag_name"); - vecAccColumn.push_back("tag_name"); - vecAccColumn.push_back("description"); - vecAccColumn.push_back("dev_tag");//2022-10-24 thxiao 读取ACC配置的顺序错了，改正。原程序不影响外部的程序 - vecAccColumn.push_back("base"); - vecAccColumn.push_back("coeff"); - vecAccColumn.push_back("res_para_int1"); - vecAccColumn.push_back("res_para_int2"); - vecAccColumn.push_back("res_para_int3"); - vecAccColumn.push_back("res_para_int4"); - vecAccColumn.push_back("res_para_int5"); - vecAccColumn.push_back("res_para_int6"); - vecAccColumn.push_back("res_para_int7"); - vecAccColumn.push_back("res_para_int8"); - ret = RdbAccTable.open(m_strAppLabel.c_str(), RT_FES_ACC_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAccTable::Open error"); - return iotFailed; - } - ret = RdbAccTable.selectOneOrder(con,VecAccParam, vecAccColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbAccTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxAccPoints = 0; - count = VecAccParam.size(); - if(count>0) - { - RtuPtr->m_MaxAccPoints = VecAccParam[count-1].PointNo+1; - if (RtuPtr->m_MaxAccPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pAcc = (SFesAcc*)malloc(RtuPtr->m_MaxAccPoints * sizeof(SFesAcc)); - if (RtuPtr->m_pAcc != NULL) - { - memset(RtuPtr->m_pAcc, 0, RtuPtr->m_MaxAccPoints * sizeof(SFesAcc)); - for (j = 0; j < count; j++) - { - if ((VecAccParam[j].PointNo>=0)&&(VecAccParam[j].PointNo < RtuPtr->m_MaxAccPoints)) - { - pAcc = RtuPtr->m_pAcc + VecAccParam[j].PointNo; - pAcc->PointNo = VecAccParam[j].PointNo; - strcpy(pAcc->TableName, VecAccParam[j].TableName); - strcpy(pAcc->ColumnName, VecAccParam[j].ColumnName); - strcpy(pAcc->TagName, VecAccParam[j].TagName); - strcpy(pAcc->PointTagName, VecAccParam[j].PointTagName); - strcpy(pAcc->PointDesc, VecAccParam[j].PointDesc); - pAcc->DevId = GetDevIdByDevTag(RtuPtr, VecAccParam[j].DevTagName);//2020-12-17 thxiao 增加DevId - pAcc->Base = (float)VecAccParam[j].Base; - pAcc->Coeff = (float)VecAccParam[j].Coeff; - pAcc->Param1 = VecAccParam[j].Param1; - pAcc->Param2 = VecAccParam[j].Param2; - pAcc->Param3 = VecAccParam[j].Param3; - pAcc->Param4 = VecAccParam[j].Param4; - pAcc->Param5 = VecAccParam[j].Param5; - pAcc->Param6 = VecAccParam[j].Param6; - pAcc->Param7 = VecAccParam[j].Param7; - pAcc->Param8 = VecAccParam[j].Param8; - pAcc->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 - pAcc->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Acc PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAccParam[j].PointNo, RtuPtr->m_MaxAccPoints); - } - } - } - else - { - RtuPtr->m_MaxAccPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pAcc create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbAccTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAccTable::close error"); - return iotFailed; - } - - - //READ MI TABLE - std::vector VecMiParam; - std::vector vecMiColumn; - vecMiColumn.push_back("rtu_no"); - vecMiColumn.push_back("dot_no"); - vecMiColumn.push_back("app_table_name"); - vecMiColumn.push_back("app_column_name"); - vecMiColumn.push_back("app_tag_name"); - vecMiColumn.push_back("tag_name"); - vecMiColumn.push_back("description"); - vecMiColumn.push_back("dev_tag"); - vecMiColumn.push_back("base"); - vecMiColumn.push_back("coeff"); - vecMiColumn.push_back("max_range"); - vecMiColumn.push_back("min_range"); - vecMiColumn.push_back("res_para_int1"); - vecMiColumn.push_back("res_para_int2"); - vecMiColumn.push_back("res_para_int3"); - vecMiColumn.push_back("res_para_int4"); - vecMiColumn.push_back("res_para_int5"); - vecMiColumn.push_back("res_para_int6"); - vecMiColumn.push_back("res_para_int7"); - vecMiColumn.push_back("res_para_int8"); - ret = RdbMiTable.open(m_strAppLabel.c_str(), RT_FES_MI_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbMiTable::Open error"); - return iotFailed; - } - ret = RdbMiTable.selectOneOrder(con,VecMiParam, vecMiColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbMiTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxMiPoints = 0; - count = VecMiParam.size(); - if(count>0) - { - RtuPtr->m_MaxMiPoints = VecMiParam[count-1].PointNo+1; - if (RtuPtr->m_MaxMiPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pMi = (SFesMi*)malloc(RtuPtr->m_MaxMiPoints * sizeof(SFesMi)); - if (RtuPtr->m_pMi != NULL) - { - memset(RtuPtr->m_pMi, 0, RtuPtr->m_MaxMiPoints * sizeof(SFesMi)); - for (j = 0; j < count; j++) - { - if ((VecMiParam[j].PointNo>=0)&&(VecMiParam[j].PointNo < RtuPtr->m_MaxMiPoints)) - { - pMi = RtuPtr->m_pMi + VecMiParam[j].PointNo; - pMi->PointNo = VecMiParam[j].PointNo; - strcpy(pMi->TableName, VecMiParam[j].TableName); - strcpy(pMi->ColumnName, VecMiParam[j].ColumnName); - strcpy(pMi->TagName, VecMiParam[j].TagName); - strcpy(pMi->PointTagName, VecMiParam[j].PointTagName); - strcpy(pMi->PointDesc, VecMiParam[j].PointDesc); - pMi->DevId = GetDevIdByDevTag(RtuPtr, VecMiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId - pMi->Base = VecMiParam[j].Base; - pMi->Coeff = VecMiParam[j].Coeff; - pMi->MaxRange = VecMiParam[j].MaxRange; - pMi->MinRange = VecMiParam[j].MinRange; - pMi->Param1 = VecMiParam[j].Param1; - pMi->Param2 = VecMiParam[j].Param2; - pMi->Param3 = VecMiParam[j].Param3; - pMi->Param4 = VecMiParam[j].Param4; - pMi->Param5 = VecMiParam[j].Param5; - pMi->Param6 = VecMiParam[j].Param6; - pMi->Param7 = VecMiParam[j].Param7; - pMi->Param8 = VecMiParam[j].Param8; - pMi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 - pMi->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Mi PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMiParam[j].PointNo, RtuPtr->m_MaxMiPoints); - } - } - } - else - { - RtuPtr->m_MaxMiPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pMi create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbMiTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbMiTable::close error"); - return iotFailed; - } - - //READ DO TABLE - std::vector VecDoParam; - std::vector vecDoColumn; - vecDoColumn.push_back("rtu_no"); - vecDoColumn.push_back("dot_no"); - vecDoColumn.push_back("tag_name"); - vecDoColumn.push_back("description"); - vecDoColumn.push_back("dev_tag"); - vecDoColumn.push_back("revers"); - - vecDoColumn.push_back("res_para_int1"); - vecDoColumn.push_back("res_para_int2"); - vecDoColumn.push_back("res_para_int3"); - vecDoColumn.push_back("res_para_int4"); - vecDoColumn.push_back("res_para_int5"); - vecDoColumn.push_back("res_para_int6"); - vecDoColumn.push_back("res_para_int7"); - vecDoColumn.push_back("res_para_int8"); - vecDoColumn.push_back("attr"); - vecDoColumn.push_back("ctrl_type"); - - ret = RdbDoTable.open(m_strAppLabel.c_str(),RT_FES_DO_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDoTable::Open error"); - return iotFailed; - } - ret = RdbDoTable.selectOneOrder(con,VecDoParam, vecDoColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbDoTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxDoPoints = 0; - count = VecDoParam.size(); - if(count>0) - { - RtuPtr->m_MaxDoPoints = VecDoParam[count-1].PointNo+1; - if (RtuPtr->m_MaxDoPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pDo = (SFesDo*)malloc(RtuPtr->m_MaxDoPoints * sizeof(SFesDo)); - if (RtuPtr->m_pDo != NULL) - { - memset(RtuPtr->m_pDo, 0, RtuPtr->m_MaxDoPoints * sizeof(SFesDo)); - for (j = 0; j < count; j++) - { - if ((VecDoParam[j].PointNo>=0)&&(VecDoParam[j].PointNo < RtuPtr->m_MaxDoPoints)) - { - pDo = RtuPtr->m_pDo + VecDoParam[j].PointNo; - pDo->PointNo = VecDoParam[j].PointNo; - strcpy(pDo->PointTagName, VecDoParam[j].PointTagName); - strcpy(pDo->PointDesc, VecDoParam[j].PointDesc); - pDo->DevId = GetDevIdByDevTag(RtuPtr, VecDoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId - //pDo->Revers = VecDoParam[j].Revers; - pDo->Param1 = VecDoParam[j].Param1; - pDo->Param2 = VecDoParam[j].Param2; - pDo->Param3 = VecDoParam[j].Param3; - pDo->Param4 = VecDoParam[j].Param4; - pDo->Param5 = VecDoParam[j].Param5; - pDo->Param6 = VecDoParam[j].Param6; - pDo->Param7 = VecDoParam[j].Param7; - pDo->Param8 = VecDoParam[j].Param8; - pDo->Attribute = VecDoParam[j].Attribute; - pDo->ControlParam = VecDoParam[j].ControlParam; - pDo->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Do PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDoParam[j].PointNo, RtuPtr->m_MaxDoPoints); - } - } - } - else - { - RtuPtr->m_MaxDoPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pDo create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbDoTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDoTable::close error"); - return iotFailed; - } - - - //READ AO TABLE - std::vector VecAoParam; - std::vector vecAoColumn; - vecAoColumn.push_back("rtu_no"); - vecAoColumn.push_back("dot_no"); - vecAoColumn.push_back("tag_name"); - vecAoColumn.push_back("description"); - vecAoColumn.push_back("dev_tag"); - vecAoColumn.push_back("base"); - vecAoColumn.push_back("coeff"); - vecAoColumn.push_back("max_range"); - vecAoColumn.push_back("min_range"); - vecAoColumn.push_back("res_para_int1"); - vecAoColumn.push_back("res_para_int2"); - vecAoColumn.push_back("res_para_int3"); - vecAoColumn.push_back("res_para_int4"); - vecAoColumn.push_back("res_para_int5"); - vecAoColumn.push_back("res_para_int6"); - vecAoColumn.push_back("res_para_int7"); - vecAoColumn.push_back("res_para_int8"); - ret = RdbAoTable.open(m_strAppLabel.c_str(), RT_FES_AO_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAoTable::Open error"); - return iotFailed; - } - ret = RdbAoTable.selectOneOrder(con,VecAoParam, vecAoColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbAoTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxAoPoints = 0; - count = VecAoParam.size(); - if(count>0) - { - RtuPtr->m_MaxAoPoints = VecAoParam[count-1].PointNo+1; - if (RtuPtr->m_MaxAoPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pAo = (SFesAo*)malloc(RtuPtr->m_MaxAoPoints * sizeof(SFesAo)); - if (RtuPtr->m_pAo != NULL) - { - memset(RtuPtr->m_pAo, 0, RtuPtr->m_MaxAoPoints * sizeof(SFesAo)); - for (j = 0; j < count; j++) - { - if ((VecAoParam[j].PointNo>=0)&&(VecAoParam[j].PointNo < RtuPtr->m_MaxAoPoints)) - { - pAo = RtuPtr->m_pAo + VecAoParam[j].PointNo; - pAo->PointNo = VecAoParam[j].PointNo; - strcpy(pAo->PointTagName, VecAoParam[j].PointTagName); - strcpy(pAo->PointDesc, VecAoParam[j].PointDesc); - pAo->DevId = GetDevIdByDevTag(RtuPtr, VecAoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId - pAo->Base = (float)VecAoParam[j].Base; - pAo->Coeff = (float)VecAoParam[j].Coeff; - pAo->MaxRange = (float)VecAoParam[j].MaxRange; - pAo->MinRange = (float)VecAoParam[j].MinRange; - pAo->Param1 = VecAoParam[j].Param1; - pAo->Param2 = VecAoParam[j].Param2; - pAo->Param3 = VecAoParam[j].Param3; - pAo->Param4 = VecAoParam[j].Param4; - pAo->Param5 = VecAoParam[j].Param5; - pAo->Param6 = VecAoParam[j].Param6; - pAo->Param7 = VecAoParam[j].Param7; - pAo->Param8 = VecAoParam[j].Param8; - pAo->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Ao PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAoParam[j].PointNo, RtuPtr->m_MaxAoPoints); - } - } - } - else - { - RtuPtr->m_MaxAoPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pAo create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbAoTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbAoTable::close error"); - return iotFailed; - } - //READ MO TABLE - std::vector VecMoParam; - std::vector vecMoColumn; - vecMoColumn.push_back("rtu_no"); - vecMoColumn.push_back("dot_no"); - vecMoColumn.push_back("tag_name"); - vecMoColumn.push_back("description"); - vecMoColumn.push_back("dev_tag"); - vecMoColumn.push_back("base"); - vecMoColumn.push_back("coeff"); - vecMoColumn.push_back("max_range"); - vecMoColumn.push_back("min_range"); - vecMoColumn.push_back("res_para_int1"); - vecMoColumn.push_back("res_para_int2"); - vecMoColumn.push_back("res_para_int3"); - vecMoColumn.push_back("res_para_int4"); - vecMoColumn.push_back("res_para_int5"); - vecMoColumn.push_back("res_para_int6"); - vecMoColumn.push_back("res_para_int7"); - vecMoColumn.push_back("res_para_int8"); - ret = RdbMoTable.open(m_strAppLabel.c_str(), RT_FES_MO_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbMoTable::Open error"); - return iotFailed; - } - ret = RdbMoTable.selectOneOrder(con,VecMoParam, vecMoColumn, "dot_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbMoTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxMoPoints = 0; - count = VecMoParam.size(); - if(count>0) - { - RtuPtr->m_MaxMoPoints = VecMoParam[count-1].PointNo+1; - if (RtuPtr->m_MaxMoPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pMo = (SFesMo*)malloc(RtuPtr->m_MaxMoPoints * sizeof(SFesMo)); - if (RtuPtr->m_pMo != NULL) - { - memset(RtuPtr->m_pMo, 0, RtuPtr->m_MaxMoPoints * sizeof(SFesMo)); - for (j = 0; j < count; j++) - { - if ((VecMoParam[j].PointNo>=0)&&(VecMoParam[j].PointNo < RtuPtr->m_MaxMoPoints)) - { - pMo = RtuPtr->m_pMo + VecMoParam[j].PointNo; - pMo->PointNo = VecMoParam[j].PointNo; - strcpy(pMo->PointTagName, VecMoParam[j].PointTagName); - strcpy(pMo->PointDesc, VecMoParam[j].PointDesc); - pMo->DevId = GetDevIdByDevTag(RtuPtr, VecMoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId - pMo->Base = VecMoParam[j].Base; - pMo->Coeff = VecMoParam[j].Coeff; - pMo->MaxRange = VecMoParam[j].MaxRange; - pMo->MinRange = VecMoParam[j].MinRange; - pMo->Param1 = VecMoParam[j].Param1; - pMo->Param2 = VecMoParam[j].Param2; - pMo->Param3 = VecMoParam[j].Param3; - pMo->Param4 = VecMoParam[j].Param4; - pMo->Param5 = VecMoParam[j].Param5; - pMo->Param6 = VecMoParam[j].Param6; - pMo->Param7 = VecMoParam[j].Param7; - pMo->Param8 = VecMoParam[j].Param8; - pMo->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Mo PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMoParam[j].PointNo, RtuPtr->m_MaxMoPoints); - } - } - } - else - { - RtuPtr->m_MaxMoPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pMo create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbMoTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbMoTable::close error"); - return iotFailed; - } - - //READ DZ TABLE - std::vector VecDzParam; - std::vector vecDzColumn; - vecDzColumn.push_back("rtu_no"); - vecDzColumn.push_back("dot_no"); - vecDzColumn.push_back("dev_tag"); - vecDzColumn.push_back("group_no"); - vecDzColumn.push_back("seq_no"); - vecDzColumn.push_back("dz_seq"); - vecDzColumn.push_back("value_type"); - vecDzColumn.push_back("unit_id"); - vecDzColumn.push_back("value_added"); - vecDzColumn.push_back("value_ratio"); - vecDzColumn.push_back("value_max"); - vecDzColumn.push_back("value_min"); - vecDzColumn.push_back("res_para_int1"); - vecDzColumn.push_back("res_para_int2"); - vecDzColumn.push_back("res_para_int3"); - vecDzColumn.push_back("res_para_int4"); - vecDzColumn.push_back("res_para_int5"); - vecDzColumn.push_back("res_para_int6"); - vecDzColumn.push_back("res_para_int7"); - vecDzColumn.push_back("res_para_int8"); - - ret = RdbDzTable.open(m_strAppLabel.c_str(), RT_FES_SETTING_TBL); - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData,RdbDzTable::Open error"); - return iotFailed; - } - ret = RdbDzTable.selectOneOrder(con, VecDzParam, vecDzColumn, "dot_no");//默认顺序 - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData, RdbDzTable.selectNoCondition error!"); - return iotFailed; - } - RtuPtr->m_MaxDzPoints = 0; - count = VecDzParam.size(); - if (RtuPtr->m_Param.RtuNo == 169) - int aa = 0; - if (count > 0) - { - RtuPtr->m_MaxDzPoints = VecDzParam[count - 1].PointNo + 1; - if (RtuPtr->m_MaxDzPoints > 0) - { - //动态分配数据空间 - RtuPtr->m_pDz = (SFesDz*)malloc(RtuPtr->m_MaxDzPoints * sizeof(SFesDz)); - if (RtuPtr->m_pDz != NULL) - { - memset(RtuPtr->m_pDz, 0, RtuPtr->m_MaxDzPoints * sizeof(SFesDz)); - for (j = 0; j < count; j++) - { - if((VecDzParam[j].PointNo>=0)&&(VecDzParam[j].PointNo < RtuPtr->m_MaxDzPoints)) - { - pDz = RtuPtr->m_pDz + VecDzParam[j].PointNo; - pDz->PointNo = VecDzParam[j].PointNo; - pDz->DevId = GetDevIdByDevTag(RtuPtr, VecDzParam[j].DevTagName);//2021-03-03 thxiao 增加DevId - pDz->GroupNo = VecDzParam[j].GroupNo; - pDz->CodeNo = VecDzParam[j].CodeNo; - pDz->SeqNo = VecDzParam[j].SeqNo; - pDz->DzType = VecDzParam[j].DzType; - pDz->Unit = VecDzParam[j].Unit; - pDz->Base = VecDzParam[j].Base; - pDz->Coeff = VecDzParam[j].Coeff; - pDz->MaxRange = VecDzParam[j].MaxRange; - pDz->MinRange = VecDzParam[j].MinRange; - pDz->Param1 = VecDzParam[j].Param1; - pDz->Param2 = VecDzParam[j].Param2; - pDz->Param3 = VecDzParam[j].Param3; - pDz->Param4 = VecDzParam[j].Param4; - pDz->Param5 = VecDzParam[j].Param5; - pDz->Param6 = VecDzParam[j].Param6; - pDz->Param7 = VecDzParam[j].Param7; - pDz->Param8 = VecDzParam[j].Param8; - pDz->Used = 1; - } - else - { - LOGDEBUG("fesbase.cpp RtuNo:%d Dz PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDzParam[j].PointNo, RtuPtr->m_MaxDzPoints); - } - } - } - else - { - RtuPtr->m_MaxDzPoints = 0; - LOGDEBUG("fesbase.cpp RtuNo:%d pDz create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - ret = RdbMoTable.close(); - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData,RdbMoTable::close error"); - return iotFailed; - } - - //READ DATA BLOCK - //2020-01-05 thxiao VecDataBlock暂时没有rtu_tag - //CONDINFO con1; - //con1.relationop = ATTRCOND_EQU; - //con1.conditionval = RtuPtr->m_Param.RtuNo; - //strcpy(con1.name, "rtu_no"); - - - std::vector VecDataBlock; - std::vector vecBlockColumn; - vecBlockColumn.push_back("rtu_no"); - vecBlockColumn.push_back("block_id"); - vecBlockColumn.push_back("func_code"); - vecBlockColumn.push_back("star_addr"); - vecBlockColumn.push_back("data_len"); - vecBlockColumn.push_back("ref_cycle"); - vecBlockColumn.push_back("data_farme_type"); - vecBlockColumn.push_back("is_create_soe"); - vecBlockColumn.push_back("para_int1"); - vecBlockColumn.push_back("para_int2"); - vecBlockColumn.push_back("para_int3");//2021-04-28 thxiao - vecBlockColumn.push_back("para_int4"); - vecBlockColumn.push_back("is_enable"); - ret = RdbDataBlockTable.open(m_strAppLabel.c_str(), RT_FES_DATA_BLOCK_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDataBlockTable::Open error"); - return iotFailed; - } - ret = RdbDataBlockTable.selectOneOrder(con,VecDataBlock, vecBlockColumn, "block_id");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbDataBlockTable.selectOneCondition error!"); - return iotFailed; - } - RtuPtr->m_Param.ModbusCmdBuf.num = VecDataBlock.size(); - BlockSeqNo = 0; - RtuPtr->m_Param.ModbusCmdBuf.readx = 0; - RtuPtr->m_Param.ModbusCmdBuf.writex = 0; - if(RtuPtr->m_Param.ModbusCmdBuf.num >=0) - { - RtuPtr->m_Param.ModbusCmdBuf.pCmd = (SModbusCmd *)malloc(RtuPtr->m_Param.ModbusCmdBuf.num * sizeof(SModbusCmd)); - if(RtuPtr->m_Param.ModbusCmdBuf.pCmd != NULL) - { - memset(RtuPtr->m_Param.ModbusCmdBuf.pCmd,0,sizeof(SModbusCmd)*RtuPtr->m_Param.ModbusCmdBuf.num); - //init cmd - SModbusCmd *pCmd; - for(int k=0;km_Param.ModbusCmdBuf.num;k++) - { - pCmd = RtuPtr->m_Param.ModbusCmdBuf.pCmd+k; - pCmd->SeqNo = BlockSeqNo;//2022-09-06 thxiao 自动分配块序号,供MODBUSTCPV3内部使用 - BlockSeqNo++; - pCmd->Index = VecDataBlock[k].Index; - pCmd->FunCode = VecDataBlock[k].FunCode; - pCmd->StartAddr = VecDataBlock[k].StartAddr; - pCmd->DataLen = VecDataBlock[k].DataLen; - pCmd->PollTime = VecDataBlock[k].PollTime; - pCmd->Type = VecDataBlock[k].FrameType; - pCmd->IsCreateSoe = VecDataBlock[k].IsCreateSoe; - pCmd->Param1 = VecDataBlock[k].Param1; - pCmd->Param2 = VecDataBlock[k].Param2; - pCmd->Param3 = VecDataBlock[k].Param3; - pCmd->Param4 = VecDataBlock[k].Param4; - pCmd->Used = VecDataBlock[k].Used; - } - } - else - { - RtuPtr->m_Param.ModbusCmdBuf.num = 0; - LOGDEBUG("fesbase.cpp pRtuData->Param.pModbusCmd create failed.\n"); - } - - //分配命令发送缓冲区 - if(RtuPtr->m_Param.ModbusCmdBuf.num>0) - { - RtuPtr->pTxCmdBuf = (SModbuTxCmdBuf*)malloc(sizeof(SModbuTxCmdBuf)); - if(RtuPtr->pTxCmdBuf == NULL) - { - LOGDEBUG(" fesbase.cpp RtuNo:%d malloc pTxCmdBuf error!",RtuPtr->m_Param.RtuNo); - return iotFailed; - } - else - memset(RtuPtr->pTxCmdBuf,0,sizeof(SModbuTxCmdBuf)); - } - } - - ret = RdbDataBlockTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbDataBlockTable::close error"); - return iotFailed; - } - - - RtuPtr->AiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxAiPoints; - RtuPtr->DiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxDiPoints; - RtuPtr->AccMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxAccPoints; - RtuPtr->MiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxMiPoints; - - //2019-05-06 thxiao add location info - for(k=0;km_Param.nLocationId == m_vectLocationPtr[k].nLocationId) - { - strcpy(RtuPtr->m_Param.LocationDesc,m_vectLocationPtr[k].LocationDesc); - - //2020-01-05 把右边空格去掉 - //LOGDEBUG("1 RtuPtr->m_Param.LocationDesc=%s!!!!!!", RtuPtr->m_Param.LocationDesc); - - int len = strlen(RtuPtr->m_Param.LocationDesc); - char *p = RtuPtr->m_Param.LocationDesc + len - 1; - while ((p >= RtuPtr->m_Param.LocationDesc) && (*p == ' ')) - { - *p = '\0'; --p; - } - //LOGDEBUG("1 RtuPtr->m_Param.LocationDesc=%s!!!!!!", RtuPtr->m_Param.LocationDesc); - - break; - } - } - if(strlen(RtuPtr->m_Param.LocationDesc)<=0) - { - sprintf(RtuPtr->m_Param.LocationDesc,"Location%d",RtuPtr->m_Param.nLocationId);//default value - } - RtuPtr->m_ComStatusPointNo = -1;//对应采集RTU通信状态点号，默认为-1； - RtuPtr->m_Status = CN_FesRtuComDown; - m_vectCFesRtuPtr.push_back(RtuPtr); - - //LOGDEBUG("m_strAppLabel: %s",m_strAppLabel.c_str()); - //forwarding->InitFesConllectRtu(RtuPtr,m_strAppLabel); //初始化转发表结构参数 - //LOGDEBUG("RtuPtr: %s",m_strAppLabel.c_str()); - } - - - //init MAP - m_RtuNum = m_vectCFesRtuPtr.size(); - for(i=0;im_Param.RtuNo] = m_vectCFesRtuPtr[i]; - m_mapTagRtu[m_vectCFesRtuPtr[i]->m_Param.TagName] = m_vectCFesRtuPtr[i]; - } - } - - - ret = RdbRtuTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbRtuTable::close error"); - return iotFailed; - } - - //读取实时库CHAN配置 - std::vector VecChanParam; - std::vector vecChanColumn; - vecChanColumn.push_back("chan_no"); - vecChanColumn.push_back("tag_name"); - vecChanColumn.push_back("chan_name"); - vecChanColumn.push_back("description"); - vecChanColumn.push_back("location_id"); - vecChanColumn.push_back("sub_system"); - vecChanColumn.push_back("region_id"); - vecChanColumn.push_back("is_used"); - vecChanColumn.push_back("error_rate_limit"); - vecChanColumn.push_back("net_desc1"); - vecChanColumn.push_back("port_no1"); - vecChanColumn.push_back("net_desc2"); - vecChanColumn.push_back("port_no2"); - vecChanColumn.push_back("net_desc3"); - vecChanColumn.push_back("port_no3"); - vecChanColumn.push_back("net_desc4"); - vecChanColumn.push_back("port_no4"); - vecChanColumn.push_back("comm_property"); - vecChanColumn.push_back("comm_type"); - vecChanColumn.push_back("comm_mode"); - vecChanColumn.push_back("proto_type"); - vecChanColumn.push_back("connectwait_sec"); - vecChanColumn.push_back("connect_timeout"); - vecChanColumn.push_back("connect_retrys"); - vecChanColumn.push_back("resp_timeout"); - vecChanColumn.push_back("recv_timeout"); - vecChanColumn.push_back("recvbuf_len"); - vecChanColumn.push_back("sendbuf_len"); - vecChanColumn.push_back("backup_chan_no1"); - vecChanColumn.push_back("backup_chan_no2"); - vecChanColumn.push_back("backup_chan_no3"); - vecChanColumn.push_back("res_para_int1"); - vecChanColumn.push_back("res_para_int2"); - vecChanColumn.push_back("res_para_int3"); - vecChanColumn.push_back("res_para_int4"); - //vecChanColumn.push_back("com_name"); - vecChanColumn.push_back("baud"); - vecChanColumn.push_back("parity"); - vecChanColumn.push_back("databit"); - vecChanColumn.push_back("stopbit"); - vecChanColumn.push_back("alarm_enable"); - - - - ret = RdbChanTable.open(m_strAppLabel.c_str(),RT_FES_CHAN_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbChanTable::Open error"); - return iotFailed; - } - ret = RdbChanTable.selectNoCondition(VecChanParam, vecChanColumn, "chan_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbChanTable.selectOneCondition error!"); - return iotFailed; - } - m_ChanNum = VecChanParam.size(); - if(m_ChanNum>0) - { - for(i=0;i(); - - ChanPtr->m_Param.ChanNo = VecChanParam[i].ChanNo; - strcpy(ChanPtr->m_Param.TagName,VecChanParam[i].TagName); - strcpy(ChanPtr->m_Param.ChanName,VecChanParam[i].ChanName); - strcpy(ChanPtr->m_Param.ChanDesc,VecChanParam[i].ChanDesc); - ChanPtr->m_Param.nLocationId =VecChanParam[i].nLocationId; - ChanPtr->m_Param.nSubSystem =VecChanParam[i].nSubSystem; - ChanPtr->m_Param.nRegionId =VecChanParam[i].nRegionId; - ChanPtr->m_Param.Used=VecChanParam[i].Used; - ChanPtr->m_Param.ErrRateLimit=(float)VecChanParam[i].ErrRateLimit/100;//2020-11-02 thxiao 取百分数 - strcpy(ChanPtr->m_Param.NetRoute[0].NetDesc,VecChanParam[i].NetDesc1); - ChanPtr->m_Param.NetRoute[0].PortNo = VecChanParam[i].PortNo1; - strcpy(ChanPtr->m_Param.NetRoute[1].NetDesc,VecChanParam[i].NetDesc2); - ChanPtr->m_Param.NetRoute[1].PortNo = VecChanParam[i].PortNo2; - strcpy(ChanPtr->m_Param.NetRoute[2].NetDesc,VecChanParam[i].NetDesc3); - ChanPtr->m_Param.NetRoute[2].PortNo = VecChanParam[i].PortNo3; - strcpy(ChanPtr->m_Param.NetRoute[3].NetDesc,VecChanParam[i].NetDesc4); - ChanPtr->m_Param.NetRoute[3].PortNo = VecChanParam[i].PortNo4; - ChanPtr->m_Param.CommProperty = VecChanParam[i].CommProperty; - ChanPtr->m_Param.CommType=VecChanParam[i].CommType; - ChanPtr->m_Param.ChanMode=VecChanParam[i].ChanMode; - ChanPtr->m_Param.ProtocolId=VecChanParam[i].ProtocolId; - ChanPtr->m_Param.ConnectWaitSec=VecChanParam[i].ConnectWaitSec; - if(VecChanParam[i].RespTimeout <= 100) - ChanPtr->m_Param.RespTimeout = 100;//响应超时，单位毫秒 - else - ChanPtr->m_Param.RespTimeout=VecChanParam[i].RespTimeout; //响应超时，单位毫秒 - ChanPtr->m_Param.RetryTimes=VecChanParam[i].RetryTimes; - ChanPtr->m_Param.RecvTimeout=VecChanParam[i].RecvTimeout*1000;//接收超时，单位秒；内部变为毫秒 - ChanPtr->m_Param.ConnectTimeout=VecChanParam[i].ConnectTimeout; - ChanPtr->m_Param.MaxRxSize=VecChanParam[i].MaxRxSize; - ChanPtr->m_Param.MaxTxSize=VecChanParam[i].MaxTxSize; - //2021-11-05 thxiao 在某种情况下，配置通道接收发送缓冲区会被清零，导致FES异常。避免这种情况给配置赋非零最小值 - if (ChanPtr->m_Param.MaxRxSize < 2048) - ChanPtr->m_Param.MaxRxSize = 2048; - if (ChanPtr->m_Param.MaxTxSize < 2048) - ChanPtr->m_Param.MaxTxSize = 2048; - ChanPtr->m_Param.BackupChanNo[0]=VecChanParam[i].BackupChanNo1; - ChanPtr->m_Param.BackupChanNo[1]=VecChanParam[i].BackupChanNo2; - ChanPtr->m_Param.BackupChanNo[2]=VecChanParam[i].BackupChanNo3; - //串口属性设置 - //strcpy(ChanPtr->m_Param.ComPortName,VecChanParam[i].ComPortName); - ChanPtr->m_Param.BaudRate=VecChanParam[i].BaudRate; - ChanPtr->m_Param.Parity=VecChanParam[i].Parity; - ChanPtr->m_Param.DataBit=VecChanParam[i].DataBit; - ChanPtr->m_Param.StopBit=VecChanParam[i].StopBit; - - ChanPtr->m_Param.ResParam1=VecChanParam[i].ResParam1; - ChanPtr->m_Param.ResParam2=VecChanParam[i].ResParam2; - ChanPtr->m_Param.SetTimeEnable=VecChanParam[i].ResParam3; - ChanPtr->m_Param.LocalPortNo=VecChanParam[i].ResParam4; - - ChanPtr->m_Param.AlarmEnable = VecChanParam[i].AlarmEnable; - //分配通道空间 - ChanPtr->m_MaxRxSize=ChanPtr->m_Param.MaxRxSize; - ChanPtr->m_MaxTxSize=ChanPtr->m_Param.MaxTxSize; - ChanPtr->m_RxBuf.pData=(byte*)malloc(ChanPtr->m_MaxRxSize*sizeof(byte)); - if(ChanPtr->m_RxBuf.pData==NULL) - { - ChanPtr->m_MaxRxSize = 0; - LOGDEBUG("fesbase.cpp ChanNo:%d m_RxBuf.pData created failed.\n",ChanPtr->m_Param.ChanNo); - } - ChanPtr->m_TxBuf.pData=(byte*)malloc(ChanPtr->m_MaxTxSize*sizeof(byte)); - if(ChanPtr->m_TxBuf.pData==NULL) - { - ChanPtr->m_MaxTxSize = 0; - LOGDEBUG("fesbase.cpp ChanNo:%d m_TxBuf.pData created failed.\n",ChanPtr->m_Param.ChanNo); - } - //2020-06-03 thxiao 通信中断的延时判断时间 - if (ChanPtr->m_Param.RecvTimeout < 5000)//5s - { - ChanPtr->m_StatusDownStartTimeReset = 5000; - } - else - ChanPtr->m_StatusDownStartTimeReset = ChanPtr->m_Param.RecvTimeout; - - //获取有效配置的通道号个数 - ChanPtr->m_BackupChanNum =1; - ChanPtr->m_BackupChanNo[0]=ChanPtr->m_Param.ChanNo; - int chanCount=1; - for (j = 0; j < (CN_FesMaxChangeChanNum - 1); j++) - { - if (ChanPtr->m_Param.BackupChanNo[j] != -1) - ChanPtr->m_BackupChanNo[chanCount++] = ChanPtr->m_Param.BackupChanNo[j]; - else - break;//2021-12-01 thxiao 备用通道配置中遇到第一个“-1”,则认为以下的备用通道都无效 - } - ChanPtr->m_BackupChanNum = chanCount; - - //获取有效配置的RTU号 - int rtuCount=0; - int StartSeqNo,retSeqNo; - StartSeqNo = 0; - retSeqNo = 0; - for (j = 0; j < static_cast(m_vectCFesRtuPtr.size()); j++) - { - if ((m_vectCFesRtuPtr[j]->m_Param.ChanNo == ChanPtr->m_Param.ChanNo) && - (m_vectCFesRtuPtr[j]->m_Param.Used == 1)) - { - ChanPtr->m_RtuNo[rtuCount++] = m_vectCFesRtuPtr[j]->m_Param.RtuNo; - //2022-10-13 thxiao 同一通道下所有RTU块序号统一排列序号 - SetRtuBlockSeqNo(m_vectCFesRtuPtr[j], StartSeqNo, retSeqNo); - StartSeqNo = retSeqNo; - } - } - ChanPtr->m_RtuNum = rtuCount; - ChanPtr->m_OfflineCountReset = m_gOfflineCountReset*rtuCount;//2020-05-20 thxiao - ChanPtr->m_OfflineCount = 0; - - //RTU获取规约号 2018-12-25 add by thxiao - for (j = 0; j < static_cast(m_vectCFesRtuPtr.size()); j++) - { - if (m_vectCFesRtuPtr[j]->m_Param.ChanNo == ChanPtr->m_Param.ChanNo) - { - m_vectCFesRtuPtr[j]->m_Param.ProtocolId = ChanPtr->m_Param.ProtocolId; - } - } - - //初始配置时主通道标志，通道的切换处理的数据结构只在主通道上有效。1：主通道 0：备通道 - //存在对应的RTU，即说明是主通道。因为备用通道不会出现在RTU配置中。 - if(ChanPtr->m_RtuNum>0) - ChanPtr->ConfigMainFlag =1; - else - ChanPtr->ConfigMainFlag =0; - - m_vectCFesChanPtr.push_back(ChanPtr); - } - //init chan map - m_ChanNum = m_vectCFesChanPtr.size(); - for (i = 0; i < static_cast(m_vectCFesChanPtr.size()); i++) - { - m_mapChan[m_vectCFesChanPtr[i]->m_Param.ChanNo] = m_vectCFesChanPtr[i]; - } - } - ret = RdbChanTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbChanTable::close error"); - return iotFailed; - } - - //设置RTU的采集或转发属性 - SetRtuProperty(); - - //读取实时库规约配置 - std::vector VecProtocolParam; - std::vector vecProtocolColumn; - vecProtocolColumn.push_back("protocol_id"); - vecProtocolColumn.push_back("protocol_name"); - - ret = RdbProtocolTable.open(m_strAppLabel.c_str(),RT_FES_PROTOCOL_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbProtocolTable::Open error"); - return iotFailed; - } - ret = RdbProtocolTable.selectNoCondition(VecProtocolParam, vecProtocolColumn, "protocol_id");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbProtocolTable.selectNoCondition error!"); - return iotFailed; - } - - count = VecProtocolParam.size(); - if(count>0) - { - int index; - m_ProtocolNum = VecProtocolParam[count-1].ProtocolId+1; - if(m_ProtocolNum>CN_FesMaxProtocolNum) - { - m_ProtocolNum = CN_FesMaxProtocolNum; - LOGERROR("CFesBase::InitBaseData, m_ProtocolNum %d exceed %d!",m_ProtocolNum,CN_FesMaxProtocolNum); - } - char tempStr[CN_FesMaxNameSize]; - for (i = 0; i < static_cast(VecProtocolParam.size()); i++) - { - index = VecProtocolParam[i].ProtocolId; - if(index < CN_FesMaxProtocolNum) - { - strcpy(m_protoclName[index].Name, VecProtocolParam[i].Name); - m_protoclName[index].ProtocolId = VecProtocolParam[i].ProtocolId; - } - else - { - LOGERROR("CFesBase::InitBaseData ProtocolId %d exceed %d",VecProtocolParam[i].ProtocolId,CN_FesMaxProtocolNum); - } - } - } - - ret = RdbProtocolTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbProtocolTable::close error"); - return iotFailed; - } - - FwRtuInit(); - - //转发RTU映射表初始化 - FwDataInit(); - - LOGDEBUG("FES 初始化配置结束。"); - - return iotSuccess; -} - -/* - @brief GetRtuDataByRtuNo() - - 通过RTU号 读取对应的数据区地址 - @param int RtuNo RTU号 - @return RTU号数据区地址 - @retval -*/ -CFesRtuPtr CFesBase::GetRtuDataByRtuNo(int RtuNo) -{ - map::iterator it; - - - it = m_mapRtu.find(RtuNo); - if(it == m_mapRtu.end()) - return NULL; - - return (CFesRtuPtr)it->second; -} - -/* - @brief GetChanDataByChanNo() - - 通过Chan号 读取对应的数据区地址 - @param int ChanNo CHAN号 - @return CHAN号数据区地址 - @retval -*/ -CFesChanPtr CFesBase::GetChanDataByChanNo(int ChanNo) -{ - map::iterator it; - - it = m_mapChan.find(ChanNo); - if(it == m_mapChan.end()) - return NULL; - - return (CFesChanPtr)it->second; -} - -/** - * @brief CFesBase::SetMonChanNo - * 设置当前监视通道号 - * @param ChanNo - */ -void CFesBase::SetMonChanNo(int ChanNo) -{ - m_FesSimChanMonBuf.ChanNo = ChanNo; -} - -/** - * @brief CFesBase::GetMonChanNo - * 读取当前监视通道号 - * @return 当前监视通道号 - */ -int CFesBase::GetMonChanNo() -{ - return m_FesSimChanMonBuf.ChanNo; -} - - -/** - * @brief CFesBase::FesSimServerWriteSoeEvent - * 对m_FesSimSoeEventBuf写入事件 - * @param num 写入个数 - * @param buffer 写入内容 - */ -void CFesBase::FesSimServerWriteSoeEvent(int num,SFesSoeEvent *buffer) -{ - int spaceCount,i; - - //if(!m_FesSimSoeEventBuf.RefreshFlag) - // return; - - if(m_FesSimSoeEventBuf.Writex!=m_FesSimSoeEventBuf.Readx) - { - spaceCount = (m_FesSimSoeEventBuf.Writex-m_FesSimSoeEventBuf.Readx+CN_FesSimSoeEventMaxBufSize)%CN_FesSimSoeEventMaxBufSize; - if((CN_FesSimSoeEventMaxBufSize-spaceCount)>num) - m_FesSimSoeEventBuf.Overflow = 0; - else - { - m_FesSimSoeEventBuf.Overflow = 1; - //LOGDEBUG("FesBase.cpp m_FesSimSoeEventBuf Overflow!\n"); - } - } - else - m_FesSimSoeEventBuf.Overflow = 0; - - for(i=0;inum) - m_FesSimRtuEventBuf.Overflow = 0; - else - { - m_FesSimRtuEventBuf.Overflow = 1; - //LOGDEBUG("FesBase.cpp m_FesSimRtuEventBuf Overflow!\n"); - } - } - else - m_FesSimRtuEventBuf.Overflow = 0; - - for(i=0;inum) - m_FesSimChanEventBuf.Overflow = 0; - else - { - m_FesSimChanEventBuf.Overflow = 1; - //LOGDEBUG("FesBase.cpp m_FesSimChanEventBuf Overflow!\n"); - } - } - else - m_FesSimChanEventBuf.Overflow = 0; - - for(i=0;inum) - m_FesSimChanMonBuf.Overflow = 0; - else - { - m_FesSimChanMonBuf.Overflow = 1; - //LOGDEBUG("FesBase.cpp m_FesSimChanMonBuf Overflow!\n"); - } - } - else - m_FesSimChanMonBuf.Overflow = 0; - - - for(i=0;i::iterator it; - CFesChanPtr pChan; - - it = m_mapChan.find(ChanNo); - if(it == m_mapChan.end()) - { - retStatistics->TxNum = -1; - retStatistics->RxNum = -1; - retStatistics->ErrNum = -1; - return iotFailed; - } - pChan = (CFesChanPtr)it->second; - retStatistics->TxNum = pChan->m_TxNum; - retStatistics->RxNum = pChan->m_RxNum; - retStatistics->ErrNum = pChan->m_ErrNum; - return iotSuccess; - -} - -/** - * @brief CFesBase::ResetChanStatisticsByChanNo - * 通过Chan号 清除通道统计数据 - * @param ChanNo CHAN号 - * @return iotSuccess,iotFailed - */ -int CFesBase::ResetChanStatisticsByChanNo(int ChanNo) -{ - map::iterator it; - CFesChanPtr pChan; - - it = m_mapChan.find(ChanNo); - if(it == m_mapChan.end()) - return iotFailed; - - pChan = (CFesChanPtr)it->second; - pChan->ResetStatisticsNum(); - return iotSuccess; - -} - -/* - @brief GetRtuDataByRtuTag() - - 通过RTU号 读取对应的数据区地址 - @param char *tagName RTU Tag name - @return RTU号数据区地址 - @retval -*/ -CFesRtuPtr CFesBase::GetRtuDataByRtuTag(char *tagName) -{ - map::iterator it; - - - it = m_mapTagRtu.find(tagName); - if(it == m_mapTagRtu.end()) - return NULL; - - return (CFesRtuPtr)it->second; -} - -/** - * @brief CFesBase::WriteWaveFormBuf - * 写入wave form缓冲区内容 - * @param num waveform 个数 - * @param buffer waveform 内容 - */ -void CFesBase::WriteWaveFormBuf(int num,SFesWaveForm *buffer) -{ - int i; - - boost::mutex::scoped_lock lock(m_WaveFormMutex); - for(i=0;im_Param.Used) - { - //found the Chan; - if((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo))!=NULL) - { - if(chanPtr->m_Param.Used &&(chanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit)) - { - forwarding->InitFesConllectRtu(m_vectCFesRtuPtr[i],m_strAppLabel); //初始化转发表结构参数 - } - } - } - } -} - -/** - * @brief CFesBase::ProtocolRtuInitByParam1 - * 通过点配置中的“PARAM1”产生规约映射点表 - */ -bool CFesBase::ProtocolRtuInitByParam1(char* ProtocolName) -{ - int i,num,ProtocolId,found; - CFesChanPtr chanPtr; - - char tempStr[CN_FesMaxNameSize]; - found = 0; - for (i = 0; i < CN_FesMaxProtocolNum; i++) - { - if(strstr(m_protoclName[i].Name, ProtocolName)!=NULL) - { - ProtocolId = m_protoclName[i].ProtocolId; - found = 1; - break; - } - } - if(!found) - { - LOGERROR("找不到配置的规约%s，规约映射表初始化失败",ProtocolName); - return false; - } - - //把转发通道对应的有效RTU地址，填入转发RTU映射表 - num = m_vectCFesRtuPtr.size(); - for(i=0;im_Param.Used) - { - //found the Chan; - if((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo))!=NULL) - { - if(chanPtr->m_Param.Used &&(chanPtr->m_Param.ProtocolId == ProtocolId)) - { - InitProtocolPointMapping(m_vectCFesRtuPtr[i]); //初始化转发表结构参数 - } - } - } - } - LOGDEBUG("规约%s，规约映射表初始化完成",ProtocolName); - return true; -} - -/** - * @brief CFesBase::InitProtocolPointMapping - * 规约映射表初始化 - * @param RtuPtr - * @return - */ -bool CFesBase::InitProtocolPointMapping(CFesRtuPtr RtuPtr) -{ - iot_dbms::CRdbAccessEx RdbAiTable; - iot_dbms::CRdbAccessEx RdbAoTable; - iot_dbms::CRdbAccessEx RdbDiTable; - iot_dbms::CRdbAccessEx RdbDoTable; - iot_dbms::CRdbAccessEx RdbAccTable; - iot_dbms::CRdbAccessEx RdbMiTable; - iot_dbms::CRdbAccessEx RdbMoTable; - int count,ret; - SFesAiIndex *pAiIndex; - SFesDiIndex *pDiIndex; - SFesAccIndex *pAccIndex; - SFesAoIndex *pAoIndex; - SFesDoIndex *pDoIndex; - SFesMoIndex *pMoIndex; - SFesMiIndex *pMiIndex; - SFesAi *pAi; - SFesDi *pDi; - SFesAcc *pAcc; - SFesAo *pAo; - SFesDo *pDo; - SFesMo *pMo; - SFesMi *pMi; - - int j; - - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - con.conditionval = RtuPtr->m_Param.RtuNo; - strcpy(con.name, "rtu_no"); - - //READ AI TABLE - std::vector VecAiParam; - std::vector vecAiColumn; - - vecAiColumn.push_back("rtu_no"); - vecAiColumn.push_back("dot_no"); - vecAiColumn.push_back("res_para_int1"); - vecAiColumn.push_back("res_para_int2"); - vecAiColumn.push_back("res_para_int3"); - vecAiColumn.push_back("res_para_int4"); - - ret = RdbAiTable.open(m_strAppLabel.c_str(),RT_FES_AI_TBL); - if(ret==false) - { - LOGERROR("RdbAiTable::Open error"); - return iotFailed; - } - ret = RdbAiTable.selectOneOrder(con,VecAiParam,vecAiColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbAiTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbAiTable.close(); - if(ret==false) - { - LOGERROR("RdbAiTable::close error"); - return iotFailed; - } - count = VecAiParam.size(); - if(count>0) - { - RtuPtr->m_MaxAiIndex = VecAiParam[count-1].Param1+1; - if (RtuPtr->m_MaxAiIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pAiIndex = (SFesAiIndex*)malloc(RtuPtr->m_MaxAiIndex * sizeof(SFesAiIndex)); - if (RtuPtr->m_pAiIndex != NULL) - { - memset(RtuPtr->m_pAiIndex, 0xff, RtuPtr->m_MaxAiIndex * sizeof(SFesAiIndex)); - for (j = 0; j < RtuPtr->m_MaxAiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pAiIndex = RtuPtr->m_pAiIndex + j; - pAiIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecAiParam[j].Param1 >= 0 && VecAiParam[j].Param1 < RtuPtr->m_MaxAiIndex) - { - pAiIndex = RtuPtr->m_pAiIndex + VecAiParam[j].Param1; - pAiIndex->PointNo = VecAiParam[j].PointNo; - pAiIndex->PIndex = VecAiParam[j].Param1; - if ((pAiIndex->PointNo >= 0) && (pAiIndex->PointNo < RtuPtr->m_MaxAiPoints)) - { - pAi = RtuPtr->m_pAi + pAiIndex->PointNo; - pAiIndex->DevId = pAi->DevId; - pAiIndex->Param2 = pAi->Param2; - pAiIndex->Param3 = pAi->Param3; - pAiIndex->Param4 = pAi->Param4; - //2021-08-04 thxiao add - pAiIndex->Param5 = pAi->Param5; - pAiIndex->Param6 = pAi->Param6; - pAiIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Ai PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAiParam[j].Param1, RtuPtr->m_MaxAiIndex); - } - } - } - else - { - RtuPtr->m_MaxAiIndex = 0; - LOGDEBUG("RtuNo:%d AI protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - - //READ DI TABLE - std::vector VecDiParam; - std::vector vecDiColumn; - - vecDiColumn.push_back("rtu_no"); - vecDiColumn.push_back("dot_no"); - vecDiColumn.push_back("res_para_int1"); - vecDiColumn.push_back("res_para_int2"); - vecDiColumn.push_back("res_para_int3"); - vecDiColumn.push_back("res_para_int4"); - - ret = RdbDiTable.open(m_strAppLabel.c_str(),RT_FES_DI_TBL); - if(ret==false) - { - LOGERROR("RdbDiTable::Open error"); - return iotFailed; - } - ret = RdbDiTable.selectOneOrder(con,VecDiParam,vecDiColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbDiTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbDiTable.close(); - if(ret==false) - { - LOGERROR("RdbDiTable::close error"); - return iotFailed; - } - count = VecDiParam.size(); - if(count>0) - { - RtuPtr->m_MaxDiIndex = VecDiParam[count-1].Param1+1; - if (RtuPtr->m_MaxDiIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pDiIndex = (SFesDiIndex*)malloc(RtuPtr->m_MaxDiIndex * sizeof(SFesDiIndex)); - if (RtuPtr->m_pDiIndex != NULL) - { - memset(RtuPtr->m_pDiIndex, 0xff, RtuPtr->m_MaxDiIndex * sizeof(SFesDiIndex)); - for (j = 0; j < RtuPtr->m_MaxDiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pDiIndex = RtuPtr->m_pDiIndex + j; - pDiIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecDiParam[j].Param1 >= 0 && VecDiParam[j].Param1 < RtuPtr->m_MaxDiIndex) - { - pDiIndex = RtuPtr->m_pDiIndex + VecDiParam[j].Param1; - pDiIndex->PointNo = VecDiParam[j].PointNo; - pDiIndex->PIndex = VecDiParam[j].Param1; - if ((pDiIndex->PointNo >= 0) && (pDiIndex->PointNo < RtuPtr->m_MaxDiPoints)) - { - pDi = RtuPtr->m_pDi + pDiIndex->PointNo; - pDiIndex->DevId = pDi->DevId; - pDiIndex->Param2 = pDi->Param2; - pDiIndex->Param3 = pDi->Param3; - pDiIndex->Param4 = pDi->Param4; - pDiIndex->Param5 = pDi->Param5; - pDiIndex->Param6 = pDi->Param6; - pDiIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Di PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDiParam[j].Param1, RtuPtr->m_MaxDiIndex); - } - } - } - else - { - RtuPtr->m_MaxDiIndex = 0; - LOGDEBUG("RtuNo:%d Di protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - //READ ACC TABLE - std::vector VecAccParam; - std::vector vecAccColumn; - - vecAccColumn.push_back("rtu_no"); - vecAccColumn.push_back("dot_no"); - vecAccColumn.push_back("res_para_int1"); - vecAccColumn.push_back("res_para_int2"); - vecAccColumn.push_back("res_para_int3"); - vecAccColumn.push_back("res_para_int4"); - - ret = RdbAccTable.open(m_strAppLabel.c_str(),RT_FES_ACC_TBL); - if(ret==false) - { - LOGERROR("RdbAccTable::Open error"); - return iotFailed; - } - ret = RdbAccTable.selectOneOrder(con,VecAccParam,vecAccColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbAccTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbAccTable.close(); - if(ret==false) - { - LOGERROR("RdbAccTable::close error"); - return iotFailed; - } - - count = VecAccParam.size(); - if(count>0) - { - RtuPtr->m_MaxAccIndex = VecAccParam[count-1].Param1+1; - if (RtuPtr->m_MaxAccIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pAccIndex = (SFesAccIndex*)malloc(RtuPtr->m_MaxAccIndex * sizeof(SFesAccIndex)); - if (RtuPtr->m_pAccIndex != NULL) - { - memset(RtuPtr->m_pAccIndex, 0xff, RtuPtr->m_MaxAccIndex * sizeof(SFesAccIndex)); - for (j = 0; j < RtuPtr->m_MaxAccIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pAccIndex = RtuPtr->m_pAccIndex + j; - pAccIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecAccParam[j].Param1 >= 0 && VecAccParam[j].Param1 < RtuPtr->m_MaxAccIndex) - { - pAccIndex = RtuPtr->m_pAccIndex + VecAccParam[j].Param1; - pAccIndex->PointNo = VecAccParam[j].PointNo; - pAccIndex->PIndex = VecAccParam[j].Param1; - if ((pAccIndex->PointNo >= 0) && (pAccIndex->PointNo < RtuPtr->m_MaxAccPoints)) - { - pAcc = RtuPtr->m_pAcc + pAccIndex->PointNo; - pAccIndex->DevId = pAcc->DevId; - pAccIndex->Param2 = pAcc->Param2; - pAccIndex->Param3 = pAcc->Param3; - pAccIndex->Param4 = pAcc->Param4; - pAccIndex->Param5 = pAcc->Param5; - pAccIndex->Param6 = pAcc->Param6; - pAccIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Acc PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAccParam[j].Param1, RtuPtr->m_MaxAccIndex); - } - } - } - else - { - RtuPtr->m_MaxAccIndex = 0; - LOGDEBUG("RtuNo:%d Acc protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - //READ MI TABLE - std::vector VecMiParam; - std::vector vecMiColumn; - - vecMiColumn.push_back("rtu_no"); - vecMiColumn.push_back("dot_no"); - vecMiColumn.push_back("res_para_int1"); - vecMiColumn.push_back("res_para_int2"); - vecMiColumn.push_back("res_para_int3"); - vecMiColumn.push_back("res_para_int4"); - - ret = RdbMiTable.open(m_strAppLabel.c_str(),RT_FES_MI_TBL); - if(ret==false) - { - LOGERROR("RdbMiTable::Open error"); - return iotFailed; - } - ret = RdbMiTable.selectOneOrder(con,VecMiParam,vecMiColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbMiTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbMiTable.close(); - if(ret==false) - { - LOGERROR("RdbMiTable::close error"); - return iotFailed; - } - count = VecMiParam.size(); - if(count>0) - { - RtuPtr->m_MaxMiIndex = VecMiParam[count-1].Param1+1; - if (RtuPtr->m_MaxMiIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pMiIndex = (SFesMiIndex*)malloc(RtuPtr->m_MaxMiIndex * sizeof(SFesMiIndex)); - if (RtuPtr->m_pMiIndex != NULL) - { - memset(RtuPtr->m_pMiIndex, 0xff, RtuPtr->m_MaxMiIndex * sizeof(SFesMiIndex)); - for (j = 0; j < RtuPtr->m_MaxMiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pMiIndex = RtuPtr->m_pMiIndex + j; - pMiIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecMiParam[j].Param1 >= 0 && VecMiParam[j].Param1 < RtuPtr->m_MaxMiIndex) - { - pMiIndex = RtuPtr->m_pMiIndex + VecMiParam[j].Param1; - pMiIndex->PointNo = VecMiParam[j].PointNo; - pMiIndex->PIndex = VecMiParam[j].Param1; - if ((pMiIndex->PointNo >= 0) && (pMiIndex->PointNo < RtuPtr->m_MaxMiPoints)) - { - pMi = RtuPtr->m_pMi + pMiIndex->PointNo; - pMiIndex->DevId = pMi->DevId; - pMiIndex->Param2 = pMi->Param2; - pMiIndex->Param3 = pMi->Param3; - pMiIndex->Param4 = pMi->Param4; - pMiIndex->Param5 = pMi->Param5; - pMiIndex->Param6 = pMi->Param6; - pMiIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Mi PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMiParam[j].Param1, RtuPtr->m_MaxMiIndex); - } - } - } - else - { - RtuPtr->m_MaxMiIndex = 0; - LOGDEBUG("RtuNo:%d Mi protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - - //READ DO TABLE - std::vector VecDoParam; - std::vector vecDoColumn; - - vecDoColumn.push_back("rtu_no"); - vecDoColumn.push_back("dot_no"); - vecDoColumn.push_back("res_para_int1"); - vecDoColumn.push_back("res_para_int2"); - vecDoColumn.push_back("res_para_int3"); - vecDoColumn.push_back("res_para_int4"); - - ret = RdbDoTable.open(m_strAppLabel.c_str(),RT_FES_DO_TBL); - if(ret==false) - { - LOGERROR("RdbDoTable::Open error"); - return iotFailed; - } - ret = RdbDoTable.selectOneOrder(con,VecDoParam,vecDoColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbDoTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbDoTable.close(); - if(ret==false) - { - LOGERROR("RdbDoTable::close error"); - return iotFailed; - } - count = VecDoParam.size(); - if(count>0) - { - RtuPtr->m_MaxDoIndex = VecDoParam[count-1].Param1+1; - if (RtuPtr->m_MaxDoIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pDoIndex = (SFesDoIndex*)malloc(RtuPtr->m_MaxDoIndex * sizeof(SFesDoIndex)); - if (RtuPtr->m_pDoIndex != NULL) - { - memset(RtuPtr->m_pDoIndex, 0xff, RtuPtr->m_MaxDoIndex * sizeof(SFesDoIndex)); - for (j = 0; j < RtuPtr->m_MaxDoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pDoIndex = RtuPtr->m_pDoIndex + j; - pDoIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecDoParam[j].Param1 >= 0 && VecDoParam[j].Param1 < RtuPtr->m_MaxDoIndex) - { - pDoIndex = RtuPtr->m_pDoIndex + VecDoParam[j].Param1; - pDoIndex->PointNo = VecDoParam[j].PointNo; - pDoIndex->PIndex = VecDoParam[j].Param1; - if ((pDoIndex->PointNo >= 0) && (pDoIndex->PointNo < RtuPtr->m_MaxDoPoints)) - { - pDo = RtuPtr->m_pDo + pDoIndex->PointNo; - pDoIndex->DevId = pDo->DevId; - pDoIndex->Param2 = pDo->Param2; - pDoIndex->Param3 = pDo->Param3; - pDoIndex->Param4 = pDo->Param4; - pDoIndex->Param5 = pDo->Param5; - pDoIndex->Param6 = pDo->Param6; - pDoIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Do PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDoParam[j].Param1, RtuPtr->m_MaxDoIndex); - } - } - } - else - { - RtuPtr->m_MaxDoIndex = 0; - LOGDEBUG("RtuNo:%d Do protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - //READ AO TABLE - std::vector VecAoParam; - std::vector vecAoColumn; - - vecAoColumn.push_back("rtu_no"); - vecAoColumn.push_back("dot_no"); - vecAoColumn.push_back("res_para_int1"); - vecAoColumn.push_back("res_para_int2"); - vecAoColumn.push_back("res_para_int3"); - vecAoColumn.push_back("res_para_int4"); - - ret = RdbAoTable.open(m_strAppLabel.c_str(),RT_FES_AO_TBL); - if(ret==false) - { - LOGERROR("RdbAoTable::Open error"); - return iotFailed; - } - ret = RdbAoTable.selectOneOrder(con,VecAoParam,vecAoColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbAoTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbAoTable.close(); - if(ret==false) - { - LOGERROR("RdbAoTable::close error"); - return iotFailed; - } - count = VecAoParam.size(); - if(count>0) - { - RtuPtr->m_MaxAoIndex = VecAoParam[count-1].Param1+1; - if (RtuPtr->m_MaxAoIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pAoIndex = (SFesAoIndex*)malloc(RtuPtr->m_MaxAoIndex * sizeof(SFesAoIndex)); - if (RtuPtr->m_pAoIndex != NULL) - { - memset(RtuPtr->m_pAoIndex, 0xff, RtuPtr->m_MaxAoIndex * sizeof(SFesAoIndex)); - for (j = 0; j < RtuPtr->m_MaxAoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pAoIndex = RtuPtr->m_pAoIndex + j; - pAoIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecAoParam[j].Param1 >= 0 && VecAoParam[j].Param1 < RtuPtr->m_MaxAoIndex) - { - pAoIndex = RtuPtr->m_pAoIndex + VecAoParam[j].Param1; - pAoIndex->PointNo = VecAoParam[j].PointNo; - pAoIndex->PIndex = VecAoParam[j].Param1; - if ((pAoIndex->PointNo >= 0) && (pAoIndex->PointNo < RtuPtr->m_MaxAoPoints)) - { - pAo = RtuPtr->m_pAo + pAoIndex->PointNo; - pAoIndex->DevId = pAo->DevId; - pAoIndex->Param2 = pAo->Param2; - pAoIndex->Param3 = pAo->Param3; - pAoIndex->Param4 = pAo->Param4; - pAoIndex->Param5 = pAo->Param5; - pAoIndex->Param6 = pAo->Param6; - pAoIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Ao PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAoParam[j].Param1, RtuPtr->m_MaxAoIndex); - } - } - } - else - { - RtuPtr->m_MaxAoIndex = 0; - LOGDEBUG("RtuNo:%d Ao protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - //READ MO TABLE - std::vector VecMoParam; - std::vector vecMoColumn; - - vecMoColumn.push_back("rtu_no"); - vecMoColumn.push_back("dot_no"); - vecMoColumn.push_back("res_para_int1"); - vecMoColumn.push_back("res_para_int2"); - vecMoColumn.push_back("res_para_int3"); - vecMoColumn.push_back("res_para_int4"); - - ret = RdbMoTable.open(m_strAppLabel.c_str(),RT_FES_MO_TBL); - if(ret==false) - { - LOGERROR("RdbMoTable::Open error"); - return iotFailed; - } - ret = RdbMoTable.selectOneOrder(con,VecMoParam,vecMoColumn,"res_para_int1");//默认顺序 - if (ret==false) - { - LOGERROR("RdbMoTable.selectNoCondition error!"); - return iotFailed; - } - ret = RdbMoTable.close(); - if(ret==false) - { - LOGERROR("RdbMoTable::close error"); - return iotFailed; - } - count = VecMoParam.size(); - if(count>0) - { - RtuPtr->m_MaxMoIndex = VecMoParam[count-1].Param1+1; - if (RtuPtr->m_MaxMoIndex > 0) - { - //动态分配数据空间 - RtuPtr->m_pMoIndex = (SFesMoIndex*)malloc(RtuPtr->m_MaxMoIndex * sizeof(SFesMoIndex)); - if (RtuPtr->m_pMoIndex != NULL) - { - memset(RtuPtr->m_pMoIndex, 0xff, RtuPtr->m_MaxMoIndex * sizeof(SFesMoIndex)); - for (j = 0; j < RtuPtr->m_MaxMoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 - { - pMoIndex = RtuPtr->m_pMoIndex + j; - pMoIndex->Used = 0; - } - for (j = 0; j < count; j++) - { - if (VecMoParam[j].Param1 >= 0 && VecMoParam[j].Param1 < RtuPtr->m_MaxMoIndex) - { - pMoIndex = RtuPtr->m_pMoIndex + VecMoParam[j].Param1; - pMoIndex->PointNo = VecMoParam[j].PointNo; - pMoIndex->PIndex = VecMoParam[j].Param1; - if ((pMoIndex->PointNo >= 0) && (pMoIndex->PointNo < RtuPtr->m_MaxMoPoints)) - { - pMo = RtuPtr->m_pMo + pMoIndex->PointNo; - pMoIndex->DevId = pMo->DevId; - pMoIndex->Param2 = pMo->Param2; - pMoIndex->Param3 = pMo->Param3; - pMoIndex->Param4 = pMo->Param4; - pMoIndex->Param5 = pMo->Param5; - pMoIndex->Param6 = pMo->Param6; - pMoIndex->Used = 1; - } - } - else - { - LOGDEBUG("RtuNo:%d Mo PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMoParam[j].Param1, RtuPtr->m_MaxMoIndex); - } - } - } - else - { - RtuPtr->m_MaxMoIndex = 0; - LOGDEBUG("RtuNo:%d Mo protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - } - - return iotSuccess; - -} - -/** -* @brief CFesBase::WriteDoReqCmdBuf -* 当转发规约需要发送遥控使用，把控制命令发送到采集规约模块。 -* FES收到遥控命令，写入RTU遥控命令缓存区 -* @param num 写入遥控个数 -* @param buffer 写入遥控内容 -*/ -void CFesBase::WriteDoReqCmdBuf(int num, SFesRxDoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesRxDoCmd *CmdPtr; - SFesFwDoBusCmd BusCmd; - - for (i = 0; iRtuNo)) != NULL)//本FES控制命令 - { - RtuPtr->WriteRxDoCmdBuf(1, CmdPtr); - } - else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - //FwCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.iValue = CmdPtr->iValue; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwDoReqBusCmdBuf(1, &BusCmd); - } - } -} - -/** -* @brief CFesBase::WritexDoRespCmdBuf -* 当采集规约需要发送遥控反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） -* @param num 写入遥控个数 -* @param buffer 写入遥控内容 -*/ -void CFesBase::WritexDoRespCmdBuf(int num, SFesTxDoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesTxDoCmd *CmdPtr; - SFesFwDoBusCmd BusCmd; - SFesFwDoRespCmd RespCmd; - - for (i = 0; iCtrlDir == CN_Fes_CtrlDir_InSide)//FES - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL)//本FES 转发RTU - { - memset(&RespCmd, 0, sizeof(RespCmd)); - RespCmd.FwRtuNo = CmdPtr->FwRtuNo; - RespCmd.FwPointNo = CmdPtr->FwPointNo; - RespCmd.retStatus = CmdPtr->retStatus; - RespCmd.CtrlActType = CmdPtr->CtrlActType; - RespCmd.Param1 = CmdPtr->Param1; - RespCmd.Param2 = CmdPtr->Param2; - RespCmd.fParam = CmdPtr->fParam; - RtuPtr->WriteFwDoRespCmdBuf(1, &RespCmd);//写入原来的RTU的响应队列 - } - else//通过消息总线发送到非本FES - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - BusCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwDoRespBusCmdBuf(1, &BusCmd); - } - } - else//HMI - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) - { - RtuPtr->WriteTxDoCmdBuf(1, CmdPtr); - } - } - } -} - -/** - * @brief CFesRtu::WriteAoReqCmdBuf - * 当转发规约需要发送Ao使用，把控制命令发送到采集规约模块。 - * FES收到遥控命令，写入RTU遥控命令缓存区 - * @param num 写入遥控个数 - * @param buffer 写入遥控内容 - */ -void CFesBase::WriteAoReqCmdBuf(int num,SFesRxAoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesRxAoCmd *CmdPtr; - SFesFwAoBusCmd BusCmd; - SFesFwAoRespCmd RespCmd; - - for(i=0;iRtuNo))!=NULL) - { - RtuPtr->WriteRxAoCmdBuf(1,CmdPtr); - } - else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - //FwCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.fValue = CmdPtr->fValue; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwAoReqBusCmdBuf(1, &BusCmd); - } - } -} - -/** - * @brief CFesBase::WritexAoRespCmdBuf - * 当采集规约需要发送Ao反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） - * @param num 写入遥控个数 - * @param buffer 写入遥控内容 - */ -void CFesBase::WritexAoRespCmdBuf(int num,SFesTxAoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesTxAoCmd *CmdPtr; - SFesFwAoBusCmd BusCmd; - SFesFwAoRespCmd RespCmd; - - for(i=0;iCtrlDir == CN_Fes_CtrlDir_InSide) - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL) - { - memset(&RespCmd, 0, sizeof(RespCmd)); - RespCmd.FwRtuNo = CmdPtr->FwRtuNo; - RespCmd.FwPointNo = CmdPtr->FwPointNo; - RespCmd.retStatus = CmdPtr->retStatus; - RespCmd.CtrlActType = CmdPtr->CtrlActType; - RespCmd.Param1 = CmdPtr->Param1; - RespCmd.Param2 = CmdPtr->Param2; - RespCmd.fParam = CmdPtr->fParam; - RtuPtr->WriteFwAoRespCmdBuf(1, &RespCmd); - } - else - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - BusCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwAoRespBusCmdBuf(1, &BusCmd); - } - } - else//HMI - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) - { - RtuPtr->WriteTxAoCmdBuf(1, CmdPtr); - } - } - } -} - -/** - * @brief CFesRtu::WriteMoReqCmdBuf - * 当转发规约需要发送Mo使用，把控制命令发送到采集规约模块。 - * FES收到遥控命令，写入RTU遥控命令缓存区 - * @param num 写入遥控个数 - * @param buffer 写入遥控内容 - */ -void CFesBase::WriteMoReqCmdBuf(int num,SFesRxMoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesRxMoCmd *CmdPtr; - SFesFwMoBusCmd BusCmd; - - for(i=0;iRtuNo))!=NULL) - { - RtuPtr->WriteRxMoCmdBuf(1,CmdPtr); - } - else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - //FwCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.iValue = CmdPtr->iValue; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwMoReqBusCmdBuf(1, &BusCmd); - } - } -} - -/** - * @brief CFesBase::WritexMoRespCmdBuf - * 当采集规约需要发送Mo反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） - * @param num 写入遥控个数 - * @param buffer 写入遥控内容 - */ -void CFesBase::WritexMoRespCmdBuf(int num,SFesTxMoCmd *buffer) -{ - int i; - CFesRtuPtr RtuPtr; - SFesTxMoCmd *CmdPtr; - SFesFwMoBusCmd BusCmd; - SFesFwMoRespCmd RespCmd; - - for(i=0;iCtrlDir == CN_Fes_CtrlDir_InSide) - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL) - { - memset(&RespCmd, 0, sizeof(RespCmd)); - RespCmd.FwRtuNo = CmdPtr->FwRtuNo; - RespCmd.FwPointNo = CmdPtr->FwPointNo; - RespCmd.retStatus = CmdPtr->retStatus; - RespCmd.CtrlActType = CmdPtr->CtrlActType; - RespCmd.Param1 = CmdPtr->Param1; - RespCmd.Param2 = CmdPtr->Param2; - RespCmd.fParam = CmdPtr->fParam; - RtuPtr->WriteFwMoRespCmdBuf(1, &RespCmd); - } - else//通过消息总线发送到非本FES - { - memset(&BusCmd, 0, sizeof(BusCmd)); - BusCmd.FwSubSystem = CmdPtr->FwSubSystem; - BusCmd.FwRtuNo = CmdPtr->FwRtuNo; - BusCmd.FwPointNo = CmdPtr->FwPointNo; - BusCmd.SubSystem = CmdPtr->SubSystem; - BusCmd.RtuNo = CmdPtr->RtuNo; - BusCmd.PointID = CmdPtr->PointID; - BusCmd.retStatus = CmdPtr->retStatus; - BusCmd.CtrlActType = CmdPtr->CtrlActType; - BusCmd.Param1 = CmdPtr->Param1; - BusCmd.Param2 = CmdPtr->Param2; - BusCmd.fParam = CmdPtr->fParam; - WriteFwMoRespBusCmdBuf(1, &BusCmd); - } - } - else//HMI - { - if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) - { - RtuPtr->WriteTxMoCmdBuf(1, CmdPtr); - } - } - } -} - -/** -* @brief CFesBase::FwDiInit -* 转发RTU Di设置转发站标志及公共数据区 -*/ -void CFesBase::FwDiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) -{ - int j; - CFesChanPtr chanPtr; - CFesRtuPtr rtuPtr; - SFesFwDi *pFwDi; - - LOGDEBUG("转发RTU Di设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); - - //单点 - for (j = 0; j < FwRtuPtr->m_MaxFwDiPoints; j++) - { - pFwDi = FwRtuPtr->m_pFwDi + j; - if (pFwDi->Used) - { - if (pFwDi->SrcType == CN_FesFw_FesSrc) - { - if ((rtuPtr = GetRtuDataByRtuNo(pFwDi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 - { - rtuPtr->SetDiFwFlag(pFwDi->FesPointNo, MappingIndex, j); - } - else//非本FES，队列m_mapFwPubFesDi中添加记录 - { - std::map::iterator pos; - pos = m_mapFwPubFesDi.find(pFwDi->DPTagName); - if (pos == m_mapFwPubFesDi.end())//没有找到 - { - SFesFwPubDi PubPoint; - PubPoint.SrcLocationID = pFwDi->SrcLocationID; - PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwDi->DPTagName); - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.SrcPointNo = pFwDi->FesPointNo; - PubPoint.PointType = CN_FesFw_SDI; - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubFesDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetFesSubSystem(pFwDi->SrcSubSystem,CN_Fes_DI); - //LOGDEBUG("DI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwDi->FesRtuNo, pFwDi->FesPointNo, pFwDi->PointDesc, pFwDi->SrcSubSystem); - } - } - else //from DP - { - std::map::iterator pos; - pos = m_mapFwPubDpDi.find(pFwDi->DPTagName); - if (pos == m_mapFwPubDpDi.end())//没有找到 - { - SFesFwPubDi PubPoint; - PubPoint.SrcLocationID = pFwDi->SrcLocationID; - PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwDi->DPTagName); - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.SrcPointNo = pFwDi->DpSeqNo; - PubPoint.PointType = CN_FesFw_SDI; - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubDpDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetDPSubSystem(pFwDi->SrcSubSystem,CN_Fes_DI); - } - } - } - //双点 - for (j = 0; j < FwRtuPtr->m_MaxFwDDiPoints; j++) - { - pFwDi = FwRtuPtr->m_pFwDDi + j; - if (pFwDi->Used) - { - if (pFwDi->SrcType == CN_FesFw_DPSrc)//only DP - { - std::map::iterator pos; - pos = m_mapFwPubDpDi.find(pFwDi->DPTagName); - if (pos == m_mapFwPubDpDi.end())//没有找到 - { - SFesFwPubDi PubPoint; - PubPoint.SrcLocationID = pFwDi->SrcLocationID; - PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwDi->DPTagName); - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.SrcPointNo = pFwDi->DpSeqNo; - PubPoint.PointType = CN_FesFw_DDI; - PubPoint.FesRtuNo = pFwDi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubDpDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetDPSubSystem(pFwDi->SrcSubSystem, CN_Fes_DI); - } - } - } - LOGDEBUG("转发RTU Di设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); - -} - -/** -* @brief CFesBase::FwAiInit -* 转发RTU Ai设置转发站标志及公共数据区 -*/ -void CFesBase::FwAiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) -{ - int j; - CFesChanPtr chanPtr; - CFesRtuPtr rtuPtr; - SFesFwAi *pFwAi; - - LOGDEBUG("转发RTU Ai设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); - - //单点 - for (j = 0; j < FwRtuPtr->m_MaxFwAiPoints; j++) - { - pFwAi = FwRtuPtr->m_pFwAi + j; - if (pFwAi->Used) - { - if (pFwAi->SrcType == CN_FesFw_FesSrc) - { - if ((rtuPtr = GetRtuDataByRtuNo(pFwAi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 - { - rtuPtr->SetAiFwFlag(pFwAi->FesPointNo, MappingIndex, j); - } - else//非本FES，队列m_mapFwPubFesAi中添加记录 - { - std::map::iterator pos; - pos = m_mapFwPubFesAi.find(pFwAi->DPTagName); - if (pos == m_mapFwPubFesAi.end())//没有找到 - { - SFesFwPubAi PubPoint; - PubPoint.SrcLocationID = pFwAi->SrcLocationID; - PubPoint.SrcSubSystem = pFwAi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwAi->DPTagName); - PubPoint.FesRtuNo = pFwAi->FesRtuNo; - PubPoint.SrcPointNo = pFwAi->FesPointNo; - PubPoint.FesRtuNo = pFwAi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubFesAi.insert(make_pair(pFwAi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetFesSubSystem(pFwAi->SrcSubSystem, CN_Fes_AI); - //LOGDEBUG("AI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwAi->FesRtuNo, pFwAi->FesPointNo, pFwAi->PointDesc, pFwAi->SrcSubSystem); - } - } - else //from DP - { - //LOGDEBUG("======TagName:%s DPTagName:%s Desc:%s", pFwAi->TagName, pFwAi->DPTagName, pFwAi->PointDesc); - - std::map::iterator pos; - pos = m_mapFwPubDpAi.find(pFwAi->DPTagName); - if (pos == m_mapFwPubDpAi.end())//没有找到 - { - SFesFwPubAi PubPoint; - PubPoint.SrcLocationID = pFwAi->SrcLocationID; - PubPoint.SrcSubSystem = pFwAi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwAi->DPTagName); - PubPoint.FesRtuNo = pFwAi->FesRtuNo; - PubPoint.SrcPointNo = pFwAi->DpSeqNo; - PubPoint.FesRtuNo = pFwAi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubDpAi.insert(make_pair(pFwAi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetDPSubSystem(pFwAi->SrcSubSystem, CN_Fes_AI); - } - } - } - LOGDEBUG("转发RTU Ai设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); -} - - -/** -* @brief CFesBase::FwAccInit -* 转发RTU Acc设置转发站标志及公共数据区 -*/ -void CFesBase::FwAccInit(CFesRtuPtr FwRtuPtr, int MappingIndex) -{ - int j; - CFesChanPtr chanPtr; - CFesRtuPtr rtuPtr; - SFesFwAcc *pFwAcc; - - LOGDEBUG("转发RTU Acc设置转发站标志及公共数据区开始时间 [%" PRId64 "] ", getMonotonicMsec()); - - //单点 - for (j = 0; j < FwRtuPtr->m_MaxFwAccPoints; j++) - { - pFwAcc = FwRtuPtr->m_pFwAcc + j; - if (pFwAcc->Used) - { - if (pFwAcc->SrcType == CN_FesFw_FesSrc) - { - if ((rtuPtr = GetRtuDataByRtuNo(pFwAcc->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 - { - rtuPtr->SetAccFwFlag(pFwAcc->FesPointNo, MappingIndex, j); - } - else//非本FES，队列m_mapFwPubFesAcc中添加记录 - { - if (strlen(pFwAcc->DPTagName) > 0) - { - std::map::iterator pos; - pos = m_mapFwPubFesAcc.find(pFwAcc->DPTagName); - if (pos == m_mapFwPubFesAcc.end())//没有找到 - { - SFesFwPubAcc PubPoint; - PubPoint.SrcLocationID = pFwAcc->SrcLocationID; - PubPoint.SrcSubSystem = pFwAcc->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwAcc->DPTagName); - PubPoint.FesRtuNo = pFwAcc->FesRtuNo; - PubPoint.SrcPointNo = pFwAcc->FesPointNo; - PubPoint.FesRtuNo = pFwAcc->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubFesAcc.insert(make_pair(pFwAcc->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetFesSubSystem(pFwAcc->SrcSubSystem, CN_Fes_ACC); - //LOGDEBUG("ACC RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwAcc->FesRtuNo, pFwAcc->FesPointNo, pFwAcc->PointDesc, pFwAcc->SrcSubSystem); - } - } - } - else //from DP - { - if (strlen(pFwAcc->DPTagName) > 0) - { - std::map::iterator pos; - pos = m_mapFwPubDpAcc.find(pFwAcc->DPTagName); - if (pos == m_mapFwPubDpAcc.end())//没有找到 - { - SFesFwPubAcc PubPoint; - PubPoint.SrcLocationID = pFwAcc->SrcLocationID; - PubPoint.SrcSubSystem = pFwAcc->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwAcc->DPTagName); - PubPoint.FesRtuNo = pFwAcc->FesRtuNo; - PubPoint.SrcPointNo = pFwAcc->DpSeqNo; - PubPoint.FesRtuNo = pFwAcc->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubDpAcc.insert(make_pair(pFwAcc->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetDPSubSystem(pFwAcc->SrcSubSystem, CN_Fes_ACC); - } - } - } - } - LOGDEBUG("转发RTU Acc设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); -} - - -/** -* @brief CFesBase::FwMiInit -* 转发RTU Mi设置转发站标志及公共数据区 -*/ -void CFesBase::FwMiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) -{ - int j; - CFesChanPtr chanPtr; - CFesRtuPtr rtuPtr; - SFesFwMi *pFwMi; - - LOGDEBUG("转发RTU Mi设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); - - //单点 - for (j = 0; j < FwRtuPtr->m_MaxFwMiPoints; j++) - { - pFwMi = FwRtuPtr->m_pFwMi + j; - if (pFwMi->Used) - { - if (pFwMi->SrcType == CN_FesFw_FesSrc) - { - if ((rtuPtr = GetRtuDataByRtuNo(pFwMi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 - { - rtuPtr->SetMiFwFlag(pFwMi->FesPointNo, MappingIndex, j); - } - else//非本FES，队列m_mapFwPubFesMi中添加记录 - { - std::map::iterator pos; - pos = m_mapFwPubFesMi.find(pFwMi->DPTagName); - if (pos == m_mapFwPubFesMi.end())//没有找到 - { - SFesFwPubMi PubPoint; - PubPoint.SrcLocationID = pFwMi->SrcLocationID; - PubPoint.SrcSubSystem = pFwMi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwMi->DPTagName); - PubPoint.FesRtuNo = pFwMi->FesRtuNo; - PubPoint.SrcPointNo = pFwMi->FesPointNo; - PubPoint.FesRtuNo = pFwMi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubFesMi.insert(make_pair(pFwMi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetFesSubSystem(pFwMi->SrcSubSystem, CN_Fes_MI); - //LOGDEBUG("MI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwMi->FesRtuNo, pFwMi->FesPointNo, pFwMi->PointDesc, pFwMi->SrcSubSystem); - } - } - else //from DP - { - std::map::iterator pos; - pos = m_mapFwPubDpMi.find(pFwMi->DPTagName); - if (pos == m_mapFwPubDpMi.end())//没有找到 - { - SFesFwPubMi PubPoint; - PubPoint.SrcLocationID = pFwMi->SrcLocationID; - PubPoint.SrcSubSystem = pFwMi->SrcSubSystem; - strcpy(PubPoint.DPTagName, pFwMi->DPTagName); - PubPoint.FesRtuNo = pFwMi->FesRtuNo; - PubPoint.SrcPointNo = pFwMi->DpSeqNo; - PubPoint.FesRtuNo = pFwMi->FesRtuNo; - PubPoint.FwMapping[0].MappingIndex = MappingIndex; - PubPoint.FwMapping[0].RemoteNo = j; - PubPoint.FwMapNum = 1; - m_mapFwPubDpMi.insert(make_pair(pFwMi->DPTagName, PubPoint)); - } - else//已存在，只增加映射RTU - { - if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) - { - pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; - pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; - pos->second.FwMapNum++; - } - } - SetDPSubSystem(pFwMi->SrcSubSystem, CN_Fes_MI); - } - } - } - LOGDEBUG("转发RTU Mi设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); -} - - -/** -* @brief CFesBase::FwMappingInit -* 初始化转发RTU映射表及设置采集RTU点转发站标志 -*/ -void CFesBase::FwDataInit() -{ - int i, num ; - CFesChanPtr chanPtr; - CFesRtuPtr rtuPtr; - CFesRtuPtr FwRtuPtr; - - //把转发通道对应的有效RTU地址，填入转发RTU映射表 - num = m_vectCFesRtuPtr.size(); - for (i = 0; im_Param.Used) - { - //found the Chan; - if ((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo)) != NULL) - { - if (chanPtr->m_Param.Used && (chanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit)) - { - if (FwMappingTable.Num>CN_Fes_Fw_MaxMapping) - break; - FwMappingTable.FwRtu[FwMappingTable.Num] = m_vectCFesRtuPtr[i]; - FwMappingTable.Num++; - } - } - } - } - - //FES源RTU点置转发站标志 - LOGDEBUG("FES源RTU点置转发站标志开始时间 [%" PRId64 "] .", getMonotonicMsec()); - for (i = 0; i < FwMappingTable.Num; i++) - { - FwRtuPtr = FwMappingTable.FwRtu[i]; - FwDiInit(FwRtuPtr, i); - FwAiInit(FwRtuPtr, i); - FwAccInit(FwRtuPtr, i); - FwMiInit(FwRtuPtr, i); - } - LOGDEBUG("FES源RTU点置转发站标志结束时间 [%" PRId64 "] .", getMonotonicMsec()); - - LOGINFO("FwMappingInit() 转发RTU映射表初始化成功"); -} - -/** -* @brief CFesBase::GetFesFwMappingIndex -* 通过RtuPtr，获取映射索引 -* @param CFesRtuPtr RtuPtr -*/ -int CFesBase::GetFesFwMappingIndex(CFesRtuPtr RtuPtr) -{ - int i; - for (i = 0; i < FwMappingTable.Num; i++) - { - if (FwMappingTable.FwRtu[i] == RtuPtr)//同一个指针 - return i; - } - if (FwMappingTable.Num < CN_Fes_Fw_MaxMapping) - { - FwMappingTable.FwRtu[FwMappingTable.Num] = RtuPtr; - i = FwMappingTable.Num; - FwMappingTable.Num++; - LOGDEBUG("GetFesFwMappingIndex add new mapping RTUNo=%d FwMappingNum=%d", RtuPtr->m_Param.RtuNo, FwMappingTable.Num); - return i; - } - return -1; -} - - -/** -* @brief CFesBase::GetFesFwPubAi -* 通过TagName，获取非本FES转发点SFesFwPubAi -* @param TagName 点TagName -*/ -SFesFwPubAi* CFesBase::GetFesFwPubFesAi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubFesAi.find(TagName); - if (it == m_mapFwPubFesAi.end()) - return NULL; - - return (SFesFwPubAi*)&it->second; -} - -/** -* @brief CFesBase::GetFesFwPubDpAi -* 通过TagName，获取DP转发点GetFesFwPubDpAi -* @param TagName 点TagName -*/ -SFesFwPubAi* CFesBase::GetFesFwPubDpAi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubDpAi.find(TagName); - if (it == m_mapFwPubDpAi.end()) - return NULL; - - return (SFesFwPubAi*)&it->second; -} - - -/** -* @brief CFesBase::GetFesFwPubDi -* 通过TagName，获取非本FES转发点SFesFwPubDi -* @param TagName 点TagName -*/ -SFesFwPubDi* CFesBase::GetFesFwPubFesDi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubFesDi.find(TagName); - if (it == m_mapFwPubFesDi.end()) - return NULL; - - return (SFesFwPubDi*)&it->second; -} - -/** -* @brief CFesBase::GetFesFwPubDpDi -* 通过TagName，获取DP转发点GetFesFwPubDpDi -* @param TagName 点TagName -*/ -SFesFwPubDi* CFesBase::GetFesFwPubDpDi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubDpDi.find(TagName); - if (it == m_mapFwPubDpDi.end()) - return NULL; - - return (SFesFwPubDi*)&it->second; -} - -/** -* @brief CFesBase::GetFesFwPubAcc -* 通过TagName，获取非本FES转发点SFesFwPubAcc -* @param TagName 点TagName -*/ -SFesFwPubAcc* CFesBase::GetFesFwPubFesAcc(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubFesAcc.find(TagName); - if (it == m_mapFwPubFesAcc.end()) - return NULL; - - return (SFesFwPubAcc*)&it->second; -} - -/** -* @brief CFesBase::GetFesFwPubAcc -* 通过TagName，获取DP转发点SFesFwPubAcc -* @param TagName 点TagName -*/ -SFesFwPubAcc* CFesBase::GetFesFwPubDpAcc(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubDpAcc.find(TagName); - if (it == m_mapFwPubDpAcc.end()) - return NULL; - - return (SFesFwPubAcc*)&it->second; -} - - -/** -* @brief CFesBase::GetFesFwPubMi -* 通过TagName，获取非本FES转发点SFesFwPubMi -* @param TagName 点TagName -*/ -SFesFwPubMi* CFesBase::GetFesFwPubFesMi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubFesMi.find(TagName); - if (it == m_mapFwPubFesMi.end()) - return NULL; - - return (SFesFwPubMi*)&it->second; -} - -/** -* @brief CFesBase::GetFesFwPubMi -* 通过TagName，获取DP转发点SFesFwPubMi -* @param TagName 点TagName -*/ -SFesFwPubMi* CFesBase::GetFesFwPubDpMi(std::string TagName) -{ - std::map::iterator it; - - it = m_mapFwPubDpMi.find(TagName); - if (it == m_mapFwPubDpMi.end()) - return NULL; - - return (SFesFwPubMi*)&it->second; -} - -/** -* @brief CFesBase::WriteSoeEventBuf -* 写入SOE EVENT缓冲区内容,如需转发，也写入转发RTU SOE EVENT缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入数据 -*/ -void CFesBase::WriteSoeEventBuf(CFesRtuPtr curRtuPtr, int num, SFesSoeEvent *buffer) -{ - int i, j,index, count; - SFesFwSoeEvent FwEvent; - SFesDi *pDi; - CFesRtuPtr rtuPtr; - - boost::mutex::scoped_lock lock(curRtuPtr->m_EventMutex); - count = curRtuPtr->SoeEventBuf.size(); - if ((count + num) > curRtuPtr->DiMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->SoeEventBuf.empty()) - { - curRtuPtr->SoeEventBuf.front(); //从头开始读取数据 - curRtuPtr->SoeEventBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d SoeEventBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->SoeEventBuf.push(buffer[i]); - //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("SOE RtuNo:%d PointNo=%d TagName:%s value=%d ms=[%" PRId64 "] count=%d", - curRtuPtr->m_Param.RtuNo, buffer[i].PointNo,buffer[i].TagName, buffer[i].Value, buffer[i].time,m_SoeCount); - m_SoeCount++; - } - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) - { - pDi = curRtuPtr->m_pDi + buffer[i].PointNo; - if (pDi->FwMapNum>0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - FwEvent.time = buffer[i].time; - FwEvent.FaultNum = buffer[i].FaultNum; - for (j = 0; j < CN_FesMaxFaultNum; j++) - { - FwEvent.FaultValTag[j] = buffer[i].FaultValTag[j]; - FwEvent.FaultVal[j] = buffer[i].FaultVal[j]; - } - for (j=0; j < pDi->FwMapNum; j++) - { - index = pDi->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; - rtuPtr->WriteFwSoeEventBuf(FwEvent); - } - } - } - } - } -} - -/** -* @brief CFesBase::WriteChgDiValue -* FES（规约模块）写入数字量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入内容 -*/ -void CFesBase::WriteChgDiValue(CFesRtuPtr curRtuPtr,int num, SFesChgDi *buffer) -{ - int i, j, index, count; - SFesFwChgDi FwEvent; - SFesDi *pDi; - CFesRtuPtr rtuPtr; - SFesFwChgDi ChgValue; - - boost::mutex::scoped_lock lock(curRtuPtr->m_DiChgMutex); - count = curRtuPtr->DiChgBuf.size(); - if ((count + num) > curRtuPtr->DiMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->DiChgBuf.empty()) - { - curRtuPtr->DiChgBuf.front(); //从头开始读取数据 - curRtuPtr->DiChgBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d DiChgBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->DiChgBuf.push(buffer[i]); - //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("DI change RtuNo:%d PointNo=%d TagName:%s value=%d ms=[%" PRId64 "] count=%d", - curRtuPtr->m_Param.RtuNo, buffer[i].PointNo, buffer[i].TagName, buffer[i].Value, buffer[i].time,m_DiChgCount); - m_DiChgCount++; - } - - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) - { - pDi = curRtuPtr->m_pDi + buffer[i].PointNo; - if (pDi->FwMapNum > 0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - FwEvent.time = buffer[i].time; - ChgValue.Status = buffer[i].Status; - ChgValue.Value = buffer[i].Value; - ChgValue.time = buffer[i].time; - for (j = 0; j < pDi->FwMapNum; j++) - { - index = pDi->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; - ChgValue.RemoteNo = FwEvent.RemoteNo; - rtuPtr->WriteFwDiBuf(FwEvent); - rtuPtr->UpdataFwDiValue(ChgValue); - } - } - } - } - } - -} - -/** -* @brief CFesBase::WriteChgAiValue -* FES（规约模块）写入模拟量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入内容 -*/ -void CFesBase::WriteChgAiValue(CFesRtuPtr curRtuPtr, int num, SFesChgAi *buffer) -{ - int i, j, index, count; - SFesFwChgAi FwEvent; - SFesAi *pAi; - CFesRtuPtr rtuPtr; - SFesFwChgAi ChgValue; - - boost::mutex::scoped_lock lock(curRtuPtr->m_AiChgMutex); - count = curRtuPtr->AiChgBuf.size(); - if ((count + num) > curRtuPtr->AiMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->AiChgBuf.empty()) - { - curRtuPtr->AiChgBuf.front(); //从头开始读取数据 - curRtuPtr->AiChgBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d AiChgBuf overflow AiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->AiMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->AiChgBuf.push(buffer[i]); - } - - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxAiPoints)) - { - pAi = curRtuPtr->m_pAi + buffer[i].PointNo; - if (pAi->FwMapNum > 0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - FwEvent.time = buffer[i].time; - ChgValue.Status = buffer[i].Status; - ChgValue.Value = buffer[i].Value; - ChgValue.time = buffer[i].time; - for (j = 0; j < pAi->FwMapNum; j++) - { - index = pAi->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pAi->FwMapping[j].RemoteNo; - ChgValue.RemoteNo = FwEvent.RemoteNo; - rtuPtr->WriteFwAiBuf(FwEvent); - rtuPtr->UpdataFwAiValue(ChgValue); - } - } - } - } - } -} - -/** -* @brief CFesBase::WriteChgAccValue -* FES（规约模块）写入整形量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入内容 -*/ -void CFesBase::WriteChgAccValue(CFesRtuPtr curRtuPtr, int num, SFesChgAcc *buffer) -{ - int i, j, index ; - SFesFwChgAcc FwEvent; - SFesAcc *pAcc; - CFesRtuPtr rtuPtr; - SFesFwChgAcc ChgValue; - - boost::mutex::scoped_lock lock(curRtuPtr->m_AccChgMutex); - int count = curRtuPtr->AccChgBuf.size(); - if ((count + num) > curRtuPtr->AccMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->AccChgBuf.empty()) - { - curRtuPtr->AccChgBuf.front(); //从头开始读取数据 - curRtuPtr->AccChgBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d AccChgBuf overflow AccMaxChgNum=%d clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->AccMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->AccChgBuf.push(buffer[i]); - } - - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxAccPoints)) - { - pAcc = curRtuPtr->m_pAcc + buffer[i].PointNo; - if (pAcc->FwMapNum > 0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - ChgValue.Status = buffer[i].Status; - ChgValue.Value = buffer[i].Value; - ChgValue.time = buffer[i].time; - FwEvent.time = buffer[i].time; - for (j = 0; j < pAcc->FwMapNum; j++) - { - index = pAcc->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pAcc->FwMapping[j].RemoteNo; - ChgValue.RemoteNo = FwEvent.RemoteNo; - rtuPtr->WriteFwAccBuf(FwEvent); - rtuPtr->UpdataFwAccValue(ChgValue); - } - } - } - } - } -} - -/** -* @brief CFesRtu::WriteChgMiValue -* FES（规约模块）写入整形量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入内容 -*/ -void CFesBase::WriteChgMiValue(CFesRtuPtr curRtuPtr, int num, SFesChgMi *buffer) -{ - int i, j, index ; - SFesFwChgMi FwEvent; - SFesMi *pMi; - CFesRtuPtr rtuPtr; - SFesFwChgMi ChgValue; - - boost::mutex::scoped_lock lock(curRtuPtr->m_MiChgMutex); - int count = curRtuPtr->MiChgBuf.size(); - if ((count + num) > curRtuPtr->MiMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->MiChgBuf.empty()) - { - curRtuPtr->MiChgBuf.front(); //从头开始读取数据 - curRtuPtr->MiChgBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d MiChgBuf overflow MiMaxChgNum=%d clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->MiMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->MiChgBuf.push(buffer[i]); - } - - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxMiPoints)) - { - pMi = curRtuPtr->m_pMi + buffer[i].PointNo; - if (pMi->FwMapNum > 0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - FwEvent.time = buffer[i].time; - ChgValue.Status = buffer[i].Status; - ChgValue.Value = buffer[i].Value; - ChgValue.time = buffer[i].time; - for (j = 0; j < pMi->FwMapNum; j++) - { - index = pMi->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pMi->FwMapping[j].RemoteNo; - ChgValue.RemoteNo = FwEvent.RemoteNo; - rtuPtr->WriteFwMiBuf(FwEvent); - rtuPtr->UpdataFwMiValue(ChgValue); - } - } - } - } - } -} - -void CFesBase::SetFesSubSystem(int SubSystemId,int /*dataType*/) -{ - std::map::iterator pos; - pos = m_mapFesSubSystem.find(SubSystemId); - if (pos == m_mapFesSubSystem.end())//没有找到 - { - m_mapFesSubSystem[SubSystemId] = SubSystemId; - } - FesRxFesDataThreadFlag = 1; -} - -void CFesBase::SetDPSubSystem(int SubSystemId, int /*dataType*/) -{ - std::map::iterator pos; - pos = m_mapDPSubSystem.find(SubSystemId); - if (pos == m_mapDPSubSystem.end())//没有找到 - { - m_mapFesSubSystem[SubSystemId] = SubSystemId; - } - FesRxDPDataThreadFlag = 1; -} - - -CFesRtuPtr CFesBase::GetFwRtuByMappingIndex(int Index) -{ - if ((Index >= 0) && (Index m_Param.Used) && - (m_vectCFesChanPtr[j]->m_Param.ProtocolId == m_protoclName[i].ProtocolId)) - { - return m_vectCFesChanPtr[j]->m_Param.ProtocolId; - } - } - } - } - return -1; -} - -/** -* @brief CFesBase::GetRtuAiValue -* 根据RtuNo ,PointNo获取点值 -* @param RtuNo RTU号 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetRtuAiValue(int RtuNo, int PointNo, SFesFwAiValue *retValue) -{ - CFesRtuPtr ptrRtu; - SFesAi *pAi; - - if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) - return false; - - if ((PointNo < ptrRtu->m_MaxAiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); - pAi=ptrRtu->m_pAi + PointNo; - retValue->Value = pAi->Value; - retValue->Status = pAi->Status; - retValue->time = pAi->time; - return true; - } - - return false; -} - -/** -* @brief CFesBase::GetRtuDiValue -* 根据RtuNo ,PointNo获取点值 -* @param RtuNo RTU号 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetRtuDiValue(int RtuNo, int PointNo, SFesFwDiValue *retValue) -{ - CFesRtuPtr ptrRtu; - SFesDi *pDi; - - if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) - return false; - - if ((PointNo < ptrRtu->m_MaxDiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); - pDi = ptrRtu->m_pDi + PointNo; - retValue->Value = pDi->Value; - retValue->Status = pDi->Status; - retValue->time = pDi->time; - return true; - } - - return false; -} - -/** -* @brief CFesBase::GetRtuAccValue -* 根据RtuNo ,PointNo获取点值 -* @param RtuNo RTU号 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetRtuAccValue(int RtuNo, int PointNo, SFesFwAccValue *retValue) -{ - CFesRtuPtr ptrRtu; - SFesAcc *pAcc; - - if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) - return false; - - if ((PointNo < ptrRtu->m_MaxAccPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); - pAcc = ptrRtu->m_pAcc + PointNo; - retValue->Value = pAcc->Value; - retValue->Status = pAcc->Status; - retValue->time = pAcc->time; - return true; - } - return false; -} - -/** -* @brief CFesBase::GetRtuMiValue -* 根据RtuNo ,PointNo获取点值 -* @param RtuNo RTU号 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetRtuMiValue(int RtuNo, int PointNo, SFesFwMiValue *retValue) -{ - CFesRtuPtr ptrRtu; - SFesMi *pMi; - - if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) - return false; - - if ((PointNo < ptrRtu->m_MaxMiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); - pMi = ptrRtu->m_pMi + PointNo; - retValue->Value = pMi->Value; - retValue->Status = pMi->Status; - retValue->time = pMi->time; - return true; - } - return false; -} - -void CFesBase::UpdateFesAiValue(CFesRtuPtr ptrRtu) -{ - int i; - SFesFwAi *pAi; - SFesFwAiValue Val; - - for (i = 0; i < ptrRtu->m_MaxFwAiPoints; i++) - { - pAi = ptrRtu->m_pFwAi + i; - if (pAi->Used) - { - if ((pAi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pAi->SrcType == CN_FesFw_FesSrc))//本FES点 - { - if (GetRtuAiValue(pAi->FesRtuNo, pAi->FesPointNo, &Val)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); - pAi->Value = Val.Value; - pAi->Status = Val.Status; - pAi->time = Val.time; - } - } - } - } -} - -void CFesBase::UpdateFesDiValue(CFesRtuPtr ptrRtu) -{ - int i; - SFesFwDi *pDi; - SFesFwDiValue Val; - - for (i = 0; i < ptrRtu->m_MaxFwDiPoints; i++) - { - pDi = ptrRtu->m_pFwDi + i; - if (pDi->Used) - { - if ((pDi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pDi->SrcType == CN_FesFw_FesSrc))//本FES点 - { - if (GetRtuDiValue(pDi->FesRtuNo, pDi->FesPointNo, &Val)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); - pDi->Value = Val.Value; - pDi->Status = Val.Status; - pDi->time = Val.time; - } - } - } - } -} - -void CFesBase::UpdateFesAccValue(CFesRtuPtr ptrRtu) -{ - int i; - SFesFwAcc *pAcc; - SFesFwAccValue Val; - - for (i = 0; i < ptrRtu->m_MaxFwAccPoints; i++) - { - pAcc = ptrRtu->m_pFwAcc + i; - if (pAcc->Used) - { - if ((pAcc->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pAcc->SrcType == CN_FesFw_FesSrc))//本FES点 - { - if (GetRtuAccValue(pAcc->FesRtuNo, pAcc->FesPointNo, &Val)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); - pAcc->Value = Val.Value; - pAcc->Status = Val.Status; - pAcc->time = Val.time; - } - } - } - } -} - -void CFesBase::UpdateFesMiValue(CFesRtuPtr ptrRtu) -{ - int i; - SFesFwMi *pMi; - SFesFwMiValue Val; - - for (i = 0; i < ptrRtu->m_MaxFwMiPoints; i++) - { - pMi = ptrRtu->m_pFwMi + i; - if (pMi->Used) - { - if ((pMi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pMi->SrcType == CN_FesFw_FesSrc))//本FES点 - { - if (GetRtuMiValue(pMi->FesRtuNo, pMi->FesPointNo, &Val)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); - pMi->Value = Val.Value; - pMi->Status = Val.Status; - pMi->time = Val.time; - } - } - } - } -} - -/** -* @brief CFesBase::SetRtuProperty -* 设置RTU的采集或转发属性,及采集RTU的通信状态点 -* @param -*/ -void CFesBase::SetRtuProperty() -{ - int ChanNo,i,j; - CFesChanPtr ChanPtr; - SFesDi *pDi; - - for (i = 0; i < (int)m_vectCFesRtuPtr.size(); i++) - { - ChanNo = m_vectCFesRtuPtr[i]->m_Param.ChanNo; - if ((ChanPtr = GetChanDataByChanNo(ChanNo)) != NULL) - { - m_vectCFesRtuPtr[i]->m_ComStatusPointNo = -1; - if (ChanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit) - { - m_vectCFesRtuPtr[i]->m_RtuProperty = CN_Fes_RTU_Forward; - } - else - { - for (j = 0; j < m_vectCFesRtuPtr[i]->m_MaxDiPoints; j++) - { - pDi = m_vectCFesRtuPtr[i]->m_pDi + j; - if ((pDi->Param2 == 65535) && (pDi->Param3 == 65535)) - { - m_vectCFesRtuPtr[i]->m_ComStatusPointNo = j; - break; - } - } - } - } - } -} -/** -* @brief CFesBase::SetWuFangDoStatusByDi -* 设置当前RTU转发Do状态,再把状态传送到FES DO遥控源 -* @param pRtu RTU结构 -* @param RemoteNo 远动号 -* @param Status 状态 -* @return 成功：true 失败：false -*/ -bool CFesBase::SetWuFangDoStatusByDi(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) -{ - SFesFwDi *pFwDi; - - if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDiPoints)) - { - pFwDi = pRtu->m_pFwDi + RemoteNo; - SetWuFangSrcDoStatus(pRtu, pFwDi->DORemoteNo, Status); - return true; - } - else{ - return false; - } -} - - - -/** -* @brief CFesBase::SetWuFangSrcDoStatus -* 设置DO遥控源的五防状态。本FES RTU点直接置上，非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送。 -* @param pRtu RTU结构 -* @param SFesFwDi DI点 -* @return 成功：true 失败：false -*/ -bool CFesBase::SetWuFangSrcDoStatus(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) -{ - SFesFwDo *pFwDo; - CFesRtuPtr pSrcRtu; - SFesFwChgDo doChgEvent; - int i; - - if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDoPoints)) - { - pFwDo = pRtu->m_pFwDo + RemoteNo; - if ((pFwDo->Status&CN_FW_YK_UNBLOCK) != (Status&CN_FW_YK_UNBLOCK))//五防解锁标志有变化 - { - pFwDo->Status = Status;//对应转发RTU遥信遥控状态定义一样 - if (pFwDo->Status&CN_FW_YK_UNBLOCK) - pFwDo->WfBlockedTimeout = getMonotonicMsec();//重新开始五防记时 - else - pFwDo->WfBlockedTimeout = 0; - - if (pFwDo->SrcType == CN_FesFw_FesSrc) - { - if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 - { - for (i = 0; i < pFwDo->FesPointNum; i++) - { - pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[i], pFwDo->Status); - } - } - else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 - { - doChgEvent.SrcSubSystem = pFwDo->SrcSubSystem; - doChgEvent.Status = pFwDo->Status; - doChgEvent.SrcRtuNo = pFwDo->FesRtuNo; - for (i = 0; i < pFwDo->FesPointNum; i++) - { - doChgEvent.SrcPointNo = pFwDo->FesPointNo[i]; - } - WriteWuFangChgDoStatusBuf(1, &doChgEvent); - } - return true; - } - } - } - return false; - -} - - -/** -* @brief CFesBase::SetWuFangSrcDoInitStatus -* 初始化DO遥控源的五防状态。本FES RTU点直接置上，非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送。 -* @param pRtu RTU结构 -* @param SFesFwDi DI点 -* @return 成功：true 失败：false -*/ -bool CFesBase::SetWuFangSrcDoInitStatus(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) -{ - SFesFwDo *pFwDo; - CFesRtuPtr pSrcRtu; - SFesFwChgDo doChgEvent; - int i; - - if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDoPoints)) - { - pFwDo = pRtu->m_pFwDo + RemoteNo; - pFwDo->Status = Status;//对应转发RTU遥信遥控状态定义一样 - pFwDo->WfBlockedTimeout = 0; - if (pFwDo->SrcType == CN_FesFw_FesSrc) - { - if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 - { - for (i = 0; i < pFwDo->FesPointNum; i++) - { - pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[i], pFwDo->Status); - } - } - else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 - { - doChgEvent.SrcSubSystem = pFwDo->SrcSubSystem; - doChgEvent.Status = pFwDo->Status; - doChgEvent.SrcRtuNo = pFwDo->FesRtuNo; - for (i = 0; i < pFwDo->FesPointNum; i++) - { - doChgEvent.SrcPointNo = pFwDo->FesPointNo[i]; - } - WriteWuFangChgDoStatusBuf(1, &doChgEvent); - } - return true; - } - } - return false; - -} - - -/** -* @brief CFesBase::WriteWuFfangChgDoStatusBuf -* FES 转发RTU 写入五防变化队列缓存区, -* @param num 写入个数 -* @param buffer 写入内容 -*/ -void CFesBase::WriteWuFangChgDoStatusBuf(int num, SFesFwChgDo *buffer) -{ - int i; - - boost::mutex::scoped_lock lock(m_FwCtrlMutex); - int count = m_FwDoChgStatusBuf.size(); - if ((count + num) > 10000) - { - LOGERROR("FwDoChgStatusBuf overflow 10000"); - return; - } - for (i = 0; i < num; i++) - { - m_FwDoChgStatusBuf.push(buffer[i]); - } -} - -int CFesBase::ReadWuFfangChgDoStatusBuf(int num, SFesFwChgDo *buffer) -{ - int i, tempNum; - - boost::mutex::scoped_lock lock(m_FwCtrlMutex); - tempNum = 0; - for (i = 0; i < num; i++) - { - if (!m_FwDoChgStatusBuf.empty()) - { - buffer[i] = m_FwDoChgStatusBuf.front(); //从头开始读取数据 - m_FwDoChgStatusBuf.pop(); //清除已读取数据 - tempNum++; - } - } - return tempNum; -} - -/** -* @brief CWfudpcdtDataProcThread::UpdateWuFangStatus -* 定时更新五防状态 -* @return -*/ -void CFesBase::UpdateWuFangStatus(CFesRtuPtr ptrRtu) -{ - SFesFwDo *pFwDo; - CFesRtuPtr pSrcRtu; - SFesFwChgDo doChgEvent[50]; - int i,j,count; - count = 0; - for (i = 0; i < ptrRtu->m_MaxFwDoPoints; i++) - { - pFwDo = ptrRtu->m_pFwDo + i; - if (pFwDo->SrcType == CN_FesFw_FesSrc) - { - if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 - { - for (j = 0; j < pFwDo->FesPointNum; j++) - { - pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[j], pFwDo->Status); - } - } - else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 - { - doChgEvent[count].SrcSubSystem = pFwDo->SrcSubSystem; - doChgEvent[count].Status = pFwDo->Status; - doChgEvent[count].SrcRtuNo = pFwDo->FesRtuNo; - for (j = 0; j < pFwDo->FesPointNum; j++) - { - doChgEvent[count].SrcPointNo = pFwDo->FesPointNo[j]; - count++; - if (count >= 50) - { - WriteWuFangChgDoStatusBuf(count, &doChgEvent[0]); - count = 0; - } - } - } - } - } - if (count > 0) - { - WriteWuFangChgDoStatusBuf(count, &doChgEvent[0]); - count = 0; - } - - -} - - -/** -* @brief CFesBase::WriteRtuSatus -* @param status RTU状态 -* 2019-09-19 thxiao 增加RTU事件的产生 -*/ -void CFesBase::WriteRtuSatus(CFesRtuPtr ptrRtu,int status) -{ - SFesSoeEvent SoeEvent; - SFesChgDi ChgDi; - SFesDi *pDi; - uint64 mSec; - SFesRtuDiValue diValue; - - mSec = getUTCTimeMsec(); - /* - if (ptrRtu->m_Param.AlarmEnable && (ptrRtu->m_Status != status)) - { - LOGDEBUG("RTU:%d 产生事件 老状态=%d 新状态=%d", ptrRtu->m_Param.RtuNo, ptrRtu->m_Status, status); - Event.time = mSec; - memcpy(Event.RtuTagName, ptrRtu->m_Param.TagName, CN_FesMaxTagSize); - memcpy(Event.RtuName, ptrRtu->m_Param.RtuName, CN_FesMaxNameSize); - memcpy(Event.RtuDesc, ptrRtu->m_Param.RtuDesc, CN_FesMaxDescSize); - Event.nLocationId = ptrRtu->m_Param.nLocationId; - Event.nSubSystem = ptrRtu->m_Param.nSubSystem; - Event.nRegionId = 0; //保留不使用； - Event.CurrentChanNo = ptrRtu->m_CurrentChanNo; - Event.Status = status; - ptrRtu->WriteRtuEventBuf(1, &Event); - } - */ - - //2020-02-27 thxiao 增加通信状态点 - if ((ptrRtu->m_RtuProperty == CN_Fes_RTU_Collect) && (ptrRtu->m_ComStatusPointNo >= 0)) - { - if(ptrRtu->m_ComStatusInit) - { - if (ptrRtu->m_Status != status) - { - pDi = ptrRtu->GetDiByPointNo(ptrRtu->m_ComStatusPointNo); - if (pDi != NULL) - { - memset(&SoeEvent, 0, sizeof(SoeEvent)); - SoeEvent.time = mSec; - memcpy(SoeEvent.TableName, pDi->TableName, CN_FesMaxTableNameSize); - memcpy(SoeEvent.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); - memcpy(SoeEvent.TagName, pDi->TagName, CN_FesMaxTagSize); - SoeEvent.FaultNum = 0; - SoeEvent.RtuNo = ptrRtu->m_Param.RtuNo; - SoeEvent.PointNo = pDi->PointNo; - SoeEvent.Status = CN_FesValueUpdate; - - memset(&ChgDi, 0, sizeof(ChgDi)); - memcpy(ChgDi.TableName, pDi->TableName, CN_FesMaxTableNameSize); - memcpy(ChgDi.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); - memcpy(ChgDi.TagName, pDi->TagName, CN_FesMaxTagSize); - ChgDi.Status = CN_FesValueUpdate; - ChgDi.time = mSec; - ChgDi.RtuNo = ptrRtu->m_Param.RtuNo; - ChgDi.PointNo = pDi->PointNo; - - memset(&diValue, 0, sizeof(diValue)); - diValue.PointNo = pDi->PointNo; - diValue.Status = CN_FesValueUpdate; - diValue.time = mSec; - - if (status == CN_FesRtuNormal) - { - SoeEvent.Value = 1; - ChgDi.Value = 1; - diValue.Value = 1; - } - else - { - SoeEvent.Value = 0; - ChgDi.Value = 0; - diValue.Value = 0; - } - WriteChgDiValue(ptrRtu, 1, &ChgDi); - WriteSoeEventBuf(ptrRtu, 1, &SoeEvent); - ptrRtu->WriteRtuDiValue(1, &diValue); - //保存FesSim监视数据 - FesSimServerWriteSoeEvent(1, &SoeEvent); - } - } - } - else - { - if (status == CN_FesRtuNormal) - { - pDi = ptrRtu->GetDiByPointNo(ptrRtu->m_ComStatusPointNo); - if (pDi != NULL) - { - diValue.PointNo = pDi->PointNo; - diValue.Status = CN_FesValueUpdate; - diValue.time = mSec; - diValue.Value = 1; - ptrRtu->WriteRtuDiValue(1, &diValue); - } - ptrRtu->m_ComStatusInit = 1; - } - } - } - ptrRtu->m_Status = status; - ptrRtu->m_OfflineFlag = status; - //2020-05-20 thxiao 通信恢复，清除离线统计 - if (status == CN_FesRtuNormal) - { - CFesChanPtr ptrChan; - if ((ptrChan = GetChanDataByChanNo(ptrRtu->m_Param.ChanNo)) != NULL) - { - if (ptrChan->m_Param.CommType == CN_FesSerialPort) - { - ptrChan->m_OfflineCount = 0; - } - } - } -} - - -/** -* @brief CProtocolBase::ClearRtuOfflineFlag -* 离线监视时间到，清除RTU离线标志 -* @param pChan 通道结构 -* @return 无 -*/ -void CFesBase::ClearRtuOfflineFlag(CFesChanPtr pChan) -{ - int i, RtuNo; - CFesRtuPtr pRtu; - - for (i = 0; i < pChan->m_RtuNum; i++) - { - RtuNo = pChan->m_RtuNo[i]; - if ((pRtu = GetRtuDataByRtuNo(RtuNo)) != NULL) - { - pRtu->m_OfflineFlag = CN_FesRtuNormal; - } - } -} - - -/** -* @brief CFesBase::SetOfflineFlag -* 设置设备离线标志 -* 当通道离线计数大过一定的值是，如果同一串口下没有其他设备正常通信，则串口通道重新打开 -* @param flag 1:CN_FesRtuNormal 2：CN_FesRtuComDown -*/ -void CFesBase::SetOfflineFlag(CFesRtuPtr ptrRtu,int flag) -{ - CFesChanPtr ptrChan; - CFesRtuPtr pRtu; - int i; - - ptrRtu->m_OfflineFlag = flag; - - if (flag == CN_FesRtuComDown) - { - //2020-05-20 thxiao 如果是串口规约，重新打开串口 - if ((ptrChan = GetChanDataByChanNo(ptrRtu->m_Param.ChanNo)) != NULL) - { - if (ptrChan->m_Param.CommType == CN_FesSerialPort) - { - if ((ptrChan->m_OfflineCountReset > 0) && (ptrChan->m_OfflineCount++ >= ptrChan->m_OfflineCountReset)) - { - ptrChan->m_OfflineCount = 0; - for (i = 0; i < ptrChan->m_RtuNum; i++) - { - if ((pRtu = GetRtuDataByRtuNo(ptrChan->m_RtuNo[i])) != NULL) - { - if (pRtu->m_Status == CN_FesRtuNormal)//只要通道下有一个RTU是通信正常的，就不用重新打开串口 - return; - } - } - - SFesAppNetEvent event; - event.EventType = CN_FesAppNetEvent_ReopenChan; - ptrChan->WriteAppNetEvent(1, &event); - LOGDEBUG("离线计数大于%d次，重新打开串口通道%d ", ptrChan->m_OfflineCountReset, ptrChan->m_Param.ChanNo); - } - } - } - } -} - -int CFesBase::GetDevIdByDevTag(CFesRtuPtr ptrRtu, char* TagName) -{ - int DevId = -1; - int i; - - for (i = 0; i < ptrRtu->m_DevInfo.DevNum; i++) - { - if (strcmp(ptrRtu->m_DevInfo.pDev[i].TagName, TagName) == 0) - { - DevId = ptrRtu->m_DevInfo.pDev[i].DevId; - break; - } - } - return DevId; -} - - -/** -* @brief CFesBase::WriteSoeStrEventBuf -* 写入SOE EVENT缓冲区内容,如需转发，也写入转发RTU SOE EVENT缓冲区 -* @param curRtuPtr 当前RtuPtr -* @param num 写入个数 -* @param buffer 写入数据 -*/ -void CFesBase::WriteSoeStrEventBuf(CFesRtuPtr curRtuPtr, int num, SFesSoeStrEvent *buffer) -{ - int i, j, index, count; - SFesFwSoeEvent FwEvent; - SFesDi *pDi; - CFesRtuPtr rtuPtr; - - { - boost::mutex::scoped_lock lock(curRtuPtr->m_EventMutex); - count = curRtuPtr->SoeStrEventBuf.size(); - if ((count + num) > curRtuPtr->DiMaxChgNum) - { - for (i = 0; i < num; i++) - { - if (!curRtuPtr->SoeStrEventBuf.empty()) - { - curRtuPtr->SoeStrEventBuf.front(); //从头开始读取数据 - curRtuPtr->SoeStrEventBuf.pop(); //清除已读取数据 - } - } - LOGERROR("RTU%d SoeStrEventBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); - } - for (i = 0; i < num; i++) - { - curRtuPtr->SoeStrEventBuf.push(buffer[i]); - LOGINFO("SOE RtuNo:%d TagName:%s value=%d ms=[%" PRId64 "]", - curRtuPtr->m_Param.RtuNo, buffer[i].TagName, buffer[i].Value, buffer[i].time); - } - } - //写入转发RTU变化队列 - for (i = 0; i < num; i++) - { - if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) - { - pDi = curRtuPtr->m_pDi + buffer[i].PointNo; - if (pDi->FwMapNum > 0) - { - memset(&FwEvent, 0, sizeof(FwEvent)); - FwEvent.RtuNo = buffer[i].RtuNo; - FwEvent.PointNo = buffer[i].PointNo; - FwEvent.Status = buffer[i].Status; - FwEvent.Value = buffer[i].Value; - FwEvent.time = buffer[i].time; - FwEvent.FaultNum = 0; - //转发协议不需要带上故障参数 - /*FwEvent.FaultNum = buffer[i].FaultNum; - for (j = 0; j < CN_FesMaxFaultNum; j++) - { - FwEvent.FaultValTag[j] = buffer[i].FaultValTag[j]; - FwEvent.FaultVal[j] = buffer[i].FaultVal[j]; - }*/ - for (j = 0; j < pDi->FwMapNum; j++) - { - index = pDi->FwMapping[j].MappingIndex; - if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) - { - FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; - rtuPtr->WriteFwSoeEventBuf(FwEvent); - } - } - } - } - } -} - -/** -* @brief CFesBase::WriteChanEventBuf -* 写入CHAN EVENT缓冲区内容 -* @param num 写入个数 -* @param buffer 写入数据 -*/ -void CFesBase::WriteChanEventBuf(int num, SFesChanEvent *buffer) -{ - int i; - - boost::mutex::scoped_lock lock(m_EventMutex); - for (i = 0; im_Param.RtuNo); - return; - } - - if (StartChanNo == -1)//所有的DI数据都转发 - { - num = m_vectCFesChanPtr.size(); - for (i = 0; i < num; i++) - { - if ((m_vectCFesChanPtr[i]->m_Param.Used) && (m_vectCFesChanPtr[i]->m_Param.CommProperty == CN_FesComProperty_Collect)) - { - for (j = 0; j < m_vectCFesChanPtr[i]->m_RtuNum; j++) - { - RtuNo = m_vectCFesChanPtr[i]->m_RtuNo[j]; - rtuPtr = GetRtuDataByRtuNo(RtuNo); - if (rtuPtr == NULL) - continue; - if (rtuPtr->m_Param.Used) - { - for (k = 0; k < rtuPtr->m_MaxDiPoints; k++) - { - pDi = rtuPtr->m_pDi + k; - pDi->FwMapping[pDi->FwMapNum].MappingIndex = MappingIndex; - pDi->FwMapping[pDi->FwMapNum].RemoteNo = RemoteNo;//远动号没有实际意义。 - RemoteNo++; - pDi->FwMapNum++; - } - } - } - } - } - FwRtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RemoteNo; - return; - } - - num = m_vectCFesChanPtr.size(); - for (i = 0; i < num; i++) - { - if ((m_vectCFesChanPtr[i]->m_Param.Used)&&(m_vectCFesChanPtr[i]->m_Param.CommProperty==CN_FesComProperty_Collect) - &&(m_vectCFesChanPtr[i]->m_Param.ChanNo>= StartChanNo)&&(m_vectCFesChanPtr[i]->m_Param.ChanNo <= EndChanNo)) - { - for (j = 0; j < m_vectCFesChanPtr[i]->m_RtuNum; j++) - { - RtuNo = m_vectCFesChanPtr[i]->m_RtuNo[j]; - rtuPtr = GetRtuDataByRtuNo(RtuNo); - if(rtuPtr==NULL) - continue; - if (rtuPtr->m_Param.Used) - { - for (k = 0; k < rtuPtr->m_MaxDiPoints; k++) - { - pDi = rtuPtr->m_pDi + k; - pDi->FwMapping[pDi->FwMapNum].MappingIndex = MappingIndex; - pDi->FwMapping[pDi->FwMapNum].RemoteNo = RemoteNo;//远动号没有实际意义。 - RemoteNo++; - pDi->FwMapNum++; - } - } - } - } - } - FwRtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RemoteNo; -} - - -/** -* @brief CFesBase::SetRtuBlockSeqNo -* 同一通道下所有RTU块序号统一排列序号 -* @param RtuPtr RTU -* @param StartSeqNo 起始块序号 -* @param retSeqNo 返回块序号 -* @return -*/ -void CFesBase::SetRtuBlockSeqNo(CFesRtuPtr RtuPtr, int StartSeqNo,int &retSeqNo) -{ - int i; - SModbusCmd *pCmd; - for (i = 0; i < RtuPtr->m_Param.ModbusCmdBuf.num; i++) - { - pCmd = RtuPtr->m_Param.ModbusCmdBuf.pCmd + i; - pCmd->SeqNo = StartSeqNo + i; - //LOGDEBUG("RTUNo=%d i=%d pCmd->SeqNo=%d", RtuPtr->m_Param.RtuNo, i, pCmd->SeqNo); - } - retSeqNo += RtuPtr->m_Param.ModbusCmdBuf.num; -} - -/** -* @brief CFesBase::GetFwRtuAiValue -* 根据RtuNo ,PointNo获取点值 -* @param ptrRtu RTU指针 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetFwRtuAiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwAiValue *retValue) -{ - SFesFwAi *pAi; - - if ((PointNo < ptrRtu->m_MaxFwAiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); - pAi = ptrRtu->m_pFwAi + PointNo; - retValue->Value = pAi->Value; - retValue->Status = pAi->Status; - retValue->time = pAi->time; - return true; - } - retValue->Value = 0; - retValue->Status = 0; - retValue->time = 0; - return false; -} - -/** -* @brief CFesBase::GetFwRtuDiValue -* 根据RtuNo ,PointNo获取点值 -* @param CFesRtuPtr RTU指针 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetFwRtuDiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwDiValue *retValue) -{ - SFesFwDi *pDi; - - if ((PointNo < ptrRtu->m_MaxFwDiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); - pDi = ptrRtu->m_pFwDi + PointNo; - retValue->Value = pDi->Value; - retValue->Status = pDi->Status; - retValue->time = pDi->time; - return true; - } - retValue->Value = 0; - retValue->Status = 0; - retValue->time = 0; - return false; -} - -/** -* @brief CFesBase::GetFwRtuAccValue -* 根据RtuNo ,PointNo获取点值 -* @param CFesRtuPtr RTU指针 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetFwRtuAccValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwAccValue *retValue) -{ - SFesFwAcc *pAcc; - - if ((PointNo < ptrRtu->m_MaxAccPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); - pAcc = ptrRtu->m_pFwAcc + PointNo; - retValue->Value = pAcc->Value; - retValue->Status = pAcc->Status; - retValue->time = pAcc->time; - return true; - } - retValue->Value = 0; - retValue->Status = 0; - retValue->time = 0; - return false; -} - -/** -* @brief CFesBase::GetRtuFwMiValue -* 根据RtuNo ,PointNo获取点值 -* @param CFesRtuPtr RTU指针 -* @param PointNo 点号 -* @param retValue 返回值 -* @return 成功：true 失败：false -*/ -bool CFesBase::GetRtuFwMiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwMiValue *retValue) -{ - SFesFwMi *pMi; - - if ((PointNo < ptrRtu->m_MaxFwMiPoints) && (PointNo >= 0)) - { - boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); - pMi = ptrRtu->m_pFwMi + PointNo; - retValue->Value = pMi->Value; - retValue->Status = pMi->Status; - retValue->time = pMi->time; - return true; - } - retValue->Value = 0; - retValue->Status = 0; - retValue->time = 0; - return false; -} +/*FwSoeEventBuf overflow + @file fesbase.cpp + @brief fes基础类 + @author thxiao + @history + 2019-06-05 thxiao SFesRtuParam 增加车站描述，方便保存录波按“车站\设备”保存 + 2019-06-14 thxiao CRdbAccessEx selectOneOrder()默认方式由倒序变为顺序，所有有关实时库的读取方式全变了，使用默认方式。 + 2019-08-23 thxiao 通用配置的文本定义不应该叫“SOE故障相”，应该叫“保护故障”。 + 2019-08-30 thxiao InitBaseData() 增加AI转换后的突变比较范围. + 2019-10-18 thxiao 增加读取RTU保留参数及定值配置。 + 2020-01-05 thxaio + 1、RtuPtr->m_Param.LocationDesc,pDevParam->DevDesc,去掉空格 + 2、InitBaseData() 读取条件由"rtu_no"变为"rtu_tag",但BLOCK除外 + 2020-02-27 thxiao WriteRtuSatus()增加通信状态点 + 2020-03-12 thxiao 配置增加录波使能 + 2020-03-24 thxiao 为测试增加m_SoeCount、m_DiChgCount参数。 + 2020-05-06 thxiao 操作串口监视缓冲区时增加锁，保护读取的数据不受到破坏。 + 2020-05-21 thxiao 增加SetOfflineFlag(),实现串口通信异常时能够重新打开串口。 + 2020-06-01 thxiao + 1、InitProtocolPointMapping()当规约参数1为负数时处理不能越限。 + 2、当通信状态为1后，才开始判断通信状态发生变化 + 3、不再报告RTU事件 + 2020-08-18 thxiao 通信中断的延时判断时间最小值为5S + 2020-09-10 thxiao InitBaseData() 点初始状态为通信中断. + 2020-12-17 thxiao AI,DI,ACC,MI增加DevId + 2021-03-04 thxiao DO AO MO DZ增加DevId + 2021-04-28 thxiao + 1、InitBaseData()读取数据块配置“自定义参数"有问题 + 2、InitProtocolPointMapping() 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + 2021-06-04 thxiao 增加通道事件队列的读写操作 + 2021-08-04 thxiao InitProtocolPointMapping() SFesXXIndex增加Param5\Param6 + 2021-08-12 thxiao 删除部分LOG + 2021-11-05 thxiao InitBaseData() 在某种情况下，配置通道接收发送缓冲区会被清零，导致FES异常。避免这种情况给配置赋非零最小值。 + 2021-12-01 thxiao InitBaseData() 备用通道配置中遇到第一个“-1”,则认为以下的备用通道都无效 + 2021-12-02 thxiao 与规约名称相关的函数，不再区分WIN和LINUX + 2022-04-14 thxiao 所有转发RTU映射表初始化。增加“所有数据转发”通道类型；不需要配置转发点，所有的数据自动转发。 + 2022-06-08 thxiao 删除2022-04-14“所有数据转发”通道类型相关处理。改为使用配置，调用SetFwDiData()来初始化转发DI。 + 2022-06-16 thxiao 增加DI SOE的LOG信息 + 2022-09-06 thxiao 自动分配块序号,供MODBUSTCPV3内部使用 + 2022-10-13 thxiao 2022-09-06修改不完善，需要考虑同一通道下所有RTU块序号统一排列序号。 + 2022-10-24 thxiao 读取ACC配置的顺序错了，改正。原程序不影响外部的程序。 + + */ +#include +#include "FesBase.h" +#include "dbms/rdb_api/CRdbAccessEx.h" +#include "dbms/rdb_api/CRdbAccess.h" +#include "pub_logger_api/logger.h" + +#include "FesForwardConfig.h" + +using namespace std; +using namespace iot_public; +using namespace iot_dbms; + +CFesBase::CFesBase() +{ + int i; + + m_LocationNum = 0; + m_gOfflineTimeReset = 0; + m_gSetTimeReset = 0; + m_gPollWaveTimeReset = 0; + m_gOfflineCountReset = 0; + m_RtuNum = 0; + m_ChanNum = 0; + m_MonChanNo = -1; + m_ptrProtocolBaseDll = NULL; + m_ProtocolNum = 0; + forwarding = new CFesForwarding; + + for(i=0;i condInfo; + std::vector VecFaultCode; + std::vector vecFaultColumn; + + //2019-08-23 thxiao 通用配置的文本定义不应该叫“SOE故障相”，应该叫“保护故障” + iot_dbms::CRdbPublic::addCondInfo(condInfo,"class_name","保护故障"); + vecFaultColumn.push_back("actual_value"); + vecFaultColumn.push_back("display_name"); + + ret = RdbFaultCodeTable.selectAllVec(condInfo,VecFaultCode,vecFaultColumn); + if (ret==false) + { + RdbFaultCodeTable.close(); + LOGERROR("CFesBase::InitBaseData, dict_text_define.selectNoCondition error!"); + return iotFailed; + } + for(i=0;i<(int)VecFaultCode.size();i++) + { + mapFaultCode.insert(pair(VecFaultCode[i].nFaultCode,VecFaultCode[i].FaultName)); + } + RdbFaultCodeTable.close(); + + //读取实时库LOCATION配置 + ret = RdbLocationTable.open(m_strAppLabel.c_str(),RT_FES_LOCATION_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbocationTable::Open error"); + return iotFailed; + } + std::vector VecLocationParam; + std::vector vecLocationColumn; + vecLocationColumn.push_back("location_id"); + vecLocationColumn.push_back("description"); + ret = RdbLocationTable.selectNoCondition(VecLocationParam, vecLocationColumn, "location_id");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbLocationTable.selectNoCondition error!"); + return iotFailed; + } + m_LocationNum = static_cast(VecLocationParam.size()); + if(m_LocationNum>0) + { + for(i=0;i VecRtuParam; + std::vector vecColumn; + vecColumn.push_back("rtu_no"); + vecColumn.push_back("tag_name"); + vecColumn.push_back("rtu_name"); + vecColumn.push_back("description"); + vecColumn.push_back("location_id"); + vecColumn.push_back("sub_system"); + vecColumn.push_back("is_used"); + vecColumn.push_back("rtu_addr"); + vecColumn.push_back("chan_no"); + vecColumn.push_back("recv_fail_num"); + vecColumn.push_back("alarm_enable"); + vecColumn.push_back("res_para_int1"); + vecColumn.push_back("res_para_int2"); + vecColumn.push_back("res_para_int3"); + vecColumn.push_back("res_para_str1"); + vecColumn.push_back("res_para_str2"); //< 字符串类型预留参数 + vecColumn.push_back("is_used_lb"); + vecColumn.push_back("controldisable"); + vecColumn.push_back("cleardataenable"); + + ret = RdbRtuTable.selectNoCondition(VecRtuParam, vecColumn, "rtu_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbRtuTable.selectNoCondition error!"); + return iotFailed; + } + m_RtuNum = static_cast(VecRtuParam.size()); + if(m_RtuNum>0) + { + for(i=0;i(); + if (RtuPtr == NULL) + { + LOGERROR("fesbase.cpp RtuIndex:%d CFesRtuPtr create failed.\n",i); + continue; + } + RtuPtr->m_Param.RtuNo = VecRtuParam[i].RtuNo; + strcpy(RtuPtr->m_Param.TagName,VecRtuParam[i].TagName); + strcpy(RtuPtr->m_Param.RtuName,VecRtuParam[i].RtuName); + strcpy(RtuPtr->m_Param.RtuDesc,VecRtuParam[i].RtuDesc); + RtuPtr->m_Param.nLocationId =VecRtuParam[i].nLocationId; + RtuPtr->m_Param.nSubSystem =VecRtuParam[i].nSubSystem; + RtuPtr->m_Param.Used =VecRtuParam[i].Used; + RtuPtr->m_Param.RtuAddr=VecRtuParam[i].RtuAddr; + RtuPtr->m_Param.ChanNo = VecRtuParam[i].ChanNo; + RtuPtr->m_Param.RecvFailLimit = VecRtuParam[i].RecvFailLimit; + RtuPtr->m_Param.AlarmEnable = VecRtuParam[i].AlarmEnable; + RtuPtr->m_Param.ResParam1 = VecRtuParam[i].ResParam1; + RtuPtr->m_Param.ResParam2 = VecRtuParam[i].ResParam2; + RtuPtr->m_Param.ResParam3 = VecRtuParam[i].ResParam3; + memcpy(RtuPtr->m_Param.DevType,VecRtuParam[i].DevType,CN_FesMaxTagSize); + memcpy(RtuPtr->m_Param.szResParam1,VecRtuParam[i].szResParam1,sizeof(RtuPtr->m_Param.szResParam1)); + RtuPtr->m_Param.WaveEnable = VecRtuParam[i].WaveEnable; + RtuPtr->m_Param.ControlDisable = VecRtuParam[i].ControlDisable; + RtuPtr->m_Param.ClearDataEnable = VecRtuParam[i].ClearDataEnable; + RtuPtr->m_CurrentChanNo = VecRtuParam[i].ChanNo; + RtuPtr->m_RtuIndex=i; + + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + //con.conditionval = RtuPtr->m_Param.RtuNo; + //strcpy(con.name, "rtu_no"); + //2020-01-06 thxiao 使用rtu_tag更为可靠 + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + + //读取DEV INFO + std::vector VecDevInfo; + std::vector vecDevInfoColumn; + vecDevInfoColumn.push_back("rtu_no");//RTUNO + vecDevInfoColumn.push_back("dev_id");//DEVID + vecDevInfoColumn.push_back("dev_desc"); //DEV DESC + vecDevInfoColumn.push_back("tag_name"); //DEV tagname + vecDevInfoColumn.push_back("para_str1"); //< 字符串类型预留参数 + ret = RdbDevInfoTable.open(m_strAppLabel.c_str(), RT_FES_DEV_INFO_TBL); + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData,RdbDevInfoTable::Open error"); + return iotFailed; + } + ret = RdbDevInfoTable.selectOneOrder(con, VecDevInfo, vecDevInfoColumn, "rtu_no");//默认顺序 + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData, RdbDevInfoTable.selectOneCondition error!"); + return iotFailed; + } + RtuPtr->m_DevInfo.RtuNo = RtuPtr->m_Param.RtuNo; + if (VecDevInfo.size() > 0) + { + RtuPtr->m_DevInfo.DevNum = static_cast(VecDevInfo.size()); + RtuPtr->m_DevInfo.pDev = (SFesRtuDevParam*)malloc(RtuPtr->m_DevInfo.DevNum * sizeof(SFesRtuDevParam)); + if (RtuPtr->m_DevInfo.pDev == NULL) + { + RtuPtr->m_DevInfo.DevNum = 0; + } + else + { + memset(RtuPtr->m_DevInfo.pDev, 0, RtuPtr->m_DevInfo.DevNum * sizeof(SFesRtuDevParam)); + SFesRtuDevParam *pDevParam; + for (j = 0; j < RtuPtr->m_DevInfo.DevNum; j++) + { + pDevParam = RtuPtr->m_DevInfo.pDev + j; + pDevParam->DevId = VecDevInfo[j].DevID; + memcpy(pDevParam->TagName, VecDevInfo[j].TagName, CN_FesMaxTagSize); + memcpy(pDevParam->DevDesc, VecDevInfo[j].DevDesc, CN_FesMaxNameSize); + memcpy(pDevParam->szResParam1, VecDevInfo[j].szResParam1, sizeof(pDevParam->szResParam1)); + //把描述中的“.”更换成“_”。 + char *pChar; + pChar = strchr(pDevParam->DevDesc, '.'); + while (pChar != NULL) + { + *pChar = '_'; + pChar = strchr(pDevParam->DevDesc, '.'); + } + + //2020-01-05 把右边空格去掉 + //LOGDEBUG("1 pDevParam->DevDesc=%s!!!!!!", pDevParam->DevDesc); + int len = static_cast(strlen(pDevParam->DevDesc)); + char *p = pDevParam->DevDesc + len - 1; + while ((p >= pDevParam->DevDesc) && (*p == ' ')) + { + *p = '\0'; --p; + } + //LOGDEBUG("2 pDevParam->DevDesc=%s!!!!!!", pDevParam->DevDesc); + + } + } + } + ret = RdbDevInfoTable.close(); + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData,RdbDevInfoTable::close error"); + return iotFailed; + } + + + //READ AI TABLE + std::vector VecAiParam; + std::vector vecAiColumn; + + vecAiColumn.push_back("rtu_no"); + vecAiColumn.push_back("dot_no"); + vecAiColumn.push_back("app_table_name"); + vecAiColumn.push_back("app_column_name"); + vecAiColumn.push_back("app_tag_name"); + vecAiColumn.push_back("tag_name"); + vecAiColumn.push_back("description"); + vecAiColumn.push_back("dev_tag"); + vecAiColumn.push_back("is_filter"); + vecAiColumn.push_back("percent"); + vecAiColumn.push_back("deadband_type"); + vecAiColumn.push_back("deadband"); + vecAiColumn.push_back("zeroband"); + vecAiColumn.push_back("base"); + vecAiColumn.push_back("coeff"); + vecAiColumn.push_back("max_range"); + vecAiColumn.push_back("min_range"); + vecAiColumn.push_back("res_para_int1"); + vecAiColumn.push_back("res_para_int2"); + vecAiColumn.push_back("res_para_int3"); + vecAiColumn.push_back("res_para_int4"); + vecAiColumn.push_back("res_para_int5"); + vecAiColumn.push_back("res_para_int6"); + vecAiColumn.push_back("res_para_int7"); + vecAiColumn.push_back("res_para_int8"); + vecAiColumn.push_back("res_para_str1"); + + ret = RdbAiTable.open(m_strAppLabel.c_str(),RT_FES_AI_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAiTable::Open error"); + return iotFailed; + } + ret = RdbAiTable.selectOneOrder(con,VecAiParam,vecAiColumn,"dot_no");//默认顺序 + //LOGDEBUG("vecAiColumn.size:%d %d",vecAiColumn.size(),ret); + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbAiTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxAiPoints = 0; + count = static_cast(VecAiParam.size()); + //LOGDEBUG("RTU%d VecAiParam.size():%d",RtuPtr->m_Param.RtuNo,count); + if(count>0) + { + RtuPtr->m_MaxAiPoints = VecAiParam[count-1].PointNo+1; + if (RtuPtr->m_MaxAiPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pAi = (SFesAi*)malloc(RtuPtr->m_MaxAiPoints * sizeof(SFesAi)); + if (RtuPtr->m_pAi != NULL) + { + memset(RtuPtr->m_pAi, 0, RtuPtr->m_MaxAiPoints * sizeof(SFesAi)); + for (j = 0; j < count; j++) + { + if ((VecAiParam[j].PointNo>=0)&&(VecAiParam[j].PointNo < RtuPtr->m_MaxAiPoints)) + { + pAi = RtuPtr->m_pAi + VecAiParam[j].PointNo; + pAi->PointNo = VecAiParam[j].PointNo; + strcpy(pAi->TableName, VecAiParam[j].TableName); + strcpy(pAi->ColumnName, VecAiParam[j].ColumnName); + strcpy(pAi->TagName, VecAiParam[j].TagName); + strcpy(pAi->PointTagName, VecAiParam[j].PointTagName); + strcpy(pAi->PointDesc, VecAiParam[j].PointDesc); + pAi->DevId = GetDevIdByDevTag(RtuPtr,VecAiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId + pAi->IsFilter = VecAiParam[j].IsFilter; + pAi->Percent = VecAiParam[j].Percent; + pAi->DeadBandType = VecAiParam[j].DeadBandType; + pAi->DeadBand = (float)VecAiParam[j].DeadBand; + pAi->ZeroBand = (float)VecAiParam[j].ZeroBand; + + if (pAi->ZeroBand > CN_FesFloatCompare) + pAi->IsZeroBand = 1; + else + pAi->IsZeroBand = 0; + + pAi->Base = (float)VecAiParam[j].Base; + pAi->Coeff = (float)VecAiParam[j].Coeff; + pAi->MaxRange = (float)VecAiParam[j].MaxRange; + pAi->MinRange = (float)VecAiParam[j].MinRange; + //2019-08-30 thxiao 增加转换后的突变比较范围 + if (pAi->IsFilter) + { + if (pAi->Percent == 0) + pAi->IsFilter = 0;//值为0，不做突变处理 + else + { + pAi->fPercentValue = (pAi->MaxRange - pAi->MinRange)*pAi->Percent; + pAi->fPercentValue = pAi->fPercentValue / 100; + } + } + pAi->Param1 = VecAiParam[j].Param1; + pAi->Param2 = VecAiParam[j].Param2; + pAi->Param3 = VecAiParam[j].Param3; + pAi->Param4 = VecAiParam[j].Param4; + pAi->Param5 = VecAiParam[j].Param5; + pAi->Param6 = VecAiParam[j].Param6; + pAi->Param7 = VecAiParam[j].Param7; + pAi->Param8 = VecAiParam[j].Param8; + strcpy(pAi->szResParam1, VecAiParam[j].szResParam1); + + pAi->JudgeFlag = CN_SFesAiJudge_Limit | CN_SFesAiJudge_Deadband; + if (pAi->DeadBandType == CN_FesDeadbandType_Percent) + { + if (pAi->MaxRange - pAi->MinRange > CN_FesFloatCompare) + pAi->DeadBandValue = (pAi->MaxRange - pAi->MinRange)*pAi->DeadBand / 100; + else + { + pAi->DeadBandValue = 0.0; + pAi->JudgeFlag &= ~CN_SFesAiJudge_Limit; + } + } + else + pAi->DeadBandValue = pAi->DeadBand; + + if (pAi->DeadBandValue == 0.0) + pAi->JudgeFlag &= ~CN_SFesAiJudge_Deadband; + pAi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 + pAi->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Ai PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAiParam[j].PointNo, RtuPtr->m_MaxAiPoints); + } + } + } + else + { + RtuPtr->m_MaxAiPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pAi create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + ret = RdbAiTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAiTable::close error"); + return iotFailed; + } + + //READ DI TABLE + std::vector VecDiParam; + std::vector vecDiColumn; + vecDiColumn.push_back("rtu_no"); + vecDiColumn.push_back("dot_no"); + vecDiColumn.push_back("app_table_name"); + vecDiColumn.push_back("app_column_name"); + vecDiColumn.push_back("app_tag_name"); + vecDiColumn.push_back("tag_name"); + vecDiColumn.push_back("description"); + vecDiColumn.push_back("dev_tag"); + vecDiColumn.push_back("filter_err"); + vecDiColumn.push_back("filter_disturb"); + vecDiColumn.push_back("disturb_time"); + vecDiColumn.push_back("revers"); + vecDiColumn.push_back("res_para_int1"); + vecDiColumn.push_back("res_para_int2"); + vecDiColumn.push_back("res_para_int3"); + vecDiColumn.push_back("res_para_int4"); + vecDiColumn.push_back("res_para_int5"); + vecDiColumn.push_back("res_para_int6"); + vecDiColumn.push_back("res_para_int7"); + vecDiColumn.push_back("res_para_int8"); + vecDiColumn.push_back("res_para_str1"); + vecDiColumn.push_back("attr"); + vecDiColumn.push_back("ass_dig"); + ret = RdbDiTable.open(m_strAppLabel.c_str(), RT_FES_DI_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDiTable::Open error"); + return iotFailed; + } + ret = RdbDiTable.selectOneOrder(con,VecDiParam, vecDiColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbDiTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxDiPoints = 0; + count = static_cast(VecDiParam.size()); + //LOGDEBUG("RTU%d VecDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); + if (count > 0) + { + RtuPtr->m_MaxDiPoints = VecDiParam[count - 1].PointNo + 1; + if (RtuPtr->m_MaxDiPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pDi = (SFesDi*)malloc(RtuPtr->m_MaxDiPoints * sizeof(SFesDi)); + if (RtuPtr->m_pDi != NULL) + { + memset(RtuPtr->m_pDi, 0, RtuPtr->m_MaxDiPoints * sizeof(SFesDi)); + for (j = 0; j < count; j++) + { + if ((VecDiParam[j].PointNo>=0)&&(VecDiParam[j].PointNo < RtuPtr->m_MaxDiPoints)) + { + pDi = RtuPtr->m_pDi + VecDiParam[j].PointNo; + pDi->PointNo = VecDiParam[j].PointNo; + strcpy(pDi->TableName, VecDiParam[j].TableName); + strcpy(pDi->ColumnName, VecDiParam[j].ColumnName); + strcpy(pDi->TagName, VecDiParam[j].TagName); + strcpy(pDi->PointTagName, VecDiParam[j].PointTagName); + strcpy(pDi->PointDesc, VecDiParam[j].PointDesc); + pDi->DevId = GetDevIdByDevTag(RtuPtr, VecDiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId + pDi->IsFilterErr = VecDiParam[j].IsFilterErr; + pDi->IsFilterDisturb = VecDiParam[j].IsFilterDisturb; + pDi->DisturbTime = VecDiParam[j].DisturbTime; + pDi->Revers = VecDiParam[j].Revers; + pDi->Param1 = VecDiParam[j].Param1; + pDi->Param2 = VecDiParam[j].Param2; + pDi->Param3 = VecDiParam[j].Param3; + pDi->Param4 = VecDiParam[j].Param4; + pDi->Param5 = VecDiParam[j].Param5; + pDi->Param6 = VecDiParam[j].Param6; + pDi->Param7 = VecDiParam[j].Param7; + pDi->Param8 = VecDiParam[j].Param8; + strcpy(pDi->szResParam1, VecDiParam[j].szResParam1); + pDi->Attribute = VecDiParam[j].Attribute; + pDi->RelateDI = VecDiParam[j].RelateDI; + pDi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 + pDi->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Di PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDiParam[j].PointNo, RtuPtr->m_MaxDiPoints); + } + } + } + else + { + RtuPtr->m_MaxDiPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pDi create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbDiTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDiTable::Open error"); + return iotFailed; + } + + + //READ ACC TABLE + std::vector VecAccParam; + std::vector vecAccColumn; + vecAccColumn.push_back("rtu_no"); + vecAccColumn.push_back("dot_no"); + vecAccColumn.push_back("app_table_name"); + vecAccColumn.push_back("app_column_name"); + vecAccColumn.push_back("app_tag_name"); + vecAccColumn.push_back("tag_name"); + vecAccColumn.push_back("description"); + vecAccColumn.push_back("dev_tag");//2022-10-24 thxiao 读取ACC配置的顺序错了，改正。原程序不影响外部的程序 + vecAccColumn.push_back("base"); + vecAccColumn.push_back("coeff"); + vecAccColumn.push_back("res_para_int1"); + vecAccColumn.push_back("res_para_int2"); + vecAccColumn.push_back("res_para_int3"); + vecAccColumn.push_back("res_para_int4"); + vecAccColumn.push_back("res_para_int5"); + vecAccColumn.push_back("res_para_int6"); + vecAccColumn.push_back("res_para_int7"); + vecAccColumn.push_back("res_para_int8"); + vecAccColumn.push_back("res_para_str1"); + ret = RdbAccTable.open(m_strAppLabel.c_str(), RT_FES_ACC_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAccTable::Open error"); + return iotFailed; + } + ret = RdbAccTable.selectOneOrder(con,VecAccParam, vecAccColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbAccTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxAccPoints = 0; + count = static_cast(VecAccParam.size()); + if(count>0) + { + RtuPtr->m_MaxAccPoints = VecAccParam[count-1].PointNo+1; + if (RtuPtr->m_MaxAccPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pAcc = (SFesAcc*)malloc(RtuPtr->m_MaxAccPoints * sizeof(SFesAcc)); + if (RtuPtr->m_pAcc != NULL) + { + memset(RtuPtr->m_pAcc, 0, RtuPtr->m_MaxAccPoints * sizeof(SFesAcc)); + for (j = 0; j < count; j++) + { + if ((VecAccParam[j].PointNo>=0)&&(VecAccParam[j].PointNo < RtuPtr->m_MaxAccPoints)) + { + pAcc = RtuPtr->m_pAcc + VecAccParam[j].PointNo; + pAcc->PointNo = VecAccParam[j].PointNo; + strcpy(pAcc->TableName, VecAccParam[j].TableName); + strcpy(pAcc->ColumnName, VecAccParam[j].ColumnName); + strcpy(pAcc->TagName, VecAccParam[j].TagName); + strcpy(pAcc->PointTagName, VecAccParam[j].PointTagName); + strcpy(pAcc->PointDesc, VecAccParam[j].PointDesc); + pAcc->DevId = GetDevIdByDevTag(RtuPtr, VecAccParam[j].DevTagName);//2020-12-17 thxiao 增加DevId + pAcc->Base = static_cast(VecAccParam[j].Base); + pAcc->Coeff = VecAccParam[j].Coeff; + pAcc->Param1 = VecAccParam[j].Param1; + pAcc->Param2 = VecAccParam[j].Param2; + pAcc->Param3 = VecAccParam[j].Param3; + pAcc->Param4 = VecAccParam[j].Param4; + pAcc->Param5 = VecAccParam[j].Param5; + pAcc->Param6 = VecAccParam[j].Param6; + pAcc->Param7 = VecAccParam[j].Param7; + pAcc->Param8 = VecAccParam[j].Param8; + strcpy(pAcc->szResParam1, VecAccParam[j].szResParam1); + pAcc->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 + pAcc->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Acc PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAccParam[j].PointNo, RtuPtr->m_MaxAccPoints); + } + } + } + else + { + RtuPtr->m_MaxAccPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pAcc create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbAccTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAccTable::close error"); + return iotFailed; + } + + + //READ MI TABLE + std::vector VecMiParam; + std::vector vecMiColumn; + vecMiColumn.push_back("rtu_no"); + vecMiColumn.push_back("dot_no"); + vecMiColumn.push_back("app_table_name"); + vecMiColumn.push_back("app_column_name"); + vecMiColumn.push_back("app_tag_name"); + vecMiColumn.push_back("tag_name"); + vecMiColumn.push_back("description"); + vecMiColumn.push_back("dev_tag"); + vecMiColumn.push_back("base"); + vecMiColumn.push_back("coeff"); + vecMiColumn.push_back("max_range"); + vecMiColumn.push_back("min_range"); + vecMiColumn.push_back("res_para_int1"); + vecMiColumn.push_back("res_para_int2"); + vecMiColumn.push_back("res_para_int3"); + vecMiColumn.push_back("res_para_int4"); + vecMiColumn.push_back("res_para_int5"); + vecMiColumn.push_back("res_para_int6"); + vecMiColumn.push_back("res_para_int7"); + vecMiColumn.push_back("res_para_int8"); + vecMiColumn.push_back("res_para_str1"); + ret = RdbMiTable.open(m_strAppLabel.c_str(), RT_FES_MI_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbMiTable::Open error"); + return iotFailed; + } + ret = RdbMiTable.selectOneOrder(con,VecMiParam, vecMiColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbMiTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxMiPoints = 0; + count = static_cast(VecMiParam.size()); + if(count>0) + { + RtuPtr->m_MaxMiPoints = VecMiParam[count-1].PointNo+1; + if (RtuPtr->m_MaxMiPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pMi = (SFesMi*)malloc(RtuPtr->m_MaxMiPoints * sizeof(SFesMi)); + if (RtuPtr->m_pMi != NULL) + { + memset(RtuPtr->m_pMi, 0, RtuPtr->m_MaxMiPoints * sizeof(SFesMi)); + for (j = 0; j < count; j++) + { + if ((VecMiParam[j].PointNo>=0)&&(VecMiParam[j].PointNo < RtuPtr->m_MaxMiPoints)) + { + pMi = RtuPtr->m_pMi + VecMiParam[j].PointNo; + pMi->PointNo = VecMiParam[j].PointNo; + strcpy(pMi->TableName, VecMiParam[j].TableName); + strcpy(pMi->ColumnName, VecMiParam[j].ColumnName); + strcpy(pMi->TagName, VecMiParam[j].TagName); + strcpy(pMi->PointTagName, VecMiParam[j].PointTagName); + strcpy(pMi->PointDesc, VecMiParam[j].PointDesc); + pMi->DevId = GetDevIdByDevTag(RtuPtr, VecMiParam[j].DevTagName);//2020-12-17 thxiao 增加DevId + pMi->Base = VecMiParam[j].Base; + pMi->Coeff = VecMiParam[j].Coeff; + pMi->MaxRange = VecMiParam[j].MaxRange; + pMi->MinRange = VecMiParam[j].MinRange; + pMi->Param1 = VecMiParam[j].Param1; + pMi->Param2 = VecMiParam[j].Param2; + pMi->Param3 = VecMiParam[j].Param3; + pMi->Param4 = VecMiParam[j].Param4; + pMi->Param5 = VecMiParam[j].Param5; + pMi->Param6 = VecMiParam[j].Param6; + pMi->Param7 = VecMiParam[j].Param7; + pMi->Param8 = VecMiParam[j].Param8; + strcpy(pMi->szResParam1, VecMiParam[j].szResParam1); + pMi->Status |= CN_FesValueComDown;//2020-09-10 thxiao 点初始状态为通信中断 + pMi->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Mi PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMiParam[j].PointNo, RtuPtr->m_MaxMiPoints); + } + } + } + else + { + RtuPtr->m_MaxMiPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pMi create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbMiTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbMiTable::close error"); + return iotFailed; + } + + //READ DO TABLE + std::vector VecDoParam; + std::vector vecDoColumn; + vecDoColumn.push_back("rtu_no"); + vecDoColumn.push_back("dot_no"); + vecDoColumn.push_back("tag_name"); + vecDoColumn.push_back("description"); + vecDoColumn.push_back("dev_tag"); + vecDoColumn.push_back("revers"); + vecDoColumn.push_back("res_para_int1"); + vecDoColumn.push_back("res_para_int2"); + vecDoColumn.push_back("res_para_int3"); + vecDoColumn.push_back("res_para_int4"); + vecDoColumn.push_back("res_para_int5"); + vecDoColumn.push_back("res_para_int6"); + vecDoColumn.push_back("res_para_int7"); + vecDoColumn.push_back("res_para_int8"); + vecDoColumn.push_back("res_para_str1"); + vecDoColumn.push_back("attr"); + vecDoColumn.push_back("ctrl_type"); + + ret = RdbDoTable.open(m_strAppLabel.c_str(),RT_FES_DO_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDoTable::Open error"); + return iotFailed; + } + ret = RdbDoTable.selectOneOrder(con,VecDoParam, vecDoColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbDoTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxDoPoints = 0; + count = static_cast(VecDoParam.size()); + if(count>0) + { + RtuPtr->m_MaxDoPoints = VecDoParam[count-1].PointNo+1; + if (RtuPtr->m_MaxDoPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pDo = (SFesDo*)malloc(RtuPtr->m_MaxDoPoints * sizeof(SFesDo)); + if (RtuPtr->m_pDo != NULL) + { + memset(RtuPtr->m_pDo, 0, RtuPtr->m_MaxDoPoints * sizeof(SFesDo)); + for (j = 0; j < count; j++) + { + if ((VecDoParam[j].PointNo>=0)&&(VecDoParam[j].PointNo < RtuPtr->m_MaxDoPoints)) + { + pDo = RtuPtr->m_pDo + VecDoParam[j].PointNo; + pDo->PointNo = VecDoParam[j].PointNo; + strcpy(pDo->PointTagName, VecDoParam[j].PointTagName); + strcpy(pDo->PointDesc, VecDoParam[j].PointDesc); + pDo->DevId = GetDevIdByDevTag(RtuPtr, VecDoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId + //pDo->Revers = VecDoParam[j].Revers; + pDo->Param1 = VecDoParam[j].Param1; + pDo->Param2 = VecDoParam[j].Param2; + pDo->Param3 = VecDoParam[j].Param3; + pDo->Param4 = VecDoParam[j].Param4; + pDo->Param5 = VecDoParam[j].Param5; + pDo->Param6 = VecDoParam[j].Param6; + pDo->Param7 = VecDoParam[j].Param7; + pDo->Param8 = VecDoParam[j].Param8; + strcpy(pDo->szResParam1, VecDoParam[j].szResParam1); + pDo->Attribute = VecDoParam[j].Attribute; + pDo->ControlParam = VecDoParam[j].ControlParam; + pDo->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Do PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDoParam[j].PointNo, RtuPtr->m_MaxDoPoints); + } + } + } + else + { + RtuPtr->m_MaxDoPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pDo create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbDoTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDoTable::close error"); + return iotFailed; + } + + + //READ AO TABLE + std::vector VecAoParam; + std::vector vecAoColumn; + vecAoColumn.push_back("rtu_no"); + vecAoColumn.push_back("dot_no"); + vecAoColumn.push_back("tag_name"); + vecAoColumn.push_back("description"); + vecAoColumn.push_back("dev_tag"); + vecAoColumn.push_back("base"); + vecAoColumn.push_back("coeff"); + vecAoColumn.push_back("max_range"); + vecAoColumn.push_back("min_range"); + vecAoColumn.push_back("res_para_int1"); + vecAoColumn.push_back("res_para_int2"); + vecAoColumn.push_back("res_para_int3"); + vecAoColumn.push_back("res_para_int4"); + vecAoColumn.push_back("res_para_int5"); + vecAoColumn.push_back("res_para_int6"); + vecAoColumn.push_back("res_para_int7"); + vecAoColumn.push_back("res_para_int8"); + vecAoColumn.push_back("res_para_str1"); + ret = RdbAoTable.open(m_strAppLabel.c_str(), RT_FES_AO_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAoTable::Open error"); + return iotFailed; + } + ret = RdbAoTable.selectOneOrder(con,VecAoParam, vecAoColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbAoTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxAoPoints = 0; + count = static_cast(VecAoParam.size()); + if(count>0) + { + RtuPtr->m_MaxAoPoints = VecAoParam[count-1].PointNo+1; + if (RtuPtr->m_MaxAoPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pAo = (SFesAo*)malloc(RtuPtr->m_MaxAoPoints * sizeof(SFesAo)); + if (RtuPtr->m_pAo != NULL) + { + memset(RtuPtr->m_pAo, 0, RtuPtr->m_MaxAoPoints * sizeof(SFesAo)); + for (j = 0; j < count; j++) + { + if ((VecAoParam[j].PointNo>=0)&&(VecAoParam[j].PointNo < RtuPtr->m_MaxAoPoints)) + { + pAo = RtuPtr->m_pAo + VecAoParam[j].PointNo; + pAo->PointNo = VecAoParam[j].PointNo; + strcpy(pAo->PointTagName, VecAoParam[j].PointTagName); + strcpy(pAo->PointDesc, VecAoParam[j].PointDesc); + pAo->DevId = GetDevIdByDevTag(RtuPtr, VecAoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId + pAo->Base = (float)VecAoParam[j].Base; + pAo->Coeff = (float)VecAoParam[j].Coeff; + pAo->MaxRange = (float)VecAoParam[j].MaxRange; + pAo->MinRange = (float)VecAoParam[j].MinRange; + pAo->Param1 = VecAoParam[j].Param1; + pAo->Param2 = VecAoParam[j].Param2; + pAo->Param3 = VecAoParam[j].Param3; + pAo->Param4 = VecAoParam[j].Param4; + pAo->Param5 = VecAoParam[j].Param5; + pAo->Param6 = VecAoParam[j].Param6; + pAo->Param7 = VecAoParam[j].Param7; + pAo->Param8 = VecAoParam[j].Param8; + strcpy(pAo->szResParam1, VecAoParam[j].szResParam1); + pAo->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Ao PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAoParam[j].PointNo, RtuPtr->m_MaxAoPoints); + } + } + } + else + { + RtuPtr->m_MaxAoPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pAo create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbAoTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbAoTable::close error"); + return iotFailed; + } + //READ MO TABLE + std::vector VecMoParam; + std::vector vecMoColumn; + vecMoColumn.push_back("rtu_no"); + vecMoColumn.push_back("dot_no"); + vecMoColumn.push_back("tag_name"); + vecMoColumn.push_back("description"); + vecMoColumn.push_back("dev_tag"); + vecMoColumn.push_back("base"); + vecMoColumn.push_back("coeff"); + vecMoColumn.push_back("max_range"); + vecMoColumn.push_back("min_range"); + vecMoColumn.push_back("res_para_int1"); + vecMoColumn.push_back("res_para_int2"); + vecMoColumn.push_back("res_para_int3"); + vecMoColumn.push_back("res_para_int4"); + vecMoColumn.push_back("res_para_int5"); + vecMoColumn.push_back("res_para_int6"); + vecMoColumn.push_back("res_para_int7"); + vecMoColumn.push_back("res_para_int8"); + vecMoColumn.push_back("res_para_str1"); + ret = RdbMoTable.open(m_strAppLabel.c_str(), RT_FES_MO_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbMoTable::Open error"); + return iotFailed; + } + ret = RdbMoTable.selectOneOrder(con,VecMoParam, vecMoColumn, "dot_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbMoTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxMoPoints = 0; + count = static_cast(VecMoParam.size()); + if(count>0) + { + RtuPtr->m_MaxMoPoints = VecMoParam[count-1].PointNo+1; + if (RtuPtr->m_MaxMoPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pMo = (SFesMo*)malloc(RtuPtr->m_MaxMoPoints * sizeof(SFesMo)); + if (RtuPtr->m_pMo != NULL) + { + memset(RtuPtr->m_pMo, 0, RtuPtr->m_MaxMoPoints * sizeof(SFesMo)); + for (j = 0; j < count; j++) + { + if ((VecMoParam[j].PointNo>=0)&&(VecMoParam[j].PointNo < RtuPtr->m_MaxMoPoints)) + { + pMo = RtuPtr->m_pMo + VecMoParam[j].PointNo; + pMo->PointNo = VecMoParam[j].PointNo; + strcpy(pMo->PointTagName, VecMoParam[j].PointTagName); + strcpy(pMo->PointDesc, VecMoParam[j].PointDesc); + pMo->DevId = GetDevIdByDevTag(RtuPtr, VecMoParam[j].DevTagName);//2021-03-03 thxiao 增加DevId + pMo->Base = VecMoParam[j].Base; + pMo->Coeff = VecMoParam[j].Coeff; + pMo->MaxRange = VecMoParam[j].MaxRange; + pMo->MinRange = VecMoParam[j].MinRange; + pMo->Param1 = VecMoParam[j].Param1; + pMo->Param2 = VecMoParam[j].Param2; + pMo->Param3 = VecMoParam[j].Param3; + pMo->Param4 = VecMoParam[j].Param4; + pMo->Param5 = VecMoParam[j].Param5; + pMo->Param6 = VecMoParam[j].Param6; + pMo->Param7 = VecMoParam[j].Param7; + pMo->Param8 = VecMoParam[j].Param8; + strcpy(pMo->szResParam1, VecMoParam[j].szResParam1); + pMo->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Mo PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMoParam[j].PointNo, RtuPtr->m_MaxMoPoints); + } + } + } + else + { + RtuPtr->m_MaxMoPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pMo create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbMoTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbMoTable::close error"); + return iotFailed; + } + + //READ DZ TABLE + std::vector VecDzParam; + std::vector vecDzColumn; + vecDzColumn.push_back("rtu_no"); + vecDzColumn.push_back("dot_no"); + vecDzColumn.push_back("dev_tag"); + vecDzColumn.push_back("group_no"); + vecDzColumn.push_back("seq_no"); + vecDzColumn.push_back("dz_seq"); + vecDzColumn.push_back("value_type"); + vecDzColumn.push_back("unit_id"); + vecDzColumn.push_back("value_added"); + vecDzColumn.push_back("value_ratio"); + vecDzColumn.push_back("value_max"); + vecDzColumn.push_back("value_min"); + vecDzColumn.push_back("res_para_int1"); + vecDzColumn.push_back("res_para_int2"); + vecDzColumn.push_back("res_para_int3"); + vecDzColumn.push_back("res_para_int4"); + vecDzColumn.push_back("res_para_int5"); + vecDzColumn.push_back("res_para_int6"); + vecDzColumn.push_back("res_para_int7"); + vecDzColumn.push_back("res_para_int8"); + vecDzColumn.push_back("res_para_str1"); + + ret = RdbDzTable.open(m_strAppLabel.c_str(), RT_FES_SETTING_TBL); + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData,RdbDzTable::Open error"); + return iotFailed; + } + ret = RdbDzTable.selectOneOrder(con, VecDzParam, vecDzColumn, "dot_no");//默认顺序 + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData, RdbDzTable.selectNoCondition error!"); + return iotFailed; + } + RtuPtr->m_MaxDzPoints = 0; + count = static_cast(VecDzParam.size()); + + if (count > 0) + { + RtuPtr->m_MaxDzPoints = VecDzParam[count - 1].PointNo + 1; + if (RtuPtr->m_MaxDzPoints > 0) + { + //动态分配数据空间 + RtuPtr->m_pDz = (SFesDz*)malloc(RtuPtr->m_MaxDzPoints * sizeof(SFesDz)); + if (RtuPtr->m_pDz != NULL) + { + memset(RtuPtr->m_pDz, 0, RtuPtr->m_MaxDzPoints * sizeof(SFesDz)); + for (j = 0; j < count; j++) + { + if((VecDzParam[j].PointNo>=0)&&(VecDzParam[j].PointNo < RtuPtr->m_MaxDzPoints)) + { + pDz = RtuPtr->m_pDz + VecDzParam[j].PointNo; + pDz->PointNo = VecDzParam[j].PointNo; + pDz->DevId = GetDevIdByDevTag(RtuPtr, VecDzParam[j].DevTagName);//2021-03-03 thxiao 增加DevId + pDz->GroupNo = VecDzParam[j].GroupNo; + pDz->CodeNo = VecDzParam[j].CodeNo; + pDz->SeqNo = VecDzParam[j].SeqNo; + pDz->DzType = VecDzParam[j].DzType; + pDz->Unit = VecDzParam[j].Unit; + pDz->Base = VecDzParam[j].Base; + pDz->Coeff = VecDzParam[j].Coeff; + pDz->MaxRange = VecDzParam[j].MaxRange; + pDz->MinRange = VecDzParam[j].MinRange; + pDz->Param1 = VecDzParam[j].Param1; + pDz->Param2 = VecDzParam[j].Param2; + pDz->Param3 = VecDzParam[j].Param3; + pDz->Param4 = VecDzParam[j].Param4; + pDz->Param5 = VecDzParam[j].Param5; + pDz->Param6 = VecDzParam[j].Param6; + pDz->Param7 = VecDzParam[j].Param7; + pDz->Param8 = VecDzParam[j].Param8; + strcpy(pDz->szResParam1,VecDzParam[j].szResParam1); + pDz->Used = 1; + } + else + { + LOGDEBUG("fesbase.cpp RtuNo:%d Dz PointNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDzParam[j].PointNo, RtuPtr->m_MaxDzPoints); + } + } + } + else + { + RtuPtr->m_MaxDzPoints = 0; + LOGDEBUG("fesbase.cpp RtuNo:%d pDz create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + ret = RdbMoTable.close(); + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData,RdbMoTable::close error"); + return iotFailed; + } + + //READ DATA BLOCK + //2020-01-05 thxiao VecDataBlock暂时没有rtu_tag + //CONDINFO con1; + //con1.relationop = ATTRCOND_EQU; + //con1.conditionval = RtuPtr->m_Param.RtuNo; + //strcpy(con1.name, "rtu_no"); + + + std::vector VecDataBlock; + std::vector vecBlockColumn; + vecBlockColumn.push_back("rtu_no"); + vecBlockColumn.push_back("block_id"); + vecBlockColumn.push_back("func_code"); + vecBlockColumn.push_back("star_addr"); + vecBlockColumn.push_back("data_len"); + vecBlockColumn.push_back("ref_cycle"); + vecBlockColumn.push_back("data_farme_type"); + vecBlockColumn.push_back("is_create_soe"); + vecBlockColumn.push_back("para_int1"); + vecBlockColumn.push_back("para_int2"); + vecBlockColumn.push_back("para_int3");//2021-04-28 thxiao + vecBlockColumn.push_back("para_int4"); + vecBlockColumn.push_back("para_str1"); + vecBlockColumn.push_back("is_enable"); + ret = RdbDataBlockTable.open(m_strAppLabel.c_str(), RT_FES_DATA_BLOCK_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDataBlockTable::Open error"); + return iotFailed; + } + ret = RdbDataBlockTable.selectOneOrder(con,VecDataBlock, vecBlockColumn, "block_id");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbDataBlockTable.selectOneCondition error!"); + return iotFailed; + } + RtuPtr->m_Param.ModbusCmdBuf.num = static_cast(VecDataBlock.size()); + BlockSeqNo = 0; + RtuPtr->m_Param.ModbusCmdBuf.readx = 0; + RtuPtr->m_Param.ModbusCmdBuf.writex = 0; + if(RtuPtr->m_Param.ModbusCmdBuf.num >=0) + { + RtuPtr->m_Param.ModbusCmdBuf.pCmd = (SModbusCmd *)malloc(RtuPtr->m_Param.ModbusCmdBuf.num * sizeof(SModbusCmd)); + if(RtuPtr->m_Param.ModbusCmdBuf.pCmd != NULL) + { + memset(RtuPtr->m_Param.ModbusCmdBuf.pCmd,0,sizeof(SModbusCmd)*RtuPtr->m_Param.ModbusCmdBuf.num); + //init cmd + SModbusCmd *pCmd; + for(int k=0;km_Param.ModbusCmdBuf.num;k++) + { + pCmd = RtuPtr->m_Param.ModbusCmdBuf.pCmd+k; + pCmd->SeqNo = BlockSeqNo;//2022-09-06 thxiao 自动分配块序号,供MODBUSTCPV3内部使用 + BlockSeqNo++; + pCmd->Index = VecDataBlock[k].Index; + pCmd->FunCode = VecDataBlock[k].FunCode; + pCmd->StartAddr = VecDataBlock[k].StartAddr; + pCmd->DataLen = VecDataBlock[k].DataLen; + pCmd->PollTime = VecDataBlock[k].PollTime; + pCmd->Type = VecDataBlock[k].FrameType; + pCmd->IsCreateSoe = VecDataBlock[k].IsCreateSoe; + pCmd->Param1 = VecDataBlock[k].Param1; + pCmd->Param2 = VecDataBlock[k].Param2; + pCmd->Param3 = VecDataBlock[k].Param3; + pCmd->Param4 = VecDataBlock[k].Param4; + strcpy(pCmd->szResParam1,VecDataBlock[k].szResParam1); + pCmd->Used = VecDataBlock[k].Used; + } + } + else + { + RtuPtr->m_Param.ModbusCmdBuf.num = 0; + LOGDEBUG("fesbase.cpp pRtuData->Param.pModbusCmd create failed.\n"); + } + + //分配命令发送缓冲区 + if(RtuPtr->m_Param.ModbusCmdBuf.num>0) + { + RtuPtr->pTxCmdBuf = (SModbuTxCmdBuf*)malloc(sizeof(SModbuTxCmdBuf)); + if(RtuPtr->pTxCmdBuf == NULL) + { + LOGDEBUG(" fesbase.cpp RtuNo:%d malloc pTxCmdBuf error!",RtuPtr->m_Param.RtuNo); + return iotFailed; + } + else + memset(RtuPtr->pTxCmdBuf,0,sizeof(SModbuTxCmdBuf)); + } + } + + ret = RdbDataBlockTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbDataBlockTable::close error"); + return iotFailed; + } + + + RtuPtr->AiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxAiPoints; + RtuPtr->DiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxDiPoints; + RtuPtr->AccMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxAccPoints; + RtuPtr->MiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxMiPoints; + + //2019-05-06 thxiao add location info + for(k=0;km_Param.nLocationId == m_vectLocationPtr[k].nLocationId) + { + strcpy(RtuPtr->m_Param.LocationDesc,m_vectLocationPtr[k].LocationDesc); + + //2020-01-05 把右边空格去掉 + //LOGDEBUG("1 RtuPtr->m_Param.LocationDesc=%s!!!!!!", RtuPtr->m_Param.LocationDesc); + + int len = static_cast(strlen(RtuPtr->m_Param.LocationDesc)); + char *p = RtuPtr->m_Param.LocationDesc + len - 1; + while ((p >= RtuPtr->m_Param.LocationDesc) && (*p == ' ')) + { + *p = '\0'; --p; + } + //LOGDEBUG("1 RtuPtr->m_Param.LocationDesc=%s!!!!!!", RtuPtr->m_Param.LocationDesc); + + break; + } + } + if(strlen(RtuPtr->m_Param.LocationDesc)<=0) + { + sprintf(RtuPtr->m_Param.LocationDesc,"Location%d",RtuPtr->m_Param.nLocationId);//default value + } + RtuPtr->m_ComStatusPointNo = -1;//对应采集RTU通信状态点号，默认为-1； + RtuPtr->m_Status = CN_FesRtuComDown; + m_vectCFesRtuPtr.push_back(RtuPtr); + + //LOGDEBUG("m_strAppLabel: %s",m_strAppLabel.c_str()); + //forwarding->InitFesConllectRtu(RtuPtr,m_strAppLabel); //初始化转发表结构参数 + //LOGDEBUG("RtuPtr: %s",m_strAppLabel.c_str()); + } + + + //init MAP + m_RtuNum = static_cast(m_vectCFesRtuPtr.size()); + for(i=0;im_Param.RtuNo] = m_vectCFesRtuPtr[i]; + m_mapTagRtu[m_vectCFesRtuPtr[i]->m_Param.TagName] = m_vectCFesRtuPtr[i]; + } + } + + + ret = RdbRtuTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbRtuTable::close error"); + return iotFailed; + } + + //读取实时库CHAN配置 + std::vector VecChanParam; + std::vector vecChanColumn; + vecChanColumn.push_back("chan_no"); + vecChanColumn.push_back("tag_name"); + vecChanColumn.push_back("chan_name"); + vecChanColumn.push_back("description"); + vecChanColumn.push_back("location_id"); + vecChanColumn.push_back("sub_system"); + vecChanColumn.push_back("region_id"); + vecChanColumn.push_back("is_used"); + vecChanColumn.push_back("error_rate_limit"); + vecChanColumn.push_back("net_desc1"); + vecChanColumn.push_back("port_no1"); + vecChanColumn.push_back("net_desc2"); + vecChanColumn.push_back("port_no2"); + vecChanColumn.push_back("net_desc3"); + vecChanColumn.push_back("port_no3"); + vecChanColumn.push_back("net_desc4"); + vecChanColumn.push_back("port_no4"); + vecChanColumn.push_back("comm_property"); + vecChanColumn.push_back("comm_type"); + vecChanColumn.push_back("comm_mode"); + vecChanColumn.push_back("proto_type"); + vecChanColumn.push_back("connectwait_sec"); + vecChanColumn.push_back("connect_timeout"); + vecChanColumn.push_back("connect_retrys"); + vecChanColumn.push_back("resp_timeout"); + vecChanColumn.push_back("recv_timeout"); + vecChanColumn.push_back("recvbuf_len"); + vecChanColumn.push_back("sendbuf_len"); + vecChanColumn.push_back("backup_chan_no1"); + vecChanColumn.push_back("backup_chan_no2"); + vecChanColumn.push_back("backup_chan_no3"); + vecChanColumn.push_back("res_para_int1"); + vecChanColumn.push_back("res_para_int2"); + vecChanColumn.push_back("res_para_int3"); + vecChanColumn.push_back("res_para_int4"); + vecChanColumn.push_back("res_para_str1"); + //vecChanColumn.push_back("com_name"); + vecChanColumn.push_back("baud"); + vecChanColumn.push_back("parity"); + vecChanColumn.push_back("databit"); + vecChanColumn.push_back("stopbit"); + vecChanColumn.push_back("alarm_enable"); + + ret = RdbChanTable.open(m_strAppLabel.c_str(),RT_FES_CHAN_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbChanTable::Open error"); + return iotFailed; + } + ret = RdbChanTable.selectNoCondition(VecChanParam, vecChanColumn, "chan_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbChanTable.selectOneCondition error!"); + return iotFailed; + } + m_ChanNum = static_cast(VecChanParam.size()); + if(m_ChanNum>0) + { + for(i=0;i(); + + ChanPtr->m_Param.ChanNo = VecChanParam[i].ChanNo; + strcpy(ChanPtr->m_Param.TagName,VecChanParam[i].TagName); + strcpy(ChanPtr->m_Param.ChanName,VecChanParam[i].ChanName); + strcpy(ChanPtr->m_Param.ChanDesc,VecChanParam[i].ChanDesc); + ChanPtr->m_Param.nLocationId =VecChanParam[i].nLocationId; + ChanPtr->m_Param.nSubSystem =VecChanParam[i].nSubSystem; + ChanPtr->m_Param.nRegionId =VecChanParam[i].nRegionId; + ChanPtr->m_Param.Used=VecChanParam[i].Used; + ChanPtr->m_Param.ErrRateLimit=(float)VecChanParam[i].ErrRateLimit/100;//2020-11-02 thxiao 取百分数 + strcpy(ChanPtr->m_Param.NetRoute[0].NetDesc,VecChanParam[i].NetDesc1); + ChanPtr->m_Param.NetRoute[0].PortNo = VecChanParam[i].PortNo1; + strcpy(ChanPtr->m_Param.NetRoute[1].NetDesc,VecChanParam[i].NetDesc2); + ChanPtr->m_Param.NetRoute[1].PortNo = VecChanParam[i].PortNo2; + strcpy(ChanPtr->m_Param.NetRoute[2].NetDesc,VecChanParam[i].NetDesc3); + ChanPtr->m_Param.NetRoute[2].PortNo = VecChanParam[i].PortNo3; + strcpy(ChanPtr->m_Param.NetRoute[3].NetDesc,VecChanParam[i].NetDesc4); + ChanPtr->m_Param.NetRoute[3].PortNo = VecChanParam[i].PortNo4; + ChanPtr->m_Param.CommProperty = VecChanParam[i].CommProperty; + ChanPtr->m_Param.CommType=VecChanParam[i].CommType; + ChanPtr->m_Param.ChanMode=VecChanParam[i].ChanMode; + ChanPtr->m_Param.ProtocolId=VecChanParam[i].ProtocolId; + ChanPtr->m_Param.ConnectWaitSec=VecChanParam[i].ConnectWaitSec; + if(VecChanParam[i].RespTimeout <= 100) + ChanPtr->m_Param.RespTimeout = 100;//响应超时，单位毫秒 + else + ChanPtr->m_Param.RespTimeout=VecChanParam[i].RespTimeout; //响应超时，单位毫秒 + ChanPtr->m_Param.RetryTimes=VecChanParam[i].RetryTimes; + ChanPtr->m_Param.RecvTimeout=VecChanParam[i].RecvTimeout*1000;//接收超时，单位秒；内部变为毫秒 + ChanPtr->m_Param.ConnectTimeout=VecChanParam[i].ConnectTimeout; + ChanPtr->m_Param.MaxRxSize=VecChanParam[i].MaxRxSize; + ChanPtr->m_Param.MaxTxSize=VecChanParam[i].MaxTxSize; + //2021-11-05 thxiao 在某种情况下，配置通道接收发送缓冲区会被清零，导致FES异常。避免这种情况给配置赋非零最小值 + if (ChanPtr->m_Param.MaxRxSize < 2048) + ChanPtr->m_Param.MaxRxSize = 2048; + if (ChanPtr->m_Param.MaxTxSize < 2048) + ChanPtr->m_Param.MaxTxSize = 2048; + ChanPtr->m_Param.BackupChanNo[0]=VecChanParam[i].BackupChanNo1; + ChanPtr->m_Param.BackupChanNo[1]=VecChanParam[i].BackupChanNo2; + ChanPtr->m_Param.BackupChanNo[2]=VecChanParam[i].BackupChanNo3; + //串口属性设置 + //strcpy(ChanPtr->m_Param.ComPortName,VecChanParam[i].ComPortName); + ChanPtr->m_Param.BaudRate=VecChanParam[i].BaudRate; + ChanPtr->m_Param.Parity=VecChanParam[i].Parity; + ChanPtr->m_Param.DataBit=VecChanParam[i].DataBit; + ChanPtr->m_Param.StopBit=VecChanParam[i].StopBit; + + ChanPtr->m_Param.ResParam1=VecChanParam[i].ResParam1; + ChanPtr->m_Param.ResParam2=VecChanParam[i].ResParam2; + ChanPtr->m_Param.SetTimeEnable=VecChanParam[i].ResParam3; + ChanPtr->m_Param.LocalPortNo=VecChanParam[i].ResParam4; + strcpy(ChanPtr->m_Param.szResParam1,VecChanParam[i].szResParam1); + + ChanPtr->m_Param.AlarmEnable = VecChanParam[i].AlarmEnable; + //分配通道空间 + ChanPtr->m_MaxRxSize=ChanPtr->m_Param.MaxRxSize; + ChanPtr->m_MaxTxSize=ChanPtr->m_Param.MaxTxSize; + ChanPtr->m_RxBuf.pData=(byte*)malloc(ChanPtr->m_MaxRxSize*sizeof(byte)); + if(ChanPtr->m_RxBuf.pData==NULL) + { + ChanPtr->m_MaxRxSize = 0; + LOGDEBUG("fesbase.cpp ChanNo:%d m_RxBuf.pData created failed.\n",ChanPtr->m_Param.ChanNo); + } + ChanPtr->m_TxBuf.pData=(byte*)malloc(ChanPtr->m_MaxTxSize*sizeof(byte)); + if(ChanPtr->m_TxBuf.pData==NULL) + { + ChanPtr->m_MaxTxSize = 0; + LOGDEBUG("fesbase.cpp ChanNo:%d m_TxBuf.pData created failed.\n",ChanPtr->m_Param.ChanNo); + } + //2020-06-03 thxiao 通信中断的延时判断时间 + if (ChanPtr->m_Param.RecvTimeout < 5000)//5s + { + ChanPtr->m_StatusDownStartTimeReset = 5000; + } + else + ChanPtr->m_StatusDownStartTimeReset = ChanPtr->m_Param.RecvTimeout; + + //获取有效配置的通道号个数 + ChanPtr->m_BackupChanNum =1; + ChanPtr->m_BackupChanNo[0]=ChanPtr->m_Param.ChanNo; + int chanCount=1; + for (j = 0; j < (CN_FesMaxChangeChanNum - 1); j++) + { + if (ChanPtr->m_Param.BackupChanNo[j] != -1) + ChanPtr->m_BackupChanNo[chanCount++] = ChanPtr->m_Param.BackupChanNo[j]; + else + break;//2021-12-01 thxiao 备用通道配置中遇到第一个“-1”,则认为以下的备用通道都无效 + } + ChanPtr->m_BackupChanNum = chanCount; + + //获取有效配置的RTU号 + int rtuCount=0; + int StartSeqNo,retSeqNo; + StartSeqNo = 0; + retSeqNo = 0; + for (j = 0; j < static_cast(m_vectCFesRtuPtr.size()); j++) + { + if ((m_vectCFesRtuPtr[j]->m_Param.ChanNo == ChanPtr->m_Param.ChanNo) && + (m_vectCFesRtuPtr[j]->m_Param.Used == 1)) + { + ChanPtr->m_RtuNo[rtuCount++] = m_vectCFesRtuPtr[j]->m_Param.RtuNo; + //2022-10-13 thxiao 同一通道下所有RTU块序号统一排列序号 + SetRtuBlockSeqNo(m_vectCFesRtuPtr[j], StartSeqNo, retSeqNo); + StartSeqNo = retSeqNo; + } + } + ChanPtr->m_RtuNum = rtuCount; + ChanPtr->m_OfflineCountReset = m_gOfflineCountReset*rtuCount;//2020-05-20 thxiao + ChanPtr->m_OfflineCount = 0; + + //RTU获取规约号 2018-12-25 add by thxiao + for (j = 0; j < static_cast(m_vectCFesRtuPtr.size()); j++) + { + if (m_vectCFesRtuPtr[j]->m_Param.ChanNo == ChanPtr->m_Param.ChanNo) + { + m_vectCFesRtuPtr[j]->m_Param.ProtocolId = ChanPtr->m_Param.ProtocolId; + } + } + + //初始配置时主通道标志，通道的切换处理的数据结构只在主通道上有效。1：主通道 0：备通道 + //存在对应的RTU，即说明是主通道。因为备用通道不会出现在RTU配置中。 + if(ChanPtr->m_RtuNum>0) + ChanPtr->ConfigMainFlag =1; + else + ChanPtr->ConfigMainFlag =0; + + m_vectCFesChanPtr.push_back(ChanPtr); + } + //init chan map + m_ChanNum = static_cast(m_vectCFesChanPtr.size()); + for (i = 0; i < static_cast(m_vectCFesChanPtr.size()); i++) + { + m_mapChan[m_vectCFesChanPtr[i]->m_Param.ChanNo] = m_vectCFesChanPtr[i]; + } + } + ret = RdbChanTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbChanTable::close error"); + return iotFailed; + } + + //设置RTU的采集或转发属性 + SetRtuProperty(); + + //读取实时库规约配置 + std::vector VecProtocolParam; + std::vector vecProtocolColumn; + vecProtocolColumn.push_back("protocol_id"); + vecProtocolColumn.push_back("protocol_name"); + + ret = RdbProtocolTable.open(m_strAppLabel.c_str(),RT_FES_PROTOCOL_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbProtocolTable::Open error"); + return iotFailed; + } + ret = RdbProtocolTable.selectNoCondition(VecProtocolParam, vecProtocolColumn, "protocol_id");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbProtocolTable.selectNoCondition error!"); + return iotFailed; + } + + count = static_cast(VecProtocolParam.size()); + if(count>0) + { + int index; + m_ProtocolNum = VecProtocolParam[count-1].ProtocolId+1; + if(m_ProtocolNum>CN_FesMaxProtocolNum) + { + m_ProtocolNum = CN_FesMaxProtocolNum; + LOGERROR("CFesBase::InitBaseData, m_ProtocolNum %d exceed %d!",m_ProtocolNum,CN_FesMaxProtocolNum); + } + + for (i = 0; i < static_cast(VecProtocolParam.size()); i++) + { + index = VecProtocolParam[i].ProtocolId; + if(index < CN_FesMaxProtocolNum) + { + strcpy(m_protoclName[index].Name, VecProtocolParam[i].Name); + m_protoclName[index].ProtocolId = VecProtocolParam[i].ProtocolId; + } + else + { + LOGERROR("CFesBase::InitBaseData ProtocolId %d exceed %d",VecProtocolParam[i].ProtocolId,CN_FesMaxProtocolNum); + } + } + } + + ret = RdbProtocolTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbProtocolTable::close error"); + return iotFailed; + } + + FwRtuInit(); + + //转发RTU映射表初始化 + FwDataInit(); + + LOGDEBUG("FES 初始化配置结束。"); + + return iotSuccess; +} + +/* + @brief GetRtuDataByRtuNo() + + 通过RTU号 读取对应的数据区地址 + @param int RtuNo RTU号 + @return RTU号数据区地址 + @retval +*/ +CFesRtuPtr CFesBase::GetRtuDataByRtuNo(int RtuNo) +{ + map::iterator it; + + + it = m_mapRtu.find(RtuNo); + if(it == m_mapRtu.end()) + return NULL; + + return (CFesRtuPtr)it->second; +} + +/* + @brief GetChanDataByChanNo() + + 通过Chan号 读取对应的数据区地址 + @param int ChanNo CHAN号 + @return CHAN号数据区地址 + @retval +*/ +CFesChanPtr CFesBase::GetChanDataByChanNo(int ChanNo) +{ + map::iterator it; + + it = m_mapChan.find(ChanNo); + if(it == m_mapChan.end()) + return NULL; + + return (CFesChanPtr)it->second; +} + +/** + * @brief CFesBase::SetMonChanNo + * 设置当前监视通道号 + * @param ChanNo + */ +void CFesBase::SetMonChanNo(int ChanNo) +{ + m_FesSimChanMonBuf.ChanNo = ChanNo; +} + +/** + * @brief CFesBase::GetMonChanNo + * 读取当前监视通道号 + * @return 当前监视通道号 + */ +int CFesBase::GetMonChanNo() +{ + return m_FesSimChanMonBuf.ChanNo; +} + + +/** + * @brief CFesBase::FesSimServerWriteSoeEvent + * 对m_FesSimSoeEventBuf写入事件 + * @param num 写入个数 + * @param buffer 写入内容 + */ +void CFesBase::FesSimServerWriteSoeEvent(int num,SFesSoeEvent *buffer) +{ + int spaceCount,i; + + //if(!m_FesSimSoeEventBuf.RefreshFlag) + // return; + + if(m_FesSimSoeEventBuf.Writex!=m_FesSimSoeEventBuf.Readx) + { + spaceCount = (m_FesSimSoeEventBuf.Writex-m_FesSimSoeEventBuf.Readx+CN_FesSimSoeEventMaxBufSize)%CN_FesSimSoeEventMaxBufSize; + if((CN_FesSimSoeEventMaxBufSize-spaceCount)>num) + m_FesSimSoeEventBuf.Overflow = 0; + else + { + m_FesSimSoeEventBuf.Overflow = 1; + //LOGDEBUG("FesBase.cpp m_FesSimSoeEventBuf Overflow!\n"); + } + } + else + m_FesSimSoeEventBuf.Overflow = 0; + + for(i=0;inum) + m_FesSimRtuEventBuf.Overflow = 0; + else + { + m_FesSimRtuEventBuf.Overflow = 1; + //LOGDEBUG("FesBase.cpp m_FesSimRtuEventBuf Overflow!\n"); + } + } + else + m_FesSimRtuEventBuf.Overflow = 0; + + for(i=0;inum) + m_FesSimChanEventBuf.Overflow = 0; + else + { + m_FesSimChanEventBuf.Overflow = 1; + //LOGDEBUG("FesBase.cpp m_FesSimChanEventBuf Overflow!\n"); + } + } + else + m_FesSimChanEventBuf.Overflow = 0; + + for(i=0;inum) + m_FesSimChanMonBuf.Overflow = 0; + else + { + m_FesSimChanMonBuf.Overflow = 1; + //LOGDEBUG("FesBase.cpp m_FesSimChanMonBuf Overflow!\n"); + } + } + else + m_FesSimChanMonBuf.Overflow = 0; + + + for(i=0;i::iterator it; + CFesChanPtr pChan; + + it = m_mapChan.find(ChanNo); + if(it == m_mapChan.end()) + { + retStatistics->TxNum = -1; + retStatistics->RxNum = -1; + retStatistics->ErrNum = -1; + return iotFailed; + } + pChan = (CFesChanPtr)it->second; + retStatistics->TxNum = pChan->m_TxNum; + retStatistics->RxNum = pChan->m_RxNum; + retStatistics->ErrNum = pChan->m_ErrNum; + return iotSuccess; + +} + +/** + * @brief CFesBase::ResetChanStatisticsByChanNo + * 通过Chan号 清除通道统计数据 + * @param ChanNo CHAN号 + * @return iotSuccess,iotFailed + */ +int CFesBase::ResetChanStatisticsByChanNo(int ChanNo) +{ + map::iterator it; + CFesChanPtr pChan; + + it = m_mapChan.find(ChanNo); + if(it == m_mapChan.end()) + return iotFailed; + + pChan = (CFesChanPtr)it->second; + pChan->ResetStatisticsNum(); + return iotSuccess; + +} + +/* + @brief GetRtuDataByRtuTag() + + 通过RTU号 读取对应的数据区地址 + @param char *tagName RTU Tag name + @return RTU号数据区地址 + @retval +*/ +CFesRtuPtr CFesBase::GetRtuDataByRtuTag(char *tagName) +{ + map::iterator it; + + + it = m_mapTagRtu.find(tagName); + if(it == m_mapTagRtu.end()) + return NULL; + + return (CFesRtuPtr)it->second; +} + +/** + * @brief CFesBase::WriteWaveFormBuf + * 写入wave form缓冲区内容 + * @param num waveform 个数 + * @param buffer waveform 内容 + */ +void CFesBase::WriteWaveFormBuf(int num,SFesWaveForm *buffer) +{ + int i; + + boost::mutex::scoped_lock lock(m_WaveFormMutex); + for(i=0;i(m_WaveFormBuf.size()); + return num; +} + +/** + * @brief CFesBase::ReadWaveFormBuf + * 获取waveform内容 + * @param num 获取内容个数 + * @param buffer 返回内容 + * @return 实际获取个数 + */ +int CFesBase::ReadWaveFormBuf(int num,SFesWaveForm *buffer) +{ + int i,tempNum; + + boost::mutex::scoped_lock lock(m_WaveFormMutex); + + tempNum = 0; + for (i=0;i(m_vectCFesRtuPtr.size()); + for(i=0;im_Param.Used) + { + //found the Chan; + if((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo))!=NULL) + { + if(chanPtr->m_Param.Used &&(chanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit)) + { + forwarding->InitFesConllectRtu(m_vectCFesRtuPtr[i],m_strAppLabel); //初始化转发表结构参数 + } + } + } + } +} + +/** + * @brief CFesBase::ProtocolRtuInitByParam1 + * 通过点配置中的“PARAM1”产生规约映射点表 + */ +bool CFesBase::ProtocolRtuInitByParam1(char* ProtocolName) +{ + int i,num,ProtocolId,found; + CFesChanPtr chanPtr; + + found = 0; + for (i = 0; i < CN_FesMaxProtocolNum; i++) + { + if(strstr(m_protoclName[i].Name, ProtocolName)!=NULL) + { + ProtocolId = m_protoclName[i].ProtocolId; + found = 1; + break; + } + } + if(!found) + { + LOGERROR("找不到配置的规约%s，规约映射表初始化失败",ProtocolName); + return false; + } + + //把转发通道对应的有效RTU地址，填入转发RTU映射表 + num = static_cast(m_vectCFesRtuPtr.size()); + for(i=0;im_Param.Used) + { + //found the Chan; + if((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo))!=NULL) + { + if(chanPtr->m_Param.Used &&(chanPtr->m_Param.ProtocolId == ProtocolId)) + { + InitProtocolPointMapping(m_vectCFesRtuPtr[i]); //初始化转发表结构参数 + } + } + } + } + LOGDEBUG("规约%s，规约映射表初始化完成",ProtocolName); + return true; +} + +/** + * @brief CFesBase::InitProtocolPointMapping + * 规约映射表初始化 + * @param RtuPtr + * @return + */ +bool CFesBase::InitProtocolPointMapping(CFesRtuPtr RtuPtr) +{ + iot_dbms::CRdbAccessEx RdbAiTable; + iot_dbms::CRdbAccessEx RdbAoTable; + iot_dbms::CRdbAccessEx RdbDiTable; + iot_dbms::CRdbAccessEx RdbDoTable; + iot_dbms::CRdbAccessEx RdbAccTable; + iot_dbms::CRdbAccessEx RdbMiTable; + iot_dbms::CRdbAccessEx RdbMoTable; + int count,ret; + SFesAiIndex *pAiIndex; + SFesDiIndex *pDiIndex; + SFesAccIndex *pAccIndex; + SFesAoIndex *pAoIndex; + SFesDoIndex *pDoIndex; + SFesMoIndex *pMoIndex; + SFesMiIndex *pMiIndex; + SFesAi *pAi; + SFesDi *pDi; + SFesAcc *pAcc; + SFesAo *pAo; + SFesDo *pDo; + SFesMo *pMo; + SFesMi *pMi; + + int j; + + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + con.conditionval = RtuPtr->m_Param.RtuNo; + strcpy(con.name, "rtu_no"); + + //READ AI TABLE + std::vector VecAiParam; + std::vector vecAiColumn; + + vecAiColumn.push_back("rtu_no"); + vecAiColumn.push_back("dot_no"); + vecAiColumn.push_back("res_para_int1"); + vecAiColumn.push_back("res_para_int2"); + vecAiColumn.push_back("res_para_int3"); + vecAiColumn.push_back("res_para_int4"); + + ret = RdbAiTable.open(m_strAppLabel.c_str(),RT_FES_AI_TBL); + if(ret==false) + { + LOGERROR("RdbAiTable::Open error"); + return iotFailed; + } + ret = RdbAiTable.selectOneOrder(con,VecAiParam,vecAiColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbAiTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbAiTable.close(); + if(ret==false) + { + LOGERROR("RdbAiTable::close error"); + return iotFailed; + } + count = static_cast(VecAiParam.size()); + if(count>0) + { + RtuPtr->m_MaxAiIndex = VecAiParam[count-1].Param1+1; + if (RtuPtr->m_MaxAiIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pAiIndex = (SFesAiIndex*)malloc(RtuPtr->m_MaxAiIndex * sizeof(SFesAiIndex)); + if (RtuPtr->m_pAiIndex != NULL) + { + memset(RtuPtr->m_pAiIndex, 0xff, RtuPtr->m_MaxAiIndex * sizeof(SFesAiIndex)); + for (j = 0; j < RtuPtr->m_MaxAiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pAiIndex = RtuPtr->m_pAiIndex + j; + pAiIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecAiParam[j].Param1 >= 0 && VecAiParam[j].Param1 < RtuPtr->m_MaxAiIndex) + { + pAiIndex = RtuPtr->m_pAiIndex + VecAiParam[j].Param1; + pAiIndex->PointNo = VecAiParam[j].PointNo; + pAiIndex->PIndex = VecAiParam[j].Param1; + if ((pAiIndex->PointNo >= 0) && (pAiIndex->PointNo < RtuPtr->m_MaxAiPoints)) + { + pAi = RtuPtr->m_pAi + pAiIndex->PointNo; + pAiIndex->DevId = pAi->DevId; + pAiIndex->Param2 = pAi->Param2; + pAiIndex->Param3 = pAi->Param3; + pAiIndex->Param4 = pAi->Param4; + //2021-08-04 thxiao add + pAiIndex->Param5 = pAi->Param5; + pAiIndex->Param6 = pAi->Param6; + pAiIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Ai PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAiParam[j].Param1, RtuPtr->m_MaxAiIndex); + } + } + } + else + { + RtuPtr->m_MaxAiIndex = 0; + LOGDEBUG("RtuNo:%d AI protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + + //READ DI TABLE + std::vector VecDiParam; + std::vector vecDiColumn; + + vecDiColumn.push_back("rtu_no"); + vecDiColumn.push_back("dot_no"); + vecDiColumn.push_back("res_para_int1"); + vecDiColumn.push_back("res_para_int2"); + vecDiColumn.push_back("res_para_int3"); + vecDiColumn.push_back("res_para_int4"); + + ret = RdbDiTable.open(m_strAppLabel.c_str(),RT_FES_DI_TBL); + if(ret==false) + { + LOGERROR("RdbDiTable::Open error"); + return iotFailed; + } + ret = RdbDiTable.selectOneOrder(con,VecDiParam,vecDiColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbDiTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbDiTable.close(); + if(ret==false) + { + LOGERROR("RdbDiTable::close error"); + return iotFailed; + } + count = static_cast(VecDiParam.size()); + if(count>0) + { + RtuPtr->m_MaxDiIndex = VecDiParam[count-1].Param1+1; + if (RtuPtr->m_MaxDiIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pDiIndex = (SFesDiIndex*)malloc(RtuPtr->m_MaxDiIndex * sizeof(SFesDiIndex)); + if (RtuPtr->m_pDiIndex != NULL) + { + memset(RtuPtr->m_pDiIndex, 0xff, RtuPtr->m_MaxDiIndex * sizeof(SFesDiIndex)); + for (j = 0; j < RtuPtr->m_MaxDiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pDiIndex = RtuPtr->m_pDiIndex + j; + pDiIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecDiParam[j].Param1 >= 0 && VecDiParam[j].Param1 < RtuPtr->m_MaxDiIndex) + { + pDiIndex = RtuPtr->m_pDiIndex + VecDiParam[j].Param1; + pDiIndex->PointNo = VecDiParam[j].PointNo; + pDiIndex->PIndex = VecDiParam[j].Param1; + if ((pDiIndex->PointNo >= 0) && (pDiIndex->PointNo < RtuPtr->m_MaxDiPoints)) + { + pDi = RtuPtr->m_pDi + pDiIndex->PointNo; + pDiIndex->DevId = pDi->DevId; + pDiIndex->Param2 = pDi->Param2; + pDiIndex->Param3 = pDi->Param3; + pDiIndex->Param4 = pDi->Param4; + pDiIndex->Param5 = pDi->Param5; + pDiIndex->Param6 = pDi->Param6; + pDiIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Di PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDiParam[j].Param1, RtuPtr->m_MaxDiIndex); + } + } + } + else + { + RtuPtr->m_MaxDiIndex = 0; + LOGDEBUG("RtuNo:%d Di protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + //READ ACC TABLE + std::vector VecAccParam; + std::vector vecAccColumn; + + vecAccColumn.push_back("rtu_no"); + vecAccColumn.push_back("dot_no"); + vecAccColumn.push_back("res_para_int1"); + vecAccColumn.push_back("res_para_int2"); + vecAccColumn.push_back("res_para_int3"); + vecAccColumn.push_back("res_para_int4"); + + ret = RdbAccTable.open(m_strAppLabel.c_str(),RT_FES_ACC_TBL); + if(ret==false) + { + LOGERROR("RdbAccTable::Open error"); + return iotFailed; + } + ret = RdbAccTable.selectOneOrder(con,VecAccParam,vecAccColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbAccTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbAccTable.close(); + if(ret==false) + { + LOGERROR("RdbAccTable::close error"); + return iotFailed; + } + + count = static_cast(VecAccParam.size()); + if(count>0) + { + RtuPtr->m_MaxAccIndex = VecAccParam[count-1].Param1+1; + if (RtuPtr->m_MaxAccIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pAccIndex = (SFesAccIndex*)malloc(RtuPtr->m_MaxAccIndex * sizeof(SFesAccIndex)); + if (RtuPtr->m_pAccIndex != NULL) + { + memset(RtuPtr->m_pAccIndex, 0xff, RtuPtr->m_MaxAccIndex * sizeof(SFesAccIndex)); + for (j = 0; j < RtuPtr->m_MaxAccIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pAccIndex = RtuPtr->m_pAccIndex + j; + pAccIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecAccParam[j].Param1 >= 0 && VecAccParam[j].Param1 < RtuPtr->m_MaxAccIndex) + { + pAccIndex = RtuPtr->m_pAccIndex + VecAccParam[j].Param1; + pAccIndex->PointNo = VecAccParam[j].PointNo; + pAccIndex->PIndex = VecAccParam[j].Param1; + if ((pAccIndex->PointNo >= 0) && (pAccIndex->PointNo < RtuPtr->m_MaxAccPoints)) + { + pAcc = RtuPtr->m_pAcc + pAccIndex->PointNo; + pAccIndex->DevId = pAcc->DevId; + pAccIndex->Param2 = pAcc->Param2; + pAccIndex->Param3 = pAcc->Param3; + pAccIndex->Param4 = pAcc->Param4; + pAccIndex->Param5 = pAcc->Param5; + pAccIndex->Param6 = pAcc->Param6; + pAccIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Acc PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAccParam[j].Param1, RtuPtr->m_MaxAccIndex); + } + } + } + else + { + RtuPtr->m_MaxAccIndex = 0; + LOGDEBUG("RtuNo:%d Acc protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + //READ MI TABLE + std::vector VecMiParam; + std::vector vecMiColumn; + + vecMiColumn.push_back("rtu_no"); + vecMiColumn.push_back("dot_no"); + vecMiColumn.push_back("res_para_int1"); + vecMiColumn.push_back("res_para_int2"); + vecMiColumn.push_back("res_para_int3"); + vecMiColumn.push_back("res_para_int4"); + + ret = RdbMiTable.open(m_strAppLabel.c_str(),RT_FES_MI_TBL); + if(ret==false) + { + LOGERROR("RdbMiTable::Open error"); + return iotFailed; + } + ret = RdbMiTable.selectOneOrder(con,VecMiParam,vecMiColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbMiTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbMiTable.close(); + if(ret==false) + { + LOGERROR("RdbMiTable::close error"); + return iotFailed; + } + count = static_cast(VecMiParam.size()); + if(count>0) + { + RtuPtr->m_MaxMiIndex = VecMiParam[count-1].Param1+1; + RtuPtr->m_MinMiIndex = VecMiParam[0].Param1; //记录规约参数1最小值，以便快速判断接收到的协议报文中地址需要解析 + if (RtuPtr->m_MaxMiIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pMiIndex = (SFesMiIndex*)malloc(RtuPtr->m_MaxMiIndex * sizeof(SFesMiIndex)); + if (RtuPtr->m_pMiIndex != NULL) + { + memset(RtuPtr->m_pMiIndex, 0xff, RtuPtr->m_MaxMiIndex * sizeof(SFesMiIndex)); + for (j = 0; j < RtuPtr->m_MaxMiIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pMiIndex = RtuPtr->m_pMiIndex + j; + pMiIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecMiParam[j].Param1 >= 0 && VecMiParam[j].Param1 < RtuPtr->m_MaxMiIndex) + { + pMiIndex = RtuPtr->m_pMiIndex + VecMiParam[j].Param1; + pMiIndex->PointNo = VecMiParam[j].PointNo; + pMiIndex->PIndex = VecMiParam[j].Param1; + if ((pMiIndex->PointNo >= 0) && (pMiIndex->PointNo < RtuPtr->m_MaxMiPoints)) + { + pMi = RtuPtr->m_pMi + pMiIndex->PointNo; + pMiIndex->DevId = pMi->DevId; + pMiIndex->Param2 = pMi->Param2; + pMiIndex->Param3 = pMi->Param3; + pMiIndex->Param4 = pMi->Param4; + pMiIndex->Param5 = pMi->Param5; + pMiIndex->Param6 = pMi->Param6; + pMiIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Mi PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMiParam[j].Param1, RtuPtr->m_MaxMiIndex); + } + } + } + else + { + RtuPtr->m_MaxMiIndex = 0; + RtuPtr->m_MinMiIndex = -1; + LOGDEBUG("RtuNo:%d Mi protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + + //READ DO TABLE + std::vector VecDoParam; + std::vector vecDoColumn; + + vecDoColumn.push_back("rtu_no"); + vecDoColumn.push_back("dot_no"); + vecDoColumn.push_back("res_para_int1"); + vecDoColumn.push_back("res_para_int2"); + vecDoColumn.push_back("res_para_int3"); + vecDoColumn.push_back("res_para_int4"); + + ret = RdbDoTable.open(m_strAppLabel.c_str(),RT_FES_DO_TBL); + if(ret==false) + { + LOGERROR("RdbDoTable::Open error"); + return iotFailed; + } + ret = RdbDoTable.selectOneOrder(con,VecDoParam,vecDoColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbDoTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbDoTable.close(); + if(ret==false) + { + LOGERROR("RdbDoTable::close error"); + return iotFailed; + } + count = static_cast(VecDoParam.size()); + if(count>0) + { + RtuPtr->m_MaxDoIndex = VecDoParam[count-1].Param1+1; + if (RtuPtr->m_MaxDoIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pDoIndex = (SFesDoIndex*)malloc(RtuPtr->m_MaxDoIndex * sizeof(SFesDoIndex)); + if (RtuPtr->m_pDoIndex != NULL) + { + memset(RtuPtr->m_pDoIndex, 0xff, RtuPtr->m_MaxDoIndex * sizeof(SFesDoIndex)); + for (j = 0; j < RtuPtr->m_MaxDoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pDoIndex = RtuPtr->m_pDoIndex + j; + pDoIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecDoParam[j].Param1 >= 0 && VecDoParam[j].Param1 < RtuPtr->m_MaxDoIndex) + { + pDoIndex = RtuPtr->m_pDoIndex + VecDoParam[j].Param1; + pDoIndex->PointNo = VecDoParam[j].PointNo; + pDoIndex->PIndex = VecDoParam[j].Param1; + if ((pDoIndex->PointNo >= 0) && (pDoIndex->PointNo < RtuPtr->m_MaxDoPoints)) + { + pDo = RtuPtr->m_pDo + pDoIndex->PointNo; + pDoIndex->DevId = pDo->DevId; + pDoIndex->Param2 = pDo->Param2; + pDoIndex->Param3 = pDo->Param3; + pDoIndex->Param4 = pDo->Param4; + pDoIndex->Param5 = pDo->Param5; + pDoIndex->Param6 = pDo->Param6; + pDoIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Do PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecDoParam[j].Param1, RtuPtr->m_MaxDoIndex); + } + } + } + else + { + RtuPtr->m_MaxDoIndex = 0; + LOGDEBUG("RtuNo:%d Do protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + //READ AO TABLE + std::vector VecAoParam; + std::vector vecAoColumn; + + vecAoColumn.push_back("rtu_no"); + vecAoColumn.push_back("dot_no"); + vecAoColumn.push_back("res_para_int1"); + vecAoColumn.push_back("res_para_int2"); + vecAoColumn.push_back("res_para_int3"); + vecAoColumn.push_back("res_para_int4"); + + ret = RdbAoTable.open(m_strAppLabel.c_str(),RT_FES_AO_TBL); + if(ret==false) + { + LOGERROR("RdbAoTable::Open error"); + return iotFailed; + } + ret = RdbAoTable.selectOneOrder(con,VecAoParam,vecAoColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbAoTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbAoTable.close(); + if(ret==false) + { + LOGERROR("RdbAoTable::close error"); + return iotFailed; + } + count = static_cast(VecAoParam.size()); + if(count>0) + { + RtuPtr->m_MaxAoIndex = VecAoParam[count-1].Param1+1; + if (RtuPtr->m_MaxAoIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pAoIndex = (SFesAoIndex*)malloc(RtuPtr->m_MaxAoIndex * sizeof(SFesAoIndex)); + if (RtuPtr->m_pAoIndex != NULL) + { + memset(RtuPtr->m_pAoIndex, 0xff, RtuPtr->m_MaxAoIndex * sizeof(SFesAoIndex)); + for (j = 0; j < RtuPtr->m_MaxAoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pAoIndex = RtuPtr->m_pAoIndex + j; + pAoIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecAoParam[j].Param1 >= 0 && VecAoParam[j].Param1 < RtuPtr->m_MaxAoIndex) + { + pAoIndex = RtuPtr->m_pAoIndex + VecAoParam[j].Param1; + pAoIndex->PointNo = VecAoParam[j].PointNo; + pAoIndex->PIndex = VecAoParam[j].Param1; + if ((pAoIndex->PointNo >= 0) && (pAoIndex->PointNo < RtuPtr->m_MaxAoPoints)) + { + pAo = RtuPtr->m_pAo + pAoIndex->PointNo; + pAoIndex->DevId = pAo->DevId; + pAoIndex->Param2 = pAo->Param2; + pAoIndex->Param3 = pAo->Param3; + pAoIndex->Param4 = pAo->Param4; + pAoIndex->Param5 = pAo->Param5; + pAoIndex->Param6 = pAo->Param6; + pAoIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Ao PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecAoParam[j].Param1, RtuPtr->m_MaxAoIndex); + } + } + } + else + { + RtuPtr->m_MaxAoIndex = 0; + LOGDEBUG("RtuNo:%d Ao protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + //READ MO TABLE + std::vector VecMoParam; + std::vector vecMoColumn; + + vecMoColumn.push_back("rtu_no"); + vecMoColumn.push_back("dot_no"); + vecMoColumn.push_back("res_para_int1"); + vecMoColumn.push_back("res_para_int2"); + vecMoColumn.push_back("res_para_int3"); + vecMoColumn.push_back("res_para_int4"); + + ret = RdbMoTable.open(m_strAppLabel.c_str(),RT_FES_MO_TBL); + if(ret==false) + { + LOGERROR("RdbMoTable::Open error"); + return iotFailed; + } + ret = RdbMoTable.selectOneOrder(con,VecMoParam,vecMoColumn,"res_para_int1");//默认顺序 + if (ret==false) + { + LOGERROR("RdbMoTable.selectNoCondition error!"); + return iotFailed; + } + ret = RdbMoTable.close(); + if(ret==false) + { + LOGERROR("RdbMoTable::close error"); + return iotFailed; + } + count = static_cast(VecMoParam.size()); + if(count>0) + { + RtuPtr->m_MaxMoIndex = VecMoParam[count-1].Param1+1; + if (RtuPtr->m_MaxMoIndex > 0) + { + //动态分配数据空间 + RtuPtr->m_pMoIndex = (SFesMoIndex*)malloc(RtuPtr->m_MaxMoIndex * sizeof(SFesMoIndex)); + if (RtuPtr->m_pMoIndex != NULL) + { + memset(RtuPtr->m_pMoIndex, 0xff, RtuPtr->m_MaxMoIndex * sizeof(SFesMoIndex)); + for (j = 0; j < RtuPtr->m_MaxMoIndex; j++)//2021-04-28 thxiao 初始化每个点的 Used=0；原来初始化为-1，但是如果使用if(Used)的判断，也会满足条件，所以对值进行初始化。 + { + pMoIndex = RtuPtr->m_pMoIndex + j; + pMoIndex->Used = 0; + } + for (j = 0; j < count; j++) + { + if (VecMoParam[j].Param1 >= 0 && VecMoParam[j].Param1 < RtuPtr->m_MaxMoIndex) + { + pMoIndex = RtuPtr->m_pMoIndex + VecMoParam[j].Param1; + pMoIndex->PointNo = VecMoParam[j].PointNo; + pMoIndex->PIndex = VecMoParam[j].Param1; + if ((pMoIndex->PointNo >= 0) && (pMoIndex->PointNo < RtuPtr->m_MaxMoPoints)) + { + pMo = RtuPtr->m_pMo + pMoIndex->PointNo; + pMoIndex->DevId = pMo->DevId; + pMoIndex->Param2 = pMo->Param2; + pMoIndex->Param3 = pMo->Param3; + pMoIndex->Param4 = pMo->Param4; + pMoIndex->Param5 = pMo->Param5; + pMoIndex->Param6 = pMo->Param6; + pMoIndex->Used = 1; + } + } + else + { + LOGDEBUG("RtuNo:%d Mo PointIndex %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecMoParam[j].Param1, RtuPtr->m_MaxMoIndex); + } + } + } + else + { + RtuPtr->m_MaxMoIndex = 0; + LOGDEBUG("RtuNo:%d Mo protocol point mapping create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + } + + return iotSuccess; + +} + +/** +* @brief CFesBase::WriteDoReqCmdBuf +* 当转发规约需要发送遥控使用，把控制命令发送到采集规约模块。 +* FES收到遥控命令，写入RTU遥控命令缓存区 +* @param num 写入遥控个数 +* @param buffer 写入遥控内容 +*/ +void CFesBase::WriteDoReqCmdBuf(int num, SFesRxDoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesRxDoCmd *CmdPtr; + SFesFwDoBusCmd BusCmd; + + for (i = 0; iRtuNo)) != NULL)//本FES控制命令 + { + RtuPtr->WriteRxDoCmdBuf(1, CmdPtr); + } + else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + //FwCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.iValue = CmdPtr->iValue; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwDoReqBusCmdBuf(1, &BusCmd); + } + } +} + +/** +* @brief CFesBase::WritexDoRespCmdBuf +* 当采集规约需要发送遥控反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） +* @param num 写入遥控个数 +* @param buffer 写入遥控内容 +*/ +void CFesBase::WritexDoRespCmdBuf(int num, SFesTxDoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesTxDoCmd *CmdPtr; + SFesFwDoBusCmd BusCmd; + SFesFwDoRespCmd RespCmd; + + for (i = 0; iCtrlDir == CN_Fes_CtrlDir_InSide)//FES + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL)//本FES 转发RTU + { + memset(&RespCmd, 0, sizeof(RespCmd)); + RespCmd.FwRtuNo = CmdPtr->FwRtuNo; + RespCmd.FwPointNo = CmdPtr->FwPointNo; + RespCmd.retStatus = CmdPtr->retStatus; + RespCmd.CtrlActType = CmdPtr->CtrlActType; + RespCmd.Param1 = CmdPtr->Param1; + RespCmd.Param2 = CmdPtr->Param2; + RespCmd.fParam = CmdPtr->fParam; + RtuPtr->WriteFwDoRespCmdBuf(1, &RespCmd);//写入原来的RTU的响应队列 + } + else//通过消息总线发送到非本FES + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + BusCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwDoRespBusCmdBuf(1, &BusCmd); + } + } + else//HMI + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) + { + RtuPtr->WriteTxDoCmdBuf(1, CmdPtr); + } + } + } +} + +/** + * @brief CFesRtu::WriteAoReqCmdBuf + * 当转发规约需要发送Ao使用，把控制命令发送到采集规约模块。 + * FES收到遥控命令，写入RTU遥控命令缓存区 + * @param num 写入遥控个数 + * @param buffer 写入遥控内容 + */ +void CFesBase::WriteAoReqCmdBuf(int num,SFesRxAoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesRxAoCmd *CmdPtr; + SFesFwAoBusCmd BusCmd; + SFesFwAoRespCmd RespCmd; + + for(i=0;iRtuNo))!=NULL) + { + RtuPtr->WriteRxAoCmdBuf(1,CmdPtr); + } + else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + //FwCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.fValue = CmdPtr->fValue; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwAoReqBusCmdBuf(1, &BusCmd); + } + } +} + +/** + * @brief CFesBase::WritexAoRespCmdBuf + * 当采集规约需要发送Ao反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） + * @param num 写入遥控个数 + * @param buffer 写入遥控内容 + */ +void CFesBase::WritexAoRespCmdBuf(int num,SFesTxAoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesTxAoCmd *CmdPtr; + SFesFwAoBusCmd BusCmd; + SFesFwAoRespCmd RespCmd; + + for(i=0;iCtrlDir == CN_Fes_CtrlDir_InSide) + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL) + { + memset(&RespCmd, 0, sizeof(RespCmd)); + RespCmd.FwRtuNo = CmdPtr->FwRtuNo; + RespCmd.FwPointNo = CmdPtr->FwPointNo; + RespCmd.retStatus = CmdPtr->retStatus; + RespCmd.CtrlActType = CmdPtr->CtrlActType; + RespCmd.Param1 = CmdPtr->Param1; + RespCmd.Param2 = CmdPtr->Param2; + RespCmd.fParam = CmdPtr->fParam; + RtuPtr->WriteFwAoRespCmdBuf(1, &RespCmd); + } + else + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + BusCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwAoRespBusCmdBuf(1, &BusCmd); + } + } + else//HMI + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) + { + RtuPtr->WriteTxAoCmdBuf(1, CmdPtr); + } + } + } +} + +/** + * @brief CFesRtu::WriteMoReqCmdBuf + * 当转发规约需要发送Mo使用，把控制命令发送到采集规约模块。 + * FES收到遥控命令，写入RTU遥控命令缓存区 + * @param num 写入遥控个数 + * @param buffer 写入遥控内容 + */ +void CFesBase::WriteMoReqCmdBuf(int num,SFesRxMoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesRxMoCmd *CmdPtr; + SFesFwMoBusCmd BusCmd; + + for(i=0;iRtuNo))!=NULL) + { + RtuPtr->WriteRxMoCmdBuf(1,CmdPtr); + } + else//非本FES控制命令，需要通过消息总线发送消息到不同的专业 + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + //FwCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.iValue = CmdPtr->iValue; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwMoReqBusCmdBuf(1, &BusCmd); + } + } +} + +/** + * @brief CFesBase::WritexMoRespCmdBuf + * 当采集规约需要发送Mo反校使用，把控制命令FES外部（HMI）或FES内部（转发规约） + * @param num 写入遥控个数 + * @param buffer 写入遥控内容 + */ +void CFesBase::WritexMoRespCmdBuf(int num,SFesTxMoCmd *buffer) +{ + int i; + CFesRtuPtr RtuPtr; + SFesTxMoCmd *CmdPtr; + SFesFwMoBusCmd BusCmd; + SFesFwMoRespCmd RespCmd; + + for(i=0;iCtrlDir == CN_Fes_CtrlDir_InSide) + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->FwRtuNo)) != NULL) + { + memset(&RespCmd, 0, sizeof(RespCmd)); + RespCmd.FwRtuNo = CmdPtr->FwRtuNo; + RespCmd.FwPointNo = CmdPtr->FwPointNo; + RespCmd.retStatus = CmdPtr->retStatus; + RespCmd.CtrlActType = CmdPtr->CtrlActType; + RespCmd.Param1 = CmdPtr->Param1; + RespCmd.Param2 = CmdPtr->Param2; + RespCmd.fParam = CmdPtr->fParam; + RtuPtr->WriteFwMoRespCmdBuf(1, &RespCmd); + } + else//通过消息总线发送到非本FES + { + memset(&BusCmd, 0, sizeof(BusCmd)); + BusCmd.FwSubSystem = CmdPtr->FwSubSystem; + BusCmd.FwRtuNo = CmdPtr->FwRtuNo; + BusCmd.FwPointNo = CmdPtr->FwPointNo; + BusCmd.SubSystem = CmdPtr->SubSystem; + BusCmd.RtuNo = CmdPtr->RtuNo; + BusCmd.PointID = CmdPtr->PointID; + BusCmd.retStatus = CmdPtr->retStatus; + BusCmd.CtrlActType = CmdPtr->CtrlActType; + BusCmd.Param1 = CmdPtr->Param1; + BusCmd.Param2 = CmdPtr->Param2; + BusCmd.fParam = CmdPtr->fParam; + WriteFwMoRespBusCmdBuf(1, &BusCmd); + } + } + else//HMI + { + if ((RtuPtr = GetRtuDataByRtuNo(CmdPtr->RtuNo)) != NULL) + { + RtuPtr->WriteTxMoCmdBuf(1, CmdPtr); + } + } + } +} + +/** +* @brief CFesBase::FwDiInit +* 转发RTU Di设置转发站标志及公共数据区 +*/ +void CFesBase::FwDiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) +{ + int j; + CFesChanPtr chanPtr; + CFesRtuPtr rtuPtr; + SFesFwDi *pFwDi; + + LOGDEBUG("转发RTU Di设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); + + //单点 + for (j = 0; j < FwRtuPtr->m_MaxFwDiPoints; j++) + { + pFwDi = FwRtuPtr->m_pFwDi + j; + if (pFwDi->Used) + { + if (pFwDi->SrcType == CN_FesFw_FesSrc) + { + if ((rtuPtr = GetRtuDataByRtuNo(pFwDi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 + { + rtuPtr->SetDiFwFlag(pFwDi->FesPointNo, MappingIndex, j); + } + else//非本FES，队列m_mapFwPubFesDi中添加记录 + { + std::map::iterator pos; + pos = m_mapFwPubFesDi.find(pFwDi->DPTagName); + if (pos == m_mapFwPubFesDi.end())//没有找到 + { + SFesFwPubDi PubPoint; + PubPoint.SrcLocationID = pFwDi->SrcLocationID; + PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwDi->DPTagName); + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.SrcPointNo = pFwDi->FesPointNo; + PubPoint.PointType = CN_FesFw_SDI; + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubFesDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetFesSubSystem(pFwDi->SrcSubSystem,CN_Fes_DI); + //LOGDEBUG("DI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwDi->FesRtuNo, pFwDi->FesPointNo, pFwDi->PointDesc, pFwDi->SrcSubSystem); + } + } + else //from DP + { + std::map::iterator pos; + pos = m_mapFwPubDpDi.find(pFwDi->DPTagName); + if (pos == m_mapFwPubDpDi.end())//没有找到 + { + SFesFwPubDi PubPoint; + PubPoint.SrcLocationID = pFwDi->SrcLocationID; + PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwDi->DPTagName); + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.SrcPointNo = pFwDi->DpSeqNo; + PubPoint.PointType = CN_FesFw_SDI; + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubDpDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetDPSubSystem(pFwDi->SrcSubSystem,CN_Fes_DI); + } + } + } + //双点 + for (j = 0; j < FwRtuPtr->m_MaxFwDDiPoints; j++) + { + pFwDi = FwRtuPtr->m_pFwDDi + j; + if (pFwDi->Used) + { + if (pFwDi->SrcType == CN_FesFw_DPSrc)//only DP + { + std::map::iterator pos; + pos = m_mapFwPubDpDi.find(pFwDi->DPTagName); + if (pos == m_mapFwPubDpDi.end())//没有找到 + { + SFesFwPubDi PubPoint; + PubPoint.SrcLocationID = pFwDi->SrcLocationID; + PubPoint.SrcSubSystem = pFwDi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwDi->DPTagName); + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.SrcPointNo = pFwDi->DpSeqNo; + PubPoint.PointType = CN_FesFw_DDI; + PubPoint.FesRtuNo = pFwDi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubDpDi.insert(make_pair(pFwDi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetDPSubSystem(pFwDi->SrcSubSystem, CN_Fes_DI); + } + } + } + LOGDEBUG("转发RTU Di设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); + +} + +/** +* @brief CFesBase::FwAiInit +* 转发RTU Ai设置转发站标志及公共数据区 +*/ +void CFesBase::FwAiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) +{ + int j; + CFesChanPtr chanPtr; + CFesRtuPtr rtuPtr; + SFesFwAi *pFwAi; + + LOGDEBUG("转发RTU Ai设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); + + //单点 + for (j = 0; j < FwRtuPtr->m_MaxFwAiPoints; j++) + { + pFwAi = FwRtuPtr->m_pFwAi + j; + if (pFwAi->Used) + { + if (pFwAi->SrcType == CN_FesFw_FesSrc) + { + if ((rtuPtr = GetRtuDataByRtuNo(pFwAi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 + { + rtuPtr->SetAiFwFlag(pFwAi->FesPointNo, MappingIndex, j); + } + else//非本FES，队列m_mapFwPubFesAi中添加记录 + { + std::map::iterator pos; + pos = m_mapFwPubFesAi.find(pFwAi->DPTagName); + if (pos == m_mapFwPubFesAi.end())//没有找到 + { + SFesFwPubAi PubPoint; + PubPoint.SrcLocationID = pFwAi->SrcLocationID; + PubPoint.SrcSubSystem = pFwAi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwAi->DPTagName); + PubPoint.FesRtuNo = pFwAi->FesRtuNo; + PubPoint.SrcPointNo = pFwAi->FesPointNo; + PubPoint.FesRtuNo = pFwAi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubFesAi.insert(make_pair(pFwAi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetFesSubSystem(pFwAi->SrcSubSystem, CN_Fes_AI); + //LOGDEBUG("AI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwAi->FesRtuNo, pFwAi->FesPointNo, pFwAi->PointDesc, pFwAi->SrcSubSystem); + } + } + else //from DP + { + //LOGDEBUG("======TagName:%s DPTagName:%s Desc:%s", pFwAi->TagName, pFwAi->DPTagName, pFwAi->PointDesc); + + std::map::iterator pos; + pos = m_mapFwPubDpAi.find(pFwAi->DPTagName); + if (pos == m_mapFwPubDpAi.end())//没有找到 + { + SFesFwPubAi PubPoint; + PubPoint.SrcLocationID = pFwAi->SrcLocationID; + PubPoint.SrcSubSystem = pFwAi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwAi->DPTagName); + PubPoint.SrcPointNo = pFwAi->DpSeqNo; + PubPoint.FesRtuNo = pFwAi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubDpAi.insert(make_pair(pFwAi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetDPSubSystem(pFwAi->SrcSubSystem, CN_Fes_AI); + } + } + } + LOGDEBUG("转发RTU Ai设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); +} + + +/** +* @brief CFesBase::FwAccInit +* 转发RTU Acc设置转发站标志及公共数据区 +*/ +void CFesBase::FwAccInit(CFesRtuPtr FwRtuPtr, int MappingIndex) +{ + int j; + CFesChanPtr chanPtr; + CFesRtuPtr rtuPtr; + SFesFwAcc *pFwAcc; + + LOGDEBUG("转发RTU Acc设置转发站标志及公共数据区开始时间 [%" PRId64 "] ", getMonotonicMsec()); + + //单点 + for (j = 0; j < FwRtuPtr->m_MaxFwAccPoints; j++) + { + pFwAcc = FwRtuPtr->m_pFwAcc + j; + if (pFwAcc->Used) + { + if (pFwAcc->SrcType == CN_FesFw_FesSrc) + { + if ((rtuPtr = GetRtuDataByRtuNo(pFwAcc->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 + { + rtuPtr->SetAccFwFlag(pFwAcc->FesPointNo, MappingIndex, j); + } + else//非本FES，队列m_mapFwPubFesAcc中添加记录 + { + if (strlen(pFwAcc->DPTagName) > 0) + { + std::map::iterator pos; + pos = m_mapFwPubFesAcc.find(pFwAcc->DPTagName); + if (pos == m_mapFwPubFesAcc.end())//没有找到 + { + SFesFwPubAcc PubPoint; + PubPoint.SrcLocationID = pFwAcc->SrcLocationID; + PubPoint.SrcSubSystem = pFwAcc->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwAcc->DPTagName); + PubPoint.FesRtuNo = pFwAcc->FesRtuNo; + PubPoint.SrcPointNo = pFwAcc->FesPointNo; + PubPoint.FesRtuNo = pFwAcc->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubFesAcc.insert(make_pair(pFwAcc->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetFesSubSystem(pFwAcc->SrcSubSystem, CN_Fes_ACC); + //LOGDEBUG("ACC RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwAcc->FesRtuNo, pFwAcc->FesPointNo, pFwAcc->PointDesc, pFwAcc->SrcSubSystem); + } + } + } + else //from DP + { + if (strlen(pFwAcc->DPTagName) > 0) + { + std::map::iterator pos; + pos = m_mapFwPubDpAcc.find(pFwAcc->DPTagName); + if (pos == m_mapFwPubDpAcc.end())//没有找到 + { + SFesFwPubAcc PubPoint; + PubPoint.SrcLocationID = pFwAcc->SrcLocationID; + PubPoint.SrcSubSystem = pFwAcc->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwAcc->DPTagName); + PubPoint.FesRtuNo = pFwAcc->FesRtuNo; + PubPoint.SrcPointNo = pFwAcc->DpSeqNo; + PubPoint.FesRtuNo = pFwAcc->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubDpAcc.insert(make_pair(pFwAcc->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetDPSubSystem(pFwAcc->SrcSubSystem, CN_Fes_ACC); + } + } + } + } + LOGDEBUG("转发RTU Acc设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); +} + + +/** +* @brief CFesBase::FwMiInit +* 转发RTU Mi设置转发站标志及公共数据区 +*/ +void CFesBase::FwMiInit(CFesRtuPtr FwRtuPtr, int MappingIndex) +{ + int j; + CFesChanPtr chanPtr; + CFesRtuPtr rtuPtr; + SFesFwMi *pFwMi; + + LOGDEBUG("转发RTU Mi设置转发站标志及公共数据区开始时间 [%" PRId64 "] .", getMonotonicMsec()); + + //单点 + for (j = 0; j < FwRtuPtr->m_MaxFwMiPoints; j++) + { + pFwMi = FwRtuPtr->m_pFwMi + j; + if (pFwMi->Used) + { + if (pFwMi->SrcType == CN_FesFw_FesSrc) + { + if ((rtuPtr = GetRtuDataByRtuNo(pFwMi->FesRtuNo)) != NULL)//本FES,本FES RTU点直接置上映射标志 + { + rtuPtr->SetMiFwFlag(pFwMi->FesPointNo, MappingIndex, j); + } + else//非本FES，队列m_mapFwPubFesMi中添加记录 + { + std::map::iterator pos; + pos = m_mapFwPubFesMi.find(pFwMi->DPTagName); + if (pos == m_mapFwPubFesMi.end())//没有找到 + { + SFesFwPubMi PubPoint; + PubPoint.SrcLocationID = pFwMi->SrcLocationID; + PubPoint.SrcSubSystem = pFwMi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwMi->DPTagName); + PubPoint.FesRtuNo = pFwMi->FesRtuNo; + PubPoint.SrcPointNo = pFwMi->FesPointNo; + PubPoint.FesRtuNo = pFwMi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubFesMi.insert(make_pair(pFwMi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetFesSubSystem(pFwMi->SrcSubSystem, CN_Fes_MI); + //LOGDEBUG("MI RtuNo=%d PointNo=%d %s SetFesSubSystem() SubSystem=%d ", pFwMi->FesRtuNo, pFwMi->FesPointNo, pFwMi->PointDesc, pFwMi->SrcSubSystem); + } + } + else //from DP + { + std::map::iterator pos; + pos = m_mapFwPubDpMi.find(pFwMi->DPTagName); + if (pos == m_mapFwPubDpMi.end())//没有找到 + { + SFesFwPubMi PubPoint; + PubPoint.SrcLocationID = pFwMi->SrcLocationID; + PubPoint.SrcSubSystem = pFwMi->SrcSubSystem; + strcpy(PubPoint.DPTagName, pFwMi->DPTagName); + PubPoint.FesRtuNo = pFwMi->FesRtuNo; + PubPoint.SrcPointNo = pFwMi->DpSeqNo; + PubPoint.FesRtuNo = pFwMi->FesRtuNo; + PubPoint.FwMapping[0].MappingIndex = MappingIndex; + PubPoint.FwMapping[0].RemoteNo = j; + PubPoint.FwMapNum = 1; + m_mapFwPubDpMi.insert(make_pair(pFwMi->DPTagName, PubPoint)); + } + else//已存在，只增加映射RTU + { + if (pos->second.FwMapNum < CN_Fes_Fw_MaxMapping) + { + pos->second.FwMapping[pos->second.FwMapNum].MappingIndex = MappingIndex; + pos->second.FwMapping[pos->second.FwMapNum].RemoteNo = j; + pos->second.FwMapNum++; + } + } + SetDPSubSystem(pFwMi->SrcSubSystem, CN_Fes_MI); + } + } + } + LOGDEBUG("转发RTU Mi设置转发站标志及公共数据区结束时间 [%" PRId64 "] .", getMonotonicMsec()); +} + + +/** +* @brief CFesBase::FwMappingInit +* 初始化转发RTU映射表及设置采集RTU点转发站标志 +*/ +void CFesBase::FwDataInit() +{ + int i, num ; + CFesChanPtr chanPtr; + CFesRtuPtr FwRtuPtr; + + //把转发通道对应的有效RTU地址，填入转发RTU映射表 + num = static_cast(m_vectCFesRtuPtr.size()); + for (i = 0; im_Param.Used) + { + //found the Chan; + if ((chanPtr = GetChanDataByChanNo(m_vectCFesRtuPtr[i]->m_Param.ChanNo)) != NULL) + { + if (chanPtr->m_Param.Used && (chanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit)) + { + if (FwMappingTable.Num>CN_Fes_Fw_MaxMapping) + break; + FwMappingTable.FwRtu[FwMappingTable.Num] = m_vectCFesRtuPtr[i]; + FwMappingTable.Num++; + } + } + } + } + + //FES源RTU点置转发站标志 + LOGDEBUG("FES源RTU点置转发站标志开始时间 [%" PRId64 "] .", getMonotonicMsec()); + for (i = 0; i < FwMappingTable.Num; i++) + { + FwRtuPtr = FwMappingTable.FwRtu[i]; + FwDiInit(FwRtuPtr, i); + FwAiInit(FwRtuPtr, i); + FwAccInit(FwRtuPtr, i); + FwMiInit(FwRtuPtr, i); + } + LOGDEBUG("FES源RTU点置转发站标志结束时间 [%" PRId64 "] .", getMonotonicMsec()); + + LOGINFO("FwMappingInit() 转发RTU映射表初始化成功"); +} + +/** +* @brief CFesBase::GetFesFwMappingIndex +* 通过RtuPtr，获取映射索引 +* @param CFesRtuPtr RtuPtr +*/ +int CFesBase::GetFesFwMappingIndex(CFesRtuPtr RtuPtr) +{ + int i; + for (i = 0; i < FwMappingTable.Num; i++) + { + if (FwMappingTable.FwRtu[i] == RtuPtr)//同一个指针 + return i; + } + if (FwMappingTable.Num < CN_Fes_Fw_MaxMapping) + { + FwMappingTable.FwRtu[FwMappingTable.Num] = RtuPtr; + i = FwMappingTable.Num; + FwMappingTable.Num++; + LOGDEBUG("GetFesFwMappingIndex add new mapping RTUNo=%d FwMappingNum=%d", RtuPtr->m_Param.RtuNo, FwMappingTable.Num); + return i; + } + return -1; +} + + +/** +* @brief CFesBase::GetFesFwPubAi +* 通过TagName，获取非本FES转发点SFesFwPubAi +* @param TagName 点TagName +*/ +SFesFwPubAi* CFesBase::GetFesFwPubFesAi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubFesAi.find(TagName); + if (it == m_mapFwPubFesAi.end()) + return NULL; + + return (SFesFwPubAi*)&it->second; +} + +/** +* @brief CFesBase::GetFesFwPubDpAi +* 通过TagName，获取DP转发点GetFesFwPubDpAi +* @param TagName 点TagName +*/ +SFesFwPubAi* CFesBase::GetFesFwPubDpAi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubDpAi.find(TagName); + if (it == m_mapFwPubDpAi.end()) + return NULL; + + return (SFesFwPubAi*)&it->second; +} + + +/** +* @brief CFesBase::GetFesFwPubDi +* 通过TagName，获取非本FES转发点SFesFwPubDi +* @param TagName 点TagName +*/ +SFesFwPubDi* CFesBase::GetFesFwPubFesDi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubFesDi.find(TagName); + if (it == m_mapFwPubFesDi.end()) + return NULL; + + return (SFesFwPubDi*)&it->second; +} + +/** +* @brief CFesBase::GetFesFwPubDpDi +* 通过TagName，获取DP转发点GetFesFwPubDpDi +* @param TagName 点TagName +*/ +SFesFwPubDi* CFesBase::GetFesFwPubDpDi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubDpDi.find(TagName); + if (it == m_mapFwPubDpDi.end()) + return NULL; + + return (SFesFwPubDi*)&it->second; +} + +/** +* @brief CFesBase::GetFesFwPubAcc +* 通过TagName，获取非本FES转发点SFesFwPubAcc +* @param TagName 点TagName +*/ +SFesFwPubAcc* CFesBase::GetFesFwPubFesAcc(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubFesAcc.find(TagName); + if (it == m_mapFwPubFesAcc.end()) + return NULL; + + return (SFesFwPubAcc*)&it->second; +} + +/** +* @brief CFesBase::GetFesFwPubAcc +* 通过TagName，获取DP转发点SFesFwPubAcc +* @param TagName 点TagName +*/ +SFesFwPubAcc* CFesBase::GetFesFwPubDpAcc(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubDpAcc.find(TagName); + if (it == m_mapFwPubDpAcc.end()) + return NULL; + + return (SFesFwPubAcc*)&it->second; +} + + +/** +* @brief CFesBase::GetFesFwPubMi +* 通过TagName，获取非本FES转发点SFesFwPubMi +* @param TagName 点TagName +*/ +SFesFwPubMi* CFesBase::GetFesFwPubFesMi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubFesMi.find(TagName); + if (it == m_mapFwPubFesMi.end()) + return NULL; + + return (SFesFwPubMi*)&it->second; +} + +/** +* @brief CFesBase::GetFesFwPubMi +* 通过TagName，获取DP转发点SFesFwPubMi +* @param TagName 点TagName +*/ +SFesFwPubMi* CFesBase::GetFesFwPubDpMi(const std::string &TagName) +{ + std::map::iterator it; + + it = m_mapFwPubDpMi.find(TagName); + if (it == m_mapFwPubDpMi.end()) + return NULL; + + return (SFesFwPubMi*)&it->second; +} + +/** +* @brief CFesBase::WriteSoeEventBuf +* 写入SOE EVENT缓冲区内容,如需转发，也写入转发RTU SOE EVENT缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入数据 +*/ +void CFesBase::WriteSoeEventBuf(CFesRtuPtr curRtuPtr, int num, SFesSoeEvent *buffer) +{ + int i, j,index, count; + SFesFwSoeEvent FwEvent; + SFesDi *pDi; + CFesRtuPtr rtuPtr; + + boost::mutex::scoped_lock lock(curRtuPtr->m_EventMutex); + count = static_cast(curRtuPtr->SoeEventBuf.size()); + if ((count + num) > curRtuPtr->DiMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->SoeEventBuf.empty()) + { + curRtuPtr->SoeEventBuf.front(); //从头开始读取数据 + curRtuPtr->SoeEventBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d SoeEventBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->SoeEventBuf.push(buffer[i]); + //2019-09-06 thxiao 方便查找事件，增加记录 + LOGTRACE("SOE RtuNo:%d PointNo=%d TagName:%s value=%d ms=[%" PRId64 "] count=%d", + curRtuPtr->m_Param.RtuNo, buffer[i].PointNo,buffer[i].TagName, buffer[i].Value, buffer[i].time,m_SoeCount); + m_SoeCount++; + } + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) + { + pDi = curRtuPtr->m_pDi + buffer[i].PointNo; + if (pDi->FwMapNum>0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + FwEvent.time = buffer[i].time; + FwEvent.FaultNum = buffer[i].FaultNum; + for (j = 0; j < CN_FesMaxFaultNum; j++) + { + FwEvent.FaultValTag[j] = buffer[i].FaultValTag[j]; + FwEvent.FaultVal[j] = buffer[i].FaultVal[j]; + } + for (j=0; j < pDi->FwMapNum; j++) + { + index = pDi->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; + rtuPtr->WriteFwSoeEventBuf(FwEvent); + } + } + } + } + } +} + +/** +* @brief CFesBase::WriteChgDiValue +* FES（规约模块）写入数字量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入内容 +*/ +void CFesBase::WriteChgDiValue(CFesRtuPtr curRtuPtr,int num, SFesChgDi *buffer) +{ + int i, j, index, count; + SFesFwChgDi FwEvent; + SFesDi *pDi; + CFesRtuPtr rtuPtr; + SFesFwChgDi ChgValue; + + boost::mutex::scoped_lock lock(curRtuPtr->m_DiChgMutex); + count = static_cast(curRtuPtr->DiChgBuf.size()); + if ((count + num) > curRtuPtr->DiMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->DiChgBuf.empty()) + { + curRtuPtr->DiChgBuf.front(); //从头开始读取数据 + curRtuPtr->DiChgBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d DiChgBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->DiChgBuf.push(buffer[i]); + //2019-09-06 thxiao 方便查找事件，增加记录 + LOGTRACE("DI change RtuNo:%d PointNo=%d TagName:%s value=%d ms=[%" PRId64 "] count=%d", + curRtuPtr->m_Param.RtuNo, buffer[i].PointNo, buffer[i].TagName, buffer[i].Value, buffer[i].time,m_DiChgCount); + m_DiChgCount++; + } + + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) + { + pDi = curRtuPtr->m_pDi + buffer[i].PointNo; + if (pDi->FwMapNum > 0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + FwEvent.time = buffer[i].time; + ChgValue.Status = buffer[i].Status; + ChgValue.Value = buffer[i].Value; + ChgValue.time = buffer[i].time; + for (j = 0; j < pDi->FwMapNum; j++) + { + index = pDi->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; + ChgValue.RemoteNo = FwEvent.RemoteNo; + rtuPtr->WriteFwDiBuf(FwEvent); + rtuPtr->UpdataFwDiValue(ChgValue); + } + } + } + } + } + +} + +/** +* @brief CFesBase::WriteChgAiValue +* FES（规约模块）写入模拟量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入内容 +*/ +void CFesBase::WriteChgAiValue(CFesRtuPtr curRtuPtr, int num, SFesChgAi *buffer) +{ + int i, j, index, count; + SFesFwChgAi FwEvent; + SFesAi *pAi; + CFesRtuPtr rtuPtr; + SFesFwChgAi ChgValue; + + boost::mutex::scoped_lock lock(curRtuPtr->m_AiChgMutex); + count = static_cast(curRtuPtr->AiChgBuf.size()); + if ((count + num) > curRtuPtr->AiMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->AiChgBuf.empty()) + { + curRtuPtr->AiChgBuf.front(); //从头开始读取数据 + curRtuPtr->AiChgBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d AiChgBuf overflow AiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->AiMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->AiChgBuf.push(buffer[i]); + } + + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxAiPoints)) + { + pAi = curRtuPtr->m_pAi + buffer[i].PointNo; + if (pAi->FwMapNum > 0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + FwEvent.time = buffer[i].time; + ChgValue.Status = buffer[i].Status; + ChgValue.Value = buffer[i].Value; + ChgValue.time = buffer[i].time; + + float fNewValue = 0.0f; + for (j = 0; j < pAi->FwMapNum; j++) + { + index = pAi->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pAi->FwMapping[j].RemoteNo; + ChgValue.RemoteNo = FwEvent.RemoteNo; + if(rtuPtr->UpdataFwAiValue(ChgValue,fNewValue,eNormalUpdate)) + { + FwEvent.Value = fNewValue; + rtuPtr->WriteFwAiBuf(FwEvent); + } + } + } + } + } + } +} + +/** +* @brief CFesBase::WriteChgAccValue +* FES（规约模块）写入整形量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入内容 +*/ +void CFesBase::WriteChgAccValue(CFesRtuPtr curRtuPtr, int num, SFesChgAcc *buffer) +{ + int i, j, index ; + SFesFwChgAcc FwEvent; + SFesAcc *pAcc; + CFesRtuPtr rtuPtr; + SFesFwChgAcc ChgValue; + + boost::mutex::scoped_lock lock(curRtuPtr->m_AccChgMutex); + int count = static_cast(curRtuPtr->AccChgBuf.size()); + if ((count + num) > curRtuPtr->AccMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->AccChgBuf.empty()) + { + curRtuPtr->AccChgBuf.front(); //从头开始读取数据 + curRtuPtr->AccChgBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d AccChgBuf overflow AccMaxChgNum=%d clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->AccMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->AccChgBuf.push(buffer[i]); + } + + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxAccPoints)) + { + pAcc = curRtuPtr->m_pAcc + buffer[i].PointNo; + if (pAcc->FwMapNum > 0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + ChgValue.Status = buffer[i].Status; + ChgValue.Value = buffer[i].Value; + ChgValue.time = buffer[i].time; + FwEvent.time = buffer[i].time; + + double dNewValue = 0.0; + for (j = 0; j < pAcc->FwMapNum; j++) + { + index = pAcc->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pAcc->FwMapping[j].RemoteNo; + ChgValue.RemoteNo = FwEvent.RemoteNo; + + if(rtuPtr->UpdataFwAccValue(ChgValue,dNewValue,eNormalUpdate)) + { + FwEvent.Value = dNewValue; + rtuPtr->WriteFwAccBuf(FwEvent); + } + } + } + } + } + } +} + +/** +* @brief CFesRtu::WriteChgMiValue +* FES（规约模块）写入整形量变化值到缓存区;如需转发，也写入转发RTU 缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入内容 +*/ +void CFesBase::WriteChgMiValue(CFesRtuPtr curRtuPtr, int num, SFesChgMi *buffer) +{ + int i, j, index ; + SFesFwChgMi FwEvent; + SFesMi *pMi; + CFesRtuPtr rtuPtr; + SFesFwChgMi ChgValue; + + boost::mutex::scoped_lock lock(curRtuPtr->m_MiChgMutex); + int count = static_cast(curRtuPtr->MiChgBuf.size()); + if ((count + num) > curRtuPtr->MiMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->MiChgBuf.empty()) + { + curRtuPtr->MiChgBuf.front(); //从头开始读取数据 + curRtuPtr->MiChgBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d MiChgBuf overflow MiMaxChgNum=%d clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->MiMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->MiChgBuf.push(buffer[i]); + } + + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxMiPoints)) + { + pMi = curRtuPtr->m_pMi + buffer[i].PointNo; + if (pMi->FwMapNum > 0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + FwEvent.time = buffer[i].time; + ChgValue.Status = buffer[i].Status; + ChgValue.Value = buffer[i].Value; + ChgValue.time = buffer[i].time; + + int nNewValue = 0; + for (j = 0; j < pMi->FwMapNum; j++) + { + index = pMi->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pMi->FwMapping[j].RemoteNo; + ChgValue.RemoteNo = FwEvent.RemoteNo; + + if(rtuPtr->UpdataFwMiValue(ChgValue,nNewValue,eNormalUpdate)) + { + FwEvent.Value = nNewValue; + rtuPtr->WriteFwMiBuf(FwEvent); + } + } + } + } + } + } +} + +void CFesBase::SetFesSubSystem(int SubSystemId,int /*dataType*/) +{ + std::map::iterator pos; + pos = m_mapFesSubSystem.find(SubSystemId); + if (pos == m_mapFesSubSystem.end())//没有找到 + { + m_mapFesSubSystem[SubSystemId] = SubSystemId; + } + FesRxFesDataThreadFlag = 1; +} + +void CFesBase::SetDPSubSystem(int SubSystemId, int /*dataType*/) +{ + std::map::iterator pos; + pos = m_mapDPSubSystem.find(SubSystemId); + if (pos == m_mapDPSubSystem.end())//没有找到 + { + m_mapFesSubSystem[SubSystemId] = SubSystemId; + } + FesRxDPDataThreadFlag = 1; +} + + +CFesRtuPtr CFesBase::GetFwRtuByMappingIndex(int Index) +{ + if ((Index >= 0) && (Index m_Param.Used) && + (m_vectCFesChanPtr[j]->m_Param.ProtocolId == m_protoclName[i].ProtocolId)) + { + return m_vectCFesChanPtr[j]->m_Param.ProtocolId; + } + } + } + } + return -1; +} + +/** +* @brief CFesBase::GetRtuAiValue +* 根据RtuNo ,PointNo获取点值 +* @param RtuNo RTU号 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetRtuAiValue(int RtuNo, int PointNo, SFesFwAiValue *retValue) +{ + CFesRtuPtr ptrRtu; + SFesAi *pAi; + + if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) + return false; + + if ((PointNo < ptrRtu->m_MaxAiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); + pAi=ptrRtu->m_pAi + PointNo; + retValue->Value = pAi->Value; + retValue->Status = pAi->Status; + retValue->time = pAi->time; + return true; + } + + return false; +} + +/** +* @brief CFesBase::GetRtuDiValue +* 根据RtuNo ,PointNo获取点值 +* @param RtuNo RTU号 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetRtuDiValue(int RtuNo, int PointNo, SFesFwDiValue *retValue) +{ + CFesRtuPtr ptrRtu; + SFesDi *pDi; + + if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) + return false; + + if ((PointNo < ptrRtu->m_MaxDiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); + pDi = ptrRtu->m_pDi + PointNo; + retValue->Value = pDi->Value; + retValue->Status = pDi->Status; + retValue->time = pDi->time; + return true; + } + + return false; +} + +/** +* @brief CFesBase::GetRtuAccValue +* 根据RtuNo ,PointNo获取点值 +* @param RtuNo RTU号 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetRtuAccValue(int RtuNo, int PointNo, SFesFwAccValue *retValue) +{ + CFesRtuPtr ptrRtu; + SFesAcc *pAcc; + + if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) + return false; + + if ((PointNo < ptrRtu->m_MaxAccPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); + pAcc = ptrRtu->m_pAcc + PointNo; + retValue->Value = pAcc->Value; + retValue->Status = pAcc->Status; + retValue->time = pAcc->time; + return true; + } + return false; +} + +/** +* @brief CFesBase::GetRtuMiValue +* 根据RtuNo ,PointNo获取点值 +* @param RtuNo RTU号 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetRtuMiValue(int RtuNo, int PointNo, SFesFwMiValue *retValue) +{ + CFesRtuPtr ptrRtu; + SFesMi *pMi; + + if ((ptrRtu = GetRtuDataByRtuNo(RtuNo)) == NULL) + return false; + + if ((PointNo < ptrRtu->m_MaxMiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); + pMi = ptrRtu->m_pMi + PointNo; + retValue->Value = pMi->Value; + retValue->Status = pMi->Status; + retValue->time = pMi->time; + return true; + } + return false; +} + +void CFesBase::UpdateFesAiValue(CFesRtuPtr ptrRtu) +{ + int i; + SFesFwAi *pAi; + SFesFwAiValue Val; + + for (i = 0; i < ptrRtu->m_MaxFwAiPoints; i++) + { + pAi = ptrRtu->m_pFwAi + i; + if (pAi->Used) + { + if ((pAi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pAi->SrcType == CN_FesFw_FesSrc))//本FES点 + { + if (GetRtuAiValue(pAi->FesRtuNo, pAi->FesPointNo, &Val)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); + pAi->Value = Val.Value; + pAi->Status = Val.Status; + pAi->time = Val.time; + } + } + } + } +} + +void CFesBase::UpdateFesDiValue(CFesRtuPtr ptrRtu) +{ + int i; + SFesFwDi *pDi; + SFesFwDiValue Val; + + for (i = 0; i < ptrRtu->m_MaxFwDiPoints; i++) + { + pDi = ptrRtu->m_pFwDi + i; + if (pDi->Used) + { + if ((pDi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pDi->SrcType == CN_FesFw_FesSrc))//本FES点 + { + if (GetRtuDiValue(pDi->FesRtuNo, pDi->FesPointNo, &Val)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); + pDi->Value = Val.Value; + pDi->Status = Val.Status; + pDi->time = Val.time; + } + } + } + } +} + +void CFesBase::UpdateFesAccValue(CFesRtuPtr ptrRtu) +{ + int i; + SFesFwAcc *pAcc; + SFesFwAccValue Val; + + for (i = 0; i < ptrRtu->m_MaxFwAccPoints; i++) + { + pAcc = ptrRtu->m_pFwAcc + i; + if (pAcc->Used) + { + if ((pAcc->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pAcc->SrcType == CN_FesFw_FesSrc))//本FES点 + { + if (GetRtuAccValue(pAcc->FesRtuNo, pAcc->FesPointNo, &Val)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); + pAcc->Value = Val.Value; + pAcc->Status = Val.Status; + pAcc->time = Val.time; + } + } + } + } +} + +void CFesBase::UpdateFesMiValue(CFesRtuPtr ptrRtu) +{ + int i; + SFesFwMi *pMi; + SFesFwMiValue Val; + + for (i = 0; i < ptrRtu->m_MaxFwMiPoints; i++) + { + pMi = ptrRtu->m_pFwMi + i; + if (pMi->Used) + { + if ((pMi->SrcSubSystem == ptrRtu->m_Param.nSubSystem) && (pMi->SrcType == CN_FesFw_FesSrc))//本FES点 + { + if (GetRtuMiValue(pMi->FesRtuNo, pMi->FesPointNo, &Val)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); + pMi->Value = Val.Value; + pMi->Status = Val.Status; + pMi->time = Val.time; + } + } + } + } +} + +/** +* @brief CFesBase::SetRtuProperty +* 设置RTU的采集或转发属性,及采集RTU的通信状态点 +* @param +*/ +void CFesBase::SetRtuProperty() +{ + int ChanNo,i,j; + CFesChanPtr ChanPtr; + SFesDi *pDi; + + for (i = 0; i < (int)m_vectCFesRtuPtr.size(); i++) + { + ChanNo = m_vectCFesRtuPtr[i]->m_Param.ChanNo; + if ((ChanPtr = GetChanDataByChanNo(ChanNo)) != NULL) + { + m_vectCFesRtuPtr[i]->m_ComStatusPointNo = -1; + if (ChanPtr->m_Param.CommProperty == CN_FesComProperty_Transmit) + { + m_vectCFesRtuPtr[i]->m_RtuProperty = CN_Fes_RTU_Forward; + } + else + { + for (j = 0; j < m_vectCFesRtuPtr[i]->m_MaxDiPoints; j++) + { + pDi = m_vectCFesRtuPtr[i]->m_pDi + j; + if ((pDi->Param2 == 65535) && (pDi->Param3 == 65535)) + { + m_vectCFesRtuPtr[i]->m_ComStatusPointNo = j; + break; + } + } + } + } + } +} +/** +* @brief CFesBase::SetWuFangDoStatusByDi +* 设置当前RTU转发Do状态,再把状态传送到FES DO遥控源 +* @param pRtu RTU结构 +* @param RemoteNo 远动号 +* @param Status 状态 +* @return 成功：true 失败：false +*/ +bool CFesBase::SetWuFangDoStatusByDi(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) +{ + SFesFwDi *pFwDi; + + if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDiPoints)) + { + pFwDi = pRtu->m_pFwDi + RemoteNo; + SetWuFangSrcDoStatus(pRtu, pFwDi->DORemoteNo, Status); + return true; + } + else{ + return false; + } +} + + + +/** +* @brief CFesBase::SetWuFangSrcDoStatus +* 设置DO遥控源的五防状态。本FES RTU点直接置上，非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送。 +* @param pRtu RTU结构 +* @param SFesFwDi DI点 +* @return 成功：true 失败：false +*/ +bool CFesBase::SetWuFangSrcDoStatus(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) +{ + SFesFwDo *pFwDo; + CFesRtuPtr pSrcRtu; + SFesFwChgDo doChgEvent; + int i; + + if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDoPoints)) + { + pFwDo = pRtu->m_pFwDo + RemoteNo; + if ((pFwDo->Status&CN_FW_YK_UNBLOCK) != (Status&CN_FW_YK_UNBLOCK))//五防解锁标志有变化 + { + pFwDo->Status = Status;//对应转发RTU遥信遥控状态定义一样 + if (pFwDo->Status&CN_FW_YK_UNBLOCK) + pFwDo->WfBlockedTimeout = getMonotonicMsec();//重新开始五防记时 + else + pFwDo->WfBlockedTimeout = 0; + + if (pFwDo->SrcType == CN_FesFw_FesSrc) + { + if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 + { + for (i = 0; i < pFwDo->FesPointNum; i++) + { + pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[i], pFwDo->Status); + } + } + else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 + { + doChgEvent.SrcSubSystem = pFwDo->SrcSubSystem; + doChgEvent.Status = pFwDo->Status; + doChgEvent.SrcRtuNo = pFwDo->FesRtuNo; + for (i = 0; i < pFwDo->FesPointNum; i++) + { + doChgEvent.SrcPointNo = pFwDo->FesPointNo[i]; + } + WriteWuFangChgDoStatusBuf(1, &doChgEvent); + } + return true; + } + } + } + return false; + +} + + +/** +* @brief CFesBase::SetWuFangSrcDoInitStatus +* 初始化DO遥控源的五防状态。本FES RTU点直接置上，非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送。 +* @param pRtu RTU结构 +* @param SFesFwDi DI点 +* @return 成功：true 失败：false +*/ +bool CFesBase::SetWuFangSrcDoInitStatus(CFesRtuPtr pRtu, int RemoteNo, uint32 Status) +{ + SFesFwDo *pFwDo; + CFesRtuPtr pSrcRtu; + SFesFwChgDo doChgEvent; + int i; + + if ((RemoteNo >= 0) && (RemoteNo < pRtu->m_MaxFwDoPoints)) + { + pFwDo = pRtu->m_pFwDo + RemoteNo; + pFwDo->Status = Status;//对应转发RTU遥信遥控状态定义一样 + pFwDo->WfBlockedTimeout = 0; + if (pFwDo->SrcType == CN_FesFw_FesSrc) + { + if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 + { + for (i = 0; i < pFwDo->FesPointNum; i++) + { + pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[i], pFwDo->Status); + } + } + else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 + { + doChgEvent.SrcSubSystem = pFwDo->SrcSubSystem; + doChgEvent.Status = pFwDo->Status; + doChgEvent.SrcRtuNo = pFwDo->FesRtuNo; + for (i = 0; i < pFwDo->FesPointNum; i++) + { + doChgEvent.SrcPointNo = pFwDo->FesPointNo[i]; + } + WriteWuFangChgDoStatusBuf(1, &doChgEvent); + } + return true; + } + } + return false; + +} + + +/** +* @brief CFesBase::WriteWuFfangChgDoStatusBuf +* FES 转发RTU 写入五防变化队列缓存区, +* @param num 写入个数 +* @param buffer 写入内容 +*/ +void CFesBase::WriteWuFangChgDoStatusBuf(int num, SFesFwChgDo *buffer) +{ + int i; + + boost::mutex::scoped_lock lock(m_FwCtrlMutex); + int count = static_cast(m_FwDoChgStatusBuf.size()); + if ((count + num) > 10000) + { + LOGERROR("FwDoChgStatusBuf overflow 10000"); + return; + } + for (i = 0; i < num; i++) + { + m_FwDoChgStatusBuf.push(buffer[i]); + } +} + +int CFesBase::ReadWuFfangChgDoStatusBuf(int num, SFesFwChgDo *buffer) +{ + int i, tempNum; + + boost::mutex::scoped_lock lock(m_FwCtrlMutex); + tempNum = 0; + for (i = 0; i < num; i++) + { + if (!m_FwDoChgStatusBuf.empty()) + { + buffer[i] = m_FwDoChgStatusBuf.front(); //从头开始读取数据 + m_FwDoChgStatusBuf.pop(); //清除已读取数据 + tempNum++; + } + } + return tempNum; +} + +/** +* @brief CWfudpcdtDataProcThread::UpdateWuFangStatus +* 定时更新五防状态 +* @return +*/ +void CFesBase::UpdateWuFangStatus(CFesRtuPtr ptrRtu) +{ + SFesFwDo *pFwDo; + CFesRtuPtr pSrcRtu; + SFesFwChgDo doChgEvent[50]; + int i,j,count; + count = 0; + for (i = 0; i < ptrRtu->m_MaxFwDoPoints; i++) + { + pFwDo = ptrRtu->m_pFwDo + i; + if (pFwDo->SrcType == CN_FesFw_FesSrc) + { + if ((pSrcRtu = GetRtuDataByRtuNo(pFwDo->FesRtuNo)) != NULL)//本FES RTU点直接置上 + { + for (j = 0; j < pFwDo->FesPointNum; j++) + { + pSrcRtu->WriteWuFangDoStatus(pFwDo->FesPointNo[j], pFwDo->Status); + } + } + else//非本FES，队列FwDoChgStatusBuf中添加记录,等待消息发送 + { + doChgEvent[count].SrcSubSystem = pFwDo->SrcSubSystem; + doChgEvent[count].Status = pFwDo->Status; + doChgEvent[count].SrcRtuNo = pFwDo->FesRtuNo; + for (j = 0; j < pFwDo->FesPointNum; j++) + { + doChgEvent[count].SrcPointNo = pFwDo->FesPointNo[j]; + count++; + if (count >= 50) + { + WriteWuFangChgDoStatusBuf(count, &doChgEvent[0]); + count = 0; + } + } + } + } + } + if (count > 0) + { + WriteWuFangChgDoStatusBuf(count, &doChgEvent[0]); + count = 0; + } + + +} + + +/** +* @brief CFesBase::WriteRtuSatus +* @param status RTU状态 +* 2019-09-19 thxiao 增加RTU事件的产生 +*/ +void CFesBase::WriteRtuSatus(CFesRtuPtr ptrRtu,int status) +{ + SFesSoeEvent SoeEvent; + SFesChgDi ChgDi; + SFesDi *pDi; + uint64 mSec; + SFesRtuDiValue diValue; + + mSec = getUTCTimeMsec(); + /* + if (ptrRtu->m_Param.AlarmEnable && (ptrRtu->m_Status != status)) + { + LOGDEBUG("RTU:%d 产生事件 老状态=%d 新状态=%d", ptrRtu->m_Param.RtuNo, ptrRtu->m_Status, status); + Event.time = mSec; + memcpy(Event.RtuTagName, ptrRtu->m_Param.TagName, CN_FesMaxTagSize); + memcpy(Event.RtuName, ptrRtu->m_Param.RtuName, CN_FesMaxNameSize); + memcpy(Event.RtuDesc, ptrRtu->m_Param.RtuDesc, CN_FesMaxDescSize); + Event.nLocationId = ptrRtu->m_Param.nLocationId; + Event.nSubSystem = ptrRtu->m_Param.nSubSystem; + Event.nRegionId = 0; //保留不使用； + Event.CurrentChanNo = ptrRtu->m_CurrentChanNo; + Event.Status = status; + ptrRtu->WriteRtuEventBuf(1, &Event); + } + */ + + //2020-02-27 thxiao 增加通信状态点 + if ((ptrRtu->m_RtuProperty == CN_Fes_RTU_Collect) && (ptrRtu->m_ComStatusPointNo >= 0)) + { + if(ptrRtu->m_ComStatusInit) + { + if (ptrRtu->m_Status != status) + { + pDi = ptrRtu->GetDiByPointNo(ptrRtu->m_ComStatusPointNo); + if (pDi != NULL) + { + memset(&SoeEvent, 0, sizeof(SoeEvent)); + SoeEvent.time = mSec; + memcpy(SoeEvent.TableName, pDi->TableName, CN_FesMaxTableNameSize); + memcpy(SoeEvent.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); + memcpy(SoeEvent.TagName, pDi->TagName, CN_FesMaxTagSize); + SoeEvent.FaultNum = 0; + SoeEvent.RtuNo = ptrRtu->m_Param.RtuNo; + SoeEvent.PointNo = pDi->PointNo; + SoeEvent.Status = CN_FesValueUpdate; + + memset(&ChgDi, 0, sizeof(ChgDi)); + memcpy(ChgDi.TableName, pDi->TableName, CN_FesMaxTableNameSize); + memcpy(ChgDi.ColumnName, pDi->ColumnName, CN_FesMaxColumnNameSize); + memcpy(ChgDi.TagName, pDi->TagName, CN_FesMaxTagSize); + ChgDi.Status = CN_FesValueUpdate; + ChgDi.time = mSec; + ChgDi.RtuNo = ptrRtu->m_Param.RtuNo; + ChgDi.PointNo = pDi->PointNo; + + memset(&diValue, 0, sizeof(diValue)); + diValue.PointNo = pDi->PointNo; + diValue.Status = CN_FesValueUpdate; + diValue.time = mSec; + + if (status == CN_FesRtuNormal) + { + SoeEvent.Value = 1; + ChgDi.Value = 1; + diValue.Value = 1; + } + else + { + SoeEvent.Value = 0; + ChgDi.Value = 0; + diValue.Value = 0; + } + WriteChgDiValue(ptrRtu, 1, &ChgDi); + WriteSoeEventBuf(ptrRtu, 1, &SoeEvent); + ptrRtu->WriteRtuDiValue(1, &diValue); + //保存FesSim监视数据 + FesSimServerWriteSoeEvent(1, &SoeEvent); + } + } + } + else + { + if (status == CN_FesRtuNormal) + { + pDi = ptrRtu->GetDiByPointNo(ptrRtu->m_ComStatusPointNo); + if (pDi != NULL) + { + diValue.PointNo = pDi->PointNo; + diValue.Status = CN_FesValueUpdate; + diValue.time = mSec; + diValue.Value = 1; + ptrRtu->WriteRtuDiValue(1, &diValue); + } + ptrRtu->m_ComStatusInit = 1; + } + } + } + ptrRtu->m_Status = status; + ptrRtu->m_OfflineFlag = status; + //2020-05-20 thxiao 通信恢复，清除离线统计 + if (status == CN_FesRtuNormal) + { + CFesChanPtr ptrChan; + if ((ptrChan = GetChanDataByChanNo(ptrRtu->m_Param.ChanNo)) != NULL) + { + if (ptrChan->m_Param.CommType == CN_FesSerialPort) + { + ptrChan->m_OfflineCount = 0; + } + } + } +} + + +/** +* @brief CProtocolBase::ClearRtuOfflineFlag +* 离线监视时间到，清除RTU离线标志 +* @param pChan 通道结构 +* @return 无 +*/ +void CFesBase::ClearRtuOfflineFlag(CFesChanPtr pChan) +{ + int i, RtuNo; + CFesRtuPtr pRtu; + + for (i = 0; i < pChan->m_RtuNum; i++) + { + RtuNo = pChan->m_RtuNo[i]; + if ((pRtu = GetRtuDataByRtuNo(RtuNo)) != NULL) + { + pRtu->m_OfflineFlag = CN_FesRtuNormal; + } + } +} + + +/** +* @brief CFesBase::SetOfflineFlag +* 设置设备离线标志 +* 当通道离线计数大过一定的值是，如果同一串口下没有其他设备正常通信，则串口通道重新打开 +* @param flag 1:CN_FesRtuNormal 2：CN_FesRtuComDown +*/ +void CFesBase::SetOfflineFlag(CFesRtuPtr ptrRtu,int flag) +{ + CFesChanPtr ptrChan; + CFesRtuPtr pRtu; + int i; + + ptrRtu->m_OfflineFlag = flag; + + if (flag == CN_FesRtuComDown) + { + //2020-05-20 thxiao 如果是串口规约，重新打开串口 + if ((ptrChan = GetChanDataByChanNo(ptrRtu->m_Param.ChanNo)) != NULL) + { + if (ptrChan->m_Param.CommType == CN_FesSerialPort) + { + if ((ptrChan->m_OfflineCountReset > 0) && (ptrChan->m_OfflineCount++ >= ptrChan->m_OfflineCountReset)) + { + ptrChan->m_OfflineCount = 0; + for (i = 0; i < ptrChan->m_RtuNum; i++) + { + if ((pRtu = GetRtuDataByRtuNo(ptrChan->m_RtuNo[i])) != NULL) + { + if (pRtu->m_Status == CN_FesRtuNormal)//只要通道下有一个RTU是通信正常的，就不用重新打开串口 + return; + } + } + + SFesAppNetEvent event; + event.EventType = CN_FesAppNetEvent_ReopenChan; + ptrChan->WriteAppNetEvent(1, &event); + LOGDEBUG("离线计数大于%d次，重新打开串口通道%d ", ptrChan->m_OfflineCountReset, ptrChan->m_Param.ChanNo); + } + } + } + } +} + +int CFesBase::GetDevIdByDevTag(CFesRtuPtr ptrRtu, char* TagName) +{ + int DevId = -1; + int i; + + for (i = 0; i < ptrRtu->m_DevInfo.DevNum; i++) + { + if (strcmp(ptrRtu->m_DevInfo.pDev[i].TagName, TagName) == 0) + { + DevId = ptrRtu->m_DevInfo.pDev[i].DevId; + break; + } + } + return DevId; +} + + +/** +* @brief CFesBase::WriteSoeStrEventBuf +* 写入SOE EVENT缓冲区内容,如需转发，也写入转发RTU SOE EVENT缓冲区 +* @param curRtuPtr 当前RtuPtr +* @param num 写入个数 +* @param buffer 写入数据 +*/ +void CFesBase::WriteSoeStrEventBuf(CFesRtuPtr curRtuPtr, int num, SFesSoeStrEvent *buffer) +{ + int i, j, index, count; + SFesFwSoeEvent FwEvent; + SFesDi *pDi; + CFesRtuPtr rtuPtr; + + { + boost::mutex::scoped_lock lock(curRtuPtr->m_EventMutex); + count = static_cast(curRtuPtr->SoeStrEventBuf.size()); + if ((count + num) > curRtuPtr->DiMaxChgNum) + { + for (i = 0; i < num; i++) + { + if (!curRtuPtr->SoeStrEventBuf.empty()) + { + curRtuPtr->SoeStrEventBuf.front(); //从头开始读取数据 + curRtuPtr->SoeStrEventBuf.pop(); //清除已读取数据 + } + } + LOGERROR("RTU%d SoeStrEventBuf overflow DiMaxChgNum=%d，clear the old", curRtuPtr->m_Param.RtuNo, curRtuPtr->DiMaxChgNum); + } + for (i = 0; i < num; i++) + { + curRtuPtr->SoeStrEventBuf.push(buffer[i]); + LOGINFO("SOE RtuNo:%d TagName:%s value=%d ms=[%" PRId64 "]", + curRtuPtr->m_Param.RtuNo, buffer[i].TagName, buffer[i].Value, buffer[i].time); + } + } + //写入转发RTU变化队列 + for (i = 0; i < num; i++) + { + if ((buffer[i].PointNo >= 0) && (buffer[i].PointNo < curRtuPtr->m_MaxDiPoints)) + { + pDi = curRtuPtr->m_pDi + buffer[i].PointNo; + if (pDi->FwMapNum > 0) + { + memset(&FwEvent, 0, sizeof(FwEvent)); + FwEvent.RtuNo = buffer[i].RtuNo; + FwEvent.PointNo = buffer[i].PointNo; + FwEvent.Status = buffer[i].Status; + FwEvent.Value = buffer[i].Value; + FwEvent.time = buffer[i].time; + FwEvent.FaultNum = 0; + //转发协议不需要带上故障参数 + /*FwEvent.FaultNum = buffer[i].FaultNum; + for (j = 0; j < CN_FesMaxFaultNum; j++) + { + FwEvent.FaultValTag[j] = buffer[i].FaultValTag[j]; + FwEvent.FaultVal[j] = buffer[i].FaultVal[j]; + }*/ + for (j = 0; j < pDi->FwMapNum; j++) + { + index = pDi->FwMapping[j].MappingIndex; + if ((rtuPtr = FwMappingTable.FwRtu[index]) != NULL) + { + FwEvent.RemoteNo = pDi->FwMapping[j].RemoteNo; + rtuPtr->WriteFwSoeEventBuf(FwEvent); + } + } + } + } + } +} + +/** +* @brief CFesBase::WriteChanEventBuf +* 写入CHAN EVENT缓冲区内容 +* @param num 写入个数 +* @param buffer 写入数据 +*/ +void CFesBase::WriteChanEventBuf(int num, SFesChanEvent *buffer) +{ + int i; + + boost::mutex::scoped_lock lock(m_EventMutex); + for (i = 0; i(m_ChanEventBuf.size()); + return num; +} + +/** +* @brief CFesBase::ReadChanEvent +* 读取Chan EVENT数据 +* @param num 读取的个数 +* @param buffer 读取存放区, size = num*sizeof(SFesChanEvent) +* @return 实际读取个数 +*/ +int CFesBase::ReadChanEvent(int num, SFesChanEvent *buffer) +{ + int i, tempNum; + boost::mutex::scoped_lock lock(m_EventMutex); + + tempNum = 0; + for (i = 0; im_Param.RtuNo); + return; + } + + if (StartChanNo == -1)//所有的DI数据都转发 + { + num = static_cast(m_vectCFesChanPtr.size()); + for (i = 0; i < num; i++) + { + if ((m_vectCFesChanPtr[i]->m_Param.Used) && (m_vectCFesChanPtr[i]->m_Param.CommProperty == CN_FesComProperty_Collect)) + { + for (j = 0; j < m_vectCFesChanPtr[i]->m_RtuNum; j++) + { + RtuNo = m_vectCFesChanPtr[i]->m_RtuNo[j]; + rtuPtr = GetRtuDataByRtuNo(RtuNo); + if (rtuPtr == NULL) + continue; + if (rtuPtr->m_Param.Used) + { + for (k = 0; k < rtuPtr->m_MaxDiPoints; k++) + { + pDi = rtuPtr->m_pDi + k; + pDi->FwMapping[pDi->FwMapNum].MappingIndex = MappingIndex; + pDi->FwMapping[pDi->FwMapNum].RemoteNo = RemoteNo;//远动号没有实际意义。 + RemoteNo++; + pDi->FwMapNum++; + } + } + } + } + } + FwRtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RemoteNo; + return; + } + + num = static_cast(m_vectCFesChanPtr.size()); + for (i = 0; i < num; i++) + { + if ((m_vectCFesChanPtr[i]->m_Param.Used)&&(m_vectCFesChanPtr[i]->m_Param.CommProperty==CN_FesComProperty_Collect) + &&(m_vectCFesChanPtr[i]->m_Param.ChanNo>= StartChanNo)&&(m_vectCFesChanPtr[i]->m_Param.ChanNo <= EndChanNo)) + { + for (j = 0; j < m_vectCFesChanPtr[i]->m_RtuNum; j++) + { + RtuNo = m_vectCFesChanPtr[i]->m_RtuNo[j]; + rtuPtr = GetRtuDataByRtuNo(RtuNo); + if(rtuPtr==NULL) + continue; + if (rtuPtr->m_Param.Used) + { + for (k = 0; k < rtuPtr->m_MaxDiPoints; k++) + { + pDi = rtuPtr->m_pDi + k; + pDi->FwMapping[pDi->FwMapNum].MappingIndex = MappingIndex; + pDi->FwMapping[pDi->FwMapNum].RemoteNo = RemoteNo;//远动号没有实际意义。 + RemoteNo++; + pDi->FwMapNum++; + } + } + } + } + } + FwRtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RemoteNo; +} + + +/** +* @brief CFesBase::SetRtuBlockSeqNo +* 同一通道下所有RTU块序号统一排列序号 +* @param RtuPtr RTU +* @param StartSeqNo 起始块序号 +* @param retSeqNo 返回块序号 +* @return +*/ +void CFesBase::SetRtuBlockSeqNo(CFesRtuPtr RtuPtr, int StartSeqNo,int &retSeqNo) +{ + int i; + SModbusCmd *pCmd; + for (i = 0; i < RtuPtr->m_Param.ModbusCmdBuf.num; i++) + { + pCmd = RtuPtr->m_Param.ModbusCmdBuf.pCmd + i; + pCmd->SeqNo = StartSeqNo + i; + //LOGDEBUG("RTUNo=%d i=%d pCmd->SeqNo=%d", RtuPtr->m_Param.RtuNo, i, pCmd->SeqNo); + } + retSeqNo += RtuPtr->m_Param.ModbusCmdBuf.num; +} + +/** +* @brief CFesBase::GetFwRtuAiValue +* 根据RtuNo ,PointNo获取点值 +* @param ptrRtu RTU指针 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetFwRtuAiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwAiValue *retValue) +{ + SFesFwAi *pAi; + + if ((PointNo < ptrRtu->m_MaxFwAiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AiMutex); + pAi = ptrRtu->m_pFwAi + PointNo; + retValue->Value = pAi->Value; + retValue->Status = pAi->Status; + retValue->time = pAi->time; + return true; + } + retValue->Value = 0; + retValue->Status = 0; + retValue->time = 0; + return false; +} + +/** +* @brief CFesBase::GetFwRtuDiValue +* 根据RtuNo ,PointNo获取点值 +* @param CFesRtuPtr RTU指针 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetFwRtuDiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwDiValue *retValue) +{ + SFesFwDi *pDi; + + if ((PointNo < ptrRtu->m_MaxFwDiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_DiMutex); + pDi = ptrRtu->m_pFwDi + PointNo; + retValue->Value = pDi->Value; + retValue->Status = pDi->Status; + retValue->time = pDi->time; + return true; + } + retValue->Value = 0; + retValue->Status = 0; + retValue->time = 0; + return false; +} + +/** +* @brief CFesBase::GetFwRtuAccValue +* 根据RtuNo ,PointNo获取点值 +* @param CFesRtuPtr RTU指针 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetFwRtuAccValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwAccValue *retValue) +{ + SFesFwAcc *pAcc; + + if ((PointNo < ptrRtu->m_MaxAccPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_AccMutex); + pAcc = ptrRtu->m_pFwAcc + PointNo; + retValue->Value = pAcc->Value; + retValue->Status = pAcc->Status; + retValue->time = pAcc->time; + return true; + } + retValue->Value = 0; + retValue->Status = 0; + retValue->time = 0; + return false; +} + +/** +* @brief CFesBase::GetRtuFwMiValue +* 根据RtuNo ,PointNo获取点值 +* @param CFesRtuPtr RTU指针 +* @param PointNo 点号 +* @param retValue 返回值 +* @return 成功：true 失败：false +*/ +bool CFesBase::GetRtuFwMiValue(CFesRtuPtr ptrRtu, int PointNo, SFesFwMiValue *retValue) +{ + SFesFwMi *pMi; + + if ((PointNo < ptrRtu->m_MaxFwMiPoints) && (PointNo >= 0)) + { + boost::mutex::scoped_lock lock(ptrRtu->m_MiMutex); + pMi = ptrRtu->m_pFwMi + PointNo; + retValue->Value = pMi->Value; + retValue->Status = pMi->Status; + retValue->time = pMi->time; + return true; + } + retValue->Value = 0; + retValue->Status = 0; + retValue->time = 0; + return false; +} diff --git a/product/src/fes/fes/FesChanManageThread.cpp b/product/src/fes/fes/FesChanManageThread.cpp index 1ebea5e6..2197c1c7 100644 --- a/product/src/fes/fes/FesChanManageThread.cpp +++ b/product/src/fes/fes/FesChanManageThread.cpp @@ -20,11 +20,9 @@ 2021-10-18 thxiao CheckChanStatus()不再判断通道下是否有RTU,主备通道状态都更新 2021-12-02 thxiao 备用通道无效，则下一通道。 2021-12-24 thxiao CheckChanStatus()主机才报告事件 - 2022-09-28 thxiao 每天随机把转发标志设置1小时为false,让通信中断1小时 */ #include "FesChanManageThread.h" #include "pub_utility_api/TimeUtil.h" -#include "pub_utility_api/CommonConfigParse.h" //#include "FesRtu.h" using namespace iot_public; @@ -32,7 +30,7 @@ using namespace iot_dbms; extern bool g_IsMainFes; extern bool g_IsMainFesOld; - + CFesChanManageThread::CFesChanManageThread(iot_public::SRunAppInfo stRunAppInfo,void* FesBaseAddr): CTimerThreadBase("FesChanManageThread", 100) { @@ -53,21 +51,6 @@ CTimerThreadBase("FesChanManageThread", 100) m_timerCount = 0; m_lastOfflineSecTime = getMonotonicMsec(); - //2022-09-28 thxiao 每天随机把转发标志设置1小时为false,让通信中断1小时 - m_IsMainFesZf = g_IsMainFes; - m_ComDownMSec = getMonotonicMsec(); //启动时间 - m_ComDownStepHighLimit=108000000; //计数偏移量，最大偏移值>24h 30*60*60*1000=108000000 - m_ComDownStepLowLimit=86400000; //计数偏移量，最小偏移值>24h 24*60*60*1000=86400000 - m_ComDownStep=1020000; //偏移值步长17*60*1000=1020000 - m_ComDownOffSet = m_ComDownStepLowLimit; //当前偏移值是个有步长的偏移量，到达最高值时，返回最低值继续循环。 - m_ComDownStepCount=0; //偏移值计数 - m_ComDownKeepMsec = 3600000; //停止持续时间 3600*1000=3600000 - m_ComDownStartMSec = m_ComDownMSec+ m_ComDownOffSet; //停止时间 - m_ComDownStopMSec = m_ComDownStartMSec + m_ComDownKeepMsec; //停止时间 - m_lastCheckDogTimes = 0; - ReadConfigParam(); - m_ptrDogAuth = iot_sys::getDogAuthInstance(); - LOGDEBUG("current=%lld m_ComDownOffSet=%lld m_ComDownStartMSec=%lld m_ComDownStopMSec=%lld", m_ComDownMSec, m_ComDownOffSet, m_ComDownStartMSec, m_ComDownStopMSec); } CFesChanManageThread::~CFesChanManageThread() @@ -100,7 +83,7 @@ void CFesChanManageThread::execute() { CFesChanPtr ptrMainFesChan; //CHAN数据区 int ChanNo, MainChanNo,i; - int64 curmsec ; + int64 curmsec; if (m_timerCount++ >= m_timerCountReset) { @@ -122,28 +105,11 @@ void CFesChanManageThread::execute() } //检查通道状态，同时计算通道误码率 - CheckChanStatus(); + CheckChanStatus(); - if(m_BreakDownFlag) //通信控制 - { - if ((curmsec - m_lastCheckDogTimes) >60*1000)//:狗校验失败情况，定时停止转发功能,检查周期 1分钟 - { - if(m_ptrDogAuth->checkAuthStatus() != AUTH_STATUS_OK) //狗异常 - { - SetIsMainFesZf(); - } - else //狗正常 - { - m_IsMainFesZf = g_IsMainFes; - } - } - } - else //不控制 - { - m_IsMainFesZf = g_IsMainFes; - } } + if (g_IsMainFes != g_IsMainFesOld) { for (int i = 0; i < m_ptrCFesBase->m_ProtocolNum; i++) @@ -159,7 +125,6 @@ void CFesChanManageThread::execute() g_IsMainFesOld = g_IsMainFes; } - for (i = 0; i < (int)m_ptrCFesBase->m_vectCFesChanPtr.size(); i++) { ptrMainFesChan = m_ptrCFesBase->m_vectCFesChanPtr[i]; @@ -284,8 +249,7 @@ void CFesChanManageThread::execute() ptrMainFesChan->m_CurrentChanIndex = 0; } //FES在主机状态下，需要打开所有通道 - //if (g_IsMainFes == true) - if ((m_IsMainFesZf == true)&&(g_IsMainFes == true)) + if(g_IsMainFes == true) { CFesChanPtr ptrCurrentChan; //current CHAN数据区 ptrCurrentChan = m_ptrCFesBase->GetChanDataByChanNo(ChanNo); @@ -334,6 +298,8 @@ void CFesChanManageThread::execute() } } } + + } /* @@ -767,76 +733,3 @@ void CFesChanManageThread::NotifyExitSystem() } LOGDEBUG("已通知%d个规约模块退出", count); } - -/** -* @brief CFesChanManageThread::SetIsMainFesZf -* -* 每天随机把转发标志设置1小时为false. -* -* @param -*/ - -void CFesChanManageThread::SetIsMainFesZf() -{ - int64 lMsec; - - lMsec = getMonotonicMsec(); - if (lMsec > m_ComDownStopMSec)// - { - m_ComDownOffSet = m_ComDownStepLowLimit + m_ComDownStep*m_ComDownStepCount;//当前偏移值 - m_ComDownStepCount++; - m_ComDownStartMSec = lMsec + m_ComDownOffSet; //启动时间 - m_ComDownStopMSec = m_ComDownStartMSec + m_ComDownKeepMsec; //停止时间 - if (m_ComDownOffSet > m_ComDownStepHighLimit) - { - m_ComDownStepCount = 0; - m_ComDownOffSet = m_ComDownStepLowLimit; - } - LOGDEBUG("current=%lld m_ComDownOffSet=%lld m_ComDownStartMSec=%lld m_ComDownStopMSec=%lld", lMsec,m_ComDownOffSet, m_ComDownStartMSec, m_ComDownStopMSec); - } - - if ((lMsec>m_ComDownStartMSec)&&(lMsec CFesChanManageThreadPtr; diff --git a/product/src/fes/fes/FesDataSyncThread.cpp b/product/src/fes/fes/FesDataSyncThread.cpp index eb074a6b..469c3193 100644 --- a/product/src/fes/fes/FesDataSyncThread.cpp +++ b/product/src/fes/fes/FesDataSyncThread.cpp @@ -249,7 +249,7 @@ int CFesDataSyncThread::RtuDiAllResp() if(m_ptrCFesBase==NULL) return iotFailed; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for(i=0;im_vectCFesRtuPtr[i]; @@ -328,7 +328,7 @@ int CFesDataSyncThread::RtuDDiAllResp() if (m_ptrCFesBase == NULL) return iotFailed; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for (i = 0; im_vectCFesRtuPtr[i]; @@ -389,12 +389,11 @@ int CFesDataSyncThread::RtuAiAllResp() { int i,j,retNum,count; CFesRtuPtr ptrCFesRtu; - CFesChanPtr pChan; if(m_ptrCFesBase==NULL) return iotFailed; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for(i=0;im_vectCFesRtuPtr[i]; @@ -469,7 +468,7 @@ int CFesDataSyncThread::RtuAccAllResp() if(m_ptrCFesBase==NULL) return iotFailed; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for(i=0;im_vectCFesRtuPtr[i]; @@ -507,7 +506,7 @@ int CFesDataSyncThread::RtuAccAllResp() pRtuAccValue = m_pAccValue+j; pAccValue = respPkg.add_stpivalue(); pAccValue->set_npointno(pRtuAccValue->PointNo); - pAccValue->set_nvalue(pRtuAccValue->Value); + pAccValue->set_dvalue(pRtuAccValue->Value); pAccValue->set_ustatus(pRtuAccValue->Status); pAccValue->set_ultime(pRtuAccValue->time); } @@ -545,7 +544,7 @@ int CFesDataSyncThread::RtuMiAllResp() if(m_ptrCFesBase==NULL) return iotFailed; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for(i=0;im_vectCFesRtuPtr[i]; @@ -638,7 +637,7 @@ int CFesDataSyncThread::RtuDiResp(const std::string &RecvStr) { for (i = 0; i < count; i++) { - SFesDiValue diValue = respPkg.stdivalue(i); + const SFesDiValue &diValue = respPkg.stdivalue(i); SFesFwChgDi RtuDiValue; RtuDiValue.RemoteNo = diValue.npointno(); RtuDiValue.Value = diValue.nvalue(); @@ -659,7 +658,7 @@ int CFesDataSyncThread::RtuDiResp(const std::string &RecvStr) for (i = 0; i < count; i++) { - SFesDiValue diValue = respPkg.stdivalue(i); + const SFesDiValue &diValue = respPkg.stdivalue(i); pRtuDiValue = m_pDiValue + i; pRtuDiValue->PointNo = diValue.npointno(); pRtuDiValue->Value = diValue.nvalue(); @@ -697,7 +696,7 @@ int CFesDataSyncThread::RtuDDiResp(const std::string &RecvStr) { for (i = 0; i < count; i++) { - SFesDiValue diValue = respPkg.stdivalue(i); + const SFesDiValue &diValue = respPkg.stdivalue(i); SFesFwChgDi RtuDiValue; RtuDiValue.RemoteNo = diValue.npointno(); RtuDiValue.Value = diValue.nvalue(); @@ -740,13 +739,15 @@ int CFesDataSyncThread::RtuAiResp(const std::string &RecvStr) { for (i = 0; i < count; i++) { - SFesAiValue aiValue = respPkg.staivalue(i); + const SFesAiValue &aiValue = respPkg.staivalue(i); SFesFwChgAi RtuAiValue; RtuAiValue.RemoteNo = aiValue.npointno(); RtuAiValue.Value = aiValue.fvalue(); RtuAiValue.Status = aiValue.ustatus(); RtuAiValue.time = aiValue.ultime(); - ptrCFesRtu->UpdataFwAiValue(RtuAiValue); + //< 直接更新，因为这是从内存中同步过来的，也就是发送的已经是经过系数变换的 + float fNewValue = 0.0f; + ptrCFesRtu->UpdataFwAiValue(RtuAiValue,fNewValue,eDirectUpdate); } } else @@ -761,7 +762,7 @@ int CFesDataSyncThread::RtuAiResp(const std::string &RecvStr) for (i = 0; i < count; i++) { - SFesAiValue aiValue = respPkg.staivalue(i); + const SFesAiValue &aiValue = respPkg.staivalue(i); pRtuAiValue = m_pAiValue + i; pRtuAiValue->PointNo = aiValue.npointno(); pRtuAiValue->Value = aiValue.fvalue(); @@ -804,15 +805,16 @@ int CFesDataSyncThread::RtuAccResp(const std::string &RecvStr) if (ptrCFesRtu->m_RtuProperty == CN_Fes_RTU_Forward)//2020-01-10 thxiao 增加转发数据同步 { + double dNewValue = 0.0; for (i = 0; i < count; i++) { - SFesPiValue accValue = respPkg.stpivalue(i); + const SFesPiValue &accValue = respPkg.stpivalue(i); SFesFwChgAcc RtuAccValue; RtuAccValue.RemoteNo = accValue.npointno(); - RtuAccValue.Value = accValue.nvalue(); + RtuAccValue.Value = accValue.dvalue(); RtuAccValue.Status = accValue.ustatus(); RtuAccValue.time = accValue.ultime(); - ptrCFesRtu->UpdataFwAccValue(RtuAccValue); + ptrCFesRtu->UpdataFwAccValue(RtuAccValue,dNewValue,eDirectUpdate); } } else @@ -827,10 +829,10 @@ int CFesDataSyncThread::RtuAccResp(const std::string &RecvStr) for (i = 0; i < count; i++) { - SFesPiValue accValue = respPkg.stpivalue(i); + const SFesPiValue &accValue = respPkg.stpivalue(i); pRtuAccValue = m_pAccValue + i; pRtuAccValue->PointNo = accValue.npointno(); - pRtuAccValue->Value = accValue.nvalue(); + pRtuAccValue->Value = accValue.dvalue(); pRtuAccValue->Status = accValue.ustatus(); pRtuAccValue->time = accValue.ultime(); } @@ -865,15 +867,16 @@ int CFesDataSyncThread::RtuMiResp(const std::string &RecvStr) if (ptrCFesRtu->m_RtuProperty == CN_Fes_RTU_Forward)//2020-01-10 thxiao 增加转发数据同步 { + int nNewValue = 0; for (i = 0; i < count; i++) { - SFesMiValue miValue = respPkg.stmivalue(i); + const SFesMiValue &miValue = respPkg.stmivalue(i); SFesFwChgMi RtuMiValue; RtuMiValue.RemoteNo = miValue.npointno(); RtuMiValue.Value = miValue.nvalue(); RtuMiValue.Status = miValue.ustatus(); RtuMiValue.time = miValue.ultime(); - ptrCFesRtu->UpdataFwMiValue(RtuMiValue); + ptrCFesRtu->UpdataFwMiValue(RtuMiValue,nNewValue,eDirectUpdate); } } else @@ -888,7 +891,7 @@ int CFesDataSyncThread::RtuMiResp(const std::string &RecvStr) for (i = 0; i < count; i++) { - SFesMiValue miValue = respPkg.stmivalue(i); + const SFesMiValue &miValue = respPkg.stmivalue(i); pRtuMiValue = m_pMiValue + i; pRtuMiValue->PointNo = miValue.npointno(); pRtuMiValue->Value = miValue.nvalue(); @@ -918,7 +921,7 @@ void CFesDataSyncThread::SendRtuDataReq() return; rtuNo = -1; - count = m_ptrCFesBase->m_vectCFesRtuPtr.size(); + count = static_cast(m_ptrCFesBase->m_vectCFesRtuPtr.size()); for(i=0;im_vectCFesRtuPtr[i]; diff --git a/product/src/fes/fes/FesForwardConfig.cpp b/product/src/fes/fes/FesForwardConfig.cpp index 62862d34..28d20c28 100644 --- a/product/src/fes/fes/FesForwardConfig.cpp +++ b/product/src/fes/fes/FesForwardConfig.cpp @@ -1,987 +1,1008 @@ -/* -@file FesForwardConfig.cpp -@brief 转发配置基础类 -@author JACKYWU -@history -2019-06-14 thxiao CRdbAccessEx selectOneOrder()默认方式由倒序变为顺序，所有有关实时库的读取方式全变了，使用默认方式。 -2022-01-17 thxiao GetRdbFwDDiTable() 判断空有误，当配置没有单点遥信，只有双点时，双点配置无法正常，点值也无法正常显示。 - -*/ -#include "FesForwardConfig.h" -#include "rdb_api/CRdbAccessEx.h" -#include "rdb_api/CRdbAccess.h" - -using namespace iot_dbms; - -CFesForwarding::CFesForwarding() -{ - -} - -CFesForwarding::~CFesForwarding() -{ - -} - -/** - * @brief CFesBase::GetRdbFwAiTable - * 获取Ai转发表参数 - * @return 无 - */ -void CFesForwarding::GetRdbFwAiTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - int j; - SFesFwAi *pFwAi; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwAiTable; - std::vector VecFwAiParam; - std::vector vecFwAiColumn; - - vecFwAiColumn.push_back("remote_no"); - vecFwAiColumn.push_back("tag_name"); - vecFwAiColumn.push_back("description"); - vecFwAiColumn.push_back("dp_tag_name"); - vecFwAiColumn.push_back("fes_rtu_no"); - vecFwAiColumn.push_back("fes_dot_no"); - vecFwAiColumn.push_back("dp_seq_no"); - vecFwAiColumn.push_back("coeff"); - vecFwAiColumn.push_back("base"); - vecFwAiColumn.push_back("deadband_type"); - vecFwAiColumn.push_back("deadband"); - vecFwAiColumn.push_back("property"); - vecFwAiColumn.push_back("src_location_id"); - vecFwAiColumn.push_back("src_sub_system"); - vecFwAiColumn.push_back("res_para_int1"); - vecFwAiColumn.push_back("res_para_int2"); - vecFwAiColumn.push_back("res_para_int3"); - vecFwAiColumn.push_back("res_para_int4"); - vecFwAiColumn.push_back("res_para_int5"); - vecFwAiColumn.push_back("res_para_int6"); - vecFwAiColumn.push_back("res_para_int7"); - vecFwAiColumn.push_back("res_para_str64"); - vecFwAiColumn.push_back("src_type"); - - ret = RdbFwAiTable.open(m_strAppLabel.c_str(),RT_FES_FW_AI_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbFwAiTable::Open error"); - return; - } - - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname= RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name,"rtu_tag"); - - ret = RdbFwAiTable.selectOneOrder(con, VecFwAiParam, vecFwAiColumn, "remote_no");//默认顺序 - if (ret==false) - { - LOGERROR("CFesBase::InitBaseData, RdbFwAiTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwAiPoints = 0; - count = VecFwAiParam.size(); - //LOGDEBUG("RTU%d VecFwAiParam.size():%d",RtuPtr->m_Param.RtuNo,count); - if(count>0) - { - RtuPtr->m_MaxFwAiPoints = VecFwAiParam[count-1].RemoteNo +1; - RtuPtr->m_FwAiPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwAi = (SFesFwAi*)malloc(RtuPtr->m_MaxFwAiPoints*sizeof(SFesFwAi)); - if(RtuPtr->m_pFwAi!=NULL) - { - memset(RtuPtr->m_pFwAi,0,RtuPtr->m_MaxFwAiPoints*sizeof(SFesFwAi)); - for(j=0;jm_MaxFwAiPoints) - { - pFwAi = RtuPtr->m_pFwAi+ VecFwAiParam[j].RemoteNo; - pFwAi->RemoteNo = VecFwAiParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwAi->TagName,VecFwAiParam[j].TagName); //点标签名 - strcpy(pFwAi->PointDesc, VecFwAiParam[j].PointDesc); //点描述 - strcpy(pFwAi->DPTagName, VecFwAiParam[j].DPTagName); //后台标签名 - pFwAi->FesRtuNo = VecFwAiParam[j].FesRtuNo; //采集rtu号 - pFwAi->FesPointNo = VecFwAiParam[j].FesPointNo; //采集点号 - pFwAi->DpSeqNo = VecFwAiParam[j].DpSeqNo; //远动序号 - pFwAi->Coeff = (float)VecFwAiParam[j].Coeff; //系数 - pFwAi->Base = (float)VecFwAiParam[j].Base; //修正值 - pFwAi->DeadBandType = (float)VecFwAiParam[j].DeadBandType; - pFwAi->DeadBand = (float)VecFwAiParam[j].DeadBand; //死区值 - pFwAi->Property = VecFwAiParam[j].Property; //属性 - pFwAi->SrcLocationID = VecFwAiParam[j].SrcLocationID; //所属厂站 - pFwAi->SrcSubSystem = VecFwAiParam[j].SrcSubSystem; //所属专业 - pFwAi->ResParam1 = VecFwAiParam[j].ResParam1; //备用参数1 - pFwAi->ResParam2 = VecFwAiParam[j].ResParam2; //备用参数1 - pFwAi->ResParam3 = VecFwAiParam[j].ResParam3; //备用参数1 - pFwAi->ResParam4 = VecFwAiParam[j].ResParam4; //备用参数1 - pFwAi->ResParam5 = VecFwAiParam[j].ResParam5; //备用参数1 - pFwAi->ResParam6 = VecFwAiParam[j].ResParam6; //备用参数1 - pFwAi->ResParam7 = VecFwAiParam[j].ResParam7; //备用参数1 - strcpy(pFwAi->StrParam, VecFwAiParam[j].StrParam); - pFwAi->SrcType = VecFwAiParam[j].SrcType; //备用参数1 - pFwAi->Used=1; //点有效标志 - //LOGDEBUG("@@@@@@@@@@@@ RtuNo:%d TagName:%s DPTagName:%s Desc:%s SrcType:%d", RtuPtr->m_Param.RtuNo, pFwAi->TagName, pFwAi->DPTagName, pFwAi->PointDesc, pFwAi->SrcType) - - } - else - { - LOGERROR("RtuNo:%d FwAi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAiParam[j].RemoteNo,RtuPtr->m_MaxFwAiPoints); - } - } - } - else - { - RtuPtr->m_MaxFwAiPoints = 0; - LOGERROR("RtuNo:%d pFwAi create failed.\n",RtuPtr->m_Param.RtuNo); - } - } - RtuPtr->FwAiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwAiPoints; - - ret = RdbFwAiTable.close(); - if(ret==false) - { - LOGERROR("RdbFwAiTable::close error"); - return; - } -} - -/** - * @brief CFesBase::GetRdbFwSDiTable - * 获取Di转发表参数 - * @return 无 - */ -void CFesForwarding::GetRdbFwSDiTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - int j; - SFesFwDi *pFwDi; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwDiTable; - std::vector VecFwDiParam; - std::vector vecFwDiColumn; - - vecFwDiColumn.push_back("remote_no"); - vecFwDiColumn.push_back("tag_name"); - vecFwDiColumn.push_back("description"); - vecFwDiColumn.push_back("dp_tag_name"); - vecFwDiColumn.push_back("fes_rtu_no"); - vecFwDiColumn.push_back("fes_dot_no"); - vecFwDiColumn.push_back("dp_seq_no"); - vecFwDiColumn.push_back("property"); - vecFwDiColumn.push_back("src_location_id"); - vecFwDiColumn.push_back("src_sub_system"); - vecFwDiColumn.push_back("res_para_int1"); - vecFwDiColumn.push_back("res_para_int2"); - vecFwDiColumn.push_back("res_para_int3"); - vecFwDiColumn.push_back("res_para_int4"); - vecFwDiColumn.push_back("res_para_int5"); - vecFwDiColumn.push_back("res_para_int6"); - vecFwDiColumn.push_back("res_para_int7"); - vecFwDiColumn.push_back("res_para_str64"); - vecFwDiColumn.push_back("src_type"); - ret = RdbFwDiTable.open(m_strAppLabel.c_str(), RT_FES_FW_SDI_TBL); - if(ret==false) - { - LOGERROR("RdbFwDiTable::Open error"); - return; - } - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwDiTable.selectOneOrder(con, VecFwDiParam, vecFwDiColumn, "remote_no");//默认顺序 - if (ret==false) - { - LOGERROR("RdbFwDiTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwDiPoints = 0; - count = VecFwDiParam.size(); - //LOGDEBUG("RTU%d VecFwDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); - if(count>0) - { - RtuPtr->m_MaxFwDiPoints = VecFwDiParam[count-1].RemoteNo +1; - RtuPtr->m_FwDiPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwDi = (SFesFwDi*)malloc(RtuPtr->m_MaxFwDiPoints*sizeof(SFesFwDi)); - if(RtuPtr->m_pFwDi!=NULL) - { - memset(RtuPtr->m_pFwDi,0,RtuPtr->m_MaxFwDiPoints*sizeof(SFesFwDi)); - for(j=0;jm_MaxFwDiPoints) - { - pFwDi = RtuPtr->m_pFwDi + VecFwDiParam[j].RemoteNo; - pFwDi->RemoteNo = VecFwDiParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwDi->TagName, VecFwDiParam[j].TagName); //点标签名 - strcpy(pFwDi->PointDesc, VecFwDiParam[j].PointDesc); //点描述 - strcpy(pFwDi->DPTagName, VecFwDiParam[j].DPTagName); //后台标签名 - pFwDi->FesRtuNo = VecFwDiParam[j].FesRtuNo; //采集rtu号 - pFwDi->FesPointNo = VecFwDiParam[j].FesPointNo; //采集点号 - pFwDi->DpSeqNo = VecFwDiParam[j].DpSeqNo; //远动序号 - pFwDi->Property = VecFwDiParam[j].Property; //属性 - pFwDi->SrcLocationID = VecFwDiParam[j].SrcLocationID; //所属厂站 - pFwDi->SrcSubSystem = VecFwDiParam[j].SrcSubSystem; //所属专业 - pFwDi->ResParam1 = VecFwDiParam[j].ResParam1; //备用参数1 - pFwDi->ResParam2 = VecFwDiParam[j].ResParam2; //备用参数1 - pFwDi->ResParam3 = VecFwDiParam[j].ResParam3; //备用参数1 - pFwDi->ResParam4 = VecFwDiParam[j].ResParam4; //备用参数1 - pFwDi->ResParam5 = VecFwDiParam[j].ResParam5; //备用参数1 - pFwDi->ResParam6 = VecFwDiParam[j].ResParam6; //备用参数1 - pFwDi->ResParam7 = VecFwDiParam[j].ResParam7; //备用参数1 - strcpy(pFwDi->StrParam, VecFwDiParam[j].StrParam); - pFwDi->SrcType = VecFwDiParam[j].SrcType; //备用参数1 - pFwDi->DORemoteNo = -1; - pFwDi->Used = 1; //点有效标志 - } - else - { - LOGERROR("RtuNo:%d FwDi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwDiParam[j].RemoteNo,RtuPtr->m_MaxFwDiPoints); - } - } - } - else - { - RtuPtr->m_MaxFwDiPoints = 0; - LOGERROR("RtuNo:%d pFwDi create failed.\n",RtuPtr->m_Param.RtuNo); - } - - RtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwDiPoints; - } - - ret = RdbFwDiTable.close(); - if(ret==false) - { - LOGERROR("RdbFwDiTable::close error"); - return; - } -} - - -/** -* @brief CFesBase::GetRdbFwDDiTable -* 获取Di转发表参数 -* @return 无 -*/ -void CFesForwarding::GetRdbFwDDiTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) -{ - int j; - SFesFwDi *pFwDi; - bool ret; - int count; - //int RtuNum; - - iot_dbms::CRdbAccessEx RdbFwDiTable; - std::vector VecFwDiParam; - std::vector vecFwDiColumn; - - vecFwDiColumn.push_back("remote_no"); - vecFwDiColumn.push_back("tag_name"); - vecFwDiColumn.push_back("description"); - vecFwDiColumn.push_back("dp_tag_name"); - vecFwDiColumn.push_back("fes_rtu_no"); - vecFwDiColumn.push_back("fes_dot_no"); - vecFwDiColumn.push_back("dp_seq_no"); - vecFwDiColumn.push_back("property"); - vecFwDiColumn.push_back("src_location_id"); - vecFwDiColumn.push_back("src_sub_system"); - vecFwDiColumn.push_back("res_para_int1"); - vecFwDiColumn.push_back("res_para_int2"); - vecFwDiColumn.push_back("res_para_int3"); - vecFwDiColumn.push_back("res_para_int4"); - vecFwDiColumn.push_back("res_para_int5"); - vecFwDiColumn.push_back("res_para_int6"); - vecFwDiColumn.push_back("res_para_int7"); - vecFwDiColumn.push_back("res_para_str64"); - vecFwDiColumn.push_back("src_type"); - ret = RdbFwDiTable.open(m_strAppLabel.c_str(), RT_FES_FW_DDI_TBL); - if (ret == false) - { - LOGERROR("CFesBase::InitBaseData,RdbFwDiTable::Open error"); - return; - } - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwDiTable.selectOneOrder(con, VecFwDiParam, vecFwDiColumn, "remote_no");//默认顺序 - if (ret == false) - { - LOGERROR("RdbFwDiTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwDDiPoints = 0; - count = VecFwDiParam.size(); - //LOGDEBUG("RTU%d VecFwDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); - if (count>0) - { - RtuPtr->m_MaxFwDDiPoints = VecFwDiParam[count - 1].RemoteNo + 1; - RtuPtr->m_FwDDiPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwDDi = (SFesFwDi*)malloc(RtuPtr->m_MaxFwDDiPoints * sizeof(SFesFwDi)); - if (RtuPtr->m_pFwDDi != NULL)//2022-01-17 thxiao - { - memset(RtuPtr->m_pFwDDi, 0, RtuPtr->m_MaxFwDDiPoints * sizeof(SFesFwDi)); - for (j = 0; jm_MaxFwDiPoints) - { - pFwDi = RtuPtr->m_pFwDDi + VecFwDiParam[j].RemoteNo; - pFwDi->RemoteNo = VecFwDiParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwDi->TagName, VecFwDiParam[j].TagName); //点标签名 - strcpy(pFwDi->PointDesc, VecFwDiParam[j].PointDesc); //点描述 - strcpy(pFwDi->DPTagName, VecFwDiParam[j].DPTagName); //后台标签名 - pFwDi->FesRtuNo = VecFwDiParam[j].FesRtuNo; //采集rtu号 - pFwDi->FesPointNo = VecFwDiParam[j].FesPointNo; //采集点号 - pFwDi->DpSeqNo = VecFwDiParam[j].DpSeqNo; //远动序号 - pFwDi->Property = VecFwDiParam[j].Property; //属性 - pFwDi->SrcLocationID = VecFwDiParam[j].SrcLocationID; //所属厂站 - pFwDi->SrcSubSystem = VecFwDiParam[j].SrcSubSystem; //所属专业 - pFwDi->ResParam1 = VecFwDiParam[j].ResParam1; //备用参数1 - pFwDi->ResParam2 = VecFwDiParam[j].ResParam2; //备用参数1 - pFwDi->ResParam3 = VecFwDiParam[j].ResParam3; //备用参数1 - pFwDi->ResParam4 = VecFwDiParam[j].ResParam4; //备用参数1 - pFwDi->ResParam5 = VecFwDiParam[j].ResParam5; //备用参数1 - pFwDi->ResParam6 = VecFwDiParam[j].ResParam6; //备用参数1 - pFwDi->ResParam7 = VecFwDiParam[j].ResParam7; //备用参数1 - strcpy(pFwDi->StrParam, VecFwDiParam[j].StrParam); - pFwDi->SrcType = VecFwDiParam[j].SrcType; //备用参数1 - pFwDi->Used = 1; //点有效标志 - // RtuNum = 0; - } - else - { - LOGERROR("RtuNo:%d FwDi RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwDiParam[j].RemoteNo, RtuPtr->m_MaxFwDiPoints); - } - } - } - else - { - RtuPtr->m_MaxFwDDiPoints = 0; - LOGERROR("RtuNo:%d pFwDi create failed.\n", RtuPtr->m_Param.RtuNo); - } - - RtuPtr->FwDDiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwDDiPoints; - } - - ret = RdbFwDiTable.close(); - if (ret == false) - { - LOGERROR("RdbFwDiTable::close error"); - return; - } -} - -/** - * @brief CFesBase::GetRdbFwAccTable - * 获取Acc转发表参数 - * @return 无 - */ -void CFesForwarding::GetRdbFwAccTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - - int j; - SFesFwAcc *pFwAcc; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwAccTable; - std::vector VecFwAccParam; - std::vector vecFwAccColumn; - - vecFwAccColumn.push_back("remote_no"); - vecFwAccColumn.push_back("tag_name"); - vecFwAccColumn.push_back("description"); - vecFwAccColumn.push_back("dp_tag_name"); - vecFwAccColumn.push_back("fes_rtu_no"); - vecFwAccColumn.push_back("fes_dot_no"); - vecFwAccColumn.push_back("dp_seq_no"); - vecFwAccColumn.push_back("coeff"); - vecFwAccColumn.push_back("base"); - vecFwAccColumn.push_back("property"); - vecFwAccColumn.push_back("src_location_id"); - vecFwAccColumn.push_back("src_sub_system"); - vecFwAccColumn.push_back("res_para_int1"); - vecFwAccColumn.push_back("res_para_int2"); - vecFwAccColumn.push_back("res_para_int3"); - vecFwAccColumn.push_back("res_para_int4"); - vecFwAccColumn.push_back("res_para_int5"); - vecFwAccColumn.push_back("res_para_int6"); - vecFwAccColumn.push_back("res_para_int7"); - vecFwAccColumn.push_back("res_para_str64"); - vecFwAccColumn.push_back("src_type"); - - ret = RdbFwAccTable.open(m_strAppLabel.c_str(),RT_FES_FW_ACC_TBL); - if(ret==false) - { - LOGERROR("RdbFwAccTable::Open error"); - return; - } - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - - ret = RdbFwAccTable.selectOneOrder(con, VecFwAccParam, vecFwAccColumn, "remote_no");//默认顺序 - if (ret==false) - { - LOGERROR("RdbFwAccTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwAccPoints = 0; - count = VecFwAccParam.size(); - if(count>0) - { - RtuPtr->m_MaxFwAccPoints = VecFwAccParam[count-1].RemoteNo +1; - RtuPtr->m_FwAccPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwAcc = (SFesFwAcc*)malloc(RtuPtr->m_MaxFwAccPoints*sizeof(SFesFwAcc)); - if(RtuPtr->m_pFwAcc!=NULL) - { - memset(RtuPtr->m_pFwAcc,0,RtuPtr->m_MaxFwAccPoints*sizeof(SFesFwAcc)); - - for(j=0;jm_MaxFwAccPoints) - { - pFwAcc = RtuPtr->m_pFwAcc + VecFwAccParam[j].RemoteNo; - pFwAcc->RemoteNo = VecFwAccParam[j].RemoteNo; - strcpy(pFwAcc->TagName, VecFwAccParam[j].TagName); //标签名 - strcpy(pFwAcc->PointDesc, VecFwAccParam[j].PointDesc); //点描述 - strcpy(pFwAcc->DPTagName, VecFwAccParam[j].DPTagName); //后台标签名 - pFwAcc->FesRtuNo = VecFwAccParam[j].FesRtuNo; //采集rtu号 - pFwAcc->FesPointNo = VecFwAccParam[j].FesPointNo; //采集点号 - pFwAcc->DpSeqNo = VecFwAccParam[j].DpSeqNo; //远动序号 - pFwAcc->Coeff = (float)VecFwAccParam[j].Coeff; //系数 - pFwAcc->Base = (float)VecFwAccParam[j].Base; //修正值 - pFwAcc->Property = VecFwAccParam[j].Property; //属性 - pFwAcc->SrcLocationID = VecFwAccParam[j].SrcLocationID; //所属厂站 - pFwAcc->SrcSubSystem = VecFwAccParam[j].SrcSubSystem; //所属专业 - pFwAcc->ResParam1 = VecFwAccParam[j].ResParam1; //备用参数1 - pFwAcc->ResParam2 = VecFwAccParam[j].ResParam2; //备用参数1 - pFwAcc->ResParam3 = VecFwAccParam[j].ResParam3; //备用参数1 - pFwAcc->ResParam4 = VecFwAccParam[j].ResParam4; //备用参数1 - pFwAcc->ResParam5 = VecFwAccParam[j].ResParam5; //备用参数1 - pFwAcc->ResParam6 = VecFwAccParam[j].ResParam6; //备用参数1 - pFwAcc->ResParam7 = VecFwAccParam[j].ResParam7; //备用参数1 - strcpy(pFwAcc->StrParam, VecFwAccParam[j].StrParam); - pFwAcc->SrcType = VecFwAccParam[j].SrcType; //备用参数1 - pFwAcc->Used = 1; //点有效标志 - } - else - { - LOGERROR("RtuNo:%d FwAcc RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAccParam[j].RemoteNo,RtuPtr->m_MaxFwAccPoints); - } - } - } - else - { - RtuPtr->m_MaxFwAccPoints = 0; - LOGERROR("RtuNo:%d pFwAcc create failed.\n",RtuPtr->m_Param.RtuNo); - } - RtuPtr->FwAccMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwAccPoints; - - } - ret = RdbFwAccTable.close(); - if(ret==false) - { - LOGERROR("RdbFwAccTable::close error"); - return; - } -} - -/** -* @brief CFesBase::GetRdbFwMiTable -* 获取Mi转发表参数 -* @return 无 -*/ -void CFesForwarding::GetRdbFwMiTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) -{ - int j; - SFesFwMi *pFwMi; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwMiTable; - std::vector VecFwMiParam; - std::vector vecFwMiColumn; - - vecFwMiColumn.push_back("remote_no"); - vecFwMiColumn.push_back("tag_name"); - vecFwMiColumn.push_back("description"); - vecFwMiColumn.push_back("dp_tag_name"); - vecFwMiColumn.push_back("fes_rtu_no"); - vecFwMiColumn.push_back("fes_dot_no"); - vecFwMiColumn.push_back("dp_seq_no"); - vecFwMiColumn.push_back("coeff"); - vecFwMiColumn.push_back("base"); - vecFwMiColumn.push_back("property"); - vecFwMiColumn.push_back("src_location_id"); - vecFwMiColumn.push_back("src_sub_system"); - vecFwMiColumn.push_back("res_para_int1"); - vecFwMiColumn.push_back("res_para_int2"); - vecFwMiColumn.push_back("res_para_int3"); - vecFwMiColumn.push_back("res_para_int4"); - vecFwMiColumn.push_back("res_para_int5"); - vecFwMiColumn.push_back("res_para_int6"); - vecFwMiColumn.push_back("res_para_int7"); - vecFwMiColumn.push_back("res_para_str64"); - vecFwMiColumn.push_back("src_type"); - - ret = RdbFwMiTable.open(m_strAppLabel.c_str(), RT_FES_FW_MI_TBL); - if (ret == false) - { - LOGERROR("RdbFwMiTable::Open error"); - return; - } - //条件判断 - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwMiTable.selectOneOrder(con, VecFwMiParam, vecFwMiColumn, "remote_no");//默认顺序 - if (ret == false) - { - LOGERROR("RdbFwMiTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwMiPoints = 0; - count = VecFwMiParam.size(); - if (count>0) - { - RtuPtr->m_MaxFwMiPoints = VecFwMiParam[count - 1].RemoteNo + 1; - RtuPtr->m_FwMiPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwMi = (SFesFwMi*)malloc(RtuPtr->m_MaxFwMiPoints * sizeof(SFesFwMi)); - if (RtuPtr->m_pFwMi != NULL) - { - memset(RtuPtr->m_pFwMi, 0, RtuPtr->m_MaxFwMiPoints * sizeof(SFesFwMi)); - - for (j = 0; jm_MaxFwMiPoints) - { - pFwMi = RtuPtr->m_pFwMi + VecFwMiParam[j].RemoteNo; - pFwMi->RemoteNo = VecFwMiParam[j].RemoteNo; - strcpy(pFwMi->TagName, VecFwMiParam[j].TagName); //标签名 - strcpy(pFwMi->PointDesc, VecFwMiParam[j].PointDesc); //点描述 - strcpy(pFwMi->DPTagName, VecFwMiParam[j].DPTagName); //后台标签名 - pFwMi->FesRtuNo = VecFwMiParam[j].FesRtuNo; //采集rtu号 - pFwMi->FesPointNo = VecFwMiParam[j].FesPointNo; //采集点号 - pFwMi->DpSeqNo = VecFwMiParam[j].DpSeqNo; //远动序号 - pFwMi->Coeff = (float)VecFwMiParam[j].Coeff; //系数 - pFwMi->Base = (float)VecFwMiParam[j].Base; //修正值 - pFwMi->Property = VecFwMiParam[j].Property; //属性 - pFwMi->SrcLocationID = VecFwMiParam[j].SrcLocationID; //所属厂站 - pFwMi->SrcSubSystem = VecFwMiParam[j].SrcSubSystem; //所属专业 - pFwMi->ResParam1 = VecFwMiParam[j].ResParam1; //备用参数1 - pFwMi->ResParam2 = VecFwMiParam[j].ResParam2; //备用参数1 - pFwMi->ResParam3 = VecFwMiParam[j].ResParam3; //备用参数1 - pFwMi->ResParam4 = VecFwMiParam[j].ResParam4; //备用参数1 - pFwMi->ResParam5 = VecFwMiParam[j].ResParam5; //备用参数1 - pFwMi->ResParam6 = VecFwMiParam[j].ResParam6; //备用参数1 - pFwMi->ResParam7 = VecFwMiParam[j].ResParam7; //备用参数1 - strcpy(pFwMi->StrParam, VecFwMiParam[j].StrParam); - pFwMi->SrcType = VecFwMiParam[j].SrcType; //备用参数1 - pFwMi->Used = 1; //点有效标志 - } - else - { - LOGERROR("RtuNo:%d FwMi RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwMiParam[j].RemoteNo, RtuPtr->m_MaxFwMiPoints); - } - } - } - else - { - RtuPtr->m_MaxFwMiPoints = 0; - LOGERROR("RtuNo:%d pFwMi create failed.\n", RtuPtr->m_Param.RtuNo); - } - RtuPtr->FwMiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwMiPoints; - - } - ret = RdbFwMiTable.close(); - if (ret == false) - { - LOGERROR("RdbFwMiTable::close error"); - return; - } -} - -/** - * @brief CFesBase::GetRdbFwAoTable - * 获取Ao转发表参数 - * @return 无 - */ -void CFesForwarding::GetRdbFwAoTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - int j; - SFesFwAo *pFwAo; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwAoTable; - std::vector VecFwAoParam; - std::vector vecFwAoColumn; - - vecFwAoColumn.push_back("remote_no"); - vecFwAoColumn.push_back("tag_name"); - vecFwAoColumn.push_back("description"); - vecFwAoColumn.push_back("fes_rtu_no"); - vecFwAoColumn.push_back("fes_dot_no"); - vecFwAoColumn.push_back("max_range"); - vecFwAoColumn.push_back("min_range"); - vecFwAoColumn.push_back("coeff"); - vecFwAoColumn.push_back("base"); - vecFwAoColumn.push_back("property"); - vecFwAoColumn.push_back("src_location_id"); - vecFwAoColumn.push_back("src_sub_system"); - vecFwAoColumn.push_back("res_para_int1"); - vecFwAoColumn.push_back("res_para_int2"); - vecFwAoColumn.push_back("res_para_int3"); - vecFwAoColumn.push_back("res_para_int4"); - vecFwAoColumn.push_back("res_para_int5"); - vecFwAoColumn.push_back("res_para_int6"); - vecFwAoColumn.push_back("res_para_int7"); - vecFwAoColumn.push_back("res_para_str64"); - vecFwAoColumn.push_back("src_type"); - - ret = RdbFwAoTable.open(m_strAppLabel.c_str(),RT_FES_FW_AO_TBL); - if(ret==false) - { - LOGERROR("RdbFwAoTable::Open error"); - return; - } - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwAoTable.selectOneOrder(con, VecFwAoParam, vecFwAoColumn, "remote_no");//默认顺序 - if (ret==false) - { - LOGERROR("RdbFwAoTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwAoPoints = 0; - count = VecFwAoParam.size(); - if(count>0) - { - RtuPtr->m_MaxFwAoPoints = VecFwAoParam[count-1].RemoteNo +1; - RtuPtr->m_FwAoPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwAo = (SFesFwAo*)malloc(RtuPtr->m_MaxFwAoPoints*sizeof(SFesFwAo)); - if(RtuPtr->m_pFwAo!=NULL) - { - memset(RtuPtr->m_pFwAo,0,RtuPtr->m_MaxFwAoPoints*sizeof(SFesFwAo)); - for(j=0;jm_MaxFwAoPoints) - { - pFwAo = RtuPtr->m_pFwAo + VecFwAoParam[j].RemoteNo; - pFwAo->RemoteNo = VecFwAoParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwAo->TagName, VecFwAoParam[j].TagName); //采集标签名 - strcpy(pFwAo->PointDesc, VecFwAoParam[j].PointDesc); //点描述 - pFwAo->FesRtuNo = VecFwAoParam[j].FesRtuNo; //采集rtu号 - pFwAo->FesPointNo = VecFwAoParam[j].FesPointNo; //采集点号 - pFwAo->MaxRange = (float)VecFwAoParam[j].MaxRange; //系数 - pFwAo->MinRange = (float)VecFwAoParam[j].MinRange; //修正值 - pFwAo->Coeff = (float)VecFwAoParam[j].Coeff; //系数 - pFwAo->Base = (float)VecFwAoParam[j].Base; //修正值 - pFwAo->Property = VecFwAoParam[j].Property; //属性 - pFwAo->SrcLocationID = VecFwAoParam[j].SrcLocationID; //所属厂站 - pFwAo->SrcSubSystem = VecFwAoParam[j].SrcSubSystem; //所属专业 - pFwAo->ResParam1 = VecFwAoParam[j].ResParam1; //备用参数1 - pFwAo->ResParam2 = VecFwAoParam[j].ResParam2; //备用参数1 - pFwAo->ResParam3 = VecFwAoParam[j].ResParam3; //备用参数1 - pFwAo->ResParam4 = VecFwAoParam[j].ResParam4; //备用参数1 - pFwAo->ResParam5 = VecFwAoParam[j].ResParam5; //备用参数1 - pFwAo->ResParam6 = VecFwAoParam[j].ResParam6; //备用参数1 - pFwAo->ResParam7 = VecFwAoParam[j].ResParam7; //备用参数1 - strcpy(pFwAo->StrParam, VecFwAoParam[j].StrParam); - pFwAo->SrcType = VecFwAoParam[j].SrcType; //备用参数1 - - pFwAo->Used=1; //点有效标志 - } - else - { - LOGERROR("RtuNo:%d FwAo RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAoParam[j].RemoteNo,RtuPtr->m_MaxFwAoPoints); - } - } - } - else - { - RtuPtr->m_MaxFwAoPoints = 0; - LOGERROR("RtuNo:%d pFwAo create failed.\n",RtuPtr->m_Param.RtuNo); - } - } - - ret = RdbFwAoTable.close(); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbFwAoTable::close error"); - return; - } -} - -/** - * @brief CFesBase::GetRdbFwDoTable - * 获取Do转发表参数 - * @return 无 - */ -void CFesForwarding::GetRdbFwDoTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - int j; - SFesFwDo *pFwDo; - bool ret; - int count; - - iot_dbms::CRdbAccessEx RdbFwDoTable; - std::vector VecFwDoParam; - std::vector vecFwDoColumn; - - vecFwDoColumn.push_back("remote_no"); - vecFwDoColumn.push_back("tag_name"); - vecFwDoColumn.push_back("description"); - vecFwDoColumn.push_back("fes_rtu_no"); - vecFwDoColumn.push_back("offset_num"); - vecFwDoColumn.push_back("fes_dot_no1"); - vecFwDoColumn.push_back("fes_dot_no2"); - vecFwDoColumn.push_back("fes_dot_no3"); - vecFwDoColumn.push_back("fes_dot_no4"); - vecFwDoColumn.push_back("fes_dot_no5"); - vecFwDoColumn.push_back("property"); - vecFwDoColumn.push_back("src_location_id"); - vecFwDoColumn.push_back("src_sub_system"); - vecFwDoColumn.push_back("res_para_int1"); - vecFwDoColumn.push_back("res_para_int2"); - vecFwDoColumn.push_back("res_para_int3"); - vecFwDoColumn.push_back("res_para_int4"); - vecFwDoColumn.push_back("res_para_int5"); - vecFwDoColumn.push_back("res_para_int6"); - vecFwDoColumn.push_back("res_para_int7"); - vecFwDoColumn.push_back("res_para_str64"); - vecFwDoColumn.push_back("src_type"); - - ret = RdbFwDoTable.open(m_strAppLabel.c_str(),RT_FES_FW_DO_TBL); - if(ret==false) - { - LOGERROR("CFesBase::InitBaseData,RdbFwDoTable::Open error"); - return; - } - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwDoTable.selectOneOrder(con, VecFwDoParam, vecFwDoColumn, "remote_no");//默认顺序 - if (ret==false) - { - LOGERROR("RdbFwDoTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwDoPoints = 0; - count = VecFwDoParam.size(); - if(count>0) - { - RtuPtr->m_MaxFwDoPoints = VecFwDoParam[count-1].RemoteNo +1; - RtuPtr->m_FwDoPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwDo = (SFesFwDo*)malloc(RtuPtr->m_MaxFwDoPoints*sizeof(SFesFwDo)); - if(RtuPtr->m_pFwDo!=NULL) - { - memset(RtuPtr->m_pFwDo,0,RtuPtr->m_MaxFwDoPoints*sizeof(SFesFwDo)); - for(j=0;jm_MaxFwDoPoints) - { - pFwDo = RtuPtr->m_pFwDo + VecFwDoParam[j].RemoteNo; - pFwDo->RemoteNo = VecFwDoParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwDo->TagName, VecFwDoParam[j].TagName); //采集标签名 - strcpy(pFwDo->PointDesc, VecFwDoParam[j].PointDesc); //点描述 - pFwDo->FesRtuNo = VecFwDoParam[j].FesRtuNo; //采集rtu号 - pFwDo->FesPointNum = VecFwDoParam[j].FesPointNum; //分量数 - if (pFwDo->FesPointNum >= CN_FesFwDoPointNum) - pFwDo->FesPointNum = CN_FesFwDoPointNum; - pFwDo->FesPointNo[0] = VecFwDoParam[j].FesPointNo1; //采集点号 - pFwDo->FesPointNo[1] = VecFwDoParam[j].FesPointNo2; //采集点号 - pFwDo->FesPointNo[2] = VecFwDoParam[j].FesPointNo3; //采集点号 - pFwDo->FesPointNo[3] = VecFwDoParam[j].FesPointNo4; //采集点号 - pFwDo->FesPointNo[4] = VecFwDoParam[j].FesPointNo5; //采集点号 - pFwDo->Property = VecFwDoParam[j].Property; //属性 - pFwDo->SrcLocationID = VecFwDoParam[j].SrcLocationID; //所属厂站 - pFwDo->SrcSubSystem = VecFwDoParam[j].SrcSubSystem; //所属专业 - pFwDo->ResParam1 = VecFwDoParam[j].ResParam1; //备用参数1 - pFwDo->ResParam2 = VecFwDoParam[j].ResParam2; //备用参数1 - pFwDo->ResParam3 = VecFwDoParam[j].ResParam3; //备用参数1 - pFwDo->ResParam4 = VecFwDoParam[j].ResParam4; //备用参数1 - pFwDo->ResParam5 = VecFwDoParam[j].ResParam5; //备用参数1 - pFwDo->ResParam6 = VecFwDoParam[j].ResParam6; //备用参数1 - pFwDo->ResParam7 = VecFwDoParam[j].ResParam7; //备用参数1 - strcpy(pFwDo->StrParam, VecFwDoParam[j].StrParam); - pFwDo->SrcType = VecFwDoParam[j].SrcType; //备用参数1 - pFwDo->DIRemoteNo = -1; - pFwDo->WfBlockedTimeout=0; //五防闭锁时间 - pFwDo->Used=1; //点有效标志 - } - else - { - LOGERROR("RtuNo:%d FwAi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwDoParam[j].RemoteNo,RtuPtr->m_MaxFwDoPoints); - } - } - } - else - { - RtuPtr->m_MaxFwDoPoints = 0; - LOGERROR("RtuNo:%d pFwDo create failed.\n",RtuPtr->m_Param.RtuNo); - } - } - - ret = RdbFwDoTable.close(); - if(ret==false) - { - LOGERROR("RdbFwDoTable::close error"); - return; - } -} - - -/** -* @brief CFesBase::GetRdbFwMoTable -* 获取Mo转发表参数 -* @return 无 -*/ -void CFesForwarding::GetRdbFwMoTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) -{ - int j; - SFesFwMo *pFwMo; - bool ret; - int count; - //int RtuNum; - - iot_dbms::CRdbAccessEx RdbFwMoTable; - std::vector VecFwMoParam; - std::vector vecFwMoColumn; - - vecFwMoColumn.push_back("remote_no"); - vecFwMoColumn.push_back("tag_name"); - vecFwMoColumn.push_back("description"); - vecFwMoColumn.push_back("fes_rtu_no"); - vecFwMoColumn.push_back("fes_dot_no"); - vecFwMoColumn.push_back("max_range"); - vecFwMoColumn.push_back("min_range"); - vecFwMoColumn.push_back("property"); - vecFwMoColumn.push_back("src_location_id"); - vecFwMoColumn.push_back("src_sub_system"); - vecFwMoColumn.push_back("res_para_int1"); - vecFwMoColumn.push_back("res_para_int2"); - vecFwMoColumn.push_back("res_para_int3"); - vecFwMoColumn.push_back("res_para_int4"); - vecFwMoColumn.push_back("res_para_int5"); - vecFwMoColumn.push_back("res_para_int6"); - vecFwMoColumn.push_back("res_para_int7"); - vecFwMoColumn.push_back("res_para_str64"); - vecFwMoColumn.push_back("src_type"); - - ret = RdbFwMoTable.open(m_strAppLabel.c_str(), RT_FES_FW_MO_TBL); - if (ret == false) - { - LOGERROR("RdbFwMoTable::Open error"); - return; - } - CONDINFO con; - con.relationop = ATTRCOND_EQU; - std::string RtuTagname = RtuPtr->m_Param.TagName; - con.conditionval = CVarType(RtuTagname); - strcpy(con.name, "rtu_tag"); - ret = RdbFwMoTable.selectOneOrder(con, VecFwMoParam, vecFwMoColumn, "remote_no");//默认顺序 - if (ret == false) - { - LOGERROR("RdbFwMoTable.selectNoCondition error!"); - return; - } - RtuPtr->m_MaxFwMoPoints = 0; - count = VecFwMoParam.size(); - if (count>0) - { - RtuPtr->m_MaxFwMoPoints = VecFwMoParam[count - 1].RemoteNo + 1; - RtuPtr->m_FwMoPointsNum = count; - //动态分配数据空间 - RtuPtr->m_pFwMo = (SFesFwMo*)malloc(RtuPtr->m_MaxFwMoPoints * sizeof(SFesFwMo)); - if (RtuPtr->m_pFwMo != NULL) - { - memset(RtuPtr->m_pFwMo, 0, RtuPtr->m_MaxFwMoPoints * sizeof(SFesFwMo)); - for (j = 0; jm_MaxFwMoPoints) - { - pFwMo = RtuPtr->m_pFwMo + VecFwMoParam[j].RemoteNo; - pFwMo->RemoteNo = VecFwMoParam[j].RemoteNo; //点ID 从0开始递增 - strcpy(pFwMo->TagName, VecFwMoParam[j].TagName); //采集标签名 - strcpy(pFwMo->PointDesc, VecFwMoParam[j].PointDesc); //点描述 - pFwMo->FesRtuNo = VecFwMoParam[j].FesRtuNo; //采集rtu号 - pFwMo->FesPointNo = VecFwMoParam[j].FesPointNo; //采集点号 - pFwMo->MaxRange = VecFwMoParam[j].MaxRange; - pFwMo->MinRange = VecFwMoParam[j].MinRange; - pFwMo->Property = VecFwMoParam[j].Property; //属性 - pFwMo->SrcLocationID = VecFwMoParam[j].SrcLocationID; //所属厂站 - pFwMo->SrcSubSystem = VecFwMoParam[j].SrcSubSystem; //所属专业 - pFwMo->ResParam1 = VecFwMoParam[j].ResParam1; //备用参数1 - pFwMo->ResParam2 = VecFwMoParam[j].ResParam2; //备用参数1 - pFwMo->ResParam3 = VecFwMoParam[j].ResParam3; //备用参数1 - pFwMo->ResParam4 = VecFwMoParam[j].ResParam4; //备用参数1 - pFwMo->ResParam5 = VecFwMoParam[j].ResParam5; //备用参数1 - pFwMo->ResParam6 = VecFwMoParam[j].ResParam6; //备用参数1 - pFwMo->ResParam7 = VecFwMoParam[j].ResParam7; //备用参数1 - strcpy(pFwMo->StrParam, VecFwMoParam[j].StrParam); - pFwMo->SrcType = VecFwMoParam[j].SrcType; //备用参数1 - - pFwMo->Used = 1; //点有效标志 - //RtuNum = 0; - } - else - { - LOGERROR("RtuNo:%d FwMo RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwMoParam[j].RemoteNo, RtuPtr->m_MaxFwMoPoints); - } - } - } - else - { - RtuPtr->m_MaxFwMoPoints = 0; - LOGERROR("RtuNo:%d pFwMo create failed.\n", RtuPtr->m_Param.RtuNo); - } - } - - ret = RdbFwMoTable.close(); - if (ret == false) - { - LOGERROR("RdbFwMoTable::close error"); - return; - } -} - - -void CFesForwarding::InitFesConllectRtu(CFesRtuPtr RtuPtr,std::string m_strAppLabel) -{ - GetRdbFwAiTable(RtuPtr,m_strAppLabel); //获取Ai转发表参数 - GetRdbFwSDiTable(RtuPtr, m_strAppLabel); //获取SDi转发表参数 - GetRdbFwDDiTable(RtuPtr, m_strAppLabel); //获取DDi转发表参数 - GetRdbFwAccTable(RtuPtr, m_strAppLabel); //获取Acc转发表参数 - GetRdbFwMiTable(RtuPtr, m_strAppLabel); //获取Mi转发表参数 - GetRdbFwAoTable(RtuPtr, m_strAppLabel); //获取Ao转发表参数 - GetRdbFwDoTable(RtuPtr, m_strAppLabel); //获取Do转发表参数 - GetRdbFwMoTable(RtuPtr, m_strAppLabel); //获取Mo转发表参数 -} - - +/* +@file FesForwardConfig.cpp +@brief 转发配置基础类 +@author JACKYWU +@history +2019-06-14 thxiao CRdbAccessEx selectOneOrder()默认方式由倒序变为顺序，所有有关实时库的读取方式全变了，使用默认方式。 +2022-01-17 thxiao GetRdbFwDDiTable() 判断空有误，当配置没有单点遥信，只有双点时，双点配置无法正常，点值也无法正常显示。 + +*/ +#include "FesForwardConfig.h" +#include "rdb_api/CRdbAccessEx.h" +#include "rdb_api/CRdbAccess.h" + +using namespace iot_dbms; + +CFesForwarding::CFesForwarding() +{ + +} + +CFesForwarding::~CFesForwarding() +{ + +} + +/** + * @brief CFesBase::GetRdbFwAiTable + * 获取Ai转发表参数 + * @return 无 + */ +void CFesForwarding::GetRdbFwAiTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + int j; + SFesFwAi *pFwAi; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwAiTable; + std::vector VecFwAiParam; + std::vector vecFwAiColumn; + + vecFwAiColumn.push_back("remote_no"); + vecFwAiColumn.push_back("tag_name"); + vecFwAiColumn.push_back("description"); + vecFwAiColumn.push_back("dp_tag_name"); + vecFwAiColumn.push_back("fes_rtu_no"); + vecFwAiColumn.push_back("fes_dot_no"); + vecFwAiColumn.push_back("dp_seq_no"); + vecFwAiColumn.push_back("coeff"); + vecFwAiColumn.push_back("base"); + vecFwAiColumn.push_back("deadband_type"); + vecFwAiColumn.push_back("deadband"); + vecFwAiColumn.push_back("property"); + vecFwAiColumn.push_back("src_location_id"); + vecFwAiColumn.push_back("src_sub_system"); + vecFwAiColumn.push_back("res_para_int1"); + vecFwAiColumn.push_back("res_para_int2"); + vecFwAiColumn.push_back("res_para_int3"); + vecFwAiColumn.push_back("res_para_int4"); + vecFwAiColumn.push_back("res_para_int5"); + vecFwAiColumn.push_back("res_para_int6"); + vecFwAiColumn.push_back("res_para_int7"); + vecFwAiColumn.push_back("res_para_str1"); + vecFwAiColumn.push_back("src_type"); + + ret = RdbFwAiTable.open(m_strAppLabel.c_str(),RT_FES_FW_AI_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbFwAiTable::Open error"); + return; + } + + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname= RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name,"rtu_tag"); + + ret = RdbFwAiTable.selectOneOrder(con, VecFwAiParam, vecFwAiColumn, "remote_no");//默认顺序 + if (ret==false) + { + LOGERROR("CFesBase::InitBaseData, RdbFwAiTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwAiPoints = 0; + count = static_cast(VecFwAiParam.size()); +// LOGINFO("RTU%d VecFwAiParam.size():%d",RtuPtr->m_Param.RtuNo,count); + if(count>0) + { + RtuPtr->m_MaxFwAiPoints = VecFwAiParam[count-1].RemoteNo +1; + RtuPtr->m_FwAiPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwAi = (SFesFwAi*)malloc(RtuPtr->m_MaxFwAiPoints*sizeof(SFesFwAi)); + if(RtuPtr->m_pFwAi!=NULL) + { + memset(RtuPtr->m_pFwAi,0,RtuPtr->m_MaxFwAiPoints*sizeof(SFesFwAi)); + for(j=0;jm_MaxFwAiPoints) + { + pFwAi = RtuPtr->m_pFwAi+ VecFwAiParam[j].RemoteNo; + pFwAi->RemoteNo = VecFwAiParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwAi->TagName,VecFwAiParam[j].TagName); //点标签名 + strcpy(pFwAi->PointDesc, VecFwAiParam[j].PointDesc); //点描述 + strcpy(pFwAi->DPTagName, VecFwAiParam[j].DPTagName); //后台标签名 + pFwAi->FesRtuNo = VecFwAiParam[j].FesRtuNo; //采集rtu号 + pFwAi->FesPointNo = VecFwAiParam[j].FesPointNo; //采集点号 + pFwAi->DpSeqNo = VecFwAiParam[j].DpSeqNo; //远动序号 + pFwAi->Coeff = VecFwAiParam[j].Coeff; //系数 + pFwAi->Base = VecFwAiParam[j].Base; //修正值 + pFwAi->DeadBandType = VecFwAiParam[j].DeadBandType; + pFwAi->DeadBand = VecFwAiParam[j].DeadBand; //死区值 + pFwAi->Property = VecFwAiParam[j].Property; //属性 + pFwAi->SrcLocationID = VecFwAiParam[j].SrcLocationID; //所属厂站 + pFwAi->SrcSubSystem = VecFwAiParam[j].SrcSubSystem; //所属专业 + pFwAi->ResParam1 = VecFwAiParam[j].ResParam1; //备用参数1 + pFwAi->ResParam2 = VecFwAiParam[j].ResParam2; //备用参数1 + pFwAi->ResParam3 = VecFwAiParam[j].ResParam3; //备用参数1 + pFwAi->ResParam4 = VecFwAiParam[j].ResParam4; //备用参数1 + pFwAi->ResParam5 = VecFwAiParam[j].ResParam5; //备用参数1 + pFwAi->ResParam6 = VecFwAiParam[j].ResParam6; //备用参数1 + pFwAi->ResParam7 = VecFwAiParam[j].ResParam7; //备用参数1 + strcpy(pFwAi->szResParam1, VecFwAiParam[j].szResParam1); + pFwAi->SrcType = VecFwAiParam[j].SrcType; //备用参数1 + pFwAi->Used=1; //点有效标志 + //LOGDEBUG("@@@@@@@@@@@@ RtuNo:%d TagName:%s DPTagName:%s Desc:%s SrcType:%d", RtuPtr->m_Param.RtuNo, pFwAi->TagName, pFwAi->DPTagName, pFwAi->PointDesc, pFwAi->SrcType) + + // 根据死区类型计算实际的死区值，避免运行时每次都判断死区类型 + UpdateDeadBandValue(pFwAi); + } + else + { + LOGERROR("RtuNo:%d FwAi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAiParam[j].RemoteNo,RtuPtr->m_MaxFwAiPoints); + } + } + } + else + { + RtuPtr->m_MaxFwAiPoints = 0; + LOGERROR("RtuNo:%d pFwAi create failed.\n",RtuPtr->m_Param.RtuNo); + } + } + RtuPtr->FwAiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwAiPoints; + + ret = RdbFwAiTable.close(); + if(ret==false) + { + LOGERROR("RdbFwAiTable::close error"); + return; + } +} + +/** + * @brief CFesBase::GetRdbFwSDiTable + * 获取Di转发表参数 + * @return 无 + */ +void CFesForwarding::GetRdbFwSDiTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + int j; + SFesFwDi *pFwDi; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwDiTable; + std::vector VecFwDiParam; + std::vector vecFwDiColumn; + + vecFwDiColumn.push_back("remote_no"); + vecFwDiColumn.push_back("tag_name"); + vecFwDiColumn.push_back("description"); + vecFwDiColumn.push_back("dp_tag_name"); + vecFwDiColumn.push_back("fes_rtu_no"); + vecFwDiColumn.push_back("fes_dot_no"); + vecFwDiColumn.push_back("dp_seq_no"); + vecFwDiColumn.push_back("property"); + vecFwDiColumn.push_back("src_location_id"); + vecFwDiColumn.push_back("src_sub_system"); + vecFwDiColumn.push_back("res_para_int1"); + vecFwDiColumn.push_back("res_para_int2"); + vecFwDiColumn.push_back("res_para_int3"); + vecFwDiColumn.push_back("res_para_int4"); + vecFwDiColumn.push_back("res_para_int5"); + vecFwDiColumn.push_back("res_para_int6"); + vecFwDiColumn.push_back("res_para_int7"); + vecFwDiColumn.push_back("res_para_str1"); + vecFwDiColumn.push_back("src_type"); + ret = RdbFwDiTable.open(m_strAppLabel.c_str(), RT_FES_FW_SDI_TBL); + if(ret==false) + { + LOGERROR("RdbFwDiTable::Open error"); + return; + } + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwDiTable.selectOneOrder(con, VecFwDiParam, vecFwDiColumn, "remote_no");//默认顺序 + if (ret==false) + { + LOGERROR("RdbFwDiTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwDiPoints = 0; + count = static_cast(VecFwDiParam.size()); + //LOGDEBUG("RTU%d VecFwDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); + if(count>0) + { + RtuPtr->m_MaxFwDiPoints = VecFwDiParam[count-1].RemoteNo +1; + RtuPtr->m_FwDiPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwDi = (SFesFwDi*)malloc(RtuPtr->m_MaxFwDiPoints*sizeof(SFesFwDi)); + if(RtuPtr->m_pFwDi!=NULL) + { + memset(RtuPtr->m_pFwDi,0,RtuPtr->m_MaxFwDiPoints*sizeof(SFesFwDi)); + for(j=0;jm_MaxFwDiPoints) + { + pFwDi = RtuPtr->m_pFwDi + VecFwDiParam[j].RemoteNo; + pFwDi->RemoteNo = VecFwDiParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwDi->TagName, VecFwDiParam[j].TagName); //点标签名 + strcpy(pFwDi->PointDesc, VecFwDiParam[j].PointDesc); //点描述 + strcpy(pFwDi->DPTagName, VecFwDiParam[j].DPTagName); //后台标签名 + pFwDi->FesRtuNo = VecFwDiParam[j].FesRtuNo; //采集rtu号 + pFwDi->FesPointNo = VecFwDiParam[j].FesPointNo; //采集点号 + pFwDi->DpSeqNo = VecFwDiParam[j].DpSeqNo; //远动序号 + pFwDi->Property = VecFwDiParam[j].Property; //属性 + pFwDi->SrcLocationID = VecFwDiParam[j].SrcLocationID; //所属厂站 + pFwDi->SrcSubSystem = VecFwDiParam[j].SrcSubSystem; //所属专业 + pFwDi->ResParam1 = VecFwDiParam[j].ResParam1; //备用参数1 + pFwDi->ResParam2 = VecFwDiParam[j].ResParam2; //备用参数1 + pFwDi->ResParam3 = VecFwDiParam[j].ResParam3; //备用参数1 + pFwDi->ResParam4 = VecFwDiParam[j].ResParam4; //备用参数1 + pFwDi->ResParam5 = VecFwDiParam[j].ResParam5; //备用参数1 + pFwDi->ResParam6 = VecFwDiParam[j].ResParam6; //备用参数1 + pFwDi->ResParam7 = VecFwDiParam[j].ResParam7; //备用参数1 + strcpy(pFwDi->szResParam1, VecFwDiParam[j].szResParam1); + pFwDi->SrcType = VecFwDiParam[j].SrcType; //备用参数1 + pFwDi->DORemoteNo = -1; + pFwDi->Used = 1; //点有效标志 + } + else + { + LOGERROR("RtuNo:%d FwDi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwDiParam[j].RemoteNo,RtuPtr->m_MaxFwDiPoints); + } + } + } + else + { + RtuPtr->m_MaxFwDiPoints = 0; + LOGERROR("RtuNo:%d pFwDi create failed.\n",RtuPtr->m_Param.RtuNo); + } + + RtuPtr->FwDiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwDiPoints; + } + + ret = RdbFwDiTable.close(); + if(ret==false) + { + LOGERROR("RdbFwDiTable::close error"); + return; + } +} + + +/** +* @brief CFesBase::GetRdbFwDDiTable +* 获取Di转发表参数 +* @return 无 +*/ +void CFesForwarding::GetRdbFwDDiTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) +{ + int j; + SFesFwDi *pFwDi; + bool ret; + int count; + //int RtuNum; + + iot_dbms::CRdbAccessEx RdbFwDiTable; + std::vector VecFwDiParam; + std::vector vecFwDiColumn; + + vecFwDiColumn.push_back("remote_no"); + vecFwDiColumn.push_back("tag_name"); + vecFwDiColumn.push_back("description"); + vecFwDiColumn.push_back("dp_tag_name"); + vecFwDiColumn.push_back("fes_rtu_no"); + vecFwDiColumn.push_back("fes_dot_no"); + vecFwDiColumn.push_back("dp_seq_no"); + vecFwDiColumn.push_back("property"); + vecFwDiColumn.push_back("src_location_id"); + vecFwDiColumn.push_back("src_sub_system"); + vecFwDiColumn.push_back("res_para_int1"); + vecFwDiColumn.push_back("res_para_int2"); + vecFwDiColumn.push_back("res_para_int3"); + vecFwDiColumn.push_back("res_para_int4"); + vecFwDiColumn.push_back("res_para_int5"); + vecFwDiColumn.push_back("res_para_int6"); + vecFwDiColumn.push_back("res_para_int7"); + vecFwDiColumn.push_back("res_para_str1"); + vecFwDiColumn.push_back("src_type"); + ret = RdbFwDiTable.open(m_strAppLabel.c_str(), RT_FES_FW_DDI_TBL); + if (ret == false) + { + LOGERROR("CFesBase::InitBaseData,RdbFwDiTable::Open error"); + return; + } + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwDiTable.selectOneOrder(con, VecFwDiParam, vecFwDiColumn, "remote_no");//默认顺序 + if (ret == false) + { + LOGERROR("RdbFwDiTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwDDiPoints = 0; + count = static_cast(VecFwDiParam.size()); + //LOGDEBUG("RTU%d VecFwDiParam.size():%d",RtuPtr->m_Param.RtuNo,count); + if (count>0) + { + RtuPtr->m_MaxFwDDiPoints = VecFwDiParam[count - 1].RemoteNo + 1; + RtuPtr->m_FwDDiPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwDDi = (SFesFwDi*)malloc(RtuPtr->m_MaxFwDDiPoints * sizeof(SFesFwDi)); + if (RtuPtr->m_pFwDDi != NULL)//2022-01-17 thxiao + { + memset(RtuPtr->m_pFwDDi, 0, RtuPtr->m_MaxFwDDiPoints * sizeof(SFesFwDi)); + for (j = 0; jm_MaxFwDiPoints) + { + pFwDi = RtuPtr->m_pFwDDi + VecFwDiParam[j].RemoteNo; + pFwDi->RemoteNo = VecFwDiParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwDi->TagName, VecFwDiParam[j].TagName); //点标签名 + strcpy(pFwDi->PointDesc, VecFwDiParam[j].PointDesc); //点描述 + strcpy(pFwDi->DPTagName, VecFwDiParam[j].DPTagName); //后台标签名 + pFwDi->FesRtuNo = VecFwDiParam[j].FesRtuNo; //采集rtu号 + pFwDi->FesPointNo = VecFwDiParam[j].FesPointNo; //采集点号 + pFwDi->DpSeqNo = VecFwDiParam[j].DpSeqNo; //远动序号 + pFwDi->Property = VecFwDiParam[j].Property; //属性 + pFwDi->SrcLocationID = VecFwDiParam[j].SrcLocationID; //所属厂站 + pFwDi->SrcSubSystem = VecFwDiParam[j].SrcSubSystem; //所属专业 + pFwDi->ResParam1 = VecFwDiParam[j].ResParam1; //备用参数1 + pFwDi->ResParam2 = VecFwDiParam[j].ResParam2; //备用参数1 + pFwDi->ResParam3 = VecFwDiParam[j].ResParam3; //备用参数1 + pFwDi->ResParam4 = VecFwDiParam[j].ResParam4; //备用参数1 + pFwDi->ResParam5 = VecFwDiParam[j].ResParam5; //备用参数1 + pFwDi->ResParam6 = VecFwDiParam[j].ResParam6; //备用参数1 + pFwDi->ResParam7 = VecFwDiParam[j].ResParam7; //备用参数1 + strcpy(pFwDi->szResParam1, VecFwDiParam[j].szResParam1); + pFwDi->SrcType = VecFwDiParam[j].SrcType; //备用参数1 + pFwDi->Used = 1; //点有效标志 + // RtuNum = 0; + } + else + { + LOGERROR("RtuNo:%d FwDi RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwDiParam[j].RemoteNo, RtuPtr->m_MaxFwDiPoints); + } + } + } + else + { + RtuPtr->m_MaxFwDDiPoints = 0; + LOGERROR("RtuNo:%d pFwDi create failed.\n", RtuPtr->m_Param.RtuNo); + } + + RtuPtr->FwDDiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwDDiPoints; + } + + ret = RdbFwDiTable.close(); + if (ret == false) + { + LOGERROR("RdbFwDiTable::close error"); + return; + } +} + +/** + * @brief CFesBase::GetRdbFwAccTable + * 获取Acc转发表参数 + * @return 无 + */ +void CFesForwarding::GetRdbFwAccTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + + int j; + SFesFwAcc *pFwAcc; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwAccTable; + std::vector VecFwAccParam; + std::vector vecFwAccColumn; + + vecFwAccColumn.push_back("remote_no"); + vecFwAccColumn.push_back("tag_name"); + vecFwAccColumn.push_back("description"); + vecFwAccColumn.push_back("dp_tag_name"); + vecFwAccColumn.push_back("fes_rtu_no"); + vecFwAccColumn.push_back("fes_dot_no"); + vecFwAccColumn.push_back("dp_seq_no"); + vecFwAccColumn.push_back("coeff"); + vecFwAccColumn.push_back("base"); + vecFwAccColumn.push_back("property"); + vecFwAccColumn.push_back("src_location_id"); + vecFwAccColumn.push_back("src_sub_system"); + vecFwAccColumn.push_back("res_para_int1"); + vecFwAccColumn.push_back("res_para_int2"); + vecFwAccColumn.push_back("res_para_int3"); + vecFwAccColumn.push_back("res_para_int4"); + vecFwAccColumn.push_back("res_para_int5"); + vecFwAccColumn.push_back("res_para_int6"); + vecFwAccColumn.push_back("res_para_int7"); + vecFwAccColumn.push_back("res_para_str1"); + vecFwAccColumn.push_back("src_type"); + + ret = RdbFwAccTable.open(m_strAppLabel.c_str(),RT_FES_FW_ACC_TBL); + if(ret==false) + { + LOGERROR("RdbFwAccTable::Open error"); + return; + } + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + + ret = RdbFwAccTable.selectOneOrder(con, VecFwAccParam, vecFwAccColumn, "remote_no");//默认顺序 + if (ret==false) + { + LOGERROR("RdbFwAccTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwAccPoints = 0; + count = static_cast(VecFwAccParam.size()); + if(count>0) + { + RtuPtr->m_MaxFwAccPoints = VecFwAccParam[count-1].RemoteNo +1; + RtuPtr->m_FwAccPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwAcc = (SFesFwAcc*)malloc(RtuPtr->m_MaxFwAccPoints*sizeof(SFesFwAcc)); + if(RtuPtr->m_pFwAcc!=NULL) + { + memset(RtuPtr->m_pFwAcc,0,RtuPtr->m_MaxFwAccPoints*sizeof(SFesFwAcc)); + + for(j=0;jm_MaxFwAccPoints) + { + pFwAcc = RtuPtr->m_pFwAcc + VecFwAccParam[j].RemoteNo; + pFwAcc->RemoteNo = VecFwAccParam[j].RemoteNo; + strcpy(pFwAcc->TagName, VecFwAccParam[j].TagName); //标签名 + strcpy(pFwAcc->PointDesc, VecFwAccParam[j].PointDesc); //点描述 + strcpy(pFwAcc->DPTagName, VecFwAccParam[j].DPTagName); //后台标签名 + pFwAcc->FesRtuNo = VecFwAccParam[j].FesRtuNo; //采集rtu号 + pFwAcc->FesPointNo = VecFwAccParam[j].FesPointNo; //采集点号 + pFwAcc->DpSeqNo = VecFwAccParam[j].DpSeqNo; //远动序号 + pFwAcc->Coeff = (float)VecFwAccParam[j].Coeff; //系数 + pFwAcc->Base = (float)VecFwAccParam[j].Base; //修正值 + pFwAcc->Property = VecFwAccParam[j].Property; //属性 + pFwAcc->SrcLocationID = VecFwAccParam[j].SrcLocationID; //所属厂站 + pFwAcc->SrcSubSystem = VecFwAccParam[j].SrcSubSystem; //所属专业 + pFwAcc->ResParam1 = VecFwAccParam[j].ResParam1; //备用参数1 + pFwAcc->ResParam2 = VecFwAccParam[j].ResParam2; //备用参数1 + pFwAcc->ResParam3 = VecFwAccParam[j].ResParam3; //备用参数1 + pFwAcc->ResParam4 = VecFwAccParam[j].ResParam4; //备用参数1 + pFwAcc->ResParam5 = VecFwAccParam[j].ResParam5; //备用参数1 + pFwAcc->ResParam6 = VecFwAccParam[j].ResParam6; //备用参数1 + pFwAcc->ResParam7 = VecFwAccParam[j].ResParam7; //备用参数1 + strcpy(pFwAcc->szResParam1, VecFwAccParam[j].szResParam1); + pFwAcc->SrcType = VecFwAccParam[j].SrcType; //备用参数1 + pFwAcc->Used = 1; //点有效标志 + } + else + { + LOGERROR("RtuNo:%d FwAcc RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAccParam[j].RemoteNo,RtuPtr->m_MaxFwAccPoints); + } + } + } + else + { + RtuPtr->m_MaxFwAccPoints = 0; + LOGERROR("RtuNo:%d pFwAcc create failed.\n",RtuPtr->m_Param.RtuNo); + } + RtuPtr->FwAccMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwAccPoints; + + } + ret = RdbFwAccTable.close(); + if(ret==false) + { + LOGERROR("RdbFwAccTable::close error"); + return; + } +} + +/** +* @brief CFesBase::GetRdbFwMiTable +* 获取Mi转发表参数 +* @return 无 +*/ +void CFesForwarding::GetRdbFwMiTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) +{ + int j; + SFesFwMi *pFwMi; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwMiTable; + std::vector VecFwMiParam; + std::vector vecFwMiColumn; + + vecFwMiColumn.push_back("remote_no"); + vecFwMiColumn.push_back("tag_name"); + vecFwMiColumn.push_back("description"); + vecFwMiColumn.push_back("dp_tag_name"); + vecFwMiColumn.push_back("fes_rtu_no"); + vecFwMiColumn.push_back("fes_dot_no"); + vecFwMiColumn.push_back("dp_seq_no"); + vecFwMiColumn.push_back("coeff"); + vecFwMiColumn.push_back("base"); + vecFwMiColumn.push_back("property"); + vecFwMiColumn.push_back("src_location_id"); + vecFwMiColumn.push_back("src_sub_system"); + vecFwMiColumn.push_back("res_para_int1"); + vecFwMiColumn.push_back("res_para_int2"); + vecFwMiColumn.push_back("res_para_int3"); + vecFwMiColumn.push_back("res_para_int4"); + vecFwMiColumn.push_back("res_para_int5"); + vecFwMiColumn.push_back("res_para_int6"); + vecFwMiColumn.push_back("res_para_int7"); + vecFwMiColumn.push_back("res_para_str1"); + vecFwMiColumn.push_back("src_type"); + + ret = RdbFwMiTable.open(m_strAppLabel.c_str(), RT_FES_FW_MI_TBL); + if (ret == false) + { + LOGERROR("RdbFwMiTable::Open error"); + return; + } + //条件判断 + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwMiTable.selectOneOrder(con, VecFwMiParam, vecFwMiColumn, "remote_no");//默认顺序 + if (ret == false) + { + LOGERROR("RdbFwMiTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwMiPoints = 0; + count = static_cast(VecFwMiParam.size()); + if (count>0) + { + RtuPtr->m_MaxFwMiPoints = VecFwMiParam[count - 1].RemoteNo + 1; + RtuPtr->m_FwMiPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwMi = (SFesFwMi*)malloc(RtuPtr->m_MaxFwMiPoints * sizeof(SFesFwMi)); + if (RtuPtr->m_pFwMi != NULL) + { + memset(RtuPtr->m_pFwMi, 0, RtuPtr->m_MaxFwMiPoints * sizeof(SFesFwMi)); + + for (j = 0; jm_MaxFwMiPoints) + { + pFwMi = RtuPtr->m_pFwMi + VecFwMiParam[j].RemoteNo; + pFwMi->RemoteNo = VecFwMiParam[j].RemoteNo; + strcpy(pFwMi->TagName, VecFwMiParam[j].TagName); //标签名 + strcpy(pFwMi->PointDesc, VecFwMiParam[j].PointDesc); //点描述 + strcpy(pFwMi->DPTagName, VecFwMiParam[j].DPTagName); //后台标签名 + pFwMi->FesRtuNo = VecFwMiParam[j].FesRtuNo; //采集rtu号 + pFwMi->FesPointNo = VecFwMiParam[j].FesPointNo; //采集点号 + pFwMi->DpSeqNo = VecFwMiParam[j].DpSeqNo; //远动序号 + pFwMi->Coeff = (float)VecFwMiParam[j].Coeff; //系数 + pFwMi->Base = (float)VecFwMiParam[j].Base; //修正值 + pFwMi->Property = VecFwMiParam[j].Property; //属性 + pFwMi->SrcLocationID = VecFwMiParam[j].SrcLocationID; //所属厂站 + pFwMi->SrcSubSystem = VecFwMiParam[j].SrcSubSystem; //所属专业 + pFwMi->ResParam1 = VecFwMiParam[j].ResParam1; //备用参数1 + pFwMi->ResParam2 = VecFwMiParam[j].ResParam2; //备用参数1 + pFwMi->ResParam3 = VecFwMiParam[j].ResParam3; //备用参数1 + pFwMi->ResParam4 = VecFwMiParam[j].ResParam4; //备用参数1 + pFwMi->ResParam5 = VecFwMiParam[j].ResParam5; //备用参数1 + pFwMi->ResParam6 = VecFwMiParam[j].ResParam6; //备用参数1 + pFwMi->ResParam7 = VecFwMiParam[j].ResParam7; //备用参数1 + strcpy(pFwMi->szResParam1, VecFwMiParam[j].szResParam1); + pFwMi->SrcType = VecFwMiParam[j].SrcType; //备用参数1 + pFwMi->Used = 1; //点有效标志 + } + else + { + LOGERROR("RtuNo:%d FwMi RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwMiParam[j].RemoteNo, RtuPtr->m_MaxFwMiPoints); + } + } + } + else + { + RtuPtr->m_MaxFwMiPoints = 0; + LOGERROR("RtuNo:%d pFwMi create failed.\n", RtuPtr->m_Param.RtuNo); + } + RtuPtr->FwMiMaxChgNum = CN_FesMaxChangeMultiple*RtuPtr->m_MaxFwMiPoints; + + } + ret = RdbFwMiTable.close(); + if (ret == false) + { + LOGERROR("RdbFwMiTable::close error"); + return; + } +} + +/** + * @brief CFesBase::GetRdbFwAoTable + * 获取Ao转发表参数 + * @return 无 + */ +void CFesForwarding::GetRdbFwAoTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + int j; + SFesFwAo *pFwAo; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwAoTable; + std::vector VecFwAoParam; + std::vector vecFwAoColumn; + + vecFwAoColumn.push_back("remote_no"); + vecFwAoColumn.push_back("tag_name"); + vecFwAoColumn.push_back("description"); + vecFwAoColumn.push_back("fes_rtu_no"); + vecFwAoColumn.push_back("fes_dot_no"); + vecFwAoColumn.push_back("max_range"); + vecFwAoColumn.push_back("min_range"); + vecFwAoColumn.push_back("coeff"); + vecFwAoColumn.push_back("base"); + vecFwAoColumn.push_back("property"); + vecFwAoColumn.push_back("src_location_id"); + vecFwAoColumn.push_back("src_sub_system"); + vecFwAoColumn.push_back("res_para_int1"); + vecFwAoColumn.push_back("res_para_int2"); + vecFwAoColumn.push_back("res_para_int3"); + vecFwAoColumn.push_back("res_para_int4"); + vecFwAoColumn.push_back("res_para_int5"); + vecFwAoColumn.push_back("res_para_int6"); + vecFwAoColumn.push_back("res_para_int7"); + vecFwAoColumn.push_back("res_para_str1"); + vecFwAoColumn.push_back("src_type"); + + ret = RdbFwAoTable.open(m_strAppLabel.c_str(),RT_FES_FW_AO_TBL); + if(ret==false) + { + LOGERROR("RdbFwAoTable::Open error"); + return; + } + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwAoTable.selectOneOrder(con, VecFwAoParam, vecFwAoColumn, "remote_no");//默认顺序 + if (ret==false) + { + LOGERROR("RdbFwAoTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwAoPoints = 0; + count = static_cast(VecFwAoParam.size()); + if(count>0) + { + RtuPtr->m_MaxFwAoPoints = VecFwAoParam[count-1].RemoteNo +1; + RtuPtr->m_FwAoPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwAo = (SFesFwAo*)malloc(RtuPtr->m_MaxFwAoPoints*sizeof(SFesFwAo)); + if(RtuPtr->m_pFwAo!=NULL) + { + memset(RtuPtr->m_pFwAo,0,RtuPtr->m_MaxFwAoPoints*sizeof(SFesFwAo)); + for(j=0;jm_MaxFwAoPoints) + { + pFwAo = RtuPtr->m_pFwAo + VecFwAoParam[j].RemoteNo; + pFwAo->RemoteNo = VecFwAoParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwAo->TagName, VecFwAoParam[j].TagName); //采集标签名 + strcpy(pFwAo->PointDesc, VecFwAoParam[j].PointDesc); //点描述 + pFwAo->FesRtuNo = VecFwAoParam[j].FesRtuNo; //采集rtu号 + pFwAo->FesPointNo = VecFwAoParam[j].FesPointNo; //采集点号 + pFwAo->MaxRange = (float)VecFwAoParam[j].MaxRange; //系数 + pFwAo->MinRange = (float)VecFwAoParam[j].MinRange; //修正值 + pFwAo->Coeff = (float)VecFwAoParam[j].Coeff; //系数 + pFwAo->Base = (float)VecFwAoParam[j].Base; //修正值 + pFwAo->Property = VecFwAoParam[j].Property; //属性 + pFwAo->SrcLocationID = VecFwAoParam[j].SrcLocationID; //所属厂站 + pFwAo->SrcSubSystem = VecFwAoParam[j].SrcSubSystem; //所属专业 + pFwAo->ResParam1 = VecFwAoParam[j].ResParam1; //备用参数1 + pFwAo->ResParam2 = VecFwAoParam[j].ResParam2; //备用参数1 + pFwAo->ResParam3 = VecFwAoParam[j].ResParam3; //备用参数1 + pFwAo->ResParam4 = VecFwAoParam[j].ResParam4; //备用参数1 + pFwAo->ResParam5 = VecFwAoParam[j].ResParam5; //备用参数1 + pFwAo->ResParam6 = VecFwAoParam[j].ResParam6; //备用参数1 + pFwAo->ResParam7 = VecFwAoParam[j].ResParam7; //备用参数1 + strcpy(pFwAo->szResParam1, VecFwAoParam[j].szResParam1); + pFwAo->SrcType = VecFwAoParam[j].SrcType; //备用参数1 + + pFwAo->Used=1; //点有效标志 + } + else + { + LOGERROR("RtuNo:%d FwAo RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwAoParam[j].RemoteNo,RtuPtr->m_MaxFwAoPoints); + } + } + } + else + { + RtuPtr->m_MaxFwAoPoints = 0; + LOGERROR("RtuNo:%d pFwAo create failed.\n",RtuPtr->m_Param.RtuNo); + } + } + + ret = RdbFwAoTable.close(); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbFwAoTable::close error"); + return; + } +} + +/** + * @brief CFesBase::GetRdbFwDoTable + * 获取Do转发表参数 + * @return 无 + */ +void CFesForwarding::GetRdbFwDoTable(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + int j; + SFesFwDo *pFwDo; + bool ret; + int count; + + iot_dbms::CRdbAccessEx RdbFwDoTable; + std::vector VecFwDoParam; + std::vector vecFwDoColumn; + + vecFwDoColumn.push_back("remote_no"); + vecFwDoColumn.push_back("tag_name"); + vecFwDoColumn.push_back("description"); + vecFwDoColumn.push_back("fes_rtu_no"); + vecFwDoColumn.push_back("offset_num"); + vecFwDoColumn.push_back("fes_dot_no1"); + vecFwDoColumn.push_back("fes_dot_no2"); + vecFwDoColumn.push_back("fes_dot_no3"); + vecFwDoColumn.push_back("fes_dot_no4"); + vecFwDoColumn.push_back("fes_dot_no5"); + vecFwDoColumn.push_back("property"); + vecFwDoColumn.push_back("src_location_id"); + vecFwDoColumn.push_back("src_sub_system"); + vecFwDoColumn.push_back("res_para_int1"); + vecFwDoColumn.push_back("res_para_int2"); + vecFwDoColumn.push_back("res_para_int3"); + vecFwDoColumn.push_back("res_para_int4"); + vecFwDoColumn.push_back("res_para_int5"); + vecFwDoColumn.push_back("res_para_int6"); + vecFwDoColumn.push_back("res_para_int7"); + vecFwDoColumn.push_back("res_para_str1"); + vecFwDoColumn.push_back("src_type"); + + ret = RdbFwDoTable.open(m_strAppLabel.c_str(),RT_FES_FW_DO_TBL); + if(ret==false) + { + LOGERROR("CFesBase::InitBaseData,RdbFwDoTable::Open error"); + return; + } + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwDoTable.selectOneOrder(con, VecFwDoParam, vecFwDoColumn, "remote_no");//默认顺序 + if (ret==false) + { + LOGERROR("RdbFwDoTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwDoPoints = 0; + count = static_cast(VecFwDoParam.size()); + if(count>0) + { + RtuPtr->m_MaxFwDoPoints = VecFwDoParam[count-1].RemoteNo +1; + RtuPtr->m_FwDoPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwDo = (SFesFwDo*)malloc(RtuPtr->m_MaxFwDoPoints*sizeof(SFesFwDo)); + if(RtuPtr->m_pFwDo!=NULL) + { + memset(RtuPtr->m_pFwDo,0,RtuPtr->m_MaxFwDoPoints*sizeof(SFesFwDo)); + for(j=0;jm_MaxFwDoPoints) + { + pFwDo = RtuPtr->m_pFwDo + VecFwDoParam[j].RemoteNo; + pFwDo->RemoteNo = VecFwDoParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwDo->TagName, VecFwDoParam[j].TagName); //采集标签名 + strcpy(pFwDo->PointDesc, VecFwDoParam[j].PointDesc); //点描述 + pFwDo->FesRtuNo = VecFwDoParam[j].FesRtuNo; //采集rtu号 + pFwDo->FesPointNum = VecFwDoParam[j].FesPointNum; //分量数 + if (pFwDo->FesPointNum >= CN_FesFwDoPointNum) + pFwDo->FesPointNum = CN_FesFwDoPointNum; + pFwDo->FesPointNo[0] = VecFwDoParam[j].FesPointNo1; //采集点号 + pFwDo->FesPointNo[1] = VecFwDoParam[j].FesPointNo2; //采集点号 + pFwDo->FesPointNo[2] = VecFwDoParam[j].FesPointNo3; //采集点号 + pFwDo->FesPointNo[3] = VecFwDoParam[j].FesPointNo4; //采集点号 + pFwDo->FesPointNo[4] = VecFwDoParam[j].FesPointNo5; //采集点号 + pFwDo->Property = VecFwDoParam[j].Property; //属性 + pFwDo->SrcLocationID = VecFwDoParam[j].SrcLocationID; //所属厂站 + pFwDo->SrcSubSystem = VecFwDoParam[j].SrcSubSystem; //所属专业 + pFwDo->ResParam1 = VecFwDoParam[j].ResParam1; //备用参数1 + pFwDo->ResParam2 = VecFwDoParam[j].ResParam2; //备用参数1 + pFwDo->ResParam3 = VecFwDoParam[j].ResParam3; //备用参数1 + pFwDo->ResParam4 = VecFwDoParam[j].ResParam4; //备用参数1 + pFwDo->ResParam5 = VecFwDoParam[j].ResParam5; //备用参数1 + pFwDo->ResParam6 = VecFwDoParam[j].ResParam6; //备用参数1 + pFwDo->ResParam7 = VecFwDoParam[j].ResParam7; //备用参数1 + strcpy(pFwDo->szResParam1, VecFwDoParam[j].szResParam1); + pFwDo->SrcType = VecFwDoParam[j].SrcType; //备用参数1 + pFwDo->DIRemoteNo = -1; + pFwDo->WfBlockedTimeout=0; //五防闭锁时间 + pFwDo->Used=1; //点有效标志 + } + else + { + LOGERROR("RtuNo:%d FwAi RemoteNo %d exceed limit %d.",RtuPtr->m_Param.RtuNo,VecFwDoParam[j].RemoteNo,RtuPtr->m_MaxFwDoPoints); + } + } + } + else + { + RtuPtr->m_MaxFwDoPoints = 0; + LOGERROR("RtuNo:%d pFwDo create failed.\n",RtuPtr->m_Param.RtuNo); + } + } + + ret = RdbFwDoTable.close(); + if(ret==false) + { + LOGERROR("RdbFwDoTable::close error"); + return; + } +} + + +/** +* @brief CFesBase::GetRdbFwMoTable +* 获取Mo转发表参数 +* @return 无 +*/ +void CFesForwarding::GetRdbFwMoTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel) +{ + int j; + SFesFwMo *pFwMo; + bool ret; + int count; + //int RtuNum; + + iot_dbms::CRdbAccessEx RdbFwMoTable; + std::vector VecFwMoParam; + std::vector vecFwMoColumn; + + vecFwMoColumn.push_back("remote_no"); + vecFwMoColumn.push_back("tag_name"); + vecFwMoColumn.push_back("description"); + vecFwMoColumn.push_back("fes_rtu_no"); + vecFwMoColumn.push_back("fes_dot_no"); + vecFwMoColumn.push_back("max_range"); + vecFwMoColumn.push_back("min_range"); + vecFwMoColumn.push_back("property"); + vecFwMoColumn.push_back("src_location_id"); + vecFwMoColumn.push_back("src_sub_system"); + vecFwMoColumn.push_back("res_para_int1"); + vecFwMoColumn.push_back("res_para_int2"); + vecFwMoColumn.push_back("res_para_int3"); + vecFwMoColumn.push_back("res_para_int4"); + vecFwMoColumn.push_back("res_para_int5"); + vecFwMoColumn.push_back("res_para_int6"); + vecFwMoColumn.push_back("res_para_int7"); + vecFwMoColumn.push_back("res_para_str1"); + vecFwMoColumn.push_back("src_type"); + + ret = RdbFwMoTable.open(m_strAppLabel.c_str(), RT_FES_FW_MO_TBL); + if (ret == false) + { + LOGERROR("RdbFwMoTable::Open error"); + return; + } + CONDINFO con; + con.relationop = ATTRCOND_EQU; + std::string RtuTagname = RtuPtr->m_Param.TagName; + con.conditionval = CVarType(RtuTagname); + strcpy(con.name, "rtu_tag"); + ret = RdbFwMoTable.selectOneOrder(con, VecFwMoParam, vecFwMoColumn, "remote_no");//默认顺序 + if (ret == false) + { + LOGERROR("RdbFwMoTable.selectNoCondition error!"); + return; + } + RtuPtr->m_MaxFwMoPoints = 0; + count = static_cast(VecFwMoParam.size()); + if (count>0) + { + RtuPtr->m_MaxFwMoPoints = VecFwMoParam[count - 1].RemoteNo + 1; + RtuPtr->m_FwMoPointsNum = count; + //动态分配数据空间 + RtuPtr->m_pFwMo = (SFesFwMo*)malloc(RtuPtr->m_MaxFwMoPoints * sizeof(SFesFwMo)); + if (RtuPtr->m_pFwMo != NULL) + { + memset(RtuPtr->m_pFwMo, 0, RtuPtr->m_MaxFwMoPoints * sizeof(SFesFwMo)); + for (j = 0; jm_MaxFwMoPoints) + { + pFwMo = RtuPtr->m_pFwMo + VecFwMoParam[j].RemoteNo; + pFwMo->RemoteNo = VecFwMoParam[j].RemoteNo; //点ID 从0开始递增 + strcpy(pFwMo->TagName, VecFwMoParam[j].TagName); //采集标签名 + strcpy(pFwMo->PointDesc, VecFwMoParam[j].PointDesc); //点描述 + pFwMo->FesRtuNo = VecFwMoParam[j].FesRtuNo; //采集rtu号 + pFwMo->FesPointNo = VecFwMoParam[j].FesPointNo; //采集点号 + pFwMo->MaxRange = VecFwMoParam[j].MaxRange; + pFwMo->MinRange = VecFwMoParam[j].MinRange; + pFwMo->Property = VecFwMoParam[j].Property; //属性 + pFwMo->SrcLocationID = VecFwMoParam[j].SrcLocationID; //所属厂站 + pFwMo->SrcSubSystem = VecFwMoParam[j].SrcSubSystem; //所属专业 + pFwMo->ResParam1 = VecFwMoParam[j].ResParam1; //备用参数1 + pFwMo->ResParam2 = VecFwMoParam[j].ResParam2; //备用参数1 + pFwMo->ResParam3 = VecFwMoParam[j].ResParam3; //备用参数1 + pFwMo->ResParam4 = VecFwMoParam[j].ResParam4; //备用参数1 + pFwMo->ResParam5 = VecFwMoParam[j].ResParam5; //备用参数1 + pFwMo->ResParam6 = VecFwMoParam[j].ResParam6; //备用参数1 + pFwMo->ResParam7 = VecFwMoParam[j].ResParam7; //备用参数1 + strcpy(pFwMo->szResParam1, VecFwMoParam[j].szResParam1); + pFwMo->SrcType = VecFwMoParam[j].SrcType; //备用参数1 + + pFwMo->Used = 1; //点有效标志 + //RtuNum = 0; + } + else + { + LOGERROR("RtuNo:%d FwMo RemoteNo %d exceed limit %d.", RtuPtr->m_Param.RtuNo, VecFwMoParam[j].RemoteNo, RtuPtr->m_MaxFwMoPoints); + } + } + } + else + { + RtuPtr->m_MaxFwMoPoints = 0; + LOGERROR("RtuNo:%d pFwMo create failed.\n", RtuPtr->m_Param.RtuNo); + } + } + + ret = RdbFwMoTable.close(); + if (ret == false) + { + LOGERROR("RdbFwMoTable::close error"); + return; + } +} + +void CFesForwarding::UpdateDeadBandValue(SFesFwAi *pFwAi) +{ + switch (pFwAi->DeadBandType) { + case CN_FesDeadbandType_Abs: + pFwAi->RealDeadBandValue = static_cast(pFwAi->DeadBand); + break; + case CN_FesDeadbandType_Percent: //< 因为转发配置中没有上下限值，所以暂时不支持百分比死区类型 + case CN_FesDeadbandType_None: + default: + pFwAi->RealDeadBandValue = CN_FesFwAIChangeScale; + break; + } + + if(pFwAi->RealDeadBandValue < CN_FesFwAIChangeScale) + { + pFwAi->RealDeadBandValue = CN_FesFwAIChangeScale; //< 避免配置负数，同时承担浮点数的精度判断 + } +} + + +void CFesForwarding::InitFesConllectRtu(CFesRtuPtr RtuPtr,std::string m_strAppLabel) +{ + GetRdbFwAiTable(RtuPtr,m_strAppLabel); //获取Ai转发表参数 + GetRdbFwSDiTable(RtuPtr, m_strAppLabel); //获取SDi转发表参数 + GetRdbFwDDiTable(RtuPtr, m_strAppLabel); //获取DDi转发表参数 + GetRdbFwAccTable(RtuPtr, m_strAppLabel); //获取Acc转发表参数 + GetRdbFwMiTable(RtuPtr, m_strAppLabel); //获取Mi转发表参数 + GetRdbFwAoTable(RtuPtr, m_strAppLabel); //获取Ao转发表参数 + GetRdbFwDoTable(RtuPtr, m_strAppLabel); //获取Do转发表参数 + GetRdbFwMoTable(RtuPtr, m_strAppLabel); //获取Mo转发表参数 +} + + diff --git a/product/src/fes/fes/FesForwardConfig.h b/product/src/fes/fes/FesForwardConfig.h index 5b4a4a38..ff357c6a 100644 --- a/product/src/fes/fes/FesForwardConfig.h +++ b/product/src/fes/fes/FesForwardConfig.h @@ -62,6 +62,12 @@ private: */ void GetRdbFwMoTable(CFesRtuPtr RtuPtr, std::string m_strAppLabel); + /** + * @brief CFesBase::UpdateDeadBandValue + * 根据死区类型计算出实际的死区值，避免运行时每次判断死区类型 + * @return 无 + */ + void UpdateDeadBandValue(SFesFwAi *pFwAi); }; diff --git a/product/src/fes/fes/FesFwRxControlCmdThread.cpp b/product/src/fes/fes/FesFwRxControlCmdThread.cpp index 6ee6b2e7..0156585f 100644 --- a/product/src/fes/fes/FesFwRxControlCmdThread.cpp +++ b/product/src/fes/fes/FesFwRxControlCmdThread.cpp @@ -68,31 +68,31 @@ void CFesFwRxControlCmdThread::execute() switch (nMsgType) { case MT_FESFW_DO_REQ: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxDoReq(CtrlPkg); break; case MT_FESFW_AO_REQ: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxAoReq(CtrlPkg); break; case MT_FESFW_MO_REQ: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxMoReq(CtrlPkg); break; case MT_FESFW_DO_RESP: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxDoResp(CtrlPkg); break; case MT_FESFW_AO_RESP: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxAoResp(CtrlPkg); break; case MT_FESFW_MO_RESP: - if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(CtrlPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxMoResp(CtrlPkg); break; case MT_FESWUFANG_STATUS_REPORT: - if(StatusPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if(StatusPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) RxWuFangStatusReport(StatusPkg); break; default: diff --git a/product/src/fes/fes/FesRedundantManage.cpp b/product/src/fes/fes/FesRedundantManage.cpp index 661d5316..e899095c 100644 --- a/product/src/fes/fes/FesRedundantManage.cpp +++ b/product/src/fes/fes/FesRedundantManage.cpp @@ -5,7 +5,6 @@ @history 2019-10-17 thxiao 由主机状态=>备机状态,停止部分线程,同时对应的线程也做了数据清理等处理 2020-02-25 thxiao 在非主非备的情况下（开门狗叫），FES按备机方式处理 - 2023-11-25 thxiao 转发数据处理改为分多个线程处理数据 */ #include "FesRedundantManage.h" @@ -93,10 +92,6 @@ void CFesRedundantManage::Init(SRedundantManageThreadParam &Param ) m_ptrFesFwTxControlCmdThread = Param.ptrFesFwTxControlCmdThread; m_ptrFesRxFesDataThread = Param.ptrFesRxFesDataThread; m_ptrFesRxDPDataThread = Param.ptrFesRxDPDataThread; - m_ptrAnaWorkThread = Param.ptrAnaWorkThread; - m_ptrDigWorkThread = Param.ptrDigWorkThread; - m_ptrAccWorkThread = Param.ptrAccWorkThread; - m_ptrMixWorkThread = Param.ptrMixWorkThread; } /* @@ -152,22 +147,6 @@ void CFesRedundantManage::ResumeThread() m_ptrFesRxDPDataThread->resume(); } - if (m_ptrAnaWorkThread != NULL) - { - m_ptrAnaWorkThread->resume(); - } - if (m_ptrDigWorkThread != NULL) - { - m_ptrDigWorkThread->resume(); - } - if (m_ptrAccWorkThread != NULL) - { - m_ptrAccWorkThread->resume(); - } - if (m_ptrMixWorkThread != NULL) - { - m_ptrMixWorkThread->resume(); - } } /* @@ -236,21 +215,4 @@ void CFesRedundantManage::SuspendThread() m_ptrFesRxDPDataThread->setSlave(); } - if (m_ptrAnaWorkThread != NULL) - { - m_ptrAnaWorkThread->suspend(); - } - if (m_ptrDigWorkThread != NULL) - { - m_ptrDigWorkThread->suspend(); - } - if (m_ptrAccWorkThread != NULL) - { - m_ptrAccWorkThread->suspend(); - } - if (m_ptrMixWorkThread != NULL) - { - m_ptrMixWorkThread->suspend(); - } - } diff --git a/product/src/fes/fes/FesRedundantManage.h b/product/src/fes/fes/FesRedundantManage.h index 6c08aa85..b24f3c56 100644 --- a/product/src/fes/fes/FesRedundantManage.h +++ b/product/src/fes/fes/FesRedundantManage.h @@ -19,10 +19,6 @@ #include "FesFwTxControlCmdThread.h" #include "FesRxFesDataThread.h" #include "FesRxDPDataThread.h" -#include "AnaWorkThread.h" -#include "DigWorkThread.h" -#include "AccWorkThread.h" -#include "MixWorkThread.h" typedef struct{ CFesRxDataUpDateThreadPtr ptrFesRxDataUpDateThread; @@ -37,10 +33,6 @@ typedef struct{ CFesFwTxControlCmdThreadPtr ptrFesFwTxControlCmdThread; CFesRxFesDataThreadPtr ptrFesRxFesDataThread; CFesRxDPDataThreadPtr ptrFesRxDPDataThread; - CAnaWorkThreadPtr ptrAnaWorkThread; - CDigWorkThreadPtr ptrDigWorkThread; - CAccWorkThreadPtr ptrAccWorkThread; - CMixWorkThreadPtr ptrMixWorkThread; }SRedundantManageThreadParam; class CFesRedundantManage : @@ -110,10 +102,6 @@ private: CFesFwTxControlCmdThreadPtr m_ptrFesFwTxControlCmdThread; CFesRxFesDataThreadPtr m_ptrFesRxFesDataThread; CFesRxDPDataThreadPtr m_ptrFesRxDPDataThread; - CAnaWorkThreadPtr m_ptrAnaWorkThread; - CDigWorkThreadPtr m_ptrDigWorkThread; - CAccWorkThreadPtr m_ptrAccWorkThread; - CMixWorkThreadPtr m_ptrMixWorkThread; }; typedef boost::shared_ptr CFesRedundantManagePtr; diff --git a/product/src/fes/fes/FesRtu.cpp b/product/src/fes/fes/FesRtu.cpp index d7396648..a83b3c6b 100644 --- a/product/src/fes/fes/FesRtu.cpp +++ b/product/src/fes/fes/FesRtu.cpp @@ -72,6 +72,7 @@ CFesRtu::CFesRtu() m_MaxDiIndex = 0; m_MaxAccIndex = 0; m_MaxMiIndex = 0; + m_MinMiIndex = -1;//实际混合量最小索引，即规约参数1最小值,-1表示没有或者无效 m_MaxAoIndex = 0; m_MaxDoIndex = 0; m_MaxMoIndex = 0; @@ -357,10 +358,8 @@ SFesMo* CFesRtu::GetMoByPointNo(int PointNo) */ int CFesRtu::GetRtuDiChgNum() { - int num; - boost::mutex::scoped_lock lock(m_DiChgMutex); - num = DiChgBuf.size(); + int num = static_cast(DiChgBuf.size()); return num; } @@ -371,10 +370,8 @@ int CFesRtu::GetRtuDiChgNum() */ int CFesRtu::GetRtuAiChgNum() { - int num; - boost::mutex::scoped_lock lock(m_AiChgMutex); - num = AiChgBuf.size(); + int num = static_cast(AiChgBuf.size()); return num; } @@ -385,10 +382,8 @@ int CFesRtu::GetRtuAiChgNum() */ int CFesRtu::GetRtuAccChgNum() { - int num; - boost::mutex::scoped_lock lock(m_AccChgMutex); - num = AccChgBuf.size(); + int num = static_cast(AccChgBuf.size()); return num; } @@ -399,10 +394,8 @@ int CFesRtu::GetRtuAccChgNum() */ int CFesRtu::GetRtuMiChgNum() { - int num; - boost::mutex::scoped_lock lock(m_MiChgMutex); - num = MiChgBuf.size(); + int num = static_cast(MiChgBuf.size()); return num; } @@ -787,10 +780,8 @@ int CFesRtu::ReadMiValue(int num,SFesAllMi *buffer) */ int CFesRtu::GetSoeEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = SoeEventBuf.size(); + int num = static_cast(SoeEventBuf.size()); return num; } @@ -801,10 +792,8 @@ int CFesRtu::GetSoeEventNum() */ int CFesRtu::GetChanEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = ChanEventBuf.size(); + int num = static_cast(ChanEventBuf.size()); return num; } @@ -816,10 +805,8 @@ int CFesRtu::GetChanEventNum() */ int CFesRtu::GetRtuEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = RtuEventBuf.size(); + int num = static_cast(RtuEventBuf.size()); return num; } @@ -1023,11 +1010,8 @@ void CFesRtu::WriteRxDoCmdBuf(int num,SFesRxDoCmd *buffer) */ void CFesRtu::WriteRxAoCmdBuf(int num,SFesRxAoCmd *buffer) { - int i; - - boost::mutex::scoped_lock lock(m_CmdMutex); - for(i=0;i(TxDoCmdBuf.size()); return num; } @@ -1107,10 +1089,8 @@ int CFesRtu::GetTxDoCmdNum() */ int CFesRtu::GetTxAoCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = TxAoCmdBuf.size(); + int num = static_cast(TxAoCmdBuf.size()); return num; } @@ -1121,10 +1101,8 @@ int CFesRtu::GetTxAoCmdNum() */ int CFesRtu::GetTxmMoCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = TxMoCmdBuf.size(); + int num = static_cast(TxMoCmdBuf.size()); return num; } @@ -1135,10 +1113,8 @@ int CFesRtu::GetTxmMoCmdNum() */ int CFesRtu::GetTxSettingCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = TxSettingCmdBuf.size(); + int num = static_cast(TxSettingCmdBuf.size()); return num; } @@ -1149,10 +1125,8 @@ int CFesRtu::GetTxSettingCmdNum() */ int CFesRtu::GetTxDefCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = TxDefCmdBuf.size(); + int num = static_cast(TxDefCmdBuf.size()); return num; } @@ -1288,7 +1262,6 @@ int CFesRtu::ReadTxDefCmd(int num,SFesTxDefCmd *buffer) return tempNum; } - /** * @brief CFesRtu::WriteChanEventBuf * 写入CHAN EVENT缓冲区内容 @@ -1315,10 +1288,8 @@ void CFesRtu::WriteChanEventBuf(int num,SFesChanEvent *buffer) void CFesRtu::WriteSoeEventBuf(int num,SFesSoeEvent *buffer) { int i; - CFesRtuPtr rtuPtr; - boost::mutex::scoped_lock lock(m_EventMutex); - int count = SoeEventBuf.size(); + int count = static_cast(SoeEventBuf.size()); if ((count + num) > DiMaxChgNum) { for (i = 0; i < num; i++) @@ -1365,10 +1336,8 @@ void CFesRtu::WriteRtuEventBuf(int num,SFesRtuEvent *buffer) */ int CFesRtu::GetRxDoCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = RxDoCmdBuf.size(); + int num = static_cast(RxDoCmdBuf.size()); return num; } @@ -1379,10 +1348,8 @@ int CFesRtu::GetRxDoCmdNum() */ int CFesRtu::GetRxAoCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = RxAoCmdBuf.size(); + int num = static_cast(RxAoCmdBuf.size()); return num; } @@ -1393,10 +1360,8 @@ int CFesRtu::GetRxAoCmdNum() */ int CFesRtu::GetRxMoCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = RxMoCmdBuf.size(); + int num = static_cast(RxMoCmdBuf.size()); return num; } @@ -1407,10 +1372,8 @@ int CFesRtu::GetRxMoCmdNum() */ int CFesRtu::GetRxSettingCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = RxSettingCmdBuf.size(); + int num = static_cast(RxSettingCmdBuf.size()); return num; } @@ -1421,10 +1384,8 @@ int CFesRtu::GetRxSettingCmdNum() */ int CFesRtu::GetRxDefCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = RxDefCmdBuf.size(); + int num = static_cast(RxDefCmdBuf.size()); return num; } @@ -1628,7 +1589,6 @@ void CFesRtu::WriteTxDefCmdBuf(int num,SFesTxDefCmd *buffer) } } - /** * @brief CFesRtu::WriteTxSettingCmdBuf * FES（规约模块）返回Setting命令结果，写入FES发送Setting命令缓存区 @@ -1679,7 +1639,7 @@ void CFesRtu::WriteChgAiValue(int num,SFesChgAi *buffer) int i; boost::mutex::scoped_lock lock(m_AiChgMutex); - int count = AiChgBuf.size(); + int count = static_cast(AiChgBuf.size()); if((count+num)>AiMaxChgNum) { LOGERROR("RTU%d AiChgBuf overflow AiMaxChgNum=%d ",m_Param.RtuNo,AiMaxChgNum); @@ -1702,7 +1662,7 @@ void CFesRtu::WriteChgAccValue(int num,SFesChgAcc *buffer) int i; boost::mutex::scoped_lock lock(m_AccChgMutex); - int count = AccChgBuf.size(); + int count = static_cast(AccChgBuf.size()); if((count+num)>AccMaxChgNum) { LOGERROR("RTU%d AccChgBuf overflow AccMaxChgNum=%d ",m_Param.RtuNo,AccMaxChgNum); @@ -1725,7 +1685,7 @@ void CFesRtu::WriteChgMiValue(int num,SFesChgMi *buffer) int i; boost::mutex::scoped_lock lock(m_MiChgMutex); - int count = MiChgBuf.size(); + int count = static_cast(MiChgBuf.size()); if((count+num)>MiMaxChgNum) { LOGERROR("RTU%d MiChgBuf overflow MiMaxChgNum=%d ",m_Param.RtuNo,MiMaxChgNum); @@ -1864,8 +1824,8 @@ void CFesRtu::WriteRtuAccValueAndRetChg(int num,SFesRtuAccValue *buffer,int *ret { int i,count; SFesAcc *pAcc; - uint64 value; - double fdValue; + //uint64 value; + double dvalue; boost::mutex::scoped_lock lock(m_AccMutex); count = 0; @@ -1874,9 +1834,10 @@ void CFesRtu::WriteRtuAccValueAndRetChg(int num,SFesRtuAccValue *buffer,int *ret if(buffer[i].PointNo < m_MaxAccPoints) { pAcc = m_pAcc+buffer[i].PointNo; - fdValue = (double)buffer[i].Value*pAcc->Coeff+pAcc->Base; - value = fdValue; - if(((int64)value) != pAcc->Value) + //fdValue = (double)buffer[i].Value*pAcc->Coeff+pAcc->Base; + dvalue = buffer[i].Value*(pAcc->Coeff)+pAcc->Base; + //value = fdValue; + if(dvalue != pAcc->Value) { //2019-08-23 thxiao 第一次启动时，HMI数据上传慢，所以不再判断是否更新过。 //if(pAcc->Status&CN_FesValueUpdate)//更新过的点才能报告变化 @@ -1884,14 +1845,14 @@ void CFesRtu::WriteRtuAccValueAndRetChg(int num,SFesRtuAccValue *buffer,int *ret memcpy(ChgBuffer[count].TableName,pAcc->TableName,CN_FesMaxTableNameSize); memcpy(ChgBuffer[count].ColumnName,pAcc->ColumnName,CN_FesMaxColumnNameSize); memcpy(ChgBuffer[count].TagName,pAcc->TagName,CN_FesMaxTagSize); - ChgBuffer[count].Value=value; + ChgBuffer[count].Value=dvalue; ChgBuffer[count].Status = buffer[i].Status; ChgBuffer[count].time = buffer[i].time; ChgBuffer[count].RtuNo = m_Param.RtuNo; ChgBuffer[count].PointNo = pAcc->PointNo; count++; } - pAcc->Value = value; + pAcc->Value = dvalue; pAcc->Status = buffer[i].Status; pAcc->time = buffer[i].time; } @@ -2021,6 +1982,7 @@ void CFesRtu::WriteRtuPointsComStatus(int comStatus) { if ((pDi->Status&CN_FesValueComDown) == 0x00)//2021-06-08 thxiao 判断原来的通信状态确实发生了状态变化，才置上全局标志 { + pDi->Status = 0; //置为值未更新状态，防止重连成功时，上一次的值被上传 pDi->Status |= status; pointCount++; if (m_Param.ClearDataEnable&CN_Fes_Comdown_Clear) @@ -2063,6 +2025,7 @@ void CFesRtu::WriteRtuPointsComStatus(int comStatus) { if ((pAi->Status&CN_FesValueComDown) == 0x00)//2021-06-08 thxiao 判断原来的通信状态确实发生了状态变化，才置上全局标志 { + pAi->Status = 0; //置为值未更新状态，防止重连成功时，上一次的值被上传 pAi->Status |= status; if (m_Param.ClearDataEnable&CN_Fes_Comdown_Clear) { @@ -2109,6 +2072,7 @@ void CFesRtu::WriteRtuPointsComStatus(int comStatus) { if ((pAcc->Status&CN_FesValueComDown) == 0x00)//2021-06-08 thxiao 有状态变化才置标志 { + pAcc->Status = 0; //置为值未更新状态，防止重连成功时，上一次的值被上传 pAcc->Status |= status; if (m_Param.ClearDataEnable&CN_Fes_Comdown_Clear) pAcc->Value = 0; @@ -2149,6 +2113,7 @@ void CFesRtu::WriteRtuPointsComStatus(int comStatus) { if ((pMi->Status&CN_FesValueComDown) == 0x00)//2021-06-08 thxiao 有状态变化才置标志 { + pMi->Status = 0; //置为值未更新状态，防止重连成功时，上一次的值被上传 pMi->Status |= status; if (m_Param.ClearDataEnable&CN_Fes_Comdown_Clear) pMi->Value = 0; @@ -2250,10 +2215,8 @@ int CFesRtu::ReadFwDoRespCmd(int num, SFesFwDoRespCmd *buffer) */ int CFesRtu::GetFwDoRespCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = FwDoRespCmdBuf.size(); + int num = static_cast(FwDoRespCmdBuf.size()); return num; } @@ -2306,7 +2269,7 @@ void CFesRtu::SetAiFwFlag(int PointNo, int MappingIndex, int RemoteNo) pAi->FwMapNum++; } else - LOGERROR("RTU:%d PointNo:%d Di 超出最大转发映射次数，映射失败。转发MappingIndex:%d RemoteNo:%d ", m_Param.RtuNo, PointNo, MappingIndex, RemoteNo); + LOGERROR("RTU:%d PointNo:%d Ai 超出最大转发映射次数，映射失败。转发MappingIndex:%d RemoteNo:%d ", m_Param.RtuNo, PointNo, MappingIndex, RemoteNo); } @@ -2367,15 +2330,13 @@ void CFesRtu::SetMiFwFlag(int PointNo, int MappingIndex, int RemoteNo) * 写入转发SOE EVENT缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwSoeEventBuf(SFesFwSoeEvent buffer) +void CFesRtu::WriteFwSoeEventBuf(const SFesFwSoeEvent &buffer) { - int count; - if (FwSoeChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_EventMutex); - count = FwSoeEventBuf.size(); + int count = static_cast(FwSoeEventBuf.size()); if(count>FwDiMaxChgNum) { //FwSoeEventBuf.front(); //从头开始读取数据 @@ -2384,7 +2345,7 @@ void CFesRtu::WriteFwSoeEventBuf(SFesFwSoeEvent buffer) } FwSoeEventBuf.push(buffer); //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("SOE RtuNo:%d RemoteNo=%d value=%d ms=[%" PRId64 "] .", m_Param.RtuNo, buffer.RemoteNo,buffer.Value, buffer.time); + LOGTRACE("SOE RtuNo:%d RemoteNo=%d value=%d ms=[%" PRId64 "] .", m_Param.RtuNo, buffer.RemoteNo,buffer.Value, buffer.time); } @@ -2393,15 +2354,13 @@ void CFesRtu::WriteFwSoeEventBuf(SFesFwSoeEvent buffer) * 写入转发DSOE EVENT缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwDSoeEventBuf(SFesFwSoeEvent buffer) +void CFesRtu::WriteFwDSoeEventBuf(const SFesFwSoeEvent &buffer) { - int count; - if (FwDSoeChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_EventMutex); - count = FwDSoeEventBuf.size(); + int count = static_cast(FwDSoeEventBuf.size()); if (count>FwDiMaxChgNum) { //FwDSoeEventBuf.front(); //从头开始读取数据 @@ -2410,7 +2369,7 @@ void CFesRtu::WriteFwDSoeEventBuf(SFesFwSoeEvent buffer) } FwDSoeEventBuf.push(buffer); //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("DSOE RtuNo:%d RemoteNo=%d value=%d ms=%ld", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); + LOGTRACE("DSOE RtuNo:%d RemoteNo=%d value=%d ms=%ld", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); } @@ -2419,15 +2378,13 @@ void CFesRtu::WriteFwDSoeEventBuf(SFesFwSoeEvent buffer) * 写入转发DI变化缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwDiBuf(SFesFwChgDi buffer) +void CFesRtu::WriteFwDiBuf(const SFesFwChgDi &buffer) { - int count; - if (FwDiChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_DiChgMutex); - count = FwDiChgBuf.size(); + int count = static_cast(FwDiChgBuf.size()); if (count>FwDiMaxChgNum) { //FwDiChgBuf.front(); //从头开始读取数据 @@ -2436,7 +2393,7 @@ void CFesRtu::WriteFwDiBuf(SFesFwChgDi buffer) } FwDiChgBuf.push(buffer); //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("转发DI变位 RtuNo:%d RemoteNo=%d value=%d ms=[%" PRId64 "] .", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); + LOGTRACE("转发DI变位 RtuNo:%d RemoteNo=%d value=%d ms=[%" PRId64 "] .", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); } @@ -2445,15 +2402,13 @@ void CFesRtu::WriteFwDiBuf(SFesFwChgDi buffer) * 写入转发DDI变化缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwDDiBuf(SFesFwChgDi buffer) +void CFesRtu::WriteFwDDiBuf(const SFesFwChgDi &buffer) { - int count; - if (FwDDiChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_DiChgMutex); - count = FwDDiChgBuf.size(); + int count = static_cast(FwDDiChgBuf.size()); if (count > FwDDiMaxChgNum) { //FwDDiChgBuf.front(); //从头开始读取数据 @@ -2462,7 +2417,7 @@ void CFesRtu::WriteFwDDiBuf(SFesFwChgDi buffer) } FwDDiChgBuf.push(buffer); //2019-09-06 thxiao 方便查找事件，增加记录 - LOGINFO("转发DDI变位 RtuNo:%d RemoteNo=%d value=%d ms=%ld", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); + LOGTRACE("转发DDI变位 RtuNo:%d RemoteNo=%d value=%d ms=%ld", m_Param.RtuNo, buffer.RemoteNo, buffer.Value, buffer.time); } @@ -2471,15 +2426,13 @@ void CFesRtu::WriteFwDDiBuf(SFesFwChgDi buffer) * 写入转发Ai变化缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwAiBuf(SFesFwChgAi buffer) +void CFesRtu::WriteFwAiBuf(const SFesFwChgAi &buffer) { - int count; - if (FwAiChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_AiChgMutex); - count = FwAiChgBuf.size(); + int count = static_cast(FwAiChgBuf.size()); if (count > FwAiMaxChgNum) { //FwAiChgBuf.front(); //从头开始读取数据 @@ -2494,15 +2447,13 @@ void CFesRtu::WriteFwAiBuf(SFesFwChgAi buffer) * 写入转发Acc变化缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwAccBuf(SFesFwChgAcc buffer) +void CFesRtu::WriteFwAccBuf(const SFesFwChgAcc &buffer) { - int count; - if (FwAccChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_AccChgMutex); - count = FwAccChgBuf.size(); + int count = static_cast(FwAccChgBuf.size()); if (count > FwAccMaxChgNum) { //FwAccChgBuf.front(); //从头开始读取数据 @@ -2518,15 +2469,13 @@ void CFesRtu::WriteFwAccBuf(SFesFwChgAcc buffer) * 写入转发Mi变化缓冲区内容 * @param buffer 写入数据 */ -void CFesRtu::WriteFwMiBuf(SFesFwChgMi buffer) +void CFesRtu::WriteFwMiBuf(const SFesFwChgMi &buffer) { - int count; - if (FwMiChgStop)//有些从站协议不支持变化报告，该标志可以用来控制是否填写对应的变化缓冲区。 return; boost::mutex::scoped_lock lock(m_MiChgMutex); - count = FwMiChgBuf.size(); + int count = static_cast(FwMiChgBuf.size()); if (count > FwMiMaxChgNum) { //FwMiChgBuf.front(); //从头开始读取数据 @@ -2544,10 +2493,8 @@ void CFesRtu::WriteFwMiBuf(SFesFwChgMi buffer) */ int CFesRtu::GetFwSOEEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = FwSoeEventBuf.size(); + int num = static_cast(FwSoeEventBuf.size()); return num; } @@ -2626,10 +2573,8 @@ int CFesRtu::ReadFwAoRespCmd(int num, SFesFwAoRespCmd *buffer) */ int CFesRtu::GetFwAoRespCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = FwAoRespCmdBuf.size(); + int num = static_cast(FwAoRespCmdBuf.size()); return num; } @@ -2683,10 +2628,8 @@ int CFesRtu::ReadFwMoRespCmd(int num,SFesFwMoRespCmd *buffer) */ int CFesRtu::GetFwMoRespCmdNum() { - int num; - boost::mutex::scoped_lock lock(m_CmdMutex); - num = FwMoRespCmdBuf.size(); + int num = static_cast(FwMoRespCmdBuf.size()); return num; } @@ -2819,10 +2762,8 @@ void CFesRtu::ClearBuf() */ int CFesRtu::GetFwChgAiNum() { - int num; - boost::mutex::scoped_lock lock(m_AiChgMutex); - num = FwAiChgBuf.size(); + int num = static_cast(FwAiChgBuf.size()); return num; } @@ -2857,10 +2798,8 @@ int CFesRtu::ReadFwChgAi(int num, SFesFwChgAi *buffer) */ int CFesRtu::GetFwChgDiNum() { - int num; - boost::mutex::scoped_lock lock(m_DiChgMutex); - num = FwDiChgBuf.size(); + int num = static_cast(FwDiChgBuf.size()); return num; } @@ -2895,10 +2834,8 @@ int CFesRtu::ReadFwChgDi(int num, SFesFwChgDi *buffer) */ int CFesRtu::GetFwChgDDiNum() { - int num; - boost::mutex::scoped_lock lock(m_DiChgMutex); - num = FwDDiChgBuf.size(); + int num = static_cast(FwDDiChgBuf.size()); return num; } @@ -2934,10 +2871,8 @@ int CFesRtu::ReadFwChgDDi(int num, SFesFwChgDi *buffer) */ int CFesRtu::GetFwChgAccNum() { - int num; - boost::mutex::scoped_lock lock(m_AccChgMutex); - num = FwAccChgBuf.size(); + int num = static_cast(FwAccChgBuf.size()); return num; } @@ -2972,10 +2907,8 @@ int CFesRtu::ReadFwChgAcc(int num, SFesFwChgAcc *buffer) */ int CFesRtu::GetFwChgMiNum() { - int num; - boost::mutex::scoped_lock lock(m_MiChgMutex); - num = FwMiChgBuf.size(); + int num = static_cast(FwMiChgBuf.size()); return num; } @@ -3011,10 +2944,8 @@ int CFesRtu::ReadFwChgMi(int num, SFesFwChgMi *buffer) */ int CFesRtu::GetFwDSOEEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = FwDSoeEventBuf.size(); + int num = static_cast(FwDSoeEventBuf.size()); return num; } @@ -3051,7 +2982,7 @@ int CFesRtu::ReadFwDSOEEvent(int num, SFesFwSoeEvent *buffer) * 第一次更新不认为是变化数据 * @return true:更新 false:没更新 */ - bool CFesRtu::UpdataFwDiValue(SFesFwChgDi DiValue,int updateMode) + bool CFesRtu::UpdataFwDiValue(const SFesFwChgDi &DiValue,int updateMode) { SFesFwDi *pDi; @@ -3105,7 +3036,7 @@ int CFesRtu::ReadFwDSOEEvent(int num, SFesFwSoeEvent *buffer) * @return true:更新 false:没更新 */ - bool CFesRtu::UpdataFwDDiValue(SFesFwChgDi DiValue, int updateMode) + bool CFesRtu::UpdataFwDDiValue(const SFesFwChgDi &DiValue, int updateMode) { SFesFwDi *pDi; @@ -3158,50 +3089,39 @@ int CFesRtu::ReadFwDSOEEvent(int num, SFesFwSoeEvent *buffer) * @param updateMode 更新模式 1：判断后更新(DP to FES) 0：直接更新，不需要判断（默认）(FES to FES) * @return true:更新 false:没更新 */ - bool CFesRtu::UpdataFwAiValue(SFesFwChgAi AiValue,int updateMode) + bool CFesRtu::UpdataFwAiValue(const SFesFwChgAi &AiValue, float &fNewValue,EnumUpdateFwCacheMode eUpdateMode) { - SFesFwAi *pAi; - int changeFlag = 0; + if(AiValue.RemoteNo >= m_MaxFwAiPoints || AiValue.RemoteNo < 0) + { + return false; + } - //boost::mutex::scoped_lock lock(m_AiChgMutex); boost::mutex::scoped_lock lock(m_AiMutex);//2023-02-15 thxiao 转发数据读写时使用同一个锁，所以改为m_AiMutex - if ((AiValue.RemoteNo < m_MaxFwAiPoints) && (AiValue.RemoteNo >= 0)) - { - pAi = m_pFwAi + AiValue.RemoteNo; - if (updateMode) - { - if ((fabs(pAi->Value) < CN_FesFloatCompare) && (fabs(AiValue.Value) < CN_FesFloatCompare)) - return false; + SFesFwAi *pAi = m_pFwAi + AiValue.RemoteNo; + //< 强制更新模式直接更新，不进行系数和死区判断 + if(eUpdateMode == eDirectUpdate) + { + pAi->Value = AiValue.Value; + pAi->Status = AiValue.Status; + pAi->time = AiValue.time; + return true; + } - if (fabs(pAi->Value*AiValue.Value) < CN_FesFloatCompare) - changeFlag = 1; - - else if ((fabs(pAi->Value / AiValue.Value) < (1 - CN_FesFwAIChangeScale)) - ||(fabs(pAi->Value / AiValue.Value) > (1 + CN_FesFwAIChangeScale))) - changeFlag = 1; - - if (changeFlag) - { - pAi->Value = AiValue.Value; - pAi->Status = AiValue.Status; - pAi->time = AiValue.time; - return true; - } - else - { - return false; - } - } - else - { - pAi->Value = AiValue.Value; - pAi->Status = AiValue.Status; - pAi->time = AiValue.time; - return true; - } - } - else - return false; + //< 超过5分钟或者超过死区更新一次 + fNewValue = static_cast(AiValue.Value * pAi->Coeff + pAi->Base); //< 进行基值和K值变换 + if( eUpdateMode == eWithoutDeadbandUpdate || + fabs(pAi->Value - fNewValue) >= pAi->RealDeadBandValue || + (AiValue.time - pAi->time) > 5 * SEC_PER_MIN * MSEC_PER_SEC ) + { + pAi->Value = fNewValue; + pAi->Status = AiValue.Status; + pAi->time = AiValue.time; + return true; + } + else + { + return false; + } } /** @@ -3211,37 +3131,33 @@ int CFesRtu::ReadFwDSOEEvent(int num, SFesFwSoeEvent *buffer) * @param updateMode 更新模式 1：判断后更新(DP to FES) 0：直接更新，不需要判断（默认）(FES to FES) * @return true:更新 false:没更新 */ - bool CFesRtu::UpdataFwAccValue(SFesFwChgAcc AccValue, int updateMode) + bool CFesRtu::UpdataFwAccValue(const SFesFwChgAcc &AccValue, double &dNewValue,EnumUpdateFwCacheMode eUpdateMode) { - SFesFwAcc *pAcc; + if(AccValue.RemoteNo >= m_MaxFwAccPoints || AccValue.RemoteNo < 0) + { + return false; + } - //boost::mutex::scoped_lock lock(m_AccChgMutex); boost::mutex::scoped_lock lock(m_AccMutex);//2023-02-15 thxiao 转发数据读写时使用同一个锁，所以改为m_AccMutex - if ((AccValue.RemoteNo < m_MaxFwAccPoints) && (AccValue.RemoteNo >= 0)) - { - pAcc = m_pFwAcc + AccValue.RemoteNo; - if (updateMode) - { - if (pAcc->Value != AccValue.Value) - { - pAcc->Value = AccValue.Value; - pAcc->Status = AccValue.Status; - pAcc->time = AccValue.time; - return true; - } - else - return false; - } - else - { - pAcc->Value = AccValue.Value; - pAcc->Status = AccValue.Status; - pAcc->time = AccValue.time; - return true; - } - } - else - return false; + SFesFwAcc *pAcc = m_pFwAcc + AccValue.RemoteNo; + if(eUpdateMode == eDirectUpdate) + { + pAcc->Value = AccValue.Value; + pAcc->Status = AccValue.Status; + pAcc->time = AccValue.time; + return true; + } + + dNewValue = AccValue.Value * pAcc->Coeff + pAcc->Base; + if( fabs(dNewValue - pAcc->Value) >= CN_FesFloatCompare ) + { + pAcc->Value = dNewValue; + pAcc->Status = AccValue.Status; + pAcc->time = AccValue.time; + return true; + } + + return false; } /** @@ -3251,37 +3167,33 @@ int CFesRtu::ReadFwDSOEEvent(int num, SFesFwSoeEvent *buffer) * @param updateMode 更新模式 1：判断后更新(DP to FES) 0：直接更新，不需要判断（默认）(FES to FES) * @return true:更新 false:没更新 */ - bool CFesRtu::UpdataFwMiValue(SFesFwChgMi MiValue,int updateMode) + bool CFesRtu::UpdataFwMiValue(const SFesFwChgMi &MiValue,int &nNewValue, EnumUpdateFwCacheMode eUpdateMode) { - SFesFwMi *pMi; + if(MiValue.RemoteNo >= m_MaxFwMiPoints || MiValue.RemoteNo < 0) + { + return false; + } - //boost::mutex::scoped_lock lock(m_MiChgMutex); boost::mutex::scoped_lock lock(m_MiMutex);//2023-02-15 thxiao 转发数据读写时使用同一个锁，所以改为m_MiMutex - if ((MiValue.RemoteNo < m_MaxFwMiPoints) && (MiValue.RemoteNo >= 0)) - { - pMi = m_pFwMi + MiValue.RemoteNo; - if (updateMode) - { - if (pMi->Value != MiValue.Value) - { - pMi->Value = MiValue.Value; - pMi->Status = MiValue.Status; - pMi->time = MiValue.time; - return true; - } - else - return false; - } - else - { - pMi->Value = MiValue.Value; - pMi->Status = MiValue.Status; - pMi->time = MiValue.time; - return true; - } - } - else - return false; + SFesFwMi *pMi = m_pFwMi + MiValue.RemoteNo; + if(eUpdateMode == eDirectUpdate) + { + pMi->Value = MiValue.Value; + pMi->Status = MiValue.Status; + pMi->time = MiValue.time; + return true; + } + + nNewValue = static_cast(MiValue.Value * pMi->Coeff + pMi->Base); + if (pMi->Value != nNewValue) + { + pMi->Value = nNewValue; + pMi->Status = MiValue.Status; + pMi->time = MiValue.time; + return true; + } + + return false; } @@ -3737,7 +3649,7 @@ void CFesRtu::ClearFwDSoeEventBuf() * @brief CFesRtu::WriteVirtualValue * 写入虚拟数据 */ - void CFesRtu::WriteVirtualValue(SFesVirtualValue Value) + void CFesRtu::WriteVirtualValue(const SFesVirtualValue &Value) { boost::mutex::scoped_lock lock(m_CmdMutex); VirtualValueBuf.push(Value); @@ -3876,10 +3788,8 @@ int CFesRtu::GetMiPointNoByDevId(int DevId, std::vector& PointNo) */ int CFesRtu::GetSoeStrEventNum() { - int num; - boost::mutex::scoped_lock lock(m_EventMutex); - num = SoeStrEventBuf.size(); + int num = static_cast(SoeStrEventBuf.size()); return num; } @@ -3997,5 +3907,59 @@ void CFesRtu::WriteRtuPointsComDown() } if (pointCount > 0) m_MiStatusChangeReportFlag = 1; - } + } +} + +void CFesRtu::writeJsonFormatReqCmd(const rapidjson::Value &jsonCmd) +{ + //(); + ptrDoc->CopyFrom(jsonCmd,ptrDoc->GetAllocator()); + + boost::mutex::scoped_lock lock(m_CmdMutex); + if(m_jsonFormatReqCmdBuf.size() > CN_Fes_MaxCmdBufSize) + { + m_jsonFormatReqCmdBuf.pop(); + } + m_jsonFormatReqCmdBuf.push(ptrDoc); +} + +void CFesRtu::readJsonFormatReqCmd(std::queue &dequeJsonCmd) +{ + boost::mutex::scoped_lock lock(m_CmdMutex); + dequeJsonCmd.swap(m_jsonFormatReqCmdBuf); +} + +size_t CFesRtu::getJsonFormatReqCmdSize() +{ + boost::mutex::scoped_lock lock(m_CmdMutex); + return m_jsonFormatReqCmdBuf.size(); +} + +void CFesRtu::clearJsonFormatReqCmdBuf() +{ + std::queue dequeJsonCmd; + boost::mutex::scoped_lock lock(m_CmdMutex); + m_jsonFormatReqCmdBuf.swap(dequeJsonCmd); +} + +void CFesRtu::writeJsonFormatReplayCmd(const std::string &strCmd) +{ + boost::mutex::scoped_lock lock(m_CmdMutex); + if(m_jsonFormatReplayCmdBuf.size() > CN_Fes_MaxCmdBufSize) + { + m_jsonFormatReplayCmdBuf.pop(); + } + m_jsonFormatReplayCmdBuf.push(strCmd); +} + +/** + * @brief CFesRtu::ReadStringFormatRespCmd + * 读取发送自定义命令缓冲区内容 + * @param dequeStrCmd 返回控制命令 + */ +void CFesRtu::readJsonFormatReplayCmd(std::queue &strCmds) +{ + boost::mutex::scoped_lock lock(m_CmdMutex); + strCmds.swap(m_jsonFormatReplayCmdBuf); } diff --git a/product/src/fes/fes/FesRxControlCmdThread.cpp b/product/src/fes/fes/FesRxControlCmdThread.cpp index 3087f402..2db81c73 100644 --- a/product/src/fes/fes/FesRxControlCmdThread.cpp +++ b/product/src/fes/fes/FesRxControlCmdThread.cpp @@ -9,14 +9,15 @@ */ #include "FesRxControlCmdThread.h" #include "MessageChannel.h" -#include "FesMessage.pb.h" using namespace iot_net; using namespace iot_public; using namespace iot_idl; +#define CN_JSON_KEY_RTUNAME "rtu_name" + CFesRxControlCmdThread::CFesRxControlCmdThread(int iDomainID, int iAppID ,void* FesBaseAddr): -CTimerThreadBase("FesRxControlCmdThread",20) +CTimerThreadBase("FesRxControlCmdThread",0) { m_ptrRxCommunicator = new CMbCommunicator("FesRxControlCmdThread"); m_pRxData = NULL; @@ -63,41 +64,53 @@ int CFesRxControlCmdThread::beforeExecute() */ void CFesRxControlCmdThread::execute() { - std::string RecvStr; - - if(m_ptrRxCommunicator==NULL) + if(m_ptrRxCommunicator==NULL) + { + m_nRunPeriodMsec = 100; //<防止异常时线程死循环 + LOGERROR("CFesRxControlCmdThread::execute m_ptrRxCommunicator is null"); return; + } //接收消息 CMbMessage msgRcv; int nMsgType; - if (m_ptrRxCommunicator->recvMsg(msgRcv)) + if (m_ptrRxCommunicator->recvMsg(msgRcv,100)) //< 通过接收消息超时防止线程空转 { + //std::string RecvStr; nMsgType = msgRcv.getMsgType(); - LOGDEBUG("Received a message: nMsgType=%d\n",nMsgType); - RecvStr.resize(msgRcv.getDataSize()+1); - memcpy((void*)RecvStr.c_str(),(void *)msgRcv.getDataPtr(),msgRcv.getDataSize()); + LOGTRACE("Received a message: nMsgType=%d\n",nMsgType); + //RecvStr.resize(msgRcv.getDataSize()+1); + //((void*)RecvStr.c_str(),(void *)msgRcv.getDataPtr(),msgRcv.getDataSize()); + switch (nMsgType) { case MT_FES_DO_SELECT: case MT_FES_DO_EXECUTE: case MT_FES_DO_CANCEL: case MT_FES_DO_PREVENT: - RxDoControl(RecvStr,nMsgType); + RxDoControl(msgRcv.getDataPtr(), msgRcv.getDataSize(),nMsgType); break; case MT_FES_AO_EXECUTE: - RxAoControl(RecvStr,nMsgType); + RxAoControl(msgRcv.getDataPtr(), msgRcv.getDataSize(),nMsgType); break; + case MT_FES_MO_SELECT: case MT_FES_MO_EXECUTE: - RxMoControl(RecvStr,nMsgType); + case MT_FES_MO_CANCEL: + RxMoControl(msgRcv.getDataPtr(), msgRcv.getDataSize(),nMsgType); break; case MT_FES_SETTING_READ: case MT_FES_SETTING_DOWN: case MT_FES_SETTING_ACK: - RxSettingControl(RecvStr,nMsgType); + RxSettingControl(msgRcv.getDataPtr(), msgRcv.getDataSize(),nMsgType); break; case MT_FES_DEFINE_CMD: - RxDefCmdControl(RecvStr); + RxDefCmdControl(msgRcv.getDataPtr(), msgRcv.getDataSize()); + break; + case MT_FES_BATCH_PNT_CMD: + RxBatchPntCmd(msgRcv.getDataPtr(), msgRcv.getDataSize()); + break; + case MT_FES_JSON_RTU_CMD_REQ: + handleJsonFormatRtuCmd(msgRcv); break; default: LOGERROR("CFesRxControlCmdThread::execute() Error message type:%d \n",nMsgType); @@ -126,73 +139,23 @@ void CFesRxControlCmdThread::afterExecute() * @param RecvStr 接收到的消息数据 * @param msgType 消息类型 */ -void CFesRxControlCmdThread::RxDoControl(const std::string &RecvStr,const int &msgType) +void CFesRxControlCmdThread::RxDoControl(const void* data,size_t dataSize,const int &msgType) { - SFesRxDoCmd cmd; - CFesRtuPtr ptrCFesRtu; - SFesDoRequestPkg DoReqPkg; + boost::ignore_unused_variable_warning(msgType); if(m_ptrCFesBase==NULL) + { return; - - // get protocbuf data - memset(&cmd,0,sizeof(SFesRxDoCmd)); - DoReqPkg.ParseFromString(RecvStr); - strcpy(cmd.TableName,(const char *)DoReqPkg.strapptablename().c_str()); - strcpy(cmd.ColumnName,(const char *)DoReqPkg.strappcolumnname().c_str()); - strcpy(cmd.TagName,(const char *)DoReqPkg.strapptagname().c_str()); - strcpy(cmd.RtuName,(const char *)DoReqPkg.strrtuname().c_str()); - cmd.PointID = DoReqPkg.norder(); - cmd.iValue = DoReqPkg.naction(); - switch(msgType) - { - case MT_FES_DO_SELECT: - cmd.CtrlActType = CN_ControlSelect; - break; - case MT_FES_DO_CANCEL: - cmd.CtrlActType = CN_ControlAbort; - break; - case MT_FES_DO_PREVENT: - cmd.CtrlActType = CN_ControlPrevent; - break; - case MT_FES_DO_EXECUTE: - cmd.CtrlActType = CN_ControlExecute; - break; - default: - LOGERROR("CFesRxControlCmdThread::RxDoControl invaild msgType:%d ",msgType); - break; - break; } - cmd.TagtState = DoReqPkg.niftagtstate(); - if(DoReqPkg.has_lpara1()==true) - cmd.Param1 = DoReqPkg.lpara1(); - if(DoReqPkg.has_lpara2()==true) - cmd.Param2 = DoReqPkg.lpara2(); - if(DoReqPkg.has_fpara()==true) - cmd.Param1 = DoReqPkg.fpara(); - if(DoReqPkg.has_strpara()==true) + SFesDoRequestPkg DoReqPkg; + if(!DoReqPkg.ParseFromArray(data,static_cast(dataSize))) { - int strLen; - if(DoReqPkg.strpara().size()>(CN_FesControlStrParamSize-1)) - strLen = CN_FesControlStrParamSize-1; - else - strLen = DoReqPkg.strpara().size(); - memcpy(cmd.strParam,(const char *)DoReqPkg.strpara().c_str(),strLen); - } - - ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); - if(ptrCFesRtu!=NULL) - { - cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-3-4 thxiao 转发规约需要RtuNo,所以此处加上。 - LOGDEBUG("RxDoControl() RTUNo:%d PointNo:%d CtrlActType:%d iValue:%d",cmd.RtuNo,cmd.PointID,cmd.CtrlActType,cmd.iValue); - ptrCFesRtu->WriteRxDoCmdBuf(1,&cmd); - } - else - { - LOGERROR("RxDoControl() can not find RTU:%s",cmd.RtuName); + LOGERROR("CFesRxControlCmdThread::RxDoControl parse recv msg failed"); + return; } + addDoControl(DoReqPkg); } /** @@ -200,63 +163,23 @@ void CFesRxControlCmdThread::RxDoControl(const std::string &RecvStr,const int &m * 接收AO控制命令，并把命令转发到RTU对应的命令缓存区 * @param RecvStr 接收到的消息数据 */ -void CFesRxControlCmdThread::RxAoControl(const std::string &RecvStr,const int &msgType) +void CFesRxControlCmdThread::RxAoControl(const void* data,size_t dataSize,const int &msgType) { - CFesRtuPtr ptrCFesRtu; - SFesRxAoCmd cmd; - SFesAoRequestPkg AoReqPkg; + boost::ignore_unused_variable_warning(msgType); if(m_ptrCFesBase==NULL) + { return; - - // get protocbuf data - memset(&cmd,0,sizeof(SFesRxAoCmd)); - AoReqPkg.ParseFromString(RecvStr); - strcpy(cmd.TableName,(const char *)AoReqPkg.strapptablename().c_str()); - strcpy(cmd.ColumnName,(const char *)AoReqPkg.strappcolumnname().c_str()); - strcpy(cmd.TagName,(const char *)AoReqPkg.strapptagname().c_str()); - strcpy(cmd.RtuName,(const char *)AoReqPkg.strrtuname().c_str()); - cmd.PointID = AoReqPkg.norder(); - cmd.fValue = AoReqPkg.fvalue(); - //cmd.CtrlActType = AoReqPkg.nctrltype(); - - switch(msgType) - { - case MT_FES_AO_EXECUTE: - cmd.CtrlActType = CN_ControlExecute; - break; - default: - LOGERROR("CFesRxControlCmdThread::RxDoControl invaild msgType:%d ",msgType); - break; } - cmd.TagtState = AoReqPkg.niftagtstate(); - if(AoReqPkg.has_lpara1()==true) - cmd.Param1 = AoReqPkg.lpara1(); - if(AoReqPkg.has_lpara2()==true) - cmd.Param2 = AoReqPkg.lpara2(); - if(AoReqPkg.has_fpara()==true) - cmd.Param1 = AoReqPkg.fpara(); - if(AoReqPkg.has_strpara()==true) + SFesAoRequestPkg AoReqPkg; + if(!AoReqPkg.ParseFromArray(data,static_cast(dataSize))) { - int strLen; - if(AoReqPkg.strpara().size()>(CN_FesControlStrParamSize-1)) - strLen = CN_FesControlStrParamSize-1; - else - strLen = AoReqPkg.strpara().size(); - memcpy(cmd.strParam,(const char *)AoReqPkg.strpara().c_str(),strLen); + LOGERROR("CFesRxControlCmdThread::RxAoControl parse recv msg failed"); + return; } - ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); - if(ptrCFesRtu!=NULL) - { - cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-03-18 thxiao 转发规约需要RtuNo,所以此处加上。 - ptrCFesRtu->WriteRxAoCmdBuf(1,&cmd); - } - else - { - LOGERROR("CFesRxControlCmdThread::RxAoControl can not find RTU:%s",cmd.RtuName); - } + addAoControl(AoReqPkg); } /** @@ -264,71 +187,23 @@ void CFesRxControlCmdThread::RxAoControl(const std::string &RecvStr,const int &m * 接收MO控制命令，并把命令转发到RTU对应的命令缓存区 * @param RecvStr 接收到的消息数据 */ -void CFesRxControlCmdThread::RxMoControl(const std::string &RecvStr,const int &msgType) +void CFesRxControlCmdThread::RxMoControl(const void* data,size_t dataSize,const int &msgType) { - CFesRtuPtr ptrCFesRtu; - SFesRxMoCmd cmd; - SFesMoRequestPkg MoReqPkg; + boost::ignore_unused_variable_warning(msgType); if(m_ptrCFesBase==NULL) + { return; - - // get protocbuf data - memset(&cmd,0,sizeof(cmd)); - MoReqPkg.ParseFromString(RecvStr); - strcpy(cmd.TableName,(const char *)MoReqPkg.strapptablename().c_str()); - strcpy(cmd.ColumnName,(const char *)MoReqPkg.strappcolumnname().c_str()); - strcpy(cmd.TagName,(const char *)MoReqPkg.strapptagname().c_str()); - strcpy(cmd.RtuName,(const char *)MoReqPkg.strrtuname().c_str()); - cmd.PointID = MoReqPkg.norder(); - cmd.iValue = MoReqPkg.nvalue(); - //cmd.CtrlActType = MoReqPkg.nctrltype(); - switch(msgType) - { - - case MT_FES_MO_SELECT: - cmd.CtrlActType = CN_ControlSelect; - break; - case MT_FES_MO_CANCEL: - cmd.CtrlActType = CN_ControlAbort; - break; - case MT_FES_MO_PREVENT: - cmd.CtrlActType = CN_ControlPrevent; - break; - case MT_FES_MO_EXECUTE: - cmd.CtrlActType = CN_ControlExecute; - break; - default: - LOGERROR("CFesRxControlCmdThread::RxDoControl invaild msgType:%d ",msgType); - break; } - cmd.TagtState = MoReqPkg.niftagtstate(); - if(MoReqPkg.has_lpara1()==true) - cmd.Param1 = MoReqPkg.lpara1(); - if(MoReqPkg.has_lpara2()==true) - cmd.Param2 = MoReqPkg.lpara2(); - if(MoReqPkg.has_fpara()==true) - cmd.Param1 = MoReqPkg.fpara(); - if(MoReqPkg.has_strpara()==true) + SFesMoRequestPkg MoReqPkg; + if(!MoReqPkg.ParseFromArray(data,static_cast(dataSize))) { - int strLen; - if(MoReqPkg.strpara().size()>(CN_FesControlStrParamSize-1)) - strLen = CN_FesControlStrParamSize-1; - else - strLen = MoReqPkg.strpara().size(); - memcpy(cmd.strParam,(const char *)MoReqPkg.strpara().c_str(),strLen); - } - ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); - if(ptrCFesRtu!=NULL) - { - cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-03-18 thxiao 转发规约需要RtuNo,所以此处加上。 - ptrCFesRtu->WriteRxMoCmdBuf(1,&cmd); - } - else - { - LOGERROR("CFesRxControlCmdThread::RxMoControl can not find RTU:%s",cmd.RtuName); + LOGERROR("CFesRxControlCmdThread::RxMoControl parse recv msg failed"); + return; } + + addMoControl(MoReqPkg); } /** @@ -339,7 +214,7 @@ void CFesRxControlCmdThread::RxMoControl(const std::string &RecvStr,const int &m * @param pData 接收到的命令数据 * @param DataSize 接收到的命令数据长度 */ -void CFesRxControlCmdThread::RxSettingControl(const std::string &RecvStr,const int &msgType) +void CFesRxControlCmdThread::RxSettingControl(const void* data,size_t dataSize,const int &msgType) { int j; SFesRxSettingCmd cmd; @@ -351,7 +226,7 @@ void CFesRxControlCmdThread::RxSettingControl(const std::string &RecvStr,const i // get protocbuf data memset(&cmd,0,sizeof(SFesRxSettingCmd)); - SettingPkg.ParseFromString(RecvStr); + SettingPkg.ParseFromArray(data,static_cast(dataSize)); cmd.RtuNo = SettingPkg.nrtuno(); cmd.DevId = SettingPkg.ndevid(); @@ -406,7 +281,7 @@ void CFesRxControlCmdThread::RxSettingControl(const std::string &RecvStr,const i * @param pData 接收到的命令数据 * @param DataSize 接收到的命令数据长度 */ -void CFesRxControlCmdThread::RxDefCmdControl(const std::string &RecvStr) +void CFesRxControlCmdThread::RxDefCmdControl(const void* data,size_t dataSize) { int i,count; SFesRxDefCmd cmd; @@ -418,7 +293,7 @@ void CFesRxControlCmdThread::RxDefCmdControl(const std::string &RecvStr) // get protocbuf data //memset(&cmd,0,sizeof(SFesRxDefCmd)); - CmddefPkg.ParseFromString(RecvStr); + CmddefPkg.ParseFromArray(data,static_cast(dataSize)); strcpy(cmd.TableName,(const char *)CmddefPkg.strapptablename().c_str()); strcpy(cmd.ColumnName,(const char *)CmddefPkg.strappcolumnname().c_str()); strcpy(cmd.TagName,(const char *)CmddefPkg.strapptagname().c_str()); @@ -449,6 +324,284 @@ void CFesRxControlCmdThread::RxDefCmdControl(const std::string &RecvStr) } +void CFesRxControlCmdThread::RxBatchPntCmd(const void* data,size_t dataSize) +{ + if(m_ptrCFesBase==NULL) + { + return; + } + + SFesCtrlRequestSeq vecReq; + if(!vecReq.ParseFromArray(data,static_cast(dataSize))) + { + LOGERROR("CFesRxControlCmdThread::RxBatchPntCmd parse recv msg failed"); + return; + } + + for(int nAo = 0; nAo < vecReq.ao_seq_size(); nAo++) + { + addAoControl(vecReq.ao_seq(nAo)); + } +} + +void CFesRxControlCmdThread::addDoControl(const SFesDoRequestPkg &doReq) +{ + SFesRxDoCmd cmd; + strcpy(cmd.TableName,(const char *)doReq.strapptablename().c_str()); + strcpy(cmd.ColumnName,(const char *)doReq.strappcolumnname().c_str()); + strcpy(cmd.TagName,(const char *)doReq.strapptagname().c_str()); + strcpy(cmd.RtuName,(const char *)doReq.strrtuname().c_str()); + cmd.PointID = doReq.norder(); + cmd.iValue = doReq.naction(); + //DoReqPkg.nctrltype()的值与msgType一致 + switch(doReq.nctrltype()) + { + case MT_FES_DO_SELECT: + cmd.CtrlActType = CN_ControlSelect; + break; + case MT_FES_DO_CANCEL: + cmd.CtrlActType = CN_ControlAbort; + break; + case MT_FES_DO_PREVENT: + cmd.CtrlActType = CN_ControlPrevent; + break; + case MT_FES_DO_EXECUTE: + cmd.CtrlActType = CN_ControlExecute; + break; + default: + LOGERROR("CFesRxControlCmdThread::addDoControl invaild msgType:%d ",doReq.nctrltype()); + return; + } + + cmd.TagtState = doReq.niftagtstate(); + if(doReq.has_lpara1()) + { + cmd.Param1 = doReq.lpara1(); + } + if(doReq.has_lpara2()) + { + cmd.Param2 = doReq.lpara2(); + } + if(doReq.has_fpara()) + { + cmd.fParam = doReq.fpara(); + } + if(doReq.has_strpara()) + { + int strLen; + if(doReq.strpara().size()>(CN_FesControlStrParamSize-1)) + strLen = CN_FesControlStrParamSize-1; + else + strLen = static_cast(doReq.strpara().size()); + memcpy(cmd.strParam,(const char *)doReq.strpara().c_str(),strLen); + } + + CFesRtuPtr ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); + if(ptrCFesRtu!=NULL) + { + cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-3-4 thxiao 转发规约需要RtuNo,所以此处加上。 + LOGTRACE("addDoControl() RTUNo:%d PointNo:%d CtrlActType:%d iValue:%d",cmd.RtuNo,cmd.PointID,cmd.CtrlActType,cmd.iValue); + ptrCFesRtu->WriteRxDoCmdBuf(1,&cmd); + } + else + { + LOGERROR("addDoControl() can not find RTU:%s",cmd.RtuName); + } +} + +void CFesRxControlCmdThread::addAoControl(const iot_idl::SFesAoRequestPkg &aoReq) +{ + SFesRxAoCmd cmd; + strcpy(cmd.TableName,(const char *)aoReq.strapptablename().c_str()); + strcpy(cmd.ColumnName,(const char *)aoReq.strappcolumnname().c_str()); + strcpy(cmd.TagName,(const char *)aoReq.strapptagname().c_str()); + strcpy(cmd.RtuName,(const char *)aoReq.strrtuname().c_str()); + cmd.PointID = aoReq.norder(); + cmd.fValue = aoReq.fvalue(); + //aoReq.nctrltype(); //控制类型：选择、执行、取消，与消息类型一致 + + switch(aoReq.nctrltype()) + { + case MT_FES_AO_EXECUTE: + cmd.CtrlActType = CN_ControlExecute; + break; + default: + LOGERROR("CFesRxControlCmdThread::addAoControl invaild msgType:%d ",aoReq.nctrltype()); + return; + } + + cmd.TagtState = aoReq.niftagtstate(); + if(aoReq.has_lpara1()) + { + cmd.Param1 = aoReq.lpara1(); + } + if(aoReq.has_lpara2()) + { + cmd.Param2 = aoReq.lpara2(); + } + if(aoReq.has_fpara()) + { + cmd.fParam = aoReq.fpara(); + } + if(aoReq.has_strpara()) + { + int strLen; + if(aoReq.strpara().size()>(CN_FesControlStrParamSize-1)) + strLen = CN_FesControlStrParamSize-1; + else + strLen = static_cast(aoReq.strpara().size()); + memcpy(cmd.strParam,(const char *)aoReq.strpara().c_str(),strLen); + } + + CFesRtuPtr ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); + if(ptrCFesRtu != NULL) + { + cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-03-18 thxiao 转发规约需要RtuNo,所以此处加上。 + ptrCFesRtu->WriteRxAoCmdBuf(1,&cmd); + } + else + { + LOGERROR("CFesRxControlCmdThread::addAoControl can not find RTU:%s",cmd.RtuName); + } +} + +void CFesRxControlCmdThread::addMoControl(const SFesMoRequestPkg &moReq) +{ + SFesRxMoCmd cmd; + strcpy(cmd.TableName,(const char *)moReq.strapptablename().c_str()); + strcpy(cmd.ColumnName,(const char *)moReq.strappcolumnname().c_str()); + strcpy(cmd.TagName,(const char *)moReq.strapptagname().c_str()); + strcpy(cmd.RtuName,(const char *)moReq.strrtuname().c_str()); + cmd.PointID = moReq.norder(); + cmd.iValue = moReq.nvalue(); + //< moReq.nctrltype() 与消息类型一致 + switch(moReq.nctrltype()) + { + case MT_FES_MO_SELECT: + cmd.CtrlActType = CN_ControlSelect; + break; + case MT_FES_MO_CANCEL: + cmd.CtrlActType = CN_ControlAbort; + break; + case MT_FES_MO_PREVENT: + cmd.CtrlActType = CN_ControlPrevent; + break; + case MT_FES_MO_EXECUTE: + cmd.CtrlActType = CN_ControlExecute; + break; + default: + LOGERROR("CFesRxControlCmdThread::RxDoControl invaild msgType:%d ",moReq.nctrltype()); + return; + } + + cmd.TagtState = moReq.niftagtstate(); + if(moReq.has_lpara1()) + { + cmd.Param1 = moReq.lpara1(); + } + if(moReq.has_lpara2()) + { + cmd.Param2 = moReq.lpara2(); + } + if(moReq.has_fpara()) + { + cmd.fParam = moReq.fpara(); + } + if(moReq.has_strpara()) + { + int strLen; + if(moReq.strpara().size()>(CN_FesControlStrParamSize-1)) + strLen = CN_FesControlStrParamSize-1; + else + strLen = static_cast(moReq.strpara().size()); + memcpy(cmd.strParam,(const char *)moReq.strpara().c_str(),strLen); + } + CFesRtuPtr ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(cmd.RtuName); + if(ptrCFesRtu!=NULL) + { + cmd.RtuNo = ptrCFesRtu->m_Param.RtuNo;//2019-03-18 thxiao 转发规约需要RtuNo,所以此处加上。 + ptrCFesRtu->WriteRxMoCmdBuf(1,&cmd); + } + else + { + LOGERROR("CFesRxControlCmdThread::addMoControl can not find RTU:%s",cmd.RtuName); + } +} + +void CFesRxControlCmdThread::handleJsonFormatRtuCmd(const CMbMessage &stMsg) +{ + LOGTRACE("handleJsonFormatRtuCmd: recv json cmd=%s",stMsg.printInfoToStr().c_str()); + + if(m_ptrCFesBase==NULL) + { + LOGERROR("m_ptrCFesBase is null"); + return; + } + + rapidjson::Document doc; + if( doc.Parse((const char *)stMsg.getDataPtr(),stMsg.getDataSize()).HasParseError() ) + { + string strMsg((const char*)stMsg.getDataPtr(),stMsg.getDataSize()); + LOGERROR("handleJsonFormatCmd: parse json cmd failed ,error=%d. cmd=\n%s", + doc.GetParseError(),strMsg.c_str()); + return; + } + + if(doc.IsObject()) + { + addJsonFormatRtuCmd(doc); + } + else if(doc.IsArray()) + { + for(size_t i = 0; i < doc.Size();i++) + { + const rapidjson::Value& arrValue = doc[i]; + if(arrValue.IsObject()) + { + addJsonFormatRtuCmd(arrValue); + } + else + { + LOGERROR("handleJsonFormatCmd: the element is not object format."); + } + } + } + else + { + string strMsg((const char *)stMsg.getDataPtr(),stMsg.getDataSize()); + LOGERROR("handleJsonFormatCmd: invalid json format.str=\n%s",strMsg.c_str()); + } +} + +void CFesRxControlCmdThread::addJsonFormatRtuCmd(const rapidjson::Value &value) +{ + const rapidjson::Value::ConstMemberIterator &iterInfo = value.FindMember(CN_JSON_KEY_RTUNAME); + if(iterInfo == value.MemberEnd()) + { + LOGERROR("addJsonFormatRtuCmd: has not key : %s",CN_JSON_KEY_RTUNAME); + return; + } + + const rapidjson::Value& rtuValue = iterInfo->value; + + if(!rtuValue.IsString()) + { + LOGERROR("addJsonFormatRtuCmd: rtu_name is not a string. type=%d",rtuValue.GetType()); + return; + } + + string strRtuName = rtuValue.GetString(); + CFesRtuPtr ptrCFesRtu = m_ptrCFesBase->GetRtuDataByRtuTag(const_cast(strRtuName.c_str())); + if(ptrCFesRtu != NULL) + { + LOGDEBUG("addJsonFormatRtuCmd: recv json cmd. rtu_name=%s",strRtuName.c_str()); + ptrCFesRtu->writeJsonFormatReqCmd(value); + } + else + { + LOGERROR("addJsonFormatRtuCmd can not find RTU:%s",strRtuName.c_str()); + } +} //订阅消息通道 int CFesRxControlCmdThread::subMessage() diff --git a/product/src/fes/fes/FesRxControlCmdThread.h b/product/src/fes/fes/FesRxControlCmdThread.h index 9ff15283..9461ccf4 100644 --- a/product/src/fes/fes/FesRxControlCmdThread.h +++ b/product/src/fes/fes/FesRxControlCmdThread.h @@ -3,8 +3,18 @@ #include "FesDef.h" #include "FesBase.h" #include "net/net_msg_bus_api/MsgBusApi.h" +#include "FesMessage.pb.h" -using namespace iot_net; +#ifdef _MSC_VER +#pragma warning(push) +#pragma warning(disable: 4003) +#endif + +#include "rapidjson/document.h" + +#ifdef _MSC_VER +#pragma warning(pop) +#endif class CFesRxControlCmdThread : public iot_public::CTimerThreadBase { @@ -31,19 +41,26 @@ public: int unsubMessage(); private: - CMbCommunicator *m_ptrRxCommunicator; + iot_net::CMbCommunicator *m_ptrRxCommunicator; byte *m_pRxData; int m_iDomainID; int m_iAppID; int m_iChannelID; CFesBase *m_ptrCFesBase; - void RxDoControl(const std::string &RecvStr,const int &msgType); - void RxAoControl(const std::string &RecvStr,const int &msgType); - void RxMoControl(const std::string &RecvStr,const int &msgType); - void RxSettingControl(const std::string &RecvStr,const int &msgType); - void RxDefCmdControl(const std::string &RecvStr); + void RxDoControl(const void* data,size_t dataSize,const int &msgType); + void RxAoControl(const void* data,size_t dataSize,const int &msgType); + void RxMoControl(const void* data,size_t dataSize,const int &msgType); + void RxSettingControl(const void* data,size_t dataSize,const int &msgType); + void RxDefCmdControl(const void* data,size_t dataSize); + void RxBatchPntCmd(const void* data,size_t dataSize); + void addDoControl(const iot_idl::SFesDoRequestPkg &doReq); + void addAoControl(const iot_idl::SFesAoRequestPkg &aoReq); + void addMoControl(const iot_idl::SFesMoRequestPkg &moReq); + + void handleJsonFormatRtuCmd(const iot_net::CMbMessage &stMsg); + void addJsonFormatRtuCmd(const rapidjson::Value &value); }; typedef boost::shared_ptr CFesRxControlCmdThreadPtr; diff --git a/product/src/fes/fes/FesRxDPDataThread.cpp b/product/src/fes/fes/FesRxDPDataThread.cpp index f98fffd4..35964cd0 100644 --- a/product/src/fes/fes/FesRxDPDataThread.cpp +++ b/product/src/fes/fes/FesRxDPDataThread.cpp @@ -13,7 +13,7 @@ using namespace iot_idl; using namespace iot_service; CFesRxDPDataThread::CFesRxDPDataThread(int iDomainID, int iAppID ,void* FesBaseAddr): -CTimerThreadBase("FesRxDPDataThread",30) +CTimerThreadBase("FesRxDPDataThread",0) { m_ptrRxCommunicator = new CMbCommunicator("FesRxDPDataThread"); m_iDomainID = iDomainID; @@ -132,7 +132,6 @@ int CFesRxDPDataThread::unsubMessage() */ int CFesRxDPDataThread::readFromBus() { - std::string RecvStr; CMbMessage msgRcv; if (m_ptrRxCommunicator == NULL) @@ -140,14 +139,14 @@ int CFesRxDPDataThread::readFromBus() //1.从消息总线接收消息，没有消息返回FALSE //==================================================================================== - if (m_ptrRxCommunicator->recvMsg(msgRcv)) + if (m_ptrRxCommunicator->recvMsg(msgRcv,100)) { int nMessageType = msgRcv.getMsgType(); //LOGDEBUG("readFromBus nMessageType=%d ", nMessageType); if (nMessageType == MT_DP_CHANGE_DATA) { SRealTimeDataPkg ChangeDataPkg; - if (true == ChangeDataPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize())) + if (true == ChangeDataPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) )) { if (iotFailed == RxDiChangeData(ChangeDataPkg)) { @@ -200,12 +199,10 @@ int CFesRxDPDataThread::RxDiChangeData(const SRealTimeDataPkg & ChangeDataPkg) if (nChangeNum > 0) { mSec = getUTCTimeMsec(); - SDiRealTimeData diStru; - std::string strTagName = ""; for (i = 0; i < nChangeNum; i++) { - diStru = ChangeDataPkg.stdirtd(i); - strTagName = diStru.strtagname(); + const SDiRealTimeData &diStru = ChangeDataPkg.stdirtd(i); + const std::string &strTagName = diStru.strtagname(); if ((pPubDi = m_ptrCFesBase->GetFesFwPubDpDi(strTagName)) == NULL) continue; @@ -282,56 +279,45 @@ int CFesRxDPDataThread::RxDiChangeData(const SRealTimeDataPkg & ChangeDataPkg) */ int CFesRxDPDataThread::RxAiChangeData(const SRealTimeDataPkg & ChangeDataPkg) { - int i,j; CFesRtuPtr ptrFwRtu; SFesFwChgAi ChangeInfo; SFesFwPubAi *pPubAi = NULL; - uint64 mSec; - - try - { - int nChangeNum = ChangeDataPkg.stairtd_size(); - if (nChangeNum > 0) - { - mSec = getUTCTimeMsec(); - ::iot_idl::SAiRealTimeData aiStru; - std::string strTagName = ""; - for (i = 0; i < nChangeNum; i++) - { - aiStru = ChangeDataPkg.stairtd(i); - strTagName = aiStru.strtagname(); + uint64 mSec = getUTCTimeMsec(); + std::string strTagName = ""; - if ((pPubAi = m_ptrCFesBase->GetFesFwPubDpAi(strTagName)) == NULL) - continue; + int nChangeNum = ChangeDataPkg.stairtd_size(); + for (int i = 0; i < nChangeNum; i++) + { + const iot_idl::SAiRealTimeData &aiStru = ChangeDataPkg.stairtd(i); + strTagName = aiStru.strtagname(); + + if ((pPubAi = m_ptrCFesBase->GetFesFwPubDpAi(strTagName)) == NULL) + continue; + + pPubAi->Value = aiStru.fvalue(); + pPubAi->Status = aiStru.ustatus(); + pPubAi->time = mSec; + ChangeInfo.RtuNo = pPubAi->FesRtuNo; + ChangeInfo.PointNo = pPubAi->SrcPointNo; + ChangeInfo.Status = pPubAi->Status; + ChangeInfo.time = pPubAi->time; + + float fNewValue = 0.0f; + for (int j = 0; j < pPubAi->FwMapNum; j++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAi->FwMapping[j].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAi->FwMapping[j].RemoteNo; + ChangeInfo.Value = pPubAi->Value; //< 每次要设置为原始值，因为ChangeInfo在下面可能会被修改 + + if(ptrFwRtu->UpdataFwAiValue(ChangeInfo,fNewValue,eNormalUpdate)) //< fNewValue值会被更新 + { + ChangeInfo.Value = fNewValue; + ptrFwRtu->WriteFwAiBuf(ChangeInfo); + } + } + } - pPubAi->Value = aiStru.fvalue(); - pPubAi->Status = aiStru.ustatus(); - pPubAi->time = mSec; - ChangeInfo.RtuNo = pPubAi->FesRtuNo; - ChangeInfo.PointNo = pPubAi->SrcPointNo; - ChangeInfo.Value = pPubAi->Value; - ChangeInfo.Status = pPubAi->Status; - ChangeInfo.time = pPubAi->time; - for (j = 0; j < pPubAi->FwMapNum; j++) - { - if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAi->FwMapping[j].MappingIndex)) == NULL) - continue; - ChangeInfo.RemoteNo = pPubAi->FwMapping[j].RemoteNo; - if(ptrFwRtu->UpdataFwAiValue(ChangeInfo,1)) - ptrFwRtu->WriteFwAiBuf(ChangeInfo); - } - } - } - } - catch (std::exception &ex) - { - LOGERROR("RxAiChangeData Fail,errNo=%s",ex.what()); - return iotFailed; - } - catch (...) - { - return iotFailed; - } return iotSuccess; } @@ -348,54 +334,42 @@ int CFesRxDPDataThread::RxAccChangeData(const SRealTimeDataPkg & ChangeDataPkg) CFesRtuPtr ptrFwRtu; SFesFwChgAcc ChangeInfo; SFesFwPubAcc *pPubAcc = NULL; - uint64 mSec; - - try - { - int nChangeNum = ChangeDataPkg.stpirtd_size(); - if (nChangeNum > 0) - { - ::iot_idl::SPiRealTimeData piStru; - std::string strTagName = ""; - mSec = getUTCTimeMsec(); - for (i = 0; i < nChangeNum; i++) - { - piStru = ChangeDataPkg.stpirtd(i); - strTagName = piStru.strtagname(); + uint64 mSec = getUTCTimeMsec(); - if ((pPubAcc = m_ptrCFesBase->GetFesFwPubDpAcc(strTagName)) == NULL) - continue; + int nChangeNum = ChangeDataPkg.stpirtd_size(); + for (i = 0; i < nChangeNum; i++) + { + const iot_idl::SPiRealTimeData &piStru = ChangeDataPkg.stpirtd(i); + const std::string &strTagName = piStru.strtagname(); + + if ((pPubAcc = m_ptrCFesBase->GetFesFwPubDpAcc(strTagName)) == NULL) + continue; + + pPubAcc->Value = piStru.dvalue(); + pPubAcc->Status = piStru.ustatus(); + pPubAcc->time = mSec; + ChangeInfo.RtuNo = pPubAcc->FesRtuNo; + ChangeInfo.PointNo = pPubAcc->SrcPointNo; + ChangeInfo.Status = pPubAcc->Status; + ChangeInfo.time = pPubAcc->time; + + double dNewValue = 0.0; + for (j = 0; j < pPubAcc->FwMapNum; j++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAcc->FwMapping[j].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAcc->FwMapping[j].RemoteNo; + ChangeInfo.Value = pPubAcc->Value; //< 每次要重新赋值 + + if(ptrFwRtu->UpdataFwAccValue(ChangeInfo,dNewValue,eNormalUpdate)) + { + ChangeInfo.Value = dNewValue; + ptrFwRtu->WriteFwAccBuf(ChangeInfo); + } + } + } - pPubAcc->Value = piStru.dvalue(); - pPubAcc->Status = piStru.ustatus(); - pPubAcc->time = mSec; - ChangeInfo.RtuNo = pPubAcc->FesRtuNo; - ChangeInfo.PointNo = pPubAcc->SrcPointNo; - ChangeInfo.Value = pPubAcc->Value; - ChangeInfo.Status = pPubAcc->Status; - ChangeInfo.time = pPubAcc->time; - for (j = 0; j < pPubAcc->FwMapNum; j++) - { - if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAcc->FwMapping[j].MappingIndex)) == NULL) - continue; - ChangeInfo.RemoteNo = pPubAcc->FwMapping[j].RemoteNo; - if(ptrFwRtu->UpdataFwAccValue(ChangeInfo,1)) - ptrFwRtu->WriteFwAccBuf(ChangeInfo); - } - } - } - } - catch (std::exception &ex) - { - LOGERROR("RxAccChangeData Fail,errNo=%s",ex.what()); - return iotFailed; - } - catch (...) - { - return iotFailed; - } return iotSuccess; - } /** @@ -407,55 +381,43 @@ int CFesRxDPDataThread::RxAccChangeData(const SRealTimeDataPkg & ChangeDataPkg) */ int CFesRxDPDataThread::RxMiChangeData(const SRealTimeDataPkg & ChangeDataPkg) { - int j; CFesRtuPtr ptrFwRtu; SFesFwChgMi ChangeInfo; SFesFwPubMi *pPubMi = NULL; - uint64 mSec; + uint64 mSec = getUTCTimeMsec(); - try - { - int nChangeNum = ChangeDataPkg.stmirtd_size(); - if (nChangeNum > 0) - { - ::iot_idl::SMiRealTimeData miStru; - std::string strTagName = ""; - mSec = getUTCTimeMsec(); - for (int i = 0; i < nChangeNum; i++) - { - miStru = ChangeDataPkg.stmirtd(i); - strTagName = miStru.strtagname(); - if ((pPubMi = m_ptrCFesBase->GetFesFwPubDpMi(strTagName)) == NULL) - continue; + int nChangeNum = ChangeDataPkg.stmirtd_size(); + for (int i = 0; i < nChangeNum; i++) + { + const iot_idl::SMiRealTimeData &miStru = ChangeDataPkg.stmirtd(i); + const std::string &strTagName = miStru.strtagname(); + if ((pPubMi = m_ptrCFesBase->GetFesFwPubDpMi(strTagName)) == NULL) + continue; + + pPubMi->Value = miStru.nvalue(); + pPubMi->Status = miStru.ustatus(); + pPubMi->time = mSec; + ChangeInfo.RtuNo = pPubMi->FesRtuNo; + ChangeInfo.PointNo = pPubMi->SrcPointNo; + ChangeInfo.Status = pPubMi->Status; + ChangeInfo.time = pPubMi->time; + + int nNewValue = 0; + for (int j = 0; j < pPubMi->FwMapNum; j++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubMi->FwMapping[j].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubMi->FwMapping[j].RemoteNo; + ChangeInfo.Value = pPubMi->Value; + + if(ptrFwRtu->UpdataFwMiValue(ChangeInfo,nNewValue,eNormalUpdate)) + { + ChangeInfo.Value = nNewValue; + ptrFwRtu->WriteFwMiBuf(ChangeInfo); + } + } + } - pPubMi->Value = miStru.nvalue(); - pPubMi->Status = miStru.ustatus(); - pPubMi->time = mSec; - ChangeInfo.RtuNo = pPubMi->FesRtuNo; - ChangeInfo.PointNo = pPubMi->SrcPointNo; - ChangeInfo.Value = pPubMi->Value; - ChangeInfo.Status = pPubMi->Status; - ChangeInfo.time = pPubMi->time; - for (j = 0; j < pPubMi->FwMapNum; j++) - { - if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubMi->FwMapping[j].MappingIndex)) == NULL) - continue; - ChangeInfo.RemoteNo = pPubMi->FwMapping[j].RemoteNo; - if(ptrFwRtu->UpdataFwMiValue(ChangeInfo,1)) - ptrFwRtu->WriteFwMiBuf(ChangeInfo); - } - } - } - } - catch (std::exception &ex) - { - LOGERROR("RxMiChangeData Fail,errNo=%s",ex.what()); - return iotFailed; - } - catch (...) - { - return iotFailed; - } return iotSuccess; } diff --git a/product/src/fes/fes/FesRxDataUpDateThread.cpp b/product/src/fes/fes/FesRxDataUpDateThread.cpp index 92f080b0..e387db4c 100644 --- a/product/src/fes/fes/FesRxDataUpDateThread.cpp +++ b/product/src/fes/fes/FesRxDataUpDateThread.cpp @@ -289,7 +289,7 @@ void CFesRxDataUpDateThread::DiAllResp() continue; memset(m_pDiValue, 0, ptrCFesRtu->m_MaxDiPoints * sizeof(SFesAllDi));//2023-02-22 thxiao 清除内存，避免点标签赋值不正确 - retNum = ptrCFesRtu->ReadDiValue(ptrCFesRtu->m_MaxDiPoints,m_pDiValue); + retNum = ptrCFesRtu->ReadDiValue(ptrCFesRtu->m_MaxDiPoints,m_pDiValue); //fill the protobuf data //LOGDEBUG("CFesRxDataUpDateThread::DiAllResp num=%d",retNum); for(j=0;jm_MaxAccPoints * sizeof(SFesAllAcc));//2023-02-22 thxiao 清除内存，避免点标签赋值不正确 - retNum = ptrCFesRtu->ReadAccValue(ptrCFesRtu->m_MaxAccPoints,m_pAccValue); + retNum = ptrCFesRtu->ReadAccValue(ptrCFesRtu->m_MaxAccPoints,m_pAccValue); //fill the protobuf data for(j=0;jset_strappcolumnname(pAcc->ColumnName); pAccWithoutTm->set_strapptagname(pAcc->TagName); pAccWithoutTm->set_ustatus(pAcc->Status); - pAccWithoutTm->set_nvalue(pAcc->Value); + pAccWithoutTm->set_dvalue(pAcc->Value); count++; } @@ -944,7 +944,7 @@ void CFesRxDataUpDateThread::AccChangeStatusReport() pAccWithoutTm->set_strappcolumnname(pAcc->ColumnName); pAccWithoutTm->set_strapptagname(pAcc->TagName); pAccWithoutTm->set_ustatus(pAcc->Status); - pAccWithoutTm->set_nvalue(pAcc->Value); + pAccWithoutTm->set_dvalue(pAcc->Value); count++; } diff --git a/product/src/fes/fes/FesRxFesDataThread.cpp b/product/src/fes/fes/FesRxFesDataThread.cpp index 988d7e60..c96640e0 100644 --- a/product/src/fes/fes/FesRxFesDataThread.cpp +++ b/product/src/fes/fes/FesRxFesDataThread.cpp @@ -3,10 +3,6 @@ @brief 接收非本FES的AI\DI\ACC\MI数据 @author thxiao - 2023-11-25 tthxiao - 长江存储项目需要从多个PSCADA把数据转发到PSCADA1，接收的消息很多，来不及处理，导致消息堆积，内存不断增长。 - 改为不停接收消息，分多个线程处理数据。接收消息满时，把老消息删除，保证内存不增长。 - */ #include "FesRxFesDataThread.h" #include "MessageChannel.h" @@ -15,21 +11,21 @@ using namespace iot_net; using namespace iot_public; using namespace iot_idl; -CFesRxFesDataThread::CFesRxFesDataThread(int iDomainID, int iAppID ,void* FesBaseAddr, CPacketQueuePtr ptrPacketQueue): -CTimerThreadBase("FesRxFesDataThread",0) +CFesRxFesDataThread::CFesRxFesDataThread(int iDomainID, int iAppID ,void* FesBaseAddr): +CTimerThreadBase("FesRxFesDataThread",30) { m_ptrRxCommunicator = new CMbCommunicator("FesRxFesDataThread"); m_iDomainID = iDomainID; m_iAppID= iAppID; m_ptrCFesBase = (CFesBase*)FesBaseAddr; - m_ptrPacketQueue = ptrPacketQueue; } CFesRxFesDataThread::~CFesRxFesDataThread() { delete m_ptrRxCommunicator; m_ptrRxCommunicator = NULL; - m_ptrPacketQueue.reset(); + + } /** @@ -132,143 +128,585 @@ bool CFesRxFesDataThread::readFromBus() { std::string RecvStr; CMbMessage msgRcv; - int nMsgType,count; - bool bRetCode = false; + int nMsgType; if (m_ptrRxCommunicator == NULL) return false; - count = 0; - while (count < 20) + //1.从消息总线接收消息，没有消息返回FALSE + //==================================================================================== + if (m_ptrRxCommunicator->recvMsg(msgRcv)) { - count++; - //1.从消息总线接收消息，没有消息返回FALSE - if (m_ptrRxCommunicator->recvMsg(msgRcv, 50) == false) - { - continue; - } nMsgType = msgRcv.getMsgType(); - switch (nMsgType) + switch(nMsgType) { case MT_FES_DI_CHANGE: { SFesChangeDiPkg ChangeDiPkg; - bRetCode = ChangeDiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::ChangeDiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesChangeDigPkg(ChangeDiPkg); - break; + ChangeDiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxDiChangeData(ChangeDiPkg); } + break; case MT_FES_DI_UPDATE: { SFesUpdateDiPkg UpdateDiPkg; - bRetCode = UpdateDiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::UpdateDiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesUpdateDigPkg(UpdateDiPkg); - break; + UpdateDiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxDiUpdataData(UpdateDiPkg); } + break; case MT_FES_SOE_EVENT: { SFesSoeEventPkg SoePkg; - bRetCode = SoePkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::SoePkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesSoeEventPkg(SoePkg); - break; + SoePkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxSOEData(SoePkg); } + break; case MT_FES_AI_CHANGE: { SFesChangeAiPkg ChangeAiPkg; - bRetCode = ChangeAiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::ChangeAiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesChangeAnaPkg(ChangeAiPkg); - break; - + ChangeAiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxAiChangeData(ChangeAiPkg); } + break; case MT_FES_AI_UPDATE: { SFesUpdateAiPkg UpdateAiPkg; - UpdateAiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::UpdateAiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesUpdateAnaPkg(UpdateAiPkg); - break; + UpdateAiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxAiUpdataData(UpdateAiPkg); } + break; case MT_FES_PI_CHANGE: { - SFesChangePiPkg ChangeAccPkg; - bRetCode = ChangeAccPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("parseFesPackage::ChangeAccPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesChangeAccPkg(ChangeAccPkg); - break; + SFesChangePiPkg ChanageAccPkg; + ChanageAccPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxAccChangeData(ChanageAccPkg); } + break; case MT_FES_PI_UPDATE: { SFesUpdatePiPkg UpdateAccPkg; - bRetCode = UpdateAccPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::UpdateAccPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesUpdateAccPkg(UpdateAccPkg); - break; + UpdateAccPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxAccUpdataData(UpdateAccPkg); } + break; case MT_FES_MI_CHANGE: { - SFesChangeMiPkg ChangeMiPkg; - bRetCode = ChangeMiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::ChangeMiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesChangeMixPkg(ChangeMiPkg); - break; + SFesChangeMiPkg ChangeMiPkg; + ChangeMiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxMiChangeData(ChangeMiPkg); } + break; case MT_FES_MI_UPDATE: { - SFesUpdateMiPkg UpdateMiPkg; - bRetCode = UpdateMiPkg.ParseFromArray(msgRcv.getDataPtr(), msgRcv.getDataSize()); - if (!bRetCode) - { - LOGDEBUG("readFromBus::UpdateMiPkg解析错误！"); - break; - } - m_ptrPacketQueue->addFesUpdateMixPkg(UpdateMiPkg); - break; + SFesUpdateMiPkg UpdateMiPkg; + UpdateMiPkg.ParseFromArray(msgRcv.getDataPtr(), static_cast(msgRcv.getDataSize()) ); + RxMiUpdataData(UpdateMiPkg); } + break; default: - { -// LOGDEBUG("readFromBus::MsgType = %d 消息类型不支持！", nMsgType); break; } + return true; + } + return false; +} + +/** +* @brief CFesRxFesDataThread::RxDiChangeData +* 接收DI变化数据。 +* +* @param stChangeDiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxDiChangeData(const SFesChangeDiPkg &ChangeDiPkg) +{ + int nChangeNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgDi ChangeInfo; + + nChangeNum = ChangeDiPkg.stdidata_size(); + + if (nChangeNum > 0) + { + LOGDEBUG("RxDiChangeData:收到变化数据报文,数目[%d],时间[%" PRId64 "].", nChangeNum, (int64)ChangeDiPkg.stdidata(0).ultime()); + } + + for (nLoop = 0; nLoop < nChangeNum; nLoop++) + { + SFesFwPubDi *pPubDi = NULL; + + const SFesDiDataWithTm &stDiData = ChangeDiPkg.stdidata(nLoop); + const std::string &TagName = stDiData.strapptagname(); + if ((pPubDi = m_ptrCFesBase->GetFesFwPubFesDi(TagName)) == NULL) + continue; + + if ((int64)stDiData.ultime() < 0) + { + LOGERROR("tag_name = %s, times = [%" PRId64 "] < 0 error!", TagName.c_str(), stDiData.ultime()); + continue; + } + pPubDi->Value = 0x01 & stDiData.nvalue(); + pPubDi->Status = 0xffff & stDiData.ustatus(); + pPubDi->time = stDiData.ultime(); + ChangeInfo.RtuNo = pPubDi->FesRtuNo; + ChangeInfo.PointNo = pPubDi->SrcPointNo; + ChangeInfo.Value = pPubDi->Value; + ChangeInfo.Status = pPubDi->Status; + ChangeInfo.time = pPubDi->time; + for (i = 0; i < pPubDi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubDi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubDi->FwMapping[i].RemoteNo; + ptrFwRtu->WriteFwDiBuf(ChangeInfo); + ptrFwRtu->UpdataFwDiValue(ChangeInfo); + } + } +} + + +/** +* @brief CFesRxFesDataThread::RxSOEData +* 接收DI变化数据。 +* +* @param SFesSoeEventPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxSOEData(const SFesSoeEventPkg &SOEPkg) +{ + int nChangeNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwSoeEvent ChangeInfo; + + nChangeNum = SOEPkg.stsoeevent_size(); + + if (nChangeNum > 0) + { + LOGDEBUG("RxSOEData:收到变化数据报文,数目[%d],时间[%" PRId64 "].", nChangeNum, (int64)SOEPkg.stsoeevent(0).ultime()); + } + + for (nLoop = 0; nLoop < nChangeNum; nLoop++) + { + SFesFwPubDi *pPubDi = NULL; + + const SFesSoeEventInfo &stSoeEvent = SOEPkg.stsoeevent(nLoop); + const std::string &TagName = stSoeEvent.strapptagname(); + if ((pPubDi = m_ptrCFesBase->GetFesFwPubFesDi(TagName)) == NULL) + continue; + + + if ((int64)stSoeEvent.ultime() < 0) + { + LOGERROR("tag_name = %s, times = [%" PRId64 "] < 0 error!", TagName.c_str(), stSoeEvent.ultime()); + continue; + } + ChangeInfo.RtuNo = pPubDi->FesRtuNo; + ChangeInfo.PointNo = pPubDi->SrcPointNo; + ChangeInfo.Value = 0x01 & stSoeEvent.nvalue(); + ChangeInfo.Status = 0xffff & stSoeEvent.ustatus(); + ChangeInfo.time = stSoeEvent.ultime(); + //SOE事件故障描述忽略不处理 + + for (i = 0; i < pPubDi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubDi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubDi->FwMapping[i].RemoteNo; + ptrFwRtu->WriteFwSoeEventBuf(ChangeInfo); + } + + } + +} + + +/** +* @brief CFesRxFesDataThread::RxAiChangeData +* 接收AI变化数据。 +* +* @param stChangeAiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxAiChangeData(const SFesChangeAiPkg &ChangeAiPkg) +{ + int nChangeNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgAi ChangeInfo; + + nChangeNum = ChangeAiPkg.staidata_size(); + + if (nChangeNum > 0) + { + LOGTRACE("RxAiChangeData:收到变化数据报文,数目[%d],时间[%" PRId64 "].", nChangeNum, (int64)ChangeAiPkg.staidata(0).ultime()); + } + + for (nLoop = 0; nLoop < nChangeNum; nLoop++) + { + SFesFwPubAi *pPubAi = NULL; + + const SFesAiDataWithTm &stAiData = ChangeAiPkg.staidata(nLoop); + const std::string &TagName = stAiData.strapptagname(); + if ((pPubAi = m_ptrCFesBase->GetFesFwPubFesAi(TagName)) == NULL) + continue; + + if ((int64)stAiData.ultime() < 0) + { + LOGERROR("tag_name = %s, times = [%" PRId64 "]< 0 error!", TagName.c_str(), stAiData.ultime()); + continue; + } + pPubAi->Value = stAiData.fvalue(); + pPubAi->Status = stAiData.ustatus(); + pPubAi->time = stAiData.ultime(); + ChangeInfo.RtuNo = pPubAi->FesRtuNo; + ChangeInfo.PointNo = pPubAi->SrcPointNo; + ChangeInfo.Status = pPubAi->Status; + ChangeInfo.time = pPubAi->time; + + float fNewValue = 0.0f; + for (i = 0; i < pPubAi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAi->FwMapping[i].RemoteNo; + ChangeInfo.Value = pPubAi->Value; //< 每次必须重新赋值，因为ChangeInfo的Value会被更新 + + if(ptrFwRtu->UpdataFwAiValue(ChangeInfo,fNewValue,eNormalUpdate)) //< fNewValue值会被更新 + { + ChangeInfo.Value = fNewValue; + ptrFwRtu->WriteFwAiBuf(ChangeInfo); + } } } - return true; +} +/** +* @brief CFesRxFesDataThread::RxAccChangeData +* 接收ACC变化数据。 +* +* @param stChangePiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxAccChangeData(const SFesChangePiPkg &ChangeAccPkg) +{ + int nChangeNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgAcc ChangeInfo; + + nChangeNum = ChangeAccPkg.stpidata_size(); + + if (nChangeNum > 0) + { + LOGTRACE("RxAccChangeData:收到变化数据报文,数目[%d],时间[%" PRId64 "].", nChangeNum, (int64)ChangeAccPkg.stpidata(0).ultime()); + } + + for (nLoop = 0; nLoop < nChangeNum; nLoop++) + { + SFesFwPubAcc *pPubAcc = NULL; + + const SFesPiDataWithTm &stAccData = ChangeAccPkg.stpidata(nLoop); + const std::string &TagName = stAccData.strapptagname(); + if ((pPubAcc = m_ptrCFesBase->GetFesFwPubFesAcc(TagName)) == NULL) + continue; + + if ((int64)stAccData.ultime() < 0) + { + LOGERROR("tag_name = %s, times = [%" PRId64 "] < 0 error!", TagName.c_str(), stAccData.ultime()); + continue; + } + pPubAcc->Value = stAccData.dvalue(); + pPubAcc->Status = stAccData.ustatus(); + pPubAcc->time = stAccData.ultime(); + ChangeInfo.RtuNo = pPubAcc->FesRtuNo; + ChangeInfo.PointNo = pPubAcc->SrcPointNo; + ChangeInfo.Status = pPubAcc->Status; + ChangeInfo.time = pPubAcc->time; + + double dNewValue = 0.0; + for (i = 0; i < pPubAcc->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAcc->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAcc->FwMapping[i].RemoteNo; + ChangeInfo.Value = pPubAcc->Value; //< 每次要重新赋值 + + if(ptrFwRtu->UpdataFwAccValue(ChangeInfo,dNewValue,eNormalUpdate)) + { + ChangeInfo.Value = dNewValue; + ptrFwRtu->WriteFwAccBuf(ChangeInfo); + } + } + } +} + +/** +* @brief CFesRxFesDataThread::RxMiChangeData +* 接收MI变化数据。 +* +* @param stChangeMiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxMiChangeData(const SFesChangeMiPkg &ChangeMiPkg) +{ + int nChangeNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgMi ChangeInfo; + + nChangeNum = ChangeMiPkg.stmidata_size(); + if (nChangeNum > 0) + { + LOGTRACE("RxMiChangeData:收到变化数据报文,数目[%d],时间[%" PRId64 "].", nChangeNum, (int64)ChangeMiPkg.stmidata(0).ultime()); + } + + for (nLoop = 0; nLoop < nChangeNum; nLoop++) + { + SFesFwPubMi *pPubMi = NULL; + + const SFesMiDataWithTm &MiData = ChangeMiPkg.stmidata(nLoop); + const std::string &TagName = MiData.strapptagname(); + if ((pPubMi = m_ptrCFesBase->GetFesFwPubFesMi(TagName)) == NULL) + continue; + + if ((int64)MiData.ultime() < 0) + { + LOGERROR("tag_name = %s, times = [%" PRId64 "] < 0 error!", TagName.c_str(), MiData.ultime()); + continue; + } + pPubMi->Value = MiData.nvalue(); + pPubMi->Status = MiData.ustatus(); + pPubMi->time = MiData.ultime(); + ChangeInfo.RtuNo = pPubMi->FesRtuNo; + ChangeInfo.PointNo = pPubMi->SrcPointNo; + ChangeInfo.Status = pPubMi->Status; + ChangeInfo.time = pPubMi->time; + + int nNewValue = 0; + for (i = 0; i < pPubMi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubMi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubMi->FwMapping[i].RemoteNo; + ChangeInfo.Value = pPubMi->Value; //< 每次要重新赋值 + + if(ptrFwRtu->UpdataFwMiValue(ChangeInfo,nNewValue,eNormalUpdate)) + { + ChangeInfo.Value = nNewValue; + ptrFwRtu->WriteFwMiBuf(ChangeInfo); + } + } + } +} + +/** +* @brief CFesRxFesDataThread::RxDiUpdataData +* 接收DI全数据。 +* +* @param UpdateDiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxDiUpdataData(const SFesUpdateDiPkg &UpdateDiPkg) +{ + int nNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgDi ChangeInfo; + uint64 mSec; + + nNum = UpdateDiPkg.stdidata_size(); + + if (nNum > 0) + { + LOGDEBUG("RxDiChangeData:收到全数据报文,数目[%d]", nNum); + } + + mSec = getUTCTimeMsec(); + for (nLoop = 0; nLoop < nNum; nLoop++) + { + SFesFwPubDi *pPubDi = NULL; + + const SFesDiDataWithoutTm &DiData = UpdateDiPkg.stdidata(nLoop); + const std::string &strTagName = DiData.strapptagname(); + if ((pPubDi = m_ptrCFesBase->GetFesFwPubFesDi(strTagName)) == NULL) + continue; + + pPubDi->Value = 0x01 & DiData.nvalue(); + pPubDi->Status = DiData.ustatus(); + pPubDi->time = mSec; + ChangeInfo.Value = pPubDi->Value; + ChangeInfo.Status = pPubDi->Status; + ChangeInfo.time = pPubDi->time; + + for (i = 0; i < pPubDi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubDi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubDi->FwMapping[i].RemoteNo; + ptrFwRtu->UpdataFwDiValue(ChangeInfo); + } + } +} + +/** +* @brief CFesRxFesDataThread::RxAiUpdataData +* 接收Ai全数据。 +* +* @param UpdateAiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxAiUpdataData(const SFesUpdateAiPkg &UpdateAiPkg) +{ + int nNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgAi ChangeInfo; + uint64 mSec; + + nNum = UpdateAiPkg.staidata_size(); + + if (nNum > 0) + { + LOGTRACE("RxAiChangeData:收到全数据报文,数目[%d]", nNum); + } + + mSec = getUTCTimeMsec(); + for (nLoop = 0; nLoop < nNum; nLoop++) + { + SFesFwPubAi *pPubAi = NULL; + + const SFesAiDataWithoutTm &AiData = UpdateAiPkg.staidata(nLoop); + const std::string &TagName = AiData.strapptagname(); + if ((pPubAi = m_ptrCFesBase->GetFesFwPubFesAi(TagName)) == NULL) + continue; + + pPubAi->Value = AiData.fvalue(); + pPubAi->Status = AiData.ustatus(); + pPubAi->time = mSec; + ChangeInfo.Value = pPubAi->Value; + ChangeInfo.Status = pPubAi->Status; + ChangeInfo.time = pPubAi->time; + float fNewValue = 0.0f; + for (i = 0; i < pPubAi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAi->FwMapping[i].RemoteNo; + ptrFwRtu->UpdataFwAiValue(ChangeInfo,fNewValue,eWithoutDeadbandUpdate); //< fNewValue的值会被更新 + } + } +} + +/** +* @brief CFesRxFesDataThread::RxAccUpdataData +* 接收ACC全数据。 +* +* @param UpdateAccPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxAccUpdataData(const SFesUpdatePiPkg &UpdateAccPkg) +{ + int nNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgAcc ChangeInfo; + uint64 mSec; + + nNum = UpdateAccPkg.stpidata_size(); + + if (nNum > 0) + { + LOGTRACE("RxAccChangeData:收到全数据报文,数目[%d]", nNum); + } + + mSec = getUTCTimeMsec(); + for (nLoop = 0; nLoop < nNum; nLoop++) + { + SFesFwPubAcc *pPubAcc = NULL; + + const SFesPiDataWithoutTm &AccData = UpdateAccPkg.stpidata(nLoop); + const std::string &TagName = AccData.strapptagname(); + if ((pPubAcc = m_ptrCFesBase->GetFesFwPubFesAcc(TagName)) == NULL) + continue; + + pPubAcc->Value = AccData.dvalue(); + pPubAcc->Status = AccData.ustatus(); + pPubAcc->time = mSec; + ChangeInfo.Value = pPubAcc->Value; + ChangeInfo.Status = pPubAcc->Status; + ChangeInfo.time = pPubAcc->time; + + double dNewValue = 0.0; + for (i = 0; i < pPubAcc->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubAcc->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubAcc->FwMapping[i].RemoteNo; + ptrFwRtu->UpdataFwAccValue(ChangeInfo,dNewValue,eWithoutDeadbandUpdate); + } + } +} + +/** +* @brief CFesRxFesDataThread::RxMiUpdataData +* 接收Mi全数据。 +* +* @param UpdateMiPkg 接收到的数据 +* @return +*/ +void CFesRxFesDataThread::RxMiUpdataData(const SFesUpdateMiPkg &UpdateMiPkg) +{ + int nNum; + int nLoop = 0; + int i; + CFesRtuPtr ptrFwRtu; + SFesFwChgMi ChangeInfo; + uint64 mSec; + + nNum = UpdateMiPkg.stmidata_size(); + + if (nNum > 0) + { + LOGTRACE("RxMiChangeData:收到全数据报文,数目[%d]", nNum); + } + + mSec = getUTCTimeMsec(); + for (nLoop = 0; nLoop < nNum; nLoop++) + { + SFesFwPubMi *pPubMi = NULL; + + const SFesMiDataWithoutTm &MiData = UpdateMiPkg.stmidata(nLoop); + const std::string &TagName = MiData.strapptagname(); + if ((pPubMi = m_ptrCFesBase->GetFesFwPubFesMi(TagName)) == NULL) + continue; + + pPubMi->Value = MiData.nvalue(); + pPubMi->Status = MiData.ustatus(); + pPubMi->time = mSec; + ChangeInfo.Value = pPubMi->Value; + ChangeInfo.Status = pPubMi->Status; + ChangeInfo.time = pPubMi->time; + + int nNewValue = 0; + for (i = 0; i < pPubMi->FwMapNum; i++) + { + if ((ptrFwRtu = m_ptrCFesBase->GetFwRtuByMappingIndex(pPubMi->FwMapping[i].MappingIndex)) == NULL) + continue; + ChangeInfo.RemoteNo = pPubMi->FwMapping[i].RemoteNo; + ptrFwRtu->UpdataFwMiValue(ChangeInfo,nNewValue,eWithoutDeadbandUpdate); + } + } } //设置为主 @@ -284,146 +722,3 @@ int CFesRxFesDataThread::setSlave() unsubMessage(); return iotSuccess; } - - -/** -@brief 前置实时数据处理（变化数据/全数据/报警/SOE/各种事件） -@param 无 -@return 无 -@retval -*/ -int CFesRxFesDataThread::parseFesPackage(const iot_net::CMbMessage &objRecvMsg) -{ - //int64 t1,t2; - bool bRetCode = false; - int nMessageType = objRecvMsg.getMsgType(); - - LOGDEBUG("parseFesPackage, Recv a Message Type=%d ", nMessageType); - - switch (nMessageType) - { - case MT_FES_DI_CHANGE://DI Change Data - { - SFesChangeDiPkg objFesChanageDiPkg; - //t1 = getUTCTimeMsec() ; - bRetCode = objFesChanageDiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - //t2 = getUTCTimeMsec() ; - //LOGINFO("parseFesPackage:解析变化数字量 num=%d，用时=%d(ms)",objFesChanageDiPkg.stdidata_size(),t2-t1); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesChanageDiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesChangeDigPkg(objFesChanageDiPkg); - break; - } - case MT_FES_DI_UPDATE://DI UPDATE Data - { - SFesUpdateDiPkg objFesUpdateDiPkg; - //t1 = getUTCTimeMsec() ; - bRetCode = objFesUpdateDiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - //t2 = getUTCTimeMsec() ; - //LOGINFO("parseFesPackage:解析数字量全数据 num=%d，用时=%d(ms)",objFesUpdateDiPkg.stdidata_size(),t2-t1); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesUpdateDiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesUpdateDigPkg(objFesUpdateDiPkg); - break; - } - case MT_FES_AI_CHANGE://AI Change Data - { - SFesChangeAiPkg objFesChanageAiPkg; - bRetCode = objFesChanageAiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesChanageAiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesChangeAnaPkg(objFesChanageAiPkg); - break; - } - case MT_FES_AI_UPDATE://AI UPDATE Data - { - SFesUpdateAiPkg objFesUpdateAiPkg; - bRetCode = objFesUpdateAiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesUpdateAiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesUpdateAnaPkg(objFesUpdateAiPkg); - break; - } - case MT_FES_MI_CHANGE://MI Change Data - { - SFesChangeMiPkg objFesChanageMiPkg; - bRetCode = objFesChanageMiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesChanageMiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesChangeMixPkg(objFesChanageMiPkg); - break; - } - case MT_FES_MI_UPDATE://MI UPDATE Data - { - SFesUpdateMiPkg objFesUpdateMiPkg; - bRetCode = objFesUpdateMiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesUpdateMiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesUpdateMixPkg(objFesUpdateMiPkg); - break; - } - case MT_FES_PI_CHANGE://PI Change Data - { - SFesChangePiPkg objFesChangePiPkg; - bRetCode = objFesChangePiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesChangePiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesChangeAccPkg(objFesChangePiPkg); - break; - } - case MT_FES_PI_UPDATE://PI UPDATE Data - { - SFesUpdatePiPkg objFesUpdatePiPkg; - bRetCode = objFesUpdatePiPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesUpdatePiPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesUpdateAccPkg(objFesUpdatePiPkg); - break; - } - case MT_FES_SOE_EVENT: //SOE事件信息 - { - SFesSoeEventPkg objFesSoeEventPkg; - bRetCode = objFesSoeEventPkg.ParseFromArray(objRecvMsg.getDataPtr(), objRecvMsg.getDataSize()); - if (!bRetCode) - { - LOGWARN("parseFesPackage::objFesSoeEventPkg解析错误！"); - return -1; - } - m_ptrPacketQueue->addFesSoeEventPkg(objFesSoeEventPkg); - break; - } - default: - { - LOGWARN("parseFesPackage::MsgType = %d 消息类型不支持！", nMessageType); - return -1; - } - }// end switch - - return 1; -} - - diff --git a/product/src/fes/fes/FesRxFesDataThread.h b/product/src/fes/fes/FesRxFesDataThread.h index b6f8efdc..fe29d932 100644 --- a/product/src/fes/fes/FesRxFesDataThread.h +++ b/product/src/fes/fes/FesRxFesDataThread.h @@ -4,8 +4,6 @@ #include "FesBase.h" #include "net/net_msg_bus_api/MsgBusApi.h" #include "FesMessage.pb.h" -#include "PacketQueue.h" -#include using namespace iot_net; using namespace iot_idl; @@ -13,7 +11,7 @@ using namespace iot_idl; class CFesRxFesDataThread : public iot_public::CTimerThreadBase { public: - CFesRxFesDataThread(int iDomainID, int iAppID, void* BaseDataAddr, CPacketQueuePtr ptrPacketQueue); + CFesRxFesDataThread(int iDomainID, int iAppID, void* BaseDataAddr); virtual ~CFesRxFesDataThread(); /* @@ -44,12 +42,15 @@ private: CFesBase *m_ptrCFesBase; bool readFromBus(); - - CPacketQueuePtr m_ptrPacketQueue; //消息缓存类 - - int parseFesPackage(const iot_net::CMbMessage &objRecvMsg); - - + void RxDiChangeData(const iot_idl::SFesChangeDiPkg &stChangeDiPkg); + void RxAiChangeData(const iot_idl::SFesChangeAiPkg &stChangeAiPkg); + void RxAccChangeData(const iot_idl::SFesChangePiPkg &stChangeAccPkg); + void RxMiChangeData(const iot_idl::SFesChangeMiPkg &stChangeMiPkg); + void RxDiUpdataData(const SFesUpdateDiPkg &UpdateDiPkg); + void RxAiUpdataData(const SFesUpdateAiPkg &UpdateAiPkg); + void RxAccUpdataData(const SFesUpdatePiPkg &UpdateAccPkg); + void RxMiUpdataData(const SFesUpdateMiPkg &UpdateMiPkg); + void RxSOEData(const SFesSoeEventPkg &SOEPkg); }; diff --git a/product/src/fes/fes/FesSimServerThread.cpp b/product/src/fes/fes/FesSimServerThread.cpp index 9f7033d8..e84c9c44 100644 --- a/product/src/fes/fes/FesSimServerThread.cpp +++ b/product/src/fes/fes/FesSimServerThread.cpp @@ -404,7 +404,7 @@ int CFesSimServerThread::RxData(unsigned char *Data,int MaxLen) TcpClose(m_AcceptSocket); m_AcceptSocket = SOCKET_ERROR; } - if (FD_ISSET(m_AcceptSocket, &fdSet)) + if (SOCKET_ERROR != m_AcceptSocket && INVALID_SOCKET != m_AcceptSocket && FD_ISSET(m_AcceptSocket, &fdSet)) { len = ::recv(m_AcceptSocket , (char *)Data , MaxLen , 0); if (len > 0) @@ -1796,6 +1796,7 @@ int CFesSimServerThread::AccDataResp(unsigned char *Data,int FrameNo) SFesAcc *pAcc; int writex,count,structLen,maxCount,RtuNo; int i,StartIndex,EndIndex; + unsigned char* pTemp; if(m_ptrCFesBase==NULL) return 0; @@ -1886,14 +1887,23 @@ int CFesSimServerThread::AccDataResp(unsigned char *Data,int FrameNo) Data[writex++] = (pAcc->PointNo>>8)&0xff; Data[writex++] = (pAcc->PointNo>>16)&0xff; Data[writex++] = (pAcc->PointNo>>24)&0xff; - Data[writex++]=pAcc->Value&0xff; - Data[writex++]=(pAcc->Value>>8)&0xff; - Data[writex++]=(pAcc->Value>>16)&0xff; - Data[writex++]=(pAcc->Value>>24)&0xff; - Data[writex++]=(pAcc->Value>>32)&0xff; - Data[writex++]=(pAcc->Value>>40)&0xff; - Data[writex++]=(pAcc->Value>>48)&0xff; - Data[writex++]=(pAcc->Value>>56)&0xff; + // Data[writex++]=pAcc->Value&0xff; + // Data[writex++]=(pAcc->Value>>8)&0xff; + // Data[writex++]=(pAcc->Value>>16)&0xff; + // Data[writex++]=(pAcc->Value>>24)&0xff; + // Data[writex++]=(pAcc->Value>>32)&0xff; + // Data[writex++]=(pAcc->Value>>40)&0xff; + // Data[writex++]=(pAcc->Value>>48)&0xff; + // Data[writex++]=(pAcc->Value>>56)&0xff; + pTemp = (unsigned char*)&pAcc->Value; + Data[writex++]=*pTemp; + Data[writex++]=*(pTemp+1); + Data[writex++]=*(pTemp+2); + Data[writex++]=*(pTemp+3); + Data[writex++]=*(pTemp+4); + Data[writex++]=*(pTemp+5); + Data[writex++]=*(pTemp+6); + Data[writex++]=*(pTemp+7); Data[writex++]=pAcc->Status&0xff; Data[writex++]=(pAcc->Status>>8)&0xff; Data[writex++]=(pAcc->Status>>16)&0xff; @@ -2869,7 +2879,7 @@ void CFesSimServerThread::SimAiSetValue() { AiValue.PointNo=m_SimAi.PointNo; AiValue.Status=CN_FesValueUpdate; - AiValue.Value=rand()%10000; + AiValue.Value = static_cast(rand()%10000); AiValue.time = getUTCTimeMsec(); ChgAiValue.Status = AiValue.Status; //ChgAiValue.Value = AiValue.Value; @@ -2908,7 +2918,7 @@ void CFesSimServerThread::SimAiSetValue() if((pAi=pRtu->GetAiByPointNo(i))!=NULL) { AiValue.PointNo = i; - AiValue.Value=rand()%10000; + AiValue.Value = static_cast(rand()%10000); //ChgAiValue.Value = AiValue.Value; memcpy(ChgAiValue.TableName,pAi->TableName,CN_FesMaxTableNameSize); memcpy(ChgAiValue.ColumnName,pAi->ColumnName,CN_FesMaxColumnNameSize); @@ -2946,7 +2956,7 @@ void CFesSimServerThread::SimAiSetValue() if((pAi=pRtu->GetAiByPointNo(j))!=NULL) { AiValue.PointNo = j; - AiValue.Value=rand()%10000; + AiValue.Value= static_cast(rand()%10000); //ChgAiValue.Value = AiValue.Value; memcpy(ChgAiValue.TableName,pAi->TableName,CN_FesMaxTableNameSize); memcpy(ChgAiValue.ColumnName,pAi->ColumnName,CN_FesMaxColumnNameSize); @@ -3540,30 +3550,55 @@ int CFesSimServerThread::SimAccStartResp(unsigned char *Data,int /*FrameNo*/) m_SimAcc.Period |= (short)m_RecvBuf[readx++]<<8; m_SimAccLastmSec = getMonotonicMsec(); - m_SimAcc.SetValue = (uint64)m_RecvBuf[readx++]; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<8; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<16; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<24; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<32; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<40; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<48; - m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<56; + // m_SimAcc.SetValue = (uint64)m_RecvBuf[readx++]; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<8; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<16; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<24; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<32; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<40; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<48; + // m_SimAcc.SetValue |= (uint64)m_RecvBuf[readx++]<<56; + unsigned char *pTemp= (unsigned char*)&m_SimAcc.SetValue; + + *pTemp = m_RecvBuf[readx++]; + *(pTemp+1) = m_RecvBuf[readx++]; + *(pTemp+2) = m_RecvBuf[readx++]; + *(pTemp+3) = m_RecvBuf[readx++]; + *(pTemp+4) = m_RecvBuf[readx++]; + *(pTemp+5) = m_RecvBuf[readx++]; + *(pTemp+6) = m_RecvBuf[readx++]; + *(pTemp+7) = m_RecvBuf[readx++]; m_SimAcc.Status = (uint32)m_RecvBuf[readx++]; m_SimAcc.Status |= (uint32)m_RecvBuf[readx++]<<8; m_SimAcc.Status |= (uint32)m_RecvBuf[readx++]<<16; m_SimAcc.Status |= (uint32)m_RecvBuf[readx++]<<24; - m_SimAcc.MinValue = (int)m_RecvBuf[readx++]; - m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<8; - m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<16; - m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<24; - m_SimAcc.MaxValue = (int)m_RecvBuf[readx++]; - m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<8; - m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<16; - m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<24; - m_SimAcc.StepValue = (int)m_RecvBuf[readx++]; - m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<8; - m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<16; - m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<24; + // m_SimAcc.MinValue = (int)m_RecvBuf[readx++]; + // m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<8; + // m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<16; + // m_SimAcc.MinValue |= (int)m_RecvBuf[readx++]<<24; + // m_SimAcc.MaxValue = (int)m_RecvBuf[readx++]; + // m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<8; + // m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<16; + // m_SimAcc.MaxValue |= (int)m_RecvBuf[readx++]<<24; + // m_SimAcc.StepValue = (int)m_RecvBuf[readx++]; + // m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<8; + // m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<16; + // m_SimAcc.StepValue |= (int)m_RecvBuf[readx++]<<24; + pTemp = (unsigned char*)&m_SimAcc.MinValue; + *pTemp = m_RecvBuf[readx++]; + *(pTemp+1) = m_RecvBuf[readx++]; + *(pTemp+2) = m_RecvBuf[readx++]; + *(pTemp+3) = m_RecvBuf[readx++]; + pTemp = (unsigned char*)&m_SimAcc.MaxValue; + *pTemp = m_RecvBuf[readx++]; + *(pTemp+1) = m_RecvBuf[readx++]; + *(pTemp+2) = m_RecvBuf[readx++]; + *(pTemp+3) = m_RecvBuf[readx++]; + pTemp = (unsigned char*)&m_SimAcc.StepValue; + *pTemp = m_RecvBuf[readx++]; + *(pTemp+1) = m_RecvBuf[readx++]; + *(pTemp+2) = m_RecvBuf[readx++]; + *(pTemp+3) = m_RecvBuf[readx++]; m_SimAcc.RtuNo = (int)m_RecvBuf[readx++]; @@ -3579,7 +3614,8 @@ int CFesSimServerThread::SimAccStartResp(unsigned char *Data,int /*FrameNo*/) m_SimAccStart = 1; m_SimAccChangeCountReset = m_SimAcc.Period*1000/50; //50ms polling; m_SimAccChangeCount = 0; - m_SimAccValue = m_SimAcc.MinValue; + //m_SimAccValue = m_SimAcc.MinValue; + m_SimAccValue = (double)m_SimAcc.MinValue; m_SimAccValueSigned = 1; Data[6] = CN_SFesSimAccStartResp; //命令码 @@ -6828,6 +6864,7 @@ int CFesSimServerThread::FwAccDataResp(unsigned char *Data, int FrameNo) SFesFwAcc *pFwAcc; int writex, count, structLen, maxCount, RtuNo; int i, StartIndex, EndIndex; + unsigned char* pTemp; if (m_ptrCFesBase == NULL) return 0; @@ -6916,14 +6953,23 @@ int CFesSimServerThread::FwAccDataResp(unsigned char *Data, int FrameNo) Data[writex++] = (pFwAcc->RemoteNo >> 8) & 0xff; Data[writex++] = (pFwAcc->RemoteNo >> 16) & 0xff; Data[writex++] = (pFwAcc->RemoteNo >> 24) & 0xff; - Data[writex++] = pFwAcc->Value & 0xff; - Data[writex++] = (pFwAcc->Value >> 8) & 0xff; - Data[writex++] = (pFwAcc->Value >> 16) & 0xff; - Data[writex++] = (pFwAcc->Value >> 24) & 0xff; - Data[writex++] = (pFwAcc->Value >> 32) & 0xff; - Data[writex++] = (pFwAcc->Value >> 40) & 0xff; - Data[writex++] = (pFwAcc->Value >> 48) & 0xff; - Data[writex++] = (pFwAcc->Value >> 56) & 0xff; + // Data[writex++] = pFwAcc->Value & 0xff; + // Data[writex++] = (pFwAcc->Value >> 8) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 16) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 24) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 32) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 40) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 48) & 0xff; + // Data[writex++] = (pFwAcc->Value >> 56) & 0xff; + pTemp = (unsigned char*)&pFwAcc->Value; + Data[writex++] = *pTemp; + Data[writex++] = *(pTemp + 1); + Data[writex++] = *(pTemp + 2); + Data[writex++] = *(pTemp + 3); + Data[writex++] = *(pTemp + 4); + Data[writex++] = *(pTemp + 5); + Data[writex++] = *(pTemp + 6); + Data[writex++] = *(pTemp + 7); Data[writex++] = pFwAcc->Status & 0xff; Data[writex++] = (pFwAcc->Status >> 8) & 0xff; Data[writex++] = (pFwAcc->Status >> 16) & 0xff; @@ -7589,6 +7635,7 @@ int CFesSimServerThread::SpecifiedAccDataResp(unsigned char *Data, int FrameNo) SFesAcc *pAcc; int writex, count, structLen, maxCount, RtuNo; int i; + unsigned char* pTemp; if (m_ptrCFesBase == NULL) return 0; @@ -7673,14 +7720,23 @@ int CFesSimServerThread::SpecifiedAccDataResp(unsigned char *Data, int FrameNo) Data[writex++] = (pAcc->PointNo >> 8) & 0xff; Data[writex++] = (pAcc->PointNo >> 16) & 0xff; Data[writex++] = (pAcc->PointNo >> 24) & 0xff; - Data[writex++] = pAcc->Value & 0xff; - Data[writex++] = (pAcc->Value >> 8) & 0xff; - Data[writex++] = (pAcc->Value >> 16) & 0xff; - Data[writex++] = (pAcc->Value >> 24) & 0xff; - Data[writex++] = (pAcc->Value >> 32) & 0xff; - Data[writex++] = (pAcc->Value >> 40) & 0xff; - Data[writex++] = (pAcc->Value >> 48) & 0xff; - Data[writex++] = (pAcc->Value >> 56) & 0xff; + // Data[writex++] = pAcc->Value & 0xff; + // Data[writex++] = (pAcc->Value >> 8) & 0xff; + // Data[writex++] = (pAcc->Value >> 16) & 0xff; + // Data[writex++] = (pAcc->Value >> 24) & 0xff; + // Data[writex++] = (pAcc->Value >> 32) & 0xff; + // Data[writex++] = (pAcc->Value >> 40) & 0xff; + // Data[writex++] = (pAcc->Value >> 48) & 0xff; + // Data[writex++] = (pAcc->Value >> 56) & 0xff; + pTemp = (unsigned char*)&pAcc->Value; + Data[writex++] = *pTemp; + Data[writex++] = *(pTemp + 1); + Data[writex++] = *(pTemp + 2); + Data[writex++] = *(pTemp + 3); + Data[writex++] = *(pTemp + 4); + Data[writex++] = *(pTemp + 5); + Data[writex++] = *(pTemp + 6); + Data[writex++] = *(pTemp + 7); Data[writex++] = pAcc->Status & 0xff; Data[writex++] = (pAcc->Status >> 8) & 0xff; Data[writex++] = (pAcc->Status >> 16) & 0xff; diff --git a/product/src/fes/fes/FesSimServerThread.h b/product/src/fes/fes/FesSimServerThread.h index 7b9b01e7..9990531a 100644 --- a/product/src/fes/fes/FesSimServerThread.h +++ b/product/src/fes/fes/FesSimServerThread.h @@ -101,7 +101,8 @@ private: SFesSimAccStartReq m_SimAcc; int m_SimAccChangeCount; int m_SimAccChangeCountReset; - int64 m_SimAccValue; + //int64 m_SimAccValue; + double m_SimAccValue; int m_SimAccValueSigned; //增加的方向 (1)+ else(-) int64 m_SimAccLastmSec; //2022-01-10 diff --git a/product/src/fes/fes/FesTxControlCmdThread.cpp b/product/src/fes/fes/FesTxControlCmdThread.cpp index d01e72c8..3988cfbe 100644 --- a/product/src/fes/fes/FesTxControlCmdThread.cpp +++ b/product/src/fes/fes/FesTxControlCmdThread.cpp @@ -61,7 +61,7 @@ void CFesTxControlCmdThread::execute() if(m_ptrTxCommunicator==NULL) return; - //发送控制消息 + //发送控制反馈消息 int retNum,msgType; for (size_t i = 0; i < m_ptrCFesBase->m_vectCFesRtuPtr.size(); i++) { @@ -203,7 +203,7 @@ void CFesTxControlCmdThread::execute() CmdReplyPkg.set_nstatus(TxDefCmd.retStatus); CmdReplyPkg.set_ndevid(TxDefCmd.DevId); CmdReplyPkg.set_ndatalen(TxDefCmd.CmdNum); - int count = TxDefCmd.VecCmd.size(); + int count = static_cast(TxDefCmd.VecCmd.size()); for(int k=0;k= m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iDiChgRtu = 0; else - m_ptrCFesBase->m_LastRtuIndx.iDiChgRtu = i; + m_ptrCFesBase->m_LastRtuIndx.iDiChgRtu = static_cast(i); return iotSuccess; } @@ -560,7 +559,7 @@ int CFesTxDataChangeThread::AiChangeResp() if(i>=m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iAiChgRtu=0; else - m_ptrCFesBase->m_LastRtuIndx.iAiChgRtu=i; + m_ptrCFesBase->m_LastRtuIndx.iAiChgRtu=static_cast(i); //LOGINFO("AiChangeResp end %lld",mSec); @@ -614,7 +613,7 @@ int CFesTxDataChangeThread::AccChangeResp() pAccWithTm->set_strappcolumnname(pChgAcc->ColumnName); pAccWithTm->set_strapptagname(pChgAcc->TagName); pAccWithTm->set_ustatus(pChgAcc->Status); - pAccWithTm->set_nvalue(pChgAcc->Value); + pAccWithTm->set_dvalue(pChgAcc->Value); pAccWithTm->set_ultime(pChgAcc->time); count++; } @@ -653,7 +652,7 @@ int CFesTxDataChangeThread::AccChangeResp() if(i>=m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iAccChgRtu=0; else - m_ptrCFesBase->m_LastRtuIndx.iAccChgRtu=i; + m_ptrCFesBase->m_LastRtuIndx.iAccChgRtu=static_cast(i); return iotSuccess; } @@ -670,8 +669,8 @@ int CFesTxDataChangeThread::MiChangeResp() int j,startIndex; CFesRtuPtr ptrCFesRtu; int num,retNum,count; - SFesChangeMiPkg ChgMiPkg; - SFesMiDataWithTm *pMiWithTm; + SFesChangeDiPkg ChgMiPkg; + SFesDiDataWithTm *pMiWithTm; SFesChgMi *pChgMi; if(m_ptrCFesBase==NULL) @@ -701,7 +700,7 @@ int CFesTxDataChangeThread::MiChangeResp() pChgMi = m_pChgMiData+j; if(strlen(pChgMi->TagName)<1)//TagName 内容<1，表明后台配置无效，不需送数据 continue; - pMiWithTm = ChgMiPkg.add_stmidata(); + pMiWithTm = ChgMiPkg.add_stdidata(); pMiWithTm->set_strapptablename(pChgMi->TableName); pMiWithTm->set_strappcolumnname(pChgMi->ColumnName); pMiWithTm->set_strapptagname(pChgMi->TagName); @@ -747,7 +746,7 @@ int CFesTxDataChangeThread::MiChangeResp() if(i>=m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iMiChgRtu=0; else - m_ptrCFesBase->m_LastRtuIndx.iMiChgRtu=i; + m_ptrCFesBase->m_LastRtuIndx.iMiChgRtu=static_cast(i); return iotSuccess; } @@ -852,7 +851,7 @@ int CFesTxDataChangeThread::SoeEventResp() if (i >= m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iSoeEventRtu=0; else - m_ptrCFesBase->m_LastRtuIndx.iSoeEventRtu=i; + m_ptrCFesBase->m_LastRtuIndx.iSoeEventRtu=static_cast(i); return iotSuccess; } @@ -1132,7 +1131,7 @@ int CFesTxDataChangeThread::SoeStrEventResp() if (i >= m_ptrCFesBase->m_vectCFesRtuPtr.size()) m_ptrCFesBase->m_LastRtuIndx.iSoeStrEventRtu = 0; else - m_ptrCFesBase->m_LastRtuIndx.iSoeStrEventRtu = i; + m_ptrCFesBase->m_LastRtuIndx.iSoeStrEventRtu = static_cast(i); return iotSuccess; } diff --git a/product/src/fes/fes/FesWaveRecord.cpp b/product/src/fes/fes/FesWaveRecord.cpp index 265cafe8..666556f0 100644 --- a/product/src/fes/fes/FesWaveRecord.cpp +++ b/product/src/fes/fes/FesWaveRecord.cpp @@ -99,7 +99,7 @@ std::set FesWaveRecord::getDevGroupTagList(CFesRtuPtr rtuPtr,int fe retNum = rtuPtr->GetDiPointNoByDevId(fesDevId, VetPointNo); std::set devGroupList; SFesDi* pFesDi; - int diCount = VetPointNo.size(); + int diCount = static_cast(VetPointNo.size()); string pointTagName; string devGroupTag; for (int i = 0; i < diCount; i++) @@ -165,8 +165,7 @@ bool FesWaveCfgFile::openFile(std::string& file) m_startTime = 0; m_endTime = 0; - CFileUtil fu; - std::string dataPath = fu.getCurModuleDir(); + std::string dataPath = CFileUtil::getCurModuleDir(); //file path filesystem::path fpath = dataPath; diff --git a/product/src/fes/fes/fes.pro b/product/src/fes/fes/fes.pro index 244c8aae..e44bb03a 100644 --- a/product/src/fes/fes/fes.pro +++ b/product/src/fes/fes/fes.pro @@ -19,20 +19,16 @@ SOURCES += main.cpp \ FesChan.cpp \ FesRedundantManage.cpp \ FesRtu.cpp \ - FesSimServerThread.cpp \ FesWaveFormThread.cpp \ FesDataPublish.cpp \ FesForwardConfig.cpp \ - FesRxFesDataThread.cpp \ - FesRxDPDataThread.cpp \ - FesFwRxControlCmdThread.cpp \ + FesRxFesDataThread.cpp \ + FesRxDPDataThread.cpp \ + FesFwRxControlCmdThread.cpp \ FesFwTxControlCmdThread.cpp \ FesWaveRecord.cpp \ - AnaWorkThread.cpp \ - DigWorkThread.cpp \ - AccWorkThread.cpp \ - MixWorkThread.cpp \ - PacketQueue.cpp + DebugThread.cpp \ + DebugMbCommunicator.cpp HEADERS += \ FesApp.h \ @@ -51,28 +47,26 @@ HEADERS += \ ../include/FesRdbStruct.h \ FesChanManageThread.h \ FesRedundantManage.h \ - FesSimServerThread.h \ FesWaveFormThread.h \ FesDataPublish.h \ FesForwardConfig.h \ - FesRxFesDataThread.h \ - FesRxDPDataThread.h \ - FesFwRxControlCmdThread.h \ - FesFwTxControlCmdThread.h \ + FesRxFesDataThread.h \ + FesRxDPDataThread.h \ + FesFwRxControlCmdThread.h \ + FesFwTxControlCmdThread.h \ ../../idl_files/FesMessage.pb.h \ ../../idl_files/FesDataMessage.pb.h \ ../../idl_files/FesFwMessage.pb.h \ FesWaveRecord.h \ - AnaWorkThread.h \ - DigWorkThread.h \ - AccWorkThread.h \ - MixWorkThread.h \ - PacketQueue.h + DebugThread.h \ + DebugMbCommunicator.h \ + DebugSimParam.h INCLUDEPATH += ../include/ +INCLUDEPATH += ../fes_idl_files/ LIBS += -lboost_system -lboost_thread -lboost_chrono -lboost_program_options -lboost_date_time -lboost_filesystem -lboost_locale -lboost_regex -LIBS += -lpub_utility_api -lpub_logger_api -lnet_msg_bus_api -lpub_sysinfo_api -llog4cplus -lsys_dog_auth_api +LIBS += -lpub_utility_api -lpub_logger_api -lnet_msg_bus_api -lpub_sysinfo_api -llog4cplus LIBS += -lrdb_api LIBS += -lprotobuf LIBS += -lsys_node_mng_api @@ -80,10 +74,12 @@ LIBS += -lsys_proc_mng_api LIBS += -lalarm_server_api LIBS += -ldp_chg_data_api LIBS += -lsys_file_sync_api +LIBS += -lzmq -lczmq DEFINES += PROTOCOLBASE_API_EXPORTS include($$PWD/../../idl_files/idl_files.pri) +include($$PWD/../fes_idl_files/fes_idl_files.pri) #------------------------------------------------------------------- COMMON_PRI=$$PWD/../../common.pri