#include "StdAfx.h"
#include "Program_SZ_XL.h"
#include "Propertie.h"
#include "PropertieMgr.h"
#include "AuthorityMgr.h"
#include "DeviceState.h"
#include "MsgBox.h"
#include "CommonFlowMgr.h"
#include "AuthorityMgr.h"
#include "FileMgr.h"
#include "DxfReadMgr.h"
#include "WorkFileMgr.h"
#include "MarkAreaMgr.h"
#include "LogMgr.h"
#include "MotionCard_PCI1245.h"
#include "ProgramCutMgr.h"
#include "GlobalFunction.h"
//#include "SuperDogMgr.h"
#define CUT_PAR_DIR   "\\CutPar\\"
#define PLC_READ_MSG_LEN      12   //接收PLC 数据的长度(字节)
#define BUF_LEN 100


//读取上料机plc 消息的线程(无限循环)
UINT ReadLoadPlcMsgThread(LPVOID pParam)
{
	CProgram_SZ_XL *WorkFlow = (CProgram_SZ_XL *)pParam;
	WorkFlow->ReadLoadPlcMsg();
	return 0;
}

CProgram_SZ_XL *gProgram_SZ_XL = new CProgram_SZ_XL;
CProgram_SZ_XL::CProgram_SZ_XL(void)
{
	m_TrackComPort1 = 1;//轨道1 串口号
	m_TrackComPort2 = 2;//轨道2 串口号
	m_LoadComPort = 3;//上料机串口号
	m_ComBaudRate = 115200;//通信波特率

	m_MotorXLoadCoord = 0;//X 轴上料坐标
	m_MotorXUnLoadCoord = 0;//X 轴下料坐标
	m_MotorX2LoadCoord = 0;//X2 轴上料坐标
	m_MotorX2UnLoadCoord = 0;//X2 轴下料坐标

	m_MotorXWaitCoord = 0;//X轴等待坐标
	m_bLoadDeviceSuc = false;
	m_bSelMarkMode = false;//选择加工模式
	m_bAutoWorkMode = true;//自动工作模式
	m_bStopReadMsg = false;//是否暂停读取plc 消息
	m_bLoadCOMLockerFlg = false;//发送消息锁定flg

	m_Track1DangerCoordStart = -1000;//轨道1 的危险范围start
	m_Track1DangerCoordEnd = 180;//轨道1 的危险范围end
	m_Track1SafeCoord = 280;//轨道1 的安全坐标
	m_Track2DangerCoordStart = 30;//轨道2 的危险范围start
	m_Track2DangerCoordEnd = 1000;//轨道2 的危险范围end
	m_Track2SafeCoord = -90;//轨道2 的安全坐标

	m_bShieldLoad = false;//屏蔽上料
	m_bShieldMarking = false;//屏蔽加工过程
	m_bShieldUnLoad = false;//屏蔽下料

	m_LoadCmdDelay = 1000;//发送上料请求上升沿的时间ms
	m_LoadCmdRevDelay = 100;//发送后间隔这个时间去读取反馈ms
	m_StopStepUnloadTimes = 5;//连续点多少次可以强制停止unload
	m_LoadCmdSendTims = 5;//发送给上料plc 的cmd尝试的次数

	m_PlcCmdSendDelay = 500;//plc指令发送后延时ms
	m_bCheckUnloadState = true;//是否检查下料机状态
}
CProgram_SZ_XL::~CProgram_SZ_XL(void)
{
}
CMFCPropertyGridProperty *CProgram_SZ_XL::CreatGridProperty()
{
	CPropertieMgr &PropertieMgr = gDevicePropertieMgr;

	CString PropertyName;//属性名称
	CString Description;//描述
	CString Path = _T("PGM_SW_XL");//存储路径
	CString Name;
	//-------------------------------------------------------------------------------//
	PropertyName = _T("双轨设备");
	CMFCPropertyGridProperty* pGroup = new CMFCPropertyGridProperty(PropertyName);
	//-------------------------------------------------------------------------------//

	if (gAuthorityMgr->CheckAuthority(_ADMIN))
	{
		PropertyName = _T("固定缩放比率");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);
		{
			//添加属性变量映射
			Name = _T("m_Jig1Scale_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig1Scale.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具1X");
			Description = _T("治具1X(放缩比率)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig1Scale.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Jig1Scale_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig1Scale.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具1Y");
			Description = _T("治具1Y(放缩比率)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig1Scale.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Jig3Scale_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig3Scale.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具3X");
			Description = _T("治具3X(放缩比率)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig3Scale.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Jig3Scale_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig3Scale.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具3Y");
			Description = _T("治具3Y(放缩比率)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig3Scale.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}

	if (gAuthorityMgr->CheckAuthority(_FACTORY))
	{
		PropertyName = _T("基础设置");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);

		{
			//添加属性变量映射
			Name = _T("m_ServerIP");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_ServerIP);
			pPropertie->SetType(_PROP_TYPE_STRING);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("副机IP");
			Description = _T("副机的IP地址");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_ServerIP, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_ServerPort");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_ServerPort);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("副机端口");
			Description = _T("副机监听的端口号");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_ServerPort, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_bCheckUnloadState");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_bCheckUnloadState);
			pPropertie->SetType(_PROP_TYPE_BOOL);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("检查下料机信号");
			Description = _T("是否检查下料机信号");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bCheckUnloadState, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_TrackComPort1");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_TrackComPort1);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("轨道1 串口号");
			Description = _T("轨道1 串口号");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_TrackComPort1, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_TrackComPort2");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_TrackComPort2);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("轨道2 串口号");
			Description = _T("轨道2 串口号");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_TrackComPort2, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_PlcCmdSendDelay");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_PlcCmdSendDelay);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("发送后延时");
			Description = _T("plc指令发送后延时ms");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_PlcCmdSendDelay, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_LoadComPort");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_LoadComPort);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("上料机串口号");
			Description = _T("上料机通信用串口号");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LoadComPort, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_LoadCmdRevDelay");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_LoadCmdRevDelay);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("上料反馈延时");
			Description = _T("发送上料请求后等待反馈信号的时间ms");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LoadCmdRevDelay, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_LoadCmdDelay");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_LoadCmdDelay);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("上料信号延时");
			Description = _T("发送上料请求上升沿的时间ms");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LoadCmdDelay, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_LoadCmdSendTims");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_LoadCmdSendTims);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("上料信号尝试次数");
			Description = _T("发送上料请求后不成功的话反复尝试次数");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_LoadCmdSendTims, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_StopStepUnloadTimes");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_StopStepUnloadTimes);
			pPropertie->SetType(_PROP_TYPE_INT);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("Unload 停止次数");
			Description = _T("连续点多少次可以强制停止unload");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_StopStepUnloadTimes, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}
	if (gAuthorityMgr->CheckAuthority(_FACTORY))
	{
		PropertyName = _T("调试功能");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);
		{
			//添加属性变量映射
			Name = _T("m_bShieldLoad");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_bShieldLoad);
			pPropertie->SetType(_PROP_TYPE_BOOL);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("屏蔽上料");
			Description = _T("跳过上料步骤");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShieldLoad, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_bShieldMarking");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_bShieldMarking);
			pPropertie->SetType(_PROP_TYPE_BOOL);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("屏蔽加工过程");
			Description = _T("跳过加工步骤");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShieldMarking, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_bShieldUnLoad");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_bShieldUnLoad);
			pPropertie->SetType(_PROP_TYPE_BOOL);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("屏蔽下料过程");
			Description = _T("跳过下料步骤");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_bShieldUnLoad, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}
	if (gAuthorityMgr->CheckAuthority(_FACTORY))
	{
		PropertyName = _T("位置管理");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);

		{
			//添加属性变量映射
			Name = _T("m_Track2Offset_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track2Offset.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("轨道2位置偏移X");
			Description = _T("轨道2相对轨道1 的偏移量X");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track2Offset.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track2Offset_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track2Offset.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("轨道2位置偏移Y");
			Description = _T("轨道2相对轨道1 的偏移量Y");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track2Offset.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}


		{
			//添加属性变量映射
			Name = _T("m_NPOffset1_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_NPCatchOffset1.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具2位置偏移X");
			Description = _T("轨道1上治具2相对治具1位置偏移量X");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_NPCatchOffset1.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_NPOffset1_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_NPCatchOffset1.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具2位置偏移Y");
			Description = _T("轨道1上治具2相对治具1位置偏移量Y");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_NPCatchOffset1.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}


		{
			//添加属性变量映射
			Name = _T("m_NPOffset2_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_NPCatchOffset2.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具4位置偏移X");
			Description = _T("轨道2上治具4相对治具3位置偏移量X");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_NPCatchOffset2.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_NPOffset2_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_NPCatchOffset2.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具4位置偏移Y");
			Description = _T("轨道2上治具4相对治具3位置偏移量Y");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_NPCatchOffset2.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}


		{
			//添加属性变量映射
			Name = _T("m_MotorXWaitCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorXWaitCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("X轴等待坐标");
			Description = _T("X轴等待坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorXWaitCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorXLoadCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorXLoadCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("X1 轴上料坐标");
			Description = _T("X1 轴上料坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorXLoadCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorXUnLoadCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorXUnLoadCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("X1 轴下料坐标");
			Description = _T("X1 轴下料坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorXUnLoadCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorXLoadZJCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorXLoadZJCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("X1送回治具");
			Description = _T("X1接送回的空治具坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorXLoadZJCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorXThrowCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorXThrowCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("X1去边框");
			Description = _T("X1去边框坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorXThrowCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorX2LoadCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorX2LoadCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("X2 轴上料坐标");
			Description = _T("X2 轴上料坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorX2LoadCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorX2UnLoadCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorX2UnLoadCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("X2 轴下料坐标");
			Description = _T("X2 轴下料坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorX2UnLoadCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorX2LoadZJCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorX2LoadZJCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("X2送回治具");
			Description = _T("X2接送回的空治具坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorX2LoadZJCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}

		{
			//添加属性变量映射
			Name = _T("m_MotorX2ThrowCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_MotorX2ThrowCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性
										//添加属性显示
			PropertyName = _T("X2去边框");
			Description = _T("X2去边框坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_MotorX2ThrowCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}



		pGroup->AddSubItem(pGroup1);
	}
	if (gAuthorityMgr->CheckAuthority(_FACTORY))
	{
		PropertyName = _T("轨道1 Y 轴区域设置");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);
		{
			//添加属性变量映射
			Name = _T("m_Track1DangerCoordStart");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track1DangerCoordStart);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("危险范围start");
			Description = _T("危险范围start");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track1DangerCoordStart, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track1DangerCoordEnd");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track1DangerCoordEnd);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("危险范围end");
			Description = _T("危险范围end");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track1DangerCoordEnd, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track1SafeCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track1SafeCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("安全坐标");
			Description = _T("安全坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track1SafeCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}
	if (gAuthorityMgr->CheckAuthority(_FACTORY))
	{
		PropertyName = _T("轨道2 Y 轴区域设置");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);
		{
			//添加属性变量映射
			Name = _T("m_Track2DangerCoordStart");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track2DangerCoordStart);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("危险范围start");
			Description = _T("危险范围start");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track2DangerCoordStart, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track2DangerCoordEnd");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track2DangerCoordEnd);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("危险范围end");
			Description = _T("危险范围end");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track2DangerCoordEnd, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track2SafeCoord");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Track2SafeCoord);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

			//添加属性显示
			PropertyName = _T("安全坐标");
			Description = _T("安全坐标");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Track2SafeCoord, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}
	


	if (gAuthorityMgr->CheckAuthority(_ADMIN))
	{
		PropertyName = _T("加工振镜偏移");
		CMFCPropertyGridProperty* pGroup1 = new CMFCPropertyGridProperty(PropertyName);
		{
			//添加属性变量映射
			Name = _T("m_Track1MarkOffset_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig1MarkOffset.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具1振镜偏移X");
			Description = _T("治具1的切割偏移X(振镜)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig1MarkOffset.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track1MarkOffset_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig1MarkOffset.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具1振镜偏移Y");
			Description = _T("治具1的切割偏移Y(振镜)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig1MarkOffset.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track2MarkOffset_x");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig3MarkOffset.x);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具3振镜偏移X");
			Description = _T("治具3的切割偏移X(振镜)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig3MarkOffset.x, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		{
			//添加属性变量映射
			Name = _T("m_Track2MarkOffset_y");//变量名字
			CPropertie *pPropertie = new CPropertie;
			pPropertie->SetpVal((void*)&m_Jig3MarkOffset.y);
			pPropertie->SetType(_PROP_TYPE_DOUBLE);
			pPropertie->SetpModule(this);
			pPropertie->SetPath(Path);
			pPropertie->SetName(Name);
			pPropertie->WriteRead(true);//读取保存的属性

										//添加属性显示
			PropertyName = _T("治具3振镜偏移Y");
			Description = _T("治具3的切割偏移Y(振镜)");
			CMFCPropertyGridProperty* p = new CMFCPropertyGridProperty(PropertyName, (_variant_t)m_Jig3MarkOffset.y, Description);
			//p->AllowEdit(FALSE);//不可修改
			pGroup1->AddSubItem(p);
			PropertieMgr.Insert(p, pPropertie);
		}
		pGroup->AddSubItem(pGroup1);
	}

	return pGroup;
}
void CProgram_SZ_XL::Ini()
{
	//设置串口参数
	gTrackWorkFlow1.SetComPar(m_TrackComPort1, m_ComBaudRate);
	gTrackWorkFlow2.SetComPar(m_TrackComPort2, m_ComBaudRate);
	//启动WorkFlow 管理线程
	gTrackWorkFlow1.WorkFlowStart();
	gTrackWorkFlow2.WorkFlowStart(false);

	CFileMgr FileMgr;
	CString DirPath;
	FileMgr.GetFullFilePath(DirPath, CUT_PAR_DIR);
	//创建目录
	if (!FileMgr.IsDirectoryExists(DirPath))
	{
		FileMgr.CreatDir(DirPath);
	}
	//读取加工次数
	gTrackWorkFlow1.ReadRecordTimesFromFile();
	gTrackWorkFlow2.ReadRecordTimesFromFile();
	//初始化上料机通信串口
	InitLoadDeviceCom();

}
//退出软件时
void CProgram_SZ_XL::OnExitApp()
{
	//复位上料机和下料机的请求信号
	ResetLoadUnloadSignal();
}
CTrackWorkFlow* CProgram_SZ_XL::GetTrackWorkFlow(ETrackType TrackType)
{
	if (TrackType == _ETrackType_Track_1)
		return &gTrackWorkFlow1;
	else
		return &gTrackWorkFlow2;
}
//获取另外一个轨道的对象
CTrackWorkFlow* CProgram_SZ_XL::GetOtherTrackWorkFlow(ETrackType TrackType)
{
	if (TrackType == _ETrackType_Track_1)
		return &gTrackWorkFlow2;
	else
		return &gTrackWorkFlow1;
}
//初始化设备
void CProgram_SZ_XL::InitDevice()
{
	if (IsbAutoWorking())
	{
		CMsgBox MsgBox;
		MsgBox.Show("自动运行中,不能初始化设备!");
		return;
	}
	//检查下料机状态
	if (m_bCheckUnloadState && gMotionCard_PCI1245->CheckUnloadState() == false)
	{
		CMsgBox MsgBox;
		MsgBox.Show("下料机在轨道上,不能初始化设备!");
		return;
	}
	if (gCommonFlowMgr->InitDevice())
	{
		//初始化上料机plc 通信
		OpenPlcCtrl();
		//复位上料机和下料机的请求信号
		ResetLoadUnloadSignal();
	}
}
//复位上料机和下料机的请求信号
void CProgram_SZ_XL::ResetLoadUnloadSignal()
{
	//取消下料请求
	CancelUnloadRequest(_ETrackType_Track_1);
	Sleep(500);
	CancelUnloadRequest(_ETrackType_Track_2);
	//复位上料机所有请求信号
	SendMsgToLoadDevice(_ETrackType_Track_1, _ETrack_Step_Reset_Load_Request, false);
}
//是否处于自动运行中
bool CProgram_SZ_XL::IsbAutoWorking()
{
	return (gTrackWorkFlow1.IsbAutoWorking() || gTrackWorkFlow2.IsbAutoWorking());
}
//开始自动加工
void CProgram_SZ_XL::StartAutoWork(ETrackType TrackType)
{
#ifdef  _USE_LAIPU_SUPERDOG
	if (gEncryptionMgr->CheckLockState() == false&&(!gLogMgr->IsDebuging()))
	{
		return;
	}
#endif
	CDeviceState &DeviceState = CDeviceState::GetInstance();
	if (!DeviceState.IsDeviceIni())
	{
		CMsgBox MsgBox;
		MsgBox.Show("设备未初始化!");
		return;
	}
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	if (pTrackWorkFlow->StartAutoWork())
	{
		if (IsbAutoWorking())
			gTrackWorkFlow1.SendAutoStartFlg(true);//打开风机
		else
			gTrackWorkFlow1.SendAutoStartFlg(false);//关闭风机
	}
}
void CProgram_SZ_XL::StopAutoWork()
{
	gTrackWorkFlow1.StopAutoWork();
	gTrackWorkFlow2.StopAutoWork();
}
//手动操作
void CProgram_SZ_XL::ManualOperation(ETrackType TrackType, ETrackWorkStep TrackWorkStep)
{
	CDeviceState &DeviceState = CDeviceState::GetInstance();
	if (!DeviceState.IsDeviceIni())
	{
		CMsgBox MsgBox;
		MsgBox.Show("设备未初始化!");
		return;
	}
	if (TrackWorkStep != _ETrack_Step_Load_End)
	{
		if (gAuthorityMgr->CheckAuthority(_FACTORY, true) == false)//手动操作需要厂家权限
			return;
	}
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	pTrackWorkFlow->ManualOperation(TrackWorkStep);
}
double CProgram_SZ_XL::GetMoveCoord(ETrackType TrackType, ETrackWorkStep WorkStep)
{
	double Coord = 0;
	switch (WorkStep)
	{
	case _ETrack_Step_Load://上料
		if (TrackType == _ETrackType_Track_1)
			Coord = m_MotorXLoadCoord;
		else
			Coord = m_MotorX2LoadCoord;
		break;

	case _ETrack_Step_Throw_Edge://去边框
		if (TrackType == _ETrackType_Track_1)
			Coord = m_MotorXThrowCoord;
		else
			Coord = m_MotorX2ThrowCoord;
		break;

	case _ETrack_Step_To_Wait_Pos://等待位置
		Coord = m_MotorXWaitCoord;
		break;

	case _ETrack_Step_Unload://下料
		if (TrackType == _ETrackType_Track_1)
			Coord = m_MotorXUnLoadCoord;
		else
			Coord = m_MotorX2UnLoadCoord;
		break;

	case _ETrack_Step_WaitBack://等送回治具
		if (TrackType == _ETrackType_Track_1)
			Coord = m_MotorXLoadZJCoord;
		else
			Coord = m_MotorX2LoadZJCoord;
		break;
	default:
		break;
	}
	return Coord;
}
//获取轨道单独的切割偏移量
Dbxy CProgram_SZ_XL::GetTrackMarkOffset(ETrackType TrackType)
{
	Dbxy MarkOffset;
	if (TrackType == _ETrackType_Track_1)
		MarkOffset = m_Jig1MarkOffset;
	else
		MarkOffset = m_Jig3MarkOffset;
	return MarkOffset;
}
/*
Dbxy CProgram_SZ_XL::GetTrackMarkPosOffset(ETrackType TrackType)
{
	Dbxy MarkOffset;
	if (TrackType == _ETrackType_Track_1)
		MarkOffset = m_Track1MarkPosOffset;
	else
		MarkOffset = m_Track2MarkPosOffset;
	return MarkOffset;
}*/
//打开,夹紧载盘/真空
void CProgram_SZ_XL::ProductCarrierOpenClose(ETrackType TrackType, bool bOpen)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	if (pTrackWorkFlow->IsbAutoWorking() == false)//自动过程不能手动操作
	{
		pTrackWorkFlow->ProductCarrierOpenClose(bOpen);
		Sleep(100);
		pTrackWorkFlow->VacSorbOnOff(!bOpen);
	}
}
//获取当前加工的数量
int CProgram_SZ_XL::GetCutProductCnt(ETrackType TrackType)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	return pTrackWorkFlow->GetCutProductCnt();
}
ETrackWorkStep CProgram_SZ_XL::GetCurTrackWorkStep(ETrackType TrackType)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	return pTrackWorkFlow->GetCurTrackWorkStep();
}
//获取另外一个轨道的工作状态
ETrackWorkStep CProgram_SZ_XL::GetOtherTrackWorkStep(ETrackType TrackType)
{
	CTrackWorkFlow*pTrackWorkFlow = GetOtherTrackWorkFlow(TrackType);
	return pTrackWorkFlow->GetCurTrackWorkStep();
}
//获取轨道Y 轴的坐标范围(危险区域/安全坐标)
void CProgram_SZ_XL::GetTrackMotorYCoord(ETrackType TrackType, double &DangerCoordStart, double &DangerCoordEnd, double &SafeCoord)
{
	if (TrackType == _ETrackType_Track_1)
	{
		DangerCoordStart = m_Track1DangerCoordStart;//危险范围start
		DangerCoordEnd = m_Track1DangerCoordEnd;//危险范围end
		SafeCoord = m_Track1SafeCoord;//安全坐标
	}
	else
	{
		DangerCoordStart = m_Track2DangerCoordStart;//危险范围start
		DangerCoordEnd = m_Track2DangerCoordEnd;//危险范围end
		SafeCoord = m_Track2SafeCoord;//安全坐标
	}
}
//移动Y 轴到安全坐标
void CProgram_SZ_XL::MoveMotorYToSafePos(ETrackType TrackType)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	pTrackWorkFlow->MoveMotorYToSafePos();
}
//取消下料请求
void CProgram_SZ_XL::CancelUnloadRequest(ETrackType TrackType)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	pTrackWorkFlow->CancelUnloadRequest();
}
//设置当前循环后停止
void CProgram_SZ_XL::SetbCircleStop(ETrackType TrackType, bool bStop)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	pTrackWorkFlow->SetbCircleStop(bStop);
}
bool CProgram_SZ_XL::GetbCircleStop(ETrackType TrackType)
{
	CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
	return pTrackWorkFlow->GetbCircleStop();
}
#if 1
//保存dxf 对应的切割参数
void CProgram_SZ_XL::SaveCutPar()
{
	CString FilePath;
	if (GetDxfParFilePath("par", FilePath))
	{
		CWorkFileMgr WorkFileMgr;
		WorkFileMgr.SaveCutParFile(FilePath);

		//保存一个同名的area 文件
		CString AreaFilePath;
		GetDxfParFilePath("are", AreaFilePath);
		CFile file(AreaFilePath, CFile::modeReadWrite | CFile::modeCreate);
		CArchive ar(&file, CArchive::store);
		gMarkAreaMgr->SaveOrLoadExt(ar);
	}
}
//读取dxf 对应的切割参数
void CProgram_SZ_XL::ReadCutPar()
{
	CString FilePath;
	if (GetDxfParFilePath("par", FilePath))
	{
		CWorkFileMgr WorkFileMgr;
		WorkFileMgr.ReadWorkFile(FilePath);

		//调出对应的area 文件
		CString AreaFilePath;
		GetDxfParFilePath("are", AreaFilePath);
		CFile file;
		if (file.Open(AreaFilePath, CFile::modeRead))
		{
			CArchive ar(&file, CArchive::load);
			gMarkAreaMgr->SaveOrLoadExt(ar);
			gLogMgr->WriteDebugLog("OpenArea:" + AreaFilePath);
			file.Close();
		}
	}
	else
	{
		gCommonFlowMgr->ResetProductOffset();
	}
}
bool CProgram_SZ_XL::GetDxfParFilePath(CString Suffix, CString &FilePath)
{
	CString OpenFileName = gProgramCutMgr->GetCurOpenFileName();
	if (OpenFileName != "")
	{
		CString Path = CUT_PAR_DIR;
		Path += OpenFileName;
		Path += "." + Suffix;
		CFileMgr FileMgr;
		FileMgr.GetFullFilePath(FilePath, Path);
		return true;
	}
	return false;
}
void CProgram_SZ_XL::ResetRecordTimes(ETrackType TrackType)
{
	CMsgBox MsgBox;
	if (MsgBox.ConfirmOkCancel("加工次数清零?"))
	{
		CTrackWorkFlow *pTrackWorkFlow = GetTrackWorkFlow(TrackType);
		pTrackWorkFlow->ResetRecordTimes();
	}
}
#endif

#if 1//上料相关功能

void CProgram_SZ_XL::ReadLoadPlcMsg()
{
	while (!gExitApp)
	{
		if (gExitApp)
			break;

		ETrackWorkStep Track1WorkStep = gTrackWorkFlow1.GetCurTrackWorkStep();
		ETrackWorkStep Track2WorkStep = gTrackWorkFlow2.GetCurTrackWorkStep();
		bool ReadMsg = false;
		if (Track1WorkStep == _ETrack_Step_Load || Track1WorkStep == _ETrack_Step_Throw_Edge || Track1WorkStep == _ETrack_Step_Unload\
			|| Track2WorkStep == _ETrack_Step_Load || Track2WorkStep == _ETrack_Step_Throw_Edge || Track2WorkStep == _ETrack_Step_Unload)
		{
			ReadMsg = true;
		}
		if (m_bStopReadMsg)
		{
			Sleep(100);
			continue;
		}
		Sleep(300);
		if (ReadMsg)//只有load/unload 和去边框时才读取
		{
			ReadLoadPlcMsgExt();
		}
	}
}
//读取上料PLC 的状态
void CProgram_SZ_XL::ReadLoadPlcMsgExt()
{
	char Buf[BUF_LEN];
	/* CString Str = ("@00RD0512000151*");//查询指令
	 int len = CreatBuf(Buf,Str);
	 m_LoadDeviceCOM.WriteBuf(Buf,len);
	 Sleep(100); */
	 //读取反馈
	memset(Buf, 0, BUF_LEN);

	int rcvLen = m_LoadDeviceCOM.Read(Buf, BUF_LEN);
	//m_LoadDeviceCOM.ReadBuf(Buf,BUF_LEN);
	if (rcvLen > 1)
	{
		CString RecvStr(Buf);
		AnalyzeRecvLoadMsg(RecvStr);
	}
}
//分析收到上料机的PLC 消息
void CProgram_SZ_XL::AnalyzeRecvLoadMsg(CString &RecvStr)
{
	CString LogStr="未解析的指令!";
	bool ret = false;

	if (gTrackWorkFlow1.GetCurTrackWorkStep() == _ETrack_Step_Unload)//只有unload 中收到信号才算
	{
		if (RecvStr.Find("$(KL1D1)#", 0) != -1)//轨道1 下料完成
		{
			if (gProgram_SZ_XL->GetbCircleStop(_ETrackType_Track_1) || (!gTrackWorkFlow1.IsbAutoWorking()))//当前循环停止或手动下料
			{
				gTrackWorkFlow1.SetbCircleStop(false);
				GetFrame()->m_DlgSW_XL_Flow.ResetCircleStopCheck(_ETrackType_Track_1);//自动恢复check 状态
				CString Log = "轨道1  Circle Stop.";
				gLogMgr->WriteDebugLog(Log);
				gTrackWorkFlow1.StopAutoWork();//停止自动运行
			}
			else
			{
				gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Unload_End);
			}
			LogStr = "轨道1 下料完成";
		}
		if (RecvStr.Find("$(KL1E)#", 0) != -1)//轨道1 下料错误
		{
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Unload_Err);
			LogStr = "轨道1 下料错误";
		}
		if (RecvStr.Find("$(KL7D1)#", 0) != -1)//轨道1拉出载具完成
		{
			gTrackWorkFlow1.m_bPullJigOut = true;
			LogStr = "轨道1载具拉出";
		}
		if (RecvStr.Find("$(KL9D1)#", 0) != -1)//轨道1可推出
		{
			gTrackWorkFlow1.m_bPushJigReady = true;
			LogStr = "轨道1载具可推出";
		}
		if (RecvStr.Find("$(KL9E)#", 0) != -1)//轨道1不可推出
		{			
			gTrackWorkFlow1.m_bPushJigReady = false;
			LogStr = "轨道1载具不可推出--from下料机";
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Unload_Err);
		}
		ret = true;
	}

	if (gTrackWorkFlow2.GetCurTrackWorkStep() == _ETrack_Step_Unload)//只有load 中收到信号才算
	{
		if (RecvStr.Find("$(KL2D1)#", 0) != -1)//轨道2 下料完成
		{
			if (gProgram_SZ_XL->GetbCircleStop(_ETrackType_Track_2) || (!gTrackWorkFlow2.IsbAutoWorking()) )//当前循环停止
			{
				gTrackWorkFlow2.SetbCircleStop(false);
				GetFrame()->m_DlgSW_XL_Flow.ResetCircleStopCheck(_ETrackType_Track_2);//自动恢复check 状态
				CString Log = "轨道1  Circle Stop.";
				gLogMgr->WriteDebugLog(Log);
				gTrackWorkFlow2.StopAutoWork();//停止自动运行
			}
			else
			{
				gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Unload_End);
			}
			LogStr = "轨道2 下料完成";
		}
		if (RecvStr.Find("$(KL2E)#", 0) != -1)//轨道2 下料错误
		{
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Unload_Err);
			LogStr = "轨道2 下料错误";
		}
		if (RecvStr.Find("$(KL8D1)#", 0) != -1)//轨道1拉出载具完成
		{
			//gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_PulledOut);
			gTrackWorkFlow2.m_bPullJigOut = true;
			LogStr = "轨道2载具拉出";
		}
		if (RecvStr.Find("$(KL10D1)#", 0) != -1)//轨道1拉出载具完成
		{
			gTrackWorkFlow2.m_bPushJigReady = true;
			LogStr = "轨道2载具可推出";
		}
		if (RecvStr.Find("$(KL10E)#", 0) != -1)//轨道1拉出载具完成
		{
			gTrackWorkFlow2.m_bPushJigReady = false;
			LogStr = "轨道2载具不可推出--from下料机";
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Unload_Err);
		}
		ret = true;
	}



	if (gTrackWorkFlow1.GetCurTrackWorkStep() == _ETrack_Step_Load)//只有load 中收到信号才算
	{
		if (RecvStr.Find("$(KL3D1)#", 0) != -1)//轨道1 上料完成
		{
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Load_End);
			LogStr = "轨道1 上料完成";
		}
		if (RecvStr.Find("$(KL3E)#", 0) != -1)//轨道1 上料错误
		{
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Load_Err);
			LogStr = "轨道1 上料错误";
		}
		ret = true;
	}

	if (gTrackWorkFlow2.GetCurTrackWorkStep() == _ETrack_Step_Load)
	{
		if (RecvStr.Find("$(KL4D1)#", 0) != -1)//轨道2 上料完成
		{
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Load_End);
			LogStr = "轨道2 上料完成";
		}
		if (RecvStr.Find("$(KL4E)#", 0) != -1)//轨道2 上料完成
		{
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Load_Err);
			LogStr = "轨道2 上料错误";
		}
		ret = true;
	}


	if (gTrackWorkFlow1.GetCurTrackWorkStep() == _ETrack_Step_Throw_Edge)
	{
		if (RecvStr.Find("$(KL5D1)#", 0) != -1)//轨道1 去边框完成(01000000)
		{
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_End);
			LogStr = "轨道1 去边框完成";
		}

		if (RecvStr.Find("$(KL5E)#", 0) != -1)//轨道1 去边框完成(01000000)
		{
			gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_Err);
			LogStr = "轨道1 去边框错误";
		}
		ret = true;
	}

	if (gTrackWorkFlow2.GetCurTrackWorkStep() == _ETrack_Step_Throw_Edge)
	{
		if (RecvStr.Find("$(KL6D1)#", 0) != -1)//轨道2 去边框完成(10000000)
		{
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_End);
			LogStr = "轨道2 去边框完成";
		}
		if (RecvStr.Find("$(KL6E)#", 0) != -1)//轨道2 去边框完成(10000000)
		{
			gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_Err);
			LogStr = "轨道2 去边框错误";
		}
		ret = true;
	}


	/*
		 else if(RecvStr.Find("@00RD00000C25*",0) != -1)//轨道1 上料完成//轨道2 上料完成(00001100)
		 {
			   if(gTrackWorkFlow1.GetCurTrackWorkStep()==_ETrack_Step_Load)
			   {
					gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Load_End);
					Sleep(500);
					LogStr1 = "轨道1 上料完成";
			   }
			   if(gTrackWorkFlow2.GetCurTrackWorkStep()==_ETrack_Step_Load)
			   {
					gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Load_End);
					LogStr2 = "轨道2 上料完成";
			   }
			   ret = true;
		 }
		 else if(RecvStr.Find("@00RD0000845A*",0) != -1)//轨道1 上料完成//轨道2 去边框完成(10000100)
		 {
			   if(gTrackWorkFlow1.GetCurTrackWorkStep()==_ETrack_Step_Load)
			   {
					gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Load_End);
					Sleep(500);
					LogStr1 = "轨道1 上料完成";
			   }
			   if(gTrackWorkFlow2.GetCurTrackWorkStep()==_ETrack_Step_Throw_Edge)
			   {
					gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_End);
					LogStr2 = "轨道2 去边框完成";
			   }
			   ret = true;
		 }
		 else if(RecvStr.Find("@00RD0000485A*",0) != -1)//轨道1 去边框完成//轨道2 上料完成(01001000)
		 {
			   if(gTrackWorkFlow1.GetCurTrackWorkStep()==_ETrack_Step_Throw_Edge)
			   {
					 gTrackWorkFlow1.SetCurTrackWorkStep(_ETrack_Step_Throw_Edge_End);
					 Sleep(500);
					 LogStr1 = "轨道1 去边框完成";
			   }
			   if(gTrackWorkFlow2.GetCurTrackWorkStep()==_ETrack_Step_Load)
			   {
					 gTrackWorkFlow2.SetCurTrackWorkStep(_ETrack_Step_Load_End);
					 LogStr2 = "轨道2 上料完成";
			   }
			   ret = true;
		 }*/

	//if (ret)
	{
		//gLogMgr->WriteDebugLog("ReadLoadDeviceMsg: "+RecvStr);
		CString str = "ReadLoadDeviceMsg: " + RecvStr+"==> ";
		gLogMgr->WriteDebugLog(str+LogStr);
	}
	/*else
	{
		CString str = "ReadLoadDeviceMsg: " + RecvStr + "==> 未能解析的指令!";
		gLogMgr->WriteDebugLog(str );
	}*/
}

#include <mutex>

mutex IniTex;

//初始化上料机通信串口
void CProgram_SZ_XL::InitLoadDeviceCom()
{
	IniTex.lock();
	static bool  bThreadStart = false;
	//打开上料机plc 通信用串口
	if (!bThreadStart)
	{
		if (m_LoadDeviceCOM.Open(m_LoadComPort, "115200,n,8,1"))
		{
			CString LogStr;
			LogStr.Format(_T("上料机通信串口 %d 打开成功"), m_LoadComPort);
			gLogMgr->WriteDebugLog(LogStr);
			if (OpenPlcCtrl())
			{
				m_bLoadDeviceSuc = true;
				if (!bThreadStart)
				{
					bThreadStart = true;
					//启动读取plc 消息的线程
					AfxBeginThread(ReadLoadPlcMsgThread, this);
				}
			}
		}
		else
		{
			CString LogStr;
			LogStr.Format(_T("上料机通信串口 %d 打开失败"), m_LoadComPort);
			gLogMgr->WriteDebugLog(LogStr);
		}
	}
	IniTex.unlock();
}
//开机发送一次,检查通信是否正常
bool CProgram_SZ_XL::OpenPlcCtrl()
{
	return true;
	char Buf[BUF_LEN];
	CString Str = ("@00SC0252*");
	int len = CreatBuf(Buf, Str);
	m_LoadDeviceCOM.WriteBuf(Buf, len);
	Sleep(m_LoadCmdRevDelay);
	//读取反馈
	memset(Buf, 0, BUF_LEN);
	m_LoadDeviceCOM.ReadBuf(Buf, BUF_LEN);

	Str = ("@00SC0050*");
	if (CompareBuf(Buf, Str))
	{
		gLogMgr->WriteDebugLog("OpenPlcCtrl Suc Rev = " + Str);
		return true;
	}
	gLogMgr->WriteDebugLog("OpenPlcCtrl Err 失败");
	return false;
}
//把str 的内容放到Buf
int CProgram_SZ_XL::CreatBuf(char *Buf, CString str)
{
	int len = str.GetLength();
	int k = 0;
	for (;k < len;k++)
	{
		Buf[k] = str[k];
	}
	Buf[k++] = char(13);
	Buf[k++] = char(10);
	return k;
}
//比较buf 的内容是否和str 相等
bool CProgram_SZ_XL::CompareBuf(char *Buf, CString str)
{
	int len = str.GetLength();
	for (int k = 0;k < len;k++)
	{
		if (Buf[k] != str[k])
			return false;
	}
	return true;
}
//获取发送字符串
bool CProgram_SZ_XL::GetLoadCmdStr(ETrackType TrackType, ETrackWorkStep WorkStep, CString &StrOn, CString &StrOnRev, CString &StrOff, CString &StrOffRev)
{
	CString LogStr;
	bool Ret = false;
	if (WorkStep == _ETrack_Step_Load)//上料
	{
		if (_ETrackType_Track_1 == TrackType)
		{
			StrOn = "$(KL3)#";
			//StrOff = "@00WD0507000051*";
			LogStr = "轨道1 上料请求";
		}
		else
		{
			StrOn = "$(KL4)#";
			//StrOff = "@00WD050800005E*";
			LogStr = "轨道2 上料请求";
		}
		Ret = true;
	}
	else if (WorkStep == _ETrack_Step_Throw_Edge)//去边框
	{
		if (_ETrackType_Track_1 == TrackType)
		{
			StrOn = "$(KL5)#";
			//StrOff = "@00WD050900005F*";
			LogStr = "轨道1去边框请求";
		}
		else
		{
			StrOn = "$(KL6)#";
			//StrOff = "@00WD0510000057*";
			LogStr = "轨道2去边框请求";
		}
		Ret = true;
	}
	else if (WorkStep == _ETrack_Step_Unload)//下料
	{
		if (_ETrackType_Track_1 == TrackType)
		{
			StrOn = "$(KL1)#";
			//StrOff = "@00WD050900005F*";
			LogStr = "轨道1下料请求";
		}
		else
		{
			StrOn = "$(KL2)#";
			//StrOff = "@00WD0510000057*";
			LogStr = "轨道2下料请求";
		}
		Ret = true;
	}
	else if (WorkStep == _ETrack_Step_WaitBack)//等待送回载具
	{
		if (_ETrackType_Track_1 == TrackType)
		{
			StrOn = "$(KL7)#";
			//StrOff = "@00WD050900005F*";
			LogStr = "轨道1可送回治具";
		}
		else
		{
			StrOn = "$(KL8)#";
			//StrOff = "@00WD0510000057*";
			LogStr = "轨道2可送回治具";
		}
		Ret = true;
	}
	else if (WorkStep == _ETrack_Step_PushOut_Finished)//等待送回载具
	{
		if (_ETrackType_Track_1 == TrackType)
		{
			StrOn = "$(KL9)#";
			//StrOff = "@00WD050900005F*";
			LogStr = "通知下料机:轨道1推出治具完成";
		}
		else
		{
			StrOn = "$(KL10)#";
			//StrOff = "@00WD0510000057*";
			LogStr = "通知下料机:轨道2推出治具完成";
		}
		Ret = true;
		gLogMgr->WritePlcTimeLog(LogStr);
	}
	if (Ret)
	{
		// gLogMgr->WriteDebugLog("Str1 = "+StrOn);
		 //gLogMgr->WriteDebugLog("Str2 = "+StrOff);
		LogStr = "SendLoadDeviceMsg: " + StrOn + "==>" + LogStr;
		gLogMgr->WriteDebugLog(LogStr);
	}
	return Ret;
}
//发送消息给上料机(bCheckRev 是否检查反馈信号) 弃用
//发送消息给plc(bCheckRev 是否检查反馈信号)

mutex SendMutex;

bool CProgram_SZ_XL::SendMsgToLoadDevice(ETrackType TrackType, ETrackWorkStep WorkStep, bool bCheckRev)
{

	if (!m_bLoadDeviceSuc)
	{
		CMsgBox MsgBox;
		MsgBox.Show("上料机通信 失败");
		return false;
	}

	lock_guard<mutex> lock(SendMutex);

	while (m_bLoadCOMLockerFlg)//等待
	{
		Sleep(100);
	}

	m_bStopReadMsg = true;//暂停读取
	Sleep(400);

	m_bLoadCOMLockerFlg = true;//锁定

	bool Ret = false;
	CString StrOn, StrOnRev;
	CString StrOff, StrOffRev;
	if (GetLoadCmdStr(TrackType, WorkStep, StrOn, StrOnRev, StrOff, StrOffRev))
	{
		char Buf[BUF_LEN];
		int len = CreatBuf(Buf, StrOn);
		m_LoadDeviceCOM.ClearCache();
		m_LoadDeviceCOM.WriteBuf(Buf, len);
		//gLogMgr->WriteDebugLog("SendMsgToLoadDevice: "+StrOn);
		/* Sleep(100);
		 m_LoadDeviceCOM.WriteBuf(Buf,len);//再发一次
		 Sleep(m_LoadCmdDelay);//等待plc 检测到上升沿的时间
		 len = CreatBuf(Buf,StrOff);
		 m_LoadDeviceCOM.WriteBuf(Buf,len);
		 Sleep(100);
		 m_LoadDeviceCOM.WriteBuf(Buf,len);	//再发一次*/
		Ret = true;
	}

	m_bLoadCOMLockerFlg = false;//解锁

	m_bStopReadMsg = false;//恢复读取
	return Ret;
}
//发送消息并检查反馈(发送SendMsg 并检查反馈信号是否为RevMsg)
/*
bool CProgram_SZ_XL::SendMsgToLoadPlc(CString &SendMsg, CString &RevMsg)
{
	return true;
}*/

#endif