MultiTerminal1 - Gitblit

QuakeGod

2022-07-22 dd67df95a7303aee3bed65ffa935465f20ee8b32

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