MultiTerminal1 - Gitblit

2024-12-24

QuakeGod

2024-12-24 61deef5cdf96cbfdd6ad45be49e80d597c00ca65

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