MultiTerminal1 - Gitblit

QuakeGod

2023-09-12 78e91efc666606328e3fc63fbd54eb2da4442799

提交 \| 用户 \| age
4b03ae	1
418cb3	2	// MultiTerminal2Doc.cpp: CMTerm1Doc 类的实现
4b03ae	3	//
Q	4
	5	#include "pch.h"
	6	#include "framework.h"
	7	// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
	8	// ATL 项目中进行定义，并允许与该项目共享文档代码。
	9	#ifndef SHARED_HANDLERS
0ed438	10	#include "MTerm1.h"
4b03ae	11	#endif
Q	12
0ed438	13	#include "MTerm1Doc.h"
4b03ae	14
418cb3	15	#include "MTerm1View.h"
Q	16	#include "MTerm1LdsView.h"
	17	#include "MTerm1BldView.h"
	18	#include "MTerm1BnlView.h"
	19
	20	#include "MTerm1CoilView.h"
	21	#include "MTerm1DataView.h"
	22
	23	#include "MTerm1CtrlView.h"
	24	#include "MTerm1TestView.h"
	25	#include "MTerm1ProgTxt.h"
	26	#include "MTerm1CommDevView.h"
4b03ae	27	#include <propkey.h>
418cb3	28
Q	29	#include "DialogCommSet1.h"
	30	#include "DialogStatusShow.h"
	31	#include "DialogSysRegSet.h"
	32	#include "DialogFactCfg.h"
	33	#include "DialogDateTime.h"
	34	#include "DialogEventLog.h"
	35	//#include "HvSerialPort.h"
	36	#include <functional>
4b03ae	37
Q	38	#ifdef _DEBUG
	39	#define new DEBUG_NEW
	40	#endif
	41
0ed438	42	// CMTerm1Doc
418cb3	43	CMTerm1Doc::stTypeNameDef CMTerm1Doc::CoilTypeNameDef[] =
Q	44	{
	45	{KLCoilTypeX,"X"},
	46	{KLCoilTypeY,"Y"},
	47	{KLCoilTypeR,"R"},
	48	{KLCoilTypeLX,"LX"},
	49	{KLCoilTypeLY,"LY"},
	50	{KLCoilTypeLR,"LR"},
	51	{KLCoilTypeSR,"SR"},
	52	{KLCoilTypeC,"C"},
	53	{KLCoilTypeT,"T"},
	54	};
	55	int CMTerm1Doc::nCoilTypeDefCount = sizeof(CMTerm1Doc::CoilTypeNameDef) / sizeof(stTypeNameDef);
	56
	57	CMTerm1Doc::stTypeNameDef CMTerm1Doc::DataTypeNameDef[] =
	58	{
	59	{KLDataTypeDEC,"K"},
	60	{KLDataTypeHEX,"H"},
	61	{KLDataTypeWX,"WX"},
	62	{KLDataTypeWY,"WY"},
	63	{KLDataTypeWR,"WR"},
	64	{KLDataTypeDT,"DT"},
	65	{KLDataTypeWLX,"WLX"},
	66	{KLDataTypeWLY,"WLY"},
	67	{KLDataTypeSDT,"SDT"},
	68	{KLDataTypeWSR,"WSR"},
	69	{KLDataTypeEV,"EV"},
	70	{KLDataTypeSV,"SV"},
	71	{KLDataTypeLD,"LD"},
	72	};
	73	int CMTerm1Doc::nDataTypeDefCount = sizeof(CMTerm1Doc::DataTypeNameDef) / sizeof(stTypeNameDef);
	74
	75	CMTerm1Doc::stOpDef CMTerm1Doc::OpDef[] =
	76	{
	77	{OP_NOP,"NOP",0},
	78	{OP_ST,"ST",1,KLParamCoil},
	79	{OP_ST_,"ST/",1,KLParamCoil},
	80	{OP_AN,"AN",1,KLParamCoil},
	81	{OP_AN_,"AN/",1,KLParamCoil},
	82	{OP_OR,"OR",1,KLParamCoil},
	83	{OP_OR_,"OR/",1,KLParamCoil},
	84	{OP_NOT,"NOT"},
	85	{OP_ANS,"ANS"},
	86	{OP_ORS,"ORS"}
	87	,
	88	{OP_PSHS,"PSHS"},
	89	{OP_RDS,"RDS"},
	90	{OP_POPS,"POPS"},
	91	{OP_OUT,"OUT",1,KLParamCoil},
	92	{OP_SET,"SET",1,KLParamCoil},
	93	{OP_RESET,"RESET",1,KLParamCoil},
	94	{OP_DF,"DF"},
	95	{OP_DF_,"DF/"},
	96	{OP_ST_EQ,"ST=",2,KLParamWord,"="},
	97	{OP_ST_LT,"ST<",2,KLParamWord,"<"},
	98	{OP_ST_GT,"ST>",2,KLParamWord,">"},
	99	{OP_ST_LE,"ST<=",2,KLParamWord,"<="},
	100	{OP_ST_GE,"ST>=",2,KLParamWord,">="},
	101	{OP_ST_NE,"ST<>",2,KLParamWord,"<>"},
	102	{OP_AN_EQ,"AN=",2,KLParamWord,"="},
	103	{OP_AN_LT,"AN<",2,KLParamWord,"<"},
	104	{OP_AN_GT,"AN>",2,KLParamWord,">"},
	105	{OP_AN_LE,"AN<=",2,KLParamWord,"<="},
	106	{OP_AN_GE,"AN>=",2,KLParamWord,">="},
	107	{OP_AN_NE,"AN<>",2,KLParamWord,"<>"},
	108	{OP_OR_EQ,"OR=",2,KLParamWord,"="},
	109	{OP_OR_LT,"OR<",2,KLParamWord,"<"},
	110	{OP_OR_GT,"OR>",2,KLParamWord,">"},
	111	{OP_OR_LE,"OR<=",2,KLParamWord,"<="},
	112	{OP_OR_GE,"OR>=",2,KLParamWord,">="},
	113	{OP_OR_NE,"OR<>",2,KLParamWord,"<>"},
	114
	115	{OP_TML,"TML",2,KLParamWord,"TML"},
	116	{OP_TMR,"TMR",2,KLParamWord,"TMR"},
	117	{OP_TMX,"TMX",2,KLParamWord,"TMX"},
	118	{OP_TMY,"TMY",2,KLParamWord,"TMY"},
	119
	120	{OP_MV,"MV",2,KLParamWord,"MV"},
	121	{OP_INC,"INC",1,KLParamWord,"+1"},
	122	{OP_ADD2,"ADD2",2,KLParamWord,"+"},
	123	{OP_ADD3,"ADD3",3,KLParamWord,"+"},
	124	{OP_DEC,"DEC",1,KLParamWord,"-1"},
	125	{OP_SUB2,"SUB2",2,KLParamWord,"-"},
	126	{OP_SUB3,"SUB3",3,KLParamWord,"-"},
	127	{OP_MUL,"MUL",3,KLParamWord,"X"},
	128	{OP_DIV,"DIV",3,KLParamWord,"/"},
	129
	130	};
	131	int CMTerm1Doc::nOpDefCount = sizeof(CMTerm1Doc::OpDef) / sizeof(stOpDef);
4b03ae	132
0ed438	133	IMPLEMENT_DYNCREATE(CMTerm1Doc, CDocument)
4b03ae	134
0ed438	135	BEGIN_MESSAGE_MAP(CMTerm1Doc, CDocument)
418cb3	136	ON_COMMAND(ID_UPLOAD_FROM_PLC, &CMTerm1Doc::OnUploadFromPlc)
Q	137	ON_COMMAND(ID_ONLINE, &CMTerm1Doc::OnOnline)
	138	ON_UPDATE_COMMAND_UI(ID_ONLINE, &CMTerm1Doc::OnUpdateOnline)
	139	ON_COMMAND(ID_OFFLINE, &CMTerm1Doc::OnOffline)
	140	ON_UPDATE_COMMAND_UI(ID_OFFLINE, &CMTerm1Doc::OnUpdateOffline)
	141	ON_COMMAND(ID_PLC_RUN, &CMTerm1Doc::OnPlcRun)
	142	ON_UPDATE_COMMAND_UI(ID_PLC_RUN, &CMTerm1Doc::OnUpdatePlcRun)
	143	ON_COMMAND(ID_DOWNLOAD_TO_PLC, &CMTerm1Doc::OnDownloadToPlc)
	144	ON_UPDATE_COMMAND_UI(ID_DOWNLOAD_TO_PLC, &CMTerm1Doc::OnUpdateDownloadToPlc)
	145
	146	ON_COMMAND(ID_COMUNICATION_SET, &CMTerm1Doc::OnComunicationSet)
	147	ON_COMMAND(ID_PLC_SYSREG_SET, &CMTerm1Doc::OnPlcSysregSet)
	148
	149	ON_COMMAND(ID_MENU_VIEW_LDS, &CMTerm1Doc::OnMenuViewLds)
	150	ON_COMMAND(ID_MENU_VIEW_BLD, &CMTerm1Doc::OnMenuViewBld)
	151	ON_COMMAND(ID_MENU_VIEW_BNL, &CMTerm1Doc::OnMenuViewBnl)
	152	ON_COMMAND(ID_MENU_SHOW_CONSOLE, &CMTerm1Doc::OnMenuShowConsole)
	153
	154	ON_COMMAND(ID_MENU_COMM_TEST, &CMTerm1Doc::OnMenuCommTest)
	155
	156
	157	ON_COMMAND(ID_SIMULATE, &CMTerm1Doc::OnSimulate)
	158	ON_UPDATE_COMMAND_UI(ID_SIMULATE, &CMTerm1Doc::OnUpdateSimulate)
	159	ON_COMMAND(ID_MENU_STATUS_SHOW, &CMTerm1Doc::OnMenuStatusShow)
	160	ON_COMMAND(ID_MENU_FACT_CFG, &CMTerm1Doc::OnMenuFactCfg)
	161	ON_COMMAND(ID_MENU_DATETIME_SET, &CMTerm1Doc::OnMenuDatetimeSet)
	162	ON_COMMAND(ID_MENU_EVENT_LOG, &CMTerm1Doc::OnMenuEventLog)
4b03ae	163	END_MESSAGE_MAP()
Q	164
	165
0ed438	166	// CMTerm1Doc 构造/析构
4b03ae	167
0ed438	168	CMTerm1Doc::CMTerm1Doc() noexcept
4b03ae	169	{
Q	170	// TODO: 在此添加一次性构造代码
	171
418cb3	172	KLink1::stCallBackFuncs callbackfuncs;
Q	173	// callbackfuncs.OpenFunc = std::bind(&HvSerialPort::Open, &myHvSerialPort1);
	174	// callbackfuncs.CloseFunc = std::bind(&HvSerialPort::Close, &myHvSerialPort1);
	175	// callbackfuncs.ClearBufFunc = std::bind(&HvSerialPort::ClearBuf, &myHvSerialPort1);
	176
	177	// callbackfuncs.SendPkgFunc = std::bind(&HvSerialPort::Send, &myHvSerialPort1, std::placeholders::_1, std::placeholders::_2);
	178	// callbackfuncs.RecvPkgFunc = std::bind(&HvSerialPort::Recv, &myHvSerialPort1, std::placeholders::_1, std::placeholders::_2);
	179
	180	// MyKLink1.SetCallBackFuncs(&callbackfuncs);
	181
	182	// StartTime = myHvSerialPort1.GetTimemS();
4b03ae	183	}
Q	184
0ed438	185	CMTerm1Doc::~CMTerm1Doc()
4b03ae	186	{
Q	187	}
418cb3	188	/*
Q	189	int CMTerm1Doc::SendPacket(void * pBuf, int Len)
	190	{
	191	return myHvSerialPort1.Send((char *)pBuf, Len);
	192	}
	193	int CMTerm1Doc::RecvPacket(void * pBuf, int Len)
	194	{
	195	int j = 0;
	196	j = myHvSerialPort1.Recv((char *)pBuf, Len);
	197	if (j <= 0)
	198	{
	199	CString s1;
	200	s1.Format(_T("Read %d R=%d %s"), Len, j, myHvSerialPort1.m_strResult);
	201	SysLog(s1);
	202	}
	203	return j;
	204	}
	205	*/
4b03ae	206
0ed438	207	BOOL CMTerm1Doc::OnNewDocument()
4b03ae	208	{
Q	209	if (!CDocument::OnNewDocument())
	210	return FALSE;
	211
	212	// TODO: 在此添加重新初始化代码
	213	// (SDI 文档将重用该文档)
418cb3	214	// LoadFromFile(_T("0prog1.txt"));
Q	215	return TRUE;
	216
	217	}
	218	BOOL CMTerm1Doc::OnOpenDocument(LPCTSTR lpszPathName)
	219	{
	220	// if (!CDocument::OnOpenDocument(lpszPathName))
	221	// return FALSE;
0ed438	222
418cb3	223	// TODO: 在此添加您专用的创建代码
Q	224	CString s1;
	225	s1.Format(_T("OnOpenDocument %s"), lpszPathName);
	226	SysLog(s1);
	227	LoadFromFile(lpszPathName);
4b03ae	228	return TRUE;
Q	229	}
	230
	231
418cb3	232	BOOL CMTerm1Doc::OnSaveDocument(LPCTSTR lpszPathName)
Q	233	{
	234	// TODO: 在此添加专用代码和/或调用基类
	235	CString s1;
	236	s1.Format(_T("OnSaveDocument %s"), lpszPathName);
	237	SysLog(s1);
	238	SaveToFile(lpszPathName);
	239	return TRUE;
	240	// return CDocument::OnSaveDocument(lpszPathName);
	241	}
4b03ae	242
418cb3	243
Q	244	void CMTerm1Doc::OnCloseDocument()
	245	{
	246	// TODO: 在此添加专用代码和/或调用基类
	247	// CString s1;
	248	// s1.Format(_T("OnCloseDocument %s"));
	249	// SysLog(s1);
	250	CDocument::OnCloseDocument();
	251	}
4b03ae	252
0ed438	253	// CMTerm1Doc 序列化
4b03ae	254
0ed438	255	void CMTerm1Doc::Serialize(CArchive& ar)
4b03ae	256	{
418cb3	257	CString s1;
4b03ae	258	if (ar.IsStoring())
Q	259	{
	260	// TODO: 在此添加存储代码
418cb3	261	ar.GetFile();
Q	262	s1.Format(_T("Serialize Saving"));
	263	SysLog(s1);
4b03ae	264	}
Q	265	else
	266	{
	267	// TODO: 在此添加加载代码
418cb3	268	s1.Format(_T("Serialize Loading"));
Q	269	SysLog(s1);
4b03ae	270	}
Q	271	}
	272
	273	#ifdef SHARED_HANDLERS
	274
	275	// 缩略图的支持
0ed438	276	void CMTerm1Doc::OnDrawThumbnail(CDC& dc, LPRECT lprcBounds)
4b03ae	277	{
Q	278	// 修改此代码以绘制文档数据
	279	dc.FillSolidRect(lprcBounds, RGB(255, 255, 255));
	280
	281	CString strText = _T("TODO: implement thumbnail drawing here");
	282	LOGFONT lf;
	283
	284	CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT));
	285	pDefaultGUIFont->GetLogFont(&lf);
	286	lf.lfHeight = 36;
	287
	288	CFont fontDraw;
	289	fontDraw.CreateFontIndirect(&lf);
	290
	291	CFont* pOldFont = dc.SelectObject(&fontDraw);
	292	dc.DrawText(strText, lprcBounds, DT_CENTER \| DT_WORDBREAK);
	293	dc.SelectObject(pOldFont);
	294	}
	295
	296	// 搜索处理程序的支持
0ed438	297	void CMTerm1Doc::InitializeSearchContent()
4b03ae	298	{
Q	299	CString strSearchContent;
	300	// 从文档数据设置搜索内容。
	301	// 内容部分应由“;”分隔
	302
	303	// 例如: strSearchContent = _T("point;rectangle;circle;ole object;")；
	304	SetSearchContent(strSearchContent);
	305	}
	306
0ed438	307	void CMTerm1Doc::SetSearchContent(const CString& value)
4b03ae	308	{
Q	309	if (value.IsEmpty())
	310	{
	311	RemoveChunk(PKEY_Search_Contents.fmtid, PKEY_Search_Contents.pid);
	312	}
	313	else
	314	{
	315	CMFCFilterChunkValueImpl *pChunk = nullptr;
	316	ATLTRY(pChunk = new CMFCFilterChunkValueImpl);
	317	if (pChunk != nullptr)
	318	{
	319	pChunk->SetTextValue(PKEY_Search_Contents, value, CHUNK_TEXT);
	320	SetChunkValue(pChunk);
	321	}
	322	}
	323	}
	324
	325	#endif // SHARED_HANDLERS
	326
0ed438	327	// CMTerm1Doc 诊断
4b03ae	328
Q	329	#ifdef _DEBUG
0ed438	330	void CMTerm1Doc::AssertValid() const
4b03ae	331	{
Q	332	CDocument::AssertValid();
	333	}
	334
0ed438	335	void CMTerm1Doc::Dump(CDumpContext& dc) const
4b03ae	336	{
Q	337	CDocument::Dump(dc);
	338	}
	339	#endif //_DEBUG
	340
	341
0ed438	342	// CMTerm1Doc 命令
418cb3	343	int CMTerm1Doc::LoadFromFile(CString sFilePathName)
Q	344	{
	345	// TODO: 在此处添加实现代码.
	346	CFile file1;
	347	CFileException e;
	348	bool r = file1.Open(sFilePathName, CFile::modeRead, &e);
	349	if (r)
	350	{
	351	int l = (int)file1.GetLength();
	352	CStringA s1A;
	353	file1.Read(s1A.GetBuffer(l + 2048), l);
	354	file1.Close();
	355	s1A.ReleaseBuffer(l);
	356	TransFileToProg(s1A);
	357	UpdateAllViews(NULL);
	358	}
	359	return 0;
	360	}
	361
	362
	363	int CMTerm1Doc::SaveToFile(CString sFilePathName)
	364	{
	365	// TODO: 在此处添加实现代码.
	366	CString s1;
	367	CFile file1;
	368	CFileException e;
	369	bool r = file1.Open(sFilePathName, CFile::modeReadWrite, &e);
	370	if (r)
	371	{
	372
	373	CStringA s1A;
	374	CStringA sSectionNameA;
	375
	376	//写入系统配置
	377	GetSectionTxt(SectionSysCfg, sSectionNameA); //
	378	s1A = "[" + sSectionNameA + "]\r\n";
	379	file1.Write(s1A, s1A.GetLength());
	380
	381	//写入程序
	382	GetSectionTxt(SectionProg, sSectionNameA); //
	383	s1A = "[" + sSectionNameA + "]\r\n";
	384	file1.Write(s1A, s1A.GetLength());
	385
	386	TransToTxt(s1A);
	387	file1.Write(s1A, s1A.GetLength());
	388
	389	//写入注释
	390	GetSectionTxt(SectionAnno, sSectionNameA); //
	391	s1A = "[" + sSectionNameA + "]\r\n";
	392	file1.Write(s1A, s1A.GetLength());
	393	for (int i = 0; i < nCoilAnnoCount; i++)
	394	{
	395	if (mCoilAnnos[i].sAnno.IsEmpty()) { continue; }
	396	s1 = mCoilAnnos[i].sCoilName + _T("\t") + mCoilAnnos[i].sAnno+ _T("\r\n");
	397	s1A = s1;
	398	file1.Write(s1A, s1A.GetLength());
	399	}
	400	//写入触点监控列表
	401	GetSectionTxt(SectionCoilList, sSectionNameA); //
	402	s1A = "[" + sSectionNameA + "]\r\n";
	403	file1.Write(s1A, s1A.GetLength());
	404	//写入数据监控列表
	405	GetSectionTxt(SectionDataList, sSectionNameA); //
	406	s1A = "[" + sSectionNameA + "]\r\n";
	407	file1.Write(s1A, s1A.GetLength());
	408
	409	file1.Close();
	410	}
	411	return 0;
	412	}
	413
	414	int CMTerm1Doc::TxtToSection(CStringA txt)
	415	{
	416	for (int i = 0; i < nSectionDefCount; i++) {
	417	if (SectionDef[i].SectionName == txt) {
	418	return SectionDef[i].nSectionType;
	419	}
	420	}
	421	return SectionNone;
	422	}
	423
	424	int CMTerm1Doc::GetSectionTxt(int nSectionType, CStringA & txt)
	425	{
	426	for (int i = 0; i < nSectionDefCount; i++) {
	427	if (SectionDef[i].nSectionType == nSectionType) {
	428	txt = SectionDef[i].SectionName;
	429	return true;
	430	}
	431	}
	432	return false;
	433	}
	434
	435	int CMTerm1Doc::GetSectionPos(int nSectionType, int * nSectionLine, int * nSectionLines)
	436	{
	437	for (int i = 0; i < nSectionCount; i++) {
	438	if (Sections[i].nSectionType == nSectionType) {
	439	*nSectionLine = Sections[i].nSectionLineNo;
	440	*nSectionLines = Sections[i].nLines;
	441	return true;
	442	}
	443	}
	444	return false;
	445	}
	446
	447	int CMTerm1Doc::TxtToOp(CStringA optxt, int* ParamCount, int* ParamType)
	448	{
	449	for (int i = 0; i < nOpDefCount; i++){
	450	if (OpDef[i].OpTxt == optxt) {
	451	*ParamCount = OpDef[i].nParamCount;
	452	*ParamType = OpDef[i].nParamType;
	453	return OpDef[i].nOpType1;
	454	}
	455	}
	456	return -1;
	457	}
	458	int CMTerm1Doc::OpToTxt(int nOp, CStringA & OpTxt)
	459	{
	460	for (int i = 0; i < nOpDefCount; i++){
	461	if (OpDef[i].nOpType1 == nOp) {
	462	OpTxt = OpDef[i].OpTxt;
	463	return true;
	464	}
	465	}
	466	return false;
	467	}
	468
	469	int CMTerm1Doc::OpToShowTxt(int nOp, CStringA & OpShowTxt)
	470	{
	471	for (int i = 0; i < nOpDefCount; i++) {
	472	if (OpDef[i].nOpType1 == nOp) {
	473	OpShowTxt = OpDef[i].ShowTxt;
	474	return true;
	475	}
	476	}
	477	return false;
	478	}
	479
	480	int CMTerm1Doc::TxtToCoilType(CStringA Typetxt, int* nCoilType, int* nCoilAddr)
	481	{
	482	Typetxt.MakeUpper();
	483	for (int i = 0; i < nCoilTypeDefCount; i++)
	484	{
	485	if (Typetxt.Find( CoilTypeNameDef[i].TypeTxt)==0) {
	486	*nCoilType = CoilTypeNameDef[i].nType;
	487	*nCoilAddr = atoi(Typetxt.Mid(CoilTypeNameDef[i].TypeTxt.GetLength()));
df0321	488	return true;
418cb3	489	return CoilTypeNameDef[i].nType;
Q	490	}
	491	}
	492	return false;;
	493	}
	494
	495	int CMTerm1Doc::CoilTypeToTxt(int nType, CStringA & typeTxt)
	496	{
	497	for (int i = 0; i < nCoilTypeDefCount; i++)
	498	{
	499	if (CoilTypeNameDef[i].nType == nType){
	500	typeTxt = CoilTypeNameDef[i].TypeTxt;
	501	return true;
	502	}
	503	}
	504	return false;
	505	}
	506
	507	int CMTerm1Doc::TxtToDataType(CStringA Typetxt, int * nDataType, int* nDataAddr)
	508	{
	509	Typetxt.MakeUpper();
	510	for (int i = 0; i < nDataTypeDefCount; i++)
	511	{
	512	if (Typetxt.Find(DataTypeNameDef[i].TypeTxt) == 0) {
	513	*nDataType = DataTypeNameDef[i].nType;
	514	*nDataAddr = atoi(Typetxt.Mid(DataTypeNameDef[i].TypeTxt.GetLength()));
	515	return true;
	516	}
	517	}
df0321	518	*nDataType = KLDataTypeDEC;
Q	519	*nDataAddr = atoi(Typetxt);
418cb3	520	return false;
Q	521	}
	522
	523
	524	int CMTerm1Doc::DataTypeToTxt(int nType, CStringA & typeTxt)
	525	{
	526	for (int i = 0; i < nDataTypeDefCount; i++)
	527	{
	528	if (DataTypeNameDef[i].nType == nType) {
	529	typeTxt = DataTypeNameDef[i].TypeTxt;
	530	return true;
	531	}
	532	}
	533	return false;
	534	}
	535
	536	int CMTerm1Doc::GetAnno(unsigned short nType, unsigned short nAddr, CString & sAnno)
	537	{
	538	// TODO: 在此处添加实现代码.
	539	// 二分法查找。
	540	// map.
	541	for (int i = 0; i < nCoilAnnoCount; i++) {
	542	if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
	543	sAnno = mCoilAnnos[i].sAnno;
	544	return 1;
	545	}
	546	}
	547	return 0;
	548	}
	549
	550	int CMTerm1Doc::SetAnno(CString sCoilName, CString sAnno)
	551	{
	552	// TODO: 在此处添加实现代码.
	553	// 二分法查找。
	554	// map.
	555	int bValid = 0;
	556	int nType = 0, nAddr = 0;
	557	CStringA s1A;
	558	s1A = sCoilName;
	559	if (TxtToCoilType(s1A, &nType, &nAddr) \|\| TxtToDataType(s1A, &nType, &nAddr)) {
	560	bValid = 1;
	561	}
	562	if (!bValid) return false;
	563
	564	for (int i = 0; i < nCoilAnnoCount; i++) {
	565	if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
	566	mCoilAnnos[i].sAnno = sAnno;
	567	return 1;
	568	}
	569	}
	570	mCoilAnnos[nCoilAnnoCount].nType = nType;
	571	mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
	572	mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
	573	mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
	574	nCoilAnnoCount++;
	575	return 2;
	576	}
	577
	578	int CMTerm1Doc::SetAnno(unsigned short nType, unsigned short nAddr, CString sCoilName, CString sAnno)
	579	{
	580	// TODO: 在此处添加实现代码.
	581	// 二分法? 查找。
	582	// map.
	583	for (int i = 0; i < nCoilAnnoCount; i++) {
	584	if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
	585	mCoilAnnos[i].sAnno = sAnno;
	586	return 1;
	587	}
	588	}
	589	mCoilAnnos[nCoilAnnoCount].nType = nType;
	590	mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
	591	mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
	592	mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
	593	nCoilAnnoCount++;
	594	return 0;
	595	}
	596	int CMTerm1Doc::TransLinesToProg(const CStringArray & txtLines, int StartLine , int ProgLines)
	597	{
	598	CString s1;
	599	int txtLineCount = (int)txtLines.GetSize();
	600
	601	//读取程序章节
	602	int nProgStartLine = 0;
	603	int nProgLines = 0;
	604
	605	nProgStartLine = StartLine;
	606	if (ProgLines == -1) nProgLines = txtLineCount;
	607	else nProgLines = ProgLines;
	608	int nProgPos = 0;
	609
	610	for (int i = nProgStartLine; i < nProgStartLine + nProgLines; i++)
	611	{
	612	CString sLine;
	613	sLine = txtLines.GetAt(i);
	614	sLine.Trim();
	615	sLine.Replace(_T("\t"), _T(" "));
	616	sLine.Replace(_T(" "), _T(" "));
	617	sLine.Replace(_T(" "), _T(" "));
	618	CStringArray strarr2;
	619	DivideStringToArray(sLine, _T(" "), strarr2);
	620	if (strarr2.GetSize() == 0) continue;
	621	CString sCmd;
	622	sCmd = strarr2.GetAt(0);
	623	sCmd.MakeUpper();
	624	CStringA s1A;
	625	s1A = sCmd;
	626	int nParamCount, nParamType;
	627	int nType, nAddr;
	628	int k = TxtToOp(s1A, &nParamCount, &nParamType);
	629	if (k >= 0)
	630	{
	631	Progs[nProgPos].nOpType1 = k;
	632	for (int j = 0; j < 3 && j < nParamCount && j < strarr2.GetSize() - 1; j++)
	633	{
	634	s1A = strarr2.GetAt(j + 1);
	635	s1A.MakeUpper();
	636	Progs[nProgPos].Params[j].sParamStr = s1A;
	637	if (nParamType == KLParamCoil) {
	638	TxtToCoilType(s1A, &nType, &nAddr);
	639	Progs[nProgPos].Params[j].nParamType = nType;
	640	Progs[nProgPos].Params[j].nParamAddr = nAddr;
	641	}
	642	else if (nParamType == KLParamWord) {
	643	TxtToDataType(s1A, &nType, &nAddr);
	644	Progs[nProgPos].Params[j].nParamType = nType;
	645	Progs[nProgPos].Params[j].nParamAddr = nAddr;
	646	}
	647	else {
	648
	649	}
	650	}
	651	Progs[nProgPos].nParamCount = (int)strarr2.GetSize() - 1;
	652	Progs[nProgPos].PairTo = 0;
	653	nProgPos++;
	654	}
	655	}
	656	m_nProgSteps = nProgPos;
	657	// 先扫描分开的程序段
	658	int stpos[100] = { 0 };
	659	int nSts = 0;
	660	int StackDeeps[512] = { 0 };
	661	int nCurStackDeep = 0;
	662	// 查找匹配指令和地址
	663	s1.Format(_T("DOC::Trans to Prog "));
	664	SysLog(s1);
	665	for (int i = 0; i < m_nProgSteps; i++) {
	666	int nOpType = Progs[i].nOpType1;
	667	int nParamCount = Progs[i].nParamCount;
	668	switch (Progs[i].nOpType1)
	669	{
	670	case OP_ST:
	671	case OP_ST_:
	672	case OP_ST_EQ:
	673	case OP_ST_NE:
	674	case OP_ST_LT:
	675	case OP_ST_GT:
	676	case OP_ST_LE:
	677	case OP_ST_GE:
	678
	679	nCurStackDeep++;
	680	s1.Format(_T("St Deep %d pos %d "), nCurStackDeep, i);
	681	//SysLog(s1);
	682	stpos[nSts] = i;
	683	nSts++;
	684	break;
	685	case OP_ANS:
	686	case OP_ORS:
	687	Progs[stpos[nSts - 1]].PairTo = i; // CMTerm1Doc::OP_ANS;
	688	s1.Format(_T("Pair deep %d %d -- %d"), nCurStackDeep, stpos[nSts - 1], i);
	689	//SysLog(s1);
	690	nCurStackDeep--;
	691	nSts--;
	692	break;
	693	case OP_PSHS:
	694	break;
	695	case OP_POPS:
	696	break;
	697	break;
	698	default:
	699	break;
	700	}
	701	StackDeeps[i] = nCurStackDeep;
	702	}
	703	s1.Format(_T("Remaining STs %d"), nSts);
	704	SysLog(s1);
	705	for (int i = 0; i < nSts; i++) {
	706	s1.Format(_T("[%d] %d "), i, stpos[i]);
	707	SysLog(s1);
	708	}
	709	s1.Format(_T("Pairs"));
	710	SysLog(s1);
	711	for (int i = 0; i < m_nProgSteps; i++) {
	712	int nPairTo = Progs[i].PairTo;
	713	if (nPairTo > 0) {
	714	s1.Format(_T("%d -- %d type:%d"), i, nPairTo, Progs[nPairTo].nOpType1);
	715	SysLog(s1);
	716	}
	717	}
	718	TransProgToBin();
	719	return 0;
	720	}
	721
	722	int CMTerm1Doc::TransTxtToProg(CStringA ProgTxtA)
	723	{
	724	CString s1;
	725	CString sProg;
	726	sProg = ProgTxtA;
	727	CStringArray txtLines;
	728	sProg.Replace(_T("\r\n"), _T("\n"));
	729	sProg.Replace(_T("\r"), _T("\n"));
	730
	731	DivideStringToArray(sProg, _T("\n"), txtLines);
	732
	733	TransLinesToProg(txtLines);
	734
	735	return 0;
	736	}
	737
	738	int CMTerm1Doc::ReadAnnoFromTxt(CStringA AnnoTxtA)
	739	{
	740	// 读取注释章节
	741	CString s1;
	742	CString sProg;
	743	sProg = AnnoTxtA;
	744	CStringArray txtLines;
	745	sProg.Replace(_T("\r\n"), _T("\n"));
	746	sProg.Replace(_T("\r"), _T("\n"));
	747
	748	DivideStringToArray(sProg, _T("\n"), txtLines);
	749
	750
	751	int txtLineCount = (int)txtLines.GetSize();
	752
	753	nCoilAnnoCount = 0;
	754	int nAnnoSectionLine = 0;
	755	int nAnnoStartLine = 0;
	756	int nAnnoLines = 0;
	757
	758	int bAnnoSection = GetSectionPos(SectionAnno, &nAnnoSectionLine, &nAnnoLines);
	759	if (bAnnoSection) { nAnnoStartLine = nAnnoSectionLine + 1; }
	760
	761	for (int i = nAnnoStartLine; i < nAnnoStartLine + nAnnoLines; i++)
	762	{
	763	CString sLine;
	764	sLine = txtLines.GetAt(i);
	765	sLine.Trim();
	766	int DivPos = sLine.Find(_T("\t"));
	767	if (DivPos < 1) continue;
	768
	769	CString sCoilName;
	770	sCoilName = sLine.Left(DivPos);
	771	sCoilName.MakeUpper();
	772	CString sAnno;
	773	sAnno = sLine.Mid(DivPos + 1);
	774
	775	// SetAnno(sCoilName, sAnno);
	776
	777	CStringA s1A;
	778	s1A = sCoilName;
	779	int nParamType, nAddr;
	780	TxtToCoilType(s1A, &nParamType, &nAddr) \|\| TxtToDataType(s1A, &nParamType, &nAddr);
	781
	782	mCoilAnnos[nCoilAnnoCount].nType = nParamType;
	783	mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
	784	mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
	785	mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
	786
	787	nCoilAnnoCount++;
	788	}
	789	return 0;
	790	}
	791
	792	int CMTerm1Doc::TransFileToProg(CStringA ProgTxtA)
	793	{
	794	CString s1;
	795	CString sProg;
	796	sProg = ProgTxtA;
	797	CStringArray txtLines;
	798	sProg.Replace(_T("\r\n"), _T("\n"));
	799	sProg.Replace(_T("\r"), _T("\n"));
	800
	801	DivideStringToArray(sProg, _T("\n"), txtLines);
	802
	803	nSectionCount = 0;
	804	int nCurSection = 0;
	805	int txtLineCount = (int)txtLines.GetSize();
	806	for (int i = 0; i < txtLineCount; i++)
	807	{
	808	CString sLine;
	809	sLine = txtLines.GetAt(i);
	810	sLine.Trim();
	811	int nRightBracket;
	812	if (sLine.Find(_T("[")) == 0 && (nRightBracket = sLine.Find(_T("]"))) > 1)
	813	{ //找到 [ ] 标志
	814	if (nSectionCount > 0) {
	815	Sections[nSectionCount - 1].nLines = i - Sections[nSectionCount - 1].nSectionLineNo - 1;
	816	s1.Format(_T("- Line %d Section %d Ends, %d Lines"), i, nSectionCount -1 ,Sections[nSectionCount - 1].nLines);
	817	SysLog(s1);
	818	}
	819	CString sSectionName;
	820	CStringA sSectionNameA;
	821	sSectionName = sLine.Mid(1, nRightBracket - 1);
	822	sSectionNameA = sSectionName;
	823	int theSection = TxtToSection(sSectionNameA);
	824	s1.Format(_T("+ Line %d Section %d : [%s] type:%d "), i + 1, nSectionCount, sSectionName, theSection);
	825	SysLog(s1);
	826	Sections[nSectionCount].nSectionType = theSection;
	827	Sections[nSectionCount].nSectionLineNo = i;
	828	nSectionCount++;
	829	}
	830	}
	831	if (nSectionCount > 0) {
	832	Sections[nSectionCount - 1].nLines = txtLineCount - Sections[nSectionCount - 1].nSectionLineNo - 1;
	833	s1.Format(_T("Section Ends at Line %d Lines %d "), txtLineCount, Sections[nSectionCount - 1].nLines);
	834	SysLog(s1);
	835	}
	836
	837	//读取程序章节
	838	int nProgSectionLine = 0;
	839	int nProgStartLine = 0;
	840	int nProgLines = 0;
	841
	842	int bProgSection = GetSectionPos(SectionProg, &nProgSectionLine, &nProgLines);
	843	if (bProgSection) { nProgStartLine = nProgSectionLine + 1; }
	844	else { nProgStartLine = 0; nProgLines = txtLineCount; }
	845
	846	TransLinesToProg(txtLines,nProgStartLine,nProgLines);
	847
	848	// 读取注释章节
	849	nCoilAnnoCount = 0;
	850	int nAnnoSectionLine = 0;
	851	int nAnnoStartLine = 0;
	852	int nAnnoLines = 0;
	853
	854	int bAnnoSection = GetSectionPos(SectionAnno, &nAnnoSectionLine, &nAnnoLines);
	855	if (bAnnoSection) { nAnnoStartLine = nAnnoSectionLine + 1; }
	856
	857	for (int i = nAnnoStartLine; i < nAnnoStartLine + nAnnoLines; i++)
	858	{
	859	CString sLine;
	860	sLine = txtLines.GetAt(i);
	861	sLine.Trim();
	862	int DivPos = sLine.Find(_T("\t"));
	863	if (DivPos < 1) continue;
	864
	865	CString sCoilName;
	866	sCoilName = sLine.Left(DivPos);
	867	sCoilName.MakeUpper();
	868	CString sAnno;
	869	sAnno = sLine.Mid(DivPos + 1);
	870
	871	// SetAnno(sCoilName, sAnno);
	872
	873	CStringA s1A;
	874	s1A = sCoilName;
	875	int nParamType,nAddr;
df0321	876	TxtToCoilType(s1A, &nParamType,&nAddr)
Q	877	\|\|TxtToDataType(s1A, &nParamType, &nAddr);
418cb3	878
Q	879	mCoilAnnos[nCoilAnnoCount].nType = nParamType;
	880	mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
	881	mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
	882	mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
	883
	884	nCoilAnnoCount++;
	885	}
	886
	887	return 0;
	888	}
	889	int CMTerm1Doc::TransToTxt(CStringA &ProgTxt)
	890	{
	891	CStringA s1, s2;
	892	for (int i = 0; i < m_nProgSteps; i++)
	893	{
	894	OpToTxt(Progs[i].nOpType1,s1);
	895	if (Progs[i].nParamCount > 0) { s1.Append("\t" + Progs[i].Params[0].sParamStr); }
	896	if (Progs[i].nParamCount > 1) { s1.Append("\t" + Progs[i].Params[1].sParamStr); }
	897	if (Progs[i].nParamCount > 2) { s1.Append("\t" + Progs[i].Params[2].sParamStr); }
	898	s1.Append("\r\n");
	899	s2 += s1;
	900	}
	901	ProgTxt = s2;
	902	return 0;
	903	}
	904
	905	int CMTerm1Doc::TransProgToBin()
	906	{
	907	CString s1;
df0321	908	stBinProg15* pBinProg15;
418cb3	909	stBinProg2 * pBinProg2;
Q	910	stBinProg3 * pBinProg3;
	911	nBinProgSteps = 0;
	912	for (int i = 0; i < m_nProgSteps; i++)
	913	{
	914	int nOpType = Progs[i].nOpType1;
	915	Progs[i].nBinStep = nBinProgSteps;
	916	int nParamType1 = Progs[i].Params[0].nParamType;
	917	int nParamAddr1 = Progs[i].Params[0].nParamAddr;
	918	int nParamType2, nParamAddr2;
	919	int nParamType3, nParamAddr3;
	920	if (Progs[i].nParamCount > 1) {
	921	nParamType2 = Progs[i].Params[1].nParamType;
	922	nParamAddr2 = Progs[i].Params[1].nParamAddr;
	923	}
	924	if (Progs[i].nParamCount > 2) {
	925	nParamType3 = Progs[i].Params[2].nParamType;
	926	nParamAddr3 = Progs[i].Params[2].nParamAddr;
	927	}
	928	switch (nOpType)
	929	{
	930	case OP_NONE:
	931	break;
	932	//case OP_NOP:
	933	break;
	934	//无参数指令
	935	case OP_NOT:
	936	case OP_ANS:
	937	case OP_ORS:
	938	case OP_PSHS:
	939	case OP_RDS:
	940	case OP_POPS:
	941	case OP_DF:
	942	case OP_DF_:
	943	BinProgs[nBinProgSteps].nOp = nOpType;
	944	nBinProgSteps += 1;
	945	break;
	946	// 1参数指令
	947	case OP_ST:
	948	case OP_ST_:
	949	case OP_AN:
	950	case OP_AN_:
	951	case OP_OR:
	952	case OP_OR_:
	953	BinProgs[nBinProgSteps].nOp = nOpType;
	954	BinProgs[nBinProgSteps].nParamType = nParamType1;
	955	BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
	956	nBinProgSteps += 1;
	957	break;
	958	// 1 参数输出
	959	case OP_OUT:
	960	case OP_SET:
	961	case OP_RESET:
	962	BinProgs[nBinProgSteps].nOp = nOpType;
	963	BinProgs[nBinProgSteps].nParamType = nParamType1;
	964	BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
	965	nBinProgSteps += 1;
	966	break;
	967
	968	// 比较指令
	969	case OP_ST_EQ:
	970	case OP_ST_NE:
	971	case OP_ST_LT:
	972	case OP_ST_GT:
	973	case OP_ST_LE:
	974	case OP_ST_GE:
	975	case OP_AN_EQ:
	976	case OP_AN_NE:
	977	case OP_AN_LT:
	978	case OP_AN_GT:
	979	case OP_AN_LE:
	980	case OP_AN_GE:
	981	case OP_OR_EQ:
	982	case OP_OR_NE:
	983	case OP_OR_LT:
	984	case OP_OR_GT:
	985	case OP_OR_LE:
	986	case OP_OR_GE:
	987	pBinProg2 = (stBinProg2 *)(&BinProgs[nBinProgSteps]);
	988	BinProgs[nBinProgSteps].nOp = nOpType;
	989	BinProgs[nBinProgSteps].nParamType = 0;
	990	BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
	991	BinProgs[nBinProgSteps+1].nOp = nParamType1;
	992	BinProgs[nBinProgSteps+1].nParamType = nParamType2;
	993	BinProgs[nBinProgSteps+1].nParamAddr = nParamAddr2;
	994	nBinProgSteps += 2;
	995	break;
	996
	997	// 定时器
	998	case OP_TML:
	999	case OP_TMR:
	1000	case OP_TMX:
	1001	case OP_TMY:
	1002	pBinProg15 = (stBinProg15 *)(&BinProgs[nBinProgSteps]);
df0321	1003
418cb3	1004	BinProgs[nBinProgSteps].nOp = nOpType;
Q	1005	BinProgs[nBinProgSteps].nParamType = nParamAddr1;
	1006	BinProgs[nBinProgSteps].nParamAddr = nParamAddr2;
	1007	BinProgs[nBinProgSteps + 1].nOp = nParamType2;
	1008	BinProgs[nBinProgSteps + 1].nParamType = 0;
	1009	BinProgs[nBinProgSteps + 1].nParamAddr = 0;
df0321	1010	pBinProg15->nOpNum = Progs[i].Params[0].nParamAddr;
Q	1011
418cb3	1012	nBinProgSteps += 2;
Q	1013	break;
	1014	// 1 参数高级指令
	1015	case OP_INC:
	1016	case OP_DEC:
	1017	pBinProg15 = (stBinProg15 *)(&BinProgs[nBinProgSteps]);
	1018	pBinProg15->nOp = nOpType;
	1019	pBinProg15->nOpNum = 0;
	1020	pBinProg15->nParamType1 = nParamType1;
	1021	pBinProg15->nParamAddr1 = nParamAddr1;
	1022	pBinProg15->resvr1 = 0;
	1023	pBinProg15->resvr2 = 0;
	1024	nBinProgSteps += 2;
	1025	break;
	1026	// 2参数高级指令
	1027	case OP_MV:
	1028	case OP_ADD2:
	1029	case OP_SUB2:
	1030	pBinProg2 = (stBinProg2 *)(&BinProgs[nBinProgSteps]);
	1031	pBinProg2->nOp = nOpType;
	1032	pBinProg2->nOpNum = 0;
	1033	pBinProg2->nParamType1 = nParamType1;
	1034	pBinProg2->nParamAddr1 = nParamAddr1;
	1035	pBinProg2->nParamType2 = nParamType2;
	1036	pBinProg2->nParamAddr2 = nParamAddr2;
	1037	nBinProgSteps += 2;
	1038
	1039	break;
	1040	// 3 参数高级指令
	1041	case OP_ADD3:
	1042	case OP_SUB3:
	1043	case OP_MUL:
	1044	case OP_DIV:
	1045	pBinProg3 = (stBinProg3 *)(&BinProgs[nBinProgSteps]);
	1046	pBinProg3->nOp = nOpType;
	1047	pBinProg3->nOpNum = 0;
	1048	pBinProg3->nParamType1 = nParamType1;
	1049	pBinProg3->nParamAddr1 = nParamAddr1;
	1050	pBinProg3->nParamType2 = nParamType2;
	1051	pBinProg3->nParamAddr2 = nParamAddr2;
	1052	pBinProg3->nParamType3 = nParamType3;
	1053	pBinProg3->nParamAddr3 = nParamAddr3;
	1054	nBinProgSteps += 3;
	1055	break;
	1056	default:
	1057	break;
	1058	}
	1059	}
	1060	s1.Format(_T("%d steps to %d binSteps "), m_nProgSteps, nBinProgSteps);
	1061	DbgLog(s1);
	1062
	1063	return 0;
	1064	}
	1065
	1066	int CMTerm1Doc::TransBinToProg()
	1067	{
df0321	1068	CString s1;
Q	1069	//nBinProgSteps = 0;
	1070	m_nProgSteps = 0;
	1071	stBinProg2* pBinProg2;
	1072	stBinProg15* pBinProg15;
	1073	stBinProg3* pBinProg3;
	1074	CStringA s1A;
	1075	CString s2,s3;
	1076	CStringA s2A, s3A;
	1077	for (int i = 0; i < nBinProgSteps; i++)
	1078	{
	1079	int nOpType = BinProgs[i].nOp;
	1080	int nParamType1 = BinProgs[i].nParamType;
	1081	int nParamAddr1 = BinProgs[i].nParamAddr;
	1082	// int nParamType1 = Progs[i].Params[0].nParamType;
	1083	// int nParamAddr1 = Progs[i].Params[0].nParamAddr;
	1084	int nParamType2, nParamAddr2;
	1085	int nParamType3, nParamAddr3;
	1086	CoilTypeToTxt(nParamType1, s1A);
	1087	s1.Format(_T("%S%d"), s1A, nParamAddr1);
	1088	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1089	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1090	Progs[m_nProgSteps].Params[0].sParamStr = s1;
418cb3	1091
df0321	1092	switch (nOpType)
Q	1093	{
	1094	case OP_NONE:
	1095	break;
	1096	//case OP_NOP:
	1097	break;
	1098	//无参数指令
	1099	case OP_NOT:
	1100	case OP_ANS:
	1101	case OP_ORS:
	1102	case OP_PSHS:
	1103	case OP_RDS:
	1104	case OP_POPS:
	1105	case OP_DF:
	1106	case OP_DF_:
	1107	Progs[m_nProgSteps].nOpType1 = nOpType;
	1108	Progs[m_nProgSteps].nParamCount = 0;
	1109	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1110	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1111
	1112	//BinProgs[nBinProgSteps].nOp = nOpType;
	1113	m_nProgSteps += 1;
	1114	//nBinProgSteps += 1;
	1115	break;
	1116	// 1参数指令
	1117	case OP_ST:
	1118	case OP_ST_:
	1119	case OP_AN:
	1120	case OP_AN_:
	1121	case OP_OR:
	1122	case OP_OR_:
	1123	Progs[m_nProgSteps].nOpType1 = nOpType;
	1124	Progs[m_nProgSteps].nParamCount = 1;
	1125	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1126	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1127	m_nProgSteps += 1;
	1128	//i += 1;
	1129	break;
	1130	// 1 参数输出
	1131	case OP_OUT:
	1132	case OP_SET:
	1133	case OP_RESET:
	1134	Progs[m_nProgSteps].nOpType1 = nOpType;
	1135	Progs[m_nProgSteps].nParamCount = 1;
	1136	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1137	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1138	m_nProgSteps += 1;
	1139	//i += 1;
	1140	break;
	1141
	1142	// 比较指令
	1143	case OP_ST_EQ:
	1144	case OP_ST_NE:
	1145	case OP_ST_LT:
	1146	case OP_ST_GT:
	1147	case OP_ST_LE:
	1148	case OP_ST_GE:
	1149	case OP_AN_EQ:
	1150	case OP_AN_NE:
	1151	case OP_AN_LT:
	1152	case OP_AN_GT:
	1153	case OP_AN_LE:
	1154	case OP_AN_GE:
	1155	case OP_OR_EQ:
	1156	case OP_OR_NE:
	1157	case OP_OR_LT:
	1158	case OP_OR_GT:
	1159	case OP_OR_LE:
	1160	case OP_OR_GE:
	1161	pBinProg2 = (stBinProg2*)(&BinProgs[i]);
	1162
	1163	nParamType1 = pBinProg2->nParamType1;
	1164	nParamAddr1 = pBinProg2->nParamAddr1;
	1165	nParamType2 = pBinProg2->nParamType2;
	1166	nParamAddr2 = pBinProg2->nParamAddr2;
	1167
	1168	DataTypeToTxt(nParamType1, s1A);
	1169	s1.Format(_T("%S%d"), s1A, nParamAddr1);
	1170
	1171	DataTypeToTxt(nParamType2, s2A);
	1172	s2.Format(_T("%S%d"), s2A, nParamAddr2);
	1173
	1174	Progs[m_nProgSteps].nOpType1 = nOpType;
	1175	Progs[m_nProgSteps].nParamCount = 2;
	1176	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1177	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1178	Progs[m_nProgSteps].Params[0].sParamStr = s1;
	1179
	1180	Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
	1181	Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
	1182	Progs[m_nProgSteps].Params[1].sParamStr = s2;
	1183
	1184	m_nProgSteps += 1;
	1185	i += 1;
	1186	break;
	1187
	1188	// 定时器
	1189	case OP_TML:
	1190	case OP_TMR:
	1191	case OP_TMX:
	1192	case OP_TMY:
	1193	//pBinProg2 = (stBinProg2*)(&BinProgs[i]);
	1194
	1195	pBinProg15 = (stBinProg15*)(&BinProgs[i]);
	1196
	1197	nParamType1 = 0;
	1198	nParamAddr1 = pBinProg15->nOpNum;
	1199	nParamType2 = pBinProg15->nParamType1;
	1200	nParamAddr2 = pBinProg15->nParamAddr1;
	1201	//nParamAddr2 = pBinProg15->nParamAddr2;
	1202	DataTypeToTxt(nParamType1, s1A);
	1203	s1.Format(_T("%d"), nParamAddr1);
	1204
	1205	DataTypeToTxt(nParamType2, s2A);
	1206	s2.Format(_T("%S%d"), s2A, nParamAddr2);
	1207
	1208	Progs[m_nProgSteps].nOpType1 = nOpType;
	1209	Progs[m_nProgSteps].nParamCount = 2;
	1210	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1211	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1212	Progs[m_nProgSteps].Params[0].sParamStr = s1;
	1213
	1214	Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
	1215	Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
	1216	Progs[m_nProgSteps].Params[1].sParamStr = s2;
	1217	m_nProgSteps += 1;
	1218	i += 1;
	1219
	1220	break;
	1221	// 1 参数高级指令
	1222	case OP_INC:
	1223	case OP_DEC:
	1224	pBinProg15 = (stBinProg15*)(&BinProgs[i]);
	1225	nParamType1 = pBinProg15->nParamType1;
	1226	nParamAddr1 = pBinProg15->nParamAddr1;
	1227
	1228	DataTypeToTxt(nParamType1, s1A);
	1229	s1.Format(_T("%S%d"), s1A, nParamAddr1);
	1230
	1231	Progs[m_nProgSteps].nOpType1 = nOpType;
	1232	Progs[m_nProgSteps].nParamCount = 1;
	1233	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1234	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1235	Progs[m_nProgSteps].Params[0].sParamStr = s1;
	1236
	1237	m_nProgSteps += 1;
	1238	i += 1;
	1239	break;
	1240	// 2参数高级指令
	1241	case OP_MV:
	1242	case OP_ADD2:
	1243	case OP_SUB2:
	1244	pBinProg2 = (stBinProg2*)(&BinProgs[i]);
	1245
	1246	nParamType1 = pBinProg2->nParamType1;
	1247	nParamAddr1 = pBinProg2->nParamAddr1;
	1248	nParamType2 = pBinProg2->nParamType2;
	1249	nParamAddr2 = pBinProg2->nParamAddr2;
	1250
	1251	DataTypeToTxt(nParamType1, s1A);
	1252	s1.Format(_T("%S%d"), s1A, nParamAddr1);
	1253
	1254	DataTypeToTxt(nParamType2, s2A);
	1255	s2.Format(_T("%S%d"), s2A, nParamAddr2);
	1256
	1257	Progs[m_nProgSteps].nOpType1 = nOpType;
	1258	Progs[m_nProgSteps].nParamCount = 2;
	1259	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1260	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1261	Progs[m_nProgSteps].Params[0].sParamStr = s1;
	1262
	1263	Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
	1264	Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
	1265	Progs[m_nProgSteps].Params[1].sParamStr = s2;
	1266
	1267	m_nProgSteps += 1;
	1268	i += 1;
	1269
	1270	break;
	1271	// 3 参数高级指令
	1272	case OP_ADD3:
	1273	case OP_SUB3:
	1274	case OP_MUL:
	1275	case OP_DIV:
	1276	pBinProg3 = (stBinProg3*)(&BinProgs[i]);
	1277	nParamType1 = pBinProg3->nParamType1;
	1278	nParamAddr1 = pBinProg3->nParamAddr1;
	1279	nParamType2 = pBinProg3->nParamType2;
	1280	nParamAddr2 = pBinProg3->nParamAddr2;
	1281	nParamType3 = pBinProg3->nParamType3;
	1282	nParamAddr3 = pBinProg3->nParamAddr3;
	1283
	1284	DataTypeToTxt(nParamType1, s1A);
	1285	s1.Format(_T("%S%d"), s1A, nParamAddr1);
	1286
	1287	DataTypeToTxt(nParamType2, s2A);
	1288	s2.Format(_T("%S%d"), s2A, nParamAddr2);
	1289	DataTypeToTxt(nParamType3, s3A);
	1290	s3.Format(_T("%S%d"), s3A, nParamAddr3);
	1291
	1292	Progs[m_nProgSteps].nOpType1 = nOpType;
	1293	Progs[m_nProgSteps].nParamCount = 3;
	1294	Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
	1295	Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
	1296	Progs[m_nProgSteps].Params[0].sParamStr = s1;
	1297	Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
	1298	Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
	1299	Progs[m_nProgSteps].Params[1].sParamStr = s2;
	1300	Progs[m_nProgSteps].Params[2].nParamType = nParamType3;
	1301	Progs[m_nProgSteps].Params[2].nParamAddr = nParamAddr3;
	1302	Progs[m_nProgSteps].Params[2].sParamStr = s3;
	1303	m_nProgSteps += 1;
	1304	i += 2;
	1305	break;
	1306	default:
	1307	break;
	1308	}
	1309
	1310	}
	1311	s1.Format(_T("%d binsteps to %d Steps "), nBinProgSteps, m_nProgSteps );
	1312	DbgLog(s1);
418cb3	1313	return 0;
Q	1314	}
	1315
	1316	void CMTerm1Doc::OnUploadFromPlc()
	1317	{
	1318	// TODO: 在此添加命令处理程序代码
	1319	int r;
	1320	CString s1;
	1321	if (!m_bOnline) {
	1322	r = Connect();
df0321	1323	// MyKLink1.Open();
418cb3	1324	}
Q	1325	if (!m_bOnline) return;
	1326	r = MyKLink1.ReadRunStat(1,0,0,32,(unsigned short *)&MyKLink1.KMRunStat);
	1327
df0321	1328	if (r != 0) {
Q	1329	AfxMessageBox(_T("UploadFrom PLC Failed"));
	1330	return;
	1331	}
418cb3	1332	// AfxMessageBox(_T("UploadFrom PLC From Doc"));
Q	1333	CString s2;
	1334	s2.Format(_T("Cur Programs %d \r\n"), nBinProgSteps);
	1335	unsigned short * pBinBuf2 = (unsigned short *)BinProgs;
	1336	for (int i = 0; i < nBinProgSteps * 2; i += 8) {
	1337	s1.Format(_T("%03X: "), i);
	1338	for (int j = 0; j < 8 && i+j < nBinProgSteps * 2; j++) {
	1339	s1.AppendFormat(_T("%04X "), pBinBuf2[i + j]);
	1340	}
	1341	s2 += s1 + _T("\r\n");
	1342	}
	1343	DbgLog(s2);
	1344
	1345	int nBinSteps = MyKLink1.KMRunStat.nBinProgSize;
	1346	s1.Format(_T("program to upload Size %d "), nBinSteps);
	1347	DbgLog(s1);
	1348
	1349	USHORT Buf3[2048];
	1350	s2.Empty();
	1351	int nUploadSize = nBinSteps *2;
	1352	int nSteps = 64;
	1353	for (int i = 0; i < nUploadSize; i += nSteps) {
	1354	if (i + nSteps > nUploadSize) { nSteps = nUploadSize - i; }
	1355	s1.Format(_T("2 Uploading %d to %d "), i, i + nSteps);
	1356	DbgLog(s1);
	1357	int r = MyKLink1.ReadProgram(1, 2, i, nSteps*2 , Buf3+i);
	1358	s1.Format(_T("Download r = %d "), r);
	1359	DbgLog(s1);
	1360	//Update Progress Bar
	1361	}
	1362	s2.Format(_T(" Uploaded from bank 2 \r\n"));
	1363	for (int i = 0; i < nBinSteps * 2; i += 8) {
	1364	s1.Format(_T("%03X: "), i);
	1365	for (int j = 0; j < 8 && i + j < nBinSteps * 2; j++) {
	1366	s1.AppendFormat(_T("%04X "), Buf3[i + j]);
	1367	}
	1368	s2 += s1 + _T("\r\n");
	1369	}
	1370	DbgLog(s2);
	1371
	1372	for (int i = 0; i < nBinSteps * 2; i++)
	1373	{
	1374	((USHORT *)BinProgs)[i] = Buf3[i];
	1375	}
	1376	nBinProgSteps = nBinSteps;
	1377	TransBinToProg();
	1378	UpdateAllViews(NULL);
	1379	}
	1380
	1381	int CMTerm1Doc::DownloadToPLC()
	1382	{
	1383	// TODO: 在此处添加实现代码.
	1384	int r;
	1385	CString s1;
	1386	if (!m_bOnline) {
	1387	r=Connect();
df0321	1388	// MyKLink1.Open();
418cb3	1389	}
Q	1390	if (!m_bOnline) return 0;
	1391
	1392	if (m_bPlcRunning) {
df0321	1393	r = AfxMessageBox(_T("PLC运行中，是否停止以便下载程序?"), MB_YESNO);
418cb3	1394	if (r == IDYES) { StopPLC();}
Q	1395	else { return 0; }
	1396	}
	1397
	1398	// 下载程序
	1399	s1.Format(_T("Start Download Program ..."));
	1400	DbgLog(s1);
	1401	r = MyKLink1.StartProgram(1,2);
	1402	s1.Format(_T("Result = %d"),r);
	1403	DbgLog(s1);
	1404	int DownloadSize = nBinProgSteps;
	1405
	1406	int Steps = 16;
	1407	for (int i = 0; i < DownloadSize; i += Steps) {
	1408	//int Steps = 16;
	1409	if (i + Steps > DownloadSize) { Steps = DownloadSize - i; }
df0321	1410	int n = 0;
Q	1411	do {
	1412	s1.Format(_T("Downloading %d to %d "), i, i + Steps);
	1413	DbgLog(s1);
	1414	r = MyKLink1.WriteProgram(1, 2, (i) * 4, Steps * 4, (USHORT*)&BinProgs[i]);
	1415	s1.Format(_T("Download r = %d "), r);
	1416	DbgLog(s1);
	1417	n += 1;
	1418	if (n > 10) break;
	1419	} while (r != 0);
418cb3	1420	//Update Progress Bar
Q	1421	}
	1422
	1423	s1.Format(_T("Finish Downloading "));
	1424	DbgLog(s1);
	1425	r = MyKLink1.FinishProgram(1,2,nBinProgSteps);
	1426	s1.Format(_T("Download Finished r = %d "), r);
	1427	DbgLog(s1);
	1428	// 下载注释
	1429
	1430
	1431	// 下载系统寄存器配置
	1432
df0321	1433	//启动运行
Q	1434	r = AfxMessageBox(_T("程序下载完成，是否启动运行?"), MB_YESNO);
	1435	if (r == IDYES) { StartPLC(); }
	1436	else { return 0; }
418cb3	1437
Q	1438	return 0;
	1439	}
	1440
	1441	void CMTerm1Doc::OnDownloadToPlc()
	1442	{
	1443	// TODO: 在此添加命令处理程序代码
	1444	DownloadToPLC();
	1445	}
	1446
	1447	void CMTerm1Doc::OnUpdateDownloadToPlc(CCmdUI *pCmdUI)
	1448	{
	1449	// TODO: 在此添加命令更新用户界面处理程序代码
	1450	}
	1451
	1452	void CMTerm1Doc::OnOnline()
	1453	{
	1454	// TODO: 在此添加命令处理程序代码
	1455	int r;
	1456	if (!m_bOnline)
	1457	{
	1458	r = Connect();
df0321	1459	//MyKLink1.Open();
418cb3	1460	}
Q	1461	if (!m_bOnline) return;
	1462	// m_bOnline = true;
	1463	UpdateAllViews(NULL, UpdataHint::UpdateStat);
	1464	}
	1465
	1466	void CMTerm1Doc::OnUpdateOnline(CCmdUI *pCmdUI)
	1467	{
	1468	// TODO: 在此添加命令更新用户界面处理程序代码
	1469	pCmdUI->SetCheck(m_bOnline == true);
	1470	}
	1471
	1472	void CMTerm1Doc::OnOffline()
	1473	{
	1474	// TODO: 在此添加命令处理程序代码
	1475	int r;
	1476	if (m_bOnline)
	1477	{
	1478	r = DisConnect();
	1479	MyKLink1.Close();
	1480	}
	1481	m_bOnline = false;
	1482	UpdateAllViews(NULL, UpdataHint::UpdateStat);
	1483	}
	1484
	1485	void CMTerm1Doc::OnUpdateOffline(CCmdUI *pCmdUI)
	1486	{
	1487	// TODO: 在此添加命令更新用户界面处理程序代码
	1488	pCmdUI->SetCheck(m_bOnline == false);
	1489	}
	1490
	1491	void CMTerm1Doc::OnSimulate()
	1492	{
	1493	// TODO: 在此添加命令处理程序代码
df0321	1494	CString s1;
Q	1495	unsigned short* p1 = (unsigned short *)&BinProgs;
418cb3	1496	if (!m_bSimulate) {
df0321	1497
Q	1498	s1.Format(_T("启动PLC模拟\r\n"));
	1499	SysLog(s1);
418cb3	1500	m_bSimulate = true;
df0321	1501	s1.Empty();
Q	1502	for (int i = 0; i < nBinProgSteps; i++) {
	1503	s1.AppendFormat(_T("%04X %04X "), p1[i2],p1[i2+1]);
	1504	}
	1505	SysLog(s1);
	1506	s1.Format(_T("Download %d program to sim PLC"),nBinProgSteps);
	1507	SysLog(s1);
	1508	myKMachine1.Download(BinProgs, nBinProgSteps);
418cb3	1509	m_bOnline = true;
df0321	1510	myKMachine1.StartPLC();
Q	1511	s1.Format(_T("Start sim PLC"));
	1512	SysLog(s1);
418cb3	1513	StartPLC();
Q	1514	}
	1515	else {
df0321	1516	StopPLC();
418cb3	1517	m_bSimulate = false;
Q	1518	m_bOnline = false;
df0321	1519
418cb3	1520	}
Q	1521	UpdateAllViews(NULL, UpdataHint::UpdateStat);
	1522	}
	1523
	1524	void CMTerm1Doc::OnUpdateSimulate(CCmdUI *pCmdUI)
	1525	{
	1526	// TODO: 在此添加命令更新用户界面处理程序代码
	1527	pCmdUI->SetCheck(m_bSimulate == true);
	1528	}
	1529
	1530	int CMTerm1Doc::StartPLC()
	1531	{
	1532	// TODO: 在此处添加实现代码.
df0321	1533	if (m_bSimulate) {
Q	1534	for (int i = 0; i < KLDataWXCount; i++) {
	1535	KMem.WX[i] = 0;
	1536	}
	1537	for (int i = 0; i < KLDataWYCount; i++) {
	1538	KMem.WY[i] = 0;
	1539	}
	1540	for (int i = 0; i < KLDataWRCount; i++) {
	1541	KMem.WR[i] = 0;
	1542	}
	1543	for (int i = 0; i < KLDataDTCount; i++) {
	1544	KMem.DT[i] = 0;
	1545	}
	1546	for (int i = 0; i < TOTALTIMERS; i++) {
	1547	KMem.Timers[i] = { 0 };
	1548	}
	1549	nScanCount = 0;
	1550	m_bPlcRunning = 1;
	1551	}else {
	1552	MyKLink1.ChangeMode(1, 1);
	1553	m_bPlcRunning = 1;
418cb3	1554	}
Q	1555	return 0;
	1556	}
	1557
	1558
	1559	int CMTerm1Doc::StopPLC()
	1560	{
	1561	// TODO: 在此处添加实现代码.
df0321	1562	if (m_bSimulate) {
Q	1563	m_bPlcRunning = false;
	1564	}
	1565	else {
	1566	MyKLink1.ChangeMode(1, 0);
	1567	m_bPlcRunning = false;
	1568	}
418cb3	1569
Q	1570	return 0;
	1571	}
	1572
	1573	void CMTerm1Doc::OnPlcRun()
	1574	{
	1575	// TODO: 在此添加命令处理程序代码
	1576	if (m_bPlcRunning) { StopPLC(); }
	1577	else
	1578	{
	1579	StartPLC();
	1580	}
	1581	UpdateAllViews(NULL, UpdataHint::UpdateStat);
	1582	}
	1583
	1584	void CMTerm1Doc::OnUpdatePlcRun(CCmdUI *pCmdUI)
	1585	{
	1586	// TODO: 在此添加命令更新用户界面处理程序代码
	1587	pCmdUI->SetCheck(m_bPlcRunning == true);
	1588	if (!m_bPlcRunning) pCmdUI->SetText(_T("PLC模式[PROG]"));
	1589	else pCmdUI->SetText(_T("PLC模式[RUN]"));
	1590	}
	1591
	1592
	1593	int CMTerm1Doc::SetCommParam()
	1594	{
	1595	// TODO: 在此处添加实现代码.
	1596	CString s1;
	1597	s1.Format(_T("Doc SetupComm"));
	1598	SysLog(s1);
	1599	MyKLink1.SetCommParam();
	1600	return 0;
	1601	/*
	1602	CDialogCommSet1 dialog1;
	1603	INT_PTR r = dialog1.DoModal();
	1604	if (r == IDOK )
	1605	{
	1606	nComPort=dialog1.m_nComNum;
	1607	nBaud=dialog1.m_nBaudRate;
	1608	ComSettings=dialog1.m_Settings;
	1609	s1.Format(_T("dialog return port %d baud %d setting %S"),
	1610	nComPort, nBaud, ComSettings);
	1611	SysLog(s1);
	1612	m_bCommParamSet = true;
	1613	}
	1614	else
	1615	{
	1616	return -1;
	1617	}
	1618	return 0;
	1619	*/
	1620	}
	1621
	1622	int CMTerm1Doc::Connect()
	1623	{
	1624	// TODO: 在此处添加实现代码.
	1625	CString s1;
	1626	unsigned short buf1[32];
	1627	int res = MyKLink1.Connect();
	1628	unsigned short len1;
	1629	int j=MyKLink1.GetInfo(1, &len1, buf1);
df0321	1630	s1.Format(_T("GetInfo = %d %d \r\n"), j,len1);
Q	1631	if (j==0 && len1 > 0) {
	1632	for (int i = 0; i < len1/2; i++) {
	1633	s1.AppendFormat(_T("%04X "), buf1[i]);
	1634	}
	1635	s1 += _T("\r\n");
	1636	pKMInfoBlock pinfob = (pKMInfoBlock)buf1;
	1637
	1638	s1.AppendFormat(_T(" DeviceType %04X \r\n"),pinfob->nDeviceTypeVer);
	1639	s1.AppendFormat(_T(" nProgVer %04X \r\n"), pinfob->nProgVer);
	1640	s1.AppendFormat(_T(" nKLinkVer %04X \r\n"), pinfob->nKLinkVer);
	1641	s1.AppendFormat(_T(" nKBusVer %04X \r\n"), pinfob->nKBusVer);
	1642	s1.AppendFormat(_T(" nCapacity1 %d k\r\n"), pinfob->nCapacity1);
	1643	s1.AppendFormat(_T(" nCapacity2 %d k\r\n"), pinfob->nCapacity2);
	1644	s1.AppendFormat(_T(" nDInput %d \r\n"), pinfob->nDInput);
	1645	s1.AppendFormat(_T(" nDOutput %d \r\n"), pinfob->nDOutput);
	1646	s1.AppendFormat(_T(" nAInput %d \r\n"), pinfob->nAInput);
	1647	s1.AppendFormat(_T(" nAOutput %d \r\n"), pinfob->nAOutput);
	1648	s1.AppendFormat(_T(" nHInput %d \r\n"), pinfob->nHInput);
	1649	s1.AppendFormat(_T(" nHOutput %d \r\n"), pinfob->nHOutput);
	1650	s1.AppendFormat(_T(" nExt1 %d \r\n"), pinfob->nExt1);
	1651	s1.AppendFormat(_T(" nExt2 %d \r\n"), pinfob->nExt2);
	1652	s1.AppendFormat(_T(" nLogSize %d \r\n"), pinfob->nLogSize);
	1653	s1.AppendFormat(_T(" nPorts %d \r\n"), pinfob->nPorts);
	1654	s1.AppendFormat(_T(" nManSize %d \r\n"), pinfob->nManSize);
	1655	s1.AppendFormat(_T(" nAbility %d \r\n"), pinfob->nAbility);
	1656	s1.AppendFormat(_T(" nSwitchBits %d \r\n"), pinfob->nSwitchBits);
	1657
	1658	}
	1659	SysLog(s1);
	1660	int r = MyKLink1.ReadRunStat(1, 0, 0, 32, (unsigned short*)&MyKLink1.KMRunStat);
	1661	s1.Format(_T("GetRunStat = %d %d \r\n"), r, 32);
	1662	KLink1::stRunStat RunStat1 = MyKLink1.KMRunStat;
	1663
	1664	s1.AppendFormat(_T(" Sign1 %04X \r\n"), RunStat1.Sign1);
	1665	s1.AppendFormat(_T(" Seq1 %d \r\n"), RunStat1.Seq1);
	1666	s1.AppendFormat(_T(" PowerCount %d \r\n"), RunStat1.PowerCount);
	1667	s1.AppendFormat(_T(" Reserved1 %d \r\n"), RunStat1.Reserved1);
	1668	s1.AppendFormat(_T(" UpTime %d \r\n"), RunStat1.UpTime);
	1669	s1.AppendFormat(_T(" UserData1 %d \r\n"), RunStat1.UserData1);
	1670	s1.AppendFormat(_T(" WorkMode %d \r\n"), RunStat1.WorkMode);
	1671	s1.AppendFormat(_T(" WorkMode2 %d \r\n"), RunStat1.WorkMode2);
	1672	s1.AppendFormat(_T(" nBinProgBank %d \r\n"), RunStat1.nBinProgBank);
	1673	s1.AppendFormat(_T(" nBinProgSize %d \r\n"), RunStat1.nBinProgSize);
	1674	s1.AppendFormat(_T(" bLEDFlick %d \r\n"), RunStat1.bLEDFlick);
	1675	s1.AppendFormat(_T(" Reserved2 %d \r\n"), RunStat1.Reserved2);
	1676	s1.AppendFormat(_T(" CRC1 %04X \r\n"), RunStat1.CRC1);
	1677	s1.AppendFormat(_T(" EndSign1 %04X \r\n"), RunStat1.EndSign1);
	1678
	1679	unsigned char value;
	1680	r = MyKLink1.GetMode(1, 0, &value);
	1681	if (r == KLink1::KL_OK) { m_bPlcRunning = value; }
	1682
	1683
418cb3	1684	SysLog(s1);
Q	1685	// m_static_connect.SetCtlColor(RGB(0, 255, 0));
	1686	/*
	1687	if (!m_bCommParamSet)
	1688	{
	1689	if (SetCommParam()) return -1;
	1690	}
	1691	if (m_bOnline) return 0;
	1692
	1693	myHvSerialPort1.m_nPort = nComPort;
	1694	myHvSerialPort1.m_nBaudRate = nBaud;
	1695	myHvSerialPort1.m_Settings = "8,N,1";
	1696	int r = myHvSerialPort1.Open();
	1697	s1.Format(_T("Open %s = %d"), myHvSerialPort1.m_strResult, r);
	1698	SysLog(s1);
	1699	if (r == myHvSerialPort1.R_OK)
	1700	{
	1701	m_bOnline = true;
	1702	// MyKLink1.Open();
	1703	// m_static_connect.SetCtlColor(RGB(0, 255, 0));
	1704	return 0;
	1705	}
	1706	*/
	1707	m_bOnline = true;
	1708	return 0;
	1709	}
	1710
	1711	int CMTerm1Doc::DisConnect()
	1712	{
	1713	// TODO: 在此处添加实现代码.
	1714	if (!m_bOnline) return -1;
	1715	// myHvSerialPort1.Close();
	1716	MyKLink1.Close();
	1717	m_bOnline = false;
	1718	return 0;
	1719	}
	1720
	1721	void CMTerm1Doc::OnComunicationSet()
	1722	{
	1723	// TODO: 在此添加命令处理程序代码
	1724	SetCommParam();
	1725
	1726	}
	1727
	1728	void CMTerm1Doc::OnPlcSysregSet()
	1729	{
	1730	// TODO: 在此添加命令处理程序代码
	1731	CDialogSysRegSet dialog1;
	1732	INT_PTR r = dialog1.DoModal();
	1733	if (r == IDOK)
	1734	{
	1735
	1736	}
	1737	}
	1738
	1739	void CMTerm1Doc::OnMenuFactCfg()
	1740	{
	1741	// TODO: 在此添加命令处理程序代码
	1742	CDialogFactCfg dialog1;
	1743	INT_PTR r = dialog1.DoModal();
	1744	if (r == IDOK)
	1745	{
	1746
	1747	}
	1748	}
	1749
	1750
	1751	CView * CMTerm1Doc::FindView(CRuntimeClass * pClass)
	1752	{
	1753	CView* pView=NULL;
	1754	POSITION pos = GetFirstViewPosition();
	1755	while (pos != NULL)
	1756	{
	1757	pView = GetNextView(pos);
	1758	if (pView->IsKindOf(pClass))
	1759	break;
	1760	}
	1761	if (!pView->IsKindOf(pClass))
	1762	{
	1763	//AfxMessageBox("Connt Locate the View.");
	1764	return NULL;
	1765	}
	1766	return pView;
	1767	}
	1768	///*
	1769	void CMTerm1Doc::OnMenuViewLds()
	1770	{
	1771	// TODO: 在此添加命令处理程序代码
	1772	CString s1;
	1773	CView * pView;
	1774	pView = FindView(RUNTIME_CLASS(CMTerm1View));
	1775	if (pView != NULL) {
	1776	((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
	1777	// pView->SetActiveWindow();
	1778	}
	1779	else {
	1780	s1 = GetTitle();
	1781	//AfxMessageBox(s1);
	1782	ASSERT_VALID(theApp.pDocTemplate);
	1783	CFrameWnd * pFrame = theApp.pDocTemplate->CreateNewFrame(this, NULL);
	1784	ASSERT_KINDOF(CFrameWnd, pFrame);
	1785	theApp.pDocTemplate->InitialUpdateFrame(pFrame, this);
	1786	}
	1787	}
	1788
	1789
	1790	void CMTerm1Doc::OnMenuViewBld()
	1791	{
	1792	// TODO: 在此添加命令处理程序代码
	1793	CString s1;
	1794	CView * pView;
	1795	pView = FindView(RUNTIME_CLASS(CMTerm1BldView));
	1796	if (pView != NULL) {
	1797	((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
	1798	// pView->SetActiveWindow();
	1799	}
	1800	else {
	1801	s1 = GetTitle();
	1802	//AfxMessageBox(s1);
	1803	ASSERT_VALID(theApp.m_pBldViewTemplate);
	1804	CFrameWnd * pFrame = theApp.m_pBldViewTemplate->CreateNewFrame(this, NULL);
	1805	ASSERT_KINDOF(CFrameWnd, pFrame);
	1806	theApp.m_pBldViewTemplate->InitialUpdateFrame(pFrame, this);
	1807	}
	1808	}
	1809
	1810
	1811	void CMTerm1Doc::OnMenuViewBnl()
	1812	{
	1813	// TODO: 在此添加命令处理程序代码
	1814	CString s1;
	1815	CView * pView;
	1816	pView = FindView(RUNTIME_CLASS(CMTerm1BnlView));
	1817	if (pView != NULL) {
	1818	((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
	1819	// pView->SetActiveWindow();
	1820	}
	1821	else {
	1822	s1 = GetTitle();
	1823	//AfxMessageBox(s1);
	1824	ASSERT_VALID(theApp.m_pBnlViewTemplate);
	1825	CFrameWnd * pFrame = theApp.m_pBnlViewTemplate->CreateNewFrame(this, NULL);
	1826	ASSERT_KINDOF(CFrameWnd, pFrame);
	1827	theApp.m_pBnlViewTemplate->InitialUpdateFrame(pFrame, this);
	1828	}
	1829	}
	1830	//*/
	1831
	1832	void CMTerm1Doc::OnMenuShowConsole()
	1833	{
	1834	// TODO: 在此添加命令处理程序代码
	1835	CString s1;
	1836	CView * pView;
	1837	pView = FindView(RUNTIME_CLASS(CMTerm1CtrlView));
	1838	if (pView != NULL) {
	1839	((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
	1840	// pView->SetActiveWindow();
	1841	}
	1842	else {
	1843	s1 = GetTitle();
	1844	//AfxMessageBox(s1);
	1845	ASSERT_VALID(theApp.m_pCtrlViewTemplate);
	1846	CFrameWnd * pFrame = theApp.m_pCtrlViewTemplate->CreateNewFrame(this, NULL);
	1847	ASSERT_KINDOF(CFrameWnd, pFrame);
	1848	theApp.m_pCtrlViewTemplate->InitialUpdateFrame(pFrame, this);
	1849	}
	1850	}
	1851
	1852
	1853	void CMTerm1Doc::OnMenuCommTest()
	1854	{
	1855	// TODO: 在此添加命令处理程序代码
	1856	CString s1;
	1857	CView * pView;
	1858	pView = FindView(RUNTIME_CLASS(CMTerm1CommDevView));
	1859	if (pView != NULL) {
	1860	((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
	1861	// pView->SetActiveWindow();
	1862	}
	1863	else {
	1864	s1 = GetTitle();
	1865	//AfxMessageBox(s1);
	1866	ASSERT_VALID(theApp.m_pCommDevViewTemplate);
	1867	CFrameWnd * pFrame = theApp.m_pCommDevViewTemplate->CreateNewFrame(this, NULL);
	1868	ASSERT_KINDOF(CFrameWnd, pFrame);
	1869	theApp.m_pCommDevViewTemplate->InitialUpdateFrame(pFrame, this);
	1870	}
	1871
	1872	}
	1873
	1874	const unsigned short bitMasks[16] =
	1875	{
	1876	0x1 << 0, 0x1 << 1, 0x1 << 2, 0x1 << 3, 0x1 << 4, 0x1 << 5, 0x1 << 6, 0x1 << 7,
	1877	0x1 << 8, 0x1 << 9, 0x1 << 10, 0x1 << 11, 0x1 << 12, 0x1 << 13, 0x1 << 14, 0x1 << 15,
	1878	};
	1879
	1880	inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
	1881	{
	1882	(*pW) \|= bitMasks[bitAddr & 0xf];
	1883	}
	1884
	1885	inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
	1886	{
	1887	(*pW) &= ~bitMasks[bitAddr & 0xf];
	1888	}
	1889
	1890	static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
	1891	{
	1892	if (Value) { SetAddrBit(pW, bitAddr); }
	1893	else { ResetBit(pW, bitAddr); }
	1894	}
	1895
	1896	static inline unsigned char GetBitValue(unsigned short W, unsigned char bitAddr)
	1897	{
	1898	if (W&bitMasks[bitAddr & 0xf]) return 1;
	1899	else return 0;
	1900	}
	1901
	1902	int CMTerm1Doc::GetCoilValue(int nCoilType, int nCoilAddr)
	1903	{
	1904	// TODO: 在此处添加实现代码.
	1905
	1906	if (m_bOnline && 0)
	1907	{
	1908	unsigned char value = 0;
	1909	MyKLink1.ReadBit(1, nCoilType, nCoilAddr, &value);
	1910	return value;
	1911	}
	1912	int nWordAddr = nCoilAddr >> 4;
	1913	int nBitAddr = nCoilAddr & 0x0F;
	1914
	1915	switch (nCoilType)
	1916	{
	1917	case KLCoilTypeX:
	1918	if (nCoilAddr >= KLCoilXCount) return 0;
	1919	return GetBitValue(KMem.WX[nWordAddr], nBitAddr);
	1920	break;
	1921	case KLCoilTypeY:
	1922	if (nCoilAddr >= KLCoilYCount) return 0;
	1923	return GetBitValue(KMem.WY[nWordAddr], nBitAddr);
	1924	break;
	1925	case KLCoilTypeR:
	1926	if (nCoilAddr >= KLCoilRCount) return 0;
	1927	return GetBitValue(KMem.WR[nWordAddr], nBitAddr);
	1928	break;
	1929	case KLCoilTypeLX:
	1930	if (nCoilAddr >= KLCoilLXCount) return 0;
	1931	return GetBitValue(KMem.WLX[nWordAddr], nBitAddr);
	1932	break;
	1933	case KLCoilTypeLY:
	1934	if (nCoilAddr >= KLCoilLYCount) return 0;
	1935	return GetBitValue(KMem.WLY[nWordAddr], nBitAddr);
	1936	break;
	1937	case KLCoilTypeT:
	1938	if (nCoilAddr >= KLCoilTCount) return 0;
	1939	return GetBitValue(KMem.WT[nWordAddr], nBitAddr);
	1940	break;
	1941	case KLCoilTypeC:
	1942	if (nCoilAddr >= KLCoilCCount) return 0;
	1943	return GetBitValue(KMem.WC[nWordAddr], nBitAddr);
	1944	break;
	1945	case KLCoilTypeLR:
	1946	if (nCoilAddr >= KLCoilLRCount) return 0;
	1947	return GetBitValue(KMem.WLR[nWordAddr], nBitAddr);
	1948	break;
	1949	case KLCoilTypeSR:
	1950	if (nCoilAddr >= KLCoilSRCount) return 0;
	1951	return GetBitValue(KMem.WSR[nWordAddr], nBitAddr);
	1952	break;
	1953	}
	1954	return 0;
	1955	}
	1956
	1957
	1958	int CMTerm1Doc::SetCoilValue(int nCoilType, int nCoilAddr, int nCoilValue)
	1959	{
	1960	// TODO: 在此处添加实现代码.
	1961	if (m_bSimulate) {
	1962	return myKMachine1.SetCoilValue(nCoilType, nCoilAddr, nCoilValue);
	1963	}else
	1964	if (m_bOnline)
	1965	{
	1966	unsigned char value =nCoilValue;
	1967	int res = 0;
	1968	res = MyKLink1.WriteBit(1, nCoilType, nCoilAddr, value);
	1969	return res;
	1970	}
	1971
	1972	int nWordAddr = nCoilAddr >> 4;
	1973	int nBitAddr = nCoilAddr & 0x0F;
	1974
	1975	switch (nCoilType)
	1976	{
	1977	case KLCoilTypeX:
	1978	if (nCoilAddr >= KLCoilXCount) return 0;
	1979	SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
	1980	break;
	1981	case KLCoilTypeY:
	1982	if (nCoilAddr >= KLCoilYCount) return 0;
	1983	SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
	1984	break;
	1985	case KLCoilTypeR:
	1986	if (nCoilAddr >= KLCoilRCount) return 0;
	1987	SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
	1988	break;
	1989	case KLCoilTypeLX:
	1990	if (nCoilAddr >= KLCoilLXCount) return 0;
	1991	SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
	1992	break;
	1993	case KLCoilTypeLY:
	1994	if (nCoilAddr >= KLCoilLYCount) return 0;
	1995	SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
	1996	break;
	1997	case KLCoilTypeT:
	1998	if (nCoilAddr >= KLCoilTCount) return 0;
	1999	SetBitValue(&KMem.WT[nWordAddr], nBitAddr, nCoilValue);
	2000	break;
	2001	case KLCoilTypeC:
	2002	if (nCoilAddr >= KLCoilCCount) return 0;
	2003	SetBitValue(&KMem.WC[nWordAddr], nBitAddr, nCoilValue);
	2004	break;
	2005	case KLCoilTypeLR:
	2006	if (nCoilAddr >= KLCoilLRCount) return 0;
	2007	SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
	2008	break;
	2009	case KLCoilTypeSR:
	2010	if (nCoilAddr >= KLCoilSRCount) return 0;
	2011	SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
	2012
	2013	break;
	2014	}
	2015	if (m_bOnline)
	2016	{
	2017	// MyKLink1.WriteBit(1, nCoilType, nCoilAddr, nCoilValue);
	2018	}
	2019	return 0;
	2020	}
	2021
	2022	int CMTerm1Doc::GetVarData(int nDataType, int nDataAddr)
	2023	{
	2024	// TODO: 在此处添加实现代码.
	2025	unsigned short nCount;
	2026	if (m_bOnline && 0)
	2027	{
	2028	unsigned short value[20];
	2029	unsigned short svalue = 0;
	2030	if (nDataType == KLDataTypeDEC \|\| nDataType == KLDataTypeHEX){
	2031	return nDataAddr;
	2032	}
	2033
	2034	MyKLink1.ReadDataWord(1, nDataType, nDataAddr, 2, &nCount, value);// (unsigned char *)&KMem.DT[nDataAddr]);
	2035	svalue = value[0];
	2036	return svalue;
	2037	}
	2038
	2039	switch (nDataType)
	2040	{
	2041	case KLDataTypeDEC:
	2042	case KLDataTypeHEX:
	2043	return nDataAddr;
	2044	break;
	2045	case KLDataTypeWX:
	2046	if (nDataAddr >= KLDataWXCount) return 0;
	2047	return KMem.WX[nDataAddr];
	2048	break;
	2049	case KLDataTypeWY:
	2050	if (nDataAddr >= KLDataWYCount) return 0;
	2051	return KMem.WY[nDataAddr];
	2052	break;
	2053	case KLDataTypeWR:
	2054	if (nDataAddr >= KLDataWRCount) return 0;
	2055	return KMem.WR[nDataAddr];
	2056	break;
	2057	case KLDataTypeWLX:
	2058	if (nDataAddr >= KLDataWLCount) return 0;
	2059	return KMem.WLX[nDataAddr];
	2060	break;
	2061	case KLDataTypeWLY:
	2062	if (nDataAddr >= KLDataWLCount) return 0;
	2063	return KMem.WLY[nDataAddr];
	2064	break;
	2065	case KLDataTypeDT:
	2066	if (nDataAddr >= KLDataDTCount) return 0;
	2067	return (signed short)KMem.DT[nDataAddr];
	2068	break;
	2069	case KLDataTypeSDT:
	2070	if (nDataAddr >= KLDataSDTCount) return 0;
	2071	return KMem.SDT[nDataAddr];
	2072	break;
	2073	case KLDataTypeWSR:
	2074	if (nDataAddr >= KLCoilLRCount) return 0;
	2075	return KMem.WSR[nDataAddr];
	2076	break;
	2077	case KLDataTypeSV:
	2078	if (nDataAddr >= KLDataSVCount) return 0;
	2079	return KMem.SV[nDataAddr];
	2080	break;
	2081	case KLDataTypeEV:
	2082	if (nDataAddr >= KLDataEVCount) return 0;
	2083	return KMem.EV[nDataAddr];
	2084	break;
	2085	case KLDataTypeLD:
	2086	if (nDataAddr >= KLDataLDCount) return 0;
	2087	return KMem.DT[nDataAddr];
	2088	break;
	2089	case KLDataSysCfg:
	2090	if (nDataAddr >= KLCoilSRCount) return 0;
	2091	return KMem.SDT[nDataAddr];
	2092	break;
	2093	case KLDataTypeFlash:
	2094	if (nDataAddr >= KLCoilSRCount) return 0;
	2095	return KMem.SDT[nDataAddr];
	2096	break;
	2097	case KLDataTypeTest:
	2098	if (nDataAddr >= KLCoilSRCount) return 0;
	2099	return KMem.SDT[nDataAddr];
	2100	break;
	2101	}
	2102	return 0;
	2103	}
	2104
	2105
	2106	int CMTerm1Doc::SetVarData(int nDataType, int nDataAddr, int nDataValue)
	2107	{
	2108	// TODO: 在此处添加实现代码.
	2109
	2110	if (m_bSimulate) {
	2111	return myKMachine1.SetVarData(nDataType, nDataAddr, nDataValue);
	2112	}else
	2113	if (m_bOnline)
	2114	{
	2115	// unsigned char value[20];
	2116	unsigned short svalue[10];
	2117	svalue[0]=nDataValue;
	2118	int res = 0;
	2119	res = MyKLink1.WriteDataWord(1, nDataType, nDataAddr, 2, svalue);
	2120	return res;
	2121	}
	2122
	2123	switch (nDataType)
	2124	{
	2125	// case KLDataTypeDEC:
	2126	// case KLDataTypeHEX:
	2127	// break;
	2128	case KLDataTypeWX:
	2129	if (nDataAddr >= KLDataWXCount) return 0;
	2130	KMem.WX[nDataAddr] = nDataValue;
	2131	break;
	2132	case KLDataTypeWY:
	2133	if (nDataAddr >= KLDataWYCount) return 0;
	2134	KMem.WY[nDataAddr] = nDataValue;
	2135	break;
	2136	case KLDataTypeWR:
	2137	if (nDataAddr >= KLDataWRCount) return 0;
	2138	KMem.WR[nDataAddr] = nDataValue;
	2139	break;
	2140	case KLDataTypeWLX:
	2141	if (nDataAddr >= KLDataWLCount) return 0;
	2142	KMem.WLX[nDataAddr] = nDataValue;
	2143	break;
	2144	case KLDataTypeWLY:
	2145	if (nDataAddr >= KLDataWLCount) return 0;
	2146	KMem.WLY[nDataAddr] = nDataValue;
	2147	break;
	2148	case KLDataTypeDT:
	2149	if (nDataAddr >= KLDataDTCount) return 0;
	2150	KMem.DT[nDataAddr] = nDataValue;
	2151	break;
	2152	case KLDataTypeSDT:
	2153	if (nDataAddr >= KLDataSDTCount) return 0;
	2154	KMem.SDT[nDataAddr] = nDataValue;
	2155	break;
	2156	case KLDataTypeWSR:
	2157	if (nDataAddr >= KLCoilLRCount) return 0;
	2158	KMem.WSR[nDataAddr] = nDataValue;
	2159	break;
	2160	case KLDataTypeSV:
	2161	if (nDataAddr >= KLDataSVCount) return 0;
	2162	KMem.SV[nDataAddr] = nDataValue;
	2163	break;
	2164	case KLDataTypeEV:
	2165	if (nDataAddr >= KLDataEVCount) return 0;
	2166	KMem.EV[nDataAddr] = nDataValue;
	2167	break;
	2168	case KLDataTypeLD:
	2169	if (nDataAddr >= KLDataLDCount) return 0;
	2170	KMem.DT[nDataAddr] = nDataValue;
	2171	break;
	2172	case KLDataSysCfg:
	2173	if (nDataAddr >= KLCoilSRCount) return 0;
	2174	KMem.SDT[nDataAddr] = nDataValue;
	2175	break;
	2176	case KLDataTypeFlash:
	2177	if (nDataAddr >= KLCoilSRCount) return 0;
	2178	KMem.SDT[nDataAddr] = nDataValue;
	2179	break;
	2180	case KLDataTypeTest:
	2181	if (nDataAddr >= KLCoilSRCount) return 0;
	2182	KMem.SDT[nDataAddr] = nDataValue;
	2183	break;
	2184	}
	2185
	2186	return 0;
	2187	}
	2188
	2189
	2190
	2191	int CMTerm1Doc::AddMonitorCoil(int nCoilType, int nCoilAddr, int nCount)
	2192	{
	2193	// TODO: 在此处添加实现代码.
	2194	return 0;
	2195	}
	2196
	2197
	2198	int CMTerm1Doc::AddMonitorData(int nDataType, int nDataAddr, int nDataCount)
	2199	{
	2200	// TODO: 在此处添加实现代码.
	2201	return 0;
	2202	}
	2203
	2204
	2205	int CMTerm1Doc::ClearMonitor()
	2206	{
	2207	// TODO: 在此处添加实现代码.
	2208	return 0;
	2209	}
	2210
	2211
	2212	int CMTerm1Doc::DoPLCMonitor()
	2213	{
	2214	// TODO: 在此处添加实现代码.
	2215	CString s1;
	2216	if (m_bSimulate) {
	2217	int nDataType = MyKLink1.KLDataTypeWX;
	2218	int nDataAddr = 0;
	2219	int nDataCount = 4;
	2220	// int res;
	2221	for (int i = 0; i < nDataCount; i++) {
	2222	KMem.WX[i] = myKMachine1.KMem.WX[i];
	2223	}
	2224
	2225	nDataType = MyKLink1.KLDataTypeWY;
	2226	nDataAddr = 0;
	2227	nDataCount = 4;
	2228	for (int i = 0; i < nDataCount; i++) {
	2229	KMem.WY[i] = myKMachine1.KMem.WY[i];
	2230	}
	2231
df0321	2232	nDataType = MyKLink1.KLDataTypeWLX;
Q	2233	nDataAddr = 0;
	2234	nDataCount = 4;
	2235	for (int i = 0; i < nDataCount; i++) {
	2236	KMem.WLX[i] = myKMachine1.KMem.WLX[i];
	2237	}
	2238
	2239	nDataType = MyKLink1.KLDataTypeWLY;
	2240	nDataAddr = 0;
	2241	nDataCount = 4;
	2242	for (int i = 0; i < nDataCount; i++) {
	2243	KMem.WLY[i] = myKMachine1.KMem.WLY[i];
	2244	}
	2245
418cb3	2246	nDataType = MyKLink1.KLDataTypeWR;
Q	2247	nDataAddr = 0;
	2248	nDataCount = 10;
	2249	for (int i = 0; i < nDataCount; i++) {
	2250	KMem.WR[i] = myKMachine1.KMem.WR[i];
	2251	}
	2252
	2253	nDataType = MyKLink1.KLDataTypeDT;
	2254	nDataAddr = 0;
	2255	nDataCount = 80;
	2256	for (int i = 0; i < nDataCount; i++) {
	2257	KMem.DT[i] = myKMachine1.KMem.DT[i];
	2258	}
	2259
	2260	nDataType = MyKLink1.KLDataTypeSV;
	2261	nDataAddr = 0;
	2262	nDataCount = 40;
	2263	for (int i = 0; i < nDataCount; i++) {
	2264	KMem.SV[i] = myKMachine1.KMem.SV[i];
	2265	}
	2266
	2267	//res = MyKLink1.ReadDataWord(1, nDataCount, nDataType, nDataAddr, KMem.SV);// (unsigned char *)&KMem.DT[nDataAddr]);
	2268
	2269	nDataType = MyKLink1.KLDataTypeEV;
	2270	nDataAddr = 0;
	2271	nDataCount = 40;
	2272	for (int i = 0; i < nDataCount; i++) {
	2273	KMem.EV[i] = myKMachine1.KMem.EV[i];
	2274	}
	2275
	2276	// res = MyKLink1.ReadDataWord(1, nDataCount, nDataType, nDataAddr, KMem.EV);// (unsigned char *)&KMem.DT[nDataAddr]);
	2277
	2278	}else if (m_bOnline)
	2279	{
	2280	int nDataType = MyKLink1.KLDataTypeWX;
	2281	int nDataAddr = 0;
	2282	int nDataCount = 4;
	2283	unsigned short nCount;
	2284	int res;
	2285	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WX);// (unsigned char *)&KMem.DT[nDataAddr]);
	2286	if (res != MyKLink1.KL_OK) {
	2287	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2288	SysLog(s1);
	2289	}
	2290
	2291	nDataType = MyKLink1.KLDataTypeWY;
	2292	nDataAddr = 0;
	2293	nDataCount = 4;
	2294	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WY);// (unsigned char *)&KMem.DT[nDataAddr]);
	2295	if (res != MyKLink1.KL_OK) {
	2296	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2297	SysLog(s1);
	2298	}
df0321	2299
Q	2300	nDataType = MyKLink1.KLDataTypeWLX;
	2301	nDataAddr = 0;
	2302	nDataCount = 4;
	2303	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WLX);// (unsigned char *)&KMem.DT[nDataAddr]);
	2304	if (res != MyKLink1.KL_OK) {
	2305	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2306	SysLog(s1);
	2307	}
	2308
	2309	nDataType = MyKLink1.KLDataTypeWLY;
	2310	nDataAddr = 0;
	2311	nDataCount = 4;
	2312	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WLY);// (unsigned char *)&KMem.DT[nDataAddr]);
	2313	if (res != MyKLink1.KL_OK) {
	2314	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2315	SysLog(s1);
	2316	}
	2317
418cb3	2318	nDataType = MyKLink1.KLDataTypeWR;
Q	2319	nDataAddr = 0;
	2320	nDataCount = 10;
	2321	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WR);// (unsigned char *)&KMem.DT[nDataAddr]);
	2322	if (res != MyKLink1.KL_OK) {
	2323	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2324	SysLog(s1);
	2325	}
	2326	nDataType = MyKLink1.KLDataTypeDT;
	2327	nDataAddr = 0;
	2328	nDataCount = 80;
	2329	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.DT);// (unsigned char *)&KMem.DT[nDataAddr]);
	2330	if (res != MyKLink1.KL_OK) {
	2331	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2332	SysLog(s1);
	2333	}
	2334	nDataType = MyKLink1.KLDataTypeSV;
	2335	nDataAddr = 0;
	2336	nDataCount = 40;
	2337	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.SV);// (unsigned char *)&KMem.DT[nDataAddr]);
	2338	if (res != MyKLink1.KL_OK) {
	2339	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2340	SysLog(s1);
	2341	}
	2342	nDataType = MyKLink1.KLDataTypeEV;
	2343	nDataAddr = 0;
	2344	nDataCount = 40;
	2345	res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.EV);// (unsigned char *)&KMem.DT[nDataAddr]);
	2346	if (res != MyKLink1.KL_OK) {
	2347	s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
	2348	SysLog(s1);
	2349	}
	2350	}
	2351
	2352	return 0;
	2353	}
	2354
	2355	void CMTerm1Doc::OnTimer(UINT_PTR nIDEvent)
	2356	{
	2357	CString s1;
	2358	// s1.Format(_T("Doc::OntTimer"));
	2359	// SysLog(s1);
	2360	if (m_bSimulate && m_bPlcRunning)
	2361	{
	2362	//ProcessPLCProg(Progs, m_nProgSteps);
	2363	myKMachine1.ProcPLC();
	2364
	2365	// update PLC Stat
	2366	}
	2367	}
	2368
	2369	void CMTerm1Doc::OnMenuStatusShow()
	2370	{
	2371	// TODO: 在此添加命令处理程序代码
	2372	CDialogStatusShow dialog1;
	2373	INT_PTR r = dialog1.DoModal();
	2374	if (r == IDOK)
	2375	{
	2376
	2377	}
	2378	}
	2379
	2380	void CMTerm1Doc::OnMenuDatetimeSet()
	2381	{
	2382	// TODO: 在此添加命令处理程序代码
	2383	CDialogDateTime dialog1;
	2384	INT_PTR r = dialog1.DoModal();
	2385	if (r == IDOK)
	2386	{
	2387
	2388	}
	2389	}
	2390
	2391	void CMTerm1Doc::OnMenuEventLog()
	2392	{
	2393	// TODO: 在此添加命令处理程序代码
	2394	CDialogEventLog dialog1;
	2395	INT_PTR r = dialog1.DoModal();
	2396	if (r == IDOK)
	2397	{
	2398
	2399	}
	2400	}