ISCS需求及问题

#if defined(WIN32)

#include    <io.h>

// #include "stdafx.h"

#endif

#include    <limits.h>

#include    <sys/stat.h>

#include	<sys/timeb.h>

#include	<time.h>

#include "ModbusEx_LnS.h"

#include "se_log.h"

#include "daq/daq_utl.h"

extern CRdbTable DEF_DCDLL  RDB_Chan;

unsigned int CRC_16(unsigned char * pSendBuf, int len)//CRC??????

{ 

    unsigned short wCrc = 0xFFFF;

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

    {

        wCrc ^= pSendBuf[i];

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

        {

            if(wCrc & 1)

            {

                wCrc >>= 1; 

                wCrc ^= 0xA001; 

            }

            else

                wCrc >>= 1; 

        }

    }

    return wCrc;

}

CModbusExLnS::CModbusExLnS()

{

// #ifdef LOG_WIN

//     m_logger = new Logger("ModbusExLnS", "ModbusExLnS.log");

// //     m_logger->WriteLineSeparator("Create a new class instance. ", 2);

// #endif

    m_bExitMe = false;

    m_b_InitBuff = 0;

    m_bufValueHasReady = 0;

    m_bufYC = NULL;

    m_bufYX = NULL;

    m_TxDataMaxLen = 1042;

    m_FrameObjNum_Max = 512;

    m_FrameDINum_Max = m_FrameObjNum_Max * DINumberPerBlock;

    resetIniParam(&m_iniConfig);	

}

CModbusExLnS::~CModbusExLnS()

{

    if (m_iniConfig.rtuConfArray != NULL)

    {

        delete [] m_iniConfig.rtuConfArray;

    }

	m_bExitMe = true;

    if (m_bufYX != NULL)

        delete [] m_bufYX;

    if (m_bufYC != NULL)

        delete [] m_bufYC;

#ifdef LOG_WIN

    delete m_logger;

#endif

}

void CModbusExLnS::Init( S_PROTOCOLCFG * pcfg )

{

// #ifdef LOG_WIN

// 	m_logger->WriteFmtStrWithTime_L3("[Init] : ");

// #endif

	PRawCtrl    = pcfg->PRawCtrl;

	pRxBuf      = pcfg->pRxBuf;

	pTxBuf      = pcfg->pTxBuf;

	pCmdMem     = pcfg->pCmdMem;

	pRtu        = pcfg->pRtu;

	pLink       = pcfg->pLink;

	pTable      = pcfg->pTable;

	pZfDataCtrl = pcfg->pZfDataCtrl;

	sint32 buflen = pRxBuf->GetReadableSize();   

	pRxBuf->Move(buflen);

	buflen = pTxBuf->GetReadableSize();

	pTxBuf->Move(buflen);

#ifdef LOG_WIN

    char logfilename[32] = {0};

    sprintf(logfilename, "S_rtu%d_chan%d.log", pLink->GetRtuNo(), pLink->GetChanNo());

    m_logger = new Logger("ModbusExLnS", logfilename);

    m_logger->WriteLineSeparator("Create a new class instance. ", 2);

#endif

	readIni();

    initBuffer();

    initStation();

	m_hThreadGetData = SE_CreateThread( (PTHREAD_FUNC_DEF)GetData, (void *)this);

}

void CModbusExLnS::initStation()

{

// #ifdef LOG_WIN

// 	m_logger->WriteFmtStrWithTime_L3("[initStation] : ");

// #endif

    m_flagSendType = 3;

    m_nSendFrameNo = 0;

    m_nSendSeqNo = 0;

    m_nYXFrameCount = 0; 

    m_nYCFrameCount = 0; 

    pLink->SetCommStatus(CMST_NORMAL);

}

void CModbusExLnS::readIni()

{

// #ifdef LOG_WIN

// 	m_logger->WriteFmtStrWithTime_L3("[readIni] : ");

// #endif

    char *home = getenv("SEROOT");

    if (NULL == home)

    {

        PrintLog(LOG_ERROR, "????????SEROOTδ????");

        return;

    }

    char filename[256] = {0};

#if defined(__unix)

    sprintf(filename, "%s%s", home, "/cfg/ModbusExLns.ini");

#else

    sprintf(filename, "%s%s", home, "\\cfg\\ModbusExLns.ini");

#endif

    CReadConf readconf;

	char sSection[7];

	sint32 rtu_no = 0;

    uint32 zfRtu_start = 0;

    uint32 zfRtu_count = 0;

	int nTotalRtuNum = readconf.ReadLong("GENERAL", "rtuCount", filename, "1");

	for (sint32 rtu_i=0; rtu_i<nTotalRtuNum; rtu_i++)

	{

        rtu_no = 0;

		memset(sSection, 0, sizeof(char)*7);

        sprintf(sSection, "RTU_%d", rtu_i+1);

        zfRtu_start = readconf.ReadLong(sSection, "zfRtuIndexStart", filename, "0");

        zfRtu_count = readconf.ReadLong(sSection, "zfRtuCount", filename, "0");

		rtu_no = readconf.ReadLong(sSection, "rtuNo", filename, "0");

		if (rtu_no == pLink->GetRtuNo())

			break;

	}

    m_logger->WriteFmtStrWithTime_L3("[readIni] : local rtu no %d, zf rtu number %d", rtu_no, zfRtu_count);

    if (rtu_no <= 0)

    {

        PrintLog(LOG_ERROR, "RTUδ????");

        return;

    }

    if (zfRtu_count <= 0)

    {

        PrintLog(LOG_ERROR, "??ת????RTU??????????");

        return;

    }

	m_iniConfig.totalRtus = zfRtu_count;

    m_iniConfig.bufType = (uint8)readconf.ReadLong("GENERAL", "buffType", filename, "0");

    m_iniConfig.rtuConfArray = new IniRtuParam[zfRtu_count];

    for (uint32 zfrtu_i=0; zfrtu_i<zfRtu_count; zfrtu_i++)

    {

        memset(sSection, 0, sizeof(char)*7);

        sprintf(sSection, "RTU%d", zfRtu_start + zfrtu_i);

        LPIniRtuParam pRtuPara = m_iniConfig.rtuConfArray + zfrtu_i;

        pRtuPara->rtuNo = readconf.ReadLong(sSection, "rtuNo", filename, "0");

        pRtuPara->totalYX = readconf.ReadLong(sSection, "yx", filename, "0");

        pRtuPara->totalYC = readconf.ReadLong(sSection, "yc", filename, "0");

        pRtuPara->totalYxBlock = (pRtuPara->totalYX + DINumberPerBlock - 1) / DINumberPerBlock;

    }

    setFrameProperty(m_iniConfig.bufType);

}

// 

sint32	CModbusExLnS::RxProc()

{

    if ( (m_flagSendType & 0x3) == 0)

        m_flagSendType = 0x3;

#if 1

    sint32 count = RDB_Chan.GetRcdCount();

    if( count>DEF_DCV_MAX_CHANNUM ) 

        count = DEF_DCV_MAX_CHANNUM;

	S_RDB_Chan * pChan = (S_RDB_Chan * )RDB_Chan.GetRcdAddr(0);

    sint32 chanNo = pLink->GetChanNo();

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

    {

        if (pChan[i].ChanNo == chanNo)

        {

            pChan[i].State = EDEV_UP_STATE;

            break;

        }

    }

#endif

    pLink->RegisterFrm( FRAME_RX_SUC );

//     pLink->SetCommStatus(CMST_NORMAL);

    return 1;

}

// 

sint32 CModbusExLnS::TxProc()

{

// 	m_logger->WriteFmtStrWithTime_L3("[TxProc] : ");

	if (m_b_InitBuff == 0)

    {

		if (NULL != m_bufYX)

		{

			delete [] m_bufYX;

			m_bufYX = NULL;

		}

#ifdef LOG_WIN

        m_logger->WriteFmtStrWithTime_L3("[TxProc] : m_iniConfig.yxBytes = %d, m_iniConfig.ycBytes = %d", m_iniConfig.totalBytesYx, m_iniConfig.totalBytesYc);

#endif

		if (m_iniConfig.totalBytesYx > 0)

			m_bufYX = new uint8[m_iniConfig.totalBytesYx];

		if (NULL == m_bufYX)

			return 0;

		memset(m_bufYX, 0, m_iniConfig.totalBytesYx);

		if (m_iniConfig.totalBytesYc > 0)

			m_bufYC = new uint8[m_iniConfig.totalBytesYc];

		if (NULL == m_bufYC)

			return 0;

		memset(m_bufYC, 0, m_iniConfig.totalBytesYc);

        m_b_InitBuff = 1;

        while (TRUE) {

            if (m_bufValueHasReady == 1)

                break;

            if (m_bExitMe)

                return 1;

            SeSleep(10);

        }

    }

    else

    {

		if (NULL == m_bufYX)

			return 0;

		if (NULL == m_bufYC)

			return 0;

    }

//     m_logger->WriteFmtStrWithTime_L3("[TxProc] : send data ...");

    if ( (m_flagSendType & 0x1) == 0x1)

    {

        if (procSendDI() == 1)

            return 1;

    }

    if ( (m_flagSendType & 0x2) == 0x2)

    {

        if (procSendAI() == 1)

            return 1;

    }

	return 1;

}

void CModbusExLnS::appToLink(uint8 nDataType)

{

    BYTE * p = m_sendData.databuf;

    int len = m_sendData.trailP - m_sendData.headP;

    unsigned int crcValue = CRC_16(p, len);

    *m_sendData.trailP++ = crcValue % 0x100;

    *m_sendData.trailP++ = crcValue / 0x100;

    len = m_sendData.trailP - m_sendData.headP;

#ifdef LOG_WIN

    if (m_logger->IfLogData())

    {

        if (nDataType == 1)

            m_logger->WriteFmtStrWithTime_L3(_T("???ͱ??? (?ֽ??? %d) : DI??%d֡"), len, m_nYXFrameCount);

        else if (nDataType == 3)

            m_logger->WriteFmtStrWithTime_L3(_T("???ͱ??? (?ֽ??? %d) : AI??%d֡"), len, m_nYCFrameCount);

        TCHAR strLog[MaxCodeLen] = {0};

        uint32 real_len = MaxCodeLen - TimeHead;

        uint32 code_line = 1;

        _tcscpy(strLog, "\n0001: ");

        int code_index;

        for (code_index=0; code_index<len; code_index++)

        {

            if ( _tcslen(strLog) >= real_len-1) {

                m_logger->WriteFmtStrWithTime_L3(strLog);

                memset(strLog, 0, sizeof(TCHAR)*MaxCodeLen);

                _stprintf(strLog, _T("\n%04d: "), ++code_line);

            }

            TCHAR tmpStr[12] = {0};

            if ( (code_index+1)/32 > 0 && (code_index+1)%32 == 0) {

                if ( (code_index+1) % (MaxLine*MaxLineCodeNum) == 0 )

                    _stprintf(tmpStr, _T("%02X  \n"), *(p+code_index));

                else

                    _stprintf(tmpStr, _T("%02X  \n%04d: "), *(p+code_index), ++code_line);

            }

            else

                _stprintf(tmpStr, _T("%02X  "), *(p+code_index));

            _tcscat(strLog, tmpStr);

        }

        m_logger->WriteFmtStrWithTime_L3(strLog);

    }

#endif

//     pLink->RegisterFrmCode(RAW_CODEDIR_DOWN, (char *)p, len);

    pTxBuf->Write(p, len);

//     pLink->SetCommStatus(CMST_NORMAL);

    pLink->RegisterFrm( FRAME_TX_SUC );

    return;

}

// index base 0

// ??ͬ??RTU????ͬһ??֡???ͣ?ÿ??֡????????

sint32 CModbusExLnS::procSendDI()

{

    if (NULL == m_bufYX || NULL == m_iniConfig.rtuConfArray)

    {

        PrintLog(LOG_ERROR, "RTUδ????");

        m_flagSendType &= 0xFE;

        m_nSendFrameNo = 0;

        return 0;

    }

#ifdef LOG_WIN

    if (m_nSendFrameNo == 0) {

        m_timeBeginYX = GetTickCount();

    }

#endif

    // save DI into buffer

    uint8 *buf = new uint8[m_TxDataMaxLen];

    if (NULL == buf)

        return 0;

    uint32 nPreCopied = m_nSendFrameNo * m_FrameObjNum_Max * 2;

    uint8 * dataSrc = m_bufYX + nPreCopied;

    uint32 nCopySize = ( (uint32)(m_nSendFrameNo + 1) >= m_iniConfig.totalFramesYx ) ? (m_iniConfig.totalBytesYx - nPreCopied) : (m_FrameObjNum_Max * 2);

    memcpy(buf, dataSrc, nCopySize);

    // DATA_HEAD

    DATA_HEAD dataHead;

    dataHead.HeadLo = 0xEB;

    dataHead.HeadHi = 0x90;

    dataHead.SysID = FixSysID_Ans;

    dataHead.PacketNoLo = m_nSendSeqNo % 256;

    dataHead.PacketNoHi = m_nSendSeqNo / 256;

    uint16 framelen = nCopySize + 8;

    dataHead.LenLo = framelen % 256;

    dataHead.LenHi = framelen / 256;

    bool bFinishedCycle = false;

    if ( (uint32)(m_nSendFrameNo + 1) >= m_iniConfig.totalFramesYx )

        bFinishedCycle = true;

    if (bFinishedCycle)

        dataHead.FollowupFlag = 0;

    else

        dataHead.FollowupFlag = 1;

    // DATA_BODY_HEAD

    DATA_BODY_HEAD dataBodyHead;    

    dataBodyHead.DataType = ReqTypeID_DI;

    uint32 nMaxCount = nCopySize * 8;

    dataBodyHead.DataCountLB = nMaxCount & 0xFF;

    dataBodyHead.DataCountMB = (nMaxCount >> 8) & 0xFF;

    dataBodyHead.DataCountHB = (nMaxCount >> 16) & 0xFF;

    dataBodyHead.DataStAddrLB = nPreCopied & 0xFF;

    dataBodyHead.DataStAddrMB = (nPreCopied >> 8) & 0xFF;

    dataBodyHead.DataStAddrHB = (nPreCopied >> 16) & 0xFF;

    //

    uint8 *ptr = m_sendData.databuf;

    m_sendData.headP = m_sendData.trailP = ptr;

    memcpy(ptr, (BYTE *)&dataHead, DataHeadLen);

    ptr += DataHeadLen;

    memcpy(ptr, (BYTE *)&dataBodyHead, DataBodyHeadLen);

    ptr += DataBodyHeadLen;

    memcpy(ptr, (BYTE *)buf, nCopySize);

    ptr += nCopySize;

    m_sendData.trailP = ptr;

    appToLink(1);

    m_nSendSeqNo = (m_nSendSeqNo + 1) % 0xFFFF;

#ifdef LOG_WIN

    m_nYXFrameCount++;

#endif

    delete [] buf;

    if (bFinishedCycle)

    {

        m_flagSendType &= 0xFE;

        m_nSendFrameNo = 0;

#ifdef LOG_WIN

        DWORD curTick = GetTickCount();

        DWORD spendTick = GetTickCount() - m_timeBeginYX;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendDI] : ң?? ??????ϣ???ʱ: %us(%ums), ????֡??: %d"), spendTick/1000, spendTick, m_nYXFrameCount);

        m_nYXFrameCount = 0;        

#endif

    }

    else

        m_nSendFrameNo++;

    return 1;

}

/* // ??ͬ??RTU?ڲ?ͬ֡

sint32 CModbusExLnS::procSendDI()

{

    if (NULL == m_bufYX || NULL == m_iniConfig.rtuConfArray)

    {

        PrintLog(LOG_ERROR, "RTUδ????");

        m_flagSendType &= 0xFE;

        m_nSendFrameNo = 0;

        return 0;

    }

    // get start RTU

    uint32 nRtuNo = 0;    

    uint32 nCalcFrames = 0; // total frames have been sent (not include current RTU)

    uint32 nTotalFramesRTU = 0; // total frames of current RTU

    uint32 nDI_byte_start = 0; // start address of current frame (:= 0~0xFFFFFF)

    LPIniRtuParam p_zfRtu = NULL;

    while ( nRtuNo < m_iniConfig.totalRtus)

    {

        p_zfRtu = m_iniConfig.rtuConfArray + nRtuNo;

        nTotalFramesRTU = (p_zfRtu->totalYxBlock + MaxObjPerFrame_DI - 1) / MaxObjPerFrame_DI;

        if (m_nSendFrameNo < nCalcFrames + nTotalFramesRTU)//SendFrameNo : index base from 0

            break;

        nCalcFrames += nTotalFramesRTU;

        nDI_byte_start += (p_zfRtu->totalYxBlock * 2);

        nRtuNo++;

    }

    if (nRtuNo >= m_iniConfig.totalRtus || NULL == p_zfRtu)

    {

        PrintLog(LOG_ERROR, "RTU?????????????????????ļ?????ǰRTU %d", nRtuNo+1);

        m_flagSendType &= 0xFE;

        m_nSendFrameNo = 0;

        return 0;

    }

    uint32 nRtuFrameNo = m_nSendFrameNo - nCalcFrames; // get frame number which has been sent in current RTU

    nDI_byte_start += (MaxObjPerFrame_DI * 2 * nRtuFrameNo);

    uint32 nRtuPointStart = (MaxObjPerFrame_DI * DINumberPerBlock) * nRtuFrameNo; // get from which DI start

#ifdef LOG_WIN

    if (m_nSendFrameNo == 0) {

        m_timeBeginYX = GetTickCount();

    }

#endif

    // re-calculate max DI

    uint32 nRetPoint = p_zfRtu->totalYX - nRtuPointStart;

    uint32 nMaxPoint = (MaxObjPerFrame_DI * DINumberPerBlock); // max DI of current frame

    nMaxPoint = nRetPoint < nMaxPoint ? nRetPoint : nMaxPoint;

    // save DI into buffer

    uint8 buf[1024] = {0};

    uint32 nCopySize = (nMaxPoint + 7) / 8;

    uint8 *dataSrc = m_bufYX + nDI_byte_start;

    memcpy(buf, dataSrc, nCopySize);

    // DATA_HEAD

    DATA_HEAD dataHead;

    dataHead.HeadLo = 0xEB;

    dataHead.HeadHi = 0x90;

    dataHead.SysID = FixSysID_Ans;

    dataHead.PacketNoLo = m_nSendSeqNo % 256;

    dataHead.PacketNoHi = m_nSendSeqNo / 256;

    uint16 nBlock = (nMaxPoint+DINumberPerBlock-1) / DINumberPerBlock;

    uint16 framelen = nBlock * 2 + 8;

    dataHead.LenLo = framelen % 256;

    dataHead.LenHi = framelen / 256;

    bool bFinishedCycle = false;

//     if ( (nRtuNo >= m_iniConfig.totalRtus-1) && (nRtuFrameNo >= nTotalFramesRTU-1) )

//         bFinishedCycle = true;

//     m_logger->WriteFmtStrWithTime_L3("[procSendDI] : nDI_byte_start = %d, nCopySize = %d, m_iniConfig.totalBytesYx = %d",

//          nDI_byte_start, nCopySize, m_iniConfig.totalBytesYx);

    if ( (nDI_byte_start + (nMaxPoint+15)/16*2) >= m_iniConfig.totalBytesYx)

        bFinishedCycle = true;

    if (bFinishedCycle)

        dataHead.FollowupFlag = 0;

    else

        dataHead.FollowupFlag = 1;

    dataHead.DataType = ReqTypeID_DI;

    //

    uint8 *ptr = m_sendData.databuf;

    m_sendData.headP = m_sendData.trailP = ptr;

    memcpy(ptr, (BYTE *)&dataHead, DataHeadLen);

    ptr += DataHeadLen;

    uint32 nMaxCount = nMaxPoint;

    *ptr++ = nMaxCount & 0xFF;

    *ptr++ = (nMaxCount >> 8) & 0xFF;

    *ptr++ = (nMaxCount >> 16) & 0xFF;

    *ptr++ = nDI_byte_start & 0xFF;

    *ptr++ = (nDI_byte_start >> 8) & 0xFF;

    *ptr++ = (nDI_byte_start >> 16) & 0xFF;

    memcpy(ptr, (BYTE *)buf, nBlock*2);

    ptr += nBlock * 2;

    m_sendData.trailP = ptr;

    appToLink(1);

    m_nSendSeqNo = (m_nSendSeqNo + 1) % 0xFFFF;

#ifdef LOG_WIN

    m_nYXFrameCount++;

#endif

    if (bFinishedCycle)

    {

        m_flagSendType &= 0xFE;

        m_nSendFrameNo = 0;

#ifdef LOG_WIN

        DWORD curTick = GetTickCount();

        DWORD spendTick = GetTickCount() - m_timeBeginYX;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendDI] : ң?? ??????ϣ???ʱ: %us(%ums), ????֡??: %d"), spendTick/1000, spendTick, m_nYXFrameCount);

        m_nYXFrameCount = 0;        

#endif

    }

    else

        m_nSendFrameNo++;

    return 1;

}

*/

// ??ͬ??RTU????ͬһ??֡???ͣ?ÿ??֡????????

sint32 CModbusExLnS::procSendAI()

{

    if (NULL == m_bufYC || NULL == m_iniConfig.rtuConfArray)

    {

        PrintLog(LOG_ERROR, "RTUδ????");

        m_flagSendType &= 0xFD;

        m_nSendFrameNo = 0;

        return 0;

    }

#ifdef LOG_WIN

    if (m_nSendFrameNo == 0) {

        m_timeBeginYC = GetTickCount();

    }

#endif

    // save AI into buffer

    uint8 *buf = new uint8[m_TxDataMaxLen];

    if (NULL == buf)

        return 0;

    uint32 nPreCopied = m_nSendFrameNo * m_FrameObjNum_Max * 2;

    uint8 * dataSrc = m_bufYC + nPreCopied;

    uint32 nCopySize = ( (uint32)(m_nSendFrameNo + 1) >= m_iniConfig.totalFramesYc ) ? (m_iniConfig.totalBytesYc - nPreCopied) : (m_FrameObjNum_Max * 2);

    memcpy(buf, dataSrc, nCopySize);

    // DATA_HEAD

    DATA_HEAD dataHead;

    dataHead.HeadLo = 0xEB;

    dataHead.HeadHi = 0x90;

    dataHead.SysID = FixSysID_Ans;

    dataHead.PacketNoLo = m_nSendSeqNo % 256;

    dataHead.PacketNoHi = m_nSendSeqNo / 256;

    uint16 framelen = nCopySize + 8;

    dataHead.LenLo = framelen % 256;

    dataHead.LenHi = framelen / 256;

    bool bFinishedCycle = false;

    if ( (uint32)(m_nSendFrameNo + 1) >= m_iniConfig.totalFramesYc )

        bFinishedCycle = true;

    if (bFinishedCycle)

        dataHead.FollowupFlag = 0;

    else

        dataHead.FollowupFlag = 1;

    // DATA_BODY_HEAD

    DATA_BODY_HEAD dataBodyHead;    

    dataBodyHead.DataType = ReqTypeID_AI;

    uint32 nMaxPoint = nCopySize / 2;

    dataBodyHead.DataCountLB = nMaxPoint & 0xFF;

    dataBodyHead.DataCountMB = (nMaxPoint >> 8) & 0xFF;

    dataBodyHead.DataCountHB = (nMaxPoint >> 16) & 0xFF;

    uint32 nInfoAddrStart = nPreCopied / 2;

    dataBodyHead.DataStAddrLB = nInfoAddrStart & 0xFF;

    dataBodyHead.DataStAddrMB = (nInfoAddrStart >> 8) & 0xFF;

    dataBodyHead.DataStAddrHB = (nInfoAddrStart >> 16) & 0xFF;

    //

    uint8 *ptr = m_sendData.databuf;

    m_sendData.headP = m_sendData.trailP = ptr;

    memcpy(ptr, (BYTE *)&dataHead, DataHeadLen);

    ptr += DataHeadLen;

    memcpy(ptr, (BYTE *)&dataBodyHead, DataBodyHeadLen);

    ptr += DataBodyHeadLen;

    memcpy(ptr, (BYTE *)buf, nMaxPoint*2);

    ptr += nCopySize;

    m_sendData.trailP = ptr;

    PrintLog(LOG_INFORMATION, "????DI??Ӧ֡");

    appToLink(3);

    m_nSendSeqNo = (m_nSendSeqNo + 1) % 0xFFFF;

#ifdef LOG_WIN

    m_nYCFrameCount++;

#endif

    delete [] buf;

    if (bFinishedCycle)

    {

        m_flagSendType &= 0xFD;

        m_nSendFrameNo = 0;

#ifdef LOG_WIN

        DWORD curTick = GetTickCount();

        DWORD spendTick = curTick - m_timeBeginYC;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendAI] : ң?? ??????ϣ???ʱ: %us(%ums), ????֡??: %d"), spendTick/1000, spendTick, m_nYCFrameCount);

        m_nYCFrameCount = 0;

        spendTick = curTick - m_timeBeginYX;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendAI] : ------>>> ???????? ??????ϣ???ʱ: %us(%ums) <<<------"), spendTick/1000, spendTick);

        m_timeBeginYX = m_timeBeginYC = 0;

#endif

    }

    else

        m_nSendFrameNo++;

    return 1;

}

/* // ??ͬ??RTU?ڲ?ͬ֡

sint32 CModbusExLnS::procSendAI()

{

    if (NULL == m_bufYC || NULL == m_iniConfig.rtuConfArray)

    {

        PrintLog(LOG_ERROR, "RTUδ????");

        m_flagSendType &= 0xFD;

        m_nSendFrameNo = 0;

        return 0;

    }

    // get start RTU

    uint32 nRtuNo = 0;    

    uint32 nCalcFrames = 0; // total frames have been sent (not include current RTU)

    uint32 nTotalFramesRTU = 0; // total frames of current RTU

    uint32 nInfoAddrStart = 0; // start address of current frame (:= 0~0xFFFFFF)

    LPIniRtuParam p_zfRtu = NULL;

    while (nRtuNo < m_iniConfig.totalRtus)

    {

        p_zfRtu = m_iniConfig.rtuConfArray + nRtuNo;

        nTotalFramesRTU = p_zfRtu->totalYcFrame;

        if (m_nSendFrameNo < nCalcFrames + nTotalFramesRTU)//SendFrameNo : index base from 0

            break;

        nCalcFrames += nTotalFramesRTU;

        nInfoAddrStart += p_zfRtu->totalYC;

        nRtuNo++;

    }

    if (nRtuNo >= m_iniConfig.totalRtus || NULL == p_zfRtu)

    {

        PrintLog(LOG_ERROR, "AI?㳬?????????????ļ?????ǰRTU %d", nRtuNo+1);

        m_flagSendType &= 0xFD;

        m_nSendFrameNo = 0;

        return 0;

    }    

    uint32 nRtuFrameNo = m_nSendFrameNo - nCalcFrames; // get frame number which has been sent in current RTU

    nInfoAddrStart += MaxObjPerFrame_AI * nRtuFrameNo;

    uint32 nMaxPoint = MaxObjPerFrame_AI; // max DI of current frame

    uint32 nRtuPointStart = nMaxPoint * nRtuFrameNo; // get from which DI start

#ifdef LOG_WIN

    if (m_nSendFrameNo == 0) {

        m_timeBeginYC = GetTickCount();

    }

#endif

    // re-calculate max DI

    uint32 nRetPoint = p_zfRtu->totalYC - nRtuPointStart;

    nMaxPoint = nRetPoint < nMaxPoint ? nRetPoint : nMaxPoint;

    // save AI into buffer

    uint8 buf[1024] = {0};

    uint32 nCopySize = nMaxPoint * 2;

    uint8 * dataSrc = m_bufYC + nInfoAddrStart * 2;

    memcpy(buf, dataSrc, nCopySize);

    // DATA_HEAD

    DATA_HEAD dataHead;

    dataHead.HeadLo = 0xEB;

    dataHead.HeadHi = 0x90;

    dataHead.SysID = FixSysID_Ans;

    dataHead.PacketNoLo = m_nSendSeqNo % 256;

    dataHead.PacketNoHi = m_nSendSeqNo / 256;

    uint16 framelen = nMaxPoint * 2 + 8;

    dataHead.LenLo = framelen % 256;

    dataHead.LenHi = framelen / 256;

    bool bFinishedCycle = false;

//     m_logger->WriteFmtStrWithTime_L3("[procSendAI] : m_iniConfig.totalRtus = %d, nRtuNo = %d, nRtuFrameNo = %d, nTotalFramesRTU = %d",

//         m_iniConfig.totalRtus, nRtuNo, nRtuFrameNo, nTotalFramesRTU);

//     if ( (nRtuNo >= m_iniConfig.totalRtus-1) && (nRtuFrameNo >= nTotalFramesRTU-1) )

//         bFinishedCycle = true;

    if ( (nInfoAddrStart*2 + nCopySize) >= m_iniConfig.totalBytesYc)

        bFinishedCycle = true;

    if (bFinishedCycle)

        dataHead.FollowupFlag = 0;

    else

        dataHead.FollowupFlag = 1;

    dataHead.DataType = ReqTypeID_AI;

    //

    uint8 *ptr = m_sendData.databuf;

    m_sendData.headP = m_sendData.trailP = ptr;

    memcpy(ptr, (BYTE *)&dataHead, DataHeadLen);

    ptr += DataHeadLen;

    *ptr++ = nMaxPoint & 0xFF;

    *ptr++ = (nMaxPoint >> 8) & 0xFF;

    *ptr++ = (nMaxPoint >> 16) & 0xFF;

    *ptr++ = nInfoAddrStart & 0xFF;

    *ptr++ = (nInfoAddrStart >> 8) & 0xFF;

    *ptr++ = (nInfoAddrStart >> 16) & 0xFF;

    memcpy(ptr, (BYTE *)buf, nMaxPoint*2);

    ptr += nMaxPoint * 2;

    m_sendData.trailP = ptr;

    PrintLog(LOG_INFORMATION, "????DI??Ӧ֡");

    appToLink(3);

    m_nSendSeqNo = (m_nSendSeqNo + 1) % 0xFFFF;

#ifdef LOG_WIN

    m_nYCFrameCount++;

#endif

    if (bFinishedCycle)

    {

        m_flagSendType &= 0xFD;

        m_nSendFrameNo = 0;

#ifdef LOG_WIN

        DWORD curTick = GetTickCount();

        DWORD spendTick = curTick - m_timeBeginYC;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendAI] : ң?? ??????ϣ???ʱ: %us(%ums), ????֡??: %d"), spendTick/1000, spendTick, m_nYCFrameCount);

        m_nYCFrameCount = 0;

        spendTick = curTick - m_timeBeginYX;

        m_logger->WriteFmtStrWithTime_L3(_T("[procSendAI] : ------>>> ???????? ??????ϣ???ʱ: %us(%ums) <<<------"), spendTick/1000, spendTick);

        m_timeBeginYX = m_timeBeginYC = 0;

#endif

    }

    else

        m_nSendFrameNo++;

    return 1;

}

*/

void CModbusExLnS::resetIniParam(LPIniConfig pParam)

{

	memset(pParam, 0, sizeof(IniConfig));

}

void CModbusExLnS::initBuffer()

{

	if (NULL == m_iniConfig.rtuConfArray)

		return;

	for (uint32 zfrtu_i=0; zfrtu_i<m_iniConfig.totalRtus; zfrtu_i++)

	{

		LPIniRtuParam pRtuPara = m_iniConfig.rtuConfArray + zfrtu_i;

//         m_logger->WriteFmtStrWithTime_L3("[initBuffer] : m_iniConfig.yxBytes 1= %d, pRtuPara->totalYxBlock = %d", m_iniConfig.yxBytes, pRtuPara->totalYxBlock);

		m_iniConfig.totalBytesYx += pRtuPara->totalYxBlock * 2;

//         m_logger->WriteFmtStrWithTime_L3("[initBuffer] : m_iniConfig.yxBytes 2= %d", m_iniConfig.yxBytes);

		m_iniConfig.totalBytesYc += pRtuPara->totalYC * 2;

	}

    uint32 nMaxBytesPerFrame = m_FrameObjNum_Max * 2;

    m_iniConfig.totalFramesYx = (m_iniConfig.totalBytesYx + nMaxBytesPerFrame - 1) / nMaxBytesPerFrame;

    m_iniConfig.totalFramesYc = (m_iniConfig.totalBytesYc + nMaxBytesPerFrame - 1) / nMaxBytesPerFrame;

}

sint32 CModbusExLnS::procWriteBuffer_DI()

{

    if (m_bufYX == NULL)

        return 0;

	uint32 yx_startNo_inBuff = 0;

	for (uint32 rtu_i=0; rtu_i<m_iniConfig.totalRtus; rtu_i++)

	{

		LPIniRtuParam pRtuPara = m_iniConfig.rtuConfArray + rtu_i;

		yx_startNo_inBuff += pRtuPara->totalYxBlock * 2;

		uint32 byteIndex, bitIndex;

		for (uint16 yx_i = 0; yx_i<pRtuPara->totalYX; yx_i++)

		{

			uint8 btVal = 0;

			PRawCtrl->GetAYx(pRtuPara->rtuNo, yx_i, &btVal);

			uint32 curYxNo_inBuff = yx_startNo_inBuff + yx_i;

			byteIndex = curYxNo_inBuff/DINumberPerBlock * 2 + curYxNo_inBuff%DINumberPerBlock / 8;

			bitIndex = curYxNo_inBuff % 8;

			if (btVal == 1) {

				*(m_bufYX+byteIndex) |= (1 << bitIndex);

			}

			else {

				*(m_bufYX+byteIndex) &= ~(1 << bitIndex);

			}

		}

	}

    return 1;

}

sint32 CModbusExLnS::procWriteBuffer_AI()

{

    if (m_bufYC == NULL)

        return 0;

	uint32 yc_startNo_inBuff = 0;

	for (uint32 rtu_i=0; rtu_i<m_iniConfig.totalRtus; rtu_i++)

	{

		LPIniRtuParam pRtuPara = m_iniConfig.rtuConfArray + rtu_i;

		uint32 byteIndex;

		for (uint16 yc_i=0; yc_i<pRtuPara->totalYC; yc_i++)

		{

			float32 fVal = 0.0f;

			PRawCtrl->GetAYc(pRtuPara->rtuNo, yc_i, &fVal);

			byteIndex = (yc_startNo_inBuff + yc_i) * 2;

			*(m_bufYC+byteIndex) = ((sint32)fVal) % 256;

			*(m_bufYC+byteIndex+1) = ((sint32)fVal) / 256; 

		}

        yc_startNo_inBuff += pRtuPara->totalYC;

	}

    return 1;

}

void CModbusExLnS::GetData(void * pClass)

{

    if (NULL == pClass)

        return;

    CModbusExLnS * pThis = (CModbusExLnS *)pClass;

    while (TRUE) {

        if (pThis->m_b_InitBuff == 1)

            break;

        if (pThis->m_bExitMe)

            return;

        SeSleep(1);

    }

    while (TRUE)

    {

        if (pThis->m_bExitMe)

            break;

		pThis->procWriteBuffer_DI();

//         pThis->m_logger->WriteFmtStrWithTime_L3("[GetData] : call procWriteBuffer_AI");

		pThis->procWriteBuffer_AI();

        if (pThis->m_bufValueHasReady == 0)

            pThis->m_bufValueHasReady = 1;

        SeSleep(1);

    }

}

void CModbusExLnS::setFrameProperty(uint8 bufType)

{

    if (bufType <= 0 || bufType > 6)

        return;