nrlan103def.h

电力故障信息采集,主要是针对南自的保护装置,这个程序用在Linux操作系统下

#ifndef NRLAN103DEF_H
#define NRLAN103DEF_H
#include <stdlib.h>
#include <stdio.h>
#include <error.h>
#include <errno.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/select.h>
#include <sys/time.h>
#include <arpa/inet.h>
#include <deque>
#include <string>
#include <unistd.h>
#include <pthread.h>
// #include <qthread.h>
#include <sstream>
#include <iostream>
#include <iomanip>
#include "baseclass/Communicate.h"
#include "baseclass/mytype.h"

#pragma pack(1)
// typedef unsigned short WORD;
typedef unsigned int DWORD;
// typedef unsigned char BYTE;

using namespace std;
inline void dump(char* begin,char* end,char* msg=NULL)
{
	stringstream sstrm;
	if(msg!=NULL)sstrm<<msg<<endl;
	sstrm<<hex<<setw(2)<<setfill('0');
	for(char* i=begin;i!=end;i++)
	{
		sstrm<<(int)*i<<" ";
	}
	cout<<sstrm.str()<<endl;
}
namespace NRLAN103
{
using namespace std;
class PackHead
{
public:
    //members
    WORD wFirstFlag;
    DWORD wLength;
    WORD wSecondFlag;
    WORD wSourceFactoryId;
    WORD wSourceAddr;
    WORD wDestinationFactoryId;
    WORD wDestinationAddr;
    WORD wDataNumber;
    WORD wDeviceType;
    WORD wDeviceState;
    WORD wFirstRouterAddr;
    WORD wLastRouterAddr;
    WORD wReserve;
    //member functions
    PackHead()
    {
        bzero(this,sizeof(PackHead));
        wFirstFlag=0xEb90;
        wLength=0x14;
        wSecondFlag=wFirstFlag;
        wDeviceType=0x01;
        //wDeviceState=0x28;
        wReserve=0xFFFF;
    };
    ~PackHead()
    {}
    ;
    PackHead(const PackHead& src)
    {
        memcpy(this,&src,sizeof(PackHead));
    }
};
class ASDUbuff
{
public:
    short size;
    BYTE buff[1000];
    ASDUbuff()
    {
        bzero(this,sizeof(ASDUbuff));
        size=-1;
    };
    ~ASDUbuff()
    {}
    ;
};
class CommMannager
{
private:
    Communicate* _pComm;
    deque<ASDUbuff> sndQueue;
    deque<ASDUbuff> rcvQueue;
    pthread_t threadId;
    pthread_mutex_t fastMutex;
    PackHead impulsHead;
    string theirAddr;
    WORD m_port;
    bool connected;
    int m_sockfd;
    bool receive(int sockfd,int& count,time_t& lastImpuls);//接收报文
    bool send(int sockfd,bool isCmd=false);//发送报文
    CommMannager(const CommMannager& src);
    time_t lastImpuls;//上次心跳时间
    time_t lastSend;//上次发送时间
    int rcvCount;//接收计数

public:
    int debugLevel;
    CommMannager();
    ~CommMannager();
    int CommThread();//通讯主线程
    bool isConnected()const
    {
			return _pComm->IsConnected();
    };
    bool CommStart(const char* addr, WORD port,BYTE addr,BYTE staAddr=150);
    bool CommSend(const ASDUbuff& asdu);
    bool CommRecv(ASDUbuff& asdu);
    void printData(const void* buff,int count,const char* msg,int debug=0)
    {
        if(debug>debugLevel)
            return;
        printf("%s\n",msg);
        if(buff==NULL||count==0)
            return;
        const BYTE* pos=(const BYTE*)buff;
        printf("total bytes:\t%d\n",count);
        for(int i=0;i<count;i++)
        {
            printf("%02x ",pos[i]);
        }
        printf("\n");
    };
    void udpsend(const ASDUbuff& src,unsigned short port)
    {
        int sockfd=socket(AF_INET,SOCK_DGRAM,0);
        if(sockfd==-1)
            return;
        struct sockaddr_in addr;
        bzero(&addr,sizeof(struct sockaddr_in));
        addr.sin_family=AF_INET;
        addr.sin_addr.s_addr=inet_addr(theirAddr.c_str());
        addr.sin_port=htons(port);
        int ret=connect(sockfd,(sockaddr*)&addr,sizeof(sockaddr_in));
        if(ret==-1)
        {
            printf("NRLAN103::CommMannager::udphread:\n\tcan not connect to \
                   %s:%d;\n",theirAddr.c_str(),port);
            close(sockfd);
            return;
        }

        impulsHead.wDataNumber++;
        BYTE sndBuff[1500];
        memcpy(sndBuff,&impulsHead,sizeof(PackHead));
        PackHead* hptr=(PackHead*)sndBuff;
        memcpy(sndBuff+sizeof(PackHead),&src.buff,src.size);
        hptr->wLength=sizeof(PackHead)+sndQueue[0].size-8;
        ::send(sockfd,sndBuff,hptr->wLength+8,0);
        printData(sndBuff,hptr->wLength+8,"CommMannager::udpsend\n\tsend\n");
        return;
    };

    /*!
        \fn NRLAN103::CommMannager::pComm(Communicate* val)
     */
    void pComm(Communicate* val)
    {
        /// @todo implement me
        this->_pComm=val;
        connected=true;
    }

    /*!
        \fn NRLAN103::CommMannager::pComm()
     */
    Communicate* pComm()
    {
        /// @todo implement me
        return _pComm;
    }
protected:
    virtual void run();
};
}
#endif