asdu.cpp

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

//asdu.cpp
#include "ASDU.h"

/////////// ASDU   /////////
CAsdu::CAsdu()
{
    m_ASDUData.SetSize(0);
    m_TYP		= 0;
    m_VSQ.byte	= 0;
    m_COT		= 0;
    m_Addr		= 0;
    m_FUN		= 0;
    m_INF		= 0;

    m_iResult = 0;
}

CAsdu::~CAsdu()
{
    m_ASDUData.SetSize(0);
}

void CAsdu::SaveAsdu(CByteArray& Data)
{
    if (Data.GetSize() < 6)
    {
        m_iResult = 0;
        Data.SetSize(0);
        return;
    }
    m_TYP		= Data[0];
    m_VSQ.byte	= Data[1];
    m_COT		= Data[2];
    m_Addr		= Data[3];
    m_FUN		= Data[4];
    m_INF		= Data[5];

    Data.RemoveAt(0, 6);

    m_ASDUData.SetSize(0);
    m_ASDUData.Copy(Data);
    m_ASDUData.FreeExtra();
    Data.SetSize(0);
    m_iResult = 1;
}
/////////// ASDU07 /////////
CAsdu07::CAsdu07()
{
    m_TYP = 0x07;
    m_VSQ.byte = 0x81;
    m_COT = 0x09;
    m_FUN = 0xfe;
    m_INF = 0x00;
}

void CAsdu07::BulidArray(CByteArray& Data)
{
    Data.SetSize(7);
    Data.FreeExtra();
    m_iResult = 1;
    Data.SetAt(0, m_TYP);
    Data.SetAt(1, m_VSQ.byte);
    Data.SetAt(2, m_COT);
    Data.SetAt(3, m_Addr);
    Data.SetAt(4, m_FUN);
    Data.SetAt(5, m_INF);
    Data.SetAt(6, m_SCN);
}
/////////// ASDU10 /////////
CAsdu10::CAsdu10()
{
    m_TYP = 0x0a;
    m_VSQ.byte = 0x81;
    m_COT = 0x28;
    m_FUN = 0xfe;
    m_INF = 0xf1;
    m_NGD.byte = 0x00;

    m_bSuccess = true;
    m_iNum = 0;
    m_DataSets.clear();
    m_DataSets.setAutoDelete(true);
}

CAsdu10::CAsdu10(CAsdu& a)
{
    m_TYP		= a.m_TYP;
    m_VSQ.byte	= a.m_VSQ.byte;
    m_COT		= a.m_COT;
    m_Addr		= a.m_Addr;
    m_FUN		= a.m_FUN;
    m_INF		= a.m_INF;

    m_ASDUData.Append(a.m_ASDUData);
    a.m_ASDUData.SetSize(0);
}

CAsdu10::~CAsdu10()
{
    m_DataSets.clear();
}

void CAsdu10::Init()
{
    m_TYP = 0x0a;
    m_VSQ.byte = 0x81;
    m_COT = 0x28;
    m_FUN = 0xfe;
    m_INF = 0xf1;
    m_RII = 0xff;
    m_NGD.byte = 0x00;
}

void CAsdu10::BulidArray(CByteArray& Data)
{
    if (m_iNum != (int)m_DataSets.count())
    {
        m_iResult = 0;
        return;
    }
    m_iResult = 1;
    Data.SetSize(0);
    Data.Add(m_TYP);
    Data.Add(m_VSQ.byte);
    Data.Add(m_COT);
    Data.Add(m_Addr);
    Data.Add(m_FUN);
    Data.Add(m_INF);
    Data.Add(m_RII);
    Data.Add(m_NGD.byte);

    if (m_bSuccess == true && m_iNum == 0)
    {
        Data.SetSize(0);
        return;
    }

    DataSet* pDataSet = NULL;
    m_NGD.ngd.No = 0;
    for (int i=0; i<m_iNum;)//
    {
        if (m_NGD.ngd.No == 63)//最大只能为63
        {
            m_NGD.ngd.Count = 1;
            m_NGD.ngd.Cont = 1;
            Data.SetAt(7, m_NGD.byte);
            Data.FreeExtra();
            return;
        }
        pDataSet = m_DataSets.at(0);
        int isize = 3+sizeof(pDataSet->gdd.byte)+pDataSet->gid.GetSize();
        if (Data.GetSize()+isize > MAXLEN)
        {
            m_NGD.ngd.Count = 1;
            m_NGD.ngd.Cont = 1;
            Data.SetAt(7, m_NGD.byte);
            Data.FreeExtra();
            return;
        }
        Data.Add(pDataSet->gin.GROUP);
        Data.Add(pDataSet->gin.ENTRY);
        Data.Add(pDataSet->kod);
        for (int j=0; j<(int)sizeof(pDataSet->gdd.byte); j++)
        {
            Data.Add(pDataSet->gdd.byte[j]);
        }
        Data.Append(pDataSet->gid);
        m_DataSets.remove((int)0);
        m_iNum--;
        m_NGD.ngd.No++;
    }
    m_NGD.ngd.Count = 0;
    m_NGD.ngd.Cont = 0;
    Data.SetAt(7, m_NGD.byte);
    Data.FreeExtra();
}

void CAsdu10::ExplainAsdu(int iProcessType /* =0 */)
{
    if (iProcessType == 0)//标准103的ASDU10的解释处理
    {
        m_RII = m_ASDUData[0];
        m_NGD.byte = m_ASDUData[1];
        m_ASDUData.RemoveAt(0, 2);
        m_ASDUData.FreeExtra();

        int i = 0;
        DataSet* pDataSet = NULL;
        m_iResult = 1;
        for (i=0; i<m_NGD.byte; i++)
        {
            if (m_ASDUData.GetSize() >= (int)(6*sizeof(BYTE)))
            {
                pDataSet = new DataSet;
                pDataSet->gin.GROUP = m_ASDUData[0];
                pDataSet->gin.ENTRY = m_ASDUData[1];
                pDataSet->kod = m_ASDUData[2];
                memcpy(pDataSet->gdd.byte, m_ASDUData.GetData()+3*sizeof(BYTE), sizeof(pDataSet->gdd.byte));
                pDataSet->gid.SetSize(pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
                memcpy(pDataSet->gid.GetData(), m_ASDUData.GetData()+3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte), pDataSet->gid.GetSize()*sizeof(BYTE));
                m_DataSets.append(pDataSet);
                m_ASDUData.RemoveAt(0, 3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte)+pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
                m_ASDUData.FreeExtra();
            }
            else
            {
                m_iResult = 0;
                break;
            }
        }
    }
    //	m_ASDUData.SetSize(0);
}

void CAsdu10::ExplainGID(CByteArray& Gid, int iProcessType /* = 0 */)
{
    if (iProcessType == 0)//标准103的ASDU10的解释处理
    {
        m_NGD.byte = Gid[1];
        Gid.RemoveAt(0, 2);
        Gid.FreeExtra();

        int i = 0;
        DataSet* pDataSet = NULL;
        m_iResult = 1;
        for (i=0; i<m_NGD.ngd.No; i++)
        {
            if (Gid.GetSize() >= (int)(6*sizeof(BYTE)))
            {
                pDataSet = new DataSet;
                pDataSet->gin.GROUP = Gid[0];
                pDataSet->gin.ENTRY = Gid[1];
                pDataSet->kod = Gid[2];
                memcpy(pDataSet->gdd.byte, Gid.GetData()+3*sizeof(BYTE), sizeof(pDataSet->gdd.byte));
                pDataSet->gid.SetSize(pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
                memcpy(pDataSet->gid.GetData(), Gid.GetData()+3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte), pDataSet->gid.GetSize()*sizeof(BYTE));
                m_DataSets.append(pDataSet);
                Gid.RemoveAt(0, 3*sizeof(BYTE)+sizeof(pDataSet->gdd.byte)+pDataSet->gdd.gdd.DataSize*pDataSet->gdd.gdd.Number*sizeof(BYTE));
                Gid.FreeExtra();
            }
            else
            {
                m_iResult = 0;
                break;
            }
        }
    }
    Gid.SetSize(0);
}

/////////// ASDU21 /////////
CAsdu21::CAsdu21()
{
    m_TYP = 0x15;
    m_VSQ.byte = 0x81;
    m_COT = 0x2a;
    m_FUN = 0xfe;
    m_INF = 0xf1;
    m_RII = 0x00;

    m_DataSets.clear();
    m_DataSets.setAutoDelete(true);
}

CAsdu21::~CAsdu21()
{
    m_DataSets.clear();
}

void CAsdu21::BulidArray(CByteArray& Data)
{
    if (m_NOG != m_DataSets.count())
    {
        m_iResult = 0;
        return;
    }
    m_iResult = 1;
    Data.SetSize(0);
    Data.Add(m_TYP);
    Data.Add(m_VSQ.byte);
    Data.Add(m_COT);
    Data.Add(m_Addr);
    Data.Add(m_FUN);
    Data.Add(m_INF);
    Data.Add(m_RII);
    Data.Add(m_NOG);
    DataSet* pDataSet = NULL;
    for (int i=0; i<m_NOG; i++)
    {
        pDataSet = m_DataSets.at(i);
        Data.Add(pDataSet->gin.GROUP);
        Data.Add(pDataSet->gin.ENTRY);
        Data.Add(pDataSet->kod);
    }
    Data.FreeExtra();
}
/////////// ASDU23 /////////
CAsdu23::CAsdu23()
{
    m_TYP = 0x0a;
    m_VSQ.byte = 0x81;
    m_COT = 0x28;
    m_FUN = 0xfe;
    m_INF = 0xf1;

    m_DDTables.SetSize(0);
}

CAsdu23::CAsdu23(CAsdu& a)
{
    m_TYP		= a.m_TYP;
    m_VSQ.byte	= a.m_VSQ.byte;
    m_COT		= a.m_COT;
    m_Addr		= a.m_Addr;
    m_FUN		= a.m_FUN;
    m_INF		= a.m_INF;

    m_ASDUData.Append(a.m_ASDUData);
    a.m_ASDUData.SetSize(0);
    m_DDTables.SetSize(0);
}

CAsdu23::~CAsdu23()
{
    m_DDTables.SetSize(0);
}

void CAsdu23::ExplainAsdu(int iProcessType /* =0 */)
{
    if (iProcessType == 0)//标准103的ASDU23的解释处理
    {
        if (m_ASDUData.GetSize() < (int)(m_VSQ.vsq.num*10*sizeof(BYTE)))
        {
            m_ASDUData.SetSize(0);
            m_iResult = 0;
            return;
        }
        DistrubDataTable DDTable;
        m_iResult = 1;
        for (int i=0; i<m_VSQ.vsq.num; i++)
        {
            DDTable.addr = m_Addr;
            DDTable.FAN = *(WORD*)(m_ASDUData.GetData());
            DDTable.SOF = m_ASDUData[2];
            memcpy(DDTable.Cp56Time.byte, m_ASDUData.GetData()+3, sizeof(DDTable.Cp56Time.byte));
            m_DDTables.Add(DDTable);
            m_ASDUData.RemoveAt(0, 10);
            m_ASDUData.FreeExtra();
        }
    }
    //	m_ASDUData.SetSize(0);
}
/////////// ASDU24 /////////
CAsdu24::CAsdu24()
{
    m_TYP = 0x18;
    m_VSQ.byte = 0x81;
    m_COT = 0x1f;
    m_INF = 0x00;