MultiTerminal1 - Gitblit

QuakeGod

2022-07-22 dd67df95a7303aee3bed65ffa935465f20ee8b32

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