MultiTerminal1 - Gitblit

QuakeGod

2022-05-10 65f7136c6dfebde14a07c89c4366fb8bed2fe37f

提交 \| 用户 \| age
0ed438	1	#include "pch.h"
Q	2	#include "KLink.h"
	3
	4	KLink::KLink()
	5	{
	6
	7	}
	8
	9	KLink::~KLink()
	10	{
	11
	12	}
	13
	14	static const KLink::stKLTypeName KLCoilTypeNames[] =
	15	{
	16	{KLink::KLCoilTypeX,"X",KLink::KLCoilXCount},
	17	{KLink::KLCoilTypeY,"Y",KLink::KLCoilYCount},
	18	{KLink::KLCoilTypeR,"R",KLink::KLCoilRCount},
	19	{KLink::KLCoilTypeLX,"LX",KLink::KLCoilLXCount},
	20	{KLink::KLCoilTypeLY,"LY",KLink::KLCoilLYCount},
	21	{KLink::KLCoilTypeT,"T",KLink::KLCoilTCount},
	22	{KLink::KLCoilTypeC,"C",KLink::KLCoilCCount}
	23	};
	24
	25	static const KLink::stKLTypeName KLDataTypeNames[] =
	26	{
	27
	28	KLink::KLDataTypeWX,"WX", KLink::KLDataWXCount,
	29	KLink::KLDataTypeWY,"WY", KLink::KLDataWYCount,
	30	KLink::KLDataTypeWR,"WR",KLink::KLDataWRCount,
	31	KLink::KLDataTypeWLX,"WLX",KLink::KLDataWLCount,
	32	KLink::KLDataTypeWLY,"WLY",KLink::KLDataWLCount,
	33	KLink::KLDataTypeDT,"DT",KLink::KLDataDTCount,
	34	KLink::KLDataTypeSDT,"SDT",KLink::KLDataSDTCount,
	35	KLink::KLDataTypeSV,"SV",KLink::KLDataSVCount ,
	36	KLink::KLDataTypeEV,"EV",KLink::KLDataEVCount ,
	37	KLink::KLDataTypeLD,"LD",KLink::KLDataLDCount,
	38	KLink::KLDataSysCfg,"Cfg",128,
	39	KLink::KLDataTypeFlash,"Flash",256,
	40	KLink::KLDataTypeTest,"Test",256
	41	};
	42
	43	const char * KLink::GetErrDescStr(int nErrNo)
	44	{
	45	switch (nErrNo)
	46	{
	47	case KL_ERR:
	48	return "ERROR";
	49	case KL_OK: //=0
	50	return "OK";
	51	case KL_NG:// = 1,
	52	return "NG";
	53	case KL_UNKNOWN: // = 2,
	54	return "KL_UNKNOWN";
	55	case KL_TIMEOUT: // = 3,
	56	return "KL_TIMEOUT";
	57	case KL_BCC_ERR: // = 4,
	58	return "KL_BCC_ERR";
	59	case KL_PKG_ERR: // = 5,
	60	return "KL_PKG_ERR";
	61	case KL_SEQ_ERR: // = 6,
	62	return "KL_SEQ_ERR";
	63	case KL_LENTH_EXCEED: //,
	64	return "KL_LENTH_EXCEED";
	65	case KL_NEED_PASS: //,
	66	return "KL_NEED_PASS";
	67	case KL_NOT_SUPPORT://,
	68	return "KL_NOT_SUPPORT";
	69	default:
	70	return "KL_OTHER_ERR";
	71	break;
	72	}
	73	}
	74
	75	int KLink::xtoi(const char * hexstr, int len)
	76	{
	77	int len1 = len;
	78	if (len <= 0) len1 = (int)strlen(hexstr);
	79	int j=0;
	80	for (int i = 0; i < len1; i++)
	81	{
	82	unsigned char ch = hexstr[i];
	83	if (ch >= '0'&&ch <= '9') { int k = ch - '0'; j = j * 16 + k; continue; }
	84	if (ch >= 'A'&&ch <= 'F') { int k = ch - 'A' + 10; j = j * 16 + k; continue; }
	85	if (ch >= 'a'&&ch <= 'f') { int k = ch - 'a' + 10; j = j * 16 + k; continue; }
	86	if (ch == ' ' \|\| ch == ' ') { continue; }
	87	break;
	88	}
	89	return j;
	90	}
	91
	92	unsigned char KLink::KLBCC(void * pData, int nSize)
	93	{
	94	unsigned char k = 0;
	95	for (int i = 0; i < nSize; i++)
	96	{
	97	k ^= ((unsigned char *)pData)[i];
	98	}
	99	return k;
	100	}
	101	int KLink::CalCRC(void * pBuf, int nSize)
	102	{
	103	return 0;
	104	}
	105
	106	int KLink::SetSendCallBackFunc(std::function<int(void *, int)> pSendFunc)
	107	{
	108	SendPkgFunc = pSendFunc;
	109	m_bSendCallBackSet = 1;
	110	return KL_OK;
	111	}
	112
	113	int KLink::SetRecvCallBackFunc(std::function<int(void *, int)> pRecvFunc)
	114	{
	115	RecvPkgFunc = pRecvFunc;
	116	m_bRecvCallBackSet = 1;
	117	return KL_OK;
	118	}
	119
	120	int KLink::SetOpenCallBackFunc(std::function<int(int)> pOpenFunc)
	121	{
	122	OpenFunc = pOpenFunc;
	123	m_bOpenCallBackSet = 1;
	124	return KL_OK;
	125	}
	126	int KLink::SetCloseCallBackFunc(std::function<int(int)> pCloseFunc)
	127	{
	128	CloseFunc = pCloseFunc;
	129	m_bCloseCallBackSet = 1;
	130	return KL_OK;
	131	}
	132	int KLink::MakeExtDataFrame(void * pBuf, UCHAR nDst, UCHAR nType, UCHAR len2, void * pData)
	133	{
	134	int framelen1 = 0;
	135	pKLExtDataFrame pF1 = (pKLExtDataFrame)pBuf;
	136	pF1->Dst = nDst;
	137	pF1->nType = nType;
	138	pF1->Len2 = len2;
	139	memcpy(pF1->Data, pData, len2);
	140	UCHAR bcc = KLBCC(pBuf, sizeof(tagKLExtDataFrame) + len2 - 1);
	141	pF1->Data[len2] = bcc;
	142
	143	framelen1 = sizeof(tagKLExtDataFrame) + len2;
	144	return framelen1;
	145	}
	146	/*
	147	int KLink::MakeReqPacket(void * pBuf, UCHAR nDst, UCHAR Stat, UCHAR nCMD, UCHAR Type, USHORT nAddr, USHORT nCount, void * pData)
	148	{
	149	int PkgLen1 = 0;
	150	pKLReqPacket pPacket = (pKLReqPacket)pBuf;
	151	pPacket->StartSign = KLSignStart;
	152	pPacket->DstAddr = nDst;
	153	pPacket->Stat = Stat;
	154	pPacket->Cmd = nCMD;
	155	pPacket->Type1 = Type;
	156	int Datalen = 0;
	157	int nWordAddr;
	158	int nWordCount;
	159
	160	switch (nCMD)
	161	{
	162	case KLCmdNone:
	163	break;
	164	case KLCmdPing:
	165	Datalen = Type;
	166	memcpy(pPacket->Params, pData, Datalen);
	167	PkgLen1 = sizeof(stKLReqPacket) + Datalen;
	168	break;
	169	case KLCmdGetInfo:
	170	break;
	171	case KLCmdRead:
	172	Datalen = 0;
	173	pPacket->Params[0] = nAddr % 256;
	174	pPacket->Params[1] = nAddr / 256;
	175	pPacket->Params[2] = nCount % 256;
	176	pPacket->Params[3] = nCount / 256;
	177	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	178	break;
	179	case KLCmdWrite:
	180	pPacket->Params[0] = nAddr % 256;
	181	pPacket->Params[1] = nAddr / 256;
	182	pPacket->Params[2] = nCount % 256;
	183	pPacket->Params[3] = nCount / 256;
	184	Datalen = nCount;
	185	memcpy(pPacket->Params + 4, pData, Datalen);
	186	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	187
	188	break;
	189	case KLCmdSaveToFlash:
	190	break;
	191	case KLCmdExChgData:
	192	break;
	193	case KLCmdGetEventLogCount:
	194	pPacket->Params[0] = 0;
	195	pPacket->Params[1] = 0;
	196	pPacket->Params[2] = 0;
	197	pPacket->Params[3] = 0;
	198	Datalen = 0;
	199	memcpy(pPacket->Params + 4, pData, Datalen);
	200	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	201	default:
	202	break;
	203	}
	204	if (PkgLen1 >= sizeof(stKLReqPacket))
	205	{
	206	UCHAR BCC = KLBCC(pBuf, PkgLen1 - 1);
	207	pPacket->Params[PkgLen1-sizeof(stKLReqPacket)] = BCC;
	208	}
	209	return PkgLen1;
	210	}
	211	*/
	212	int KLink::MakeReqPacketEx(void * pBuf, UCHAR nDst, UCHAR Stat, UCHAR nCMD, UCHAR Type, USHORT nAddr, USHORT nCount, void * pData, int ExtFrameLen, void * pExtDataFrame)
	213	{
	214	int PkgLen1 = 0;
	215	pKLReqPacket pPacket = (pKLReqPacket)pBuf;
	216	pPacket->StartSign = KLSignStart;
	217	pPacket->DstAddr = nDst;
	218	pPacket->Stat = Stat;
	219	pPacket->Cmd = nCMD;
	220	pPacket->Type1 = Type;
	221
	222	pKLStat pStat = (pKLStat)&(pPacket->Stat);
	223	int Datalen = 0;
	224	int nWordAddr=nAddr;
	225	int nWordCount=nCount;
	226	pPacket->Params[0] = LOBYTE(nAddr);
	227	pPacket->Params[1] = HIBYTE(nAddr);
	228	pPacket->Params[2] = nCount % 256;
	229	pPacket->Params[3] = nCount / 256;
	230
	231	switch (nCMD)
	232	{
	233	case KLCmdNone:
	234	break;
	235	case KLCmdPing:
	236	Datalen = Type;
	237	memcpy(pPacket->Params, pData, Datalen);
	238	PkgLen1 = sizeof(stKLReqPacket) + Datalen;
	239	break;
	240	case KLCmdGetInfo:
65f713	241	case KLCmdGetSN:
Q	242	Datalen = 0;
	243	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	244	break;
	245	case KLCmdGetFactoryData:
	246	Datalen = 0;
	247	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	248	break;
	249	case KLCmdWriteFactoryData:
	250	Datalen = nCount;
	251	memcpy(pPacket->Params + 4, pData, Datalen);
	252	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
0ed438	253	break;
Q	254	case KLCmdRead:
	255	Datalen = 0;
	256	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	257	break;
	258	case KLCmdWrite:
	259	Datalen = nCount;
	260	memcpy(pPacket->Params + 4, pData, Datalen);
	261	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	262	break;
	263	case KLCmdRead1Bit:
	264	Datalen = 0;
	265	PkgLen1 = sizeof(stKLReqPacket) + 2 + Datalen;
	266	break;
	267	case KLCmdWrite1Bit:
	268	Datalen = 1;
	269	memcpy(pPacket->Params + 2, pData, Datalen);
	270	PkgLen1 = sizeof(stKLReqPacket) + 2 + Datalen;
	271	break;
	272
	273	case KLCmdReadBits:
	274	Datalen = 0;
	275	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	276	break;
	277	case KLCmdWriteBits:
	278	Datalen = 0;
	279	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	280	break;
	281	case KLCmdReadDataByte:
	282	case KLCmdReadDataWord:
	283	case KLCmdReadData:
	284	Datalen = 0;
	285	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	286	break;
	287	case KLCmdWriteDataByte:
	288	case KLCmdWriteDataWord:
	289	case KLCmdWriteData:
	290	Datalen = nCount;
	291	memcpy(pPacket->Params + 4, pData, Datalen);
	292	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	293	break;
	294	case KLCmdSaveToFlash:
	295	break;
	296	case KLCmdExChgData:
	297	break;
	298	case KLCmdReadProgram:
	299	Datalen = 0;
	300	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	301	break;
	302	case KLCmdStartProgram:
	303	Datalen = 0;
	304	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	305	break;
	306	case KLCmdWriteProgram:
	307	Datalen = nCount;
	308	memcpy(pPacket->Params + 4, pData, Datalen);
	309	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	310	break;
	311	case KLCmdFinishProgram:
	312	Datalen = 0;
	313	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	314	break;
	315
	316	case KLCmdReadRunStat:
	317	Datalen = 0;
	318	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	319	break;
	320
	321	case KLCmdSaveSysCfg:
	322	pPacket->Params[0] = 0;
	323	pPacket->Params[1] = 0;
	324	pPacket->Params[2] = 0;
	325	pPacket->Params[3] = 0;
	326	Datalen = 0;
	327	memcpy(pPacket->Params + 4, pData, Datalen);
	328	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	329	break;
	330	case KLCmdSaveRunStat:
	331	pPacket->Params[0] = 0;
	332	pPacket->Params[1] = 0;
	333	pPacket->Params[2] = 0;
	334	pPacket->Params[3] = 0;
	335	Datalen = 0;
	336	memcpy(pPacket->Params + 4, pData, Datalen);
	337	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	338	break;
	339	case KLCmdClearEventLog:
	340	pPacket->Params[0] = 0;
	341	pPacket->Params[1] = 0;
	342	pPacket->Params[2] = 0;
	343	pPacket->Params[3] = 0;
	344	Datalen = 0;
	345	memcpy(pPacket->Params + 4, pData, Datalen);
	346	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	347
	348	case KLCmdGetEventLogCount:
	349	pPacket->Params[0] = 0;
	350	pPacket->Params[1] = 0;
	351	pPacket->Params[2] = 0;
	352	pPacket->Params[3] = 0;
	353	Datalen = 0;
	354	memcpy(pPacket->Params + 4, pData, Datalen);
	355	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	356	break;
	357	case KLCmdGetEventLog:
	358	pPacket->Params[0] = nAddr % 256;
	359	pPacket->Params[1] = nAddr / 256;
	360	pPacket->Params[2] = nCount % 256;
	361	pPacket->Params[3] = nCount / 256;
	362	Datalen = 0;
	363	memcpy(pPacket->Params + 4, pData, Datalen);
	364	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	365	break;
	366
	367	default:
	368	pPacket->Params[0] = nAddr % 256;
	369	pPacket->Params[1] = nAddr / 256;
	370	pPacket->Params[2] = nCount % 256;
	371	pPacket->Params[3] = nCount / 256;
	372	Datalen = 0;
	373	memcpy(pPacket->Params + 4, pData, Datalen);
	374	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	375	break;
	376	}
	377
	378	if (PkgLen1 >= sizeof(stKLReqPacket))
	379	{
	380	UCHAR BCC = KLBCC(pBuf, PkgLen1 - 1);
	381	pPacket->Params[PkgLen1 - sizeof(stKLReqPacket)] = BCC;
	382	}
	383
	384	if (pStat->HasExt && ExtFrameLen > 0 && pExtDataFrame != NULL)
	385	{
	386
	387	memcpy(pPacket->Params + PkgLen1 - sizeof(stKLReqPacket) + 1, pExtDataFrame, ExtFrameLen);
	388	PkgLen1 += ExtFrameLen;
	389	};
	390	return PkgLen1;
	391	}
	392
	393
	394	int KLink::CheckPackage(void * pBuf, int nSize)
	395	{
	396	pKLRplyPktHdr p1 = (pKLRplyPktHdr)pBuf;
	397	if (p1->RplyStSgn != KLSignReply)
	398	{
	399	return KL_UNKNOWN;
	400	}
	401
	402	int DataLen = 0; //p1->LoadLen;
	403	if (DataLen > KLMaxPacketLength)
	404	{
	405	return KL_PKG_ERR;
	406	}
	407	if (nSize < DataLen + sizeof(stKLRplyPktHdr))
	408	{
	409	//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stPacket));
	410	//PutStr(str3,len4);
	411	return KL_PKG_ERR; //not long enough
	412	}
	413	// if (p1->data[DataLen+1] != EndSign)
	414	// {
	415	// ClientStat[nCurPollId].NoEndErr++;
	416	// Uart2Stat.LengthErr++;
	417	// return -2;
	418	// }
	419	unsigned char thisBCC = KLBCC(p1, nSize - 1);
	420	if (thisBCC != ((UCHAR *)pBuf)[nSize - 1])
	421	{//BCC Error;
	422	return KL_BCC_ERR;
	423	}
	424	return KL_OK;
	425
	426	return true;
	427	return false;
	428	}
	429
	430	int KLink::ProcessPacket(void *pBuf, int nLen)
	431	{
	432	return false;
	433	}
	434
	435	int KLink::ParseRplyPacket(void pBuf, int nPkgLen, UCHAR nCmd, UCHAR * Status, USHORT* nCount, void * pData)
	436	{
	437	if (nPkgLen < 0) { return KL_ERR; }
	438	int res = CheckPackage(pBuf, nPkgLen);
	439	if (res != KL_OK) return res;
	440	int len1 = 0;
	441	pKLRplyPktHdr pPacket = (pKLRplyPktHdr)pBuf;
	442	UCHAR Sign = pPacket->RplyStSgn;
	443	UCHAR nDst= pPacket->DstAddr;
	444	*nCmd = pPacket->nRplyCMD;
	445	UCHAR nStatus = pPacket->nStatus;
	446	*Status = nStatus;
	447	m_nRSeq = ((pKLStat)&nStatus)->nSEQ;
	448	int Datalen = pPacket->nSize1;
	449	*nCount = Datalen;
	450	switch (*nCmd)
	451	{
	452	case KLCmdNone:
	453	break;
	454	case KLCmdPing:
	455	case KLCmdPingReply:
	456	*nCount = Datalen;
65f713	457	memcpy(pData, pPacket->Datas, Datalen);
0ed438	458	break;
Q	459	case KLCmdGetInfo:
	460	case KLCmdVerInfo:
	461	*nCount = Datalen;
65f713	462	memcpy(pData, pPacket->Datas, Datalen);
Q	463	break;
	464	case KLCmdGetUid:
	465	case KLCmdGetSN:
	466	case KLCmdGetFactoryData:
	467	*nCount = Datalen;
	468	memcpy(pData, pPacket->Datas, Datalen);
	469	break;
	470	case KLCmdWriteFactoryData:
	471	*nCount = Datalen;
0ed438	472	break;
Q	473	case KLCmdRead:
	474	case KLCmdReadReply:
	475	*nCount = Datalen;
	476	memcpy(pData, pPacket->Datas, Datalen);
	477	break;
	478	case KLCmdWrite:
	479	case KLCmdWriteReply:
	480	*nCount = Datalen;
	481	break;
	482	case KLCmdRead1Bit:
	483	case KLCmdReadBits:
	484	*nCount = Datalen;
	485	memcpy(pData, pPacket->Datas, Datalen);
	486	break;
	487	case KLCmdReadDataByte:
	488	*nCount = Datalen;
	489	memcpy(pData, pPacket->Datas, Datalen);
	490	break;
	491	case KLCmdReadDataWord:
	492	case KLCmdReadData:
	493	*nCount = Datalen;
	494	memcpy(pData, pPacket->Datas, Datalen);
	495	break;
	496	case KLCmdWriteDataByte:
	497	case KLCmdWriteDataWord:
	498	case KLCmdWriteData:
	499	*nCount = Datalen;
	500	break;
	501
	502	case KLCmdSaveToFlash:
	503	break;
	504
	505	case KLCmdReadProgram:
	506	*nCount = Datalen;
	507	memcpy(pData, pPacket->Datas, Datalen);
	508	break;
	509	case KLCmdStartProgram:
	510	*nCount =Datalen;
	511	break;
	512	case KLCmdWriteProgram:
	513	*nCount = Datalen;
	514	break;
	515	case KLCmdFinishProgram:
	516	*nCount = Datalen;
	517	break;
	518
	519	case KLCmdReadRunStat:
	520	*nCount = Datalen;
	521	memcpy(pData, pPacket->Datas, Datalen);
	522	break;
	523	case KLCmdExChgData:
	524	case KLCmdExChgDataReply:
	525	break;
	526	case KLCmdGetEventLogCount:
	527	*nCount = Datalen;
	528	memcpy(pData, pPacket->Datas, Datalen);
	529	break;
	530	case KLCmdGetEventLog:
	531	*nCount = Datalen;
	532	memcpy(pData, pPacket->Datas, Datalen);
	533	break;
	534
	535	case KLCmdErrRply:
	536	*nCount = Datalen;
	537	memcpy(pData, pPacket->Datas, Datalen);
	538	break;
	539	default:
	540	*nCount = Datalen;
	541	//memcpy(pData, pPacket->Datas, Datalen);
	542	break;
	543	}
	544	return KL_OK;
	545
	546	return false;
	547	}
	548
	549	int KLink::ReadBit(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR * Value)
	550	{
	551	m_Dst = nDst;
	552	int len1=MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdRead1Bit, nType, nBitAddr);
	553	SendPacket(m_Packetbuf, len1);
	554	int numToRead = sizeof(stKLRplyPktHdr) + 1;
	555
	556	int len2=RecvPacket(m_RecvBuf, numToRead);
	557	unsigned char nCmd;
65f713	558	unsigned short nCount=0;
0ed438	559	ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nCount, m_DataBuf);
Q	560	Value[0] = m_DataBuf[0];
	561	return KL_OK;
	562	}
	563	int KLink::WriteBit(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR Value)
	564	{
	565	m_Dst = nDst;
	566	m_DataBuf[0] = Value;
	567	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWrite1Bit, nType, nBitAddr,1,m_DataBuf);
	568	SendPacket(m_Packetbuf, len1);
	569	int len2 = RecvPacket(m_RecvBuf, 64);
	570	unsigned char nCmd;
65f713	571	unsigned short nCount=0;
0ed438	572	ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nCount, m_DataBuf);
Q	573	return KL_OK;
	574	}
65f713	575	int KLink::ReadBits(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR nBitCount, UCHAR * Values)
0ed438	576	{
Q	577	return KL_OK;
	578	}
65f713	579	int KLink::WriteBits(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR nBitCount, UCHAR * Values)
0ed438	580	{
Q	581	return KL_OK;
	582	}
65f713	583	int KLink::ReadBitsByWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT *Values)
0ed438	584	{
Q	585	return KL_OK;
	586	}
65f713	587	int KLink::WriteBitsByWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT *Values)
0ed438	588	{
Q	589	return KL_OK;
	590	}
	591	int KLink::GetNextSeq()
	592	{
	593	m_nSeq++;
	594	if (m_nSeq >= 8) m_nSeq = 0;
	595	m_Stat1.nSEQ = m_nSeq;
	596	return m_nSeq;
	597	}
	598
65f713	599	int KLink::ReadDataByte(UCHAR nDst, UCHAR nType, USHORT nByteAddr, UCHAR nByteCount, UCHAR * Values)
0ed438	600	{
Q	601	m_Dst = nDst;
	602	m_resultStr.Empty();
	603	UCHAR nExpSeq = GetNextSeq();
	604	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadDataByte, nType, nByteAddr/2, nByteCount);
	605	SendPacket(m_Packetbuf, len1);
	606	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	607	int len2 = 0;
	608	len2= RecvPacket(m_RecvBuf, numToRead);
	609	if (len2 <= 0) { m_resultStr.Format(_T("Recv Failed len %d To=%d"),len2,numToRead); return KL_ERR; }
	610	if (len2 < numToRead)
	611	{
	612	CString s1;
	613	for (int i=0;i<len2;i++)
	614	{
	615	s1.AppendFormat(_T("%02X "),m_RecvBuf[i]);
	616	}
	617	s1.Append(_T("\r\n"));
	618	m_resultStr.Format(_T("ToRead %d R= %d \r\n"),numToRead,len2);
	619	m_resultStr += s1;
	620	}
	621	unsigned char nCmd ;
65f713	622	unsigned short nnCount=0;
0ed438	623	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	624	if (res == KL_OK)
	625	{
	626	for (int i = 0; i < nnCount; i++)
	627	{ Values[i] = m_DataBuf[i]; }
	628	}
	629	else
	630	{
	631	m_resultStr.AppendFormat(_T("Res=%d ToRead %d Count %d "), res, numToRead, len2);
	632	return res;
	633	}
	634
	635	return KL_OK;
	636	}
65f713	637	int KLink::WriteDataByte(UCHAR nDst, UCHAR nType, USHORT nByteAddr, UCHAR nByteCount, UCHAR * Values)
0ed438	638	{
Q	639	m_Dst = nDst;
	640	UCHAR nExpSeq = GetNextSeq();
	641	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteDataByte, nType, nByteAddr/2, nByteCount, Values);
	642	SendPacket(m_Packetbuf, len1);
65f713	643	nByteCount = 0;
Q	644	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	645	int len2 = RecvPacket(m_RecvBuf, numToRead);
	646	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
0ed438	647	if (len2 == 0) return KL_ERR;
Q	648	unsigned char nCmd;
65f713	649	unsigned short nnCount=0;
0ed438	650	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	651	return res;
	652	}
	653
65f713	654	int KLink::ReadDataWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
0ed438	655	{
Q	656	m_Dst = nDst;
	657	UCHAR nExpSeq = GetNextSeq();
	658	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadDataWord, nType, nWordAddr, nWordCount);
	659	SendPacket(m_Packetbuf, len1);
	660	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	661
	662	int len2 = RecvPacket(m_RecvBuf, numToRead);
	663	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	664	if (len2 == 0) return KL_ERR;
	665	unsigned char nCmd;
65f713	666	unsigned short nnCount=0;
0ed438	667	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	668	for (int i = 0; i < nnCount/2; i++)
	669	{
	670	// Values[0] = m_DataBuf[0];
	671	Values[i] = m_DataBuf[i2] + (m_DataBuf[i 2 +1]<<8);
	672	}
	673	return res;
	674	}
65f713	675	int KLink::WriteDataWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
0ed438	676	{
Q	677	m_Dst = nDst;
	678	UCHAR nExpSeq = GetNextSeq();
	679	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteDataWord, nType, nWordAddr, nWordCount, Values);
	680	SendPacket(m_Packetbuf, len1);
65f713	681	nWordCount = 0;
Q	682	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	683	int len2 = RecvPacket(m_RecvBuf, nWordCount);
	684	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, nWordCount); }
0ed438	685	if (len2 == 0) return KL_ERR;
Q	686	unsigned char nCmd;
65f713	687	unsigned short nnCount=0;
0ed438	688	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	689	Values[0] = m_DataBuf[0];
	690	return res;
	691	}
	692
65f713	693	int KLink::ReadData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
0ed438	694	{
Q	695	m_Dst = nDst;
	696	UCHAR nExpSeq = GetNextSeq();
	697	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadData, nType, nWordAddr, nWordCount);
	698	SendPacket(m_Packetbuf, len1);
	699	int len2 = RecvPacket(m_RecvBuf, 64);
	700	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	701	if (len2 == 0) return KL_ERR;
	702	unsigned char nCmd;
65f713	703	unsigned short nnCount=0;
0ed438	704	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	705	for (int i=0;i<nnCount;i++) Values[i] = m_DataBuf[i];
	706	return res;
	707
	708	return KL_OK;
	709	}
65f713	710	int KLink::WriteData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
0ed438	711	{
Q	712	m_Dst = nDst;
	713	UCHAR nExpSeq = GetNextSeq();
	714	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteData, nType, nWordAddr, nWordCount, Values);
	715	SendPacket(m_Packetbuf, len1);
	716	int len2 = RecvPacket(m_RecvBuf, 64);
	717	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	718	if (len2 == 0) return KL_ERR;
	719	unsigned char nCmd;
65f713	720	unsigned short nnCount=0;
0ed438	721	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	722	// Values[0] = m_DataBuf[0];
	723	return res;
	724
	725	return KL_OK;
	726	}
65f713	727	int KLink::GetInfo(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
0ed438	728	{
Q	729	m_Dst = nDst;
	730	UCHAR nExpSeq = GetNextSeq();
	731	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetInfo, nType, nWordAddr, nWordCount, Values);
65f713	732	CString s1;
Q	733	for (int i = 0; i < len1; i++) {
	734	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	735	}
	736	m_resultStr = s1;
0ed438	737	SendPacket(m_Packetbuf, len1);
65f713	738	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
Q	739	int len2 = RecvPacket(m_RecvBuf, numToRead);
	740	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
0ed438	741	if (len2 == 0) return KL_ERR;
Q	742	unsigned char nCmd;
65f713	743	unsigned short nnCount=0;
Q	744	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	745	// Values[0] = m_DataBuf[0];
	746	return res;
	747
	748	return KL_OK;
	749	}
	750	int KLink::GetSN(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	751	{
	752	m_Dst = nDst;
	753	UCHAR nExpSeq = GetNextSeq();
	754	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetSN, nType, nWordAddr, nWordCount, Values);
	755	CString s1;
	756	for (int i = 0; i < len1; i++) {
	757	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	758	}
	759	m_resultStr = s1;
	760	SendPacket(m_Packetbuf, len1);
	761	nWordCount = 4;
	762	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	763	int len2 = RecvPacket(m_RecvBuf, numToRead);
	764	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	765	if (len2 == 0) return KL_ERR;
	766	unsigned char nCmd;
	767	unsigned short nnCount = 0;
	768	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	769	// Values[0] = m_DataBuf[0];
	770	return res;
	771
	772	return KL_OK;
	773	return 0;
	774	}
	775	int KLink::GetUID(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	776	{
	777	m_Dst = nDst;
	778	UCHAR nExpSeq = GetNextSeq();
	779	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetUid, nType, nWordAddr, nWordCount, Values);
	780	CString s1;
	781	for (int i = 0; i < len1; i++) {
	782	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	783	}
	784	m_resultStr = s1;
	785	SendPacket(m_Packetbuf, len1);
	786	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	787	int len2 = RecvPacket(m_RecvBuf, numToRead);
	788	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	789	if (len2 == 0) return KL_ERR;
	790	unsigned char nCmd;
	791	unsigned short nnCount = 0;
	792	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	793	// Values[0] = m_DataBuf[0];
	794	return res;
	795
	796	return KL_OK;
	797	return 0;
	798	}
	799
	800	int KLink::GetFactoryData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	801	{
	802	m_Dst = nDst;
	803	UCHAR nExpSeq = GetNextSeq();
	804	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetFactoryData, nType, nWordAddr, nWordCount, Values);
	805	CString s1;
	806	for (int i = 0; i < len1; i++) {
	807	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	808	}
	809	m_resultStr = s1;
	810	SendPacket(m_Packetbuf, len1);
	811	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	812	int len2 = RecvPacket(m_RecvBuf, numToRead);
	813	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	814	if (len2 == 0) return KL_ERR;
	815	unsigned char nCmd;
	816	unsigned short nnCount = 0;
	817	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	818	// Values[0] = m_DataBuf[0];
	819	return res;
	820	return KL_OK;
	821	}
	822	int KLink::WriteFactoryData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	823	{
	824	m_Dst = nDst;
	825	UCHAR nExpSeq = GetNextSeq();
	826	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteFactoryData, nType, nWordAddr, nWordCount, Values);
	827	SendPacket(m_Packetbuf, len1);
	828	nWordCount = 0;
	829	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	830	int len2 = RecvPacket(m_RecvBuf, numToRead);
	831	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	832	if (len2 == 0) return KL_ERR;
	833	unsigned char nCmd;
	834	unsigned short nnCount = 0;
0ed438	835	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	836	// Values[0] = m_DataBuf[0];
	837	return res;
	838
	839	return KL_OK;
	840	}
65f713	841
0ed438	842	int KLink::GetEventLogCount(UCHAR nDst, int * nCount)
Q	843	{
	844	m_Dst = nDst;
	845	UCHAR nExpSeq = GetNextSeq();
	846	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetEventLogCount, 0);
	847	SendPacket(m_Packetbuf, len1);
	848	int len2 = RecvPacket(m_RecvBuf, 64);
	849	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	850	if (len2 == 0) return KL_ERR;
	851	unsigned char nCmd;
65f713	852	unsigned short nnCount=0;
0ed438	853	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	854	nCount[0] = (int )m_DataBuf;
	855	return res;
	856
	857	return KL_OK;
	858	}
	859
	860	int KLink::GetEventLog(UCHAR nDst, int nStartIndex, int nCount, stEventLog * theEventLogs)
	861	{
	862	m_Dst = nDst;
	863	UCHAR nExpSeq = GetNextSeq();
	864	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetEventLog, 0, nStartIndex, nCount, 0);
	865	SendPacket(m_Packetbuf, len1);
	866	int len2 = RecvPacket(m_RecvBuf, 64);
	867	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	868	if (len2 == 0) return KL_ERR;
	869	unsigned char nCmd;
65f713	870	unsigned short nnCount=0;
0ed438	871	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	872
	873	memcpy(theEventLogs, m_DataBuf, nCount * sizeof(stEventLog));
	874
	875	return res;
	876
	877	return KL_OK;
	878	}
	879
	880	int KLink::GetDateTime32(UCHAR nDst, UINT * pValue)
	881	{
	882	int res = KL_OK;
65f713	883	res = ReadDataByte(nDst, KLDataTypeSDT, 36, 4, (UCHAR *)pValue);
0ed438	884	return res;
Q	885
	886	}
	887
	888	int KLink::SetDateTime32(UCHAR nDst, UINT Value)
	889	{
	890	int res = KL_OK;
65f713	891	res = WriteDataByte(nDst, KLDataTypeSDT, 36, 4, (UCHAR *)&Value);
0ed438	892	return res;
Q	893	}
	894
	895	int KLink::GetMode(UCHAR nDst, UCHAR nType)
	896	{
	897	int res = KL_OK;
	898	// res = ReadDataByte(nDst, 4, KLDataTypeSDT, 36, (UCHAR *)pValue);
	899	m_Dst = nDst;
	900	UCHAR nExpSeq = GetNextSeq();
	901	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetMode, nType);
	902	SendPacket(m_Packetbuf, len1);
	903	int len2 = RecvPacket(m_RecvBuf, 64);
	904	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	905	if (len2 == 0) return KL_ERR;
	906	unsigned char nCmd;
65f713	907	unsigned short nnCount=0;
0ed438	908	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	909	return res;
	910
	911	}
	912
	913
	914	int KLink::ChangeMode(UCHAR nDst, UCHAR nType)
	915	{
	916	int res = KL_OK;
	917	// res = WriteDataByte(nDst, 4, KLDataTypeSDT, 36, (UCHAR *)&Value);
	918	m_Dst = nDst;
	919	UCHAR nExpSeq = GetNextSeq();
	920	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdChgMode, nType);
	921	SendPacket(m_Packetbuf, len1);
	922	int len2 = RecvPacket(m_RecvBuf, 64);
	923	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	924	if (len2 == 0) return KL_ERR;
	925	unsigned char nCmd;
65f713	926	unsigned short nnCount=0;
0ed438	927	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	928	return res;
	929
	930	}
	931
	932
	933
	934	int KLink::ReadProgram(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	935	{
	936	int res = KL_OK;
	937	m_Dst = nDst;
	938	UCHAR nExpSeq = GetNextSeq();
	939	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadProgram, nType, nWordAddr, nWordCount);
	940	SendPacket(m_Packetbuf, len1);
	941	int nByteCount = nWordCount;
	942	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	943	int len2 = RecvPacket(m_RecvBuf, numToRead);
	944	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	945	if (len2 <= 0) return KL_ERR;
	946	unsigned char nCmd;
65f713	947	unsigned short nnCount=0;
0ed438	948	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	949	unsigned char * values2 = (unsigned char *)Values;
	950	for (int i = 0; i < nnCount; i++) values2[i] = m_DataBuf[i];
	951	return res;
	952
	953	}
	954
	955	int KLink::StartProgram(UCHAR nDst, UCHAR nType)
	956	{
	957	int res = KL_OK;
	958	m_Dst = nDst;
	959	UCHAR nExpSeq = GetNextSeq();
	960	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdStartProgram, nType);
	961	SendPacket(m_Packetbuf, len1);
	962	int len2 = RecvPacket(m_RecvBuf, 6);
	963	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6); }
	964	if (len2 <= 0) return KL_ERR;
	965	unsigned char nCmd;
65f713	966	unsigned short nnCount=0;
0ed438	967	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	968	return res;
	969
	970	}
	971	int KLink::WriteProgram(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	972	{
	973	int res = KL_OK;
	974	m_Dst = nDst;
	975	UCHAR nExpSeq = GetNextSeq();
	976	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteProgram, nType, nWordAddr, nWordCount, Values);
	977
	978	SendPacket(m_Packetbuf, len1);
	979	int len2 = RecvPacket(m_RecvBuf, 6);
	980	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6, 30); }
	981	if (len2 <= 0) return KL_ERR;
	982	unsigned char nCmd;
65f713	983	unsigned short nnCount=0;
0ed438	984	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	985	// Values[0] = m_DataBuf[0];
	986	return res;
	987
	988	}
	989	int KLink::FinishProgram(UCHAR nDst, UCHAR nType, USHORT nStepSize)
	990	{
	991	int res = KL_OK;
	992
	993	m_Dst = nDst;
	994	UCHAR nExpSeq = GetNextSeq();
	995	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdFinishProgram, nType, nStepSize);
	996	SendPacket(m_Packetbuf, len1);
	997	int len2 = RecvPacket(m_RecvBuf, 6);
	998	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6, 30); }
	999	if (len2 <= 0) return KL_ERR;
	1000	unsigned char nCmd;
65f713	1001	unsigned short nnCount=0;
0ed438	1002	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	1003	return res;
	1004	}
	1005
	1006	int KLink::ReadRunStat(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	1007	{
	1008	int res = KL_OK;
	1009	m_Dst = nDst;
	1010	UCHAR nExpSeq = GetNextSeq();
	1011	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadRunStat, nType, nWordAddr, nWordCount);
	1012	SendPacket(m_Packetbuf, len1);
	1013	int nByteCount = nWordCount;
	1014	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1015	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1016	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1017	if (len2 <= 0) return KL_ERR;
	1018	unsigned char nCmd;
65f713	1019	unsigned short nnCount=0;
0ed438	1020	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
Q	1021	unsigned char * values2 = (unsigned char *)Values;
	1022	for (int i = 0; i < nnCount; i++) values2[i] = m_DataBuf[i];
	1023	return res;
	1024
	1025	}