【《电力通信网络管理信息系统的设计与实现》源代码】信息系统实现的过程

　 头文件：

　/******************************************************************

　* All rights reserved.

　*

　 * 文件名称：baserule.h

　******************************************************************/

　#ifndef _BASERULE_H

　#define _BASERULE_H

　#if _MSC_VER>1000

　#pragma warning(disable: 4786)

　#endif

　#include <windows.h>

　#include "datadef.h"

　using namespace std;

　class BaseRule

　{

　public:

　 BaseRule(BYTE no, short rlen, short slen);

　 BaseRule(BaseRule& b);

　 //拷贝构造函数

　 virtual ~BaseRule();

　 unsigned int m_nPortNo;

　//RTU逻辑端口号

　 unsigned char *m_bSendBuf; //发送缓冲区地址

　 unsigned char *m_bRevBuf;

　//接收缓冲区地址

　 int

　 m_wRevLen;

　//接收数据包长度

　 int

　 m_wSendLen;

　//发送数据包长度

　 enum CMD_TYPE m_eCmdCode;

　//当前通讯命令码

　 enum CMD_TYPE m_ePreCode;

　//上次通讯命令码

　 //将TCP/IP、RS-232、LON通讯方式融合在一个函数里，对外部规约

　 //模块的调用是透明的，实现连接的初次建立及重新建立

　 int BaseConnect(unsigned char Channel_Type);

　 //支持TCP/IP、RS-232、LON通讯方式发送数据包

　 int BaseSend(unsigned char Channel_Type);

　//支持TCP/IP、RS-232、LON通讯方式接收数据包

　 //其中：t最长延时时间（秒），ms字节最大间隔时间（毫秒），SOCK方式cdt规约，RS232，LON：ms=0不用，Channel_Type通道类型

　 int BaseRead(int t, int ms, unsigned char Channel_Type);

　//纯虚函数，BaseRule类为抽象类

　 //循环发送接收函数

　 virtual void RuleLoop(void) = 0;

　 //对数据进行解包处理

　 virtual void UnpackData(void) = 0;

　 //对数据进行打包处理

　 virtual void PackData(void) = 0;

　 //设置网络状态

　 void SetNetState(enum GateDevStatus state);

　 //读取网络状态

　 void GetNetAddr(GateIpPort &netaddr);

　 //读取站类型

　 void GetGateStation(enum GateStation &eStation);

　private:

　 int

　 m_nServer;

　 //服务器方式 SOCKET通讯连接句柄

　 unsigned char m_bComIndex;

　//串口序号

　 HANDLE

　m_hCom;

　 //RS-232通讯连接柄

　 COMINFO

　m_ComInfo[MAXCOMCOUNT]; //串口信息

　 BYTE

　m_no;

　 //构造函数参数值

　 short

　m_rlen;

　//构造函数参数值

　 short

　m_slen;

　//构造函数参数值

　 //TCP/IP通讯方式接收数据包，等待方式

　 int SockRead(int fd, int t, int ms);

　 //TCP/IP通讯方式：实现连接的建立

　 int SockConnect(void);

　//TCP/IP通讯方式发送数据包

　 int SockSend(void);

　 //释放套接字资源

　 int FreeSocket(int &s);

　 //串口连接，实现连接的建立

　 int CommConnect(void);

　 //监测串口是否打开。

　 int CommCheck(char *sysname);

　 //写232串口信息

　 int RS232Send(void);

　 //读232串口信息

　 int RS232Read(int nLength);

　 //读配置信息

　 void ReadConfig(void);

　 //取文件数据

　 DWORD GetFileValue(FILE *fp);

　 //读字符数据

　 void GetFileChar(FILE *fp, char pcRead[]);

　protected://可以继承

　 int

　m_iAddress;

　 //节点地址

　 char

　m_szIPAddress[20]; //IP地址

　 int

　m_iPort;

　 //IP端口号

　 char

　m_szComm[20];

　//串口地址

　 DWORD

　m_dbBaudRate;

　//波特率baud;

　 BYTE

　m_bByteSize;

　//数据位number of bits/byte, 4-8

　BYTE

　m_bParity;

　 //校验位0-4=no,odd,even,mark,space

　BYTE

　m_bStopBits;

　//停止位0,1,2 = 1, 1.5, 2

　};

　#endif

　/**********************************************************************/

　/******************************************************************

　* All rights reserved.

　*

　 * 文件名称：cdt.h

　******************************************************************/

　#ifndef _CCDT_H

　#define _CCDT_H

　#include <vector>

　#include "baserule.h"

　using namespace std;

　class CCDT : public BaseRule

　{

　public:

　CCDT(BYTE no, short rlen, short slen);

　 virtual ~CCDT();

　private:

　 //同步字类型

　 enum CdtType

　 {

　FIND_HEAD = 0x00,

　SYN_HEAD,

　PACK_DATA

　 };

　 unsigned char m_bHeadEB;

　 //字节eb个数

　 unsigned char m_bHead90;

　 //字节90个数

　 unsigned char m_bSerial;

　 //解包数据序号

　 enum CdtType m_bSyncFlag;

　//同步字类型

　 unsigned char m_bInfoBuf[6];

　//解包数据信息

　 unsigned char m_bControl;

　 //控制字节

　 unsigned char m_bFrameType;

　//帧类别

　 unsigned char m_bInfoNumber;

　//信息字数

　 unsigned char m_bBchTable[256];

　//中间余式表

　 enum FUNC_TYPE m_ePreFuncType;

　//上一包功能码类型

　 unsigned char m_bSoe80;

　 //soe事件的第一个功能码

　 unsigned char m_bSoeBuf[12];

　//soe信息

　 unsigned long m_lTimeBegin;

　//开始时刻

　 unsigned int m_nCtrlNumber;

　//控制号

　 unsigned char m_bCtrlType;

　//控分控合

　 //??测试使用

　 unsigned long

　 m_begin;

　//装置遥信状态测试时钟开始

　// vector <unsigned char> bCommSendVec; //发送缓冲

　// vector <unsigned char> bCommReceiveVec; //接收缓冲

　private:

　 //循环发送接收函数

　 virtual void RuleLoop(void);

　 //处理收到的数据，防止有接收的数据分两次传送的情况

　 void PreUnpackData(BYTE bRead);

　 //验证接收数据校验码

　 bool CheckRevCode(void);

　 //计算发送数据校验码

　 void CheckSendCode(int no);

　 //解包，整理数据

　 void UnpackData(void);

　 //打包函数

　 void PackData(void);

　 //区分功能码代号

　 int GetFunType(enum FUNC_TYPE &eFunc);

　 //存储遥测数值，按照60870系列格式。

　 void PutYC(void);

　 //存储遥信值

　 void PutYX(void);

　 //存储事件进队列

　 void PutSOE(void);

　 //存储电度值

　 void PutDD(void);

　 //存储遥控返校信息。

　 void PutYK(enum INFO_TYPE eType, bool bFailFlag = false);

　 //存储频率值

　 void PutHZ(void);

　 //16进制数转换成BCD码

　 int HexToBCD(unsigned char bHex);

　 //超时检测

　 int TimeCheck(void);

　 //??测试使用，模拟遥信信息

　 void TestPutYX(void);

　 //??测试使用，模拟SOE

　 void TestPutSOE(void);

　 //??测试使用,间隔一段时间送遥信信息

　 int TimeTest();

　};

　#endif

　/********************************************************/

　/******************************************************************

　* All rights reserved.

　*

　 * 文件名称：corearg.h

　******************************************************************/

　#ifndef _CORE_ARG_H

　#define _CORE_ARG_H

　#if _MSC_VER>1000

　#pragma warning(disable: 4786)

　#endif

　#include <list>

　#include <map>

　#include "numdef.h"

　#include "ntdef.h"

　#include "datadef.h"

　using namespace std;

　//网络内存数据

　class CGloalNet

　{

　public:

　 CGloalNet();

　 ~CGloalNet();

　public:

　 enum GateDevStatus m_eState;

　 //装置状态(起初设置的时候置为ACIE_UNKNOW)

　 GateNetAddr

　 NetAddr;

　//网络地址

　 sem_t

　sem_addr;

　 sem_t

　sem_msg;

　int InsNetAddr(GateNetAddr addr);

　 int GetNetAddr(GateNetAddr &addr);

　 int InsDevStatus(enum GateDevStatus state);

　 int GetDevStatus(enum GateDevStatus state);

　};

　//事件内存数据，包括从下层向上层传输的数据；上层向下层发送的命令

　class CSoeData

　{

　public:

　 CSoeData();

　 ~CSoeData();

　 list<SOE_STATUS> m_ListSoe;

　//下层上送的遥信、soe等信息

　 list<CTRL_VALUE> m_CtrlValue; //103/104到CDT的命令

　 sem_t

　 sem_soe;

　public:

　 //插入事件信息

　 int InsSoeData(SOE_STATUS soe_status);

　 //读取并弹出事件信息

　 int GetSoeData(enum GateStation eStation, SOE_STATUS &soe_status);

　 //插入命令信息

　 int InsCtrlData(CTRL_VALUE ctrl_value);

　 //读取并弹出命令信息

　 int GetCtrlData(CTRL_VALUE &ctrl_value);

　protected:

　private:

　 //检测事件队列,list最大值超过2000弹出第一个值

　 void CheckSoeData(void);

　 //检测命令队列,list最大值超过2000弹出第一个值

　 void CheckCtrlData(void);

　};

　//设备内存数据，包括遥测量、遥信量、soe。

　class CDevData

　{

　public:

　 CDevData();

　 ~CDevData();

　 //键值为<pair<装置序号,信息号>,数据类型>

　 map<pair<pair<unsigned int, unsigned int>, enum DATA_TYPE>, DATAGROUP> m_MapData;//Yc, m_MapSoe, m_MapYx;

　 sem_t

　sem_dev;

　public:

　 //插入设备数据信息

　 int InsDevData(DATAGROUP *pData, int count);

　 //删除设备数据信息

　 int DelDevData(unsigned int nPortNo, unsigned int *No, enum DATA_TYPE eType, int count);

　 // 删除全部设备数据信息

　 int DelAllDevData(unsigned int nPortNo);

　 //返回指定装置的数据分组信息记录

　 int CountDevData(unsigned int nPortNo, enum DATA_TYPE eType);

　 //返回指定装置和序号的指定数据信息记录(根据设备编号/序号找实际值)

　 int GetFixDevData(unsigned int nPortNo, unsigned int no, enum DATA_TYPE eType, DATAGROUP &pData);

　};

　#endif

　/****************************************/

　/******************************************************************

　* All rights reserved.

　*

　 * 文件名称：datadef.h

　******************************************************************/

　#ifndef _DATADEF_H

　#define _DATADEF_H

　#if _MSC_VER>1000

　#pragma warning(disable: 4786)

　#endif

　#include <vector>

　#include "numdef.h"

　using namespace std;

　const unsigned

　char MAXCOMCOUNT = 24;

　//串口的最大个数

　//串口信息

　typedef struct COMINFO

　{

　 char name[20]; //串口名称

　 HANDLE hcom; //句柄

　// sem_t semcom; //串口锁

　 BYTE flag;

　//有效标志

　}COMINFO;

　//SOE_STATUS队列结构体，存储状态变化信息、SOE事件。

　typedef struct SOE_STATUS

　{

　 unsigned char bAddress;

　//装置地址

　 enum GateStation eStation;

　//通道类型

　 int

　 nPot;

　 //信息点号

　 unsigned char bStatus;

　//状态

　 unsigned char bDay;

　 //日

　 unsigned char bHour;

　//时

　 unsigned char bMinute;

　//分

　 unsigned short wMilliseconds; //毫秒

　 enum INFO_TYPE eType;

　//上送类型

　// unsigned short wSerial;

　//soe对象号

　}SOE_STATUS;

　//链路层前六个字节

　struct APDUHEAD

　{

　 unsigned char bStartCode;

　//启动字符

　 unsigned char bApduLength; //长度

　 unsigned char bControlCode1; //控制域1

　 unsigned char bControlCode2; //控制域2

　 unsigned char bControlCode3; //控制域3

　 unsigned char bControlCode4; //控制域4

　};

　//应用层前六个字节

　struct ASDUHEAD

　{

　 unsigned char

　bAsduType;

　 //类型标示

　 unsigned char

　bAsduVsq;

　//可变结构限定词

　 unsigned short nAsduCot;

　//传送原因

　 unsigned short nAsduComAddr;

　//应用服务数据单元公共地址

　 unsigned char

　bAsduFun;

　//功能类型，104没有此位

　 unsigned char

　bAsduInf;

　//信息序号

　};

　//上送报文结构

　typedef struct _tagDATASTR

　{

　 struct APDUHEAD

　ApduHead; //链路层

　 struct ASDUHEAD

　AsduHead; //应用层前六个字节

　 vector <unsigned char> bDataVec; //数据

　}DATA_STR;

　//命令结构体

　typedef struct _tagCtrlValue

　{

　// unsigned int

　nPortno;

　//装置序号

　// unsigned int

　nPortno103;

　//后台序号

　 unsigned char

　bAddress;

　//装置地址

　 unsigned char

　bSwitch;

　//定值区号

　 unsigned int

　iValue;

　//值

　 unsigned short

　nPotValue;

　//信息地址

　// unsigned char

　bCpu;

　 //cpu号

　 enum CMD_TYPE

　eCmdType;

　//命令类型

　}CTRL_VALUE;

　//在内存中存储装置的一些信息，包括遥测、遥信、事件、定值区、定值

　typedef struct _tagDataGroup

　 {

　 unsigned int nPortNo;

　//装置序号

　 unsigned int nSerial;

　//序号

　 unsigned int nAddress;

　//装置地址

　 unsigned char bLocal;

　//远方就地，0远方，1就地

　// unsigned int nSize;

　//长度

　 enum DATA_TYPE eType;

　//遥测/遥信/SOE/电度

　 unsigned short nValue;

　//存储装置信息

　}DATAGROUP;

　#endif

　/***************************************************/

　主程序：

　/********************************************************************/

　/******************************************************************

　* All rights reserved.

　*

　 * 文件名称：baserule.cpp

　******************************************************************/

　#include "baserule.h"

　#include "ext.h"

　BaseRule::BaseRule(BYTE no, short rlen, short slen)

　{

　 m_nPortNo = no;

　 m_nServer = INVALID_SOCKET;

　 m_wRevLen = 0;

　 m_wSendLen = 0;

　 m_eCmdCode = COMMAND_NONE;

　//当前通讯命令码

　 m_ePreCode = m_eCmdCode;

　//上次通讯命令码

　 m_bSendBuf = new BYTE [slen];

　 m_bRevBuf = new BYTE [rlen];

　 memset(m_bSendBuf, 0, slen);

　 memset(m_bRevBuf, 0, rlen);

　 m_bComIndex = 0;

　 m_hCom = NULL;

　 memset(&m_ComInfo, 0, sizeof(COMINFO)*MAXCOMCOUNT);

　 for(int i=0; i<MAXCOMCOUNT; i++)

　 {

　sprintf(m_ComInfo[i].name,"COM%d",i);

　 }

　 //网络状态为断开

　 SetNetState(GATE_UNCLOSE);

　 ReadConfig();

　}

　//拷贝构造函数

　BaseRule::BaseRule(BaseRule& b)

　{

　 m_nPortNo = b.m_nPortNo;

　 m_nServer = b.m_nServer;

　 m_wRevLen = b.m_wRevLen;

　 m_wSendLen = b.m_wSendLen;

　 m_eCmdCode = b.m_eCmdCode;

　//当前通讯命令码

　 m_ePreCode = b.m_ePreCode;

　//上次通讯命令码

　 m_bSendBuf = new BYTE [m_slen=b.m_slen];

　 memcpy((void*)m_bSendBuf, (void*)b.m_bSendBuf, m_slen*sizeof(BYTE));

　 m_bRevBuf = new BYTE [m_rlen=b.m_rlen];

　 memcpy((void*)m_bRevBuf, (void*)b.m_bRevBuf, m_rlen*sizeof(BYTE));

　 memset(m_bSendBuf, 0, b.m_slen);

　 memset(m_bRevBuf, 0, b.m_rlen);

　 m_bComIndex = b.m_bComIndex;

　 m_hCom = b.m_hCom;

　 memset(&b.m_ComInfo, 0, sizeof(COMINFO)*MAXCOMCOUNT);

　 for(int i=0; i<MAXCOMCOUNT; i++)

　 {

　sprintf(b.m_ComInfo[i].name,"COM%d",i);

　 }

　 //网络状态为断开

　 b.SetNetState(GATE_UNCLOSE);

　 b.ReadConfig();

　}

　BaseRule::~BaseRule()

　{

　 if(m_bSendBuf)

　 {

　delete []m_bSendBuf;

　m_bSendBuf = NULL;

　 }

　 if(m_bRevBuf)

　 {

　delete []m_bRevBuf;

　m_bRevBuf = NULL;

　 }

　 if ( m_nServer != 0 )

　 {

　FreeSocket(m_nServer);

　 }

　 if (m_hCom)

　 {

　CloseHandle(m_hCom);

　 }

　}

　/*====================================================================================

　int BaseRule::BaseConnect(BYTE Channel_Type)

　{

　 int ret = 0;

　 if (!g_bSysStop)

　 {

　switch(Channel_Type)

　{

　case CHANNEL_SOCK:

　 ret = SockConnect();

　 break;

　case CHANNEL_RS232:

　 ret = CommConnect();

　 break;

　case CHANNEL_LON:

　 ret = TRUE;

　 break;

　}

　 }

　 return ret;

　}

　int BaseRule::BaseRead(int t, int ms, BYTE Channel_Type)

　{

　 int ret = 0;

　 switch(Channel_Type)

　 {

　 case CHANNEL_SOCK: //-1:fail

　ret = SockRead(m_nServer, t, ms) ;

　break;

　 case CHANNEL_RS232: //-1:fail

　//

　Sleep(t*1000);

　ret = RS232Read(300);

　break;

　// case CHANNEL_RS485:

　//

　break;

　 case CHANNEL_LON:

　//

　ret = LonRead( t );

　break;

　 default:

　break;

　 }

　 return ret;

　}

　int BaseRule::BaseSend(BYTE Channel_Type)

　{

　 int ret= 0;

　 switch(Channel_Type)

　 {

　 case CHANNEL_SOCK: //-1:fail

　ret = SockSend();

　break;

　 case CHANNEL_RS232: //-1:fail

　ret = RS232Send();

　break;

　 case CHANNEL_LON:

　//

　ret = m_pLon->LonWriteLpdu(m_nPortNo,&m_bSendVec); //RETOK,RETFAIL

　break;

　 default:

　break;

　 }

　 return ret;

　}

　 int BaseRule::SockConnect(void)

　{

　 unsigned long larg=1;

　 int iret;

　 int ipport;

　 char szIP[20];

　 int

　asock;

　 struct sockaddr_in ServerAddr; //TCP/IP SOCKET地址数据结构

　 memset(&ServerAddr,0x00,sizeof(sockaddr_in));

　 if (m_nServer != INVALID_SOCKET)

　{

　FreeSocket(m_nServer);

　 }

　 m_nServer = socket(AF_INET, SOCK_STREAM, 0);

　 if (m_nServer==INVALID_SOCKET)

　{

　return FALSE;

　 }

　 ServerAddr.sin_family = AF_INET;

　 ipport = m_iPort;//2403;//5000;//NetAddr.port;//界面??

　 ServerAddr.sin_port = htons(ipport);

　// strcpy(szIP, "10.100.100.34");

　 strcpy(szIP, m_szIPAddress);//NetAddr.NetIp);//界面??

　 //把字符串形式的IP地址转换成unsigned long型的整数值

　ServerAddr.sin_addr.s_addr = inet_addr(szIP);

　if (bind(m_nServer,(struct sockaddr *)&ServerAddr,sizeof(ServerAddr))==SOCKET_ERROR)

　 {

　FreeSocket(m_nServer);

　return FALSE;

　 }

　 if (listen(m_nServer,8) == SOCKET_ERROR)

　 {

　FreeSocket(m_nServer);

　return FALSE;

　 }

　 int sin_size=sizeof(struct sockaddr_in);

　// 服务器阻塞,直到客户程序建立连接

　 asock=accept(m_nServer,(struct sockaddr *)(&ServerAddr),&sin_size);

　 if (asock == INVALID_SOCKET)

　{

　 FreeSocket(m_nServer);

　return FALSE;

　}

　else

　{

　 FreeSocket(m_nServer);

　m_nServer=asock;

　 }

　iret = ioctlsocket(m_nServer,FIONBIO,(u_long *)&larg);

　if (iret !=0)

　{

　FreeSocket(m_nServer);

　return FALSE;

　 }

　 return TRUE;

　}

　int BaseRule::SockRead(int fd, int t, int ms)

　 {

　 fd_set readbits;

　 struct timeval timer;

　 unsigned long lBegin = 0;

　 unsigned long lEnd = 0;

　 int ret = 0;

　 int i = 0;

　 int rlen;//isec,ims;

　 int n = 256;

　// int fd = m_nServer;

　 m_wRevLen = 0;

　 timer.tv_sec = t;

　 timer.tv_usec = 0;

　FD_ZERO(&readbits);

　 FD_SET(m_nServer, &readbits);

　 lBegin = GetTickCount();

　 ret = select(fd+1, &readbits, NULL, NULL, &timer);

　 if (FD_ISSET(m_nServer, &readbits)) //有报文

　 {

　do

　{

　 Sleep(1);

　 rlen = 0;

　 for (i=m_wRevLen; i<n; i++)

　{

　//

　m_bRevVec.push_back(0);

　ret = recv(m_nServer, (char *)&m_bRevBuf[i], 1, 0);

　if (ret == 1)

　{

　 rlen ++;

　 m_wRevLen++;

　}

　else

　 {

　 break;

　}

　 }

　 //时间到退出

　 lEnd = GetTickCount();

　 unsigned long lTime = lEnd - lBegin;

　 if (((t*1000 + ms) - lTime) <=0)

　 {

　break;

　 }

　} while(rlen>0); //收不到报文退出

　 }

　 return m_wRevLen;

　}

　int BaseRule::SockSend()

　{

　 int ret = 0;

　 if( m_wSendLen > 0 )

　 {

　ret = send(m_nServer,(char *)m_bSendBuf, m_wSendLen, MSG_DONTROUTE);

　 }

　 return ret;

　}

　/*====================================================================================

　int BaseRule::FreeSocket(int &s)

　{

　 int ret;

　 ret = closesocket(s);

　 s = 0;

　 return ret;

　}

　int BaseRule::CommConnect()

　{

　 DCB dcb;

　// BYTE b=8,p=0,s=0;

　 // number of bits/byte, 4-8

　char portname[20];

　 char cportname[20];

　 DWORD dwerr,derr;

　 int comlen=0;

　 int ret = 0;

　 DWORD C_Rtimeout = 3000;

　 DWORD C_RtimeMilti = 20;

　 memcpy(&portname, m_szComm, 0); //m_szComm在config.txt中配置

　 ret = CommCheck(portname);

　 if (ret!=0)

　 {

　return true;

　 }

　 sprintf(cportname,"\\\\.\\%s",portname);

　 if ((m_ComInfo[m_bComIndex].hcom =

　 CreateFile(cportname,

　 GENERIC_READ | GENERIC_WRITE, 0, NULL,

　OPEN_EXISTING,

　 FILE_ATTRIBUTE_NORMAL|FILE_FLAG_OVERLAPPED,

　 NULL))

　== INVALID_HANDLE_VALUE)

　 {

　derr = GetLastError();

　return false;

　 }

　 ClearCommError(m_ComInfo[m_bComIndex].hcom,&dwerr,NULL);

　 derr=GetLastError();

　 if(derr!=0)

　{

　return false;

　 }

　 SetCommMask(m_ComInfo[m_bComIndex].hcom, EV_RXCHAR);

　 SetupComm(m_ComInfo[m_bComIndex].hcom, 1024, 1024);

　 derr=GetLastError();

　 if(derr!=0)

　{

　CloseHandle( m_ComInfo[m_bComIndex].hcom );

　return false;

　 }

　 ///////////////////////////////////////

　 //{

　 m_hCom = m_ComInfo[m_bComIndex].hcom;

　 m_ComInfo[m_bComIndex].flag = 1;

　 //}

　 ///////////////////////////////////////

　 GetCommState(m_ComInfo[m_bComIndex].hcom,&dcb);

　 dcb.BaudRate = m_dbBaudRate;

　//波特率baud;

　 dcb.ByteSize = m_bByteSize;

　 //数据位number of bits/byte, 4-8

　 dcb.Parity = m_bParity;

　 //校验位0-4=no,odd,even,mark,space

　 dcb.StopBits = m_bStopBits;

　//停止位0,1,2 = 1, 1.5, 2

　 SetCommState(m_ComInfo[m_bComIndex].hcom, &dcb);

　 derr=GetLastError();

　 COMMTIMEOUTS CommTimeOuts;

　 CommTimeOuts.ReadIntervalTimeout = 0x100;

　 CommTimeOuts.ReadTotalTimeoutMultiplier = C_RtimeMilti;

　 CommTimeOuts.ReadTotalTimeoutConstant = C_Rtimeout;

　 CommTimeOuts.WriteTotalTimeoutMultiplier = 10;

　 CommTimeOuts.WriteTotalTimeoutConstant =3000;

　 SetCommTimeouts(m_ComInfo[m_bComIndex].hcom, &CommTimeOuts);

　derr=GetLastError();

　 PurgeComm(m_ComInfo[m_bComIndex].hcom,PURGE_TXCLEAR|PURGE_RXCLEAR);

　 return true;

　}

　int BaseRule::CommCheck(char *sysname)

　{

　 int i = 0;

　 int ret = false;

　 if (m_bComIndex > 0)

　 {//更换

　m_ComInfo[m_bComIndex].flag--;

　if (m_ComInfo[m_bComIndex].flag <= 0)

　{

　 CloseHandle(m_ComInfo[m_bComIndex].hcom);

　 m_ComInfo[m_bComIndex].hcom = NULL;

　}

　m_bComIndex = 0;

　 }

　 if (m_bComIndex <= 0)

　 {

　for (i=0; i<MAXCOMCOUNT; i++)

　{

　 if (!strcmp(m_ComInfo[i].name, sysname))

　 {

　m_bComIndex = i;

　if (m_ComInfo[i].flag > 0)break;

　 }

　}

　if (i < MAXCOMCOUNT)

　{

　 m_hCom = m_ComInfo[i].hcom;

　 m_ComInfo[i].flag ++;

　 ret = true;

　}

　 }

　 return ret;

　}

　int BaseRule::RS232Send()

　{

　 OVERLAPPED OlWRtu;

　DWORD byte1,byte2=0;

　 BOOL waitflag;

　 memset(&OlWRtu,0,sizeof(OlWRtu));

　 OlWRtu.hEvent=NULL;

　 if (m_ComInfo[m_bComIndex].hcom != NULL)

　{

　WriteFile(m_ComInfo[m_bComIndex].hcom, m_bSendBuf, m_wSendLen, &byte1, &OlWRtu);

　waitflag = GetOverlappedResult(m_ComInfo[m_bComIndex].hcom, &OlWRtu, &byte2, TRUE);

　 }

　 if( (int) byte2!=m_wSendLen)

　{

　byte2 = -1;

　 }

　 return byte2;

　}

　int BaseRule::RS232Read(int n)

　{

　 OVERLAPPED OlWRtu;

　DWORD byte1,byte2=0;

　 BOOL waitflag=FALSE;

　 memset(&OlWRtu,0,sizeof(OlWRtu));

　 OlWRtu.hEvent=NULL;

　 if(m_ComInfo[m_bComIndex].hcom != NULL)

　{

　ReadFile(m_ComInfo[m_bComIndex].hcom, m_bRevBuf, n, &byte1, &OlWRtu);

　waitflag = GetOverlappedResult(m_ComInfo[m_bComIndex].hcom, &OlWRtu, &byte2, TRUE);

　 }

　 if(waitflag && byte2>0 )

　 {

　m_wSendLen = (short)byte2;

　byte2 = -1;

　 }

　 return byte2;

　}

　void BaseRule::SetNetState(enum GateDevStatus state)

　{

　 GateNetAddr

　n_addr;

　 g_glonet.GetNetAddr(n_addr);

　 switch(m_nPortNo)

　 {

　 case RULE_CDT:

　//CDT规约

　{

　 break;

　}

　 case RULE_ENGINEER:

　//103规约，工程师站

　{

　 n_addr.ENGINEERNet.eNetState = state;

　 break;

　}

　 case RULE_REMOTE: //104规约，远动站

　{

　 n_addr.REMOTENet.eNetState = state;

　 break;

　}

　 case RULE_OPERATER: //104规约，操作员站

　{

　 n_addr.OPERATERNet.eNetState = state;

　 break;

　}

　 default:

　break;

　 }

　g_glonet.InsNetAddr(n_addr);

　}

　void BaseRule::GetNetAddr(GateIpPort &netaddr)

　{

　 GateNetAddr

　n_addr;

　 g_glonet.GetNetAddr(n_addr);

　 switch(m_nPortNo)

　 {

　 case RULE_CDT:

　//CDT规约

　{

　 break;

　}

　 case RULE_ENGINEER:

　//103规约，工程师站

　{

　 memcpy(&netaddr, &n_addr.ENGINEERNet, sizeof(GateIpPort));//确认OPERATENet??

　 break;

　}

　 case RULE_REMOTE: //104规约，远动站

　{

　 memcpy(&netaddr, &n_addr.REMOTENet, sizeof(GateIpPort));//确认OPERATENet??

　 break;

　}

　 case RULE_OPERATER: //104规约，操作员站

　{

　 memcpy(&netaddr, &n_addr.OPERATERNet, sizeof(GateIpPort));//确认OPERATENet??

　 break;

　}

　 default:

　break;

　 }

　return;

　}

　void BaseRule::GetGateStation(enum GateStation &eStation)

　{

　 switch(m_nPortNo)

　 {

　 case RULE_CDT:

　//CDT规约

　{

　 break;

　}

　 case RULE_ENGINEER:

　//103规约，工程师站

　{

　 eStation = GATE_ENGINEERSTATION;

　 break;

　}

　 case RULE_REMOTE: //104规约，远动站

　{

　 eStation = GATE_REMOTESTATION;

　 break;

　}

　 case RULE_OPERATER: //104规约，操作员站

　{

　 eStation = GATE_OPERATERSTATION;

　 break;

　}

　 default:

　break;

　 }

　 }

　void BaseRule::ReadConfig()

　{

　 FILE*

　fp = NULL;

　 m_iAddress = 0;

　 m_iPort = 0;

　 memset(m_szIPAddress, 0, sizeof(char)*20);

　 memset(m_szComm, 0, sizeof(char)*20);

　 m_dbBaudRate = 9600; //波特率baud;

　 m_bByteSize = 8;

　//数据位number of bits/byte, 4-8

　m_bParity = 0;

　//校验位0-4=no,odd,even,mark,space

　m_bStopBits = 0;

　//停止位0,1,2 = 1, 1.5, 2

　 fp = fopen("config.txt", "r");

　 if (fp == NULL)

　 {

　strcpy(m_szIPAddress, "10.100.100.7");

　m_iAddress = 1;

　m_iPort = 2403;

　 }

　 else

　 {

　//地址

　m_iAddress = GetFileValue(fp);

　//IP地址

　GetFileChar(fp, m_szIPAddress);

　//IP端口号

　m_iPort = GetFileValue(fp);

　//串口地址

　GetFileChar(fp, &m_szComm[0]);

　//波特率baud

　m_dbBaudRate = GetFileValue(fp);

　//数据位number of bits/byte, 4-8

　 m_bByteSize = GetFileValue(fp);

　//校验位0-4=no,odd,even,mark,space

　 m_bParity = GetFileValue(fp);

　//停止位0,1,2 = 1, 1.5, 2

　m_bStopBits = GetFileValue(fp);

　if (fp != NULL)

　{

　 fclose(fp);

　}

　 }

　 }

　DWORD BaseRule::GetFileValue(FILE *fp)

　{

　 int val,idx;

　 char szStr[80];

　 char szNum[20];

　 string s;

　 fscanf(fp, "%s\n", szStr);

　//position year

　 s = szStr;

　 idx = s.find('=');

　 memcpy(szNum, &szStr[idx+1], 20);

　 val = atoi(szNum);

　 return val;

　}

　void BaseRule::GetFileChar(FILE *fp, char pcRead[])

　{

　 int idx;

　 char szStr[80];

　 string s;

　 fscanf(fp, "%s\n", szStr);

　 s = szStr;

　 idx = s.find('=');

　 memcpy(pcRead, &szStr[idx+1], 20);

　}

　/*************************************************************/

　#include <windows.h>

　#include "stdio.h"

　#include "ext.h"

　#include "cdt.h"

　#include "ntdef.h"

　#include "gatetime.h"

　CCDT::CCDT(BYTE no, short rlen, short slen) : BaseRule(no,rlen,slen)

　{

　 memcpy(m_bBchTable, G_bBchTable, 256);

　 m_bHeadEB = 0;

　 m_bHead90 = 0;

　 m_bSerial = 0;

　//解包数据序号

　 m_bSyncFlag = FIND_HEAD;

　//同步字类型

　 m_nCtrlNumber = 0;

　 //遥控号，初始成0好像有问题??

　 m_bCtrlType = 0;

　//控分控合

　 m_bControl = 0;

　//控制字节

　 m_bFrameType = 0;

　//帧类别

　 m_bInfoNumber = 0;

　 //信息字数

　 memset(&m_bInfoBuf, 0, sizeof(m_bInfoBuf)); //解包数据信息

　 for (int i=0; i<6; i+=2)

　 {

　m_bSendBuf[i] = 0xeb;

　m_bSendBuf[i+1] = 0x90;

　 }

　}

　CCDT::~CCDT()

　{

　}

　void CCDT::RuleLoop(void)

　{

　 int nResult = 0; //返回值变量

　 int i = 0;

　//一般变量]

　 unsigned long i_start;

　//收到报文判断开始

　 unsigned long i_end;

　//结束时间

　 int tstop = 30;//??????

　 i_start = GetTickCount(); //初始化

　 i_end = GetTickCount();

　//初始化

　 g_glonet.InsDevStatus(GATE_UNCLOSE);

　 //??测试使用

　 m_begin = GetTickCount();

　 while (1)

　 {

　if (g_bSysStop)

　 {

　 break;

　}

　//??测试使用

　TimeTest();

　if (BaseConnect(CHANNEL_RS232) == 0)

　{

　 Sleep(10);//函数最小分辨率为10

　 continue;

　}

　while (1)

　 {

　 Sleep(10);

　//

　 PackData();

　//

　 BaseSend();

　 nResult = BaseRead(1, 0, CHANNEL_SOCK);// RS232Read(300);

　 if (nResult>0)

　 {

　i_start = GetTickCount();

　g_glonet.InsDevStatus(GATE_CLOSE);

　for (i=0; i<nResult; i++)

　 {

　 PreUnpackData(m_bRevBuf[i]);

　}

　 }

　 else

　 {

　i_end = GetTickCount();

　if ((i_end-i_start)/1000>tstop)

　 {

　 g_glonet.InsDevStatus(GATE_UNCLOSE);

　 break;

　}

　 }

　}

　 }

　 return;

　}

　/*====================================================================================

　void CCDT::PreUnpackData(BYTE bRead)

　{

　 if (bRead == m_bHeadEB)

　{

　m_bHeadEB++;

　 }

　 else if ((bRead == 0x90) && (m_bHeadEB > 0) )

　{

　m_bHead90++;

　 }

　 else

　{

　 m_bHeadEB = 0;

　 m_bHead90 = 0;

　 }

　 if ( (m_bHeadEB == 3) && (m_bHead90 == 3) )

　 {

　m_bHeadEB = 0;

　m_bHead90 = 0;

　m_bSerial = 0;

　 m_bSyncFlag = SYN_HEAD;

　return;

　 }

　 if (m_bSyncFlag == SYN_HEAD)

　 {

　m_bInfoBuf[m_bSerial] = bRead;

　m_bSerial ++;

　if (m_bSerial >= 6)

　 {

　 m_bSerial = 0;

　 if ( CheckRevCode() )

　 {

　m_bInfoNumber = m_bInfoBuf[2];

　m_bControl

　= ((m_bInfoBuf[0]&0x80) != 0) ? 1:0;

　m_bFrameType = m_bInfoBuf[1];

　if ((m_bInfoNumber > 0) && (m_bInfoBuf[1] != 0xf9) )

　 {

　 m_bSyncFlag = PACK_DATA;

　}

　else

　 {

　 m_bSyncFlag = FIND_HEAD;

　}

　 }

　 else

　{

　m_bSyncFlag = FIND_HEAD;

　 }

　 return;

　}

　 }

　 if (m_bSyncFlag == PACK_DATA)

　 {

　m_bInfoBuf[m_bSerial] = bRead;

　m_bSerial++;

　if (m_bSerial >= 6)

　 {

　 m_bSerial = 0;

　 if (CheckRevCode())

　 {

　UnpackData();

　 }

　 else

　{ //error rate

　m_bSyncFlag = FIND_HEAD;

　 }

　 if( m_bInfoNumber > 0)

　{

　m_bInfoNumber--;

　 }

　 if( m_bInfoNumber == 0 )

　 {

　m_bSyncFlag = FIND_HEAD;

　 }

　}

　 }

　}

　/*====================================================================================

　bool CCDT::CheckRevCode()

　{

　 bool

　 bResult = false; //返回值

　 unsigned char temp = 0x00; //临时变量

　 for (int i=0; i<5; i++)

　 {

　temp = temp ^ m_bInfoBuf[i];

　temp = m_bBchTable[temp];

　 }

　 temp = temp ^ 0xff;

　 if (temp

　== m_bInfoBuf[5])

　 {

　bResult = true;

　 }

　 return bResult;

　}

　void CCDT::CheckSendCode(int no)

　{

　 unsigned char temp = 0x00; //临时变量

　 for (int i=0; i<5; i++)

　 {

　temp = temp ^ m_bSendBuf[no+i];

　temp = m_bBchTable[temp];

　 }

　 temp = temp ^ 0xff;

　 m_bSendBuf[no+5] = temp;

　}

　{

　 int nOrder = 0;

　//序号

　 short nValue = 0;

　//数值

　// BYTE cstatus;

　// short pyx;

　// char szStr[20];

　 enum FUNC_TYPE eFuncType = FUNC_NONE; //功能码类型

　 GetFunType(eFuncType);

　// if( eFuncType != m_ePreFuncType && m_ePreFuncType == BAOHU_KIND )

　 // {//notify

　//

　Fill_BaoHuNotify();

　//

　m_ePreFuncType = eFuncType;

　// }

　 if( eFuncType != m_ePreFuncType && m_ePreFuncType == FUNC_YK_UP )

　{

　//

　CTRL_Proc(VARTYPE_YX,0,0,1);

　 }

　 if( eFuncType != m_ePreFuncType && m_ePreFuncType == FUNC_YT_UP )

　{

　//

　CTRL_Proc(VARTYPE_YT,0,0,1);

　 }

　 m_ePreFuncType = eFuncType;

　 switch(eFuncType)

　 {

　 case FUNC_YC: //遥测

　PutYC();

　break;

　case FUNC_YX: //遥信

　PutYX();

　break;

　 case FUNC_DD://电能脉冲计数值

　PutDD();

　break;

　 case FUNC_SOE://事件顺序纪录

　PutSOE();

　break;

　 case FUNC_YK_UP://遥控返校

　PutYK(INFDATA_YK_SEL);

　break;

　 case FUNC_YT_UP://升降返校

　//

　if( m_bInfoBuf[1] == 0x33) CTRL_Proc(VARTYPE_YT,0,m_bInfoBuf[2],0);

　//

　else CTRL_Proc(VARTYPE_YT,1,m_bInfoBuf[2],0);

　break;

　 case FUNC_HZ://频率

　PutHZ();

　break;

　 case FUNC_YC_ADD://总加遥测

　break;

　 case FUNC_WHITE://水位

　//

　lValue = HexToBCD(m_bInfoBuf[1]) + HexToBCD(m_bInfoBuf[2])*100+HexToBCD(m_bInfoBuf[3])*10000;

　break;

　// case BAOHU_KIND:

　//

　lValue = ((m_bInfoBuf[4]*256+m_bInfoBuf[3])*256+m_bInfoBuf[2])*256+m_bInfoBuf[1];

　//

　PutBHDZValue(m_bInfoBuf[0],lValue);

　break;

　 default:

　break;

　 }

　 return;

　}

　int CCDT::GetFunType(enum FUNC_TYPE &eFunc)

　{

　 unsigned char bFunc;

　//功能码

　 bool

　 bResult = 1; //返回值

　 bFunc = m_bInfoBuf[0];

　 if (m_bControl==0)

　 {

　if (bFunc >= 0x00 && bFunc < 0x80 )

　 {

　 eFunc = FUNC_YC;

　 //遥测

　}

　else if (bFunc == 0x8a)

　 {

　 eFunc = FUNC_HZ;

　 //频率

　}

　else if ((bFunc >=0x8d) && (bFunc<0x93))

　{

　 eFunc = FUNC_WHITE;

　//水位

　}

　else if ((bFunc >= 0x86) && (bFunc <= 0x89))

　 {

　 eFunc = FUNC_YC_ADD;

　//总加遥测

　}

　else if ((bFunc >= 0xf0) && (bFunc <= 0xff))

　{

　 eFunc = FUNC_YX;

　//遥信

　}

　else if (bFunc == 0xe1)

　 {

　 eFunc = FUNC_YK_UP; //遥控返校

　}

　else if (bFunc == 0xe5)

　 {

　 eFunc = FUNC_YT_UP; //升降返校

　}

　else if ((bFunc >= 0xa0) && (bFunc < 0xe0))

　{

　 eFunc = FUNC_DD;

　//电能脉冲，D2帧

　}

　else if ((bFunc == 0x80) || (bFunc==0x81))

　{

　 eFunc = FUNC_SOE;

　//事件顺序纪录

　}

　else

　{

　 bResult = 0;

　}

　 }

　 else

　{

　//

　if ((m_bFrameType == 0x3d) && ((eFunc>=0x00) && (eFunc< 0x40)))

　 //

　{

　//

　 eFunc = BAOHU_KIND;

　//

　}

　//

　else if ((m_bFrameType == 0x3d) && (eFunc ==0x96))

　 //

　{//notify

　//

　 if(m_bInfoBuf[1] ==0xa5) Fill_BaohuValueEvt(0,0,PortNo); //ok

　//

　 else Fill_BaohuValueEvt(0,1,PortNo);

　//fail

　//

　 return;

　//

　}

　//

　else return;

　bResult = 0;

　 }

　 return bResult;

　}

　void CCDT::PutYC(void)

　{

　 unsigned short nOrder = 0;

　//序号

　 unsigned short nValue = 0;

　//数值

　 unsigned short nData = 0;

　//上送数据

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 nOrder = m_bInfoBuf[0] * 2;

　 for (int i=0; i<2; i++)

　 {

　nValue = m_bInfoBuf[i*2+1] + (m_bInfoBuf[i*2+2] & 0x07) * 0x100;

　DataGroup.bLocal = 0;

　DataGroup.eType = DATA_YC;

　//

　DataGroup.nAddress = m_nAddr;

　DataGroup.nPortNo = m_nPortNo;

　DataGroup.nSerial = nOrder +i;

　nData = (nValue & 0x07ff) >> 3;

　//负数

　if (m_bInfoBuf[i*2+2] & 0x08)

　{

　 nData =

　nData | 0x80;

　}

　if (m_bInfoBuf[i*2+2] & 0x80)

　{

　 nData =

　nData | 0x02; //无效

　}

　else if (m_bInfoBuf[i*2+2] & 0x40)

　{

　 nData =

　nData | 0x01; //溢出

　}

　DataGroup.nValue = nData;

　g_devdata.InsDevData(&DataGroup, 1);

　 }

　 return;

　}

　/*====================================================================================

　void CCDT::PutYX(void)

　{

　 int

　 nOrder = 0;

　//序号

　 unsigned short nValue = 0;

　//数值

　 int

　 nNumber = 0; //存储序号

　 int

　 i = 0;

　//一般变量

　 int

　 j = 0;

　//一般变量

　 SYSTEMTIME

　systime;

　//时间结构体

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 SOE_STATUS

　SoeStatus;

　//事件结构体

　memset(&SoeStatus, 0, sizeof(SOE_STATUS));

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 GetLocalTime(&systime);

　 nOrder = (m_bInfoBuf[0] - 0xf0) * 32;

　 for (i=0; i<4; i++)

　 {

　unsigned char m = 0;

　for (j=0; j<8; j++)

　{

　 nNumber = nOrder + i*8 + j;

　 m = 1 << j;

　 if ((m_bInfoBuf[i+1] & m)== 0x00 )

　{

　nValue = 1;//换算成双点

　 }

　 else

　{

　nValue = 2;

　 }

　 g_devdata.GetFixDevData(m_nPortNo, nNumber, DATA_YX, DataGroup);

　 if (DataGroup.nValue != nValue)

　 {

　if (m_nCtrlNumber = nNumber)

　{

　 PutYK(INFDATA_YK_EXE, false); //遥控执行成功

　}

　SoeStatus.bAddress = 0x01; //固定值??

　SoeStatus.nPot = nNumber;

　SoeStatus.bStatus = nValue;

　SoeStatus.wMilliseconds = systime.wMilliseconds + (systime.wSecond & 0xff) * 1000;

　//

　SoeStatus.bSecond = systime.wMilliseconds / 1000;

　SoeStatus.bMinute = systime.wMinute & 0x3f;

　SoeStatus.bHour = systime.wHour & 0x1f;

　SoeStatus.bDay = systime.wDay & 0x3f;

　SoeStatus.eType = INFDATA_YX;

　SoeStatus.eStation = GATE_REMOTESTATION; //远动站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_OPERATERSTATION; //操作员站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_ENGINEERSTATION; //工程师站

　g_soedata.InsSoeData(SoeStatus);

　g_devdata.InsDevData(&DataGroup, 1);

　 }

　}

　 }

　 return;

　}

　void CCDT::PutSOE(void)

　{

　 SOE_STATUS

　SoeStatus;

　//事件结构体

　memset(&SoeStatus, 0, sizeof(SOE_STATUS));

　 if(m_bInfoBuf[0]==0x80)

　 {

　m_bSoe80 = 0x80;

　memcpy(&m_bSoeBuf[0],&m_bInfoBuf[0],6);

　 }

　 if(m_bInfoBuf[0]==0x81 && m_bSoe80 == 0x80)

　 {

　m_bSoe80 = 0x00;

　memcpy(&m_bSoeBuf[6],&m_bInfoBuf[0],6);

　SoeStatus.bAddress = 0x01; //固定值??

　SoeStatus.nPot = m_bSoeBuf[9] + (m_bSoeBuf[10] & 0x0f) * 256;

　SoeStatus.bStatus = m_bSoeBuf[10] & 0x80;

　SoeStatus.wMilliseconds = (m_bSoeBuf[2] & 0x03 ) * 256 + m_bSoeBuf[1]

　+ (m_bSoeBuf[3] & 0x3f) * 1000;

　//

　SoeStatus.bSecond = m_bSoeBuf[3];

　SoeStatus.bMinute = m_bSoeBuf[4];

　SoeStatus.bHour = m_bSoeBuf[7];

　SoeStatus.bDay = m_bSoeBuf[8];

　SoeStatus.eType = INFDATA_SOE;

　//

　SoeStatus.wSerial = m_bSoeBuf[9] + (m_bSoeBuf[10] & 0x0f) * 0x100;

　SoeStatus.eStation = GATE_REMOTESTATION; //远动站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_OPERATERSTATION; //操作员站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_ENGINEERSTATION; //工程师站

　g_soedata.InsSoeData(SoeStatus);

　 }

　 return;

　}

　void CCDT::PutDD(void)

　{

　 unsigned short nOrder = 0;

　//序号

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 nOrder = m_bInfoBuf[0] - 0xa0;

　 DataGroup.bLocal = 0;

　 DataGroup.eType = DATA_DD;

　// DataGroup.nAddress = m_nAddr;

　 DataGroup.nPortNo = m_nPortNo;

　 DataGroup.nSerial = nOrder;

　 DataGroup.nValue = (((m_bInfoBuf[4]&0x0f) * 256 + m_bInfoBuf[3]) * 256

　+ m_bInfoBuf[2]) * 256 + m_bInfoBuf[1];

　 g_devdata.InsDevData(&DataGroup, 1);

　 return;

　}

　void CCDT::PutYK(enum INFO_TYPE eType, bool bFailFlag)

　{

　 SYSTEMTIME

　systime;

　//时间结构体

　 SOE_STATUS

　SoeStatus;

　//事件结构体

　memset(&SoeStatus, 0, sizeof(SOE_STATUS));

　 GetLocalTime(&systime);

　 SoeStatus.bAddress = 0x01;

　//固定值??

　// SoeStatus.nPot = m_bInfoBuf[2];

　 if (eType == INFDATA_YK_EXE)

　 {

　SoeStatus.nPot = m_nCtrlNumber;

　if (bFailFlag)

　{

　 SoeStatus.bStatus = 0;

　}

　else

　{

　 SoeStatus.bStatus = m_bCtrlType;

　}

　 }

　 else if (eType == INFDATA_YK_SEL)

　 {

　if (bFailFlag) //遥控失败

　{

　 SoeStatus.nPot = m_nCtrlNumber;

　 SoeStatus.bStatus = 0x00;

　 }

　else

　{

　 SoeStatus.nPot = m_bInfoBuf[2];

　 if (m_bInfoBuf[1] == 0x33)

　 {

　SoeStatus.bStatus = 1;

　 }

　 else if (m_bInfoBuf[1] == 0xcc)

　 {

　SoeStatus.bStatus = 2;

　 }

　 else

　 {

　SoeStatus.bStatus = 0;

　 }

　}

　 }

　 SoeStatus.wMilliseconds = systime.wMilliseconds + (systime.wSecond & 0xff) * 1000;

　 SoeStatus.bMinute = systime.wMinute & 0x3f;

　 SoeStatus.bHour = systime.wHour & 0x1f;

　 SoeStatus.bDay = systime.wDay & 0x3f;

　 SoeStatus.eType = eType;

　 SoeStatus.eStation = GATE_REMOTESTATION;

　//远动站

　 g_soedata.InsSoeData(SoeStatus);

　 SoeStatus.eStation = GATE_OPERATERSTATION; //操作员站

　 g_soedata.InsSoeData(SoeStatus);

　 SoeStatus.eStation = GATE_ENGINEERSTATION; //工程师站

　 g_soedata.InsSoeData(SoeStatus);

　 m_nCtrlNumber = 0;

　 m_bCtrlType = 0;

　 return;

　}

　void CCDT::PutHZ(void)

　{

　 unsigned short nOrder = 0;

　//序号

　 int

　 val1 = 0;

　//数值1

　 int

　 val2 = 0;

　//数值2

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 nOrder = m_bInfoBuf[0] - 0x8a;

　 DataGroup.bLocal = 0;

　 DataGroup.eType = DATA_HZ;

　// DataGroup.nAddress = m_nAddr;

　 DataGroup.nPortNo = m_nPortNo;

　 DataGroup.nSerial = nOrder;

　 val1 = HexToBCD(m_bInfoBuf[1]);

　 val2 = HexToBCD(m_bInfoBuf[2]);

　 if ((val1>=0) && (val2>=0))

　 {

　DataGroup.nValue = val1 + val2 * 100;

　g_devdata.InsDevData(&DataGroup, 1);

　 }

　 return;

　}

　void CCDT::PackData(void)

　{

　 int

　 nResult = 0; //常用变量，返回值

　 unsigned short nTime = 0;

　//时间变量

　 int

　 nOffset = 0; //延时时间

　 SYSTEMTIME

　newtime;

　//时间结构

　 CTRL_VALUE

　CtrlValue;

　//下发命令结构体

　 PansTime

　pt;

　 //时间类

　 memset(&CtrlValue, 0x00, sizeof(CTRL_VALUE));

　 nResult = TimeCheck();

　 if (nResult != 0)

　 {

　return;

　 }

　 nResult = g_soedata.GetCtrlData(CtrlValue);

　 if (nResult == 0)

　 {

　m_eCmdCode = COMMAND_NONE;

　 }

　 else

　 {

　m_eCmdCode = CtrlValue.eCmdType;

　 }

　 switch (m_eCmdCode)

　 {

　 case COMMAND_SEL_CTRL:

　//控制选择

　m_bSendBuf[6] = 0x71;

　m_bSendBuf[7] = 0x61;

　m_bSendBuf[8] = 0x03;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;??配置

　m_bSendBuf[10] = 0x01;//配置??

　CheckSendCode(6);

　m_bSendBuf[12] = 0xe0;

　if (CtrlValue.iValue == 1)

　{

　 m_bSendBuf[13] = 0x33;

　}

　else if (CtrlValue.iValue == 2)

　{

　 m_bSendBuf[13] = 0xcc;

　}

　m_bSendBuf[14] = CtrlValue.nPotValue;

　m_bSendBuf[15] = m_bSendBuf[13];

　m_bSendBuf[16] = m_bSendBuf[14];

　CheckSendCode(12);

　memcpy(&m_bSendBuf[18], &m_bSendBuf[12], 6); //连送三个相同的信息字

　memcpy(&m_bSendBuf[24], &m_bSendBuf[12], 6);

　m_wSendLen = 30;

　m_nCtrlNumber = CtrlValue.nPotValue;

　m_bCtrlType = CtrlValue.iValue;

　break;

　 case COMMAND_EXE_CTRL:

　//控制执行

　m_bSendBuf[6] = 0x71;

　m_bSendBuf[7] = 0xc2;

　m_bSendBuf[8] = 0x03;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;??配置

　m_bSendBuf[10] = 0x01;//配置??

　CheckSendCode(6);

　m_bSendBuf[12] = 0xe2;

　m_bSendBuf[13] = 0xaa;

　m_bSendBuf[14] = CtrlValue.nPotValue;

　m_bSendBuf[15] = m_bSendBuf[13];

　m_bSendBuf[16] = m_bSendBuf[14];

　CheckSendCode(12);

　memcpy(&m_bSendBuf[18], &m_bSendBuf[12], 6); //连送三个相同的信息字

　memcpy(&m_bSendBuf[24], &m_bSendBuf[12], 6);

　m_wSendLen = 30;

　m_nCtrlNumber = CtrlValue.nPotValue;

　m_bCtrlType = CtrlValue.iValue;

　break;

　 case COMMAND_CANCEL_CTRL:

　//控制撤消

　m_bSendBuf[6] = 0x71;

　m_bSendBuf[7] = 0xb3;

　m_bSendBuf[8] = 0x03;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;??配置

　m_bSendBuf[10] = 0x01;//配置??

　CheckSendCode(6);

　m_bSendBuf[12] = 0xe3;

　m_bSendBuf[13] = 0x55;

　m_bSendBuf[14] = CtrlValue.nPotValue;

　m_bSendBuf[15] = m_bSendBuf[13];

　m_bSendBuf[16] = m_bSendBuf[14];

　CheckSendCode(12);

　memcpy(&m_bSendBuf[18], &m_bSendBuf[12], 6); //连送三个相同的信息字

　memcpy(&m_bSendBuf[24], &m_bSendBuf[12], 6);

　m_wSendLen = 30;

　break;

　case COMMAND_BAOHU_RESET:

　//保护复归

　m_bSendBuf[6] = 0x31;

　m_bSendBuf[7] = 0x3d;

　 m_bSendBuf[8] = 0x00;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;??

　m_bSendBuf[10] = 0x01;

　CheckSendCode(6);

　m_wSendLen = 12;

　//

　m_bSendBuf[6] = 0xf0; //自定义格式

　//

　m_bSendBuf[7] = 0x3d;

　 //

　m_bSendBuf[8] = 0x01;

　//

　m_bSendBuf[9] = RtuID;

　//

　m_bSendBuf[10] = 0x01;

　//

　Check_SendCode(6);

　//

　m_bSendBuf[12] = 0x9f;

　//

　m_bSendBuf[13] = 0xaa;

　 //

　m_bSendBuf[14] = rtu_debug.pdata[0];

　//

　m_bSendBuf[15] = 0xaa;

　//

　m_bSendBuf[16] = SendBuf[14];

　//

　Check_SendCode(12);

　//

　m_wSendLen = 18;

　break;

　 case COMMAND_AMMETER:

　 //冻结电度

　m_bSendBuf[6] = 0x21;

　m_bSendBuf[7] = 0x9e;

　 m_bSendBuf[8] = 0x00;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;??

　m_bSendBuf[10] = 0xff;

　//广播命令

　CheckSendCode(6);

　m_wSendLen = 12;

　break;

　 case COMMAND_CALI_TIME:

　 //对时

　m_bSendBuf[6] = 0x70;

　m_bSendBuf[7] = 0x7a;

　m_bSendBuf[8] = 0x02;

　m_bSendBuf[9] = CtrlValue.bAddress;//RtuID;配置

　m_bSendBuf[10]= 0x01;

　//destination

　CheckSendCode(6);

　m_bSendBuf[12]= 0xee;

　//

　try

　//

　{

　//

　 Fetch_VDTSysInfo(PortNo,BAUD,(void *)&baud);

　//

　 msoff= 240000/baud;

　//

　}

　//

　catch( ... ) {}

　//

　SYSTEMTIME newtime;

　pt.GetCurTime(&newtime);

　nOffset = 240000 / 600;//分母为波特率

　newtime.wMilliseconds += nOffset;

　if (newtime.wMilliseconds > 999)

　{

　 newtime.wMilliseconds -= 1000;

　 pt.TimeAdd(&newtime, 1);

　}

　m_bSendBuf[13] = (BYTE)(newtime.wMilliseconds % 256);

　m_bSendBuf[14] = (BYTE)(newtime.wMilliseconds / 256);

　m_bSendBuf[15] = (BYTE)newtime.wSecond;;

　m_bSendBuf[16] = (BYTE)newtime.wMinute;

　CheckSendCode(12);

　m_bSendBuf[18] = 0xef;

　m_bSendBuf[19] = (BYTE)newtime.wHour;

　m_bSendBuf[20] = (BYTE)newtime.wDay;

　m_bSendBuf[21] = (BYTE)newtime.wMonth;

　m_bSendBuf[22] = (BYTE)(newtime.wYear % 100);

　CheckSendCode(18);

　m_wSendLen = 24;

　break;

　 case COMMAND_NONE:

　 //空命令

　break;

　 case COMMAND_SET_RYB:

　 //软压板

　break;

　 default:

　break;

　 }

　 m_ePreCode = m_eCmdCode;

　 m_eCmdCode = COMMAND_NONE;

　#ifdef SYNC_HEADBB

　 if (m_wSendLen < 1)

　{

　m_wSendLen = 6;

　 }

　#endif

　}

　int CCDT::TimeCheck(void)

　{

　 int

　 nResult = 0;

　//返回值变量

　 unsigned long lTimeEnd = 0;

　//结束时刻

　 unsigned long lUsingTime = 0;

　//溢出时间

　 bool

　 bFlag = false;

　//失败参数

　 if ((m_ePreCode == COMMAND_SEL_CTRL) //控制选择

　||(m_ePreCode == COMMAND_EXE_CTRL)) //控制执行

　 {

　lTimeEnd = GetTickCount();

　lUsingTime = (lTimeEnd - m_lTimeBegin) / 1000;

　if (lUsingTime > TIMEOUT)

　{

　 if (m_ePreCode == COMMAND_SEL_CTRL)

　//控制选择

　 {

　m_ePreCode = COMMAND_NONE;

　bFlag = true;

　PutYK(INFDATA_YK_SEL, bFlag);

　//遥控返校失败

　 }

　 else if (m_ePreCode == COMMAND_EXE_CTRL) //控制执行

　 {

　//

　CommandReturn(INF_SWITCH, RESULT_FAIL);

　 }

　}

　else

　 {

　 nResult = 1;

　}

　 }

　 else

　 {

　m_lTimeBegin = GetTickCount();

　 }

　 return nResult;

　}

　int CCDT::HexToBCD(unsigned char bHex)

　{

　 int nResult = -1;

　 if (((bHex >> 4) < 10)

　|| ((bHex & 0x0f) < 10))

　 {

　nResult = ((bHex & 0xf0) /16) * 10 + (bHex & 0x0f);

　 }

　 return nResult;

　}

　void CCDT::TestPutYX(void)

　{

　 int

　 i = 0;

　//一般变量

　 SYSTEMTIME

　systime;

　//时间结构体

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 SOE_STATUS

　SoeStatus;

　//事件结构体

　memset(&SoeStatus, 0, sizeof(SOE_STATUS));

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 GetLocalTime(&systime);

　 for (i=0; i<43; i++)

　 {

　SoeStatus.bAddress = 0x01; //固定值??

　SoeStatus.nPot = i;

　SoeStatus.bStatus = rand()%2+1;

　SoeStatus.wMilliseconds = systime.wMilliseconds + (systime.wSecond & 0xff) * 1000;

　SoeStatus.bMinute = systime.wMinute & 0x3f;

　SoeStatus.bHour = systime.wHour & 0x1f;

　SoeStatus.bDay = systime.wDay & 0x3f;

　SoeStatus.eType = INFDATA_YX;

　SoeStatus.eStation = GATE_REMOTESTATION; //远动站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_OPERATERSTATION; //操作员站

　g_soedata.InsSoeData(SoeStatus);

　SoeStatus.eStation = GATE_ENGINEERSTATION; //工程师站

　g_soedata.InsSoeData(SoeStatus);

　g_devdata.InsDevData(&DataGroup, 1);

　 }

　 return;

　}

　void CCDT::TestPutSOE(void)

　{

　 SOE_STATUS

　SoeStatus;

　//事件结构体

　SYSTEMTIME

　systime;

　//时间结构体

　 DATAGROUP

　DataGroup;

　//存储数据结构体

　 memset(&DataGroup, 0x00, sizeof(DATAGROUP));

　 memset(&SoeStatus, 0, sizeof(SOE_STATUS));

　 GetLocalTime(&systime);

　 SoeStatus.bAddress = 0x01; //固定值??

　 SoeStatus.nPot = 17;//m_bSoeBuf[9] + (m_bSoeBuf[10] & 0x0f) * 256;

　 SoeStatus.bStatus = rand()%2+1;//m_bSoeBuf[10] & 0x80;

　 SoeStatus.wMilliseconds = systime.wMilliseconds + (systime.wSecond & 0xff) * 1000;

　 SoeStatus.bMinute = systime.wMinute & 0x3f;

　 SoeStatus.bHour = systime.wHour & 0x1f;

　 SoeStatus.bDay = systime.wDay & 0x3f;

　 SoeStatus.eType = INFDATA_SOE;

　 SoeStatus.eStation = GATE_REMOTESTATION; //远动站

　 g_soedata.InsSoeData(SoeStatus);

　 SoeStatus.eStation = GATE_OPERATERSTATION; //操作员站

　 g_soedata.InsSoeData(SoeStatus);

　 SoeStatus.eStation = GATE_ENGINEERSTATION; //工程师站

　 g_soedata.InsSoeData(SoeStatus);

　 return;

　}

　int CCDT::TimeTest()

　{

　 int i=0;

　 unsigned long YXend;

　//间隔30秒送一次状态

　 YXend = GetTickCount();

　 if ((YXend - m_begin)/1000 > 30)

　{

　m_begin = GetTickCount();

　//

　TestPutYX();

　TestPutSOE();

　return 1;

　 }

　 return 0;

　 }

　/*******************************************************