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