|
// MultiTerminal2Doc.cpp: CMTerm1Doc 类的实现
|
//
|
|
#include "pch.h"
|
#include "framework.h"
|
// SHARED_HANDLERS 可以在实现预览、缩略图和搜索筛选器句柄的
|
// ATL 项目中进行定义，并允许与该项目共享文档代码。
|
#ifndef SHARED_HANDLERS
|
#include "MTerm1.h"
|
#endif
|
|
#include "MTerm1Doc.h"
|
|
#include "MTerm1View.h"
|
#include "MTerm1LdsView.h"
|
#include "MTerm1BldView.h"
|
#include "MTerm1BnlView.h"
|
|
#include "MTerm1CoilView.h"
|
#include "MTerm1DataView.h"
|
|
#include "MTerm1CtrlView.h"
|
#include "MTerm1TestView.h"
|
#include "MTerm1ProgTxt.h"
|
#include "MTerm1CommDevView.h"
|
#include <propkey.h>
|
|
#include "DialogCommSet1.h"
|
#include "DialogStatusShow.h"
|
#include "DialogSysRegSet.h"
|
#include "DialogFactCfg.h"
|
#include "DialogDateTime.h"
|
#include "DialogEventLog.h"
|
//#include "HvSerialPort.h"
|
#include <functional>
|
|
#ifdef _DEBUG
|
#define new DEBUG_NEW
|
#endif
|
|
// CMTerm1Doc
|
CMTerm1Doc::stTypeNameDef CMTerm1Doc::CoilTypeNameDef[] =
|
{
|
{KLCoilTypeX,"X"},
|
{KLCoilTypeY,"Y"},
|
{KLCoilTypeR,"R"},
|
{KLCoilTypeLX,"LX"},
|
{KLCoilTypeLY,"LY"},
|
{KLCoilTypeLR,"LR"},
|
{KLCoilTypeSR,"SR"},
|
{KLCoilTypeC,"C"},
|
{KLCoilTypeT,"T"},
|
{KLCoilTypeP,"P"},
|
{KLCoilTypeE,"E"},
|
};
|
int CMTerm1Doc::nCoilTypeDefCount = sizeof(CMTerm1Doc::CoilTypeNameDef) / sizeof(stTypeNameDef);
|
|
CMTerm1Doc::stTypeNameDef CMTerm1Doc::DataTypeNameDef[] =
|
{
|
{KLDataTypeDEC,"K"},
|
{KLDataTypeHEX,"H"},
|
{KLDataTypeWX,"WX"},
|
{KLDataTypeWY,"WY"},
|
{KLDataTypeWR,"WR"},
|
{KLDataTypeDT,"DT"},
|
{KLDataTypeWLX,"WLX"},
|
{KLDataTypeWLY,"WLY"},
|
{KLDataTypeSDT,"SDT"},
|
{KLDataTypeWSR,"WSR"},
|
{KLDataTypeEV,"EV"},
|
{KLDataTypeSV,"SV"},
|
{KLDataTypeLD,"LD"},
|
};
|
int CMTerm1Doc::nDataTypeDefCount = sizeof(CMTerm1Doc::DataTypeNameDef) / sizeof(stTypeNameDef);
|
|
CMTerm1Doc::stOpDef CMTerm1Doc::OpDef[] =
|
{
|
{OP_NOP,"NOP",0},
|
{OP_ST,"ST",1,KLParamCoil},
|
{OP_ST_,"ST/",1,KLParamCoil},
|
{OP_AN,"AN",1,KLParamCoil},
|
{OP_AN_,"AN/",1,KLParamCoil},
|
{OP_OR,"OR",1,KLParamCoil},
|
{OP_OR_,"OR/",1,KLParamCoil},
|
{OP_NOT,"NOT"},
|
{OP_ANS,"ANS"},
|
{OP_ORS,"ORS"}
|
,
|
{OP_PSHS,"PSHS"},
|
{OP_RDS,"RDS"},
|
{OP_POPS,"POPS"},
|
{OP_OUT,"OUT",1,KLParamCoil},
|
{OP_SET,"SET",1,KLParamCoil},
|
{OP_RESET,"RESET",1,KLParamCoil},
|
{OP_DF,"DF"},
|
{OP_DF_,"DF/"},
|
{OP_ST_EQ,"ST=",2,KLParamWord,"="},
|
{OP_ST_LT,"ST<",2,KLParamWord,"<"},
|
{OP_ST_GT,"ST>",2,KLParamWord,">"},
|
{OP_ST_LE,"ST<=",2,KLParamWord,"<="},
|
{OP_ST_GE,"ST>=",2,KLParamWord,">="},
|
{OP_ST_NE,"ST<>",2,KLParamWord,"<>"},
|
{OP_AN_EQ,"AN=",2,KLParamWord,"="},
|
{OP_AN_LT,"AN<",2,KLParamWord,"<"},
|
{OP_AN_GT,"AN>",2,KLParamWord,">"},
|
{OP_AN_LE,"AN<=",2,KLParamWord,"<="},
|
{OP_AN_GE,"AN>=",2,KLParamWord,">="},
|
{OP_AN_NE,"AN<>",2,KLParamWord,"<>"},
|
{OP_OR_EQ,"OR=",2,KLParamWord,"="},
|
{OP_OR_LT,"OR<",2,KLParamWord,"<"},
|
{OP_OR_GT,"OR>",2,KLParamWord,">"},
|
{OP_OR_LE,"OR<=",2,KLParamWord,"<="},
|
{OP_OR_GE,"OR>=",2,KLParamWord,">="},
|
{OP_OR_NE,"OR<>",2,KLParamWord,"<>"},
|
|
{OP_TML,"TML",2,KLParamWord,"TML"},
|
{OP_TMR,"TMR",2,KLParamWord,"TMR"},
|
{OP_TMX,"TMX",2,KLParamWord,"TMX"},
|
{OP_TMY,"TMY",2,KLParamWord,"TMY"},
|
|
{OP_MV,"MV",2,KLParamWord,"MV"},
|
{OP_INC,"INC",1,KLParamWord,"+1"},
|
{OP_ADD2,"ADD2",2,KLParamWord,"+"},
|
{OP_ADD3,"ADD3",3,KLParamWord,"+"},
|
{OP_DEC,"DEC",1,KLParamWord,"-1"},
|
{OP_SUB2,"SUB2",2,KLParamWord,"-"},
|
{OP_SUB3,"SUB3",3,KLParamWord,"-"},
|
{OP_MUL,"MUL",3,KLParamWord,"X"},
|
{OP_DIV,"DIV",3,KLParamWord,"/"},
|
|
};
|
int CMTerm1Doc::nOpDefCount = sizeof(CMTerm1Doc::OpDef) / sizeof(stOpDef);
|
|
IMPLEMENT_DYNCREATE(CMTerm1Doc, CDocument)
|
|
BEGIN_MESSAGE_MAP(CMTerm1Doc, CDocument)
|
ON_COMMAND(ID_UPLOAD_FROM_PLC, &CMTerm1Doc::OnUploadFromPlc)
|
ON_COMMAND(ID_ONLINE, &CMTerm1Doc::OnOnline)
|
ON_UPDATE_COMMAND_UI(ID_ONLINE, &CMTerm1Doc::OnUpdateOnline)
|
ON_COMMAND(ID_OFFLINE, &CMTerm1Doc::OnOffline)
|
ON_UPDATE_COMMAND_UI(ID_OFFLINE, &CMTerm1Doc::OnUpdateOffline)
|
ON_COMMAND(ID_PLC_RUN, &CMTerm1Doc::OnPlcRun)
|
ON_UPDATE_COMMAND_UI(ID_PLC_RUN, &CMTerm1Doc::OnUpdatePlcRun)
|
ON_COMMAND(ID_DOWNLOAD_TO_PLC, &CMTerm1Doc::OnDownloadToPlc)
|
ON_UPDATE_COMMAND_UI(ID_DOWNLOAD_TO_PLC, &CMTerm1Doc::OnUpdateDownloadToPlc)
|
|
ON_COMMAND(ID_COMUNICATION_SET, &CMTerm1Doc::OnComunicationSet)
|
ON_COMMAND(ID_PLC_SYSREG_SET, &CMTerm1Doc::OnPlcSysregSet)
|
|
ON_COMMAND(ID_MENU_VIEW_LDS, &CMTerm1Doc::OnMenuViewLds)
|
ON_COMMAND(ID_MENU_VIEW_BLD, &CMTerm1Doc::OnMenuViewBld)
|
ON_COMMAND(ID_MENU_VIEW_BNL, &CMTerm1Doc::OnMenuViewBnl)
|
ON_COMMAND(ID_MENU_SHOW_CONSOLE, &CMTerm1Doc::OnMenuShowConsole)
|
|
ON_COMMAND(ID_MENU_COMM_TEST, &CMTerm1Doc::OnMenuCommTest)
|
|
|
ON_COMMAND(ID_SIMULATE, &CMTerm1Doc::OnSimulate)
|
ON_UPDATE_COMMAND_UI(ID_SIMULATE, &CMTerm1Doc::OnUpdateSimulate)
|
ON_COMMAND(ID_MENU_STATUS_SHOW, &CMTerm1Doc::OnMenuStatusShow)
|
ON_COMMAND(ID_MENU_FACT_CFG, &CMTerm1Doc::OnMenuFactCfg)
|
ON_COMMAND(ID_MENU_DATETIME_SET, &CMTerm1Doc::OnMenuDatetimeSet)
|
ON_COMMAND(ID_MENU_EVENT_LOG, &CMTerm1Doc::OnMenuEventLog)
|
END_MESSAGE_MAP()
|
|
|
// CMTerm1Doc 构造/析构
|
|
CMTerm1Doc::CMTerm1Doc() noexcept
|
{
|
// TODO: 在此添加一次性构造代码
|
|
KLink1::stCallBackFuncs callbackfuncs;
|
// callbackfuncs.OpenFunc = std::bind(&HvSerialPort::Open, &myHvSerialPort1);
|
// callbackfuncs.CloseFunc = std::bind(&HvSerialPort::Close, &myHvSerialPort1);
|
// callbackfuncs.ClearBufFunc = std::bind(&HvSerialPort::ClearBuf, &myHvSerialPort1);
|
|
// callbackfuncs.SendPkgFunc = std::bind(&HvSerialPort::Send, &myHvSerialPort1, std::placeholders::_1, std::placeholders::_2);
|
// callbackfuncs.RecvPkgFunc = std::bind(&HvSerialPort::Recv, &myHvSerialPort1, std::placeholders::_1, std::placeholders::_2);
|
|
// MyKLink1.SetCallBackFuncs(&callbackfuncs);
|
|
// StartTime = myHvSerialPort1.GetTimemS();
|
}
|
|
CMTerm1Doc::~CMTerm1Doc()
|
{
|
}
|
/*
|
int CMTerm1Doc::SendPacket(void * pBuf, int Len)
|
{
|
return myHvSerialPort1.Send((char *)pBuf, Len);
|
}
|
int CMTerm1Doc::RecvPacket(void * pBuf, int Len)
|
{
|
int j = 0;
|
j = myHvSerialPort1.Recv((char *)pBuf, Len);
|
if (j <= 0)
|
{
|
CString s1;
|
s1.Format(_T("Read %d R=%d %s"), Len, j, myHvSerialPort1.m_strResult);
|
SysLog(s1);
|
}
|
return j;
|
}
|
*/
|
|
/// <summary>
|
/// 处理新文档的创建事件
|
/// </summary>
|
/// <returns></returns>
|
BOOL CMTerm1Doc::OnNewDocument()
|
{
|
if (!CDocument::OnNewDocument())
|
{
|
return FALSE;
|
|
}
|
|
// TODO: 在此添加重新初始化代码
|
// (SDI 文档将重用该文档)
|
//LoadFromFile(_T("0prog1.txt"));
|
return TRUE;
|
|
}
|
|
/// <summary>
|
/// 处理打开的文档
|
/// </summary>
|
/// <param name="lpszPathName">指向要打开的文件路径的指针</param>
|
/// <returns></returns>
|
BOOL CMTerm1Doc::OnOpenDocument(LPCTSTR lpszPathName)
|
{
|
// if (!CDocument::OnOpenDocument(lpszPathName))
|
// return FALSE;
|
|
CString s1;//日志信息
|
s1.Format(_T("OnOpenDocument %s"), lpszPathName);
|
SysLog(s1);
|
|
//加载文件内容
|
LoadFromFile(lpszPathName);
|
return TRUE;
|
}
|
|
/// <summary>
|
/// 处理保存文档的事件
|
/// </summary>
|
/// <param name="lpszPathName">指向要打开的文件路径的指针</param>
|
/// <returns></returns>
|
BOOL CMTerm1Doc::OnSaveDocument(LPCTSTR lpszPathName)
|
{
|
// TODO: 在此添加专用代码和/或调用基类
|
CString s1;
|
s1.Format(_T("OnSaveDocument %s"), lpszPathName);
|
SysLog(s1);
|
|
//0912-zxd-Modify
|
int result = SaveToFile(lpszPathName);
|
return result == 1 ? TRUE : FALSE;
|
// return CDocument::OnSaveDocument(lpszPathName);
|
}
|
|
/// <summary>
|
/// 处理关闭文档的事件
|
/// </summary>
|
void CMTerm1Doc::OnCloseDocument()
|
{
|
// TODO: 在此添加专用代码和/或调用基类
|
// CString s1;
|
// s1.Format(_T("OnCloseDocument %s"));
|
// SysLog(s1);
|
CDocument::OnCloseDocument();
|
}
|
|
/// <summary>
|
/// CMTerm1Doc 序列化
|
/// </summary>
|
/// <param name="ar"></param>
|
void CMTerm1Doc::Serialize(CArchive& ar)
|
{
|
CString s1;
|
if (ar.IsStoring())
|
{
|
// TODO: 在此添加存储代码
|
ar.GetFile();
|
s1.Format(_T("Serialize Saving"));
|
SysLog(s1);
|
}
|
else
|
{
|
// TODO: 在此添加加载代码
|
s1.Format(_T("Serialize Loading"));
|
SysLog(s1);
|
}
|
}
|
|
#ifdef SHARED_HANDLERS
|
|
// 缩略图的支持
|
void CMTerm1Doc::OnDrawThumbnail(CDC& dc, LPRECT lprcBounds)
|
{
|
// 修改此代码以绘制文档数据
|
dc.FillSolidRect(lprcBounds, RGB(255, 255, 255));
|
|
CString strText = _T("TODO: implement thumbnail drawing here");
|
LOGFONT lf;
|
|
CFont* pDefaultGUIFont = CFont::FromHandle((HFONT) GetStockObject(DEFAULT_GUI_FONT));
|
pDefaultGUIFont->GetLogFont(&lf);
|
lf.lfHeight = 36;
|
|
CFont fontDraw;
|
fontDraw.CreateFontIndirect(&lf);
|
|
CFont* pOldFont = dc.SelectObject(&fontDraw);
|
dc.DrawText(strText, lprcBounds, DT_CENTER | DT_WORDBREAK);
|
dc.SelectObject(pOldFont);
|
}
|
|
// 搜索处理程序的支持
|
void CMTerm1Doc::InitializeSearchContent()
|
{
|
CString strSearchContent;
|
// 从文档数据设置搜索内容。
|
// 内容部分应由“;”分隔
|
|
// 例如: strSearchContent = _T("point;rectangle;circle;ole object;")；
|
SetSearchContent(strSearchContent);
|
}
|
|
/// <summary>
|
/// 设置文档的搜索内容
|
/// </summary>
|
/// <param name="value">要搜索内容的字符串值</param>
|
void CMTerm1Doc::SetSearchContent(const CString& value)
|
{
|
if (value.IsEmpty())
|
{
|
RemoveChunk(PKEY_Search_Contents.fmtid, PKEY_Search_Contents.pid);
|
}
|
else
|
{
|
CMFCFilterChunkValueImpl *pChunk = nullptr;
|
ATLTRY(pChunk = new CMFCFilterChunkValueImpl);
|
if (pChunk != nullptr)
|
{
|
pChunk->SetTextValue(PKEY_Search_Contents, value, CHUNK_TEXT);
|
SetChunkValue(pChunk);
|
}
|
}
|
}
|
|
#endif // SHARED_HANDLERS
|
|
// CMTerm1Doc 诊断
|
|
#ifdef _DEBUG
|
/// <summary>
|
/// 验证对象的有效性
|
/// </summary>
|
void CMTerm1Doc::AssertValid() const
|
{
|
CDocument::AssertValid();
|
}
|
/// <summary>
|
/// 诊断信息的输出
|
/// </summary>
|
/// <param name="dc"></param>
|
void CMTerm1Doc::Dump(CDumpContext& dc) const
|
{
|
CDocument::Dump(dc);
|
}
|
#endif //_DEBUG
|
|
|
/// <summary>
|
/// 加载指定的文件
|
/// </summary>
|
/// <param name="sFilePathName">需要加载的文件的路径名</param>
|
/// <returns></returns>
|
int CMTerm1Doc::LoadFromFile(CString sFilePathName)
|
{
|
CFile file1;//打开指定的文件
|
CFileException e;
|
bool r = file1.Open(sFilePathName, CFile::modeRead, &e);
|
if (r)
|
{
|
int l = (int)file1.GetLength();
|
CStringA s1A;
|
file1.Read(s1A.GetBuffer(l + 2048), l);
|
file1.Close();
|
s1A.ReleaseBuffer(l);
|
|
TransFileToProg(s1A);//文件内容转换为Prog格式
|
UpdateAllViews(NULL);//更新所有的视图，以反映新加载的内容
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 保存文件
|
/// </summary>
|
/// <param name="sFilePathName">需要保存的文件的路径名</param>
|
/// <returns></returns>
|
int CMTerm1Doc::SaveToFile(CString sFilePathName)
|
{
|
CString s1;
|
CFile file1;
|
CFileException e;
|
|
bool r = file1.Open(sFilePathName, CFile::modeReadWrite, &e);//读写模式打开文件
|
if (r)
|
{
|
|
CStringA s1A;
|
CStringA sSectionNameA;
|
|
//写入系统配置
|
GetSectionTxt(SectionSysCfg, sSectionNameA); //获取系统配置的文本表示
|
s1A = "[" + sSectionNameA + "]\r\n";
|
file1.Write(s1A, s1A.GetLength());//将获取到的文本内容写入文件
|
|
//写入程序
|
GetSectionTxt(SectionProg, sSectionNameA); //获取程序的文本表示
|
s1A = "[" + sSectionNameA + "]\r\n";
|
file1.Write(s1A, s1A.GetLength());//获取到的文本内容写入文件
|
|
TransToTxt(s1A);//将程序内容转换为文本格式
|
file1.Write(s1A, s1A.GetLength());//将转换后的文本内容写入文件
|
|
//写入注释
|
GetSectionTxt(SectionAnno, sSectionNameA); //获取注释的文本表示
|
s1A = "[" + sSectionNameA + "]\r\n";
|
file1.Write(s1A, s1A.GetLength());
|
//循环遍历所有注释，并将其写入文件
|
for (int i = 0; i < nCoilAnnoCount; i++)
|
{
|
if (mCoilAnnos[i].sAnno.IsEmpty()) { continue; }
|
s1 = mCoilAnnos[i].sCoilName + _T("\t") + mCoilAnnos[i].sAnno + _T("\r\n");
|
s1A = s1;
|
file1.Write(s1A, s1A.GetLength());
|
}
|
//写入触点监控列表
|
GetSectionTxt(SectionCoilList, sSectionNameA); //获取触点监控列表的文本表示
|
s1A = "[" + sSectionNameA + "]\r\n";
|
file1.Write(s1A, s1A.GetLength());
|
|
//写入数据监控列表
|
GetSectionTxt(SectionDataList, sSectionNameA); //获取数据监控列表的文本表示
|
s1A = "[" + sSectionNameA + "]\r\n";
|
file1.Write(s1A, s1A.GetLength());
|
|
file1.Close();
|
return 1;
|
}
|
else//文件打开失败
|
{
|
return 0;
|
}
|
}
|
|
/// <summary>
|
/// 根据文本匹配类型的Key并返回
|
/// </summary>
|
/// <param name="txt"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::TxtToSection(CStringA txt)
|
{
|
for (int i = 0; i < nSectionDefCount; i++) {
|
if (SectionDef[i].SectionName == txt) {
|
return SectionDef[i].nSectionType;
|
}
|
}
|
return SectionNone;
|
}
|
|
/// <summary>
|
/// 根据Key匹配类型的文本，通过txt传递，返回查询执行结果
|
/// </summary>
|
/// <param name="nSectionType"></param>
|
/// <param name="txt"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::GetSectionTxt(int nSectionType, CStringA & txt)
|
{
|
for (int i = 0; i < nSectionDefCount; i++) {
|
if (SectionDef[i].nSectionType == nSectionType) {
|
txt = SectionDef[i].SectionName;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="nSectionType">Section类型</param>
|
/// <param name="nSectionLine">行号</param>
|
/// <param name="nSectionLines">行数</param>
|
/// <returns></returns>
|
int CMTerm1Doc::GetSectionPos(int nSectionType, int * nSectionLine, int * nSectionLines)
|
{
|
for (int i = 0; i < nSectionCount; i++) {
|
if (Sections[i].nSectionType == nSectionType) {
|
*nSectionLine = Sections[i].nSectionLineNo;
|
*nSectionLines = Sections[i].nLines;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 文本表示的操作转换为其相应的操作类型、参数数量和参数类型
|
/// </summary>
|
/// <param name="optxt">表示操作的字符串</param>
|
/// <param name="ParamCount">返回与给定操作相对应的参数数量</param>
|
/// <param name="ParamType">返回与给定操作相对应的参数类型</param>
|
/// <returns>-1：匹配失败</returns>
|
int CMTerm1Doc::TxtToOp(CStringA optxt, int* ParamCount, int* ParamType)
|
{
|
for (int i = 0; i < nOpDefCount; i++){
|
if (OpDef[i].OpTxt == optxt) {
|
*ParamCount = OpDef[i].nParamCount;
|
*ParamType = OpDef[i].nParamType;
|
return OpDef[i].nOpType1;
|
}
|
}
|
return -1;
|
}
|
|
/// <summary>
|
/// 操作类型转换为其相应的文本表示
|
/// </summary>
|
/// <param name="nOp">操作类型</param>
|
/// <param name="OpTxt">操作文本</param>
|
/// <returns></returns>
|
int CMTerm1Doc::OpToTxt(int nOp, CStringA & OpTxt)
|
{
|
for (int i = 0; i < nOpDefCount; i++){
|
if (OpDef[i].nOpType1 == nOp) {
|
OpTxt = OpDef[i].OpTxt;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 操作类型转换为其相应的前台展示文本
|
/// </summary>
|
/// <param name="nOp">操作类型</param>
|
/// <param name="OpShowTxt">前台展示文本</param>
|
/// <returns></returns>
|
int CMTerm1Doc::OpToShowTxt(int nOp, CStringA & OpShowTxt)
|
{
|
for (int i = 0; i < nOpDefCount; i++) {
|
if (OpDef[i].nOpType1 == nOp) {
|
OpShowTxt = OpDef[i].ShowTxt;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 文本转线圈类型
|
/// </summary>
|
/// <param name="Typetxt">线圈类型</param>
|
/// <param name="nCoilType">线圈类型</param>
|
/// <param name="nCoilAddr">线圈地址</param>
|
/// <returns></returns>
|
int CMTerm1Doc::TxtToCoilType(CStringA Typetxt, int* nCoilType, int* nCoilAddr)
|
{
|
Typetxt.MakeUpper();
|
for (int i = 0; i < nCoilTypeDefCount; i++)
|
{
|
if (Typetxt.Find( CoilTypeNameDef[i].TypeTxt)==0) {
|
*nCoilType = CoilTypeNameDef[i].nType;
|
*nCoilAddr = atoi(Typetxt.Mid(CoilTypeNameDef[i].TypeTxt.GetLength()));
|
return true;
|
return CoilTypeNameDef[i].nType;
|
}
|
}
|
return false;;
|
}
|
|
/// <summary>
|
/// 线圈类型转文本
|
/// </summary>
|
/// <param name="nType">线圈类型</param>
|
/// <param name="typeTxt">线圈文本</param>
|
/// <returns></returns>
|
int CMTerm1Doc::CoilTypeToTxt(int nType, CStringA & typeTxt)
|
{
|
for (int i = 0; i < nCoilTypeDefCount; i++)
|
{
|
if (CoilTypeNameDef[i].nType == nType){
|
typeTxt = CoilTypeNameDef[i].TypeTxt;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="Typetxt"></param>
|
/// <param name="nDataType"></param>
|
/// <param name="nDataAddr"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::TxtToDataType(CStringA Typetxt, int * nDataType, int* nDataAddr)
|
{
|
Typetxt.MakeUpper();
|
for (int i = 0; i < nDataTypeDefCount; i++)
|
{
|
if (Typetxt.Find(DataTypeNameDef[i].TypeTxt) == 0) {
|
*nDataType = DataTypeNameDef[i].nType;
|
*nDataAddr = atoi(Typetxt.Mid(DataTypeNameDef[i].TypeTxt.GetLength()));
|
return true;
|
}
|
}
|
*nDataType = KLDataTypeDEC;
|
*nDataAddr = atoi(Typetxt);
|
return false;
|
}
|
|
|
/// <summary>
|
///
|
/// </summary>
|
/// <param name="nType"></param>
|
/// <param name="typeTxt"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::DataTypeToTxt(int nType, CStringA & typeTxt)
|
{
|
for (int i = 0; i < nDataTypeDefCount; i++)
|
{
|
if (DataTypeNameDef[i].nType == nType) {
|
typeTxt = DataTypeNameDef[i].TypeTxt;
|
return true;
|
}
|
}
|
return false;
|
}
|
|
/// <summary>
|
/// 获取与特定类型和地址相对应的线圈注释
|
/// </summary>
|
/// <param name="nType"></param>
|
/// <param name="nAddr"></param>
|
/// <param name="sAnno"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::GetAnno(unsigned short nType, unsigned short nAddr, CString & sAnno)
|
{
|
// TODO: 在此处添加实现代码.
|
// 二分法 查找。
|
// map.
|
for (int i = 0; i < nCoilAnnoCount; i++) {
|
if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
|
sAnno = mCoilAnnos[i].sAnno;
|
return 1;
|
}
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 设置或更新特定线圈的注释
|
/// </summary>
|
/// <param name="sCoilName"></param>
|
/// <param name="sAnno"></param>
|
/// <returns></returns>
|
int CMTerm1Doc::SetAnno(CString sCoilName, CString sAnno)
|
{
|
// TODO: 在此处添加实现代码.
|
// 二分法 查找。
|
// map.
|
int bValid = 0;
|
int nType = 0, nAddr = 0;
|
CStringA s1A;
|
s1A = sCoilName;
|
if (TxtToCoilType(s1A, &nType, &nAddr) || TxtToDataType(s1A, &nType, &nAddr)) {
|
bValid = 1;
|
}
|
if (!bValid) return false;
|
|
for (int i = 0; i < nCoilAnnoCount; i++) {
|
if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
|
mCoilAnnos[i].sAnno = sAnno;
|
return 1;
|
}
|
}
|
mCoilAnnos[nCoilAnnoCount].nType = nType;
|
mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
|
mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
|
mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
|
nCoilAnnoCount++;
|
return 2;
|
}
|
|
/// <summary>
|
/// 直接使用类型和地址参数来设置或更新特定线圈的注释
|
/// </summary>
|
/// <param name="nType">类型</param>
|
/// <param name="nAddr">地址</param>
|
/// <param name="sCoilName">线圈名称</param>
|
/// <param name="sAnno">线圈注释</param>
|
/// <returns></returns>
|
int CMTerm1Doc::SetAnno(unsigned short nType, unsigned short nAddr, CString sCoilName, CString sAnno)
|
{
|
// TODO: 在此处添加实现代码.
|
// 二分法? 查找。
|
// map.
|
for (int i = 0; i < nCoilAnnoCount; i++) {
|
if (mCoilAnnos[i].nType == nType && mCoilAnnos[i].nAddr == nAddr) {
|
mCoilAnnos[i].sAnno = sAnno;
|
return 1;
|
}
|
}
|
mCoilAnnos[nCoilAnnoCount].nType = nType;
|
mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
|
mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
|
mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
|
nCoilAnnoCount++;
|
return 0;
|
}
|
|
/// <summary>
|
/// 转换文本行为Prog格式
|
/// </summary>
|
/// <param name="txtLines">文本行集合</param>
|
/// <param name="StartLine">开始行</param>
|
/// <param name="ProgLines">程序行</param>
|
/// <returns></returns>
|
int CMTerm1Doc::TransLinesToProg(const CStringArray & txtLines, int StartLine , int ProgLines)
|
{
|
CString s1;
|
int txtLineCount = (int)txtLines.GetSize();
|
|
//读取程序 章节
|
int nProgStartLine = 0;
|
int nProgLines = 0;
|
|
nProgStartLine = StartLine;
|
if (ProgLines == -1) nProgLines = txtLineCount;
|
else nProgLines = ProgLines;
|
int nProgPos = 0;
|
|
//逐行读取并转化
|
for (int i = nProgStartLine; i < nProgStartLine + nProgLines; i++)
|
{
|
CString sLine;
|
sLine = txtLines.GetAt(i);
|
//清除空格和制表符
|
sLine.Trim();
|
sLine.Replace(_T("\t"), _T(" "));
|
sLine.Replace(_T(" "), _T(" "));
|
sLine.Replace(_T(" "), _T(" "));
|
|
//使用空格分隔字符串，并将其存储在 strarr2 数组中
|
CStringArray strarr2;
|
DivideStringToArray(sLine, _T(" "), strarr2);
|
|
if (strarr2.GetSize() == 0)
|
{
|
continue;
|
}
|
|
//从数组中提取指令，并将其转换为大写形式
|
CString sCmd;
|
sCmd = strarr2.GetAt(0);
|
sCmd.MakeUpper();
|
|
//使用 TxtToOp 函数将指令文本转换为操作类型。
|
CStringA s1A;
|
s1A = sCmd;
|
int nParamCount, nParamType;
|
int nType, nAddr;
|
int k = TxtToOp(s1A, &nParamCount, &nParamType);
|
|
if (k >= 0)
|
{
|
//根据参数类型，使用 TxtToCoilType 或 TxtToDataType 函数将参数文本转换为参数类型和地址
|
Progs[nProgPos].nOpType1 = k;
|
for (int j = 0; j < 3 && j < nParamCount && j < strarr2.GetSize() - 1; j++)
|
{
|
s1A = strarr2.GetAt(j + 1);
|
s1A.MakeUpper();
|
Progs[nProgPos].Params[j].sParamStr = s1A;
|
if (nParamType == KLParamCoil) {
|
TxtToCoilType(s1A, &nType, &nAddr);
|
Progs[nProgPos].Params[j].nParamType = nType;
|
Progs[nProgPos].Params[j].nParamAddr = nAddr;
|
}
|
else if (nParamType == KLParamWord) {
|
TxtToDataType(s1A, &nType, &nAddr);
|
Progs[nProgPos].Params[j].nParamType = nType;
|
Progs[nProgPos].Params[j].nParamAddr = nAddr;
|
}
|
else {
|
|
}
|
}
|
Progs[nProgPos].nParamCount = (int)strarr2.GetSize() - 1;
|
Progs[nProgPos].PairTo = 0;
|
nProgPos++;
|
}
|
}
|
|
|
m_nProgSteps = nProgPos;
|
// 先扫描分开的程序段
|
int stpos[100] = { 0 };
|
int nSts = 0;
|
int StackDeeps[512] = { 0 };
|
int nCurStackDeep = 0;
|
// 查找匹配指令和地址
|
s1.Format(_T("DOC::Trans to Prog "));
|
SysLog(s1);
|
|
//匹配指令（错误，此处匹配指令使用数字
|
for (int i = 0; i < m_nProgSteps; i++)
|
{
|
int nOpType = Progs[i].nOpType1;
|
int nParamCount = Progs[i].nParamCount;
|
switch (Progs[i].nOpType1)
|
{
|
case OP_ST:
|
case OP_ST_:
|
case OP_ST_EQ:
|
case OP_ST_NE:
|
case OP_ST_LT:
|
case OP_ST_GT:
|
case OP_ST_LE:
|
case OP_ST_GE:
|
|
nCurStackDeep++;
|
s1.Format(_T("St Deep %d pos %d "), nCurStackDeep, i);
|
//SysLog(s1);
|
stpos[nSts] = i;
|
nSts++;
|
break;
|
case OP_ANS:
|
case OP_ORS:
|
Progs[stpos[nSts - 1]].PairTo = i; // CMTerm1Doc::OP_ANS;
|
s1.Format(_T("Pair deep %d %d -- %d"), nCurStackDeep, stpos[nSts - 1], i);
|
//SysLog(s1);
|
nCurStackDeep--;
|
nSts--;
|
break;
|
case OP_PSHS:
|
break;
|
case OP_POPS:
|
break;
|
break;
|
default:
|
break;
|
}
|
StackDeeps[i] = nCurStackDeep;
|
}
|
|
s1.Format(_T("Remaining STs %d"), nSts);
|
SysLog(s1);
|
|
for (int i = 0; i < nSts; i++) {
|
s1.Format(_T("[%d] %d "), i, stpos[i]);
|
SysLog(s1);
|
}
|
s1.Format(_T("Pairs"));
|
SysLog(s1);
|
for (int i = 0; i < m_nProgSteps; i++) {
|
int nPairTo = Progs[i].PairTo;
|
if (nPairTo > 0) {
|
s1.Format(_T("%d -- %d type:%d"), i, nPairTo, Progs[nPairTo].nOpType1);
|
SysLog(s1);
|
}
|
}
|
TransProgToBin();
|
return 0;
|
}
|
|
int CMTerm1Doc::TransTxtToProg(CStringA ProgTxtA)
|
{
|
CString s1;
|
CString sProg;
|
sProg = ProgTxtA;
|
CStringArray txtLines;
|
sProg.Replace(_T("\r\n"), _T("\n"));
|
sProg.Replace(_T("\r"), _T("\n"));
|
|
DivideStringToArray(sProg, _T("\n"), txtLines);
|
|
TransLinesToProg(txtLines);
|
|
return 0;
|
}
|
|
int CMTerm1Doc::ReadAnnoFromTxt(CStringA AnnoTxtA)
|
{
|
// 读取注释章节
|
CString s1;
|
CString sProg;
|
sProg = AnnoTxtA;
|
CStringArray txtLines;
|
sProg.Replace(_T("\r\n"), _T("\n"));
|
sProg.Replace(_T("\r"), _T("\n"));
|
|
DivideStringToArray(sProg, _T("\n"), txtLines);
|
|
|
int txtLineCount = (int)txtLines.GetSize();
|
|
nCoilAnnoCount = 0;
|
int nAnnoSectionLine = 0;
|
int nAnnoStartLine = 0;
|
int nAnnoLines = 0;
|
|
int bAnnoSection = GetSectionPos(SectionAnno, &nAnnoSectionLine, &nAnnoLines);
|
if (bAnnoSection) { nAnnoStartLine = nAnnoSectionLine + 1; }
|
|
for (int i = nAnnoStartLine; i < nAnnoStartLine + nAnnoLines; i++)
|
{
|
CString sLine;
|
sLine = txtLines.GetAt(i);
|
sLine.Trim();
|
int DivPos = sLine.Find(_T("\t"));
|
if (DivPos < 1) continue;
|
|
CString sCoilName;
|
sCoilName = sLine.Left(DivPos);
|
sCoilName.MakeUpper();
|
CString sAnno;
|
sAnno = sLine.Mid(DivPos + 1);
|
|
// SetAnno(sCoilName, sAnno);
|
|
CStringA s1A;
|
s1A = sCoilName;
|
int nParamType, nAddr;
|
TxtToCoilType(s1A, &nParamType, &nAddr) || TxtToDataType(s1A, &nParamType, &nAddr);
|
|
mCoilAnnos[nCoilAnnoCount].nType = nParamType;
|
mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
|
mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
|
mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
|
|
nCoilAnnoCount++;
|
}
|
return 0;
|
}
|
|
/// <summary>
|
/// 解析文件为梯形图
|
/// </summary>
|
/// <param name="ProgTxtA">文本</param>
|
/// <returns></returns>
|
int CMTerm1Doc::TransFileToProg(CStringA ProgTxtA)
|
{
|
CString s1;
|
CString sProg;
|
sProg = ProgTxtA;
|
CStringArray txtLines;
|
sProg.Replace(_T("\r\n"), _T("\n"));
|
sProg.Replace(_T("\r"), _T("\n"));
|
|
//分割文本字符串
|
DivideStringToArray(sProg, _T("\n"), txtLines);
|
|
nSectionCount = 0;
|
int nCurSection = 0;
|
int txtLineCount = (int)txtLines.GetSize();
|
for (int i = 0; i < txtLineCount; i++)
|
{
|
CString sLine;
|
sLine = txtLines.GetAt(i);
|
sLine.Trim();
|
int nRightBracket;
|
if (sLine.Find(_T("[")) == 0 && (nRightBracket = sLine.Find(_T("]"))) > 1)
|
{ //找到 [ ] 标志
|
if (nSectionCount > 0)
|
{
|
Sections[nSectionCount - 1].nLines = i - Sections[nSectionCount - 1].nSectionLineNo - 1;
|
s1.Format(_T("- Line %d Section %d Ends, %d Lines"), i, nSectionCount -1 ,Sections[nSectionCount - 1].nLines);
|
SysLog(s1);
|
}
|
CString sSectionName;
|
CStringA sSectionNameA;
|
sSectionName = sLine.Mid(1, nRightBracket - 1);
|
sSectionNameA = sSectionName;
|
int theSection = TxtToSection(sSectionNameA);
|
|
s1.Format(_T("+ Line %d Section %d : [%s] type:%d "), i + 1, nSectionCount, sSectionName, theSection);
|
SysLog(s1);
|
Sections[nSectionCount].nSectionType = theSection;
|
Sections[nSectionCount].nSectionLineNo = i;
|
nSectionCount++;
|
}
|
}
|
if (nSectionCount > 0) {
|
Sections[nSectionCount - 1].nLines = txtLineCount - Sections[nSectionCount - 1].nSectionLineNo - 1;
|
s1.Format(_T("Section Ends at Line %d Lines %d "), txtLineCount, Sections[nSectionCount - 1].nLines);
|
SysLog(s1);
|
}
|
|
//读取程序 章节
|
int nProgSectionLine = 0;
|
int nProgStartLine = 0;
|
int nProgLines = 0;
|
|
int bProgSection = GetSectionPos(SectionProg, &nProgSectionLine, &nProgLines);
|
if (bProgSection) { nProgStartLine = nProgSectionLine + 1; }
|
else { nProgStartLine = 0; nProgLines = txtLineCount; }
|
|
TransLinesToProg(txtLines,nProgStartLine,nProgLines);
|
|
// 读取注释章节
|
nCoilAnnoCount = 0;
|
int nAnnoSectionLine = 0;
|
int nAnnoStartLine = 0;
|
int nAnnoLines = 0;
|
|
int bAnnoSection = GetSectionPos(SectionAnno, &nAnnoSectionLine, &nAnnoLines);
|
if (bAnnoSection)
|
{
|
nAnnoStartLine = nAnnoSectionLine + 1;
|
}
|
|
for (int i = nAnnoStartLine; i < nAnnoStartLine + nAnnoLines; i++)
|
{
|
CString sLine;
|
sLine = txtLines.GetAt(i);
|
sLine.Trim();
|
int DivPos = sLine.Find(_T("\t"));
|
if (DivPos < 1) continue;
|
|
CString sCoilName;
|
sCoilName = sLine.Left(DivPos);
|
sCoilName.MakeUpper();
|
CString sAnno;
|
sAnno = sLine.Mid(DivPos + 1);
|
|
// SetAnno(sCoilName, sAnno);
|
|
CStringA s1A;
|
s1A = sCoilName;
|
int nParamType,nAddr;
|
TxtToCoilType(s1A, &nParamType,&nAddr)
|
||TxtToDataType(s1A, &nParamType, &nAddr);
|
|
mCoilAnnos[nCoilAnnoCount].nType = nParamType;
|
mCoilAnnos[nCoilAnnoCount].nAddr = nAddr;
|
mCoilAnnos[nCoilAnnoCount].sCoilName = sCoilName;
|
mCoilAnnos[nCoilAnnoCount].sAnno = sAnno;
|
|
nCoilAnnoCount++;
|
}
|
|
return 0;
|
}
|
|
//文本段在此处组装
|
int CMTerm1Doc::TransToTxt(CStringA &ProgTxt)
|
{
|
CStringA s1, s2;
|
for (int i = 0; i < m_nProgSteps; i++)
|
{
|
OpToTxt(Progs[i].nOpType1,s1);
|
if (Progs[i].nParamCount > 0) { s1.Append("\t" + Progs[i].Params[0].sParamStr); }
|
if (Progs[i].nParamCount > 1) { s1.Append("\t" + Progs[i].Params[1].sParamStr); }
|
if (Progs[i].nParamCount > 2) { s1.Append("\t" + Progs[i].Params[2].sParamStr); }
|
s1.Append("\r\n");
|
s2 += s1;
|
}
|
ProgTxt = s2;
|
return 0;
|
}
|
|
int CMTerm1Doc::TransProgToBin()
|
{
|
CString s1;
|
stBinProg15* pBinProg15;
|
stBinProg2 * pBinProg2;
|
stBinProg3 * pBinProg3;
|
nBinProgSteps = 0;
|
for (int i = 0; i < m_nProgSteps; i++)
|
{
|
int nOpType = Progs[i].nOpType1;
|
Progs[i].nBinStep = nBinProgSteps;
|
int nParamType1 = Progs[i].Params[0].nParamType;
|
int nParamAddr1 = Progs[i].Params[0].nParamAddr;
|
int nParamType2, nParamAddr2;
|
int nParamType3, nParamAddr3;
|
if (Progs[i].nParamCount > 1) {
|
nParamType2 = Progs[i].Params[1].nParamType;
|
nParamAddr2 = Progs[i].Params[1].nParamAddr;
|
}
|
if (Progs[i].nParamCount > 2) {
|
nParamType3 = Progs[i].Params[2].nParamType;
|
nParamAddr3 = Progs[i].Params[2].nParamAddr;
|
}
|
switch (nOpType)
|
{
|
case OP_NONE:
|
break;
|
//case OP_NOP:
|
break;
|
//无参数 指令
|
case OP_NOT:
|
case OP_ANS:
|
case OP_ORS:
|
case OP_PSHS:
|
case OP_RDS:
|
case OP_POPS:
|
case OP_DF:
|
case OP_DF_:
|
BinProgs[nBinProgSteps].nOp = nOpType;
|
nBinProgSteps += 1;
|
break;
|
// 1参数指令
|
case OP_ST:
|
case OP_ST_:
|
case OP_AN:
|
case OP_AN_:
|
case OP_OR:
|
case OP_OR_:
|
BinProgs[nBinProgSteps].nOp = nOpType;
|
BinProgs[nBinProgSteps].nParamType = nParamType1;
|
BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
|
nBinProgSteps += 1;
|
break;
|
// 1 参数 输出
|
case OP_OUT:
|
case OP_SET:
|
case OP_RESET:
|
BinProgs[nBinProgSteps].nOp = nOpType;
|
BinProgs[nBinProgSteps].nParamType = nParamType1;
|
BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
|
nBinProgSteps += 1;
|
break;
|
|
// 比较指令
|
case OP_ST_EQ:
|
case OP_ST_NE:
|
case OP_ST_LT:
|
case OP_ST_GT:
|
case OP_ST_LE:
|
case OP_ST_GE:
|
case OP_AN_EQ:
|
case OP_AN_NE:
|
case OP_AN_LT:
|
case OP_AN_GT:
|
case OP_AN_LE:
|
case OP_AN_GE:
|
case OP_OR_EQ:
|
case OP_OR_NE:
|
case OP_OR_LT:
|
case OP_OR_GT:
|
case OP_OR_LE:
|
case OP_OR_GE:
|
pBinProg2 = (stBinProg2 *)(&BinProgs[nBinProgSteps]);
|
BinProgs[nBinProgSteps].nOp = nOpType;
|
BinProgs[nBinProgSteps].nParamType = 0;
|
BinProgs[nBinProgSteps].nParamAddr = nParamAddr1;
|
BinProgs[nBinProgSteps+1].nOp = nParamType1;
|
BinProgs[nBinProgSteps+1].nParamType = nParamType2;
|
BinProgs[nBinProgSteps+1].nParamAddr = nParamAddr2;
|
nBinProgSteps += 2;
|
break;
|
|
// 定时器
|
case OP_TML:
|
case OP_TMR:
|
case OP_TMX:
|
case OP_TMY:
|
pBinProg15 = (stBinProg15 *)(&BinProgs[nBinProgSteps]);
|
|
BinProgs[nBinProgSteps].nOp = nOpType;
|
BinProgs[nBinProgSteps].nParamType = nParamAddr1;
|
BinProgs[nBinProgSteps].nParamAddr = nParamAddr2;
|
BinProgs[nBinProgSteps + 1].nOp = nParamType2;
|
BinProgs[nBinProgSteps + 1].nParamType = 0;
|
BinProgs[nBinProgSteps + 1].nParamAddr = 0;
|
pBinProg15->nOpNum = Progs[i].Params[0].nParamAddr;
|
|
nBinProgSteps += 2;
|
break;
|
// 1 参数高级指令
|
case OP_INC:
|
case OP_DEC:
|
pBinProg15 = (stBinProg15 *)(&BinProgs[nBinProgSteps]);
|
pBinProg15->nOp = nOpType;
|
pBinProg15->nOpNum = 0;
|
pBinProg15->nParamType1 = nParamType1;
|
pBinProg15->nParamAddr1 = nParamAddr1;
|
pBinProg15->resvr1 = 0;
|
pBinProg15->resvr2 = 0;
|
nBinProgSteps += 2;
|
break;
|
// 2参数高级指令
|
case OP_MV:
|
case OP_ADD2:
|
case OP_SUB2:
|
pBinProg2 = (stBinProg2 *)(&BinProgs[nBinProgSteps]);
|
pBinProg2->nOp = nOpType;
|
pBinProg2->nOpNum = 0;
|
pBinProg2->nParamType1 = nParamType1;
|
pBinProg2->nParamAddr1 = nParamAddr1;
|
pBinProg2->nParamType2 = nParamType2;
|
pBinProg2->nParamAddr2 = nParamAddr2;
|
nBinProgSteps += 2;
|
|
break;
|
// 3 参数高级指令
|
case OP_ADD3:
|
case OP_SUB3:
|
case OP_MUL:
|
case OP_DIV:
|
pBinProg3 = (stBinProg3 *)(&BinProgs[nBinProgSteps]);
|
pBinProg3->nOp = nOpType;
|
pBinProg3->nOpNum = 0;
|
pBinProg3->nParamType1 = nParamType1;
|
pBinProg3->nParamAddr1 = nParamAddr1;
|
pBinProg3->nParamType2 = nParamType2;
|
pBinProg3->nParamAddr2 = nParamAddr2;
|
pBinProg3->nParamType3 = nParamType3;
|
pBinProg3->nParamAddr3 = nParamAddr3;
|
nBinProgSteps += 3;
|
break;
|
default:
|
break;
|
}
|
}
|
s1.Format(_T("%d steps to %d binSteps "), m_nProgSteps, nBinProgSteps);
|
DbgLog(s1);
|
|
return 0;
|
}
|
|
int CMTerm1Doc::TransBinToProg()
|
{
|
CString s1;
|
//nBinProgSteps = 0;
|
m_nProgSteps = 0;
|
stBinProg2* pBinProg2;
|
stBinProg15* pBinProg15;
|
stBinProg3* pBinProg3;
|
CStringA s1A;
|
CString s2,s3;
|
CStringA s2A, s3A;
|
for (int i = 0; i < nBinProgSteps; i++)
|
{
|
int nOpType = BinProgs[i].nOp;
|
int nParamType1 = BinProgs[i].nParamType;
|
int nParamAddr1 = BinProgs[i].nParamAddr;
|
// int nParamType1 = Progs[i].Params[0].nParamType;
|
// int nParamAddr1 = Progs[i].Params[0].nParamAddr;
|
int nParamType2, nParamAddr2;
|
int nParamType3, nParamAddr3;
|
CoilTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%S%d"), s1A, nParamAddr1);
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
|
switch (nOpType)
|
{
|
case OP_NONE:
|
break;
|
//case OP_NOP:
|
break;
|
//无参数 指令
|
case OP_NOT:
|
case OP_ANS:
|
case OP_ORS:
|
case OP_PSHS:
|
case OP_RDS:
|
case OP_POPS:
|
case OP_DF:
|
case OP_DF_:
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 0;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
|
//BinProgs[nBinProgSteps].nOp = nOpType;
|
m_nProgSteps += 1;
|
//nBinProgSteps += 1;
|
break;
|
// 1参数指令
|
case OP_ST:
|
case OP_ST_:
|
case OP_AN:
|
case OP_AN_:
|
case OP_OR:
|
case OP_OR_:
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 1;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
m_nProgSteps += 1;
|
//i += 1;
|
break;
|
// 1 参数 输出
|
case OP_OUT:
|
case OP_SET:
|
case OP_RESET:
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 1;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
m_nProgSteps += 1;
|
//i += 1;
|
break;
|
|
// 比较指令
|
case OP_ST_EQ:
|
case OP_ST_NE:
|
case OP_ST_LT:
|
case OP_ST_GT:
|
case OP_ST_LE:
|
case OP_ST_GE:
|
case OP_AN_EQ:
|
case OP_AN_NE:
|
case OP_AN_LT:
|
case OP_AN_GT:
|
case OP_AN_LE:
|
case OP_AN_GE:
|
case OP_OR_EQ:
|
case OP_OR_NE:
|
case OP_OR_LT:
|
case OP_OR_GT:
|
case OP_OR_LE:
|
case OP_OR_GE:
|
pBinProg2 = (stBinProg2*)(&BinProgs[i]);
|
|
nParamType1 = pBinProg2->nParamType1;
|
nParamAddr1 = pBinProg2->nParamAddr1;
|
nParamType2 = pBinProg2->nParamType2;
|
nParamAddr2 = pBinProg2->nParamAddr2;
|
|
DataTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%S%d"), s1A, nParamAddr1);
|
|
DataTypeToTxt(nParamType2, s2A);
|
s2.Format(_T("%S%d"), s2A, nParamAddr2);
|
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 2;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
|
Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
|
Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
|
Progs[m_nProgSteps].Params[1].sParamStr = s2;
|
|
m_nProgSteps += 1;
|
i += 1;
|
break;
|
|
// 定时器
|
case OP_TML:
|
case OP_TMR:
|
case OP_TMX:
|
case OP_TMY:
|
//pBinProg2 = (stBinProg2*)(&BinProgs[i]);
|
|
pBinProg15 = (stBinProg15*)(&BinProgs[i]);
|
|
nParamType1 = 0;
|
nParamAddr1 = pBinProg15->nOpNum;
|
nParamType2 = pBinProg15->nParamType1;
|
nParamAddr2 = pBinProg15->nParamAddr1;
|
//nParamAddr2 = pBinProg15->nParamAddr2;
|
DataTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%d"), nParamAddr1);
|
|
DataTypeToTxt(nParamType2, s2A);
|
s2.Format(_T("%S%d"), s2A, nParamAddr2);
|
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 2;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
|
Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
|
Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
|
Progs[m_nProgSteps].Params[1].sParamStr = s2;
|
m_nProgSteps += 1;
|
i += 1;
|
|
break;
|
// 1 参数高级指令
|
case OP_INC:
|
case OP_DEC:
|
pBinProg15 = (stBinProg15*)(&BinProgs[i]);
|
nParamType1 = pBinProg15->nParamType1;
|
nParamAddr1 = pBinProg15->nParamAddr1;
|
|
DataTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%S%d"), s1A, nParamAddr1);
|
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 1;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
|
m_nProgSteps += 1;
|
i += 1;
|
break;
|
// 2参数高级指令
|
case OP_MV:
|
case OP_ADD2:
|
case OP_SUB2:
|
pBinProg2 = (stBinProg2*)(&BinProgs[i]);
|
|
nParamType1 = pBinProg2->nParamType1;
|
nParamAddr1 = pBinProg2->nParamAddr1;
|
nParamType2 = pBinProg2->nParamType2;
|
nParamAddr2 = pBinProg2->nParamAddr2;
|
|
DataTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%S%d"), s1A, nParamAddr1);
|
|
DataTypeToTxt(nParamType2, s2A);
|
s2.Format(_T("%S%d"), s2A, nParamAddr2);
|
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 2;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
|
Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
|
Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
|
Progs[m_nProgSteps].Params[1].sParamStr = s2;
|
|
m_nProgSteps += 1;
|
i += 1;
|
|
break;
|
// 3 参数高级指令
|
case OP_ADD3:
|
case OP_SUB3:
|
case OP_MUL:
|
case OP_DIV:
|
pBinProg3 = (stBinProg3*)(&BinProgs[i]);
|
nParamType1 = pBinProg3->nParamType1;
|
nParamAddr1 = pBinProg3->nParamAddr1;
|
nParamType2 = pBinProg3->nParamType2;
|
nParamAddr2 = pBinProg3->nParamAddr2;
|
nParamType3 = pBinProg3->nParamType3;
|
nParamAddr3 = pBinProg3->nParamAddr3;
|
|
DataTypeToTxt(nParamType1, s1A);
|
s1.Format(_T("%S%d"), s1A, nParamAddr1);
|
|
DataTypeToTxt(nParamType2, s2A);
|
s2.Format(_T("%S%d"), s2A, nParamAddr2);
|
DataTypeToTxt(nParamType3, s3A);
|
s3.Format(_T("%S%d"), s3A, nParamAddr3);
|
|
Progs[m_nProgSteps].nOpType1 = nOpType;
|
Progs[m_nProgSteps].nParamCount = 3;
|
Progs[m_nProgSteps].Params[0].nParamType = nParamType1;
|
Progs[m_nProgSteps].Params[0].nParamAddr = nParamAddr1;
|
Progs[m_nProgSteps].Params[0].sParamStr = s1;
|
Progs[m_nProgSteps].Params[1].nParamType = nParamType2;
|
Progs[m_nProgSteps].Params[1].nParamAddr = nParamAddr2;
|
Progs[m_nProgSteps].Params[1].sParamStr = s2;
|
Progs[m_nProgSteps].Params[2].nParamType = nParamType3;
|
Progs[m_nProgSteps].Params[2].nParamAddr = nParamAddr3;
|
Progs[m_nProgSteps].Params[2].sParamStr = s3;
|
m_nProgSteps += 1;
|
i += 2;
|
break;
|
default:
|
break;
|
}
|
|
}
|
s1.Format(_T("%d binsteps to %d Steps "), nBinProgSteps, m_nProgSteps );
|
DbgLog(s1);
|
return 0;
|
}
|
|
void CMTerm1Doc::OnUploadFromPlc()
|
{
|
// TODO: 在此添加命令处理程序代码
|
int r;
|
CString s1;
|
if (!m_bOnline) {
|
r = Connect();
|
// MyKLink1.Open();
|
}
|
if (!m_bOnline) return;
|
r = MyKLink1.ReadRunStat(1,0,0,32,(unsigned short *)&MyKLink1.KMRunStat);
|
|
if (r != 0) {
|
AfxMessageBox(_T("UploadFrom PLC Failed"));
|
return;
|
}
|
// AfxMessageBox(_T("UploadFrom PLC From Doc"));
|
CString s2;
|
s2.Format(_T("Cur Programs %d \r\n"), nBinProgSteps);
|
unsigned short * pBinBuf2 = (unsigned short *)BinProgs;
|
for (int i = 0; i < nBinProgSteps * 2; i += 8) {
|
s1.Format(_T("%03X: "), i);
|
for (int j = 0; j < 8 && i+j < nBinProgSteps * 2; j++) {
|
s1.AppendFormat(_T("%04X "), pBinBuf2[i + j]);
|
}
|
s2 += s1 + _T("\r\n");
|
}
|
DbgLog(s2);
|
|
int nBinSteps = MyKLink1.KMRunStat.nBinProgSize;
|
s1.Format(_T("program to upload Size %d "), nBinSteps);
|
DbgLog(s1);
|
|
USHORT Buf3[2048];
|
s2.Empty();
|
int nUploadSize = nBinSteps *2;
|
int nSteps = 64;
|
for (int i = 0; i < nUploadSize; i += nSteps) {
|
if (i + nSteps > nUploadSize) { nSteps = nUploadSize - i; }
|
s1.Format(_T("2 Uploading %d to %d "), i, i + nSteps);
|
DbgLog(s1);
|
int r = MyKLink1.ReadProgram(1, 2, i, nSteps*2 , Buf3+i);
|
s1.Format(_T("Download r = %d "), r);
|
DbgLog(s1);
|
//Update Progress Bar
|
}
|
s2.Format(_T(" Uploaded from bank 2 \r\n"));
|
for (int i = 0; i < nBinSteps * 2; i += 8) {
|
s1.Format(_T("%03X: "), i);
|
for (int j = 0; j < 8 && i + j < nBinSteps * 2; j++) {
|
s1.AppendFormat(_T("%04X "), Buf3[i + j]);
|
}
|
s2 += s1 + _T("\r\n");
|
}
|
DbgLog(s2);
|
|
for (int i = 0; i < nBinSteps * 2; i++)
|
{
|
((USHORT *)BinProgs)[i] = Buf3[i];
|
}
|
nBinProgSteps = nBinSteps;
|
TransBinToProg();
|
UpdateAllViews(NULL);
|
}
|
|
int CMTerm1Doc::DownloadToPLC()
|
{
|
// TODO: 在此处添加实现代码.
|
int r;
|
CString s1;
|
if (!m_bOnline) {
|
r=Connect();
|
// MyKLink1.Open();
|
}
|
if (!m_bOnline) return 0;
|
|
if (m_bPlcRunning) {
|
r = AfxMessageBox(_T("PLC运行中，是否停止以便下载程序?"), MB_YESNO);
|
if (r == IDYES) { StopPLC();}
|
else { return 0; }
|
}
|
|
// 下载程序
|
s1.Format(_T("Start Download Program ..."));
|
DbgLog(s1);
|
r = MyKLink1.StartProgram(1,2);
|
s1.Format(_T("Result = %d"),r);
|
DbgLog(s1);
|
int DownloadSize = nBinProgSteps;
|
|
int Steps = 16;
|
for (int i = 0; i < DownloadSize; i += Steps) {
|
//int Steps = 16;
|
if (i + Steps > DownloadSize) { Steps = DownloadSize - i; }
|
int n = 0;
|
do {
|
s1.Format(_T("Downloading %d to %d "), i, i + Steps);
|
DbgLog(s1);
|
r = MyKLink1.WriteProgram(1, 2, (i) * 4, Steps * 4, (USHORT*)&BinProgs[i]);
|
s1.Format(_T("Download r = %d "), r);
|
DbgLog(s1);
|
n += 1;
|
if (n > 10) break;
|
} while (r != 0);
|
//Update Progress Bar
|
}
|
|
s1.Format(_T("Finish Downloading "));
|
DbgLog(s1);
|
r = MyKLink1.FinishProgram(1,2,nBinProgSteps);
|
s1.Format(_T("Download Finished r = %d "), r);
|
DbgLog(s1);
|
// 下载注释
|
|
|
// 下载系统寄存器配置
|
|
//启动运行
|
r = AfxMessageBox(_T("程序下载完成，是否启动运行?"), MB_YESNO);
|
if (r == IDYES) { StartPLC(); }
|
else { return 0; }
|
|
return 0;
|
}
|
|
void CMTerm1Doc::OnDownloadToPlc()
|
{
|
// TODO: 在此添加命令处理程序代码
|
DownloadToPLC();
|
}
|
|
void CMTerm1Doc::OnUpdateDownloadToPlc(CCmdUI *pCmdUI)
|
{
|
// TODO: 在此添加命令更新用户界面处理程序代码
|
}
|
|
void CMTerm1Doc::OnOnline()
|
{
|
// TODO: 在此添加命令处理程序代码
|
int r;
|
if (!m_bOnline)
|
{
|
r = Connect();
|
//MyKLink1.Open();
|
}
|
if (!m_bOnline) return;
|
// m_bOnline = true;
|
UpdateAllViews(NULL, UpdataHint::UpdateStat);
|
}
|
|
void CMTerm1Doc::OnUpdateOnline(CCmdUI *pCmdUI)
|
{
|
// TODO: 在此添加命令更新用户界面处理程序代码
|
pCmdUI->SetCheck(m_bOnline == true);
|
}
|
|
void CMTerm1Doc::OnOffline()
|
{
|
// TODO: 在此添加命令处理程序代码
|
int r;
|
if (m_bOnline)
|
{
|
r = DisConnect();
|
MyKLink1.Close();
|
}
|
m_bOnline = false;
|
UpdateAllViews(NULL, UpdataHint::UpdateStat);
|
}
|
|
void CMTerm1Doc::OnUpdateOffline(CCmdUI *pCmdUI)
|
{
|
// TODO: 在此添加命令更新用户界面处理程序代码
|
pCmdUI->SetCheck(m_bOnline == false);
|
}
|
|
void CMTerm1Doc::OnSimulate()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
unsigned short* p1 = (unsigned short *)&BinProgs;
|
if (!m_bSimulate) {
|
|
s1.Format(_T("启动PLC模拟\r\n"));
|
SysLog(s1);
|
m_bSimulate = true;
|
s1.Empty();
|
for (int i = 0; i < nBinProgSteps; i++) {
|
s1.AppendFormat(_T("%04X %04X "), p1[i*2],p1[i*2+1]);
|
}
|
SysLog(s1);
|
s1.Format(_T("Download %d program to sim PLC"),nBinProgSteps);
|
SysLog(s1);
|
myKMachine1.Download(BinProgs, nBinProgSteps);
|
m_bOnline = true;
|
myKMachine1.StartPLC();
|
s1.Format(_T("Start sim PLC"));
|
SysLog(s1);
|
StartPLC();
|
}
|
else {
|
StopPLC();
|
m_bSimulate = false;
|
m_bOnline = false;
|
|
}
|
UpdateAllViews(NULL, UpdataHint::UpdateStat);
|
}
|
|
void CMTerm1Doc::OnUpdateSimulate(CCmdUI *pCmdUI)
|
{
|
// TODO: 在此添加命令更新用户界面处理程序代码
|
pCmdUI->SetCheck(m_bSimulate == true);
|
}
|
|
int CMTerm1Doc::StartPLC()
|
{
|
// TODO: 在此处添加实现代码.
|
if (m_bSimulate) {
|
for (int i = 0; i < KLDataWXCount; i++) {
|
KMem.WX[i] = 0;
|
}
|
for (int i = 0; i < KLDataWYCount; i++) {
|
KMem.WY[i] = 0;
|
}
|
for (int i = 0; i < KLDataWRCount; i++) {
|
KMem.WR[i] = 0;
|
}
|
for (int i = 0; i < KLDataDTCount; i++) {
|
KMem.DT[i] = 0;
|
}
|
for (int i = 0; i < TOTALTIMERS; i++) {
|
KMem.Timers[i] = { 0 };
|
}
|
nScanCount = 0;
|
m_bPlcRunning = 1;
|
}else {
|
MyKLink1.ChangeMode(1, 1);
|
m_bPlcRunning = 1;
|
}
|
return 0;
|
}
|
|
|
int CMTerm1Doc::StopPLC()
|
{
|
// TODO: 在此处添加实现代码.
|
if (m_bSimulate) {
|
m_bPlcRunning = false;
|
}
|
else {
|
MyKLink1.ChangeMode(1, 0);
|
m_bPlcRunning = false;
|
}
|
|
return 0;
|
}
|
|
void CMTerm1Doc::OnPlcRun()
|
{
|
// TODO: 在此添加命令处理程序代码
|
if (m_bPlcRunning) { StopPLC(); }
|
else
|
{
|
StartPLC();
|
}
|
UpdateAllViews(NULL, UpdataHint::UpdateStat);
|
}
|
|
void CMTerm1Doc::OnUpdatePlcRun(CCmdUI *pCmdUI)
|
{
|
// TODO: 在此添加命令更新用户界面处理程序代码
|
pCmdUI->SetCheck(m_bPlcRunning == true);
|
if (!m_bPlcRunning) pCmdUI->SetText(_T("PLC模式[PROG]"));
|
else pCmdUI->SetText(_T("PLC模式[RUN]"));
|
}
|
|
|
int CMTerm1Doc::SetCommParam()
|
{
|
// TODO: 在此处添加实现代码.
|
CString s1;
|
s1.Format(_T("Doc SetupComm"));
|
SysLog(s1);
|
MyKLink1.SetCommParam();
|
return 0;
|
/*
|
CDialogCommSet1 dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK )
|
{
|
nComPort=dialog1.m_nComNum;
|
nBaud=dialog1.m_nBaudRate;
|
ComSettings=dialog1.m_Settings;
|
s1.Format(_T("dialog return port %d baud %d setting %S"),
|
nComPort, nBaud, ComSettings);
|
SysLog(s1);
|
m_bCommParamSet = true;
|
}
|
else
|
{
|
return -1;
|
}
|
return 0;
|
*/
|
}
|
|
int CMTerm1Doc::Connect()
|
{
|
// TODO: 在此处添加实现代码.
|
CString s1;
|
unsigned short buf1[32];
|
int res = MyKLink1.Connect();
|
unsigned short len1;
|
int j=MyKLink1.GetInfo(1, &len1, buf1);
|
s1.Format(_T("GetInfo = %d %d \r\n"), j,len1);
|
if (j==0 && len1 > 0) {
|
for (int i = 0; i < len1/2; i++) {
|
s1.AppendFormat(_T("%04X "), buf1[i]);
|
}
|
s1 += _T("\r\n");
|
pKMInfoBlock pinfob = (pKMInfoBlock)buf1;
|
|
s1.AppendFormat(_T(" DeviceType %04X \r\n"),pinfob->nDeviceTypeVer);
|
s1.AppendFormat(_T(" nProgVer %04X \r\n"), pinfob->nProgVer);
|
s1.AppendFormat(_T(" nKLinkVer %04X \r\n"), pinfob->nKLinkVer);
|
s1.AppendFormat(_T(" nKBusVer %04X \r\n"), pinfob->nKBusVer);
|
s1.AppendFormat(_T(" nCapacity1 %d k\r\n"), pinfob->nCapacity1);
|
s1.AppendFormat(_T(" nCapacity2 %d k\r\n"), pinfob->nCapacity2);
|
s1.AppendFormat(_T(" nDInput %d \r\n"), pinfob->nDInput);
|
s1.AppendFormat(_T(" nDOutput %d \r\n"), pinfob->nDOutput);
|
s1.AppendFormat(_T(" nAInput %d \r\n"), pinfob->nAInput);
|
s1.AppendFormat(_T(" nAOutput %d \r\n"), pinfob->nAOutput);
|
s1.AppendFormat(_T(" nHInput %d \r\n"), pinfob->nHInput);
|
s1.AppendFormat(_T(" nHOutput %d \r\n"), pinfob->nHOutput);
|
s1.AppendFormat(_T(" nExt1 %d \r\n"), pinfob->nExt1);
|
s1.AppendFormat(_T(" nExt2 %d \r\n"), pinfob->nExt2);
|
s1.AppendFormat(_T(" nLogSize %d \r\n"), pinfob->nLogSize);
|
s1.AppendFormat(_T(" nPorts %d \r\n"), pinfob->nPorts);
|
s1.AppendFormat(_T(" nManSize %d \r\n"), pinfob->nManSize);
|
s1.AppendFormat(_T(" nAbility %d \r\n"), pinfob->nAbility);
|
s1.AppendFormat(_T(" nSwitchBits %d \r\n"), pinfob->nSwitchBits);
|
|
}
|
SysLog(s1);
|
int r = MyKLink1.ReadRunStat(1, 0, 0, 32, (unsigned short*)&MyKLink1.KMRunStat);
|
s1.Format(_T("GetRunStat = %d %d \r\n"), r, 32);
|
KLink1::stRunStat RunStat1 = MyKLink1.KMRunStat;
|
|
s1.AppendFormat(_T(" Sign1 %04X \r\n"), RunStat1.Sign1);
|
s1.AppendFormat(_T(" Seq1 %d \r\n"), RunStat1.Seq1);
|
s1.AppendFormat(_T(" PowerCount %d \r\n"), RunStat1.PowerCount);
|
s1.AppendFormat(_T(" Reserved1 %d \r\n"), RunStat1.Reserved1);
|
s1.AppendFormat(_T(" UpTime %d \r\n"), RunStat1.UpTime);
|
s1.AppendFormat(_T(" UserData1 %d \r\n"), RunStat1.UserData1);
|
s1.AppendFormat(_T(" WorkMode %d \r\n"), RunStat1.WorkMode);
|
s1.AppendFormat(_T(" WorkMode2 %d \r\n"), RunStat1.WorkMode2);
|
s1.AppendFormat(_T(" nBinProgBank %d \r\n"), RunStat1.nBinProgBank);
|
s1.AppendFormat(_T(" nBinProgSize %d \r\n"), RunStat1.nBinProgSize);
|
s1.AppendFormat(_T(" bLEDFlick %d \r\n"), RunStat1.bLEDFlick);
|
s1.AppendFormat(_T(" Reserved2 %d \r\n"), RunStat1.Reserved2);
|
s1.AppendFormat(_T(" CRC1 %04X \r\n"), RunStat1.CRC1);
|
s1.AppendFormat(_T(" EndSign1 %04X \r\n"), RunStat1.EndSign1);
|
|
unsigned char value;
|
r = MyKLink1.GetMode(1, 0, &value);
|
if (r == KLink1::KL_OK) { m_bPlcRunning = value; }
|
|
|
SysLog(s1);
|
// m_static_connect.SetCtlColor(RGB(0, 255, 0));
|
/*
|
if (!m_bCommParamSet)
|
{
|
if (SetCommParam()) return -1;
|
}
|
if (m_bOnline) return 0;
|
|
myHvSerialPort1.m_nPort = nComPort;
|
myHvSerialPort1.m_nBaudRate = nBaud;
|
myHvSerialPort1.m_Settings = "8,N,1";
|
int r = myHvSerialPort1.Open();
|
s1.Format(_T("Open %s = %d"), myHvSerialPort1.m_strResult, r);
|
SysLog(s1);
|
if (r == myHvSerialPort1.R_OK)
|
{
|
m_bOnline = true;
|
// MyKLink1.Open();
|
// m_static_connect.SetCtlColor(RGB(0, 255, 0));
|
return 0;
|
}
|
*/
|
m_bOnline = true;
|
return 0;
|
}
|
|
int CMTerm1Doc::DisConnect()
|
{
|
// TODO: 在此处添加实现代码.
|
if (!m_bOnline) return -1;
|
// myHvSerialPort1.Close();
|
MyKLink1.Close();
|
m_bOnline = false;
|
return 0;
|
}
|
|
void CMTerm1Doc::OnComunicationSet()
|
{
|
// TODO: 在此添加命令处理程序代码
|
SetCommParam();
|
|
}
|
|
void CMTerm1Doc::OnPlcSysregSet()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CDialogSysRegSet dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK)
|
{
|
|
}
|
}
|
|
void CMTerm1Doc::OnMenuFactCfg()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CDialogFactCfg dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK)
|
{
|
|
}
|
}
|
|
|
CView * CMTerm1Doc::FindView(CRuntimeClass * pClass)
|
{
|
CView* pView=NULL;
|
POSITION pos = GetFirstViewPosition();
|
while (pos != NULL)
|
{
|
pView = GetNextView(pos);
|
if (pView->IsKindOf(pClass))
|
break;
|
}
|
if (!pView->IsKindOf(pClass))
|
{
|
//AfxMessageBox("Connt Locate the View.");
|
return NULL;
|
}
|
return pView;
|
}
|
///*
|
void CMTerm1Doc::OnMenuViewLds()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
CView * pView;
|
pView = FindView(RUNTIME_CLASS(CMTerm1View));
|
if (pView != NULL) {
|
((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
|
// pView->SetActiveWindow();
|
}
|
else {
|
s1 = GetTitle();
|
//AfxMessageBox(s1);
|
ASSERT_VALID(theApp.pDocTemplate);
|
CFrameWnd * pFrame = theApp.pDocTemplate->CreateNewFrame(this, NULL);
|
ASSERT_KINDOF(CFrameWnd, pFrame);
|
theApp.pDocTemplate->InitialUpdateFrame(pFrame, this);
|
}
|
}
|
|
|
void CMTerm1Doc::OnMenuViewBld()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
CView * pView;
|
pView = FindView(RUNTIME_CLASS(CMTerm1BldView));
|
if (pView != NULL) {
|
((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
|
// pView->SetActiveWindow();
|
}
|
else {
|
s1 = GetTitle();
|
//AfxMessageBox(s1);
|
ASSERT_VALID(theApp.m_pBldViewTemplate);
|
CFrameWnd * pFrame = theApp.m_pBldViewTemplate->CreateNewFrame(this, NULL);
|
ASSERT_KINDOF(CFrameWnd, pFrame);
|
theApp.m_pBldViewTemplate->InitialUpdateFrame(pFrame, this);
|
}
|
}
|
|
|
void CMTerm1Doc::OnMenuViewBnl()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
CView * pView;
|
pView = FindView(RUNTIME_CLASS(CMTerm1BnlView));
|
if (pView != NULL) {
|
((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
|
// pView->SetActiveWindow();
|
}
|
else {
|
s1 = GetTitle();
|
//AfxMessageBox(s1);
|
ASSERT_VALID(theApp.m_pBnlViewTemplate);
|
CFrameWnd * pFrame = theApp.m_pBnlViewTemplate->CreateNewFrame(this, NULL);
|
ASSERT_KINDOF(CFrameWnd, pFrame);
|
theApp.m_pBnlViewTemplate->InitialUpdateFrame(pFrame, this);
|
}
|
}
|
//*/
|
|
void CMTerm1Doc::OnMenuShowConsole()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
CView * pView;
|
pView = FindView(RUNTIME_CLASS(CMTerm1CtrlView));
|
if (pView != NULL) {
|
((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
|
// pView->SetActiveWindow();
|
}
|
else {
|
s1 = GetTitle();
|
//AfxMessageBox(s1);
|
ASSERT_VALID(theApp.m_pCtrlViewTemplate);
|
CFrameWnd * pFrame = theApp.m_pCtrlViewTemplate->CreateNewFrame(this, NULL);
|
ASSERT_KINDOF(CFrameWnd, pFrame);
|
theApp.m_pCtrlViewTemplate->InitialUpdateFrame(pFrame, this);
|
}
|
}
|
|
|
void CMTerm1Doc::OnMenuCommTest()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CString s1;
|
CView * pView;
|
pView = FindView(RUNTIME_CLASS(CMTerm1CommDevView));
|
if (pView != NULL) {
|
((CMDIFrameWndEx *)AfxGetMainWnd())->MDIActivate(pView->GetParent());
|
// pView->SetActiveWindow();
|
}
|
else {
|
s1 = GetTitle();
|
//AfxMessageBox(s1);
|
ASSERT_VALID(theApp.m_pCommDevViewTemplate);
|
CFrameWnd * pFrame = theApp.m_pCommDevViewTemplate->CreateNewFrame(this, NULL);
|
ASSERT_KINDOF(CFrameWnd, pFrame);
|
theApp.m_pCommDevViewTemplate->InitialUpdateFrame(pFrame, this);
|
}
|
|
}
|
|
const unsigned short bitMasks[16] =
|
{
|
0x1 << 0, 0x1 << 1, 0x1 << 2, 0x1 << 3, 0x1 << 4, 0x1 << 5, 0x1 << 6, 0x1 << 7,
|
0x1 << 8, 0x1 << 9, 0x1 << 10, 0x1 << 11, 0x1 << 12, 0x1 << 13, 0x1 << 14, 0x1 << 15,
|
};
|
|
inline void SetAddrBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW) |= bitMasks[bitAddr & 0xf];
|
}
|
|
inline void ResetBit(unsigned short * pW, unsigned char bitAddr)
|
{
|
(*pW) &= ~bitMasks[bitAddr & 0xf];
|
}
|
|
static inline void SetBitValue(unsigned short * pW, unsigned char bitAddr, unsigned char Value)
|
{
|
if (Value) { SetAddrBit(pW, bitAddr); }
|
else { ResetBit(pW, bitAddr); }
|
}
|
|
static inline unsigned char GetBitValue(unsigned short W, unsigned char bitAddr)
|
{
|
if (W&bitMasks[bitAddr & 0xf]) return 1;
|
else return 0;
|
}
|
|
int CMTerm1Doc::GetCoilValue(int nCoilType, int nCoilAddr)
|
{
|
// TODO: 在此处添加实现代码.
|
|
if (m_bOnline && 0)
|
{
|
unsigned char value = 0;
|
MyKLink1.ReadBit(1, nCoilType, nCoilAddr, &value);
|
return value;
|
}
|
int nWordAddr = nCoilAddr >> 4;
|
int nBitAddr = nCoilAddr & 0x0F;
|
|
switch (nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
return GetBitValue(KMem.WX[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
return GetBitValue(KMem.WY[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeR:
|
if (nCoilAddr >= KLCoilRCount) return 0;
|
return GetBitValue(KMem.WR[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
return GetBitValue(KMem.WLX[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
return GetBitValue(KMem.WLY[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
return GetBitValue(KMem.WT[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
return GetBitValue(KMem.WC[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
return GetBitValue(KMem.WLR[nWordAddr], nBitAddr);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
return GetBitValue(KMem.WSR[nWordAddr], nBitAddr);
|
break;
|
}
|
return 0;
|
}
|
|
|
int CMTerm1Doc::SetCoilValue(int nCoilType, int nCoilAddr, int nCoilValue)
|
{
|
// TODO: 在此处添加实现代码.
|
if (m_bSimulate) {
|
return myKMachine1.SetCoilValue(nCoilType, nCoilAddr, nCoilValue);
|
}else
|
if (m_bOnline)
|
{
|
unsigned char value =nCoilValue;
|
int res = 0;
|
res = MyKLink1.WriteBit(1, nCoilType, nCoilAddr, value);
|
return res;
|
}
|
|
int nWordAddr = nCoilAddr >> 4;
|
int nBitAddr = nCoilAddr & 0x0F;
|
|
switch (nCoilType)
|
{
|
case KLCoilTypeX:
|
if (nCoilAddr >= KLCoilXCount) return 0;
|
SetBitValue(&KMem.WX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeY:
|
if (nCoilAddr >= KLCoilYCount) return 0;
|
SetBitValue(&KMem.WY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeR:
|
if (nCoilAddr >= KLCoilRCount) return 0;
|
SetBitValue(&KMem.WR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLX:
|
if (nCoilAddr >= KLCoilLXCount) return 0;
|
SetBitValue(&KMem.WLX[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLY:
|
if (nCoilAddr >= KLCoilLYCount) return 0;
|
SetBitValue(&KMem.WLY[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeT:
|
if (nCoilAddr >= KLCoilTCount) return 0;
|
SetBitValue(&KMem.WT[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeC:
|
if (nCoilAddr >= KLCoilCCount) return 0;
|
SetBitValue(&KMem.WC[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeLR:
|
if (nCoilAddr >= KLCoilLRCount) return 0;
|
SetBitValue(&KMem.WLR[nWordAddr], nBitAddr, nCoilValue);
|
break;
|
case KLCoilTypeSR:
|
if (nCoilAddr >= KLCoilSRCount) return 0;
|
SetBitValue(&KMem.WSR[nWordAddr], nBitAddr, nCoilValue);
|
|
break;
|
}
|
if (m_bOnline)
|
{
|
// MyKLink1.WriteBit(1, nCoilType, nCoilAddr, nCoilValue);
|
}
|
return 0;
|
}
|
|
int CMTerm1Doc::GetVarData(int nDataType, int nDataAddr)
|
{
|
// TODO: 在此处添加实现代码.
|
unsigned short nCount;
|
if (m_bOnline && 0)
|
{
|
unsigned short value[20];
|
unsigned short svalue = 0;
|
if (nDataType == KLDataTypeDEC || nDataType == KLDataTypeHEX){
|
return nDataAddr;
|
}
|
|
MyKLink1.ReadDataWord(1, nDataType, nDataAddr, 2, &nCount, value);// (unsigned char *)&KMem.DT[nDataAddr]);
|
svalue = value[0];
|
return svalue;
|
}
|
|
switch (nDataType)
|
{
|
case KLDataTypeDEC:
|
case KLDataTypeHEX:
|
return nDataAddr;
|
break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
return KMem.WX[nDataAddr];
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
return KMem.WY[nDataAddr];
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
return KMem.WR[nDataAddr];
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
return KMem.WLX[nDataAddr];
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
return KMem.WLY[nDataAddr];
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
return (signed short)KMem.DT[nDataAddr];
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
return KMem.WSR[nDataAddr];
|
break;
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
return KMem.SV[nDataAddr];
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
return KMem.EV[nDataAddr];
|
break;
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
return KMem.DT[nDataAddr];
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
return KMem.SDT[nDataAddr];
|
break;
|
}
|
return 0;
|
}
|
|
|
int CMTerm1Doc::SetVarData(int nDataType, int nDataAddr, int nDataValue)
|
{
|
// TODO: 在此处添加实现代码.
|
|
if (m_bSimulate) {
|
return myKMachine1.SetVarData(nDataType, nDataAddr, nDataValue);
|
}else
|
if (m_bOnline)
|
{
|
// unsigned char value[20];
|
unsigned short svalue[10];
|
svalue[0]=nDataValue;
|
int res = 0;
|
res = MyKLink1.WriteDataWord(1, nDataType, nDataAddr, 2, svalue);
|
return res;
|
}
|
|
switch (nDataType)
|
{
|
// case KLDataTypeDEC:
|
// case KLDataTypeHEX:
|
// break;
|
case KLDataTypeWX:
|
if (nDataAddr >= KLDataWXCount) return 0;
|
KMem.WX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWY:
|
if (nDataAddr >= KLDataWYCount) return 0;
|
KMem.WY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWR:
|
if (nDataAddr >= KLDataWRCount) return 0;
|
KMem.WR[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLX:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLX[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWLY:
|
if (nDataAddr >= KLDataWLCount) return 0;
|
KMem.WLY[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeDT:
|
if (nDataAddr >= KLDataDTCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeSDT:
|
if (nDataAddr >= KLDataSDTCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeWSR:
|
if (nDataAddr >= KLCoilLRCount) return 0;
|
KMem.WSR[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeSV:
|
if (nDataAddr >= KLDataSVCount) return 0;
|
KMem.SV[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeEV:
|
if (nDataAddr >= KLDataEVCount) return 0;
|
KMem.EV[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeLD:
|
if (nDataAddr >= KLDataLDCount) return 0;
|
KMem.DT[nDataAddr] = nDataValue;
|
break;
|
case KLDataSysCfg:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeFlash:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
case KLDataTypeTest:
|
if (nDataAddr >= KLCoilSRCount) return 0;
|
KMem.SDT[nDataAddr] = nDataValue;
|
break;
|
}
|
|
return 0;
|
}
|
|
|
|
int CMTerm1Doc::AddMonitorCoil(int nCoilType, int nCoilAddr, int nCount)
|
{
|
// TODO: 在此处添加实现代码.
|
return 0;
|
}
|
|
|
int CMTerm1Doc::AddMonitorData(int nDataType, int nDataAddr, int nDataCount)
|
{
|
// TODO: 在此处添加实现代码.
|
return 0;
|
}
|
|
|
int CMTerm1Doc::ClearMonitor()
|
{
|
// TODO: 在此处添加实现代码.
|
return 0;
|
}
|
|
|
int CMTerm1Doc::DoPLCMonitor()
|
{
|
// TODO: 在此处添加实现代码.
|
CString s1;
|
if (m_bSimulate) {
|
int nDataType = MyKLink1.KLDataTypeWX;
|
int nDataAddr = 0;
|
int nDataCount = 4;
|
// int res;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.WX[i] = myKMachine1.KMem.WX[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeWY;
|
nDataAddr = 0;
|
nDataCount = 4;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.WY[i] = myKMachine1.KMem.WY[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeWLX;
|
nDataAddr = 0;
|
nDataCount = 4;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.WLX[i] = myKMachine1.KMem.WLX[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeWLY;
|
nDataAddr = 0;
|
nDataCount = 4;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.WLY[i] = myKMachine1.KMem.WLY[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeWR;
|
nDataAddr = 0;
|
nDataCount = 10;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.WR[i] = myKMachine1.KMem.WR[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeDT;
|
nDataAddr = 0;
|
nDataCount = 80;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.DT[i] = myKMachine1.KMem.DT[i];
|
}
|
|
nDataType = MyKLink1.KLDataTypeSV;
|
nDataAddr = 0;
|
nDataCount = 40;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.SV[i] = myKMachine1.KMem.SV[i];
|
}
|
|
//res = MyKLink1.ReadDataWord(1, nDataCount, nDataType, nDataAddr, KMem.SV);// (unsigned char *)&KMem.DT[nDataAddr]);
|
|
nDataType = MyKLink1.KLDataTypeEV;
|
nDataAddr = 0;
|
nDataCount = 40;
|
for (int i = 0; i < nDataCount; i++) {
|
KMem.EV[i] = myKMachine1.KMem.EV[i];
|
}
|
|
// res = MyKLink1.ReadDataWord(1, nDataCount, nDataType, nDataAddr, KMem.EV);// (unsigned char *)&KMem.DT[nDataAddr]);
|
|
}else if (m_bOnline)
|
{
|
int nDataType = MyKLink1.KLDataTypeWX;
|
int nDataAddr = 0;
|
int nDataCount = 4;
|
unsigned short nCount;
|
int res;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WX);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
|
nDataType = MyKLink1.KLDataTypeWY;
|
nDataAddr = 0;
|
nDataCount = 4;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WY);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
|
nDataType = MyKLink1.KLDataTypeWLX;
|
nDataAddr = 0;
|
nDataCount = 4;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WLX);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
|
nDataType = MyKLink1.KLDataTypeWLY;
|
nDataAddr = 0;
|
nDataCount = 4;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WLY);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
|
nDataType = MyKLink1.KLDataTypeWR;
|
nDataAddr = 0;
|
nDataCount = 10;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.WR);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
nDataType = MyKLink1.KLDataTypeDT;
|
nDataAddr = 0;
|
nDataCount = 80;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.DT);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
nDataType = MyKLink1.KLDataTypeSV;
|
nDataAddr = 0;
|
nDataCount = 40;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.SV);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
nDataType = MyKLink1.KLDataTypeEV;
|
nDataAddr = 0;
|
nDataCount = 40;
|
res = MyKLink1.ReadDataWord(1, nDataType, nDataAddr, nDataCount, &nCount, KMem.EV);// (unsigned char *)&KMem.DT[nDataAddr]);
|
if (res != MyKLink1.KL_OK) {
|
s1.Format(_T("R:= %d %s \r\n"), res, MyKLink1.m_resultStr);
|
SysLog(s1);
|
}
|
}
|
|
return 0;
|
}
|
|
void CMTerm1Doc::OnTimer(UINT_PTR nIDEvent)
|
{
|
CString s1;
|
// s1.Format(_T("Doc::OntTimer"));
|
// SysLog(s1);
|
if (m_bSimulate && m_bPlcRunning)
|
{
|
//ProcessPLCProg(Progs, m_nProgSteps);
|
myKMachine1.ProcPLC();
|
|
// update PLC Stat
|
}
|
}
|
|
void CMTerm1Doc::OnMenuStatusShow()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CDialogStatusShow dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK)
|
{
|
|
}
|
}
|
|
void CMTerm1Doc::OnMenuDatetimeSet()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CDialogDateTime dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK)
|
{
|
|
}
|
}
|
|
void CMTerm1Doc::OnMenuEventLog()
|
{
|
// TODO: 在此添加命令处理程序代码
|
CDialogEventLog dialog1;
|
INT_PTR r = dialog1.DoModal();
|
if (r == IDOK)
|
{
|
|
}
|
}
|
