scbc_repos/TCLCommand/TCLCommand/Command.cpp

#include "StdAfx.h"
#include "Command.h"

#define NoneOptLen 5
#define MINSIZE 128
#define MIDSIZE 4096
#define MAXSIZE 10240

// 宏函数;
#define OPEN_CHECK if (!IsOpen()) return false


byte* TCLCommand::m_pData = NULL;
TCLCommand::TCLCommand(bool bSync):CBaseSerial(bSync ? 0 : FILE_FLAG_OVERLAPPED)
{
    m_pData = new byte[MAXSIZE];
}

TCLCommand::~TCLCommand(void)
{
    if (m_pData)
        delete []m_pData;
    m_pData = NULL;
    m_vtExternalCMDParams.clear();
    m_vtInternalCMDParams.clear();
}

int TCLCommand::ParseTimeValue(std::string strTimeInfo)
{
    int nTimes = 0;
#if _MSC_VER >= 1200 && _MSC_VER < 1500
    if (strstr(strTimeInfo.c_str(), _T("ms")) || strstr(strTimeInfo.c_str(), _T("MS")))
    {
        nTimes = atol(strTimeInfo.c_str());
    }
    else if (strstr(strTimeInfo.c_str(), _T("s")) || strstr(strTimeInfo.c_str(), _T("S")))
    {
        nTimes = atol(strTimeInfo.c_str()) * 1000;
    }
    else if (strstr(strTimeInfo.c_str(), _T("m")) || strstr(strTimeInfo.c_str(), _T("M")))
    {
        nTimes = atol(strTimeInfo.c_str()) * 6000;
    }
    else
    {
        // 不带单位或其他的,默认ms;
        nTimes = atol(strTimeInfo.c_str());
    }
#elif _MSC_VER >= 1500
    if (_tcsstr(strTimeInfo.c_str(), _T("ms")) || _tcsstr(strTimeInfo.c_str(), _T("MS")))
    {
        nTimes = _tstol(strTimeInfo.c_str());
    }
    else if (_tcsstr(strTimeInfo.c_str(), _T("s")) || _tcsstr(strTimeInfo.c_str(), _T("S")))
    {
        nTimes = _tstol(strTimeInfo.c_str()) * 1000;
    }
    else if (_tcsstr(strTimeInfo.c_str(), _T("m")) || _tcsstr(strTimeInfo.c_str(), _T("M")))
    {
        nTimes = _tstol(strTimeInfo.c_str()) * 6000;
    }
    else
    {
        // 不带单位或其他的,默认ms;
        nTimes = _tstol(strTimeInfo.c_str());
    }
#endif

    return nTimes;
}

bool TCLCommand::ParseKeyValuePairs(std::string& strValue, std::string strPairText, const TCHAR* lpszKeyName)
{
    TCHAR szText[MAX_PATH] = { 0 };
    TCHAR szValue[MAX_PATH] = { 0 };
    // 去除空格;
#if _MSC_VER > 1900
    strPairText.erase(std::remove_if(strPairText.begin(), strPairText.end(), [](unsigned char x) {return std::isspace(x); }), strPairText.end()); //C++17
#else
    for (std::string::iterator it = strPairText.begin(); it != strPairText.end();) {
        !isspace(*it) ? it++ : it = it = strPairText.erase(it);
    }
#endif

#if _MSC_VER >= 1200 && _MSC_VER < 1500 // VC6.0~8.0
    if (2 == sscanf(strPairText.c_str(), _T("%[^=]=%s"), szText, MAX_PATH, szValue, MAX_PATH))
#else
    if (2 == _stscanf_s(strPairText.c_str(), _T("%[^=]=%s"), szText, MAX_PATH, szValue, MAX_PATH))
#endif
    {
        if (_tcsstr(szText, lpszKeyName)) {
            strValue = szValue;
            return true;
        }
    }

    return false;
}

int TCLCommand::ParseCommandsFromFile(const TCHAR* file_name, std::vector<CommandParam>& vtCommandParams)
{
    int ret = -1;
    FILE* fp = NULL;
    TCHAR buf[MAX_PATH] = { 0 };
    if (!file_name || file_name[0] == '\0')
        return ret;

    fp = fopen(file_name, "r");
    if (!fp)
        goto EXIT;

    while ((fgets((char*)buf, MAX_PATH, fp) != NULL)) {
        int tmp_len = 0;
        tmp_len = _tcslen(buf);
        if (tmp_len >= 1) {
            if (buf[tmp_len - 1] == '\r' || buf[tmp_len - 1] == '\n')
                buf[tmp_len - 1] = 0;
            if (tmp_len >= 2) {
                if (buf[tmp_len - 2] == '\r' || buf[tmp_len - 2] == '\n')
                    buf[tmp_len - 2] = 0;
            }
        }

        CommandParam cp;
        if (ParseCommandFromString(buf, cp))
            vtCommandParams.push_back(cp);
    }

    ret = 0;
EXIT:
    if (fp)
        fclose(fp);
    return ret;
}

void TCLCommand::ParseCommandsFromString(std::string str, std::vector<CommandParam>& vtCommandParams)
{
    int nPos(0);
    TCHAR buf[MAX_PATH] = { 0 };

    do 
    {
        memset(buf, 0, MAX_PATH);
        int nPos1 = str.find_first_of('\r');
        int nPos2 = str.find_first_of('\n');
        if ( std::string::npos != nPos1 && std::string::npos != nPos2 ) {
            nPos = nPos1 > nPos2 ? nPos1 : nPos2;
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			sprintf(buf, _T("%s"), str.substr(0, nPos - 1).c_str());
#elif _MSC_VER >= 1500
            _stprintf_s(buf, _T("%s"), str.substr(0, nPos - 1).c_str());
#endif
            str = str.substr(nPos+1);
        } 
        else if ( std::string::npos != nPos1 ) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			sprintf(buf, _T("%s"), str.substr(0, nPos1 - 1).c_str());
#elif _MSC_VER >= 1500
            _stprintf_s(buf, _T("%s"), str.substr(0, nPos1 - 1).c_str());
#endif
            str = str.substr(nPos + 1);
        }
        else if ( std::string::npos != nPos2 ) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			sprintf(buf, _T("%s"), str.substr(0, nPos2 - 1).c_str());
#elif _MSC_VER >= 1500
            _stprintf_s(buf, _T("%s"), str.substr(0, nPos2 - 1).c_str());
#endif
            str = str.substr(nPos + 1);
        }
        else {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			sprintf(buf, _T("%s"), str.c_str());
#elif _MSC_VER >= 1500
            _stprintf_s(buf, _T("%s"), str.c_str());
#endif
            str = "";
        }

        CommandParam cp;
        if (ParseCommandFromString(buf, cp))
            vtCommandParams.push_back(cp);
    } while (str.size());
}

bool TCLCommand::ParseCommandFromString(std::string str, CommandParam &cmdParam)
{
    TCHAR name[MAX_PATH] = { 0 };
    TCHAR option[MAX_PATH] = { 0 };
    TCHAR head[MAX_PATH] = { 0 };
    TCHAR code[MAX_PATH] = { 0 };
    TCHAR param[MAX_PATH] = { 0 };
    TCHAR multicode[MAX_PATH] = { 0 };
    TCHAR cmd_wait_time[MAX_PATH] = { 0 };
    TCHAR read_wait_time[MAX_PATH] = { 0 };

#if _MSC_VER >= 1200 && _MSC_VER < 1500 // VC6.0~8.0 
    if (sscanf(str.c_str(), "%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;]", name, option, head, code, param, multicode, read_wait_time, cmd_wait_time) == 8)
#elif _MSC_VER >= 1500 
    //if ( _stscanf_s(buf, "%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;]", name, MAX_PATH, option, MAX_PATH, head, MAX_PATH, code, MAX_PATH, param, MAX_PATH, multicode, MAX_PATH, read_wait_time, MAX_PATH, cmd_wait_time, MAX_PATH) == 8) // 等价下面;
    if (_stscanf_s(str.c_str(), "%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%s", name, MAX_PATH, option, MAX_PATH, head, MAX_PATH, code, MAX_PATH, param, MAX_PATH, multicode, MAX_PATH, read_wait_time, MAX_PATH, cmd_wait_time, MAX_PATH) == 8)
#endif
    {
        ParseKeyValuePairs(cmdParam.name, name, _T("name"));
        ParseKeyValuePairs(cmdParam.head, head, _T("head"));
        ParseKeyValuePairs(cmdParam.code, code, _T("cmd"));
        ParseKeyValuePairs(cmdParam.param, param, _T("param"));

        std::string value;
        ParseKeyValuePairs(value, option, _T("option"));
        if (!_tcsicmp(value.c_str(), _T("None")))
            cmdParam.nOption = CMDOPT_None;
        else if (!_tcsicmp(value.c_str(), _T("Get")))
            cmdParam.nOption = CMDOPT_Get;
        else if (!_tcsicmp(value.c_str(), _T("Set")))
            cmdParam.nOption = CMDOPT_Set;

        ParseKeyValuePairs(value, multicode, _T("returnParam"));
        cmdParam.returnParam = !_tcsicmp(value.c_str(), _T("true")) ? true : false;

        ParseKeyValuePairs(value, read_wait_time, _T("readWaitTime"));
        cmdParam.read_wait_time = ParseTimeValue(value.c_str());

        ParseKeyValuePairs(value, cmd_wait_time, _T("cmdWaitTime"));
        cmdParam.cmd_wait_time = ParseTimeValue(value.c_str());
        cmdParam.UpdateRtnCode();

        return true;
    }

    return false;
}

bool TCLCommand::GetCommandParams(std::string name, CommandParam& cmdPara)
{
    bool bget = false;
    // 外部优先;
    for (std::vector<CommandParam>::iterator it = m_vtExternalCMDParams.begin(); it != m_vtExternalCMDParams.end(); it++ )
    {
        if ( !_tcsicmp(name.c_str(), it->name.c_str()) ) {
            bget = true;
            cmdPara = *it;
            break;
        }
    }
    
    if ( !bget )
    {
        for (std::vector<CommandParam>::iterator it = m_vtInternalCMDParams.begin(); it != m_vtInternalCMDParams.end(); it++ )
        {
            if ( !_tcsicmp(name.c_str(), it->name.c_str()) ) {
                bget = true;
                cmdPara = *it;
                break;
            }
        }
    }

    // 清除状态;
    cmdPara.Clean();

    return bget;
}

bool TCLCommand::TheFirstPart(CommandParam& cmdPara, std::string data)
{
    if (data.size() == NoneOptLen) {
        if ((byte)data[0] == cmdPara._rtnCode) {
            // 长度;
            int nPacketLen = (byte)data[1];
            if (nPacketLen != NoneOptLen) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
				cmdPara._rtnError = utils::_dprintf("[%s] 返回数据长度错误：%ld", (byte)data[1]);
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf("[%s] 返回数据长度错误：%ld", __FUNCTION__, (byte)data[1]);
#endif
                return false;
            }

            // 执行状态;
            cmdPara._rtnStatus = (byte)data[2];
            //utils::_dprintf(_T("[%s] rtnStatus=%02X"), __FUNCTION__, cmdPara._rtnStatus);

            // 校验crc;
            unsigned short usCRCValue = utils::CRC16Calculate((byte*)data.data(), nPacketLen - 2);
            if (((usCRCValue >> 8) & 0xFF) != (byte)data[nPacketLen - 2] || (usCRCValue & 0xFF) != (byte)data[nPacketLen - 1]) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
				cmdPara._rtnError = utils::_dprintf("CRC校验错误：计算[%02% %02X] != 接收[%02X %02X]", (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf("[%s] CRC校验错误：计算[%02% %02X] != 接收[%02X %02X]", __FUNCTION__, (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#endif
				return false;
            }

            if ( cmdPara._rtnStatus != 0x0A )
            {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
                cmdPara._rtnError = utils::_dprintf("执行结果错误：%02X", (byte)cmdPara._rtnStatus);
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf("[%s] 执行结果错误：%02X", __FUNCTION__, (byte)cmdPara._rtnStatus);
#endif
                return false;
            }
        }
        else {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			cmdPara._rtnError = utils::_dprintf("返回码错误：%02X", (byte)data[0]);
#elif _MSC_VER >= 1500
            cmdPara._rtnError = utils::_dprintf("[%s] 返回码错误：%02X", __FUNCTION__, (byte)data[0]);
#endif
            return false;
        }
    }
    else {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
		cmdPara._rtnError = utils::_dprintf("返回数据长度错误", (byte)data[0]);
#elif _MSC_VER >= 1500
        cmdPara._rtnError = utils::_dprintf("[%s] 返回数据长度错误", __FUNCTION__);
#endif
        return false;
    }

    return true;
}

bool TCLCommand::TheSecondPart(CommandParam& cmdPara, std::string data)
{
    // 数据起始位;
    int nDataPos = 0;
    // 数据包长度;
    int nPacketLen = 0;
    if ((byte)data[0] == cmdPara._rtnCode) {
        // 获取长度;
        if ((byte)data[1] == 0xFE) {
            nDataPos = 4;
            nPacketLen = (byte)data[2] << 8 | (byte)data[3];
            if (data.size() < 255 && data[2] != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
				cmdPara._rtnError = utils::_dprintf(_T("返回数据长度异常"));
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回数据长度异常"), __FUNCTION__);
#endif
                return false;
            }
        }
        else
        {
            nDataPos = 2;
            nPacketLen = (byte)data[1];
#if 0 // 如果数据包含有非协议包内的数据,会判断异常;
            if (data.size() > 255) {
                //nPackageLen = data[1] << 8 | data[2];
                cmdPara._rtnError = _dprintf(_T("长度异常"));
                return false;
            }
#endif
        }

#if 1
        // 计算出的长度,必等于包长;// 如果包含有其他非包数据,会判断异常;
        if (nPacketLen > data.size())
        {
            cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的数据长度错误, 计算：%d > 实际：%d"), __FUNCTION__, nPacketLen, data.size());
            return false;
        }
#endif

        if (_tcsicmp(cmdPara.code.c_str(), utils::ByteToChars((byte)data[nDataPos] - 1).c_str()) != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			cmdPara._rtnError = utils::_dprintf(_T("返回的指令码错误, 正确：%02X, 当前：%02X"), utils::TwoHexCharToInteger(cmdPara.code[0],cmdPara.code[1])+1, (byte)data[nDataPos]);
#elif _MSC_VER >= 1500
            cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令码错误, 正确：%02X, 当前：%02X"), __FUNCTION__, utils::TwoHexCharToInteger(cmdPara.code[0],cmdPara.code[1])+1, (byte)data[nDataPos]);
#endif
            return false;
        }

        // 返回的数据;
        ++nDataPos;// 返回码占一字节;
        if (cmdPara.returnParam) {
            // 返回的指令参数
            std::string rtnParam = data.substr(nDataPos, cmdPara.param.size()/2);
            rtnParam = utils::BytesToHexString((byte*)rtnParam.c_str(), rtnParam.size());
            if (_tcsicmp(cmdPara.param.c_str(), rtnParam.c_str()) != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
				cmdPara._rtnError = utils::_dprintf(_T("返回的指令参数错误, %s, %s"), cmdPara.param.c_str(), rtnParam.c_str());
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令参数错误, %s, %s"), __FUNCTION__, cmdPara.param.c_str(), rtnParam.c_str());
#endif
				return false;
            }

            nDataPos += rtnParam.size()/2;// 指令参数码占一字节;
        }

        cmdPara._rtnData = data.substr(nDataPos, nPacketLen - nDataPos - 2); //2 = crc;
        utils::_dprintf(_T("rtnData=%s"), utils::BytesToHexString((byte*)cmdPara._rtnData.c_str(), cmdPara._rtnData.size(), ' ').c_str());

        // 校验crc;
        unsigned short usCRCValue = utils::CRC16Calculate((byte*)data.data(), nPacketLen - 2);
        if (((usCRCValue >> 8) & 0xFF) != (byte)data[nPacketLen - 2] || (usCRCValue & 0xFF) != (byte)data[nPacketLen - 1])
        {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			cmdPara._rtnError = utils::_dprintf("CRC校验错误：计算[%02X %02X] != 接收[%02X %02X]", (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#elif _MSC_VER >= 1500
            cmdPara._rtnError = utils::_dprintf("[%s] CRC校验错误：计算[%02X %02X] != 接收[%02X %02X]", __FUNCTION__, (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#endif
			return false;
        }

        if (data.size() > nPacketLen)
#if _MSC_VER >= 1200 && _MSC_VER < 1500
			utils::_dprintf(_T("带有脏数据：%s"), data.substr(nPacketLen));
#elif _MSC_VER >= 1500
            utils::_dprintf("[%s] 带有脏数据：%s", __FUNCTION__, data.substr(nPacketLen));
#endif
    }
    else 
    {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
        cmdPara._rtnError = utils::_dprintf("返回码错误：%02X", (byte)data[0]);
#elif _MSC_VER >= 1500
		cmdPara._rtnError = utils::_dprintf("[%s] 返回码错误：%02X", __FUNCTION__, (byte)data[0]);
#endif
        return false;
    }

    return true;
}

bool TCLCommand::TheSecondPartForFC(CommandParam& cmdPara, std::string data)
{
    // 数据起始位;
    int nDataPos = 0;
    // 数据包长度;
    int nPacketLen = 0;
    if ((byte)data[0] == cmdPara._rtnCode) {
        // 获取长度;
        if ((byte)data[1] == 0xFE) {
            nDataPos = 4;
            nPacketLen = (byte)data[2] << 8 | (byte)data[3];
            if (data.size() < 255 && data[2] != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
                cmdPara._rtnError = utils::_dprintf(_T("返回数据长度异常"));
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回数据长度异常"), __FUNCTION__);
#endif
                return false;
            }
        }
        else
        {
            nDataPos = 2;
            nPacketLen = (byte)data[1];
#if 0 // 如果数据包含有非协议包内的数据,会判断异常;
            if (data.size() > 255) {
                //nPackageLen = data[1] << 8 | data[2];
                cmdPara._rtnError = _dprintf(_T("长度异常"));
                return false;
            }
#endif
        }

#if 1
        // 计算出的长度,必等于包长;// 如果包含有其他非包数据,会判断异常;
        if (nPacketLen > data.size())
        {
            cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的数据长度错误, 计算：%d > 实际：%d"), __FUNCTION__, nPacketLen, data.size());
            return false;
        }
#endif

        // FireTV的Code是与Write时一样;
        if (_tcsicmp(cmdPara.code.c_str(), utils::ByteToChars((byte)data[nDataPos]).c_str()) != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
            cmdPara._rtnError = utils::_dprintf(_T("返回的指令码错误, 正确：%02X, 当前：%02X"), utils::TwoHexCharToInteger(cmdPara.code[0],cmdPara.code[1]), (byte)data[nDataPos]);
#elif _MSC_VER >= 1500
            cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令码错误, 正确：%02X, 当前：%02X"), __FUNCTION__, utils::TwoHexCharToInteger(cmdPara.code[0],cmdPara.code[1]), (byte)data[nDataPos]);
#endif
            return false;
        }

        // 返回的数据;
        ++nDataPos;// code返回码占一字节;
#if 0 // FireTV的返回的指令参数与code没有规律对应;returnParam要外部根据协议来判断;
        if (cmdPara.returnParam) {
            // 返回的指令参数
            std::string rtnParam = data.substr(nDataPos, cmdPara.param.size()/2);
            rtnParam = utils::BytesToHexString((byte*)rtnParam.c_str(), rtnParam.size());
            if (_tcsicmp(cmdPara.param.c_str(), rtnParam.c_str()) != 0) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
                cmdPara._rtnError = utils::_dprintf(_T("返回的指令参数错误, %s, %s"), cmdPara.param.c_str(), rtnParam.c_str());
#elif _MSC_VER >= 1500
                cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令参数错误, %s, %s"), __FUNCTION__, cmdPara.param.c_str(), rtnParam.c_str());
#endif
                return false;
            }

            nDataPos += rtnParam.size()/2;// 指令参数码占一字节;
        }
#endif

        cmdPara._rtnData = data.substr(nDataPos, nPacketLen - nDataPos - 2); //2 = crc;
        utils::_dprintf(_T("rtnData=%s"), utils::BytesToHexString((byte*)cmdPara._rtnData.c_str(), cmdPara._rtnData.size(), ' ').c_str());

        // 校验crc;
        unsigned short usCRCValue = utils::CRC16Calculate((byte*)data.data(), nPacketLen - 2);
        if (((usCRCValue >> 8) & 0xFF) != (byte)data[nPacketLen - 2] || (usCRCValue & 0xFF) != (byte)data[nPacketLen - 1])
        {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
            cmdPara._rtnError = utils::_dprintf("CRC校验错误：计算[%02X %02X] != 接收[%02X %02X]", (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#elif _MSC_VER >= 1500
            cmdPara._rtnError = utils::_dprintf("[%s] CRC校验错误：计算[%02X %02X] != 接收[%02X %02X]", __FUNCTION__, (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
#endif
            return false;
        }

        if (data.size() > nPacketLen)
#if _MSC_VER >= 1200 && _MSC_VER < 1500
            utils::_dprintf(_T("带有脏数据：%s"), data.substr(nPacketLen));
#elif _MSC_VER >= 1500
            utils::_dprintf("[%s] 带有脏数据：%s", __FUNCTION__, data.substr(nPacketLen));
#endif
    }
    else 
    {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
        cmdPara._rtnError = utils::_dprintf("返回码错误：%02X", (byte)data[0]);
#elif _MSC_VER >= 1500
        cmdPara._rtnError = utils::_dprintf("[%s] 返回码错误：%02X", __FUNCTION__, (byte)data[0]);
#endif
        return false;
    }

    return true;
}

void TCLCommand::PackingCommand(CommandParam& cmdPara, LPCVOID data, const int& dataLen)
{
    // Tag:[命令头][全命令长度][命令码]<命令码参数><附加数据>[crc1][crc2]
    std::string command;
    // 命令头标识位;
    command.append(utils::HexStringToBytes(cmdPara.head, 2).c_str(), cmdPara.head.size() / 2);
    // 命令码;
    command.append(utils::HexStringToBytes(cmdPara.code, 2).c_str(), cmdPara.code.size() / 2);
    // 命令码参数;
    if ( cmdPara.param.size()%2 == 0 )
        command.append(utils::HexStringToBytes(cmdPara.param, 2).c_str(), cmdPara.param.size() / 2);
    // 附加的数据;
    if (dataLen > 0 && NULL != data)
        command.append((char*)data, dataLen);

    int len(0);
    // 长度：可能1字节表示，超过255用2字节表示;
    byte szlen[2] = { 0 };
    //if ((byte)command[1] == 0xFE)
    //if ( cmdPara.head.size() >= 4 && cmdPara.head.find("FE", 2, 2) != std::string::npos )
    if (_tcsicmp(_T("AAFE"), cmdPara.head.c_str()) == 0)
    {// 长度超过255,需要2字节表示;
        len = command.size() + 4;    // 2位crc + 2位长度;
        szlen[0] = (len >> 8) & 0xFF;
        szlen[1] = len & 0xFF;
        command.insert(2, (char*)szlen, 2);
    } else {
        // 2位crc + 1位长度;
        len = command.size() + 3;
        //if ( _tcsicmp(cmdPara.code.c_str(), "99 00") == 0 )
        //    len -= 2;

        if (len > 255) {// 长度超过255，多一个占位符;
            ++len;
            szlen[0] = (len >> 8) & 0xFF;
            szlen[1] = len & 0xFF;
            command.insert(1, (char*)szlen, 2);
        }
        else {
            szlen[0] = len & 0xFF;
            command.insert(1, (char*)szlen, 1);
        }
    }

    // crc校验;
    byte szcrc[2] = { 0 };
    WORD usCRCValue = utils::CRC16Calculate((byte*)command.c_str(), command.size()); // 如果有0断开有危险;
    //WORD usCRCValue = CRC16Calculate((byte *)command.c_str(), len - 2);
    szcrc[0] = (usCRCValue >> 8) & 0xFF;
    szcrc[1] = usCRCValue & 0xFF;
    command.append((char*)szcrc, 2);

    cmdPara._cmdContext = command;
    utils::_dprintf(_T("指令：%s = %s"), cmdPara.name.c_str(), utils::BytesToHexString((byte*)command.c_str(), command.size(), ' ').c_str());
}

bool TCLCommand::ParseResultString(CommandParam& cmdPara, std::string data, const int& dataLen)
{
    // Tag:[返回头][全数据长度][返回码]<返回码子项><附加数据>[crc16]
    if (!TheFirstPart(cmdPara, data.substr(0, 5)))
        return false;

    if (cmdPara._rtnStatus != 0x0A) {
#if _MSC_VER >= 1200 && _MSC_VER < 1500
        utils::_dprintf("执行结果错误：%02X", cmdPara._rtnStatus);
#elif _MSC_VER >= 1500
        utils::_dprintf("[%s] 执行结果错误：%02X", __FUNCTION__, cmdPara._rtnStatus);
#endif
        return false;
    }

    if ( data.size() == 5 )
    {
        return true;
    }

    switch (cmdPara.nOption)
    {
    case CMDOPT_None:
        break;
    case CMDOPT_Get:
    case CMDOPT_Set:
        if ( _tcsicmp(cmdPara.code.c_str(), _T("FC")) )
            return TheSecondPart(cmdPara, data.substr(5));
        else
            return TheSecondPartForFC(cmdPara, data.substr(5));
        break;
    default:
        break;
    }

    return false;
}

bool TCLCommand::SendCommand(CommandParam& cmdPara)
{
    OPEN_CHECK;
    memset(m_pData, 0, MAXSIZE);
    if (_dwIOMode == FILE_FLAG_OVERLAPPED)
    {
        if (!Write((void*)cmdPara._cmdContext.c_str(), cmdPara._cmdContext.size()))
            return false;

        Sleep(cmdPara.read_wait_time);     
		int nReadCount = Read(m_pData, MAXSIZE);
		cmdPara._rtnContext.append((char*)m_pData, nReadCount);
    }
    else 
    {
        if (!WriteSync((void*)cmdPara._cmdContext.c_str(), cmdPara._cmdContext.size()))
            return false;

        Sleep(cmdPara.read_wait_time);
        int nReadCount = ReadSync(m_pData, MAXSIZE);
		cmdPara._rtnContext.append((char*)m_pData, nReadCount);
    }

	utils::_dprintf("结果：%s = %s", cmdPara.name.c_str(), utils::BytesToHexString((byte*)cmdPara._rtnContext.c_str(), cmdPara._rtnContext.size(), ' ').c_str());
	ParseResultString(cmdPara, cmdPara._rtnContext, cmdPara._rtnContext.size());
    Sleep(cmdPara.cmd_wait_time);

    return cmdPara._rtnStatus == 0x0A ? true : false;
}

bool TCLCommand::SendCommand(std::string name, CommandParam& cmdPara, LPCVOID data /* = NULL */, int dataLen /* = 0 */)
{
    if ( !GetCommandParams(name, cmdPara) )
        return false;
    PackingCommand(cmdPara, data, dataLen);
    return SendCommand(cmdPara);
}

void TCLCommand::SetInternalCMDParams(DWORD dwResouceID)
{
    std::string data;
    if ( utils::GetResourceData(dwResouceID, _T("BIN"), data) )
    {
        ParseCommandsFromString(data, m_vtInternalCMDParams);
    }
}

void TCLCommand::SetExternalCMDParams(LPCTSTR lpFileName)
{
    m_vtExternalCMDParams.clear();
    ParseCommandsFromFile(lpFileName, m_vtExternalCMDParams);
}