MultiTerminal1 - Gitblit

QuakeGod

2022-01-16 326d3e312c74726814c39c9d112faab03c4a167c

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