MultiTerminal1 - Gitblit

zxd

2023-09-14 d34256830982fb9ea822c1e9b874c3b7fa0a614d

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