scbc_repos/Serail-Demo/Demo/TCLCommand.cpp

#include "StdAfx.h"
#include "TCLCommand.h"

#define NoneOptLen 5

TCLCommand::TCLCommand(bool bSync):CBaseSerial(bSync ? 0 : FILE_FLAG_OVERLAPPED)
{

}

TCLCommand::~TCLCommand(void)
{

}

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

	return nTimes;
}

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

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

	return false;
}

int TCLCommand::parse_cmd_param_from_file(TCHAR* file_name, std::vector<CommandParam>& vtCommandParams)
{
	TCHAR buf[MAX_PATH] = { 0 };
	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 };

	int ret = -1;
	FILE* fp = NULL;

	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;
		unsigned short keycode = 0;
		unsigned int protocol = 0;
		unsigned int scancode = 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;
			}
		}

#if _MSC_VER >= 1200 && _MSC_VER < 1500 // VC6.0~8.0 
		if (sscanf(buf, "%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;]", 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(buf, "%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%[^;];%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
		{
			CommandParam cp;
			parse_pair_key(cp.name, name, _T("Name"));
			parse_pair_key(cp.head, head, _T("HeadCode"));
			parse_pair_key(cp.code, code, _T("Command"));
			parse_pair_key(cp.param, param, _T("CMDParam"));

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

			parse_pair_key(value, multicode, _T("MultiParams"));
			cp.bMulticode = !_tcsicmp(value.c_str(), _T("true")) ? true : false;

			parse_pair_key(value, read_wait_time, _T("ReadWaitTime"));
			cp.read_wait_time = pares_time_value(value.c_str());

			parse_pair_key(value, cmd_wait_time, _T("CMDWaitTime"));
			cp.cmd_wait_time = pares_time_value(value.c_str());
			cp.UpdateRtnCode();

			vtCommandParams.push_back(cp);
		}
	}

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

int TCLCommand::parse_cmd_from_string(std::string str, std::vector<CommandParam>& vtCommandParams)
{
	return 0;
}

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) {
				cmdPara._rtnError = utils::_dprintf("[%s] 返回数据长度错误：%ld", __FUNCTION__, (byte)data[1]);
				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]) {
				cmdPara._rtnError = utils::_dprintf("[%s] CRC校验错误：计算[%02% %02X] != 接收[%02X %02X]", __FUNCTION__, (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
				return false;
			}
		}
		else {
			cmdPara._rtnError = utils::_dprintf("[%s] 返回码错误：%02X", __FUNCTION__, (byte)data[0]);
			return false;
		}
	}
	else {
		cmdPara._rtnError = utils::_dprintf("[%s] 返回数据长度错误", __FUNCTION__);
		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) {
				cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回数据长度异常"), __FUNCTION__);
				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 0
		// 计算出的长度,必等于包长;// 如果包含有其他非包数据,会判断异常;
		if (nPackageLen != data.size())
			return false;
#endif

		if (_tcsicmp(cmdPara.code.c_str(), utils::ByteToChars((byte)data[nDataPos] - 1).c_str()) != 0) {
			cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令错误, %s, %02X"), __FUNCTION__, cmdPara.head.c_str(), (byte)data[nDataPos]);
			return false;
		}

		// 返回的数据;
		++nDataPos;// 返回码占一字节;
		if (cmdPara.bMulticode) {
			if (_tcsicmp(cmdPara.param.c_str(), utils::ByteToChars((byte)data[nDataPos]).c_str()) != 0) {
				cmdPara._rtnError = utils::_dprintf(_T("[%s] 返回的指令参数错误, %s, %02X"), __FUNCTION__, cmdPara.param.c_str(), (byte)data[nDataPos]);
				return false;
			}

			++nDataPos;// 指令参数码占一字节;
		}

		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])
		{
			cmdPara._rtnError = utils::_dprintf("[%s] CRC校验错误：计算[%02X %02X] != 接收[%02X %02X]", __FUNCTION__, (usCRCValue >> 8) & 0xFF, usCRCValue & 0xFF, (byte)data[nPacketLen - 2], (byte)data[nPacketLen - 1]);
			return false;
		}

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

	return true;
}

std::string TCLCommand::PackingCommand(CommandParam& cmdPara, std::string 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);
	// 命令码参数;
	command.append(utils::HexStringToBytes(cmdPara.param, 2).c_str(), cmdPara.param.size() / 2);
	// 附加的数据;
	if (dataLen > 0)
		command.append(data.c_str(), 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 = utils::BytesToHexString((byte*)command.c_str(), command.size(), ' ');
	utils::_dprintf(_T("指令：%s"), cmdPara._cmdContext.c_str());

	return command;
}

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

	if (cmdPara._rtnStatus != 0x0A) {
		utils::_dprintf("[%s] 执行结果错误：%02X", __FUNCTION__, cmdPara._rtnStatus);
		return;
	}

	switch (cmdPara.nOption)
	{
	case CMDOPT_None:
		break;
	case CMDOPT_Get:
	case CMDOPT_Set:
		TheSecondPart(cmdPara, data.substr(5));
		break;
	default:
		break;
	}
}