MultiTerminal1 - Gitblit

2023-05-19

QuakeGod

2023-05-19 418cb35b936f21415807a2bcc21b2d75934bd4d2

提交 \| 用户 \| age
418cb3	1	#include "pch.h"
Q	2	#include "KLink1.h"
	3	#include "KLink.h"
	4	#include <afxdialogex.h>
	5	#include "CDialogCommSet1.h"
	6
	7	KLink1::KLink1()
	8	{
	9
	10	}
	11
	12	KLink1::~KLink1()
	13	{
	14
	15	}
	16
	17	static const KLink1::stKLTypeName KLCoilTypeNames[] =
	18	{
	19	{KLink1::KLCoilTypeX,"X",KLink1::KLCoilXCount},
	20	{KLink1::KLCoilTypeY,"Y",KLink1::KLCoilYCount},
	21	{KLink1::KLCoilTypeR,"R",KLink1::KLCoilRCount},
	22	{KLink1::KLCoilTypeLX,"LX",KLink1::KLCoilLXCount},
	23	{KLink1::KLCoilTypeLY,"LY",KLink1::KLCoilLYCount},
	24	{KLink1::KLCoilTypeT,"T",KLink1::KLCoilTCount},
	25	{KLink1::KLCoilTypeC,"C",KLink1::KLCoilCCount}
	26	};
	27
	28	static const KLink1::stKLTypeName KLDataTypeNames[] =
	29	{
	30
	31	KLink1::KLDataTypeWX,"WX", KLink1::KLDataWXCount,
	32	KLink1::KLDataTypeWY,"WY", KLink1::KLDataWYCount,
	33	KLink1::KLDataTypeWR,"WR",KLink1::KLDataWRCount,
	34	KLink1::KLDataTypeWLX,"WLX",KLink1::KLDataWLCount,
	35	KLink1::KLDataTypeWLY,"WLY",KLink1::KLDataWLCount,
	36	KLink1::KLDataTypeDT,"DT",KLink1::KLDataDTCount,
	37	KLink1::KLDataTypeSDT,"SDT",KLink1::KLDataSDTCount,
	38	KLink1::KLDataTypeSV,"SV",KLink1::KLDataSVCount ,
	39	KLink1::KLDataTypeEV,"EV",KLink1::KLDataEVCount ,
	40	KLink1::KLDataTypeLD,"LD",KLink1::KLDataLDCount,
	41	KLink1::KLDataSysCfg,"Cfg",128,
	42	KLink1::KLDataTypeFlash,"Flash",256,
	43	KLink1::KLDataTypeTest,"Test",256
	44	};
	45
	46	const char * KLink1::GetErrDescStr(int nErrNo)
	47	{
	48	switch (nErrNo)
	49	{
	50	case KL_ERR:
	51	return "ERROR";
	52	case KL_OK: //=0
	53	return "OK";
	54	case KL_NG:// = 1,
	55	return "NG";
	56	case KL_UNKNOWN: // = 2,
	57	return "KL_UNKNOWN";
	58	case KL_TIMEOUT: // = 3,
	59	return "KL_TIMEOUT";
	60	case KL_BCC_ERR: // = 4,
	61	return "KL_BCC_ERR";
	62	case KL_PKG_ERR: // = 5,
	63	return "KL_PKG_ERR";
	64	case KL_SEQ_ERR: // = 6,
	65	return "KL_SEQ_ERR";
	66	case KL_LENTH_EXCEED: //,
	67	return "KL_LENTH_EXCEED";
	68	case KL_NEED_PASS: //,
	69	return "KL_NEED_PASS";
	70	case KL_NOT_SUPPORT://,
	71	return "KL_NOT_SUPPORT";
	72	default:
	73	return "KL_OTHER_ERR";
	74	break;
	75	}
	76	}
	77
	78	int KLink1::xtoi(const char * hexstr, int len)
	79	{
	80	int len1 = len;
	81	if (len <= 0) len1 = (int)strlen(hexstr);
	82	int j = 0;
	83	for (int i = 0; i < len1; i++)
	84	{
	85	unsigned char ch = hexstr[i];
	86	if (ch >= '0'&&ch <= '9') { int k = ch - '0'; j = j * 16 + k; continue; }
	87	if (ch >= 'A'&&ch <= 'F') { int k = ch - 'A' + 10; j = j * 16 + k; continue; }
	88	if (ch >= 'a'&&ch <= 'f') { int k = ch - 'a' + 10; j = j * 16 + k; continue; }
	89	if (ch == ' ' \|\| ch == ' ') { continue; }
	90	break;
	91	}
	92	return j;
	93	}
	94
	95	unsigned char KLink1::KLBCC(void * pData, int nSize)
	96	{
	97	unsigned char k = 0;
	98	for (int i = 0; i < nSize; i++)
	99	{
	100	k ^= ((unsigned char *)pData)[i];
	101	}
	102	return k;
	103	}
	104	int KLink1::CalCRC(void * pBuf, int nSize)
	105	{
	106	return 0;
	107	}
	108
	109	int KLink1::SetCallBackFuncs(pCallBackFuncs pFuncSt)
	110	{
	111	if (pFuncSt->OpenFunc) { m_CallBackFuncs.OpenFunc = pFuncSt->OpenFunc; m_bOpenCallBackSet = 1; }
	112	if (pFuncSt->CloseFunc) { m_CallBackFuncs.CloseFunc = pFuncSt->CloseFunc; m_bCloseCallBackSet = 1; }
	113	if (pFuncSt->SendPkgFunc) { m_CallBackFuncs.SendPkgFunc = pFuncSt->SendPkgFunc; m_bSendCallBackSet = 1; }
	114	if (pFuncSt->RecvPkgFunc) { m_CallBackFuncs.RecvPkgFunc = pFuncSt->RecvPkgFunc; m_bRecvCallBackSet = 1; }
	115	if (pFuncSt->ClearBufFunc) { m_CallBackFuncs.ClearBufFunc = pFuncSt->ClearBufFunc; m_bClearBufCallBackSet = 1; }
	116	if (pFuncSt->OnConnect) { m_CallBackFuncs.OnConnect = pFuncSt->OnConnect; m_bOnConnectCallBackSet = 1; }
	117	if (pFuncSt->OnDisConnect) { m_CallBackFuncs.OnDisConnect = pFuncSt->OnDisConnect; m_bOnDisConnectCallBackSet = 1; }
	118	if (pFuncSt->OnError) { m_CallBackFuncs.OnError = pFuncSt->OnError; m_bOnErrorCallBackSet = 1; }
	119
	120	// if (pFuncSt->SendPkgFunc) { m_CallBackFuncs.SendPkgFunc = pFuncSt->SendPkgFunc; m_bSendCallBackSet = 1; }
	121
	122	return KL_OK;
	123	}
	124
	125
	126	int KLink1::SetCommParam()
	127	{
	128	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	129	/*
	130	//方法2的状态变更
	131	HINSTANCE save_hInstance = AfxGetResourceHandle();
	132
	133	AfxSetResourceHandle(theApp.m_hInstance);
	134
	135	// CDialog dlg(IDD_DLL_DIALOG);//打开ID为2000的对话框
	136	// dlg.DoModal();
	137	*/
	138	CDialogCommSet1 dialog1;
	139	INT_PTR r = dialog1.DoModal();
	140	//方法2的状态还原
	141
	142	// AfxSetResourceHandle(save_hInstance);
	143	if (r == IDOK)
	144	{
	145	m_nPort = dialog1.m_nComNum;
	146	m_nBaudRate = dialog1.m_nBaudRate;
	147	m_Settings = dialog1.m_Settings;
	148	m_bCommParamSet = true;
	149	}
	150	else
	151	{
	152	return -1;
	153	}
	154
	155	return 0;
	156	}
	157	int KLink1::fnTest1(int n)
	158	{
	159	AFX_MANAGE_STATE(AfxGetStaticModuleState());
	160	/*
	161	//方法2的状态变更
	162	HINSTANCE save_hInstance = AfxGetResourceHandle();
	163
	164	AfxSetResourceHandle(theApp.m_hInstance);
	165
	166	// CDialog dlg(IDD_DLL_DIALOG);//打开ID为2000的对话框
	167	// dlg.DoModal();
	168	*/
	169	CDialogCommSet1 dialog1;
	170	INT_PTR r = dialog1.DoModal();
	171	//方法2的状态还原
	172
	173	// AfxSetResourceHandle(save_hInstance);
	174
	175	return 0;
	176	}
	177
	178	int KLink1::Open(int OpenParam)
	179	{
	180	CString s1;
	181	if (!m_bCommParamSet)
	182	{
	183	if (SetCommParam()) return -1;
	184	m_bCommParamSet = 1;
	185	}
	186	MySerPort1.SetParams(m_nPort, m_nBaudRate, _T("8,N,1"));
	187	int r = MySerPort1.Open();
	188	s1.Format(_T("Open %s = %d"), MySerPort1.m_strResult, r);
	189	m_resultStr = s1; // MySerPort1.m_strResult;
	190	if (r == MySerPort1.R_OK)
	191	{
	192	m_bOpened = true;
	193	// MyKLink1.Open();
	194	// m_static_connect.SetCtlColor(RGB(0, 255, 0));
	195	return KL_OK;
	196	}
	197	else
	198	{
	199	m_bOpened = false;
	200	return r;
	201	}
	202	/*
	203	if (m_bOpenCallBackSet)
	204	{
	205	m_CallBackFuncs.OpenFunc();
	206	}
	207	*/
	208	m_bOpened = true;
	209	return KL_OK;
	210	};
	211	int KLink1::Close(int CloseParam)
	212	{
	213	if (m_bCloseCallBackSet)
	214	{
	215	m_CallBackFuncs.CloseFunc();
	216	}
	217	m_bOpened = false;
	218	return KL_OK;
	219	};
	220	int KLink1::Connect(int ConnectParam)
	221	{
	222	int OpenParam = ConnectParam;
	223	int res=Open(OpenParam);
	224	unsigned short len1;
	225	unsigned short buf1[256];
	226	//m_resultStr = MySerPort1.m_strResult;
	227	return res;
	228	if (res == KL_OK)
	229	{
	230	int res2 = GetInfo(m_Dst, &len1, buf1);
	231
	232	if (m_bOnConnectCallBackSet) { m_CallBackFuncs.OnConnect(); }
	233	return res;
	234	}
	235	return res;
	236	}
	237	int KLink1::DisConnect(int DisConnectParam)
	238	{
	239	if (m_bOnDisConnectCallBackSet) { m_CallBackFuncs.OnDisConnect(DisConnectParam); }
	240	return Close();
	241	}
	242
	243	int KLink1::CalSpeed()
	244	{
	245	double thistime = MySerPort1.GetTimemS();
	246	double diftime = thistime - LastTime;
	247	if (diftime >= 500)
	248	{
	249	m_SendSpeed = (DWORD)(m_nSendCount * 1000 / diftime);
	250	m_RecvSpeed = static_cast<DWORD> (m_nRecvCount * 1000 / diftime);
	251	m_nLastSendCount = m_nSendCount; m_nSendCount = 0;
	252	m_nLastRecvCount = m_nRecvCount; m_nRecvCount = 0;
	253	LastTime = thistime;
	254	}
	255	return 0;
	256	}
	257
	258	int KLink1::DoHeartBeat(int nParam)
	259	{
	260	unsigned short nByteCount;
	261	unsigned short buf1[256];
	262	int res = GetInfo(m_Dst, &nByteCount, buf1);
	263	return KL_OK;
	264	}
	265
	266	void KLink1::OnTimer()
	267	{
	268	DoHeartBeat();
	269	}
	270
	271	int KLink1::SendPacket(void * pBuf, int Len)
	272	{
	273	if (m_bOpened && m_bSendCallBackSet)
	274	{
	275	if (m_bClearBufCallBackSet) m_CallBackFuncs.ClearBufFunc();
	276	return m_CallBackFuncs.SendPkgFunc(pBuf, Len);
	277	}
	278	else return KL_ERR;
	279	}
	280
	281	int KLink1::RecvPacket(void * pBuf, int LenToRead, int ReTryCount)
	282	{
	283
	284	if (m_bOpened && m_bRecvCallBackSet)
	285	{
	286	int len2 = 0;
	287	char * pBufByte = (char *)pBuf;
	288	for (int i = 0; i < ReTryCount; i++)
	289	{
	290	int len1 = m_CallBackFuncs.RecvPkgFunc(pBufByte + len2, LenToRead - len2);
	291	if (len1 <= 0 \|\| len1 > 256) {
	292	continue;
	293	}
	294	len2 += len1;
	295	if (len2 >= LenToRead) break;
	296	}
	297	if (len2 >= LenToRead) {
	298	m_nContinueErrCount = 0;
	299	return len2;
	300	}
	301	else if (len2 <= 0) {
	302	m_nErrCount++;
	303	m_nContinueErrCount++;
	304	if (m_nContinueErrCount > 10)
	305	{
	306	// Close(-1);
	307	}
	308	return KL_ERR;
	309	}
	310	else {
	311	return len2;
	312	}
	313	}
	314	else
	315	{
	316	return KL_ERR;
	317	}
	318	}
	319
	320	int KLink1::MakeExtDataFrame(void * pBuf, UCHAR nDst, UCHAR nType, UCHAR len2, void * pData)
	321	{
	322	int framelen1 = 0;
	323	pKLExtDataFrame pF1 = (pKLExtDataFrame)pBuf;
	324	pF1->Dst = nDst;
	325	pF1->nType = nType;
	326	pF1->Len2 = len2;
	327	memcpy(pF1->Data, pData, len2);
	328	UCHAR bcc = KLBCC(pBuf, sizeof(tagKLExtDataFrame) + len2 - 1);
	329	pF1->Data[len2] = bcc;
	330
	331	framelen1 = sizeof(tagKLExtDataFrame) + len2;
	332	return framelen1;
	333	}
	334	/*
	335	int KLink1::MakeReqPacket(void * pBuf, UCHAR nDst, UCHAR Stat, UCHAR nCMD, UCHAR Type, USHORT nAddr, USHORT nCount, void * pData)
	336	{
	337	int PkgLen1 = 0;
	338	pKLReqPacket pPacket = (pKLReqPacket)pBuf;
	339	pPacket->StartSign = KLSignStart;
	340	pPacket->DstAddr = nDst;
	341	pPacket->Stat = Stat;
	342	pPacket->Cmd = nCMD;
	343	pPacket->Type1 = Type;
	344	int Datalen = 0;
	345	int nWordAddr;
	346	int nWordCount;
	347
	348	switch (nCMD)
	349	{
	350	case KLCmdNone:
	351	break;
	352	case KLCmdPing:
	353	Datalen = Type;
	354	memcpy(pPacket->Params, pData, Datalen);
	355	PkgLen1 = sizeof(stKLReqPacket) + Datalen;
	356	break;
	357	case KLCmdGetInfo:
	358	break;
	359	case KLCmdRead:
	360	Datalen = 0;
	361	pPacket->Params[0] = nAddr % 256;
	362	pPacket->Params[1] = nAddr / 256;
	363	pPacket->Params[2] = nCount % 256;
	364	pPacket->Params[3] = nCount / 256;
	365	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	366	break;
	367	case KLCmdWrite:
	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 = nCount;
	373	memcpy(pPacket->Params + 4, pData, Datalen);
	374	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	375
	376	break;
	377	case KLCmdSaveToFlash:
	378	break;
	379	case KLCmdExChgData:
	380	break;
	381	case KLCmdGetEventLogCount:
	382	pPacket->Params[0] = 0;
	383	pPacket->Params[1] = 0;
	384	pPacket->Params[2] = 0;
	385	pPacket->Params[3] = 0;
	386	Datalen = 0;
	387	memcpy(pPacket->Params + 4, pData, Datalen);
	388	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	389	default:
	390	break;
	391	}
	392	if (PkgLen1 >= sizeof(stKLReqPacket))
	393	{
	394	UCHAR BCC = KLBCC(pBuf, PkgLen1 - 1);
	395	pPacket->Params[PkgLen1-sizeof(stKLReqPacket)] = BCC;
	396	}
	397	return PkgLen1;
	398	}
	399	*/
	400	int KLink1::MakeReqPacketEx(void * pBuf, UCHAR nDst, UCHAR Stat, UCHAR nCMD, UCHAR Type, USHORT nAddr, USHORT nCount, void * pData, int ExtFrameLen, void * pExtDataFrame)
	401	{
	402	int PkgLen1 = 0;
	403	pKLReqPacket pPacket = (pKLReqPacket)pBuf;
	404	pPacket->StartSign = KLSignStart;
	405	pPacket->DstAddr = nDst;
	406	pPacket->Stat = Stat;
	407	pPacket->Cmd = nCMD;
	408	pPacket->Type1 = Type;
	409
	410	pKLStat pStat = (pKLStat)&(pPacket->Stat);
	411	int Datalen = 0;
	412	int nWordAddr = nAddr;
	413	int nWordCount = nCount;
	414	pPacket->Params[0] = LOBYTE(nAddr);
	415	pPacket->Params[1] = HIBYTE(nAddr);
	416	pPacket->Params[2] = nCount % 256;
	417	pPacket->Params[3] = nCount / 256;
	418
	419	switch (nCMD)
	420	{
	421	case KLCmdNone:
	422	break;
	423	case KLCmdPing:
	424	Datalen = Type;
	425	memcpy(pPacket->Params, pData, Datalen);
	426	PkgLen1 = sizeof(stKLReqPacket) + Datalen;
	427	break;
	428	case KLCmdGetInfo:
	429	case KLCmdGetSN:
	430	Datalen = 0;
	431	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	432	break;
	433	case KLCmdGetFactoryData:
	434	Datalen = 0;
	435	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	436	break;
	437	case KLCmdWriteFactoryData:
	438	Datalen = nCount;
	439	memcpy(pPacket->Params + 4, pData, Datalen);
	440	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	441	break;
	442	case KLCmdRead:
	443	Datalen = 0;
	444	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	445	break;
	446	case KLCmdWrite:
	447	Datalen = nCount;
	448	memcpy(pPacket->Params + 4, pData, Datalen);
	449	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	450	break;
	451	case KLCmdRead1Bit:
	452	Datalen = 0;
	453	PkgLen1 = sizeof(stKLReqPacket) + 2 + Datalen;
	454	break;
	455	case KLCmdWrite1Bit:
	456	Datalen = 1;
	457	memcpy(pPacket->Params + 2, pData, Datalen);
	458	PkgLen1 = sizeof(stKLReqPacket) + 2 + Datalen;
	459	break;
	460
	461	case KLCmdReadBits:
	462	Datalen = 0;
	463	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	464	break;
	465	case KLCmdWriteBits:
	466	Datalen = 0;
	467	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	468	break;
	469	case KLCmdReadDataByte:
	470	case KLCmdReadDataWord:
	471	case KLCmdReadData:
	472	Datalen = 0;
	473	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	474	break;
	475	case KLCmdWriteDataByte:
	476	case KLCmdWriteDataWord:
	477	case KLCmdWriteData:
	478	Datalen = nCount;
	479	memcpy(pPacket->Params + 4, pData, Datalen);
	480	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	481	break;
	482	case KLCmdSaveToFlash:
	483	break;
	484	case KLCmdExChgData:
	485	break;
	486	case KLCmdReadProgram:
	487	Datalen = 0;
	488	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	489	break;
	490	case KLCmdStartProgram:
	491	Datalen = 0;
	492	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	493	break;
	494	case KLCmdWriteProgram:
	495	Datalen = nCount;
	496	memcpy(pPacket->Params + 4, pData, Datalen);
	497	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	498	break;
	499	case KLCmdFinishProgram:
	500	Datalen = 0;
	501	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	502	break;
	503
	504	case KLCmdReadRunStat:
	505	Datalen = 0;
	506	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	507	break;
	508
	509	case KLCmdWriteSysCfg:
	510	Datalen = nCount;
	511	memcpy(pPacket->Params + 4, pData, Datalen);
	512	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	513	break;
	514	case KLCmdSaveSysCfg:
	515	pPacket->Params[0] = 0;
	516	pPacket->Params[1] = 0;
	517	pPacket->Params[2] = 0;
	518	pPacket->Params[3] = 0;
	519	Datalen = 0;
	520	memcpy(pPacket->Params + 4, pData, Datalen);
	521	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	522	break;
	523	case KLCmdSaveRunStat:
	524	pPacket->Params[0] = 0;
	525	pPacket->Params[1] = 0;
	526	pPacket->Params[2] = 0;
	527	pPacket->Params[3] = 0;
	528	Datalen = 0;
	529	memcpy(pPacket->Params + 4, pData, Datalen);
	530	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	531	break;
	532	case KLCmdClearEventLog:
	533	pPacket->Params[0] = 0;
	534	pPacket->Params[1] = 0;
	535	pPacket->Params[2] = 0;
	536	pPacket->Params[3] = 0;
	537	Datalen = 0;
	538	memcpy(pPacket->Params + 4, pData, Datalen);
	539	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	540
	541	case KLCmdGetEventLogCount:
	542	pPacket->Params[0] = 0;
	543	pPacket->Params[1] = 0;
	544	pPacket->Params[2] = 0;
	545	pPacket->Params[3] = 0;
	546	Datalen = 0;
	547	memcpy(pPacket->Params + 4, pData, Datalen);
	548	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	549	break;
	550	case KLCmdGetEventLog:
	551	pPacket->Params[0] = nAddr % 256;
	552	pPacket->Params[1] = nAddr / 256;
	553	pPacket->Params[2] = nCount % 256;
	554	pPacket->Params[3] = nCount / 256;
	555	Datalen = 0;
	556	memcpy(pPacket->Params + 4, pData, Datalen);
	557	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	558	break;
	559
	560	default:
	561	pPacket->Params[0] = nAddr % 256;
	562	pPacket->Params[1] = nAddr / 256;
	563	pPacket->Params[2] = nCount % 256;
	564	pPacket->Params[3] = nCount / 256;
	565	Datalen = 0;
	566	memcpy(pPacket->Params + 4, pData, Datalen);
	567	PkgLen1 = sizeof(stKLReqPacket) + 4 + Datalen;
	568	break;
	569	}
	570
	571	if (PkgLen1 >= sizeof(stKLReqPacket))
	572	{
	573	UCHAR BCC = KLBCC(pBuf, PkgLen1 - 1);
	574	pPacket->Params[PkgLen1 - sizeof(stKLReqPacket)] = BCC;
	575	}
	576
	577	if (pStat->HasExt && ExtFrameLen > 0 && pExtDataFrame != NULL)
	578	{
	579
	580	memcpy(pPacket->Params + PkgLen1 - sizeof(stKLReqPacket) + 1, pExtDataFrame, ExtFrameLen);
	581	PkgLen1 += ExtFrameLen;
	582	};
	583	return PkgLen1;
	584	}
	585
	586
	587	int KLink1::CheckPackage(void * pBuf, int nSize)
	588	{
	589	pKLRplyPktHdr p1 = (pKLRplyPktHdr)pBuf;
	590	if (p1->RplyStSgn != KLSignReply)
	591	{
	592	return KL_UNKNOWN;
	593	}
	594
	595	int DataLen = 0; //p1->LoadLen;
	596	if (DataLen > KLMaxPacketLength)
	597	{
	598	return KL_PKG_ERR;
	599	}
	600	if (nSize < DataLen + sizeof(stKLRplyPktHdr))
	601	{
	602	//len4=sprintf(str3,"%d < %d + %d \r\n",len2,DataLen,sizeof(stPacket));
	603	//PutStr(str3,len4);
	604	return KL_PKG_ERR; //not long enough
	605	}
	606	// if (p1->data[DataLen+1] != EndSign)
	607	// {
	608	// ClientStat[nCurPollId].NoEndErr++;
	609	// Uart2Stat.LengthErr++;
	610	// return -2;
	611	// }
	612	unsigned char thisBCC = KLBCC(p1, nSize - 1);
	613	if (thisBCC != ((UCHAR *)pBuf)[nSize - 1])
	614	{//BCC Error;
	615	return KL_BCC_ERR;
	616	}
	617	return KL_OK;
	618
	619	return true;
	620	return false;
	621	}
	622
	623	int KLink1::ProcessPacket(void *pBuf, int nLen)
	624	{
	625	return false;
	626	}
	627
	628	int KLink1::ParseRplyPacket(void pBuf, int nPkgLen, UCHAR nCmd, UCHAR * Status, USHORT* nCount, void * pData)
	629	{
	630	if (nPkgLen < 0) { return KL_ERR; }
	631	int res = CheckPackage(pBuf, nPkgLen);
	632	if (res != KL_OK) return res;
	633	int len1 = 0;
	634	pKLRplyPktHdr pPacket = (pKLRplyPktHdr)pBuf;
	635	UCHAR Sign = pPacket->RplyStSgn;
	636	UCHAR nDst = pPacket->DstAddr;
	637	*nCmd = pPacket->nRplyCMD;
	638	UCHAR nStatus = pPacket->nStatus;
	639	*Status = nStatus;
	640	m_nRSeq = ((pKLStat)&nStatus)->nSEQ;
	641	int Datalen = pPacket->nSize1;
	642	*nCount = Datalen;
	643	switch (*nCmd)
	644	{
	645	case KLCmdNone:
	646	break;
	647	case KLCmdPing:
	648	case KLCmdPingReply:
	649	*nCount = Datalen;
	650	memcpy(pData, pPacket->Datas, Datalen);
	651	break;
	652	case KLCmdGetInfo:
	653	case KLCmdVerInfo:
	654	*nCount = Datalen;
	655	memcpy(pData, pPacket->Datas, Datalen);
	656	break;
	657	case KLCmdGetUid:
	658	case KLCmdGetSN:
	659	case KLCmdGetFactoryData:
	660	*nCount = Datalen;
	661	memcpy(pData, pPacket->Datas, Datalen);
	662	break;
	663	case KLCmdWriteFactoryData:
	664	*nCount = Datalen;
	665	break;
	666	case KLCmdRead:
	667	case KLCmdReadReply:
	668	*nCount = Datalen;
	669	memcpy(pData, pPacket->Datas, Datalen);
	670	break;
	671	case KLCmdWrite:
	672	case KLCmdWriteReply:
	673	*nCount = Datalen;
	674	break;
	675	case KLCmdRead1Bit:
	676	case KLCmdReadBits:
	677	*nCount = Datalen;
	678	memcpy(pData, pPacket->Datas, Datalen);
	679	break;
	680	case KLCmdReadDataByte:
	681	*nCount = Datalen;
	682	memcpy(pData, pPacket->Datas, Datalen);
	683	break;
	684	case KLCmdReadDataWord:
	685	case KLCmdReadData:
	686	*nCount = Datalen;
	687	memcpy(pData, pPacket->Datas, Datalen);
	688	break;
	689	case KLCmdWriteDataByte:
	690	case KLCmdWriteDataWord:
	691	case KLCmdWriteData:
	692	*nCount = Datalen;
	693	break;
	694
	695	case KLCmdSaveToFlash:
	696	break;
	697
	698	case KLCmdReadProgram:
	699	*nCount = Datalen;
	700	memcpy(pData, pPacket->Datas, Datalen);
	701	break;
	702	case KLCmdStartProgram:
	703	*nCount = Datalen;
	704	break;
	705	case KLCmdWriteProgram:
	706	*nCount = Datalen;
	707	break;
	708	case KLCmdFinishProgram:
	709	*nCount = Datalen;
	710	break;
	711
	712	case KLCmdReadRunStat:
	713	*nCount = Datalen;
	714	memcpy(pData, pPacket->Datas, Datalen);
	715	break;
	716	case KLCmdReadSysCfg:
	717	*nCount = Datalen;
	718	memcpy(pData, pPacket->Datas, Datalen);
	719	break;
	720	case KLCmdExChgData:
	721	case KLCmdExChgDataReply:
	722	break;
	723	case KLCmdGetEventLogCount:
	724	*nCount = Datalen;
	725	memcpy(pData, pPacket->Datas, Datalen);
	726	break;
	727	case KLCmdGetEventLog:
	728	*nCount = Datalen;
	729	memcpy(pData, pPacket->Datas, Datalen);
	730	break;
	731
	732	case KLCmdErrRply:
	733	*nCount = Datalen;
	734	memcpy(pData, pPacket->Datas, Datalen);
	735	break;
	736	default:
	737	*nCount = Datalen;
	738	//memcpy(pData, pPacket->Datas, Datalen);
	739	break;
	740	}
	741	return KL_OK;
	742
	743	return false;
	744	}
	745
	746	int KLink1::ReadBit(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR * Value)
	747	{
	748	m_Dst = nDst;
	749	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdRead1Bit, nType, nBitAddr);
	750	SendPacket(m_Packetbuf, len1);
	751	int numToRead = sizeof(stKLRplyPktHdr) + 1;
	752
	753	int len2 = RecvPacket(m_RecvBuf, numToRead);
	754	unsigned char nCmd;
	755	unsigned short nCount = 0;
	756	ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nCount, m_DataBuf);
	757	Value[0] = m_DataBuf[0];
	758	return KL_OK;
	759	}
	760	int KLink1::WriteBit(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR Value)
	761	{
	762	m_Dst = nDst;
	763	m_DataBuf[0] = Value;
	764	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWrite1Bit, nType, nBitAddr, 1, m_DataBuf);
	765	SendPacket(m_Packetbuf, len1);
	766	int len2 = RecvPacket(m_RecvBuf, 6);
	767	unsigned char nCmd;
	768	unsigned short nCount = 0;
	769	ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nCount, m_DataBuf);
	770	return KL_OK;
	771	}
	772	int KLink1::ReadBits(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR nBitCount, UCHAR * Values)
	773	{
	774	return KL_OK;
	775	}
	776	int KLink1::WriteBits(UCHAR nDst, UCHAR nType, USHORT nBitAddr, UCHAR nBitCount, UCHAR * Values)
	777	{
	778	return KL_OK;
	779	}
	780	int KLink1::ReadBitsByWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT *Values)
	781	{
	782	return KL_OK;
	783	}
	784	int KLink1::WriteBitsByWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT *Values)
	785	{
	786	return KL_OK;
	787	}
	788	int KLink1::GetNextSeq()
	789	{
	790	m_nSeq++;
	791	if (m_nSeq >= 8) m_nSeq = 0;
	792	m_Stat1.nSEQ = m_nSeq;
	793	return m_nSeq;
	794	}
	795
	796	int KLink1::ReadDataByte(UCHAR nDst, UCHAR nType, USHORT nByteAddr, UCHAR nByteCount, USHORT * nByteRead, UCHAR * Values)
	797	{
	798	m_Dst = nDst;
	799	m_resultStr.Empty();
	800	UCHAR nExpSeq = GetNextSeq();
	801	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadDataByte, nType, nByteAddr / 2, nByteCount);
	802	SendPacket(m_Packetbuf, len1);
	803	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	804	int len2 = 0;
	805	len2 = RecvPacket(m_RecvBuf, numToRead);
	806	if (len2 <= 0) { m_resultStr.Format(_T("Recv Failed len %d To=%d"), len2, numToRead); return KL_ERR; }
	807	if (len2 < numToRead)
	808	{
	809	CString s1;
	810	for (int i = 0; i < len2; i++)
	811	{
	812	s1.AppendFormat(_T("%02X "), m_RecvBuf[i]);
	813	}
	814	s1.Append(_T("\r\n"));
	815	m_resultStr.Format(_T("ToRead %d R= %d \r\n"), numToRead, len2);
	816	m_resultStr += s1;
	817	}
	818	unsigned char nCmd;
	819	unsigned short nnCount = 0;
	820	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	821	if (res == KL_OK)
	822	{
	823	for (int i = 0; i < nnCount; i++)
	824	{
	825	Values[i] = m_DataBuf[i];
	826	}
	827	}
	828	else
	829	{
	830	m_resultStr.AppendFormat(_T("Res=%d ToRead %d Count %d "), res, numToRead, len2);
	831	CString s1;
	832	s1 = GetErrDescStr(res);
	833	m_resultStr += s1;
	834	return res;
	835	}
	836	*nByteRead = nnCount;
	837	return KL_OK;
	838	}
	839
	840	int KLink1::WriteDataByte(UCHAR nDst, UCHAR nType, USHORT nByteAddr, UCHAR nByteCount, UCHAR * Values)
	841	{
	842	m_Dst = nDst;
	843	m_resultStr.Empty();
	844	UCHAR nExpSeq = GetNextSeq();
	845	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteDataByte, nType, nByteAddr / 2, nByteCount, Values);
	846	SendPacket(m_Packetbuf, len1);
	847	nByteCount = 0;
	848	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	849	int len2 = RecvPacket(m_RecvBuf, numToRead);
	850	// if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	851	if (len2 <= 0) return KL_ERR;
	852	unsigned char nCmd;
	853	unsigned short nnCount = 0;
	854	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	855	return res;
	856	}
	857
	858	int KLink1::ReadDataWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * nByteRead, USHORT * Values)
	859	{
	860	m_Dst = nDst;
	861	m_resultStr.Empty();
	862	UCHAR nExpSeq = GetNextSeq();
	863	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadDataWord, nType, nWordAddr, nWordCount * 2);
	864	SendPacket(m_Packetbuf, len1);
	865	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount * 2;
	866
	867	int len2 = RecvPacket(m_RecvBuf, numToRead);
	868	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	869	if (len2 <= 0) { m_resultStr.Format(_T("Recv Failed len %d To=%d"), len2, numToRead); return KL_ERR; }
	870	if (len2 < numToRead)
	871	{
	872	CString s1;
	873	for (int i = 0; i < len2; i++)
	874	{
	875	s1.AppendFormat(_T("%02X "), m_RecvBuf[i]);
	876	}
	877	s1.Append(_T("\r\n"));
	878	m_resultStr.Format(_T("ToRead %d R= %d \r\n"), numToRead, len2);
	879	m_resultStr += s1;
	880	}
	881	unsigned char nCmd;
	882	unsigned short nnCount = 0;
	883	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	884	if (res == KL_OK)
	885	{
	886	for (int i = 0; i < nnCount / 2; i++)
	887	{
	888	// Values[0] = m_DataBuf[0];
	889	Values[i] = m_DataBuf[i * 2] + (m_DataBuf[i * 2 + 1] << 8);
	890	}
	891	}
	892	else
	893	{
	894	m_resultStr.AppendFormat(_T("Res=%d ToRead %d Count %d "), res, numToRead, len2);
	895	CString s1;
	896	s1 = GetErrDescStr(res);
	897	m_resultStr += s1;
	898	return res;
	899	}
	900	*nByteRead = nnCount;
	901	return KL_OK;
	902	}
	903
	904	int KLink1::WriteDataWord(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	905	{
	906	m_Dst = nDst;
	907	m_resultStr.Empty();
	908	UCHAR nExpSeq = GetNextSeq();
	909	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteDataWord, nType, nWordAddr, nWordCount, Values);
	910	SendPacket(m_Packetbuf, len1);
	911	nWordCount = 0;
	912	int numToRead = sizeof(stKLRplyPktHdr) + nWordCount;
	913	int len2 = RecvPacket(m_RecvBuf, numToRead);
	914	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	915	if (len2 == 0) return KL_ERR;
	916	unsigned char nCmd;
	917	unsigned short nnCount = 0;
	918	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	919	Values[0] = m_DataBuf[0];
	920	return res;
	921	}
	922
	923	int KLink1::ReadData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * nByteRead, USHORT * Values)
	924	{
	925	m_Dst = nDst;
	926	m_resultStr.Empty();
	927	UCHAR nExpSeq = GetNextSeq();
	928	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadData, nType, nWordAddr, nWordCount);
	929	SendPacket(m_Packetbuf, len1);
	930	int len2 = RecvPacket(m_RecvBuf, 64);
	931	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	932	if (len2 == 0) return KL_ERR;
	933	unsigned char nCmd;
	934	unsigned short nnCount = 0;
	935	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	936	for (int i = 0; i < nnCount; i++) Values[i] = m_DataBuf[i];
	937	*nByteRead = nnCount;
	938	return res;
	939
	940	return KL_OK;
	941	}
	942	int KLink1::WriteData(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	943	{
	944	m_Dst = nDst;
	945	m_resultStr.Empty();
	946	UCHAR nExpSeq = GetNextSeq();
	947	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteData, nType, nWordAddr, nWordCount, Values);
	948	SendPacket(m_Packetbuf, len1);
	949	int len2 = RecvPacket(m_RecvBuf, 64);
	950	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	951	if (len2 == 0) return KL_ERR;
	952	unsigned char nCmd;
	953	unsigned short nnCount = 0;
	954	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	955	// Values[0] = m_DataBuf[0];
	956	return res;
	957
	958	return KL_OK;
	959	}
	960
	961	int KLink1::GetInfo(UCHAR nDst, USHORT * nReadBytes, USHORT * Values)
	962	{
	963	m_Dst = nDst;
	964	m_resultStr.Empty();
	965	UCHAR nExpSeq = GetNextSeq();
	966	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetInfo, 0, 0, 0, Values);
	967	CString s1;
	968	for (int i = 0; i < len1; i++) {
	969	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	970	}
	971	//m_resultStr = s1;
	972	SendPacket(m_Packetbuf, len1);
	973	int numToRead = sizeof(stKLRplyPktHdr) + 32;
	974	int len2 = RecvPacket(m_RecvBuf, numToRead);
	975	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	976	if (len2 == 0) return KL_ERR;
	977	unsigned char nCmd;
	978	unsigned short nnCount = 0;
	979	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	980	// Values[0] = m_DataBuf[0];
	981	*nReadBytes = nnCount;
	982	return res;
	983
	984	return KL_OK;
	985	}
	986
	987	int KLink1::GetSN(UCHAR nDst, USHORT * nReadBytes, USHORT * Values)
	988	{
	989	m_Dst = nDst;
	990	m_resultStr.Empty();
	991	UCHAR nExpSeq = GetNextSeq();
	992	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetSN, 0, 0, 4, Values);
	993	CString s1;
	994	for (int i = 0; i < len1; i++) {
	995	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	996	}
	997	m_resultStr = s1;
	998	SendPacket(m_Packetbuf, len1);
	999	int ByteCount = 4;
	1000	int numToRead = sizeof(stKLRplyPktHdr) + ByteCount;
	1001	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1002	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1003	if (len2 == 0) return KL_ERR;
	1004	unsigned char nCmd;
	1005	unsigned short nnCount = 0;
	1006	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	1007	// Values[0] = m_DataBuf[0];
	1008	*nReadBytes = nnCount;
	1009	return res;
	1010
	1011	return KL_OK;
	1012	return 0;
	1013	}
	1014	int KLink1::GetUID(UCHAR nDst, USHORT * nReadBytes, USHORT * Values)
	1015	{
	1016	m_Dst = nDst;
	1017	m_resultStr.Empty();
	1018	UCHAR nExpSeq = GetNextSeq();
	1019	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetUid, 0, 0, 12, Values);
	1020	CString s1;
	1021	for (int i = 0; i < len1; i++) {
	1022	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	1023	}
	1024	m_resultStr = s1;
	1025	SendPacket(m_Packetbuf, len1);
	1026
	1027	int numToRead = sizeof(stKLRplyPktHdr) + 12;
	1028	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1029	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1030	if (len2 == 0) return KL_ERR;
	1031	unsigned char nCmd;
	1032	unsigned short nnCount = 0;
	1033	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	1034	// Values[0] = m_DataBuf[0];
	1035	*nReadBytes = nnCount;
	1036	return res;
	1037
	1038	return KL_OK;
	1039	return 0;
	1040	}
	1041
	1042	int KLink1::ReadFactoryData(UCHAR nDst, USHORT nStartAddr, UCHAR nByteCount, USHORT * nReadBytes, USHORT * Values)
	1043	{
	1044	m_Dst = nDst;
	1045	m_resultStr.Empty();
	1046	UCHAR nExpSeq = GetNextSeq();
	1047	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetFactoryData, 0, nStartAddr, nByteCount, Values);
	1048	CString s1;
	1049	for (int i = 0; i < len1; i++) {
	1050	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	1051	}
	1052	m_resultStr = s1;
	1053	SendPacket(m_Packetbuf, len1);
	1054	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1055	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1056	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1057	if (len2 == 0) return KL_ERR;
	1058	unsigned char nCmd;
	1059	unsigned short nnCount = 0;
	1060	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	1061	// Values[0] = m_DataBuf[0];
	1062	*nReadBytes = nnCount;
	1063	return res;
	1064	return KL_OK;
	1065	}
	1066	int KLink1::WriteFactoryData(UCHAR nDst, USHORT nStartAddr, UCHAR nByteCount, USHORT * Values)
	1067	{
	1068
	1069	m_Dst = nDst;
	1070	m_resultStr.Empty();
	1071	UCHAR nExpSeq = GetNextSeq();
	1072	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteFactoryData, 0, nStartAddr, nByteCount, Values);
	1073	SendPacket(m_Packetbuf, len1);
	1074	int nReadBytes = 0;
	1075	int numToRead = sizeof(stKLRplyPktHdr) + nReadBytes;
	1076	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1077	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1078	if (len2 == 0) return KL_ERR;
	1079	unsigned char nCmd;
	1080	unsigned short nnCount = 0;
	1081	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1082	// Values[0] = m_DataBuf[0];
	1083	return res;
	1084
	1085	return KL_OK;
	1086	}
	1087
	1088
	1089	int KLink1::ReadSysCfgData(UCHAR nDst, USHORT nStartAddr, UCHAR nByteCount, USHORT * nReadBytes, USHORT * Values)
	1090	{
	1091	m_Dst = nDst;
	1092	m_resultStr.Empty();
	1093	UCHAR nExpSeq = GetNextSeq();
	1094	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadSysCfg, 0, nStartAddr, nByteCount, Values);
	1095	CString s1;
	1096	for (int i = 0; i < len1; i++) {
	1097	s1.AppendFormat(_T("%02X "), m_Packetbuf[i]);
	1098	}
	1099	m_resultStr = s1;
	1100	SendPacket(m_Packetbuf, len1);
	1101	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1102	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1103	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1104	if (len2 == 0) return KL_ERR;
	1105	unsigned char nCmd;
	1106	unsigned short nnCount = 0;
	1107	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, Values);
	1108	// Values[0] = m_DataBuf[0];
	1109	*nReadBytes = nnCount;
	1110	return res;
	1111	return KL_OK;
	1112	}
	1113	int KLink1::WriteSysCfgData(UCHAR nDst, USHORT nStartAddr, UCHAR nByteCount, USHORT * Values)
	1114	{
	1115
	1116	m_Dst = nDst;
	1117	m_resultStr.Empty();
	1118	UCHAR nExpSeq = GetNextSeq();
	1119	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteSysCfg, 0, nStartAddr, nByteCount, Values);
	1120	SendPacket(m_Packetbuf, len1);
	1121	int nReadBytes = 0;
	1122	int numToRead = sizeof(stKLRplyPktHdr) + nReadBytes;
	1123	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1124	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1125	if (len2 == 0) return KL_ERR;
	1126	unsigned char nCmd;
	1127	unsigned short nnCount = 0;
	1128	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1129	// Values[0] = m_DataBuf[0];
	1130	return res;
	1131
	1132	return KL_OK;
	1133	}
	1134	int KLink1::GetEventLogCount(UCHAR nDst, int * nCount)
	1135	{
	1136	m_Dst = nDst;
	1137	m_resultStr.Empty();
	1138	UCHAR nExpSeq = GetNextSeq();
	1139	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetEventLogCount, 0);
	1140	SendPacket(m_Packetbuf, len1);
	1141	int len2 = RecvPacket(m_RecvBuf, 64);
	1142	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	1143	if (len2 == 0) return KL_ERR;
	1144	unsigned char nCmd;
	1145	unsigned short nnCount = 0;
	1146	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1147	nCount[0] = (int )m_DataBuf;
	1148	return res;
	1149
	1150	return KL_OK;
	1151	}
	1152
	1153	int KLink1::GetEventLog(UCHAR nDst, int nStartIndex, int nCount, stEventLog * theEventLogs)
	1154	{
	1155	m_Dst = nDst;
	1156	m_resultStr.Empty();
	1157	UCHAR nExpSeq = GetNextSeq();
	1158	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetEventLog, 0, nStartIndex, nCount, 0);
	1159	SendPacket(m_Packetbuf, len1);
	1160	int len2 = RecvPacket(m_RecvBuf, 64);
	1161	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	1162	if (len2 == 0) return KL_ERR;
	1163	unsigned char nCmd;
	1164	unsigned short nnCount = 0;
	1165	int res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1166
	1167	memcpy(theEventLogs, m_DataBuf, nCount * sizeof(stEventLog));
	1168
	1169	return res;
	1170
	1171	return KL_OK;
	1172	}
	1173
	1174	int KLink1::GetDateTime32(UCHAR nDst, UINT * pValue)
	1175	{
	1176	int res = KL_OK;
	1177	unsigned short nCount;
	1178	res = ReadDataByte(nDst, KLDataTypeSDT, 36, 4, &nCount, (UCHAR *)pValue);
	1179	return res;
	1180
	1181	}
	1182
	1183	int KLink1::SetDateTime32(UCHAR nDst, UINT Value)
	1184	{
	1185	int res = KL_OK;
	1186	res = WriteDataByte(nDst, KLDataTypeSDT, 36, 4, (UCHAR *)&Value);
	1187	return res;
	1188	}
	1189
	1190	int KLink1::GetMode(UCHAR nDst, UCHAR nType)
	1191	{
	1192	int res = KL_OK;
	1193	// res = ReadDataByte(nDst, 4, KLDataTypeSDT, 36, (UCHAR *)pValue);
	1194	m_Dst = nDst;
	1195	UCHAR nExpSeq = GetNextSeq();
	1196	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdGetMode, nType);
	1197	SendPacket(m_Packetbuf, len1);
	1198	int len2 = RecvPacket(m_RecvBuf, 64);
	1199	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	1200	if (len2 == 0) return KL_ERR;
	1201	unsigned char nCmd;
	1202	unsigned short nnCount = 0;
	1203	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1204	return res;
	1205
	1206	}
	1207
	1208
	1209	int KLink1::ChangeMode(UCHAR nDst, UCHAR nType)
	1210	{
	1211	int res = KL_OK;
	1212	// res = WriteDataByte(nDst, 4, KLDataTypeSDT, 36, (UCHAR *)&Value);
	1213	m_Dst = nDst;
	1214	UCHAR nExpSeq = GetNextSeq();
	1215	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdChgMode, nType);
	1216	SendPacket(m_Packetbuf, len1);
	1217	int len2 = RecvPacket(m_RecvBuf, 64);
	1218	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, 64); }
	1219	if (len2 == 0) return KL_ERR;
	1220	unsigned char nCmd;
	1221	unsigned short nnCount = 0;
	1222	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1223	return res;
	1224
	1225	}
	1226
	1227	int KLink1::BlinkLED(UCHAR nDst, UCHAR nSecond)
	1228	{
	1229	int res = KL_OK;
	1230	// res = WriteDataByte(nDst, 4, KLDataTypeSDT, 36, (UCHAR *)&Value);
	1231	m_Dst = nDst;
	1232	UCHAR nExpSeq = GetNextSeq();
	1233	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdBlinkLED, nSecond);
	1234	SendPacket(m_Packetbuf, len1);
	1235	int nByteCount = 0;
	1236	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1237
	1238	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1239	if (len2 == 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1240	if (len2 == 0) return KL_ERR;
	1241	unsigned char nCmd;
	1242	unsigned short nnCount = 0;
	1243	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1244	return res;
	1245
	1246	}
	1247
	1248	int KLink1::ReadProgram(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	1249	{
	1250	int res = KL_OK;
	1251	m_Dst = nDst;
	1252	UCHAR nExpSeq = GetNextSeq();
	1253	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadProgram, nType, nWordAddr, nWordCount);
	1254	SendPacket(m_Packetbuf, len1);
	1255	int nByteCount = nWordCount;
	1256	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1257	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1258	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1259	if (len2 <= 0) return KL_ERR;
	1260	unsigned char nCmd;
	1261	unsigned short nnCount = 0;
	1262	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1263	unsigned char * values2 = (unsigned char *)Values;
	1264	for (int i = 0; i < nnCount; i++) values2[i] = m_DataBuf[i];
	1265	return res;
	1266
	1267	}
	1268
	1269	int KLink1::StartProgram(UCHAR nDst, UCHAR nType)
	1270	{
	1271	int res = KL_OK;
	1272	m_Dst = nDst;
	1273	UCHAR nExpSeq = GetNextSeq();
	1274	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdStartProgram, nType);
	1275	SendPacket(m_Packetbuf, len1);
	1276	int len2 = RecvPacket(m_RecvBuf, 6);
	1277	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6); }
	1278	if (len2 <= 0) return KL_ERR;
	1279	unsigned char nCmd;
	1280	unsigned short nnCount = 0;
	1281	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1282	return res;
	1283
	1284	}
	1285
	1286	int KLink1::WriteProgram(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	1287	{
	1288	int res = KL_OK;
	1289	m_Dst = nDst;
	1290	UCHAR nExpSeq = GetNextSeq();
	1291	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdWriteProgram, nType, nWordAddr, nWordCount, Values);
	1292
	1293	SendPacket(m_Packetbuf, len1);
	1294	int len2 = RecvPacket(m_RecvBuf, 6);
	1295	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6, 30); }
	1296	if (len2 <= 0) return KL_ERR;
	1297	unsigned char nCmd;
	1298	unsigned short nnCount = 0;
	1299	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1300	// Values[0] = m_DataBuf[0];
	1301	return res;
	1302
	1303	}
	1304
	1305	int KLink1::FinishProgram(UCHAR nDst, UCHAR nType, USHORT nStepSize)
	1306	{
	1307	int res = KL_OK;
	1308
	1309	m_Dst = nDst;
	1310	UCHAR nExpSeq = GetNextSeq();
	1311	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdFinishProgram, nType, nStepSize);
	1312	SendPacket(m_Packetbuf, len1);
	1313	int len2 = RecvPacket(m_RecvBuf, 6);
	1314	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, 6, 30); }
	1315	if (len2 <= 0) return KL_ERR;
	1316	unsigned char nCmd;
	1317	unsigned short nnCount = 0;
	1318	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1319	return res;
	1320	}
	1321
	1322
	1323	int KLink1::ReadRunStat(UCHAR nDst, UCHAR nType, USHORT nWordAddr, UCHAR nWordCount, USHORT * Values)
	1324	{
	1325	int res = KL_OK;
	1326	m_Dst = nDst;
	1327	UCHAR nExpSeq = GetNextSeq();
	1328	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdReadRunStat, nType, nWordAddr, nWordCount);
	1329	SendPacket(m_Packetbuf, len1);
	1330	int nByteCount = nWordCount;
	1331	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1332	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1333	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1334	if (len2 <= 0) return KL_ERR;
	1335	unsigned char nCmd;
	1336	unsigned short nnCount = 0;
	1337	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1338	unsigned char * values2 = (unsigned char *)Values;
	1339	for (int i = 0; i < nnCount; i++) values2[i] = m_DataBuf[i];
	1340	return res;
	1341
	1342	}
	1343
	1344	int KLink1::ClearStatistics(UCHAR nDst, UCHAR nType)
	1345	{
	1346	int res = KL_OK;
	1347	m_Dst = nDst;
	1348	UCHAR nExpSeq = GetNextSeq();
	1349	int len1 = MakeReqPacketEx(m_Packetbuf, nDst, m_Stat1.StatByte, KLCmdClearRunStat, nType);
	1350	SendPacket(m_Packetbuf, len1);
	1351	int nByteCount = 0;
	1352	int numToRead = sizeof(stKLRplyPktHdr) + nByteCount;
	1353	int len2 = RecvPacket(m_RecvBuf, numToRead);
	1354	if (len2 <= 0) { len2 = RecvPacket(m_RecvBuf, numToRead); }
	1355	if (len2 <= 0) return KL_ERR;
	1356	unsigned char nCmd;
	1357	unsigned short nnCount = 0;
	1358	res = ParseRplyPacket(m_RecvBuf, len2, &nCmd, &m_DstStat.StatByte, &nnCount, m_DataBuf);
	1359	return res;
	1360
	1361	}