From c61f379dd97c71e4bc546dc4e188be360d8d62d3 Mon Sep 17 00:00:00 2001 From: wangxx1809 Date: Wed, 27 Mar 2024 16:09:22 +0800 Subject: [PATCH] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=E5=8F=82=E6=95=B0=E6=98=A0?= =?UTF-8?q?=E5=B0=84=E5=8A=9F=E8=83=BD=E7=AD=89?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- PrintS/Config/ConfigManager.cpp | 2 +- PrintS/DataManage/ClientInfo.h | 4 +- PrintS/DataManage/DataHandle.cpp | 14 +- PrintS/DataManage/DataHandle.h | 2 +- PrintS/DataManage/StreamServer.h | 4 +- PrintS/Machine/HBD1000.cpp | 620 +++++++++++++++++++++++++++++- PrintS/Machine/HBD1200.cpp | 634 +++++++++++++++++++++---------- PrintS/Machine/Machine.h | 31 +- PrintS/PLC/SysParam.cpp | 13 +- PrintS/PLC/SysParam.h | 12 +- PrintS/PrintS.vcxproj | 2 +- PrintS/main.cpp | 55 +-- PrintS/output/Release/config.hbd | Bin 229376 -> 241664 bytes PrintS/utils/DataByte.h | 2 +- PrintS/说明.txt | 3 + 15 files changed, 1126 insertions(+), 272 deletions(-) diff --git a/PrintS/Config/ConfigManager.cpp b/PrintS/Config/ConfigManager.cpp index 07ca99f..cd800bd 100644 --- a/PrintS/Config/ConfigManager.cpp +++ b/PrintS/Config/ConfigManager.cpp @@ -114,7 +114,7 @@ void ConfigManager::PreInit() void ConfigManager::Init() { - m_Machine = Machine::CreateInstance(m_MachineCfg.m_MachineType); + m_Machine = Machine::CreateInstance(MachineTypeCfg::HBD_1000/*m_MachineCfg.m_MachineType*/); m_LoadCfg = m_Machine->CreateLoadAxisCfg(); m_MoldCfg = m_Machine->CreateMoldAxisCfg(); diff --git a/PrintS/DataManage/ClientInfo.h b/PrintS/DataManage/ClientInfo.h index ccc0c75..351136a 100644 --- a/PrintS/DataManage/ClientInfo.h +++ b/PrintS/DataManage/ClientInfo.h @@ -36,13 +36,15 @@ enum READTYPE { }; enum DATATYPE { - iBOOL =0, + iBOOL = 0, iSHORT, iUSHORT, iINT, iUINT, iFLOAT, iSTRING, + + iWORD, }; class ClientInfo; diff --git a/PrintS/DataManage/DataHandle.cpp b/PrintS/DataManage/DataHandle.cpp index 3ef0694..f5ce4f2 100644 --- a/PrintS/DataManage/DataHandle.cpp +++ b/PrintS/DataManage/DataHandle.cpp @@ -6,7 +6,10 @@ DataHandle::DataHandle() : m_dataCallBack(nullptr) - , m_streamServer(nullptr){ + , m_streamServer(nullptr) + , m_config(nullptr) + , m_controler(nullptr) + , m_testFlag(false){ } @@ -28,19 +31,21 @@ void DataHandle::Init() { m_config->Init(); + //WriteData(); + m_streamServer = new StreamServer(m_config->GetMachine()); //测试线程 m_testTd = std::thread ([this] { static float i = 10.12540f; - while (1) { + while (!m_testFlag) { WriteData* wd = new WriteData(); wd->dataType = RESPOND; wd->strValue = std::to_string(i); wd->nameKey = "hello"; wd->result = true; wd->valueType = iFLOAT; - if (m_streamServer->GetClient()) + if (m_streamServer && m_streamServer->GetClient()) m_streamServer->GetClient()->SetPushMsg(wd); std::this_thread::sleep_for(std::chrono::seconds(1)); } @@ -60,6 +65,9 @@ void DataHandle::Run() { } void DataHandle::Stop() { + m_testFlag = true; + if (m_testTd.joinable()) m_testTd.join(); + m_streamServer->Stop(); } diff --git a/PrintS/DataManage/DataHandle.h b/PrintS/DataManage/DataHandle.h index 6bcc345..1e75001 100644 --- a/PrintS/DataManage/DataHandle.h +++ b/PrintS/DataManage/DataHandle.h @@ -22,7 +22,7 @@ private: ConfigManager* m_config; Controler* m_controler; - + bool m_testFlag; //测试线程 public: StreamServer* m_streamServer; diff --git a/PrintS/DataManage/StreamServer.h b/PrintS/DataManage/StreamServer.h index 885a386..a3f842a 100644 --- a/PrintS/DataManage/StreamServer.h +++ b/PrintS/DataManage/StreamServer.h @@ -17,8 +17,6 @@ using stream::RequestInfo; using stream::ResponseInfo; - - class StreamServer final : public Stream::Service { typedef void (*DataCallBack)(void* pthis,const ReadData& msg); typedef void (*ClientStateCallBack)(void* pthis,const ReadData& msg); @@ -39,7 +37,7 @@ public: ClientInfo* GetClient() { std::lock_guard lck(m_clientMutex); - return m_clientList.front(); + return m_clientList.empty() ? nullptr : m_clientList.front(); } ClientInfo* GetAllClient() { diff --git a/PrintS/Machine/HBD1000.cpp b/PrintS/Machine/HBD1000.cpp index 0ea4ae5..2fc64fa 100644 --- a/PrintS/Machine/HBD1000.cpp +++ b/PrintS/Machine/HBD1000.cpp @@ -8,6 +8,7 @@ #include "../Toast.h" #include "../SystemInfo.h" #include "../Logger.h" +//#include "../utils/DataKey.hpp" HBD1000::HBD1000(MachineTypeCfg::MachineTypeId type) :Machine(type) { @@ -11219,6 +11220,16 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_MotionDebug = new SysParamBool(flag++, 1, cc); //动作流程调试模式 m_SignalStateWrapper->m_CylinderExceptionReset = new SysParamBool(flag++, 1, cc); //气缸异常复位 + m_plcMp.insert(make_pair("PLCKeepAlive", DValue(m_SignalStateWrapper->m_PLCKeepAlive))); + m_plcMp.insert(make_pair("PCKeepAlice", DValue(m_SignalStateWrapper->m_PCKeepAlice))); + m_plcMp.insert(make_pair("DeviceStandby", DValue(m_SignalStateWrapper->m_DeviceStandby))); + m_plcMp.insert(make_pair("DevicePrinting", DValue(m_SignalStateWrapper->m_DevicePrinting))); + m_plcMp.insert(make_pair("DeviceManualDebug", DValue(m_SignalStateWrapper->m_DeviceManualDebug))); + m_plcMp.insert(make_pair("DeviceAutoRuning", DValue(m_SignalStateWrapper->m_DeviceAutoRuning))); + m_plcMp.insert(make_pair("TouchPanelCtrling", DValue(m_SignalStateWrapper->m_TouchPanelCtrling))); + m_plcMp.insert(make_pair("MotionDebug", DValue(m_SignalStateWrapper->m_MotionDebug))); + m_plcMp.insert(make_pair("CylinderExceptionReset", DValue(m_SignalStateWrapper->m_CylinderExceptionReset))); + flag = 55 * 8 + 6; m_SignalStateWrapper->m_PLCConnectAlarm = new SysParamBool(flag++, 1, cc); //PC与PLC网络异常 m_SignalStateWrapper->m_SystemStopAlarm = new SysParamBool(flag++, 1, cc); //系统急停异常 @@ -11238,6 +11249,25 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_Laser4Alarm = new SysParamBool(flag++, 1, cc); //激光器4报警 m_SignalStateWrapper->m_HeatingInputAlarm = new SysParamBool(flag++, 1, cc); //加热输入异常 m_SignalStateWrapper->m_HeatingOutputAlarm = new SysParamBool(flag++, 1, cc); //加热输出异常 + m_plcMp.insert(make_pair("PLCConnectAlarm", DValue(m_SignalStateWrapper->m_PLCConnectAlarm))); + m_plcMp.insert(make_pair("SystemStopAlarm", DValue(m_SignalStateWrapper->m_SystemStopAlarm))); + m_plcMp.insert(make_pair("HighPressureLackAlarm", DValue(m_SignalStateWrapper->m_HighPressureLackAlarm))); + m_plcMp.insert(make_pair("ProtectGasLackAlarm", DValue(m_SignalStateWrapper->m_ProtectGasLackAlarm))); + m_plcMp.insert(make_pair("PowerDownAlarm", DValue(m_SignalStateWrapper->m_PowerDownAlarm))); + m_plcMp.insert(make_pair("OutsideOxygenLackAlarm", DValue(m_SignalStateWrapper->m_OutsideOxygenLackAlarm))); + m_plcMp.insert(make_pair("LaserChillerAlarm", DValue(m_SignalStateWrapper->m_LaserChillerAlarm))); + m_plcMp.insert(make_pair("BusAirSwitchAlarm", DValue(m_SignalStateWrapper->m_BusAirSwitchAlarm))); + m_plcMp.insert(make_pair("ExtDevicePowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_ExtDevicePowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("HeatingPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_HeatingPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("LaserPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_LaserPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("ServoPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_ServoPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("Laser1Alarm", DValue(m_SignalStateWrapper->m_Laser1Alarm))); + m_plcMp.insert(make_pair("Laser2Alarm", DValue(m_SignalStateWrapper->m_Laser2Alarm))); + m_plcMp.insert(make_pair("Laser3Alarm", DValue(m_SignalStateWrapper->m_Laser3Alarm))); + m_plcMp.insert(make_pair("Laser4Alarm", DValue(m_SignalStateWrapper->m_Laser4Alarm))); + m_plcMp.insert(make_pair("HeatingInputAlarm", DValue(m_SignalStateWrapper->m_HeatingInputAlarm))); + m_plcMp.insert(make_pair("HeatingOutputAlarm", DValue(m_SignalStateWrapper->m_HeatingOutputAlarm))); + m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn = new SysParamBool(flag++, 1, cc); //打印存粉小车1粉罐已满警示 m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn = new SysParamBool(flag++, 1, cc); //打印存粉小车1没有连接警示 @@ -11274,11 +11304,47 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_PrintCabinLockDisableAlarm = new SysParamBool(flag++, 1, cc); //打印舱电锁感应异常 m_SignalStateWrapper->m_CleanBoxUpOpenAlarm = new SysParamBool(flag++, 1, cc); //清粉箱上盖气缸打开不到位异常 m_SignalStateWrapper->m_CleanBoxUpCloseAlarm = new SysParamBool(flag++, 1, cc); //清粉箱上盖气缸关闭不到位异常 + + m_plcMp.insert(make_pair("PrintStorageCar1JarFullWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn))); + m_plcMp.insert(make_pair("PrintStorageCar1DisconnectWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn))); + m_plcMp.insert(make_pair("PrintStorageCar2JarFullWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar2JarFullWarn))); + m_plcMp.insert(make_pair("PrintStorageCar2DisconnectWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar2DisconnectWarn))); + m_plcMp.insert(make_pair("MoldMainUpLimitActive", DValue(m_SignalStateWrapper->m_MoldMainUpLimitActive))); + m_plcMp.insert(make_pair("MoldMainDownLimitActive", DValue(m_SignalStateWrapper->m_MoldMainDownLimitActive))); + m_plcMp.insert(make_pair("MoldSlaveUpLimitActive", DValue(m_SignalStateWrapper->m_MoldSlaveUpLimitActive))); + m_plcMp.insert(make_pair("MoldSlaveDownLimitActive", DValue(m_SignalStateWrapper->m_MoldSlaveDownLimitActive))); + m_plcMp.insert(make_pair("Print3RSeparateAlarm", DValue(m_SignalStateWrapper->m_Print3RSeparateAlarm))); + m_plcMp.insert(make_pair("Print3RConnectAlarm", DValue(m_SignalStateWrapper->m_Print3RConnectAlarm))); + m_plcMp.insert(make_pair("Print3RDisableAlarm", DValue(m_SignalStateWrapper->m_Print3RDisableAlarm))); + m_plcMp.insert(make_pair("PrintTrackDisableWarn", DValue(m_SignalStateWrapper->m_PrintTrackDisableWarn))); + m_plcMp.insert(make_pair("PrintPressOnDisableAlarm", DValue(m_SignalStateWrapper->m_PrintPressOnDisableAlarm))); + m_plcMp.insert(make_pair("PrintPressOffDisableAlarm", DValue(m_SignalStateWrapper->m_PrintPressOffDisableAlarm))); + m_plcMp.insert(make_pair("PrintJackUpDisableAlarm", DValue(m_SignalStateWrapper->m_PrintJackUpDisableAlarm))); + m_plcMp.insert(make_pair("PrintJackDownDisableAlarm", DValue(m_SignalStateWrapper->m_PrintJackDownDisableAlarm))); + m_plcMp.insert(make_pair("PrintSupportOnDisableAlarm", DValue(m_SignalStateWrapper->m_PrintSupportOnDisableAlarm))); + m_plcMp.insert(make_pair("PrintSupportOffDisableAlarm", DValue(m_SignalStateWrapper->m_PrintSupportOffDisableAlarm))); + m_plcMp.insert(make_pair("PrintHorizontalExtendOnAlarm", DValue(m_SignalStateWrapper->m_PrintHorizontalExtendOnAlarm))); + m_plcMp.insert(make_pair("PrintHorizontalExtendOffAlarm", DValue(m_SignalStateWrapper->m_PrintHorizontalExtendOffAlarm))); + m_plcMp.insert(make_pair("PrintVerticalExtendOnAlarm", DValue(m_SignalStateWrapper->m_PrintVerticalExtendOnAlarm))); + m_plcMp.insert(make_pair("PrintVerticalExtendOffAlarm", DValue(m_SignalStateWrapper->m_PrintVerticalExtendOffAlarm))); + m_plcMp.insert(make_pair("PrintCylinderVerifyAlarm", DValue(m_SignalStateWrapper->m_PrintCylinderVerifyAlarm))); + m_plcMp.insert(make_pair("CleanMainUpLimit", DValue(m_SignalStateWrapper->m_CleanMainUpLimit))); + m_plcMp.insert(make_pair("CleanMainDownLimit", DValue(m_SignalStateWrapper->m_CleanMainDownLimit))); + m_plcMp.insert(make_pair("CleanSlaveUpLimit", DValue(m_SignalStateWrapper->m_CleanSlaveUpLimit))); + m_plcMp.insert(make_pair("CleanSlaveDownLimit", DValue(m_SignalStateWrapper->m_CleanSlaveDownLimit))); + m_plcMp.insert(make_pair("CleanTrackConnectAlarm", DValue(m_SignalStateWrapper->m_CleanTrackConnectAlarm))); + m_plcMp.insert(make_pair("CleanTrackPosDisableAlarm", DValue(m_SignalStateWrapper->m_CleanTrackPosDisableAlarm))); + m_plcMp.insert(make_pair("CleanLiftStopAlarm", DValue(m_SignalStateWrapper->m_CleanLiftStopAlarm))); + m_plcMp.insert(make_pair("CleanCabinDisableAlarm", DValue(m_SignalStateWrapper->m_CleanCabinDisableAlarm))); + m_plcMp.insert(make_pair("MainPowerLossCheckAlarm", DValue(m_SignalStateWrapper->m_MainPowerLossCheckAlarm))); + m_plcMp.insert(make_pair("PrintCabinLockDisableAlarm", DValue(m_SignalStateWrapper->m_PrintCabinLockDisableAlarm))); flag++; flag++; m_SignalStateWrapper->m_CleanBoxPressOnAlarm = new SysParamBool(flag++, 1, cc); //清粉箱压紧气缸压紧不到位异常 m_SignalStateWrapper->m_CleanBoxPressOffAlarm = new SysParamBool(flag++, 1, cc); //清粉箱压紧气缸松开不到位异常 + m_plcMp.insert(make_pair("CleanBoxPressOnAlarm", DValue(m_SignalStateWrapper->m_CleanBoxPressOnAlarm))); + m_plcMp.insert(make_pair("CleanBoxPressOffAlarm", DValue(m_SignalStateWrapper->m_CleanBoxPressOffAlarm))); flag++; flag++; flag++; @@ -11299,10 +11365,30 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_LoadAxisSearchEdgeDisableAlarm = new SysParamBool(flag++, 1, cc); //移载寻边感应器失效异常 m_SignalStateWrapper->m_LoadAxisInnertOnAlarm = new SysParamBool(flag++, 1, cc); //移载插销气缸插紧不到位异常 m_SignalStateWrapper->m_LoadAxisInnertOffAlarm = new SysParamBool(flag++, 1, cc); //移载插销气缸松开不到位异常 + m_plcMp.insert(make_pair("CleanBoxCylinderDisconnectAlarm", DValue(m_SignalStateWrapper->m_CleanBoxCylinderDisconnectAlarm))); + m_plcMp.insert(make_pair("CleanPosPressOnAlarm", DValue(m_SignalStateWrapper->m_CleanPosPressOnAlarm))); + m_plcMp.insert(make_pair("CleanPosPressOffAlarm", DValue(m_SignalStateWrapper->m_CleanPosPressOffAlarm))); + m_plcMp.insert(make_pair("TrackAssistExtendOnAlarm", DValue(m_SignalStateWrapper->m_TrackAssistExtendOnAlarm))); + m_plcMp.insert(make_pair("TrackAssistExtendOffAlarm", DValue(m_SignalStateWrapper->m_TrackAssistExtendOffAlarm))); + m_plcMp.insert(make_pair("Clean3RConnectAlarm", DValue(m_SignalStateWrapper->m_Clean3RConnectAlarm))); + m_plcMp.insert(make_pair("Clean3RCombineAlarm", DValue(m_SignalStateWrapper->m_Clean3RCombineAlarm))); + m_plcMp.insert(make_pair("Clean3RDisableAlarm", DValue(m_SignalStateWrapper->m_Clean3RDisableAlarm))); + m_plcMp.insert(make_pair("ArmFrontLimit", DValue(m_SignalStateWrapper->m_ArmFrontLimit))); + m_plcMp.insert(make_pair("ArmBackLimit", DValue(m_SignalStateWrapper->m_ArmBackLimit))); + m_plcMp.insert(make_pair("LoadAxisLeftLimit", DValue(m_SignalStateWrapper->m_LoadAxisLeftLimit))); + m_plcMp.insert(make_pair("LoadAxisRightLimit", DValue(m_SignalStateWrapper->m_LoadAxisRightLimit))); + m_plcMp.insert(make_pair("LoadAxisSearchEdgeDisableAlarm", DValue(m_SignalStateWrapper->m_LoadAxisSearchEdgeDisableAlarm))); + m_plcMp.insert(make_pair("LoadAxisInnertOnAlarm", DValue(m_SignalStateWrapper->m_LoadAxisInnertOnAlarm))); + m_plcMp.insert(make_pair("LoadAxisInnertOffAlarm", DValue(m_SignalStateWrapper->m_LoadAxisInnertOffAlarm))); + flag = 64 * 8 + 7; m_SignalStateWrapper->m_PrintInnerLossPressureAlarm= new SysParamBool(flag++, 1, cc); //舱内失压报警 m_SignalStateWrapper->m_PrintOxygenRiseAlarm= new SysParamBool(flag++, 1, cc); //氧含量快速升高报警 m_SignalStateWrapper->m_PrintHandupSeparateAlarm= new SysParamBool(flag++, 1, cc); //顶升气缸异常分离报警 + m_plcMp.insert(make_pair("PrintInnerLossPressureAlarm", DValue(m_SignalStateWrapper->m_PrintInnerLossPressureAlarm))); + m_plcMp.insert(make_pair("PrintOxygenRiseAlarm", DValue(m_SignalStateWrapper->m_PrintOxygenRiseAlarm))); + m_plcMp.insert(make_pair("PrintHandupSeparateAlarm", DValue(m_SignalStateWrapper->m_PrintHandupSeparateAlarm))); + flag = 65 * 8 + 2; m_SignalStateWrapper->m_PowderPosition1Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器1异常 m_SignalStateWrapper->m_PowderPosition2Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器2异常 @@ -11349,10 +11435,52 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_LoadAxisSoftStopTrigger = new SysParamBool(flag++, 1, cc); //移载轴软急停触发 m_SignalStateWrapper->m_CoverSoftStopTrigger = new SysParamBool(flag++, 1, cc); //铺粉轴软急停触发 m_SignalStateWrapper->m_CoverHomeException= new SysParamBool(flag++, 1, cc); //铺粉归原点异常 + m_plcMp.insert(make_pair("PowderPosition1Alarm", DValue(m_SignalStateWrapper->m_PowderPosition1Alarm))); + m_plcMp.insert(make_pair("PowderPosition2Alarm", DValue(m_SignalStateWrapper->m_PowderPosition2Alarm))); + m_plcMp.insert(make_pair("PowderPosition3Alarm", DValue(m_SignalStateWrapper->m_PowderPosition3Alarm))); + m_plcMp.insert(make_pair("PowderPosition4Alarm", DValue(m_SignalStateWrapper->m_PowderPosition4Alarm))); + m_plcMp.insert(make_pair("PowderPosition5Alarm", DValue(m_SignalStateWrapper->m_PowderPosition5Alarm))); + m_plcMp.insert(make_pair("SupplyHomeIndexDisableAlarm", DValue(m_SignalStateWrapper->m_SupplyHomeIndexDisableAlarm))); + m_plcMp.insert(make_pair("SupplyPipeBlockWarn", DValue(m_SignalStateWrapper->m_SupplyPipeBlockWarn))); + m_plcMp.insert(make_pair("PrintOxygen1DeciceAlarm", DValue(m_SignalStateWrapper->m_PrintOxygen1DeciceAlarm))); + m_plcMp.insert(make_pair("PrintOxygen2DeviceAlarm", DValue(m_SignalStateWrapper->m_PrintOxygen2DeviceAlarm))); + m_plcMp.insert(make_pair("OutsideOxygenDeviceAlarm", DValue(m_SignalStateWrapper->m_OutsideOxygenDeviceAlarm))); + m_plcMp.insert(make_pair("PrintPressureOverLimitAlarm", DValue(m_SignalStateWrapper->m_PrintPressureOverLimitAlarm))); + m_plcMp.insert(make_pair("ScannerChillerAlarm", DValue(m_SignalStateWrapper->m_ScannerChillerAlarm))); + m_plcMp.insert(make_pair("PurifierChillerAlarm", DValue(m_SignalStateWrapper->m_PurifierChillerAlarm))); + m_plcMp.insert(make_pair("MoldTorqueAlarm", DValue(m_SignalStateWrapper->m_MoldTorqueAlarm))); + m_plcMp.insert(make_pair("MoldSlaveTorqueAlarm", DValue(m_SignalStateWrapper->m_MoldSlaveTorqueAlarm))); + m_plcMp.insert(make_pair("CleanTorqueAlarm", DValue(m_SignalStateWrapper->m_CleanTorqueAlarm))); + m_plcMp.insert(make_pair("CleanSlaveTorqueAlarm", DValue(m_SignalStateWrapper->m_CleanSlaveTorqueAlarm))); + m_plcMp.insert(make_pair("LoadTorqueAlarm", DValue(m_SignalStateWrapper->m_LoadTorqueAlarm))); + m_plcMp.insert(make_pair("PrintMainOverSoftUpLimit", DValue(m_SignalStateWrapper->m_PrintMainOverSoftUpLimit))); + m_plcMp.insert(make_pair("PrintMainOverSoftDownLimit", DValue(m_SignalStateWrapper->m_PrintMainOverSoftDownLimit))); + m_plcMp.insert(make_pair("CleanMainOverSoftUpLimit", DValue(m_SignalStateWrapper->m_CleanMainOverSoftUpLimit))); + m_plcMp.insert(make_pair("CleanMainOverSoftDownLimit", DValue(m_SignalStateWrapper->m_CleanMainOverSoftDownLimit))); - + m_plcMp.insert(make_pair("LoadAxisOverSoftLeftLimit", DValue(m_SignalStateWrapper->m_LoadAxisOverSoftLeftLimit))); + m_plcMp.insert(make_pair("LoadAxisOverSoftRightLimit", DValue(m_SignalStateWrapper->m_LoadAxisOverSoftRightLimit))); + m_plcMp.insert(make_pair("ArmOverSoftFrontLimit", DValue(m_SignalStateWrapper->m_ArmOverSoftFrontLimit))); + m_plcMp.insert(make_pair("ArmOverSoftBackLimit", DValue(m_SignalStateWrapper->m_ArmOverSoftBackLimit))); + m_plcMp.insert(make_pair("PrintMainServoAlarmSignal", DValue(m_SignalStateWrapper->m_PrintMainServoAlarmSignal))); + m_plcMp.insert(make_pair("PrintSlaveServoAlarmSignal", DValue(m_SignalStateWrapper->m_PrintSlaveServoAlarmSignal))); + m_plcMp.insert(make_pair("CleanMainServoAlarmSignal", DValue(m_SignalStateWrapper->m_CleanMainServoAlarmSignal))); + m_plcMp.insert(make_pair("CleanSlaveServoAlarmSignal", DValue(m_SignalStateWrapper->m_CleanSlaveServoAlarmSignal))); + m_plcMp.insert(make_pair("LoadAxisServoAlarmSignal", DValue(m_SignalStateWrapper->m_LoadAxisServoAlarmSignal))); + m_plcMp.insert(make_pair("ArmServoAlarmSignal", DValue(m_SignalStateWrapper->m_ArmServoAlarmSignal))); + m_plcMp.insert(make_pair("SupplyServoAlarmSignal", DValue(m_SignalStateWrapper->m_SupplyServoAlarmSignal))); + m_plcMp.insert(make_pair("PrintMainSoftStopTrigger", DValue(m_SignalStateWrapper->m_PrintMainSoftStopTrigger))); + m_plcMp.insert(make_pair("PrintSlaveSoftStopTrigger", DValue(m_SignalStateWrapper->m_PrintSlaveSoftStopTrigger))); + m_plcMp.insert(make_pair("CleanMainSoftStopTrigger", DValue(m_SignalStateWrapper->m_CleanMainSoftStopTrigger))); + m_plcMp.insert(make_pair("CleanSlaveSoftStopTrigger", DValue(m_SignalStateWrapper->m_CleanSlaveSoftStopTrigger))); + m_plcMp.insert(make_pair("LoadAxisSoftStopTrigger", DValue(m_SignalStateWrapper->m_LoadAxisSoftStopTrigger))); + m_plcMp.insert(make_pair("CoverSoftStopTrigger", DValue(m_SignalStateWrapper->m_CoverSoftStopTrigger))); + m_plcMp.insert(make_pair("CoverHomeException", DValue(m_SignalStateWrapper->m_CoverHomeException))); + flag = 78; m_SignalStateWrapper->m_CylinderState = new SysParamInt(flag, 1, cc); //缸体状态_R + m_plcMp.insert(make_pair("CylinderState", DValue(m_SignalStateWrapper->m_CylinderState))); + flag = 80 * 8; m_SignalStateWrapper->m_CylinderReachPrintTriger = new SysParamBool(flag++, 1, cc); //触发缸体到达打印位_自动_RW m_SignalStateWrapper->m_CylinderReachPrintRun = new SysParamBool(flag++, 1, cc); //缸体到打印位运行中_自动_RW @@ -11394,6 +11522,48 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_StorgeCarDeoxygenFinished = new SysParamBool(flag++, 1, cc); //存粉小车除氧完毕_RW m_SignalStateWrapper->m_CleanBoxVacuumTriger = new SysParamBool(flag++, 1, cc); //清粉箱启动吸尘器_R m_SignalStateWrapper->m_PrintVacuumTriger = new SysParamBool(flag++, 1, cc); //打印室启动吸尘器_W + + m_plcMp.insert(make_pair("CylinderReachPrintTriger", DValue(m_SignalStateWrapper->m_CylinderReachPrintTriger))); + m_plcMp.insert(make_pair("CylinderReachPrintRun", DValue(m_SignalStateWrapper->m_CylinderReachPrintRun))); + m_plcMp.insert(make_pair("CylinderReachPrintFinished", DValue(m_SignalStateWrapper->m_CylinderReachPrintFinished))); + m_plcMp.insert(make_pair("CylinderPrintLoadTriger", DValue(m_SignalStateWrapper->m_CylinderPrintLoadTriger))); + m_plcMp.insert(make_pair("CylinderPrintLoadRun", DValue(m_SignalStateWrapper->m_CylinderPrintLoadRun))); + m_plcMp.insert(make_pair("CylinderPrintLoadFinished", DValue(m_SignalStateWrapper->m_CylinderPrintLoadFinished))); + m_plcMp.insert(make_pair("CylinderPrintUnloadTriger", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadTriger))); + m_plcMp.insert(make_pair("CylinderPrintUnloadRun", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadRun))); + m_plcMp.insert(make_pair("CylinderPrintUnloadFinished", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadFinished))); + m_plcMp.insert(make_pair("MoldConnectCylinderTriger", DValue(m_SignalStateWrapper->m_MoldConnectCylinderTriger))); + m_plcMp.insert(make_pair("MoldConnectCylinderRun", DValue(m_SignalStateWrapper->m_MoldConnectCylinderRun))); + m_plcMp.insert(make_pair("MoldConnectCylinderFinished", DValue(m_SignalStateWrapper->m_MoldConnectCylinderFinished))); + m_plcMp.insert(make_pair("MoldDisconnectCylinderTriger", DValue(m_SignalStateWrapper->m_MoldDisconnectCylinderTriger))); + m_plcMp.insert(make_pair("MoldDisconnectCylinderRun", DValue(m_SignalStateWrapper->m_MoldDisconnectCylinderRun))); + m_plcMp.insert(make_pair("MoldDisconnectCylinderFinished", DValue(m_SignalStateWrapper->m_MoldDisconnectCylinderFinished))); + m_plcMp.insert(make_pair("CylinderReachCleanTriger", DValue(m_SignalStateWrapper->m_CylinderReachCleanTriger))); + m_plcMp.insert(make_pair("CylinderReachCleanRun", DValue(m_SignalStateWrapper->m_CylinderReachCleanRun))); + m_plcMp.insert(make_pair("CylinderReachCleanFinished", DValue(m_SignalStateWrapper->m_CylinderReachCleanFinished))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxTriger", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxTriger))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxRun", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxRun))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxFinished", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxFinished))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxTriger", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxTriger))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxRun", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxRun))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxFinished", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxFinished))); + m_plcMp.insert(make_pair("CoverTriger", DValue(m_SignalStateWrapper->m_CoverTriger))); + m_plcMp.insert(make_pair("IsCovering", DValue(m_SignalStateWrapper->m_IsCovering))); + m_plcMp.insert(make_pair("IsCoverFinishedCanPrint", DValue(m_SignalStateWrapper->m_IsCoverFinishedCanPrint))); + m_plcMp.insert(make_pair("IsCoverDebug", DValue(m_SignalStateWrapper->m_IsCoverDebug))); + m_plcMp.insert(make_pair("IsFirstCover", DValue(m_SignalStateWrapper->m_IsFirstCover))); + m_plcMp.insert(make_pair("PrintDeoxygenTriger", DValue(m_SignalStateWrapper->m_PrintDeoxygenTriger))); + m_plcMp.insert(make_pair("PrintDeoxygenRun", DValue(m_SignalStateWrapper->m_PrintDeoxygenRun))); + m_plcMp.insert(make_pair("PrintDeoxygenFinished", DValue(m_SignalStateWrapper->m_PrintDeoxygenFinished))); + m_plcMp.insert(make_pair("MoldDeoxygenTriger", DValue(m_SignalStateWrapper->m_MoldDeoxygenTriger))); + m_plcMp.insert(make_pair("MoldDeoxygenRun", DValue(m_SignalStateWrapper->m_MoldDeoxygenRun))); + m_plcMp.insert(make_pair("MoldDeoxygenFinished", DValue(m_SignalStateWrapper->m_MoldDeoxygenFinished))); + m_plcMp.insert(make_pair("StorgeCarDeoxygenTriger", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenTriger))); + m_plcMp.insert(make_pair("StorgeCarDeoxygenRun", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenRun))); + m_plcMp.insert(make_pair("StorgeCarDeoxygenFinished", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenFinished))); + m_plcMp.insert(make_pair("CleanBoxVacuumTriger", DValue(m_SignalStateWrapper->m_CleanBoxVacuumTriger))); + m_plcMp.insert(make_pair("PrintVacuumTriger", DValue(m_SignalStateWrapper->m_PrintVacuumTriger))); + flag++; flag++; m_SignalStateWrapper->m_DisableRasterJudge = new SysParamBool(flag++, 1, cc); //屏蔽光栅尺判断_W @@ -11412,6 +11582,22 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_MoldDeoxygenEnable = new SysParamBool(flag++, 1, cc); //触发打印升降轴除氧EN_R m_SignalStateWrapper->m_CalcLoadSearchEdgeOffset = new SysParamBool(flag++, 1, cc); //计算移栽寻边偏移值_RW m_SignalStateWrapper->m_ManualTestOffset = new SysParamBool(flag++, 1, cc); //手动测试偏移值 + + m_plcMp.insert(make_pair("DisableRasterJudge", DValue(m_SignalStateWrapper->m_DisableRasterJudge))); + m_plcMp.insert(make_pair("RasterJudgeOK", DValue(m_SignalStateWrapper->m_RasterJudgeOK))); + m_plcMp.insert(make_pair("RasterJudgeNG", DValue(m_SignalStateWrapper->m_RasterJudgeNG))); + m_plcMp.insert(make_pair("CylinderReachPrintEnable", DValue(m_SignalStateWrapper->m_CylinderReachPrintEnable))); + m_plcMp.insert(make_pair("CylinderPrintLoadEnable", DValue(m_SignalStateWrapper->m_CylinderPrintLoadEnable))); + m_plcMp.insert(make_pair("CylinderPrintUnloadEnable", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadEnable))); + m_plcMp.insert(make_pair("MoldConnectCylinderEnable", DValue(m_SignalStateWrapper->m_MoldConnectCylinderEnable))); + m_plcMp.insert(make_pair("MoldDisconnectCylinderEnable", DValue(m_SignalStateWrapper->m_MoldDisconnectCylinderEnable))); + m_plcMp.insert(make_pair("CylinderReachCleanEnable", DValue(m_SignalStateWrapper->m_CylinderReachCleanEnable))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxEnable", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxEnable))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxEnable", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxEnable))); + m_plcMp.insert(make_pair("CoverEnable", DValue(m_SignalStateWrapper->m_CoverEnable))); + m_plcMp.insert(make_pair("MoldDeoxygenEnable", DValue(m_SignalStateWrapper->m_MoldDeoxygenEnable))); + m_plcMp.insert(make_pair("CalcLoadSearchEdgeOffset", DValue(m_SignalStateWrapper->m_CalcLoadSearchEdgeOffset))); + m_plcMp.insert(make_pair("ManualTestOffset", DValue(m_SignalStateWrapper->m_ManualTestOffset))); flag = 96 * 8; m_SignalStateWrapper->m_PrintStoreCar1ExhaustEnable = new SysParamBool(flag++, 1, cc); //触发打印存粉小车1排粉 @@ -11426,6 +11612,16 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_RollerEdgeSearchSuccess = new SysParamBool(flag++, 1, cc); //滚粉轴寻边成功 m_SignalStateWrapper->m_RollerEdgeSearchFaild = new SysParamBool(flag++, 1, cc); //滚粉轴寻边失败 + m_plcMp.insert(make_pair("PrintStoreCar1ExhaustEnable", DValue(m_SignalStateWrapper->m_PrintStoreCar1ExhaustEnable))); + m_plcMp.insert(make_pair("PrintStoreCar2ExhaustEnable", DValue(m_SignalStateWrapper->m_PrintStoreCar2ExhaustEnable))); + m_plcMp.insert(make_pair("PrintAirRenewalEnable", DValue(m_SignalStateWrapper->m_PrintAirRenewalEnable))); + m_plcMp.insert(make_pair("PrintAirRenewalTrigger", DValue(m_SignalStateWrapper->m_PrintAirRenewalTrigger))); + m_plcMp.insert(make_pair("AllowRiseWindSpeed", DValue(m_SignalStateWrapper->m_AllowRiseWindSpeed))); + m_plcMp.insert(make_pair("ManualCoverTest", DValue(m_SignalStateWrapper->m_ManualCoverTest))); + m_plcMp.insert(make_pair("RollerEdgeSearching", DValue(m_SignalStateWrapper->m_RollerEdgeSearching))); + m_plcMp.insert(make_pair("RollerEdgeSearchSuccess", DValue(m_SignalStateWrapper->m_RollerEdgeSearchSuccess))); + m_plcMp.insert(make_pair("RollerEdgeSearchFaild", DValue(m_SignalStateWrapper->m_RollerEdgeSearchFaild))); + flag = 0; m_SignalStateWrapper->m_SheildPrintPosSensor = new SysParamBool(flag++, 68, cc); //屏蔽打印位感应器 m_SignalStateWrapper->m_SheildCylinderSensor = new SysParamBool(flag++, 68, cc); //屏蔽缸体感应器 @@ -11446,6 +11642,24 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_LinearEncoderOppDirection = new SysParamBool(flag++, 68, cc); //光栅尺反向 m_SignalStateWrapper->m_CoverV2UseCintinueMode = new SysParamBool(flag++, 68, cc); //铺粉V2是否使用连续模式 + m_plcMp.insert(make_pair("SheildPrintPosSensor", DValue(m_SignalStateWrapper->m_SheildPrintPosSensor))); + m_plcMp.insert(make_pair("SheildCylinderSensor", DValue(m_SignalStateWrapper->m_SheildCylinderSensor))); + m_plcMp.insert(make_pair("SheildLeftRightLocSensor", DValue(m_SignalStateWrapper->m_SheildLeftRightLocSensor))); + m_plcMp.insert(make_pair("SheildCleanAssCylinder", DValue(m_SignalStateWrapper->m_SheildCleanAssCylinder))); + m_plcMp.insert(make_pair("SheildPrintSupportCylinder", DValue(m_SignalStateWrapper->m_SheildPrintSupportCylinder))); + m_plcMp.insert(make_pair("SheildLinearEncoder", DValue(m_SignalStateWrapper->m_SheildLinearEncoder))); + m_plcMp.insert(make_pair("LoadAxisUseSensorPos", DValue(m_SignalStateWrapper->m_LoadAxisUseSensorPos))); + m_plcMp.insert(make_pair("SheildSlaveLimit", DValue(m_SignalStateWrapper->m_SheildSlaveLimit))); + m_plcMp.insert(make_pair("SheildFrontBackLocSensor", DValue(m_SignalStateWrapper->m_SheildFrontBackLocSensor))); + m_plcMp.insert(make_pair("SheildHighPressure", DValue(m_SignalStateWrapper->m_SheildHighPressure))); + m_plcMp.insert(make_pair("RailValveAdsorb", DValue(m_SignalStateWrapper->m_RailValveAdsorb))); + m_plcMp.insert(make_pair("LoadPrintBackDistance", DValue(m_SignalStateWrapper->m_LoadPrintBackDistance))); + m_plcMp.insert(make_pair("UseSupplySearchEdge", DValue(m_SignalStateWrapper->m_UseSupplySearchEdge))); + m_plcMp.insert(make_pair("UseArmCaptureHome", DValue(m_SignalStateWrapper->m_UseArmCaptureHome))); + m_plcMp.insert(make_pair("UseCapacityBar", DValue(m_SignalStateWrapper->m_UseCapacityBar))); + m_plcMp.insert(make_pair("LinearEncoderOppDirection", DValue(m_SignalStateWrapper->m_LinearEncoderOppDirection))); + m_plcMp.insert(make_pair("CoverV2UseCintinueMode", DValue(m_SignalStateWrapper->m_CoverV2UseCintinueMode))); + flag = 249 * 8 + 4; m_SignalStateWrapper->m_IsInPrintCylinderSeparatePos = new SysParamBool(flag++, 4, cc); //打印缸体分离位 m_SignalStateWrapper->m_IsInPrint3RSeparatePos = new SysParamBool(flag++, 4, cc); //打印3R脱离位 @@ -11463,6 +11677,22 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_IsInDropPowderPos = new SysParamBool(flag++, 4, cc); //铺粉下粉位 m_SignalStateWrapper->m_IsInAcceptPowderPos = new SysParamBool(flag++, 4, cc); //铺粉接粉位 + m_plcMp.insert(make_pair("IsInPrintCylinderSeparatePos", DValue(m_SignalStateWrapper->m_IsInPrintCylinderSeparatePos))); + m_plcMp.insert(make_pair("IsInPrint3RSeparatePos", DValue(m_SignalStateWrapper->m_IsInPrint3RSeparatePos))); + m_plcMp.insert(make_pair("IsInPrintDeoxygenLowestPos", DValue(m_SignalStateWrapper->m_IsInPrintDeoxygenLowestPos))); + m_plcMp.insert(make_pair("IsInPrintPlatformBottomPos", DValue(m_SignalStateWrapper->m_IsInPrintPlatformBottomPos))); + m_plcMp.insert(make_pair("IsInPrintPlatformFlatPos", DValue(m_SignalStateWrapper->m_IsInPrintPlatformFlatPos))); + m_plcMp.insert(make_pair("IsInPrintJackupPos", DValue(m_SignalStateWrapper->m_IsInPrintJackupPos))); + m_plcMp.insert(make_pair("IsInCleanPlatfromBottomPos", DValue(m_SignalStateWrapper->m_IsInCleanPlatfromBottomPos))); + m_plcMp.insert(make_pair("IsInClean3RSeparatePos", DValue(m_SignalStateWrapper->m_IsInClean3RSeparatePos))); + m_plcMp.insert(make_pair("IsInCleanLowestPos", DValue(m_SignalStateWrapper->m_IsInCleanLowestPos))); + m_plcMp.insert(make_pair("IsInLoadPrintPos", DValue(m_SignalStateWrapper->m_IsInLoadPrintPos))); + m_plcMp.insert(make_pair("IsInLoadCleanPos", DValue(m_SignalStateWrapper->m_IsInLoadCleanPos))); + m_plcMp.insert(make_pair("IsInLoadWaitPos", DValue(m_SignalStateWrapper->m_IsInLoadWaitPos))); + m_plcMp.insert(make_pair("IsInDropPowderPos", DValue(m_SignalStateWrapper->m_IsInDropPowderPos))); + m_plcMp.insert(make_pair("IsInAcceptPowderPos", DValue(m_SignalStateWrapper->m_IsInAcceptPowderPos))); + + flag = 88 * 8; m_SignalStateWrapper->m_PrintTorqueUpInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在上升扭力范围内 m_SignalStateWrapper->m_ArmNotUponBasePlatform = new SysParamBool(flag++, 1, cc); //铺粉轴不在基板范围内 @@ -11473,6 +11703,15 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_PrintInsideDownLimit = new SysParamBool(flag++, 1, cc); //下限位没触发 m_SignalStateWrapper->m_PrintMainServoNoAlarm = new SysParamBool(flag++, 1, cc); //打印主轴伺服无异常 m_SignalStateWrapper->m_PrintSlaveServoNoAlarm = new SysParamBool(flag++, 1, cc); //打印从轴伺服无异常 + m_plcMp.insert(make_pair("PrintTorqueUpInsideLimit", DValue(m_SignalStateWrapper->m_PrintTorqueUpInsideLimit))); + m_plcMp.insert(make_pair("ArmNotUponBasePlatform", DValue(m_SignalStateWrapper->m_ArmNotUponBasePlatform))); + m_plcMp.insert(make_pair("PrintMoldPosInsideUpSoftLimit", DValue(m_SignalStateWrapper->m_PrintMoldPosInsideUpSoftLimit))); + m_plcMp.insert(make_pair("PrintInsideUpLimit", DValue(m_SignalStateWrapper->m_PrintInsideUpLimit))); + m_plcMp.insert(make_pair("PrintTorqueDownInsideLimit", DValue(m_SignalStateWrapper->m_PrintTorqueDownInsideLimit))); + m_plcMp.insert(make_pair("PrintAxisPosInsideDownSoftLimit", DValue(m_SignalStateWrapper->m_PrintAxisPosInsideDownSoftLimit))); + m_plcMp.insert(make_pair("PrintInsideDownLimit", DValue(m_SignalStateWrapper->m_PrintInsideDownLimit))); + m_plcMp.insert(make_pair("PrintMainServoNoAlarm", DValue(m_SignalStateWrapper->m_PrintMainServoNoAlarm))); + m_plcMp.insert(make_pair("PrintSlaveServoNoAlarm", DValue(m_SignalStateWrapper->m_PrintSlaveServoNoAlarm))); flag = 90 * 8; m_SignalStateWrapper->m_CleanCylinderOnSafePos = new SysParamBool(flag++, 1, cc); //缸体在安全位置 @@ -11486,6 +11725,16 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_CleanMainServoNoAlarm = new SysParamBool(flag++, 1, cc); //清粉主轴伺服无异常 m_SignalStateWrapper->m_CleanSlaveServoNoAlarm = new SysParamBool(flag++, 1, cc); //清粉从轴伺服无异常 + m_plcMp.insert(make_pair("CleanCylinderOnSafePos", DValue(m_SignalStateWrapper->m_CleanCylinderOnSafePos))); + m_plcMp.insert(make_pair("CleanTorqueUpInsideLimit", DValue(m_SignalStateWrapper->m_CleanTorqueUpInsideLimit))); + m_plcMp.insert(make_pair("CleanAxisPosUpInSoftLimit", DValue(m_SignalStateWrapper->m_CleanAxisPosUpInSoftLimit))); + m_plcMp.insert(make_pair("CleanTorqueDownInsideLimit", DValue(m_SignalStateWrapper->m_CleanTorqueDownInsideLimit))); + m_plcMp.insert(make_pair("CleanAxisPosDownInsideSoftLimit", DValue(m_SignalStateWrapper->m_CleanAxisPosDownInsideSoftLimit))); + m_plcMp.insert(make_pair("CleanUpInsideLimit", DValue(m_SignalStateWrapper->m_CleanUpInsideLimit))); + m_plcMp.insert(make_pair("CleanDownInsideLimit", DValue(m_SignalStateWrapper->m_CleanDownInsideLimit))); + m_plcMp.insert(make_pair("CleanMainServoNoAlarm", DValue(m_SignalStateWrapper->m_CleanMainServoNoAlarm))); + m_plcMp.insert(make_pair("CleanSlaveServoNoAlarm", DValue(m_SignalStateWrapper->m_CleanSlaveServoNoAlarm))); + flag = 92 * 8; m_SignalStateWrapper->m_PrintJackupInSplitePos = new SysParamBool(flag++, 1, cc); //打印顶升轴在缸体分离位 m_SignalStateWrapper->m_LoadTorqueInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在扭力范围内 @@ -11500,6 +11749,19 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_LoadLeftNotInsideLimit = new SysParamBool(flag++, 1, cc); //左限位没触发 m_SignalStateWrapper->m_LoadRightNotInsideLimit = new SysParamBool(flag++, 1, cc); //右限位没触发 m_SignalStateWrapper->m_LoadServoNoAlarm = new SysParamBool(flag++, 1, cc); //移载轴伺服无异常 + m_plcMp.insert(make_pair("PrintJackupInSplitePos", DValue(m_SignalStateWrapper->m_PrintJackupInSplitePos))); + m_plcMp.insert(make_pair("LoadTorqueInsideLimit", DValue(m_SignalStateWrapper->m_LoadTorqueInsideLimit))); + m_plcMp.insert(make_pair("LoadPosInsideLeftSoftLimit", DValue(m_SignalStateWrapper->m_LoadPosInsideLeftSoftLimit))); + m_plcMp.insert(make_pair("LoadPosInsideRightSoftLimit", DValue(m_SignalStateWrapper->m_LoadPosInsideRightSoftLimit))); + m_plcMp.insert(make_pair("PrintPressingInReleasePos", DValue(m_SignalStateWrapper->m_PrintPressingInReleasePos))); + m_plcMp.insert(make_pair("PrintJackupInDropPos", DValue(m_SignalStateWrapper->m_PrintJackupInDropPos))); + m_plcMp.insert(make_pair("PrintSupportInAvoidPos", DValue(m_SignalStateWrapper->m_PrintSupportInAvoidPos))); + m_plcMp.insert(make_pair("CleanPressingInReleasePos", DValue(m_SignalStateWrapper->m_CleanPressingInReleasePos))); + m_plcMp.insert(make_pair("CleanUpDownInDownestPos", DValue(m_SignalStateWrapper->m_CleanUpDownInDownestPos))); + m_plcMp.insert(make_pair("CylinderCleanHadSparate", DValue(m_SignalStateWrapper->m_CylinderCleanHadSparate))); + m_plcMp.insert(make_pair("LoadLeftNotInsideLimit", DValue(m_SignalStateWrapper->m_LoadLeftNotInsideLimit))); + m_plcMp.insert(make_pair("LoadRightNotInsideLimit", DValue(m_SignalStateWrapper->m_LoadRightNotInsideLimit))); + m_plcMp.insert(make_pair("LoadServoNoAlarm", DValue(m_SignalStateWrapper->m_LoadServoNoAlarm))); flag = 94 * 8; m_SignalStateWrapper->m_PrintUpDownPosBelowPlatform = new SysParamBool(flag++, 1, cc); //打印顶升轴位置低于基板缸平面 @@ -11510,6 +11772,14 @@ void HBD1000::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_ArmPosInsideBackLimit = new SysParamBool(flag++, 1, cc); //后限位没触发 m_SignalStateWrapper->m_ArmServoNoAlarm = new SysParamBool(flag++, 1, cc); //铺粉轴伺服无异常 + m_plcMp.insert(make_pair("PrintUpDownPosBelowPlatform", DValue(m_SignalStateWrapper->m_PrintUpDownPosBelowPlatform))); + m_plcMp.insert(make_pair("ArmTorqueInsideLimit", DValue(m_SignalStateWrapper->m_ArmTorqueInsideLimit))); + m_plcMp.insert(make_pair("ArmPosInsideSoftFrontLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideSoftFrontLimit))); + m_plcMp.insert(make_pair("ArmPosInsideSoftBackLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideSoftBackLimit))); + m_plcMp.insert(make_pair("ArmPosInsideFrontLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideFrontLimit))); + m_plcMp.insert(make_pair("ArmPosInsideBackLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideBackLimit))); + m_plcMp.insert(make_pair("ArmServoNoAlarm", DValue(m_SignalStateWrapper->m_ArmServoNoAlarm))); + m_SignalStateWrapper->m_KeepAliveCommand = new KeepAliveCommand(cc); m_SignalStateWrapper->m_KeepAliveCommand->m_PCKeepAlice = m_SignalStateWrapper->m_PCKeepAlice; m_SignalStateWrapper->m_KeepAliveCommand->m_DevicePrinting = m_SignalStateWrapper->m_DevicePrinting; @@ -11539,8 +11809,30 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_ProtectGasPressureMin = new SysParamFloat(flag, 3, cc); flag += 4; //保护气量程最小值_RW m_SysParamWrapper->m_PrintPressureMax = new SysParamFloat(flag, 3, cc); flag += 4; //打印舱压力量程最大值_RW m_SysParamWrapper->m_PrintPressureMin = new SysParamFloat(flag, 3, cc); flag += 4; //打印舱压力量程最小值_RW + m_plcMp.insert(make_pair("PrintOxygen1", DValue(m_SysParamWrapper->m_PrintOxygen1))); + m_plcMp.insert(make_pair("PrintOxygen2", DValue(m_SysParamWrapper->m_PrintOxygen2))); + m_plcMp.insert(make_pair("OutsideOxygen", DValue(m_SysParamWrapper->m_OutsideOxygen))); + m_plcMp.insert(make_pair("HighPressure", DValue(m_SysParamWrapper->m_HighPressure))); + m_plcMp.insert(make_pair("ProtectGasPressure", DValue(m_SysParamWrapper->m_ProtectGasPressure))); + m_plcMp.insert(make_pair("PrintPressure", DValue(m_SysParamWrapper->m_PrintPressure))); + m_plcMp.insert(make_pair("PrintOxygen1Max", DValue(m_SysParamWrapper->m_PrintOxygen1Max))); + m_plcMp.insert(make_pair("PrintOxygen1Min", DValue(m_SysParamWrapper->m_PrintOxygen1Min))); + m_plcMp.insert(make_pair("PrintOxygen2Max", DValue(m_SysParamWrapper->m_PrintOxygen2Max))); + m_plcMp.insert(make_pair("PrintOxygen2Min", DValue(m_SysParamWrapper->m_PrintOxygen2Min))); + m_plcMp.insert(make_pair("OutsideOxygenMax", DValue(m_SysParamWrapper->m_OutsideOxygenMax))); + m_plcMp.insert(make_pair("OutsideOxygenMin", DValue(m_SysParamWrapper->m_OutsideOxygenMin))); + m_plcMp.insert(make_pair("HighPressureMax", DValue(m_SysParamWrapper->m_HighPressureMax))); + m_plcMp.insert(make_pair("HighPressureMin", DValue(m_SysParamWrapper->m_HighPressureMin))); + m_plcMp.insert(make_pair("ProtectGasPressureMax", DValue(m_SysParamWrapper->m_ProtectGasPressureMax))); + m_plcMp.insert(make_pair("ProtectGasPressureMin", DValue(m_SysParamWrapper->m_ProtectGasPressureMin))); + m_plcMp.insert(make_pair("PrintPressureMax", DValue(m_SysParamWrapper->m_PrintPressureMax))); + m_plcMp.insert(make_pair("PrintPressureMin", DValue(m_SysParamWrapper->m_PrintPressureMin))); + + m_SysParamWrapper->m_OutsideOxygenAlarmValue = new SysParamFloat(flag, 3, cc); flag += 4; //室外氧含量报警值_RW + m_plcMp.insert(make_pair("OutsideOxygenAlarmValue", DValue(m_SysParamWrapper->m_OutsideOxygenAlarmValue))); + m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen1Max = new SysParamFloatUI(m_SysParamWrapper->m_PrintOxygen1Max); m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen1Min = new SysParamFloatUI(m_SysParamWrapper->m_PrintOxygen1Min); m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen2Max = new SysParamFloatUI(m_SysParamWrapper->m_PrintOxygen2Max); @@ -11553,9 +11845,22 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_EnvUIAssit.m_ProtectGasPressureMin = new SysParamFloatUI(m_SysParamWrapper->m_ProtectGasPressureMin); m_SysParamWrapper->m_EnvUIAssit.m_PrintPressureMax = new SysParamFloatUI(m_SysParamWrapper->m_PrintPressureMax); m_SysParamWrapper->m_EnvUIAssit.m_PrintPressureMin = new SysParamFloatUI(m_SysParamWrapper->m_PrintPressureMin); - m_SysParamWrapper->m_EnvUIAssit.m_OutsideOxygenAlarmValue = new SysParamFloatUI(m_SysParamWrapper->m_OutsideOxygenAlarmValue); + m_plcMp.insert(make_pair("PrintOxygen1Max", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen1Max))); + m_plcMp.insert(make_pair("PrintOxygen1Min", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen1Min))); + m_plcMp.insert(make_pair("PrintOxygen2Max", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen2Max))); + m_plcMp.insert(make_pair("PrintOxygen2Min", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintOxygen2Min))); + m_plcMp.insert(make_pair("OutsideOxygenMax", DValue(m_SysParamWrapper->m_EnvUIAssit.m_OutsideOxygenMax))); + m_plcMp.insert(make_pair("OutsideOxygenMin", DValue(m_SysParamWrapper->m_EnvUIAssit.m_OutsideOxygenMin))); + m_plcMp.insert(make_pair("HighPressureMax", DValue(m_SysParamWrapper->m_EnvUIAssit.m_HighPressureMax))); + m_plcMp.insert(make_pair("HighPressureMin", DValue(m_SysParamWrapper->m_EnvUIAssit.m_HighPressureMin))); + m_plcMp.insert(make_pair("ProtectGasPressureMax", DValue(m_SysParamWrapper->m_EnvUIAssit.m_ProtectGasPressureMax))); + m_plcMp.insert(make_pair("ProtectGasPressureMin", DValue(m_SysParamWrapper->m_EnvUIAssit.m_ProtectGasPressureMin))); + m_plcMp.insert(make_pair("PrintPressureMax", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintPressureMax))); + m_plcMp.insert(make_pair("PrintPressureMin", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintPressureMin))); + m_plcMp.insert(make_pair("OutsideOxygenAlarmValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_OutsideOxygenAlarmValue))); + m_SysParamWrapper->m_SupplyPowderGridPerCycle = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴的格数一圈_RW m_SysParamWrapper->m_SupplyAxisAnglePerGrid = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴每格对用度数_RW m_SysParamWrapper->m_MoldMainCurrentPos = new SysParamFloat(flag, 3, cc); flag += 4; //打印主轴当前位置_R @@ -11586,6 +11891,36 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_CleanSlaveManualDec = new SysParamFloat(flag, 3, cc); flag += 4; //清粉从轴手动减速_RW m_SysParamWrapper->m_CleanSlaveManualRefDistance = new SysParamFloat(flag, 3, cc); flag += 4; //清粉从轴手动相对位移距离_RW m_SysParamWrapper->m_CleanSlaveManualAbsPos = new SysParamFloat(flag, 3, cc); flag += 4; //清粉从轴绝对位置_手动_RW + m_plcMp.insert(make_pair("SupplyPowderGridPerCycle", DValue(m_SysParamWrapper->m_SupplyPowderGridPerCycle))); + m_plcMp.insert(make_pair("SupplyAxisAnglePerGrid", DValue(m_SysParamWrapper->m_SupplyAxisAnglePerGrid))); + m_plcMp.insert(make_pair("MoldMainCurrentPos", DValue(m_SysParamWrapper->m_MoldMainCurrentPos))); + m_plcMp.insert(make_pair("MoldMainCurrentLoad", DValue(m_SysParamWrapper->m_MoldMainCurrentLoad))); + m_plcMp.insert(make_pair("MoldSlaveCurrentPos", DValue(m_SysParamWrapper->m_MoldSlaveCurrentPos))); + m_plcMp.insert(make_pair("MoldSlaveCurrentLoad", DValue(m_SysParamWrapper->m_MoldSlaveCurrentLoad))); + m_plcMp.insert(make_pair("MoldMainManualSpeed", DValue(m_SysParamWrapper->m_MoldMainManualSpeed))); + m_plcMp.insert(make_pair("MoldMainManualAcc", DValue(m_SysParamWrapper->m_MoldMainManualAcc))); + m_plcMp.insert(make_pair("MoldMainManualDec", DValue(m_SysParamWrapper->m_MoldMainManualDec))); + m_plcMp.insert(make_pair("MoldMainManualRefDistance", DValue(m_SysParamWrapper->m_MoldMainManualRefDistance))); + m_plcMp.insert(make_pair("MoldMainManualAbsPos", DValue(m_SysParamWrapper->m_MoldMainManualAbsPos))); + m_plcMp.insert(make_pair("MoldSlaveManualSpeed", DValue(m_SysParamWrapper->m_MoldSlaveManualSpeed))); + m_plcMp.insert(make_pair("MoldSlaveManualAcc", DValue(m_SysParamWrapper->m_MoldSlaveManualAcc))); + m_plcMp.insert(make_pair("MoldSlaveManualDec", DValue(m_SysParamWrapper->m_MoldSlaveManualDec))); + m_plcMp.insert(make_pair("MoldSlaveManualRefDistance", DValue(m_SysParamWrapper->m_MoldSlaveManualRefDistance))); + m_plcMp.insert(make_pair("MoldSlaveManualAbsPos", DValue(m_SysParamWrapper->m_MoldSlaveManualAbsPos))); + m_plcMp.insert(make_pair("CleanMainCurrentPos", DValue(m_SysParamWrapper->m_CleanMainCurrentPos))); + m_plcMp.insert(make_pair("CleanMainCurrentLoad", DValue(m_SysParamWrapper->m_CleanMainCurrentLoad))); + m_plcMp.insert(make_pair("CleanSlaveCurrentPos", DValue(m_SysParamWrapper->m_CleanSlaveCurrentPos))); + m_plcMp.insert(make_pair("CleanSlaveCurrentLoad", DValue(m_SysParamWrapper->m_CleanSlaveCurrentLoad))); + m_plcMp.insert(make_pair("CleanMainManualSpeed", DValue(m_SysParamWrapper->m_CleanMainManualSpeed))); + m_plcMp.insert(make_pair("CleanMainManualAcc", DValue(m_SysParamWrapper->m_CleanMainManualAcc))); + m_plcMp.insert(make_pair("CleanMainManualDec", DValue(m_SysParamWrapper->m_CleanMainManualDec))); + m_plcMp.insert(make_pair("CleanMainManualRefDistance", DValue(m_SysParamWrapper->m_CleanMainManualRefDistance))); + m_plcMp.insert(make_pair("CleanMainManualAbsPos", DValue(m_SysParamWrapper->m_CleanMainManualAbsPos))); + m_plcMp.insert(make_pair("CleanSlaveManualSpeed", DValue(m_SysParamWrapper->m_CleanSlaveManualSpeed))); + m_plcMp.insert(make_pair("CleanSlaveManualAcc", DValue(m_SysParamWrapper->m_CleanSlaveManualAcc))); + m_plcMp.insert(make_pair("CleanSlaveManualDec", DValue(m_SysParamWrapper->m_CleanSlaveManualDec))); + m_plcMp.insert(make_pair("CleanSlaveManualRefDistance", DValue(m_SysParamWrapper->m_CleanSlaveManualRefDistance))); + m_plcMp.insert(make_pair("CleanSlaveManualAbsPos", DValue(m_SysParamWrapper->m_CleanSlaveManualAbsPos))); m_SysParamWrapper->m_EleCylinderMainCurrentPos = m_SysParamWrapper->m_CleanMainCurrentPos; //电缸主轴当前位置_R m_SysParamWrapper->m_EleCylinderMainCurrentLoad = m_SysParamWrapper->m_CleanMainCurrentLoad; //电缸主轴当前扭矩_R @@ -11601,6 +11936,20 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_EleCylinderSlaveManualDec = m_SysParamWrapper->m_CleanSlaveManualDec; //电缸从轴手动减速_RW m_SysParamWrapper->m_EleCylinderSlaveManualRefDistance = m_SysParamWrapper->m_CleanSlaveManualRefDistance; //电缸从轴手动相对位移距离_RW m_SysParamWrapper->m_EleCylinderSlaveManualAbsPos = m_SysParamWrapper->m_CleanSlaveManualAbsPos; //电缸从轴绝对位置_手动_RW + m_plcMp.insert(make_pair("EleCylinderMainCurrentPos", DValue(m_SysParamWrapper->m_EleCylinderMainCurrentPos))); + m_plcMp.insert(make_pair("EleCylinderMainCurrentLoad", DValue(m_SysParamWrapper->m_EleCylinderMainCurrentLoad))); + m_plcMp.insert(make_pair("EleCylinderSlaveCurrentPos", DValue(m_SysParamWrapper->m_EleCylinderSlaveCurrentPos))); + m_plcMp.insert(make_pair("EleCylinderSlaveCurrentLoad", DValue(m_SysParamWrapper->m_EleCylinderSlaveCurrentLoad))); + m_plcMp.insert(make_pair("EleCylinderMainManualSpeed", DValue(m_SysParamWrapper->m_EleCylinderMainManualSpeed))); + m_plcMp.insert(make_pair("EleCylinderMainManualAcc", DValue(m_SysParamWrapper->m_EleCylinderMainManualAcc))); + m_plcMp.insert(make_pair("EleCylinderMainManualDec", DValue(m_SysParamWrapper->m_EleCylinderMainManualDec))); + m_plcMp.insert(make_pair("EleCylinderMainManualRefDistance", DValue(m_SysParamWrapper->m_EleCylinderMainManualRefDistance))); + m_plcMp.insert(make_pair("EleCylinderMainManualAbsPos", DValue(m_SysParamWrapper->m_EleCylinderMainManualAbsPos))); + m_plcMp.insert(make_pair("EleCylinderSlaveManualSpeed", DValue(m_SysParamWrapper->m_EleCylinderSlaveManualSpeed))); + m_plcMp.insert(make_pair("EleCylinderSlaveManualAcc", DValue(m_SysParamWrapper->m_EleCylinderSlaveManualAcc))); + m_plcMp.insert(make_pair("EleCylinderSlaveManualDec", DValue(m_SysParamWrapper->m_EleCylinderSlaveManualDec))); + m_plcMp.insert(make_pair("EleCylinderSlaveManualRefDistance", DValue(m_SysParamWrapper->m_EleCylinderSlaveManualRefDistance))); + m_plcMp.insert(make_pair("EleCylinderSlaveManualAbsPos", DValue(m_SysParamWrapper->m_EleCylinderSlaveManualAbsPos))); m_SysParamWrapper->m_LoadAxisCurrentPos = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴当前位置_R m_SysParamWrapper->m_LoadAxisCurrentLoad = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴当前扭矩_R @@ -11682,6 +12031,86 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_EleCylinderSlaveHomeIndexEnc = m_SysParamWrapper->m_CleanSlaveHomeIndexEnc; //电缸从轴原点编码器值_RW m_SysParamWrapper->m_EleCylinderSlaveAlignEnc = m_SysParamWrapper->m_CleanSlaveAlignEnc; //电缸从轴对齐位编码器值_RW m_SysParamWrapper->m_EleCylinderSlaveAlignHomeRel = m_SysParamWrapper->m_CleanSlaveAlignHomeRel; //电缸从轴对齐位与原点相对值_RW + m_plcMp.insert(make_pair("LoadAxisCurrentPos", DValue(m_SysParamWrapper->m_LoadAxisCurrentPos))); + m_plcMp.insert(make_pair("LoadAxisCurrentLoad", DValue(m_SysParamWrapper->m_LoadAxisCurrentLoad))); + m_plcMp.insert(make_pair("LoadAxisManualSpeed", DValue(m_SysParamWrapper->m_LoadAxisManualSpeed))); + m_plcMp.insert(make_pair("LoadAxisManualAcc", DValue(m_SysParamWrapper->m_LoadAxisManualAcc))); + m_plcMp.insert(make_pair("LoadAxisManualDec", DValue(m_SysParamWrapper->m_LoadAxisManualDec))); + m_plcMp.insert(make_pair("LoadAxisManualRefDistance", DValue(m_SysParamWrapper->m_LoadAxisManualRefDistance))); + m_plcMp.insert(make_pair("LoadAxisManualAbsPos", DValue(m_SysParamWrapper->m_LoadAxisManualAbsPos))); + m_plcMp.insert(make_pair("ArmCurrentPos", DValue(m_SysParamWrapper->m_ArmCurrentPos))); + m_plcMp.insert(make_pair("ArmCurrentLoad", DValue(m_SysParamWrapper->m_ArmCurrentLoad))); + m_plcMp.insert(make_pair("ArmManualSpeed", DValue(m_SysParamWrapper->m_ArmManualSpeed))); + m_plcMp.insert(make_pair("ArmManualAcc", DValue(m_SysParamWrapper->m_ArmManualAcc))); + m_plcMp.insert(make_pair("ArmManualDec", DValue(m_SysParamWrapper->m_ArmManualDec))); + m_plcMp.insert(make_pair("ArmManualRefDistance", DValue(m_SysParamWrapper->m_ArmManualRefDistance))); + m_plcMp.insert(make_pair("ArmManualAbsPos", DValue(m_SysParamWrapper->m_ArmManualAbsPos))); + m_plcMp.insert(make_pair("SupplyCurrentPos", DValue(m_SysParamWrapper->m_SupplyCurrentPos))); + m_plcMp.insert(make_pair("SupplyCurrentLoad", DValue(m_SysParamWrapper->m_SupplyCurrentLoad))); + m_plcMp.insert(make_pair("SupplyManualSpeed", DValue(m_SysParamWrapper->m_SupplyManualSpeed))); + m_plcMp.insert(make_pair("SupplyManualAcc", DValue(m_SysParamWrapper->m_SupplyManualAcc))); + m_plcMp.insert(make_pair("SupplyManualDec", DValue(m_SysParamWrapper->m_SupplyManualDec))); + m_plcMp.insert(make_pair("SupplyManualRefDistance", DValue(m_SysParamWrapper->m_SupplyManualRefDistance))); + m_plcMp.insert(make_pair("SupplyManualAbsPos", DValue(m_SysParamWrapper->m_SupplyManualAbsPos))); + m_plcMp.insert(make_pair("MoldCylinderSeparatePos", DValue(m_SysParamWrapper->m_MoldCylinderSeparatePos))); + m_plcMp.insert(make_pair("PrintUpDownSafePos", DValue(m_SysParamWrapper->m_PrintUpDownSafePos))); + m_plcMp.insert(make_pair("Print3RSeparatePos", DValue(m_SysParamWrapper->m_Print3RSeparatePos))); + m_plcMp.insert(make_pair("Print3RSeparateCheckDistance", DValue(m_SysParamWrapper->m_Print3RSeparateCheckDistance))); + m_plcMp.insert(make_pair("PrintJackupDeoxygenPressureMinPos", DValue(m_SysParamWrapper->m_PrintJackupDeoxygenPressureMinPos))); + m_plcMp.insert(make_pair("PrintJackupPlatformBottomPos", DValue(m_SysParamWrapper->m_PrintJackupPlatformBottomPos))); + m_plcMp.insert(make_pair("PrintJackupPlatformPlanePos", DValue(m_SysParamWrapper->m_PrintJackupPlatformPlanePos))); + m_plcMp.insert(make_pair("PrintPlatformHight", DValue(m_SysParamWrapper->m_PrintPlatformHight))); + m_plcMp.insert(make_pair("MoldUpLimitPos", DValue(m_SysParamWrapper->m_MoldUpLimitPos))); + m_plcMp.insert(make_pair("MoldDownLimitPos", DValue(m_SysParamWrapper->m_MoldDownLimitPos))); + m_plcMp.insert(make_pair("CleanTrackConnectPos", DValue(m_SysParamWrapper->m_CleanTrackConnectPos))); + m_plcMp.insert(make_pair("CleanAxisPlatformAlignPos", DValue(m_SysParamWrapper->m_CleanAxisPlatformAlignPos))); + m_plcMp.insert(make_pair("CleanBoxCylinderConnectPos", DValue(m_SysParamWrapper->m_CleanBoxCylinderConnectPos))); + m_plcMp.insert(make_pair("Clean3RSeparatePos", DValue(m_SysParamWrapper->m_Clean3RSeparatePos))); + m_plcMp.insert(make_pair("Clean3RSeparateCheckDistance", DValue(m_SysParamWrapper->m_Clean3RSeparateCheckDistance))); + m_plcMp.insert(make_pair("CleanLowestPos", DValue(m_SysParamWrapper->m_CleanLowestPos))); + m_plcMp.insert(make_pair("CleanUpLimit", DValue(m_SysParamWrapper->m_CleanUpLimit))); + m_plcMp.insert(make_pair("CleanDownLimit", DValue(m_SysParamWrapper->m_CleanDownLimit))); + m_plcMp.insert(make_pair("EleCylinderPrintJackupPos", DValue(m_SysParamWrapper->m_EleCylinderPrintJackupPos))); + m_plcMp.insert(make_pair("EleCylinderCleanJackupPos", DValue(m_SysParamWrapper->m_EleCylinderCleanJackupPos))); + m_plcMp.insert(make_pair("EleCylinderBottomFitPos", DValue(m_SysParamWrapper->m_EleCylinderBottomFitPos))); + m_plcMp.insert(make_pair("EleCylinderSoftUpLimit", DValue(m_SysParamWrapper->m_EleCylinderSoftUpLimit))); + m_plcMp.insert(make_pair("EleCylinderSoftDownLimit", DValue(m_SysParamWrapper->m_EleCylinderSoftDownLimit))); + m_plcMp.insert(make_pair("LoadAxisTrackPrintPos", DValue(m_SysParamWrapper->m_LoadAxisTrackPrintPos))); + m_plcMp.insert(make_pair("LoadAxisTrackCleanPos", DValue(m_SysParamWrapper->m_LoadAxisTrackCleanPos))); + m_plcMp.insert(make_pair("LoadAxisTrackWaitPos", DValue(m_SysParamWrapper->m_LoadAxisTrackWaitPos))); + m_plcMp.insert(make_pair("LoadAxisLeftLimit", DValue(m_SysParamWrapper->m_LoadAxisLeftLimit))); + m_plcMp.insert(make_pair("LoadAxisRightLimit", DValue(m_SysParamWrapper->m_LoadAxisRightLimit))); + m_plcMp.insert(make_pair("ArmPowderAcceptPos", DValue(m_SysParamWrapper->m_ArmPowderAcceptPos))); + m_plcMp.insert(make_pair("ArmPowderDropFrontPos", DValue(m_SysParamWrapper->m_ArmPowderDropFrontPos))); + m_plcMp.insert(make_pair("ArmPrintFrontLimit", DValue(m_SysParamWrapper->m_ArmPrintFrontLimit))); + m_plcMp.insert(make_pair("ArmPrintBackLimit", DValue(m_SysParamWrapper->m_ArmPrintBackLimit))); + m_plcMp.insert(make_pair("ArmFrontLimit", DValue(m_SysParamWrapper->m_ArmFrontLimit))); + m_plcMp.insert(make_pair("ArmBackLimit", DValue(m_SysParamWrapper->m_ArmBackLimit))); + m_plcMp.insert(make_pair("MoldAbsTestPos", DValue(m_SysParamWrapper->m_MoldAbsTestPos))); + m_plcMp.insert(make_pair("CleanAbsTestPos", DValue(m_SysParamWrapper->m_CleanAbsTestPos))); + m_plcMp.insert(make_pair("EleCylinderAbsTestPos", DValue(m_SysParamWrapper->m_EleCylinderAbsTestPos))); + m_plcMp.insert(make_pair("LoadAxisAbsTestPos", DValue(m_SysParamWrapper->m_LoadAxisAbsTestPos))); + m_plcMp.insert(make_pair("ArmAbsTestPos", DValue(m_SysParamWrapper->m_ArmAbsTestPos))); + m_plcMp.insert(make_pair("LineEncMoveValue", DValue(m_SysParamWrapper->m_LineEncMoveValue))); + m_plcMp.insert(make_pair("LineEncPulseEqu", DValue(m_SysParamWrapper->m_LineEncPulseEqu))); + m_plcMp.insert(make_pair("MoldMainHomeIndexEnc", DValue(m_SysParamWrapper->m_MoldMainHomeIndexEnc))); + m_plcMp.insert(make_pair("MoldMainAlignEnc", DValue(m_SysParamWrapper->m_MoldMainAlignEnc))); + m_plcMp.insert(make_pair("MoldMainAlignHomeRel", DValue(m_SysParamWrapper->m_MoldMainAlignHomeRel))); + m_plcMp.insert(make_pair("MoldSlaveHomeIndexEnc", DValue(m_SysParamWrapper->m_MoldSlaveHomeIndexEnc))); + m_plcMp.insert(make_pair("MoldSlaveAlignEnc", DValue(m_SysParamWrapper->m_MoldSlaveAlignEnc))); + m_plcMp.insert(make_pair("MoldSlaveAlignHomeRel", DValue(m_SysParamWrapper->m_MoldSlaveAlignHomeRel))); + m_plcMp.insert(make_pair("CleanMainHomeIndexEnc", DValue(m_SysParamWrapper->m_CleanMainHomeIndexEnc))); + m_plcMp.insert(make_pair("CleanMainAlignEnc", DValue(m_SysParamWrapper->m_CleanMainAlignEnc))); + m_plcMp.insert(make_pair("CleanMainAlignHomeRel", DValue(m_SysParamWrapper->m_CleanMainAlignHomeRel))); + m_plcMp.insert(make_pair("CleanSlaveHomeIndexEnc", DValue(m_SysParamWrapper->m_CleanSlaveHomeIndexEnc))); + m_plcMp.insert(make_pair("CleanSlaveAlignEnc", DValue(m_SysParamWrapper->m_CleanSlaveAlignEnc))); + m_plcMp.insert(make_pair("CleanSlaveAlignHomeRel", DValue(m_SysParamWrapper->m_CleanSlaveAlignHomeRel))); + m_plcMp.insert(make_pair("EleCylinderMainHomeIndexEnc", DValue(m_SysParamWrapper->m_EleCylinderMainHomeIndexEnc))); + m_plcMp.insert(make_pair("EleCylinderMainAlignEnc", DValue(m_SysParamWrapper->m_EleCylinderMainAlignEnc))); + m_plcMp.insert(make_pair("EleCylinderMainAlignHomeRel", DValue(m_SysParamWrapper->m_EleCylinderMainAlignHomeRel))); + m_plcMp.insert(make_pair("EleCylinderSlaveHomeIndexEnc", DValue(m_SysParamWrapper->m_EleCylinderSlaveHomeIndexEnc))); + m_plcMp.insert(make_pair("EleCylinderSlaveAlignEnc", DValue(m_SysParamWrapper->m_EleCylinderSlaveAlignEnc))); + m_plcMp.insert(make_pair("EleCylinderSlaveAlignHomeRel", DValue(m_SysParamWrapper->m_EleCylinderSlaveAlignHomeRel))); m_SysParamWrapper->m_MoldAutoSpeed = new SysParamFloat(flag, 3, cc); flag += 4; //打印升降轴速度_自动_RW m_SysParamWrapper->m_MoldAutoAcc = new SysParamFloat(flag, 3, cc); flag += 4; //打印升降轴加速度_自动_RW @@ -11699,6 +12128,23 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_EleCylinderAutoRelShift = m_SysParamWrapper->m_CleanAutoRelShift; //电缸升降轴相对位移_自动_RW m_SysParamWrapper->m_EleCylinderAutoAbsPos = m_SysParamWrapper->m_CleanAutoAbsPos; //电缸升降轴绝对位置_自动_RW + m_plcMp.insert(make_pair("MoldAutoSpeed", DValue(m_SysParamWrapper->m_MoldAutoSpeed))); + m_plcMp.insert(make_pair("MoldAutoAcc", DValue(m_SysParamWrapper->m_MoldAutoAcc))); + m_plcMp.insert(make_pair("MoldAutoDec", DValue(m_SysParamWrapper->m_MoldAutoDec))); + m_plcMp.insert(make_pair("MoldAutoRelShift", DValue(m_SysParamWrapper->m_MoldAutoRelShift))); + m_plcMp.insert(make_pair("MoldAutoAbsPos", DValue(m_SysParamWrapper->m_MoldAutoAbsPos))); + m_plcMp.insert(make_pair("CleanAutoSpeed", DValue(m_SysParamWrapper->m_CleanAutoSpeed))); + m_plcMp.insert(make_pair("CleanAutoAcc", DValue(m_SysParamWrapper->m_CleanAutoAcc))); + m_plcMp.insert(make_pair("CleanAutoDec", DValue(m_SysParamWrapper->m_CleanAutoDec))); + m_plcMp.insert(make_pair("CleanAutoRelShift", DValue(m_SysParamWrapper->m_CleanAutoRelShift))); + m_plcMp.insert(make_pair("CleanAutoAbsPos", DValue(m_SysParamWrapper->m_CleanAutoAbsPos))); + m_plcMp.insert(make_pair("EleCylinderAutoSpeed", DValue(m_SysParamWrapper->m_EleCylinderAutoSpeed))); + m_plcMp.insert(make_pair("EleCylinderAutoAcc", DValue(m_SysParamWrapper->m_EleCylinderAutoAcc))); + m_plcMp.insert(make_pair("EleCylinderAutoDec", DValue(m_SysParamWrapper->m_EleCylinderAutoDec))); + m_plcMp.insert(make_pair("EleCylinderAutoRelShift", DValue(m_SysParamWrapper->m_EleCylinderAutoRelShift))); + m_plcMp.insert(make_pair("EleCylinderAutoAbsPos", DValue(m_SysParamWrapper->m_EleCylinderAutoAbsPos))); + + m_SysParamWrapper->m_LoadAxisAutoSpeed = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴速度_自动_RW m_SysParamWrapper->m_LoadAxisnAutoAcc = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴加速度_自动_RW m_SysParamWrapper->m_LoadAxisAutoDec = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴减速度_自动_RW @@ -11714,6 +12160,21 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_SupplyAxisAutoDec = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴减速度_自动_RW m_SysParamWrapper->m_SupplyAxisAutoRelShift = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴相对位移_自动_RW m_SysParamWrapper->m_SupplyAxisAutoAbsPos = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴绝对位置_自动_RW + m_plcMp.insert(make_pair("LoadAxisAutoSpeed", DValue(m_SysParamWrapper->m_LoadAxisAutoSpeed))); + m_plcMp.insert(make_pair("LoadAxisnAutoAcc", DValue(m_SysParamWrapper->m_LoadAxisnAutoAcc))); + m_plcMp.insert(make_pair("LoadAxisAutoDec", DValue(m_SysParamWrapper->m_LoadAxisAutoDec))); + m_plcMp.insert(make_pair("LoadAxisAutoRelShift", DValue(m_SysParamWrapper->m_LoadAxisAutoRelShift))); + m_plcMp.insert(make_pair("LoadAxisAutoAbsPos", DValue(m_SysParamWrapper->m_LoadAxisAutoAbsPos))); + m_plcMp.insert(make_pair("ArmAutoSpeed", DValue(m_SysParamWrapper->m_ArmAutoSpeed))); + m_plcMp.insert(make_pair("ArmAxisnAutoAcc", DValue(m_SysParamWrapper->m_ArmAxisnAutoAcc))); + m_plcMp.insert(make_pair("ArmAxisAutoDec", DValue(m_SysParamWrapper->m_ArmAxisAutoDec))); + m_plcMp.insert(make_pair("ArmAxisAutoRelShift", DValue(m_SysParamWrapper->m_ArmAxisAutoRelShift))); + m_plcMp.insert(make_pair("ArmAxisAutoAbsPos", DValue(m_SysParamWrapper->m_ArmAxisAutoAbsPos))); + m_plcMp.insert(make_pair("SupplyAutoSpeed", DValue(m_SysParamWrapper->m_SupplyAutoSpeed))); + m_plcMp.insert(make_pair("SupplyAxisnAutoAcc", DValue(m_SysParamWrapper->m_SupplyAxisnAutoAcc))); + m_plcMp.insert(make_pair("SupplyAxisAutoDec", DValue(m_SysParamWrapper->m_SupplyAxisAutoDec))); + m_plcMp.insert(make_pair("SupplyAxisAutoRelShift", DValue(m_SysParamWrapper->m_SupplyAxisAutoRelShift))); + m_plcMp.insert(make_pair("SupplyAxisAutoAbsPos", DValue(m_SysParamWrapper->m_SupplyAxisAutoAbsPos))); m_SysParamWrapper->m_Print3RSeparatTorqueThreshold = new SysParamFloat(flag, 3, cc); flag += 4; //打印3R脱离扭力报警值_RW Real m_SysParamWrapper->m_MoldUpTorqueThrehold = new SysParamFloat(flag, 3, cc); flag += 4; //打印升降轴上升扭力报警值_RW Real @@ -11747,6 +12208,38 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_ArmTorqueThreshold = new SysParamFloat(flag, 3, cc); flag += 4; //铺粉轴扭力报警值 m_SysParamWrapper->m_LoadTorqueThreshold = new SysParamFloat(flag, 3, cc); flag += 4; //移载轴扭力报警值 m_SysParamWrapper->m_SupplyTorqueThreshold = new SysParamFloat(flag, 3, cc); flag += 4; //供粉轴扭力报警值 + m_plcMp.insert(make_pair("Print3RSeparatTorqueThreshold", DValue(m_SysParamWrapper->m_Print3RSeparatTorqueThreshold))); + m_plcMp.insert(make_pair("MoldUpTorqueThrehold", DValue(m_SysParamWrapper->m_MoldUpTorqueThrehold))); + m_plcMp.insert(make_pair("MoldDownTorqueThrehold", DValue(m_SysParamWrapper->m_MoldDownTorqueThrehold))); + m_plcMp.insert(make_pair("Clean3RSeparatTorqueThrehold", DValue(m_SysParamWrapper->m_Clean3RSeparatTorqueThrehold))); + m_plcMp.insert(make_pair("CleanUpTorqueThrehold", DValue(m_SysParamWrapper->m_CleanUpTorqueThrehold))); + m_plcMp.insert(make_pair("CleanDownTorqueThreshold", DValue(m_SysParamWrapper->m_CleanDownTorqueThreshold))); + m_plcMp.insert(make_pair("EleCylinderUpTorqueThrehold", DValue(m_SysParamWrapper->m_EleCylinderUpTorqueThrehold))); + m_plcMp.insert(make_pair("EleCylinderDownTorqueThreshold", DValue(m_SysParamWrapper->m_EleCylinderDownTorqueThreshold))); + m_plcMp.insert(make_pair("CoverType", DValue(m_SysParamWrapper->m_CoverType))); + m_plcMp.insert(make_pair("CoverSpeed", DValue(m_SysParamWrapper->m_CoverSpeed))); + m_plcMp.insert(make_pair("CoverReturnSpeed", DValue(m_SysParamWrapper->m_CoverReturnSpeed))); + m_plcMp.insert(make_pair("CoverDistance", DValue(m_SysParamWrapper->m_CoverDistance))); + m_plcMp.insert(make_pair("LayerThick", DValue(m_SysParamWrapper->m_LayerThick))); + m_plcMp.insert(make_pair("FixGap", DValue(m_SysParamWrapper->m_FixGap))); + m_plcMp.insert(make_pair("SupplyCount", DValue(m_SysParamWrapper->m_SupplyCount))); + m_plcMp.insert(make_pair("SupplyTime", DValue(m_SysParamWrapper->m_SupplyTime))); + m_plcMp.insert(make_pair("DebugLayerThick", DValue(m_SysParamWrapper->m_DebugLayerThick))); + m_plcMp.insert(make_pair("DebugFixGap", DValue(m_SysParamWrapper->m_DebugFixGap))); + m_plcMp.insert(make_pair("DebugSupplyTime", DValue(m_SysParamWrapper->m_DebugSupplyTime))); + m_plcMp.insert(make_pair("DebugSupplyCount", DValue(m_SysParamWrapper->m_DebugSupplyCount))); + m_plcMp.insert(make_pair("DebugCoverDistance", DValue(m_SysParamWrapper->m_DebugCoverDistance))); + m_plcMp.insert(make_pair("MoldHighSpeed", DValue(m_SysParamWrapper->m_MoldHighSpeed))); + m_plcMp.insert(make_pair("MoldDeoxygenSpeed", DValue(m_SysParamWrapper->m_MoldDeoxygenSpeed))); + m_plcMp.insert(make_pair("CleanHighSpeed", DValue(m_SysParamWrapper->m_CleanHighSpeed))); + m_plcMp.insert(make_pair("PrintPressureThrehold", DValue(m_SysParamWrapper->m_PrintPressureThrehold))); + m_plcMp.insert(make_pair("PrintPressureThrehold", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintPressureThrehold))); + m_plcMp.insert(make_pair("MoldDeoxygenTime", DValue(m_SysParamWrapper->m_MoldDeoxygenTime))); + m_plcMp.insert(make_pair("PowderCarDeoxygenTime", DValue(m_SysParamWrapper->m_PowderCarDeoxygenTime))); + m_plcMp.insert(make_pair("GratingRulerValue", DValue(m_SysParamWrapper->m_GratingRulerValue))); + m_plcMp.insert(make_pair("ArmTorqueThreshold", DValue(m_SysParamWrapper->m_ArmTorqueThreshold))); + m_plcMp.insert(make_pair("LoadTorqueThreshold", DValue(m_SysParamWrapper->m_LoadTorqueThreshold))); + m_plcMp.insert(make_pair("LoadTorqueThreshold", DValue(m_SysParamWrapper->m_SupplyTorqueThreshold))); m_SysParamWrapper->m_PrintMainLead = new SysParamFloat(flag, 3, cc); flag += 4; //打印主轴导程_RW m_SysParamWrapper->m_PrintMainReductionRatio = new SysParamFloat(flag, 3, cc); flag += 4; //打印主轴减速比 @@ -11775,6 +12268,33 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_SupplyLead = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴导程 m_SysParamWrapper->m_SupplyReductionRatio = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴减速比 m_SysParamWrapper->m_SupplyRotationlSpeed = new SysParamFloat(flag, 3, cc); flag += 4; //供粉转轴电机最高转速 + m_plcMp.insert(make_pair("PrintMainLead", DValue(m_SysParamWrapper->m_PrintMainLead))); + m_plcMp.insert(make_pair("PrintMainReductionRatio", DValue(m_SysParamWrapper->m_PrintMainReductionRatio))); + m_plcMp.insert(make_pair("PrintMainMaxRotationlSpeed", DValue(m_SysParamWrapper->m_PrintMainMaxRotationlSpeed))); + m_plcMp.insert(make_pair("PrintSlaveLead", DValue(m_SysParamWrapper->m_PrintSlaveLead))); + m_plcMp.insert(make_pair("PrintSlaveReductionRatio", DValue(m_SysParamWrapper->m_PrintSlaveReductionRatio))); + m_plcMp.insert(make_pair("PrintSlaveMaxRotationlSpeed", DValue(m_SysParamWrapper->m_PrintSlaveMaxRotationlSpeed))); + m_plcMp.insert(make_pair("CleanMainLead", DValue(m_SysParamWrapper->m_CleanMainLead))); + m_plcMp.insert(make_pair("CleanMainReductionRatio", DValue(m_SysParamWrapper->m_CleanMainReductionRatio))); + m_plcMp.insert(make_pair("CleanMainMaxRotationlSpeed", DValue(m_SysParamWrapper->m_CleanMainMaxRotationlSpeed))); + m_plcMp.insert(make_pair("CleanSlaveLead", DValue(m_SysParamWrapper->m_CleanSlaveLead))); + m_plcMp.insert(make_pair("CleanSlaveReductionRatio", DValue(m_SysParamWrapper->m_CleanSlaveReductionRatio))); + m_plcMp.insert(make_pair("CleanSlaveMaxRotationlSpeed", DValue(m_SysParamWrapper->m_CleanSlaveMaxRotationlSpeed))); + m_plcMp.insert(make_pair("EleCylinderMainLead", DValue(m_SysParamWrapper->m_EleCylinderMainLead))); + m_plcMp.insert(make_pair("EleCylinderMainReductionRatio", DValue(m_SysParamWrapper->m_EleCylinderMainReductionRatio))); + m_plcMp.insert(make_pair("EleCylinderMainMaxRotationlSpeed", DValue(m_SysParamWrapper->m_EleCylinderMainMaxRotationlSpeed))); + m_plcMp.insert(make_pair("EleCylinderSlaveLead", DValue(m_SysParamWrapper->m_EleCylinderSlaveLead))); + m_plcMp.insert(make_pair("EleCylinderSlaveReductionRatio", DValue(m_SysParamWrapper->m_EleCylinderSlaveReductionRatio))); + m_plcMp.insert(make_pair("EleCylinderSlaveMaxRotationlSpeed", DValue(m_SysParamWrapper->m_EleCylinderSlaveMaxRotationlSpeed))); + m_plcMp.insert(make_pair("LoadAxisLead", DValue(m_SysParamWrapper->m_LoadAxisLead))); + m_plcMp.insert(make_pair("LoadAxisReductionRatio", DValue(m_SysParamWrapper->m_LoadAxisReductionRatio))); + m_plcMp.insert(make_pair("LoadAxisMaxRotationlSpeed", DValue(m_SysParamWrapper->m_LoadAxisMaxRotationlSpeed))); + m_plcMp.insert(make_pair("ArmLead", DValue(m_SysParamWrapper->m_ArmLead))); + m_plcMp.insert(make_pair("ArmReductionRatio", DValue(m_SysParamWrapper->m_ArmReductionRatio))); + m_plcMp.insert(make_pair("ArmMaxRotationlSpeed", DValue(m_SysParamWrapper->m_ArmMaxRotationlSpeed))); + m_plcMp.insert(make_pair("SupplyLead", DValue(m_SysParamWrapper->m_SupplyLead))); + m_plcMp.insert(make_pair("SupplyReductionRatio", DValue(m_SysParamWrapper->m_SupplyReductionRatio))); + m_plcMp.insert(make_pair("SupplyRotationlSpeed", DValue(m_SysParamWrapper->m_SupplyRotationlSpeed))); m_SysParamWrapper->m_ArmSlotDistance = new SysParamFloat(flag, 3, cc); flag += 4; //铺粉槽距离 m_SysParamWrapper->m_PowderJarCabinPressureVoltage = new SysParamFloat(flag, 3, cc); flag += 4; //下粉罐与粉仓的压差电压值 @@ -11819,7 +12339,49 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_DataSizeMinY = new SysParamFloat(flag, 3, cc); flag += 4; m_SysParamWrapper->m_DataSizeMaxY = new SysParamFloat(flag, 3, cc); flag += 4; - + + m_plcMp.insert(make_pair("ArmSlotDistance", DValue(m_SysParamWrapper->m_ArmSlotDistance))); + m_plcMp.insert(make_pair("PowderJarCabinPressureVoltage", DValue(m_SysParamWrapper->m_PowderJarCabinPressureVoltage))); + m_plcMp.insert(make_pair("PowderJarCabinPressureValue", DValue(m_SysParamWrapper->m_PowderJarCabinPressureValue))); + m_plcMp.insert(make_pair("CleanBoxDeoxygenSetValue", DValue(m_SysParamWrapper->m_CleanBoxDeoxygenSetValue))); + m_plcMp.insert(make_pair("CleanBoxOxygenDownLimit", DValue(m_SysParamWrapper->m_CleanBoxOxygenDownLimit))); + m_plcMp.insert(make_pair("CleanBoxOxygenUpLimit", DValue(m_SysParamWrapper->m_CleanBoxOxygenUpLimit))); + m_plcMp.insert(make_pair("CleanBoxPressureReleaseValue", DValue(m_SysParamWrapper->m_CleanBoxPressureReleaseValue))); + m_plcMp.insert(make_pair("PrintCar1RealWeight", DValue(m_SysParamWrapper->m_PrintCar1RealWeight))); + m_plcMp.insert(make_pair("PrintCar1AlarmWeight", DValue(m_SysParamWrapper->m_PrintCar1AlarmWeight))); + m_plcMp.insert(make_pair("PrintCar2RealWeight", DValue(m_SysParamWrapper->m_PrintCar2RealWeight))); + m_plcMp.insert(make_pair("PrintCar2AlarmWeight", DValue(m_SysParamWrapper->m_PrintCar2AlarmWeight))); + m_plcMp.insert(make_pair("CleanCar1RealWeight", DValue(m_SysParamWrapper->m_CleanCar1RealWeight))); + m_plcMp.insert(make_pair("CleanCar1AlarmWeight", DValue(m_SysParamWrapper->m_CleanCar1AlarmWeight))); + m_plcMp.insert(make_pair("CleanCar2RealWeight", DValue(m_SysParamWrapper->m_CleanCar2RealWeight))); + m_plcMp.insert(make_pair("CleanCar2AlarmWeight", DValue(m_SysParamWrapper->m_CleanCar2AlarmWeight))); + m_plcMp.insert(make_pair("LoadHandPos", DValue(m_SysParamWrapper->m_LoadHandPos))); + m_plcMp.insert(make_pair("PowderLevelLength", DValue(m_SysParamWrapper->m_PowderLevelLength))); + m_plcMp.insert(make_pair("PowderLevelValue", DValue(m_SysParamWrapper->m_PowderLevelValue))); + m_plcMp.insert(make_pair("PrintAirRenewalPresRelValue", DValue(m_SysParamWrapper->m_PrintAirRenewalPresRelValue))); + m_plcMp.insert(make_pair("RollerEdgeSearchOffset", DValue(m_SysParamWrapper->m_RollerEdgeSearchOffset))); + m_plcMp.insert(make_pair("LoadHandCrashPos", DValue(m_SysParamWrapper->m_LoadHandCrashPos))); + m_plcMp.insert(make_pair("ArmCatpureHomeFastSpeed", DValue(m_SysParamWrapper->m_ArmCatpureHomeFastSpeed))); + m_plcMp.insert(make_pair("ArmCatpureHomeSlowSpeed", DValue(m_SysParamWrapper->m_ArmCatpureHomeSlowSpeed))); + m_plcMp.insert(make_pair("LinearEncoderErrorJudgeValue", DValue(m_SysParamWrapper->m_LinearEncoderErrorJudgeValue))); + m_plcMp.insert(make_pair("LinearEncoderPerLayerRealValue", DValue(m_SysParamWrapper->m_LinearEncoderPerLayerRealValue))); + m_plcMp.insert(make_pair("GapCompensateDiffValue", DValue(m_SysParamWrapper->m_GapCompensateDiffValue))); + m_plcMp.insert(make_pair("MoldTheoryDistance", DValue(m_SysParamWrapper->m_MoldTheoryDistance))); + m_plcMp.insert(make_pair("LinearActDistance", DValue(m_SysParamWrapper->m_LinearActDistance))); + m_plcMp.insert(make_pair("LinearActPulse", DValue(m_SysParamWrapper->m_LinearActPulse))); + m_plcMp.insert(make_pair("PrintHomeSpeed", DValue(m_SysParamWrapper->m_PrintHomeSpeed))); + m_plcMp.insert(make_pair("EleCylinderHomeSpeed", DValue(m_SysParamWrapper->m_EleCylinderHomeSpeed))); + m_plcMp.insert(make_pair("CleanHomeSpeed", DValue(m_SysParamWrapper->m_CleanHomeSpeed))); + m_plcMp.insert(make_pair("LoadHomeSpeed", DValue(m_SysParamWrapper->m_LoadHomeSpeed))); + m_plcMp.insert(make_pair("LoadSearchEdgeTorqueAlarmValue", DValue(m_SysParamWrapper->m_LoadSearchEdgeTorqueAlarmValue))); + m_plcMp.insert(make_pair("ArmBackAcceptPos", DValue(m_SysParamWrapper->m_ArmBackAcceptPos))); + m_plcMp.insert(make_pair("HighPressureGasJudgmentValue", DValue(m_SysParamWrapper->m_HighPressureGasJudgmentValue))); + m_plcMp.insert(make_pair("ProtectiveGasJudgmentValue", DValue(m_SysParamWrapper->m_ProtectiveGasJudgmentValue))); + m_plcMp.insert(make_pair("UnloadDropDistance", DValue(m_SysParamWrapper->m_UnloadDropDistance))); + m_plcMp.insert(make_pair("DataSizeMinY", DValue(m_SysParamWrapper->m_DataSizeMinY))); + m_plcMp.insert(make_pair("DataSizeMaxY", DValue(m_SysParamWrapper->m_DataSizeMaxY))); + + flag = 914; m_SysParamWrapper->m_AllowPrintHigh = new SysParamFloat(flag, 3, cc); flag = 1158; @@ -11861,6 +12423,43 @@ void HBD1000::InitSysParam(SysParamWrapper* spw, PLCReveiver* cc) m_SysParamWrapper->m_LinearEncoderCompensateTime = new SysParamInt(flag, 65, cc); flag += 4; m_SysParamWrapper->m_DropPowderOpenDeleyTime = new SysParamInt(flag, 65, cc); flag += 4; //下粉阀开延时ms_RW m_SysParamWrapper->m_DropPowderCloseDelayTime = new SysParamInt(flag, 65, cc); flag += 4; //下粉阀关延时ms_RW + + m_plcMp.insert(make_pair("AllowPrintHigh", DValue(m_SysParamWrapper->m_AllowPrintHigh))); + m_plcMp.insert(make_pair("AutoCaptureCoverHomeIntervalTimes", DValue(m_SysParamWrapper->m_AutoCaptureCoverHomeIntervalTimes))); + m_plcMp.insert(make_pair("AutoCaptureCoverHomeCalcTimes", DValue(m_SysParamWrapper->m_AutoCaptureCoverHomeCalcTimes))); + m_plcMp.insert(make_pair("LinearEncoderCompensateTimes", DValue(m_SysParamWrapper->m_LinearEncoderCompensateTimes))); + + m_plcMp.insert(make_pair("CleanBoxDeoxygenSetValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanBoxDeoxygenSetValue))); + m_plcMp.insert(make_pair("CleanBoxOxygenDownLimit", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanBoxOxygenDownLimit))); + m_plcMp.insert(make_pair("CleanBoxOxygenUpLimit", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanBoxOxygenUpLimit))); + m_plcMp.insert(make_pair("CleanBoxPressureReleaseValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanBoxPressureReleaseValue))); + m_plcMp.insert(make_pair("PrintCar1AlarmWeight", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintCar1AlarmWeight))); + m_plcMp.insert(make_pair("PrintCar2AlarmWeight", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintCar2AlarmWeight))); + m_plcMp.insert(make_pair("CleanCar1AlarmWeight", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanCar1AlarmWeight))); + m_plcMp.insert(make_pair("CleanCar2AlarmWeight", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanCar2AlarmWeight))); + m_plcMp.insert(make_pair("LoadHandPos", DValue(m_SysParamWrapper->m_EnvUIAssit.m_LoadHandPos))); + m_plcMp.insert(make_pair("PowderLevelLength", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PowderLevelLength))); + m_plcMp.insert(make_pair("PowderLevelValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PowderLevelValue))); + m_plcMp.insert(make_pair("PrintAirRenewalPresRelValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintAirRenewalPresRelValue))); + m_plcMp.insert(make_pair("RollerEdgeSearchOffset", DValue(m_SysParamWrapper->m_EnvUIAssit.m_RollerEdgeSearchOffset))); + m_plcMp.insert(make_pair("LoadHandCrashPos", DValue(m_SysParamWrapper->m_EnvUIAssit.m_LoadHandCrashPos))); + m_plcMp.insert(make_pair("ArmCatpureHomeFastSpeed", DValue(m_SysParamWrapper->m_EnvUIAssit.m_ArmCatpureHomeFastSpeed))); + m_plcMp.insert(make_pair("ArmCatpureHomeSlowSpeed", DValue(m_SysParamWrapper->m_EnvUIAssit.m_ArmCatpureHomeSlowSpeed))); + m_plcMp.insert(make_pair("LinearEncoderErrorJudgeValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_LinearEncoderErrorJudgeValue))); + m_plcMp.insert(make_pair("GapCompensateDiffValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_GapCompensateDiffValue))); + m_plcMp.insert(make_pair("PrintHomeSpeed", DValue(m_SysParamWrapper->m_EnvUIAssit.m_PrintHomeSpeed))); + m_plcMp.insert(make_pair("CleanHomeSpeed", DValue(m_SysParamWrapper->m_EnvUIAssit.m_CleanHomeSpeed))); + m_plcMp.insert(make_pair("LoadHomeSpeed", DValue(m_SysParamWrapper->m_EnvUIAssit.m_LoadHomeSpeed))); + + m_plcMp.insert(make_pair("AutoCaptureCoverHomeIntervalTimes", DValue(m_SysParamWrapper->m_EnvUIAssit.m_AutoCaptureCoverHomeIntervalTimes))); + m_plcMp.insert(make_pair("HighPressureGasJudgmentValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_HighPressureGasJudgmentValue))); + m_plcMp.insert(make_pair("ProtectiveGasJudgmentValue", DValue(m_SysParamWrapper->m_EnvUIAssit.m_ProtectiveGasJudgmentValue))); + + m_plcMp.insert(make_pair("HeatingCheckTime", DValue(m_SysParamWrapper->m_HeatingCheckTime))); + m_plcMp.insert(make_pair("CylinderMotionDelayTime", DValue(m_SysParamWrapper->m_CylinderMotionDelayTime))); + m_plcMp.insert(make_pair("LinearEncoderCompensateTime", DValue(m_SysParamWrapper->m_LinearEncoderCompensateTime))); + m_plcMp.insert(make_pair("DropPowderOpenDeleyTime", DValue(m_SysParamWrapper->m_DropPowderOpenDeleyTime))); + m_plcMp.insert(make_pair("DropPowderCloseDelayTime", DValue(m_SysParamWrapper->m_DropPowderCloseDelayTime))); } void HBD1000::InitPLCCommand(vector& vecs) @@ -11959,21 +12558,6 @@ void HBD1000::ProcReadPLC(void* pobject, Command* pcommand) TS7DataItem pDataSize = pdataItems[6]; CoreCommunication* cc = (CoreCommunication*)machine->m_PLC; - - /*for (int i = 0; i < itemcount; ++i) { - WriteData* data = new WriteData(); - data->dataType = WRITETYPE(i); - data->strValue = (char*)pdataItems[i].pdata; - data->result = true; - for (auto& client : machine->m_clientUser) { - client->SetPushMsg(data); - } - - }*/ - - - - std::unique_lock lock(cc->m_ValueMtx); if (pIOAndStatus.Result == 0) { unsigned char* arr = (unsigned char*)pIOAndStatus.pdata; diff --git a/PrintS/Machine/HBD1200.cpp b/PrintS/Machine/HBD1200.cpp index ea93fee..3a68536 100644 --- a/PrintS/Machine/HBD1200.cpp +++ b/PrintS/Machine/HBD1200.cpp @@ -4263,6 +4263,16 @@ void HBD1200::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_TouchPanelCtrling = new SysParamBool(flag++, 1, cc); //触摸屏控制状态 m_SignalStateWrapper->m_MotionDebug = new SysParamBool(flag++, 1, cc); //动作流程调试模式 m_SignalStateWrapper->m_CylinderExceptionReset = new SysParamBool(flag++, 1, cc); //气缸异常复位 + m_plcMp.insert(make_pair("PLCKeepAlive", DValue(m_SignalStateWrapper->m_PLCKeepAlive))); + m_plcMp.insert(make_pair("PCKeepAlice", DValue(m_SignalStateWrapper->m_PCKeepAlice))); + m_plcMp.insert(make_pair("DeviceStandby", DValue(m_SignalStateWrapper->m_DeviceStandby))); + m_plcMp.insert(make_pair("DevicePrinting", DValue(m_SignalStateWrapper->m_DevicePrinting))); + m_plcMp.insert(make_pair("DeviceManualDebug", DValue(m_SignalStateWrapper->m_DeviceManualDebug))); + m_plcMp.insert(make_pair("DeviceAutoRuning", DValue(m_SignalStateWrapper->m_DeviceAutoRuning))); + m_plcMp.insert(make_pair("TouchPanelCtrling", DValue(m_SignalStateWrapper->m_TouchPanelCtrling))); + m_plcMp.insert(make_pair("MotionDebug", DValue(m_SignalStateWrapper->m_MotionDebug))); + m_plcMp.insert(make_pair("CylinderExceptionReset", DValue(m_SignalStateWrapper->m_CylinderExceptionReset))); + flag = 55 * 8 + 6; m_SignalStateWrapper->m_PLCConnectAlarm = new SysParamBool(flag++, 1, cc); //PC与PLC网络异常 @@ -4283,274 +4293,486 @@ void HBD1200::InitSignal(SignalStateWrapper* ssw, PLCReveiver* cc) m_SignalStateWrapper->m_Laser4Alarm = new SysParamBool(flag++, 1, cc); //激光器4报警 m_SignalStateWrapper->m_HeatingInputAlarm = new SysParamBool(flag++, 1, cc); //加热输入异常 m_SignalStateWrapper->m_HeatingOutputAlarm = new SysParamBool(flag++, 1, cc); //加热输出异常 + m_plcMp.insert(make_pair("PLCConnectAlarm", DValue(m_SignalStateWrapper->m_PLCConnectAlarm))); + m_plcMp.insert(make_pair("SystemStopAlarm", DValue(m_SignalStateWrapper->m_SystemStopAlarm))); + m_plcMp.insert(make_pair("HighPressureLackAlarm", DValue(m_SignalStateWrapper->m_HighPressureLackAlarm))); + m_plcMp.insert(make_pair("ProtectGasLackAlarm", DValue(m_SignalStateWrapper->m_ProtectGasLackAlarm))); + m_plcMp.insert(make_pair("PowerDownAlarm", DValue(m_SignalStateWrapper->m_PowerDownAlarm))); + m_plcMp.insert(make_pair("OutsideOxygenLackAlarm", DValue(m_SignalStateWrapper->m_OutsideOxygenLackAlarm))); + m_plcMp.insert(make_pair("LaserChillerAlarm", DValue(m_SignalStateWrapper->m_LaserChillerAlarm))); + m_plcMp.insert(make_pair("BusAirSwitchAlarm", DValue(m_SignalStateWrapper->m_BusAirSwitchAlarm))); + m_plcMp.insert(make_pair("ExtDevicePowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_ExtDevicePowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("HeatingPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_HeatingPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("LaserPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_LaserPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("ServoPowerAirSwitchAlarm", DValue(m_SignalStateWrapper->m_ServoPowerAirSwitchAlarm))); + m_plcMp.insert(make_pair("Laser1Alarm", DValue(m_SignalStateWrapper->m_Laser1Alarm))); + m_plcMp.insert(make_pair("Laser2Alarm", DValue(m_SignalStateWrapper->m_Laser2Alarm))); + m_plcMp.insert(make_pair("Laser3Alarm", DValue(m_SignalStateWrapper->m_Laser3Alarm))); + m_plcMp.insert(make_pair("Laser4Alarm", DValue(m_SignalStateWrapper->m_Laser4Alarm))); + m_plcMp.insert(make_pair("HeatingInputAlarm", DValue(m_SignalStateWrapper->m_HeatingInputAlarm))); + m_plcMp.insert(make_pair("HeatingOutputAlarm", DValue(m_SignalStateWrapper->m_HeatingOutputAlarm))); - m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn = new SysParamBool(flag++, 1, cc); //存粉小车1粉罐已满警示 - m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn = new SysParamBool(flag++, 1, cc); //存粉小车1没有连接警示 - m_SignalStateWrapper->m_PrintStorageCar1BlockWarn = new SysParamBool(flag++, 1, cc); //打印存粉小车1堵塞警示 + m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn = new SysParamBool(flag++, 1, cc, "存粉小车1粉罐已满警示"); + m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn = new SysParamBool(flag++, 1, cc, "存粉小车1没有连接警示"); + m_SignalStateWrapper->m_PrintStorageCar1BlockWarn = new SysParamBool(flag++, 1, cc, "打印存粉小车1堵塞警示"); flag++; - m_SignalStateWrapper->m_MoldMainUpLimitActive = new SysParamBool(flag++, 1, cc); //打印主轴上限位触发警示 - m_SignalStateWrapper->m_MoldMainDownLimitActive = new SysParamBool(flag++, 1, cc); //打印主轴下限位触发警示 + m_SignalStateWrapper->m_MoldMainUpLimitActive = new SysParamBool(flag++, 1, cc, "打印主轴上限位触发警示"); + m_SignalStateWrapper->m_MoldMainDownLimitActive = new SysParamBool(flag++, 1, cc, "打印主轴下限位触发警示"); flag++; flag++; flag++; flag++; flag++; - m_SignalStateWrapper->m_PrintTrackDisableWarn = new SysParamBool(flag++, 1, cc); //轨道打印位感应失效警告 + m_SignalStateWrapper->m_PrintTrackDisableWarn = new SysParamBool(flag++, 1, cc, "轨道打印位感应失效警告"); flag++; flag++; flag++; flag++; flag++; flag++; - m_SignalStateWrapper->m_CylinderExtendOnAlarm = new SysParamBool(flag++, 1, cc); //缸体固定气缸伸出不到位异常 - m_SignalStateWrapper->m_CylinderExtendOffAlarm = new SysParamBool(flag++, 1, cc); //缸体固定定位气缸缩回不到位异常 + m_SignalStateWrapper->m_CylinderExtendOnAlarm = new SysParamBool(flag++, 1, cc, "缸体固定气缸伸出不到位异常"); + m_SignalStateWrapper->m_CylinderExtendOffAlarm = new SysParamBool(flag++, 1, cc, "缸体固定定位气缸缩回不到位异常"); flag++; flag++; - m_SignalStateWrapper->m_PrintCylinderVerifyAlarm = new SysParamBool(flag++, 1, cc); //打印位缸体检测异常 + m_SignalStateWrapper->m_PrintCylinderVerifyAlarm = new SysParamBool(flag++, 1, cc, "打印位缸体检测异常"); flag++; flag++; flag++; flag++; flag++; - m_SignalStateWrapper->m_CleanTrackPosDisableAlarm = new SysParamBool(flag++, 1, cc); //轨道清粉位失效异常 - m_SignalStateWrapper->m_CleanLiftStopAlarm = new SysParamBool(flag++, 1, cc); //清粉升降急停异常 - m_SignalStateWrapper->m_LoadHandPosSensorDiable = new SysParamBool(flag++, 1, cc); //移载吊装位感应器失效 - m_SignalStateWrapper->m_MainPowerLossCheckAlarm = new SysParamBool(flag++, 1, cc); //主电源缺相检测异常 - m_SignalStateWrapper->m_PrintCabinLockDisableAlarm = new SysParamBool(flag++, 1, cc); //打印舱电锁感应异常 - m_SignalStateWrapper->m_CleanBoxUpOpenAlarm = new SysParamBool(flag++, 1, cc); //清粉箱上盖气缸打开不到位异常 - m_SignalStateWrapper->m_CleanBoxUpCloseAlarm = new SysParamBool(flag++, 1, cc); //清粉箱上盖气缸关闭不到位异常 - m_SignalStateWrapper->m_CylinderHandPlatformOpenAlarm = new SysParamBool(flag++, 1, cc); //缸体吊装盖板打开异常 - m_SignalStateWrapper->m_CylinderHandDoorOpenAlarm = new SysParamBool(flag++, 1, cc); //缸体吊装门打开异常 - flag++; - flag++; - m_SignalStateWrapper->m_HandPlatformCloseAlarm = new SysParamBool(flag++, 1, cc); //吊装盖板关闭异常 - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - flag++; - m_SignalStateWrapper->m_ArmFrontLimit = new SysParamBool(flag++, 1, cc); //铺粉轴前限位触发警示 - m_SignalStateWrapper->m_ArmBackLimit = new SysParamBool(flag++, 1, cc); //铺粉轴后限位触发警示 - m_SignalStateWrapper->m_LoadAxisLeftLimit = new SysParamBool(flag++, 1, cc); //移载轴左限位触发警示 - m_SignalStateWrapper->m_LoadAxisRightLimit = new SysParamBool(flag++, 1, cc); //移载轴右限位触发警示 - flag++; - flag++; - flag++; - m_SignalStateWrapper->m_PowderPosition1Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器1异常 - m_SignalStateWrapper->m_PowderPosition2Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器2异常 - m_SignalStateWrapper->m_PowderPosition3Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器3异常 - m_SignalStateWrapper->m_PowderPosition4Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器4异常 - m_SignalStateWrapper->m_PowderPosition5Alarm = new SysParamBool(flag++, 1, cc); //粉仓料位感应器5异常 - m_SignalStateWrapper->m_SupplyHomeIndexDisableAlarm = new SysParamBool(flag++, 1, cc); //供粉转轴原点失效异常 - flag++; - m_SignalStateWrapper->m_PrintOxygen1DeciceAlarm = new SysParamBool(flag++, 1, cc); //打印舱测氧仪1异常 - m_SignalStateWrapper->m_PrintOxygen2DeviceAlarm = new SysParamBool(flag++, 1, cc); //打印舱测氧仪2异常 - m_SignalStateWrapper->m_OutsideOxygenDeviceAlarm = new SysParamBool(flag++, 1, cc); //室外测氧仪异常 - m_SignalStateWrapper->m_PrintPressureOverLimitAlarm = new SysParamBool(flag++, 1, cc); //打印舱压力过高异常 - m_SignalStateWrapper->m_ScannerChillerAlarm = new SysParamBool(flag++, 1, cc); //光路冷水机报警 - m_SignalStateWrapper->m_PurifierChillerAlarm = new SysParamBool(flag++, 1, cc); //净化器冷水机报警 - m_SignalStateWrapper->m_MoldTorqueAlarm = new SysParamBool(flag++, 1, cc); //打印主轴扭力异常 - flag++; - m_SignalStateWrapper->m_EleCylinderMainTorqueAlarm = new SysParamBool(flag++, 1, cc); //电缸主轴扭力异常 - m_SignalStateWrapper->m_EleCylinderSlaveTorqueAlarm = new SysParamBool(flag++, 1, cc); //电缸从轴扭力异常 - m_SignalStateWrapper->m_LoadTorqueAlarm = new SysParamBool(flag++, 1, cc); //移载轴扭力异常 - m_SignalStateWrapper->m_ArmTorqueAlarm = new SysParamBool(flag++, 1, cc); //铺粉轴扭力异常 - m_SignalStateWrapper->m_SupplyTorqueAlarm = new SysParamBool(flag++, 1, cc); //供粉轴扭力异常 - m_SignalStateWrapper->m_GratingRulerFail = new SysParamBool(flag++, 1, cc); //光栅尺补偿失败 + m_SignalStateWrapper->m_CleanTrackPosDisableAlarm = new SysParamBool(flag++, 1, cc, "轨道清粉位失效异常"); + m_SignalStateWrapper->m_CleanLiftStopAlarm = new SysParamBool(flag++, 1, cc, "清粉升降急停异常"); + m_SignalStateWrapper->m_LoadHandPosSensorDiable = new SysParamBool(flag++, 1, cc, "移载吊装位感应器失效"); - m_SignalStateWrapper->m_PrintMainOverSoftUpLimit = new SysParamBool(flag++, 1, cc); //打印主轴超软上限 - m_SignalStateWrapper->m_PrintMainOverSoftDownLimit = new SysParamBool(flag++, 1, cc); //打印主轴超软下限 - m_SignalStateWrapper->m_EleCylinderMainOverSoftUpLimit = new SysParamBool(flag++, 1, cc); //电缸主轴超软上限 - m_SignalStateWrapper->m_EleCylinderMainOverSoftDownLimit = new SysParamBool(flag++, 1, cc); //电缸主轴超软下限 - m_SignalStateWrapper->m_LoadAxisOverSoftLeftLimit = new SysParamBool(flag++, 1, cc); //移载轴超左软限 - m_SignalStateWrapper->m_LoadAxisOverSoftRightLimit = new SysParamBool(flag++, 1, cc); //移载轴超右软限 - m_SignalStateWrapper->m_ArmOverSoftFrontLimit = new SysParamBool(flag++, 1, cc); //铺粉轴超前软限 - m_SignalStateWrapper->m_ArmOverSoftBackLimit = new SysParamBool(flag++, 1, cc); //铺粉轴超后软限 - m_SignalStateWrapper->m_PrintStorageCar2JarFullWarn = new SysParamBool(flag++, 1, cc); //存粉小车2粉罐已满警示 - m_SignalStateWrapper->m_PrintStorageCar2DisconnectWarn = new SysParamBool(flag++, 1, cc); //存粉小车2没有连接警示 - m_SignalStateWrapper->m_PrintStorageCar2BlockAlarm = new SysParamBool(flag++, 1, cc); //打印存粉小车2堵塞报警 + m_SignalStateWrapper->m_MainPowerLossCheckAlarm = new SysParamBool(flag++, 1, cc, "主电源缺相检测异常"); + m_SignalStateWrapper->m_PrintCabinLockDisableAlarm = new SysParamBool(flag++, 1, cc, "打印舱电锁感应异常"); + m_SignalStateWrapper->m_CleanBoxUpOpenAlarm = new SysParamBool(flag++, 1, cc, "清粉箱上盖气缸打开不到位异常"); + m_SignalStateWrapper->m_CleanBoxUpCloseAlarm = new SysParamBool(flag++, 1, cc, "清粉箱上盖气缸关闭不到位异常"); + m_SignalStateWrapper->m_CylinderHandPlatformOpenAlarm = new SysParamBool(flag++, 1, cc, "缸体吊装盖板打开异常"); + m_SignalStateWrapper->m_CylinderHandDoorOpenAlarm = new SysParamBool(flag++, 1, cc, "缸体吊装门打开异常"); + flag++; + flag++; + m_SignalStateWrapper->m_HandPlatformCloseAlarm = new SysParamBool(flag++, 1, cc, "吊装盖板关闭异常"); + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + flag++; + m_SignalStateWrapper->m_ArmFrontLimit = new SysParamBool(flag++, 1, cc, "铺粉轴前限位触发警示"); + m_SignalStateWrapper->m_ArmBackLimit = new SysParamBool(flag++, 1, cc, "铺粉轴后限位触发警示"); + m_SignalStateWrapper->m_LoadAxisLeftLimit = new SysParamBool(flag++, 1, cc, "移载轴左限位触发警示"); + m_SignalStateWrapper->m_LoadAxisRightLimit = new SysParamBool(flag++, 1, cc, "移载轴右限位触发警示"); + flag++; + flag++; + flag++; + m_plcMp.insert(make_pair("PrintStorageCar1JarFullWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn))); + m_plcMp.insert(make_pair("PrintStorageCar1DisconnectWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn))); + m_plcMp.insert(make_pair("PrintStorageCar1BlockWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1BlockWarn))); + m_plcMp.insert(make_pair("MoldMainUpLimitActive", DValue(m_SignalStateWrapper->m_MoldMainUpLimitActive))); + m_plcMp.insert(make_pair("MoldMainDownLimitActive", DValue(m_SignalStateWrapper->m_MoldMainDownLimitActive))); + m_plcMp.insert(make_pair("PrintTrackDisableWarn", DValue(m_SignalStateWrapper->m_PrintTrackDisableWarn))); + m_plcMp.insert(make_pair("CylinderExtendOnAlarm", DValue(m_SignalStateWrapper->m_CylinderExtendOnAlarm))); + m_plcMp.insert(make_pair("CylinderExtendOffAlarm", DValue(m_SignalStateWrapper->m_CylinderExtendOffAlarm))); + m_plcMp.insert(make_pair("PrintCylinderVerifyAlarm", DValue(m_SignalStateWrapper->m_PrintCylinderVerifyAlarm))); + m_plcMp.insert(make_pair("CleanTrackPosDisableAlarm", DValue(m_SignalStateWrapper->m_CleanTrackPosDisableAlarm))); + m_plcMp.insert(make_pair("CleanLiftStopAlarm", DValue(m_SignalStateWrapper->m_CleanLiftStopAlarm))); + m_plcMp.insert(make_pair("LoadHandPosSensorDiable", DValue(m_SignalStateWrapper->m_LoadHandPosSensorDiable))); + m_plcMp.insert(make_pair("PrintStorageCar1JarFullWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1JarFullWarn))); + m_plcMp.insert(make_pair("PrintStorageCar1DisconnectWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1DisconnectWarn))); + m_plcMp.insert(make_pair("PrintStorageCar1BlockWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar1BlockWarn))); + m_plcMp.insert(make_pair("MoldMainUpLimitActive", DValue(m_SignalStateWrapper->m_MoldMainUpLimitActive))); + m_plcMp.insert(make_pair("MoldMainDownLimitActive", DValue(m_SignalStateWrapper->m_MoldMainDownLimitActive))); + m_plcMp.insert(make_pair("PrintTrackDisableWarn", DValue(m_SignalStateWrapper->m_PrintTrackDisableWarn))); + m_plcMp.insert(make_pair("CylinderExtendOnAlarm", DValue(m_SignalStateWrapper->m_CylinderExtendOnAlarm))); + m_plcMp.insert(make_pair("CylinderExtendOffAlarm", DValue(m_SignalStateWrapper->m_CylinderExtendOffAlarm))); + m_plcMp.insert(make_pair("PrintCylinderVerifyAlarm", DValue(m_SignalStateWrapper->m_PrintCylinderVerifyAlarm))); + m_plcMp.insert(make_pair("CleanTrackPosDisableAlarm", DValue(m_SignalStateWrapper->m_CleanTrackPosDisableAlarm))); + m_plcMp.insert(make_pair("CleanLiftStopAlarm", DValue(m_SignalStateWrapper->m_CleanLiftStopAlarm))); + m_plcMp.insert(make_pair("LoadHandPosSensorDiable", DValue(m_SignalStateWrapper->m_LoadHandPosSensorDiable))); + m_plcMp.insert(make_pair("MainPowerLossCheckAlarm", DValue(m_SignalStateWrapper->m_MainPowerLossCheckAlarm))); + m_plcMp.insert(make_pair("PrintCabinLockDisableAlarm", DValue(m_SignalStateWrapper->m_PrintCabinLockDisableAlarm))); + m_plcMp.insert(make_pair("CleanBoxUpOpenAlarm", DValue(m_SignalStateWrapper->m_CleanBoxUpOpenAlarm))); + m_plcMp.insert(make_pair("CleanBoxUpCloseAlarm", DValue(m_SignalStateWrapper->m_CleanBoxUpCloseAlarm))); + m_plcMp.insert(make_pair("CylinderHandPlatformOpenAlarm", DValue(m_SignalStateWrapper->m_CylinderHandPlatformOpenAlarm))); + m_plcMp.insert(make_pair("CylinderHandDoorOpenAlarm", DValue(m_SignalStateWrapper->m_CylinderHandDoorOpenAlarm))); + m_plcMp.insert(make_pair("HandPlatformCloseAlarm", DValue(m_SignalStateWrapper->m_HandPlatformCloseAlarm))); + m_plcMp.insert(make_pair("ArmFrontLimit", DValue(m_SignalStateWrapper->m_ArmFrontLimit))); + m_plcMp.insert(make_pair("ArmBackLimit", DValue(m_SignalStateWrapper->m_ArmBackLimit))); + m_plcMp.insert(make_pair("LoadAxisLeftLimit", DValue(m_SignalStateWrapper->m_LoadAxisLeftLimit))); + m_plcMp.insert(make_pair("LoadAxisRightLimit", DValue(m_SignalStateWrapper->m_LoadAxisRightLimit))); + + + + m_SignalStateWrapper->m_PowderPosition1Alarm = new SysParamBool(flag++, 1, cc, "粉仓料位感应器1异常"); + m_SignalStateWrapper->m_PowderPosition2Alarm = new SysParamBool(flag++, 1, cc, "粉仓料位感应器2异常"); + m_SignalStateWrapper->m_PowderPosition3Alarm = new SysParamBool(flag++, 1, cc, "粉仓料位感应器3异常"); + m_SignalStateWrapper->m_PowderPosition4Alarm = new SysParamBool(flag++, 1, cc, "粉仓料位感应器4异常"); + m_SignalStateWrapper->m_PowderPosition5Alarm = new SysParamBool(flag++, 1, cc, "粉仓料位感应器5异常"); + m_SignalStateWrapper->m_SupplyHomeIndexDisableAlarm = new SysParamBool(flag++, 1, cc, "供粉转轴原点失效异常"); + flag++; + m_SignalStateWrapper->m_PrintOxygen1DeciceAlarm = new SysParamBool(flag++, 1, cc, "打印舱测氧仪1异常"); + m_SignalStateWrapper->m_PrintOxygen2DeviceAlarm = new SysParamBool(flag++, 1, cc, "打印舱测氧仪2异常"); + m_SignalStateWrapper->m_OutsideOxygenDeviceAlarm = new SysParamBool(flag++, 1, cc, "室外测氧仪异常"); + m_SignalStateWrapper->m_PrintPressureOverLimitAlarm = new SysParamBool(flag++, 1, cc, "打印舱压力过高异常"); + m_SignalStateWrapper->m_ScannerChillerAlarm = new SysParamBool(flag++, 1, cc, "光路冷水机报警"); + m_SignalStateWrapper->m_PurifierChillerAlarm = new SysParamBool(flag++, 1, cc, "净化器冷水机报警"); + m_SignalStateWrapper->m_MoldTorqueAlarm = new SysParamBool(flag++, 1, cc, "打印主轴扭力异常"); + flag++; + m_SignalStateWrapper->m_EleCylinderMainTorqueAlarm = new SysParamBool(flag++, 1, cc, "电缸主轴扭力异常"); + m_SignalStateWrapper->m_EleCylinderSlaveTorqueAlarm = new SysParamBool(flag++, 1, cc, "电缸从轴扭力异常"); + m_SignalStateWrapper->m_LoadTorqueAlarm = new SysParamBool(flag++, 1, cc, "移载轴扭力异常"); + m_SignalStateWrapper->m_ArmTorqueAlarm = new SysParamBool(flag++, 1, cc, "铺粉轴扭力异常"); + m_SignalStateWrapper->m_SupplyTorqueAlarm = new SysParamBool(flag++, 1, cc, "供粉轴扭力异常"); + m_SignalStateWrapper->m_GratingRulerFail = new SysParamBool(flag++, 1, cc, "光栅尺补偿失败"); + m_SignalStateWrapper->m_PrintMainOverSoftUpLimit = new SysParamBool(flag++, 1, cc, "打印主轴超软上限"); + m_SignalStateWrapper->m_PrintMainOverSoftDownLimit = new SysParamBool(flag++, 1, cc, "打印主轴超软下限"); + m_SignalStateWrapper->m_EleCylinderMainOverSoftUpLimit = new SysParamBool(flag++, 1, cc, "电缸主轴超软上限"); + m_SignalStateWrapper->m_EleCylinderMainOverSoftDownLimit = new SysParamBool(flag++, 1, cc, "电缸主轴超软下限"); + m_SignalStateWrapper->m_LoadAxisOverSoftLeftLimit = new SysParamBool(flag++, 1, cc, "移载轴超左软限"); + m_SignalStateWrapper->m_LoadAxisOverSoftRightLimit = new SysParamBool(flag++, 1, cc, "移载轴超右软限"); + m_SignalStateWrapper->m_ArmOverSoftFrontLimit = new SysParamBool(flag++, 1, cc, "铺粉轴超前软限"); + m_SignalStateWrapper->m_ArmOverSoftBackLimit = new SysParamBool(flag++, 1, cc, "铺粉轴超后软限"); + m_SignalStateWrapper->m_PrintStorageCar2JarFullWarn = new SysParamBool(flag++, 1, cc, "存粉小车2粉罐已满警示"); + m_SignalStateWrapper->m_PrintStorageCar2DisconnectWarn = new SysParamBool(flag++, 1, cc, "存粉小车2没有连接警示"); + m_SignalStateWrapper->m_PrintStorageCar2BlockAlarm = new SysParamBool(flag++, 1, cc, "打印存粉小车2堵塞报警"); + m_plcMp.insert(make_pair("PowderPosition1Alarm", DValue(m_SignalStateWrapper->m_PowderPosition1Alarm))); + m_plcMp.insert(make_pair("PowderPosition2Alarm", DValue(m_SignalStateWrapper->m_PowderPosition2Alarm))); + m_plcMp.insert(make_pair("PowderPosition3Alarm", DValue(m_SignalStateWrapper->m_PowderPosition3Alarm))); + m_plcMp.insert(make_pair("PowderPosition4Alarm", DValue(m_SignalStateWrapper->m_PowderPosition4Alarm))); + m_plcMp.insert(make_pair("PowderPosition5Alarm", DValue(m_SignalStateWrapper->m_PowderPosition5Alarm))); + m_plcMp.insert(make_pair("SupplyHomeIndexDisableAlarm", DValue(m_SignalStateWrapper->m_SupplyHomeIndexDisableAlarm))); + m_plcMp.insert(make_pair("PrintOxygen1DeciceAlarm", DValue(m_SignalStateWrapper->m_PrintOxygen1DeciceAlarm))); + m_plcMp.insert(make_pair("PrintOxygen2DeviceAlarm", DValue(m_SignalStateWrapper->m_PrintOxygen2DeviceAlarm))); + m_plcMp.insert(make_pair("OutsideOxygenDeviceAlarm", DValue(m_SignalStateWrapper->m_OutsideOxygenDeviceAlarm))); + m_plcMp.insert(make_pair("PrintPressureOverLimitAlarm", DValue(m_SignalStateWrapper->m_PrintPressureOverLimitAlarm))); + m_plcMp.insert(make_pair("ScannerChillerAlarm", DValue(m_SignalStateWrapper->m_ScannerChillerAlarm))); + m_plcMp.insert(make_pair("PurifierChillerAlarm", DValue(m_SignalStateWrapper->m_PurifierChillerAlarm))); + m_plcMp.insert(make_pair("MoldTorqueAlarm", DValue(m_SignalStateWrapper->m_MoldTorqueAlarm))); + m_plcMp.insert(make_pair("EleCylinderMainTorqueAlarm", DValue(m_SignalStateWrapper->m_EleCylinderMainTorqueAlarm))); + m_plcMp.insert(make_pair("EleCylinderSlaveTorqueAlarm", DValue(m_SignalStateWrapper->m_EleCylinderSlaveTorqueAlarm))); + m_plcMp.insert(make_pair("LoadTorqueAlarm", DValue(m_SignalStateWrapper->m_LoadTorqueAlarm))); + m_plcMp.insert(make_pair("ArmTorqueAlarm", DValue(m_SignalStateWrapper->m_ArmTorqueAlarm))); + m_plcMp.insert(make_pair("SupplyTorqueAlarm", DValue(m_SignalStateWrapper->m_SupplyTorqueAlarm))); + m_plcMp.insert(make_pair("GratingRulerFail", DValue(m_SignalStateWrapper->m_GratingRulerFail))); + m_plcMp.insert(make_pair("PrintMainOverSoftUpLimit", DValue(m_SignalStateWrapper->m_PrintMainOverSoftUpLimit))); + m_plcMp.insert(make_pair("PrintMainOverSoftDownLimit", DValue(m_SignalStateWrapper->m_PrintMainOverSoftDownLimit))); + m_plcMp.insert(make_pair("EleCylinderMainOverSoftUpLimit", DValue(m_SignalStateWrapper->m_EleCylinderMainOverSoftUpLimit))); + m_plcMp.insert(make_pair("EleCylinderMainOverSoftDownLimit", DValue(m_SignalStateWrapper->m_EleCylinderMainOverSoftDownLimit))); + m_plcMp.insert(make_pair("LoadAxisOverSoftLeftLimit", DValue(m_SignalStateWrapper->m_LoadAxisOverSoftLeftLimit))); + m_plcMp.insert(make_pair("LoadAxisOverSoftRightLimit", DValue(m_SignalStateWrapper->m_LoadAxisOverSoftRightLimit))); + m_plcMp.insert(make_pair("ArmOverSoftFrontLimit", DValue(m_SignalStateWrapper->m_ArmOverSoftFrontLimit))); + m_plcMp.insert(make_pair("ArmOverSoftBackLimit", DValue(m_SignalStateWrapper->m_ArmOverSoftBackLimit))); + m_plcMp.insert(make_pair("PrintStorageCar2JarFullWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar2JarFullWarn))); + m_plcMp.insert(make_pair("PrintStorageCar2DisconnectWarn", DValue(m_SignalStateWrapper->m_PrintStorageCar2DisconnectWarn))); + m_plcMp.insert(make_pair("PrintStorageCar2BlockAlarm", DValue(m_SignalStateWrapper->m_PrintStorageCar2BlockAlarm))); flag = 70 * 8 + 1; - m_SignalStateWrapper->m_LoadAxisManualAlarmSignal= new SysParamBool(flag++, 1, cc); //移栽手动异常 - m_SignalStateWrapper->m_PrintMainServoAlarmSignal = new SysParamBool(flag++, 1, cc); //打印主轴伺服驱动器异常 - m_SignalStateWrapper->m_LoadAxisServoAlarmSignal = new SysParamBool(flag++, 1, cc); //移载轴伺服驱动器异常 - m_SignalStateWrapper->m_ArmServoAlarmSignal = new SysParamBool(flag++, 1, cc); //铺粉轴伺服驱动器异常 - m_SignalStateWrapper->m_SupplyServoAlarmSignal = new SysParamBool(flag++, 1, cc); //供粉转轴伺服驱动器异常 - m_SignalStateWrapper->m_EleCylinderMainServoAlarmSignal = new SysParamBool(flag++, 1, cc); //电缸主轴伺服异常 - m_SignalStateWrapper->m_EleCylinderPrintHandupAlarmSignal = new SysParamBool(flag++, 1, cc);//电缸打印位顶升异常 - m_SignalStateWrapper->m_CleanBoxTopDoorRiseAlarmSignal = new SysParamBool(flag++, 1, cc); //清粉箱顶门升高异常 - m_SignalStateWrapper->m_CleanBoxTopDoorFallAlarmSignal = new SysParamBool(flag++, 1, cc); //清粉箱顶门降低异常 - m_SignalStateWrapper->m_CoverReachAcceptPowderAlarmSignal = new SysParamBool(flag++, 1, cc); //铺粉轴到接粉位异常 - m_SignalStateWrapper->m_CoverReachDropPowderAlarmSignal = new SysParamBool(flag++, 1, cc); //铺粉轴到下粉位异常 - m_SignalStateWrapper->m_EleCylinderSlaveServoAlarmSignal = new SysParamBool(flag++, 1, cc); //电缸从轴伺服异常 - m_SignalStateWrapper->m_LinearEncoderCheckAlarmSignal = new SysParamBool(flag++, 1, cc); //光栅尺检测异常 - m_SignalStateWrapper->m_PrintMainSoftStopTrigger = new SysParamBool(flag++, 1, cc); //打印主轴软急停触发 - m_SignalStateWrapper->m_EleCylinderSoftStopTrigger = new SysParamBool(flag++, 1, cc); //电缸主轴软急停触发 - m_SignalStateWrapper->m_LoadAxisSoftStopTrigger = new SysParamBool(flag++, 1, cc); //移载轴软急停触发 - m_SignalStateWrapper->m_CoverSoftStopTrigger = new SysParamBool(flag++, 1, cc); //铺粉轴软急停触发 - m_SignalStateWrapper->m_CoverHomeException = new SysParamBool(flag++, 1, cc); //铺粉归原点异常 + m_SignalStateWrapper->m_LoadAxisManualAlarmSignal = new SysParamBool(flag++, 1, cc, "移栽手动异常"); + m_SignalStateWrapper->m_PrintMainServoAlarmSignal = new SysParamBool(flag++, 1, cc, "打印主轴伺服驱动器异常"); + m_SignalStateWrapper->m_LoadAxisServoAlarmSignal = new SysParamBool(flag++, 1, cc, "移载轴伺服驱动器异常"); + m_SignalStateWrapper->m_ArmServoAlarmSignal = new SysParamBool(flag++, 1, cc, "铺粉轴伺服驱动器异常"); + m_SignalStateWrapper->m_SupplyServoAlarmSignal = new SysParamBool(flag++, 1, cc, "供粉转轴伺服驱动器异常"); + m_SignalStateWrapper->m_EleCylinderMainServoAlarmSignal = new SysParamBool(flag++, 1, cc, "电缸主轴伺服异常"); + m_SignalStateWrapper->m_EleCylinderPrintHandupAlarmSignal = new SysParamBool(flag++, 1, cc, "电缸打印位顶升异常"); + m_SignalStateWrapper->m_CleanBoxTopDoorRiseAlarmSignal = new SysParamBool(flag++, 1, cc, "清粉箱顶门升高异常"); + m_SignalStateWrapper->m_CleanBoxTopDoorFallAlarmSignal = new SysParamBool(flag++, 1, cc, "清粉箱顶门降低异常"); + m_SignalStateWrapper->m_CoverReachAcceptPowderAlarmSignal = new SysParamBool(flag++, 1, cc, "铺粉轴到接粉位异常"); + m_SignalStateWrapper->m_CoverReachDropPowderAlarmSignal = new SysParamBool(flag++, 1, cc, "铺粉轴到下粉位异常"); + m_SignalStateWrapper->m_EleCylinderSlaveServoAlarmSignal = new SysParamBool(flag++, 1, cc, "电缸从轴伺服异常"); + m_SignalStateWrapper->m_LinearEncoderCheckAlarmSignal = new SysParamBool(flag++, 1, cc, "光栅尺检测异常"); + m_SignalStateWrapper->m_PrintMainSoftStopTrigger = new SysParamBool(flag++, 1, cc, "打印主轴软急停触发"); + m_SignalStateWrapper->m_EleCylinderSoftStopTrigger = new SysParamBool(flag++, 1, cc, "电缸主轴软急停触发"); + m_SignalStateWrapper->m_LoadAxisSoftStopTrigger = new SysParamBool(flag++, 1, cc, "移载轴软急停触发"); + m_SignalStateWrapper->m_CoverSoftStopTrigger = new SysParamBool(flag++, 1, cc, "铺粉轴软急停触发"); + m_SignalStateWrapper->m_CoverHomeException = new SysParamBool(flag++, 1, cc, "铺粉归原点异常"); + m_plcMp.insert(make_pair("LoadAxisManualAlarmSignal", DValue(m_SignalStateWrapper->m_LoadAxisManualAlarmSignal))); + m_plcMp.insert(make_pair("PrintMainServoAlarmSignal", DValue(m_SignalStateWrapper->m_PrintMainServoAlarmSignal))); + m_plcMp.insert(make_pair("LoadAxisServoAlarmSignal", DValue(m_SignalStateWrapper->m_LoadAxisServoAlarmSignal))); + m_plcMp.insert(make_pair("ArmServoAlarmSignal", DValue(m_SignalStateWrapper->m_ArmServoAlarmSignal))); + m_plcMp.insert(make_pair("SupplyServoAlarmSignal", DValue(m_SignalStateWrapper->m_SupplyServoAlarmSignal))); + m_plcMp.insert(make_pair("EleCylinderMainServoAlarmSignal", DValue(m_SignalStateWrapper->m_EleCylinderMainServoAlarmSignal))); + m_plcMp.insert(make_pair("EleCylinderPrintHandupAlarmSignal", DValue(m_SignalStateWrapper->m_EleCylinderPrintHandupAlarmSignal))); + m_plcMp.insert(make_pair("CleanBoxTopDoorRiseAlarmSignal", DValue(m_SignalStateWrapper->m_CleanBoxTopDoorRiseAlarmSignal))); + m_plcMp.insert(make_pair("CleanBoxTopDoorFallAlarmSignal", DValue(m_SignalStateWrapper->m_CleanBoxTopDoorFallAlarmSignal))); + m_plcMp.insert(make_pair("CoverReachAcceptPowderAlarmSignal", DValue(m_SignalStateWrapper->m_CoverReachAcceptPowderAlarmSignal))); + m_plcMp.insert(make_pair("CoverReachDropPowderAlarmSignal", DValue(m_SignalStateWrapper->m_CoverReachDropPowderAlarmSignal))); + m_plcMp.insert(make_pair("EleCylinderSlaveServoAlarmSignal", DValue(m_SignalStateWrapper->m_EleCylinderSlaveServoAlarmSignal))); + m_plcMp.insert(make_pair("LinearEncoderCheckAlarmSignal", DValue(m_SignalStateWrapper->m_LinearEncoderCheckAlarmSignal))); + m_plcMp.insert(make_pair("PrintMainSoftStopTrigger", DValue(m_SignalStateWrapper->m_PrintMainSoftStopTrigger))); + m_plcMp.insert(make_pair("EleCylinderSoftStopTrigger", DValue(m_SignalStateWrapper->m_EleCylinderSoftStopTrigger))); + m_plcMp.insert(make_pair("LoadAxisSoftStopTrigger", DValue(m_SignalStateWrapper->m_LoadAxisSoftStopTrigger))); + m_plcMp.insert(make_pair("CoverSoftStopTrigger", DValue(m_SignalStateWrapper->m_CoverSoftStopTrigger))); + m_plcMp.insert(make_pair("CoverHomeException", DValue(m_SignalStateWrapper->m_CoverHomeException))); + flag = 78; - m_SignalStateWrapper->m_CylinderState = new SysParamInt(flag, 1, cc); //缸体状态_R + m_SignalStateWrapper->m_CylinderState = new SysParamInt(flag, 1, cc, "缸体状态_R"); flag = 80 * 8; - m_SignalStateWrapper->m_CylinderReachPrintTriger = new SysParamBool(flag++, 1, cc); //触发缸体到达打印位_自动_RW - m_SignalStateWrapper->m_CylinderReachPrintRun = new SysParamBool(flag++, 1, cc); //缸体到打印位运行中_自动_RW - m_SignalStateWrapper->m_CylinderReachPrintFinished = new SysParamBool(flag++, 1, cc); //缸体到达打印位完毕_自动_RW - m_SignalStateWrapper->m_CylinderPrintLoadTriger = new SysParamBool(flag++, 1, cc); //触发缸体打印位装载_自动_RW - m_SignalStateWrapper->m_CylinderPrintLoadRun = new SysParamBool(flag++, 1, cc); //缸体打印位装载运行中_自动_RW - m_SignalStateWrapper->m_CylinderPrintLoadFinished = new SysParamBool(flag++, 1, cc); //缸体打印位装载完毕_自动_RW - m_SignalStateWrapper->m_CylinderPrintUnloadTriger = new SysParamBool(flag++, 1, cc); //触发缸体打印位卸载_自动_RW - m_SignalStateWrapper->m_CylinderPrintUnloadRun = new SysParamBool(flag++, 1, cc); //缸体打印位卸载运行中_自动_RW - m_SignalStateWrapper->m_CylinderPrintUnloadFinished = new SysParamBool(flag++, 1, cc); //缸体打印位卸载完毕_自动_RW - + m_SignalStateWrapper->m_CylinderReachPrintTriger = new SysParamBool(flag++, 1, cc, "触发缸体到达打印位_自动_RW"); + m_SignalStateWrapper->m_CylinderReachPrintRun = new SysParamBool(flag++, 1, cc, "缸体到打印位运行中_自动_RW"); + m_SignalStateWrapper->m_CylinderReachPrintFinished = new SysParamBool(flag++, 1, cc, "缸体到达打印位完毕_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintLoadTriger = new SysParamBool(flag++, 1, cc, "触发缸体打印位装载_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintLoadRun = new SysParamBool(flag++, 1, cc, "缸体打印位装载运行中_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintLoadFinished = new SysParamBool(flag++, 1, cc, "缸体打印位装载完毕_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintUnloadTriger = new SysParamBool(flag++, 1, cc, "触发缸体打印位卸载_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintUnloadRun = new SysParamBool(flag++, 1, cc, "缸体打印位卸载运行中_自动_RW"); + m_SignalStateWrapper->m_CylinderPrintUnloadFinished = new SysParamBool(flag++, 1, cc, "缸体打印位卸载完毕_自动_RW"); + m_plcMp.insert(make_pair("CylinderState", DValue(m_SignalStateWrapper->m_CylinderState))); + m_plcMp.insert(make_pair("CylinderReachPrintTriger", DValue(m_SignalStateWrapper->m_CylinderReachPrintTriger))); + m_plcMp.insert(make_pair("CylinderReachPrintRun", DValue(m_SignalStateWrapper->m_CylinderReachPrintRun))); + m_plcMp.insert(make_pair("CylinderReachPrintFinished", DValue(m_SignalStateWrapper->m_CylinderReachPrintFinished))); + m_plcMp.insert(make_pair("CylinderPrintLoadTriger", DValue(m_SignalStateWrapper->m_CylinderPrintLoadTriger))); + m_plcMp.insert(make_pair("CylinderPrintLoadRun", DValue(m_SignalStateWrapper->m_CylinderPrintLoadRun))); + m_plcMp.insert(make_pair("CylinderPrintLoadFinished", DValue(m_SignalStateWrapper->m_CylinderPrintLoadFinished))); + m_plcMp.insert(make_pair("CylinderPrintUnloadTriger", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadTriger))); + m_plcMp.insert(make_pair("CylinderPrintUnloadRun", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadRun))); + m_plcMp.insert(make_pair("CylinderPrintUnloadFinished", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadFinished))); flag = 81 * 8+7; - m_SignalStateWrapper->m_CylinderReachCleanTriger = new SysParamBool(flag++, 1, cc); //触发缸体到达清粉位_自动_RW - m_SignalStateWrapper->m_CylinderReachCleanRun = new SysParamBool(flag++, 1, cc); //缸体到清粉位运行中_RW - m_SignalStateWrapper->m_CylinderReachCleanFinished = new SysParamBool(flag++, 1, cc); //缸体到清粉位完毕_自动_RW - m_SignalStateWrapper->m_CylinderConnectCleanBoxTriger = new SysParamBool(flag++, 1, cc); //触发缸体与清粉箱连接_自动_RW - m_SignalStateWrapper->m_CylinderConnectCleanBoxRun = new SysParamBool(flag++, 1, cc); //缸体与清粉箱连接中_RW - m_SignalStateWrapper->m_CylinderConnectCleanBoxFinished = new SysParamBool(flag++, 1, cc); //缸体与清粉箱连接完毕_自动_RW - m_SignalStateWrapper->m_CylinderDisconnectCleanBoxTriger = new SysParamBool(flag++, 1, cc); //触发缸体与清粉箱分离_自动_RW - m_SignalStateWrapper->m_CylinderDisconnectCleanBoxRun = new SysParamBool(flag++, 1, cc); //缸体与清粉箱分离中_RW - m_SignalStateWrapper->m_CylinderDisconnectCleanBoxFinished = new SysParamBool(flag++, 1, cc); //缸体与清粉箱分离完毕_自动_RW - m_SignalStateWrapper->m_CoverTriger = new SysParamBool(flag++, 1, cc); //触发铺粉流程_W - m_SignalStateWrapper->m_IsCovering = new SysParamBool(flag++, 1, cc); //铺粉流程忙_R - m_SignalStateWrapper->m_IsCoverFinishedCanPrint = new SysParamBool(flag++, 1, cc); //铺粉完成允许打印_RW - m_SignalStateWrapper->m_IsCoverDebug = new SysParamBool(flag++, 1, cc); //铺粉调试模式_W - m_SignalStateWrapper->m_IsFirstCover = new SysParamBool(flag++, 1, cc); //第一次铺粉_W - m_SignalStateWrapper->m_PrintDeoxygenTriger = new SysParamBool(flag++, 1, cc); //触发打印室除氧_W - m_SignalStateWrapper->m_PrintDeoxygenRun = new SysParamBool(flag++, 1, cc); //打印室除氧中_RW - m_SignalStateWrapper->m_PrintDeoxygenFinished = new SysParamBool(flag++, 1, cc); //打印室氧含量值到达_R + m_SignalStateWrapper->m_CylinderReachCleanTriger = new SysParamBool(flag++, 1, cc, "触发缸体到达清粉位_自动_RW"); + m_SignalStateWrapper->m_CylinderReachCleanRun = new SysParamBool(flag++, 1, cc, "缸体到清粉位运行中_RW"); + m_SignalStateWrapper->m_CylinderReachCleanFinished = new SysParamBool(flag++, 1, cc, "缸体到清粉位完毕_自动_RW"); + m_SignalStateWrapper->m_CylinderConnectCleanBoxTriger = new SysParamBool(flag++, 1, cc, "触发缸体与清粉箱连接_自动_RW"); + m_SignalStateWrapper->m_CylinderConnectCleanBoxRun = new SysParamBool(flag++, 1, cc, "缸体与清粉箱连接中_RW"); + m_SignalStateWrapper->m_CylinderConnectCleanBoxFinished = new SysParamBool(flag++, 1, cc, "缸体与清粉箱连接完毕_自动_RW"); + m_SignalStateWrapper->m_CylinderDisconnectCleanBoxTriger = new SysParamBool(flag++, 1, cc, "触发缸体与清粉箱分离_自动_RW"); + m_SignalStateWrapper->m_CylinderDisconnectCleanBoxRun = new SysParamBool(flag++, 1, cc, "缸体与清粉箱分离中_RW"); + m_SignalStateWrapper->m_CylinderDisconnectCleanBoxFinished = new SysParamBool(flag++, 1, cc, "缸体与清粉箱分离完毕_自动_RW"); + m_SignalStateWrapper->m_CoverTriger = new SysParamBool(flag++, 1, cc, "触发铺粉流程_W"); + m_SignalStateWrapper->m_IsCovering = new SysParamBool(flag++, 1, cc, "铺粉流程忙_R"); + m_SignalStateWrapper->m_IsCoverFinishedCanPrint = new SysParamBool(flag++, 1, cc, "铺粉完成允许打印_RW"); + m_SignalStateWrapper->m_IsCoverDebug = new SysParamBool(flag++, 1, cc, "铺粉调试模式_W"); + m_SignalStateWrapper->m_IsFirstCover = new SysParamBool(flag++, 1, cc, "第一次铺粉_W"); + m_SignalStateWrapper->m_PrintDeoxygenTriger = new SysParamBool(flag++, 1, cc, "触发打印室除氧_W"); + m_SignalStateWrapper->m_PrintDeoxygenRun = new SysParamBool(flag++, 1, cc, "打印室除氧中_RW"); + m_SignalStateWrapper->m_PrintDeoxygenFinished = new SysParamBool(flag++, 1, cc, "打印室氧含量值到达_R"); + + m_plcMp.insert(make_pair("CylinderReachCleanTriger", DValue(m_SignalStateWrapper->m_CylinderReachCleanTriger))); + m_plcMp.insert(make_pair("CylinderReachCleanRun", DValue(m_SignalStateWrapper->m_CylinderReachCleanRun))); + m_plcMp.insert(make_pair("CylinderReachCleanFinished", DValue(m_SignalStateWrapper->m_CylinderReachCleanFinished))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxTriger", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxTriger))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxRun", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxRun))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxFinished", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxFinished))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxTriger", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxTriger))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxRun", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxRun))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxFinished", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxFinished))); + m_plcMp.insert(make_pair("CoverTriger", DValue(m_SignalStateWrapper->m_CoverTriger))); + m_plcMp.insert(make_pair("IsCovering", DValue(m_SignalStateWrapper->m_IsCovering))); + m_plcMp.insert(make_pair("IsCoverFinishedCanPrint", DValue(m_SignalStateWrapper->m_IsCoverFinishedCanPrint))); + m_plcMp.insert(make_pair("IsCoverDebug", DValue(m_SignalStateWrapper->m_IsCoverDebug))); + m_plcMp.insert(make_pair("IsFirstCover", DValue(m_SignalStateWrapper->m_IsFirstCover))); + m_plcMp.insert(make_pair("PrintDeoxygenTriger", DValue(m_SignalStateWrapper->m_PrintDeoxygenTriger))); + m_plcMp.insert(make_pair("PrintDeoxygenRun", DValue(m_SignalStateWrapper->m_PrintDeoxygenRun))); + m_plcMp.insert(make_pair("PrintDeoxygenFinished", DValue(m_SignalStateWrapper->m_PrintDeoxygenFinished))); flag++; flag++; flag++; - m_SignalStateWrapper->m_StorgeCarDeoxygenTriger = new SysParamBool(flag++, 1, cc); //触发存粉小车除氧_W - m_SignalStateWrapper->m_StorgeCarDeoxygenRun = new SysParamBool(flag++, 1, cc); //存粉小车除氧中_R - m_SignalStateWrapper->m_StorgeCarDeoxygenFinished = new SysParamBool(flag++, 1, cc); //存粉小车除氧完毕_RW - m_SignalStateWrapper->m_CleanBoxVacuumTriger = new SysParamBool(flag++, 1, cc); //清粉箱启动吸尘器_R - m_SignalStateWrapper->m_PrintVacuumTriger = new SysParamBool(flag++, 1, cc); //打印室启动吸尘器_W + m_SignalStateWrapper->m_StorgeCarDeoxygenTriger = new SysParamBool(flag++, 1, cc, "触发存粉小车除氧_W"); + m_SignalStateWrapper->m_StorgeCarDeoxygenRun = new SysParamBool(flag++, 1, cc, "存粉小车除氧中_R"); + m_SignalStateWrapper->m_StorgeCarDeoxygenFinished = new SysParamBool(flag++, 1, cc, "存粉小车除氧完毕_RW"); + m_SignalStateWrapper->m_CleanBoxVacuumTriger = new SysParamBool(flag++, 1, cc, "清粉箱启动吸尘器_R"); + m_SignalStateWrapper->m_PrintVacuumTriger = new SysParamBool(flag++, 1, cc, "打印室启动吸尘器_W"); + m_plcMp.insert(make_pair("StorgeCarDeoxygenTriger", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenTriger))); + m_plcMp.insert(make_pair("StorgeCarDeoxygenRun", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenRun))); + m_plcMp.insert(make_pair("StorgeCarDeoxygenFinished", DValue(m_SignalStateWrapper->m_StorgeCarDeoxygenFinished))); + m_plcMp.insert(make_pair("CleanBoxVacuumTriger", DValue(m_SignalStateWrapper->m_CleanBoxVacuumTriger))); + m_plcMp.insert(make_pair("PrintVacuumTriger", DValue(m_SignalStateWrapper->m_PrintVacuumTriger))); flag++; flag++; - m_SignalStateWrapper->m_DisableRasterJudge = new SysParamBool(flag++, 1, cc); //屏蔽光栅尺判断_W - m_SignalStateWrapper->m_RasterJudgeOK = new SysParamBool(flag++, 1, cc); //光栅尺判断OK_R - m_SignalStateWrapper->m_RasterJudgeNG = new SysParamBool(flag++, 1, cc); //光栅尺判断NG_R + m_SignalStateWrapper->m_DisableRasterJudge = new SysParamBool(flag++, 1, cc, "屏蔽光栅尺判断_W"); + m_SignalStateWrapper->m_RasterJudgeOK = new SysParamBool(flag++, 1, cc, "光栅尺判断OK_R"); + m_SignalStateWrapper->m_RasterJudgeNG = new SysParamBool(flag++, 1, cc, "光栅尺判断NG_R"); - m_SignalStateWrapper->m_CylinderReachPrintEnable = new SysParamBool(flag++, 1, cc); //触发缸体到打印位EN_R - m_SignalStateWrapper->m_CylinderPrintLoadEnable = new SysParamBool(flag++, 1, cc); //触发缸体打印位装载EN_R - m_SignalStateWrapper->m_CylinderPrintUnloadEnable = new SysParamBool(flag++, 1, cc); //触发缸体打印位卸载EN_R + m_SignalStateWrapper->m_CylinderReachPrintEnable = new SysParamBool(flag++, 1, cc, "触发缸体到打印位EN_R"); + m_SignalStateWrapper->m_CylinderPrintLoadEnable = new SysParamBool(flag++, 1, cc, "触发缸体打印位装载EN_R"); + m_SignalStateWrapper->m_CylinderPrintUnloadEnable = new SysParamBool(flag++, 1, cc, "触发缸体打印位卸载EN_R"); + m_plcMp.insert(make_pair("DisableRasterJudge", DValue(m_SignalStateWrapper->m_DisableRasterJudge))); + m_plcMp.insert(make_pair("RasterJudgeOK", DValue(m_SignalStateWrapper->m_RasterJudgeOK))); + m_plcMp.insert(make_pair("RasterJudgeNG", DValue(m_SignalStateWrapper->m_RasterJudgeNG))); + m_plcMp.insert(make_pair("CylinderReachPrintEnable", DValue(m_SignalStateWrapper->m_CylinderReachPrintEnable))); + m_plcMp.insert(make_pair("CylinderPrintLoadEnable", DValue(m_SignalStateWrapper->m_CylinderPrintLoadEnable))); + m_plcMp.insert(make_pair("CylinderPrintUnloadEnable", DValue(m_SignalStateWrapper->m_CylinderPrintUnloadEnable))); + flag++; flag++; - m_SignalStateWrapper->m_CylinderReachCleanEnable = new SysParamBool(flag++, 1, cc); //触发缸体到清粉位EN_R - m_SignalStateWrapper->m_CylinderConnectCleanBoxEnable = new SysParamBool(flag++, 1, cc); //触发缸体与清粉箱连接EN_R - m_SignalStateWrapper->m_CylinderDisconnectCleanBoxEnable = new SysParamBool(flag++, 1, cc); //触发缸体与清粉箱分离EN_R - m_SignalStateWrapper->m_CoverEnable = new SysParamBool(flag++, 1, cc); //触发铺粉EN_R - + m_SignalStateWrapper->m_CylinderReachCleanEnable = new SysParamBool(flag++, 1, cc, "触发缸体到清粉位EN_R"); + m_SignalStateWrapper->m_CylinderConnectCleanBoxEnable = new SysParamBool(flag++, 1, cc, "触发缸体与清粉箱连接EN_R"); + m_SignalStateWrapper->m_CylinderDisconnectCleanBoxEnable = new SysParamBool(flag++, 1, cc, "触发缸体与清粉箱分离EN_R"); + m_SignalStateWrapper->m_CoverEnable = new SysParamBool(flag++, 1, cc, "触发铺粉EN_R"); flag = 96 * 8; - m_SignalStateWrapper->m_PrintStoreCar1ExhaustEnable = new SysParamBool(flag++, 1, cc); //触发打印存粉小车1排粉 - m_SignalStateWrapper->m_PrintStoreCar2ExhaustEnable = new SysParamBool(flag++, 1, cc); //触发打印存粉小车2排粉 - m_SignalStateWrapper->m_CylinderMoveHandPosEnable = new SysParamBool(flag++, 1, cc); //触发缸体到吊装位En - m_SignalStateWrapper->m_CylinderMoveHandPos = new SysParamBool(flag++, 1, cc); //触发缸体到吊装位 - m_SignalStateWrapper->m_CylinderMovingHandPos = new SysParamBool(flag++, 1, cc); //触发缸体到吊装位运行中 - m_SignalStateWrapper->m_CylinderMovedHandPos = new SysParamBool(flag++, 1, cc); //触发缸体到吊装位完毕 - m_SignalStateWrapper->m_PrintAirRenewalEnable = new SysParamBool(flag++, 1, cc); //打印室换气功能EN - m_SignalStateWrapper->m_PrintAirRenewalTrigger = new SysParamBool(flag++, 1, cc); //触发打印室换气 - m_SignalStateWrapper->m_AllowRiseWindSpeed = new SysParamBool(flag++, 1, cc); //允许提风速 - m_SignalStateWrapper->m_ManualCoverTest = new SysParamBool(flag++, 1, cc); //手动铺粉测试 - m_SignalStateWrapper->m_RollerEdgeSearching = new SysParamBool(flag++, 1, cc); //滚粉轴寻边中 - m_SignalStateWrapper->m_RollerEdgeSearchSuccess = new SysParamBool(flag++, 1, cc); //滚粉轴寻边成功 - m_SignalStateWrapper->m_RollerEdgeSearchFaild = new SysParamBool(flag++, 1, cc); //滚粉轴寻边失败 + m_SignalStateWrapper->m_PrintStoreCar1ExhaustEnable = new SysParamBool(flag++, 1, cc, "触发打印存粉小车1排粉"); + m_SignalStateWrapper->m_PrintStoreCar2ExhaustEnable = new SysParamBool(flag++, 1, cc, "触发打印存粉小车2排粉"); + m_SignalStateWrapper->m_CylinderMoveHandPosEnable = new SysParamBool(flag++, 1, cc, "触发缸体到吊装位En"); + m_SignalStateWrapper->m_CylinderMoveHandPos = new SysParamBool(flag++, 1, cc, "触发缸体到吊装位"); + m_SignalStateWrapper->m_CylinderMovingHandPos = new SysParamBool(flag++, 1, cc, "触发缸体到吊装位运行中"); + m_SignalStateWrapper->m_CylinderMovedHandPos = new SysParamBool(flag++, 1, cc, "触发缸体到吊装位完毕"); + m_SignalStateWrapper->m_PrintAirRenewalEnable = new SysParamBool(flag++, 1, cc, "打印室换气功能EN"); + m_SignalStateWrapper->m_PrintAirRenewalTrigger = new SysParamBool(flag++, 1, cc, "触发打印室换气"); + m_SignalStateWrapper->m_AllowRiseWindSpeed = new SysParamBool(flag++, 1, cc, "允许提风速"); + m_SignalStateWrapper->m_ManualCoverTest = new SysParamBool(flag++, 1, cc, "手动铺粉测试"); + m_SignalStateWrapper->m_RollerEdgeSearching = new SysParamBool(flag++, 1, cc, "滚粉轴寻边中"); + m_SignalStateWrapper->m_RollerEdgeSearchSuccess = new SysParamBool(flag++, 1, cc, "滚粉轴寻边成功"); + m_SignalStateWrapper->m_RollerEdgeSearchFaild = new SysParamBool(flag++, 1, cc, "滚粉轴寻边失败"); + m_plcMp.insert(make_pair("CylinderReachCleanEnable", DValue(m_SignalStateWrapper->m_CylinderReachCleanEnable))); + m_plcMp.insert(make_pair("CylinderConnectCleanBoxEnable", DValue(m_SignalStateWrapper->m_CylinderConnectCleanBoxEnable))); + m_plcMp.insert(make_pair("CylinderDisconnectCleanBoxEnable", DValue(m_SignalStateWrapper->m_CylinderDisconnectCleanBoxEnable))); + m_plcMp.insert(make_pair("CoverEnable", DValue(m_SignalStateWrapper->m_CoverEnable))); + m_plcMp.insert(make_pair("PrintStoreCar1ExhaustEnable", DValue(m_SignalStateWrapper->m_PrintStoreCar1ExhaustEnable))); + m_plcMp.insert(make_pair("PrintStoreCar2ExhaustEnable", DValue(m_SignalStateWrapper->m_PrintStoreCar2ExhaustEnable))); + m_plcMp.insert(make_pair("CylinderMoveHandPosEnable", DValue(m_SignalStateWrapper->m_CylinderMoveHandPosEnable))); + m_plcMp.insert(make_pair("CylinderMoveHandPos", DValue(m_SignalStateWrapper->m_CylinderMoveHandPos))); + m_plcMp.insert(make_pair("CylinderMovingHandPos", DValue(m_SignalStateWrapper->m_CylinderMovingHandPos))); + m_plcMp.insert(make_pair("CylinderMovedHandPos", DValue(m_SignalStateWrapper->m_CylinderMovedHandPos))); + m_plcMp.insert(make_pair("PrintAirRenewalEnable", DValue(m_SignalStateWrapper->m_PrintAirRenewalEnable))); + m_plcMp.insert(make_pair("PrintAirRenewalTrigger", DValue(m_SignalStateWrapper->m_PrintAirRenewalTrigger))); + m_plcMp.insert(make_pair("AllowRiseWindSpeed", DValue(m_SignalStateWrapper->m_AllowRiseWindSpeed))); + m_plcMp.insert(make_pair("ManualCoverTest", DValue(m_SignalStateWrapper->m_ManualCoverTest))); + m_plcMp.insert(make_pair("RollerEdgeSearching", DValue(m_SignalStateWrapper->m_RollerEdgeSearching))); + m_plcMp.insert(make_pair("RollerEdgeSearchSuccess", DValue(m_SignalStateWrapper->m_RollerEdgeSearchSuccess))); + m_plcMp.insert(make_pair("RollerEdgeSearchFaild", DValue(m_SignalStateWrapper->m_RollerEdgeSearchFaild))); flag = 1; - m_SignalStateWrapper->m_UseSupplySearchEdge = new SysParamBool(flag++, 68, cc); //使用滚粉轴寻边 - m_SignalStateWrapper->m_SheildCylinderFixSensor = new SysParamBool(flag++, 68, cc); //屏蔽缸体固定定位感应器 + m_SignalStateWrapper->m_UseSupplySearchEdge = new SysParamBool(flag++, 68, cc,"使用滚粉轴寻边"); + m_SignalStateWrapper->m_SheildCylinderFixSensor = new SysParamBool(flag++, 68, cc, "屏蔽缸体固定定位感应器"); + m_plcMp.insert(make_pair("UseSupplySearchEdge", DValue(m_SignalStateWrapper->m_UseSupplySearchEdge))); + m_plcMp.insert(make_pair("SheildCylinderFixSensor", DValue(m_SignalStateWrapper->m_SheildCylinderFixSensor))); flag++; flag++; - m_SignalStateWrapper->m_SheildLinearEncoder = new SysParamBool(flag++, 68, cc); //屏蔽光栅尺 + m_SignalStateWrapper->m_SheildLinearEncoder = new SysParamBool(flag++, 68, cc,"屏蔽光栅尺"); + m_plcMp.insert(make_pair("SheildLinearEncoder", DValue(m_SignalStateWrapper->m_SheildLinearEncoder))); flag++; - m_SignalStateWrapper->m_UseWellAutoCount = new SysParamBool(flag++, 68, cc); //使用wellauto高速计数 - m_SignalStateWrapper->m_SheilServoEmptyOpen = new SysParamBool(flag++, 68, cc); //屏蔽伺服空开 + m_SignalStateWrapper->m_UseWellAutoCount = new SysParamBool(flag++, 68, cc,"使用wellauto高速计数"); + m_SignalStateWrapper->m_SheilServoEmptyOpen = new SysParamBool(flag++, 68, cc,"屏蔽伺服空开"); + m_plcMp.insert(make_pair("UseWellAutoCount", DValue(m_SignalStateWrapper->m_UseWellAutoCount))); + m_plcMp.insert(make_pair("SheilServoEmptyOpen", DValue(m_SignalStateWrapper->m_SheilServoEmptyOpen))); flag++; - m_SignalStateWrapper->m_SheildHighPressure = new SysParamBool(flag++, 68, cc); //屏蔽高压气 - m_SignalStateWrapper->m_UnuseCoverReachSensor = new SysParamBool(flag++, 68, cc); //不使用铺粉轴到位感应器 - flag++; - m_SignalStateWrapper->m_UseArmCaptureHome = new SysParamBool(flag++, 68, cc); flag++; //使用铺粉臂归原点 - flag++; - m_SignalStateWrapper->m_LinearEncoderOppDirection = new SysParamBool(flag++, 68, cc); //光栅尺反向 - m_SignalStateWrapper->m_CoverV2UseCintinueMode = new SysParamBool(flag++, 68, cc); //铺粉V2是否使用连续模式 + m_SignalStateWrapper->m_SheildHighPressure = new SysParamBool(flag++, 68, cc,"屏蔽高压气"); + m_SignalStateWrapper->m_UnuseCoverReachSensor = new SysParamBool(flag++, 68, cc,"不使用铺粉轴到位感应器"); + m_plcMp.insert(make_pair("SheildHighPressure", DValue(m_SignalStateWrapper->m_SheildHighPressure))); + m_plcMp.insert(make_pair("UnuseCoverReachSensor", DValue(m_SignalStateWrapper->m_UnuseCoverReachSensor))); + flag++; + m_SignalStateWrapper->m_UseArmCaptureHome = new SysParamBool(flag++, 68, cc,"使用铺粉臂归原点"); flag++; + m_plcMp.insert(make_pair("UseArmCaptureHome", DValue(m_SignalStateWrapper->m_UseArmCaptureHome))); + flag++; + m_SignalStateWrapper->m_LinearEncoderOppDirection = new SysParamBool(flag++, 68, cc,"光栅尺反向"); + m_SignalStateWrapper->m_CoverV2UseCintinueMode = new SysParamBool(flag++, 68, cc,"铺粉V2是否使用连续模式"); + m_plcMp.insert(make_pair("LinearEncoderOppDirection", DValue(m_SignalStateWrapper->m_LinearEncoderOppDirection))); + m_plcMp.insert(make_pair("CoverV2UseCintinueMode", DValue(m_SignalStateWrapper->m_CoverV2UseCintinueMode))); flag = 249 * 8 + 4; - m_SignalStateWrapper->m_IsInPrintCylinderSeparatePos = new SysParamBool(flag++, 4, cc); //打印缸体分离位 + m_SignalStateWrapper->m_IsInPrintCylinderSeparatePos = new SysParamBool(flag++, 4, cc,"打印缸体分离位"); + m_plcMp.insert(make_pair("IsInPrintCylinderSeparatePos", DValue(m_SignalStateWrapper->m_IsInPrintCylinderSeparatePos))); flag++; flag++; - m_SignalStateWrapper->m_IsInPrintPlatformBottomPos = new SysParamBool(flag++, 4, cc); //打印基板底座面 - m_SignalStateWrapper->m_IsInPrintPlatformFlatPos = new SysParamBool(flag++, 4, cc); //打印基板平面 - m_SignalStateWrapper->m_IsInPrintJackupPos = new SysParamBool(flag++, 4, cc); //打印顶升位 - m_SignalStateWrapper->m_IsInCleanJackupPos = new SysParamBool(flag++, 4, cc); //清粉顶升位 - m_SignalStateWrapper->m_IsInEleCylinderBottomFixPos = new SysParamBool(flag++, 4, cc); //底座贴合位 + m_SignalStateWrapper->m_IsInPrintPlatformBottomPos = new SysParamBool(flag++, 4, cc,"打印基板底座面"); + m_SignalStateWrapper->m_IsInPrintPlatformFlatPos = new SysParamBool(flag++, 4, cc,"打印基板平面"); + m_SignalStateWrapper->m_IsInPrintJackupPos = new SysParamBool(flag++, 4, cc,"打印顶升位"); + m_SignalStateWrapper->m_IsInCleanJackupPos = new SysParamBool(flag++, 4, cc,"清粉顶升位"); + m_SignalStateWrapper->m_IsInEleCylinderBottomFixPos = new SysParamBool(flag++, 4, cc,"底座贴合位"); + m_plcMp.insert(make_pair("IsInPrintPlatformBottomPos", DValue(m_SignalStateWrapper->m_IsInPrintPlatformBottomPos))); + m_plcMp.insert(make_pair("IsInPrintPlatformFlatPos", DValue(m_SignalStateWrapper->m_IsInPrintPlatformFlatPos))); + m_plcMp.insert(make_pair("IsInPrintJackupPos", DValue(m_SignalStateWrapper->m_IsInPrintJackupPos))); + m_plcMp.insert(make_pair("IsInCleanJackupPos", DValue(m_SignalStateWrapper->m_IsInCleanJackupPos))); + m_plcMp.insert(make_pair("IsInEleCylinderBottomFixPos", DValue(m_SignalStateWrapper->m_IsInEleCylinderBottomFixPos))); flag++; - m_SignalStateWrapper->m_IsInLoadPrintPos = new SysParamBool(flag++, 4, cc); //移载打印位 - m_SignalStateWrapper->m_IsInLoadCleanPos = new SysParamBool(flag++, 4, cc); //移载清粉位 - + m_SignalStateWrapper->m_IsInLoadPrintPos = new SysParamBool(flag++, 4, cc,"移载打印位"); + m_SignalStateWrapper->m_IsInLoadCleanPos = new SysParamBool(flag++, 4, cc,"移载清粉位"); + m_plcMp.insert(make_pair("IsInLoadPrintPos", DValue(m_SignalStateWrapper->m_IsInLoadPrintPos))); + m_plcMp.insert(make_pair("IsInLoadCleanPos", DValue(m_SignalStateWrapper->m_IsInLoadCleanPos))); flag = 251 * 8; - m_SignalStateWrapper->m_IsInDropPowderPos = new SysParamBool(flag++, 4, cc); //铺粉下粉位 - m_SignalStateWrapper->m_IsInAcceptPowderPos = new SysParamBool(flag++, 4, cc); //铺粉接粉位 + m_SignalStateWrapper->m_IsInDropPowderPos = new SysParamBool(flag++, 4, cc,"铺粉下粉位"); + m_SignalStateWrapper->m_IsInAcceptPowderPos = new SysParamBool(flag++, 4, cc,"铺粉接粉位"); + m_plcMp.insert(make_pair("IsInDropPowderPos", DValue(m_SignalStateWrapper->m_IsInDropPowderPos))); + m_plcMp.insert(make_pair("IsInAcceptPowderPos", DValue(m_SignalStateWrapper->m_IsInAcceptPowderPos))); flag = 88 * 8; - m_SignalStateWrapper->m_PrintTorqueUpInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在上升扭力范围内 - m_SignalStateWrapper->m_ArmNotUponBasePlatform = new SysParamBool(flag++, 1, cc); //铺粉轴不在基板范围内 - m_SignalStateWrapper->m_PrintMoldPosInsideUpSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软上限 - m_SignalStateWrapper->m_PrintInsideUpLimit = new SysParamBool(flag++, 1, cc); //上限位没触发 - m_SignalStateWrapper->m_PrintTorqueDownInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在下降扭力范围内 - m_SignalStateWrapper->m_PrintAxisPosInsideDownSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软下限 - m_SignalStateWrapper->m_PrintInsideDownLimit = new SysParamBool(flag++, 1, cc); //下限位没触发 - m_SignalStateWrapper->m_PrintMainServoNoAlarm = new SysParamBool(flag++, 1, cc); //打印主轴伺服无异常 - m_SignalStateWrapper->m_PrintMoldInPrintPos = new SysParamBool(flag++, 1, cc); //缸体在打印位 - m_SignalStateWrapper->m_PrintMoldInCleanPos = new SysParamBool(flag++, 1, cc); //缸体在清粉位 - m_SignalStateWrapper->m_PrintMoldInHandPos = new SysParamBool(flag++, 1, cc); //缸体在吊装位 - + m_SignalStateWrapper->m_PrintTorqueUpInsideLimit = new SysParamBool(flag++, 1, cc, "扭力值在上升扭力范围内"); + m_SignalStateWrapper->m_ArmNotUponBasePlatform = new SysParamBool(flag++, 1, cc, "铺粉轴不在基板范围内"); + m_SignalStateWrapper->m_PrintMoldPosInsideUpSoftLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软上限"); + m_SignalStateWrapper->m_PrintInsideUpLimit = new SysParamBool(flag++, 1, cc, "上限位没触发"); + m_SignalStateWrapper->m_PrintTorqueDownInsideLimit = new SysParamBool(flag++, 1, cc, "扭力值在下降扭力范围内"); + m_SignalStateWrapper->m_PrintAxisPosInsideDownSoftLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软下限"); + m_SignalStateWrapper->m_PrintInsideDownLimit = new SysParamBool(flag++, 1, cc, "下限位没触发"); + m_SignalStateWrapper->m_PrintMainServoNoAlarm = new SysParamBool(flag++, 1, cc, "打印主轴伺服无异常"); + m_SignalStateWrapper->m_PrintMoldInPrintPos = new SysParamBool(flag++, 1, cc, "缸体在打印位"); + m_SignalStateWrapper->m_PrintMoldInCleanPos = new SysParamBool(flag++, 1, cc, "缸体在清粉位"); + m_SignalStateWrapper->m_PrintMoldInHandPos = new SysParamBool(flag++, 1, cc, "缸体在吊装位"); + m_plcMp.insert(make_pair("PrintTorqueUpInsideLimit", DValue(m_SignalStateWrapper->m_PrintTorqueUpInsideLimit))); + m_plcMp.insert(make_pair("ArmNotUponBasePlatform", DValue(m_SignalStateWrapper->m_ArmNotUponBasePlatform))); + m_plcMp.insert(make_pair("PrintMoldPosInsideUpSoftLimit", DValue(m_SignalStateWrapper->m_PrintMoldPosInsideUpSoftLimit))); + m_plcMp.insert(make_pair("PrintInsideUpLimit", DValue(m_SignalStateWrapper->m_PrintInsideUpLimit))); + m_plcMp.insert(make_pair("PrintTorqueDownInsideLimit", DValue(m_SignalStateWrapper->m_PrintTorqueDownInsideLimit))); + m_plcMp.insert(make_pair("PrintAxisPosInsideDownSoftLimit", DValue(m_SignalStateWrapper->m_PrintAxisPosInsideDownSoftLimit))); + m_plcMp.insert(make_pair("PrintInsideDownLimit", DValue(m_SignalStateWrapper->m_PrintInsideDownLimit))); + m_plcMp.insert(make_pair("PrintMainServoNoAlarm", DValue(m_SignalStateWrapper->m_PrintMainServoNoAlarm))); + m_plcMp.insert(make_pair("PrintMoldInPrintPos", DValue(m_SignalStateWrapper->m_PrintMoldInPrintPos))); + m_plcMp.insert(make_pair("PrintMoldInCleanPos", DValue(m_SignalStateWrapper->m_PrintMoldInCleanPos))); + m_plcMp.insert(make_pair("PrintMoldInHandPos", DValue(m_SignalStateWrapper->m_PrintMoldInHandPos))); flag = 90 * 8+2; - m_SignalStateWrapper->m_CleanTorqueUpInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在上升扭力范围内 - m_SignalStateWrapper->m_CleanAxisPosUpInSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软上限 - m_SignalStateWrapper->m_CleanTorqueDownInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在下降扭力范围内 - m_SignalStateWrapper->m_CleanAxisPosDownInsideSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软下限 - m_SignalStateWrapper->m_CleanUpInsideLimit = new SysParamBool(flag++, 1, cc); //上限位没触发 - m_SignalStateWrapper->m_CleanDownInsideLimit = new SysParamBool(flag++, 1, cc); //下限位没触发 - m_SignalStateWrapper->m_EleMainServoNoAlarm = new SysParamBool(flag++, 1, cc); //电缸主轴伺服无异常 - m_SignalStateWrapper->m_EleSlaveServoNoAlarm = new SysParamBool(flag++, 1, cc); //电缸从轴伺服无异常 + m_SignalStateWrapper->m_CleanTorqueUpInsideLimit = new SysParamBool(flag++, 1, cc, "扭力值在上升扭力范围内"); + m_SignalStateWrapper->m_CleanAxisPosUpInSoftLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软上限"); + m_SignalStateWrapper->m_CleanTorqueDownInsideLimit = new SysParamBool(flag++, 1, cc, "扭力值在下降扭力范围内"); + m_SignalStateWrapper->m_CleanAxisPosDownInsideSoftLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软下限"); + m_SignalStateWrapper->m_CleanUpInsideLimit = new SysParamBool(flag++, 1, cc, "上限位没触发"); + m_SignalStateWrapper->m_CleanDownInsideLimit = new SysParamBool(flag++, 1, cc, "下限位没触发"); + m_SignalStateWrapper->m_EleMainServoNoAlarm = new SysParamBool(flag++, 1, cc, "电缸主轴伺服无异常"); + m_SignalStateWrapper->m_EleSlaveServoNoAlarm = new SysParamBool(flag++, 1, cc, "电缸从轴伺服无异常"); + m_plcMp.insert(make_pair("CleanTorqueUpInsideLimit", DValue(m_SignalStateWrapper->m_CleanTorqueUpInsideLimit))); + m_plcMp.insert(make_pair("CleanAxisPosUpInSoftLimit", DValue(m_SignalStateWrapper->m_CleanAxisPosUpInSoftLimit))); + m_plcMp.insert(make_pair("CleanTorqueDownInsideLimit", DValue(m_SignalStateWrapper->m_CleanTorqueDownInsideLimit))); + m_plcMp.insert(make_pair("CleanAxisPosDownInsideSoftLimit", DValue(m_SignalStateWrapper->m_CleanAxisPosDownInsideSoftLimit))); + m_plcMp.insert(make_pair("CleanUpInsideLimit", DValue(m_SignalStateWrapper->m_CleanUpInsideLimit))); + m_plcMp.insert(make_pair("CleanDownInsideLimit", DValue(m_SignalStateWrapper->m_CleanDownInsideLimit))); + m_plcMp.insert(make_pair("EleMainServoNoAlarm", DValue(m_SignalStateWrapper->m_EleMainServoNoAlarm))); + m_plcMp.insert(make_pair("EleSlaveServoNoAlarm", DValue(m_SignalStateWrapper->m_EleSlaveServoNoAlarm))); flag = 92 * 8; - m_SignalStateWrapper->m_PrintJackupInSafePos = new SysParamBool(flag++, 1, cc); //打印顶升轴在安全位 - m_SignalStateWrapper->m_LoadTorqueInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在扭力范围内 - m_SignalStateWrapper->m_LoadPosInsideLeftSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软左限 - m_SignalStateWrapper->m_LoadPosInsideRightSoftLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软右限 + m_SignalStateWrapper->m_PrintJackupInSafePos = new SysParamBool(flag++, 1, cc,"打印顶升轴在安全位"); + m_SignalStateWrapper->m_LoadTorqueInsideLimit = new SysParamBool(flag++, 1, cc,"扭力值在扭力范围内"); + m_SignalStateWrapper->m_LoadPosInsideLeftSoftLimit = new SysParamBool(flag++, 1, cc,"轴位置没超过软左限"); + m_SignalStateWrapper->m_LoadPosInsideRightSoftLimit = new SysParamBool(flag++, 1, cc,"轴位置没超过软右限"); + m_plcMp.insert(make_pair("PrintJackupInSafePos", DValue(m_SignalStateWrapper->m_PrintJackupInSafePos))); + m_plcMp.insert(make_pair("LoadTorqueInsideLimit", DValue(m_SignalStateWrapper->m_LoadTorqueInsideLimit))); + m_plcMp.insert(make_pair("LoadPosInsideLeftSoftLimit", DValue(m_SignalStateWrapper->m_LoadPosInsideLeftSoftLimit))); + m_plcMp.insert(make_pair("LoadPosInsideRightSoftLimit", DValue(m_SignalStateWrapper->m_LoadPosInsideRightSoftLimit))); flag++; flag++; flag++; flag++; - m_SignalStateWrapper->m_CylinderFixInReleasePos = new SysParamBool(flag++, 1, cc); //缸体固定气缸在松开位 + m_SignalStateWrapper->m_CylinderFixInReleasePos = new SysParamBool(flag++, 1, cc,"缸体固定气缸在松开位"); + m_plcMp.insert(make_pair("CylinderFixInReleasePos", DValue(m_SignalStateWrapper->m_CylinderFixInReleasePos))); flag++; - m_SignalStateWrapper->m_LoadLeftNotInsideLimit = new SysParamBool(flag++, 1, cc); //左限位没触发 - m_SignalStateWrapper->m_LoadRightNotInsideLimit = new SysParamBool(flag++, 1, cc); //右限位没触发 - m_SignalStateWrapper->m_LoadServoNoAlarm = new SysParamBool(flag++, 1, cc); //移载轴伺服无异常 - m_SignalStateWrapper->m_EleServoInBottomPos = new SysParamBool(flag++, 1, cc); //电缸在底座位 - + m_SignalStateWrapper->m_LoadLeftNotInsideLimit = new SysParamBool(flag++, 1, cc,"左限位没触发"); + m_SignalStateWrapper->m_LoadRightNotInsideLimit = new SysParamBool(flag++, 1, cc,"右限位没触发"); + m_SignalStateWrapper->m_LoadServoNoAlarm = new SysParamBool(flag++, 1, cc,"移载轴伺服无异常"); + m_SignalStateWrapper->m_EleServoInBottomPos = new SysParamBool(flag++, 1, cc,"电缸在底座位"); + m_plcMp.insert(make_pair("LoadLeftNotInsideLimit", DValue(m_SignalStateWrapper->m_LoadLeftNotInsideLimit))); + m_plcMp.insert(make_pair("LoadRightNotInsideLimit", DValue(m_SignalStateWrapper->m_LoadRightNotInsideLimit))); + m_plcMp.insert(make_pair("LoadServoNoAlarm", DValue(m_SignalStateWrapper->m_LoadServoNoAlarm))); + m_plcMp.insert(make_pair("EleServoInBottomPos", DValue(m_SignalStateWrapper->m_EleServoInBottomPos))); flag = 94 * 8; - m_SignalStateWrapper->m_PrintUpDownPosBelowPlatform = new SysParamBool(flag++, 1, cc); //打印顶升轴位置低于基板缸平面 - m_SignalStateWrapper->m_ArmTorqueInsideLimit = new SysParamBool(flag++, 1, cc); //扭力值在扭力范围内 - m_SignalStateWrapper->m_ArmPosInsideSoftFrontLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软前限 - m_SignalStateWrapper->m_ArmPosInsideSoftBackLimit = new SysParamBool(flag++, 1, cc); //轴位置没超过软后限 - m_SignalStateWrapper->m_ArmPosInsideFrontLimit = new SysParamBool(flag++, 1, cc); //前限位没触发 - m_SignalStateWrapper->m_ArmPosInsideBackLimit = new SysParamBool(flag++, 1, cc); //后限位没触发 - m_SignalStateWrapper->m_ArmServoNoAlarm = new SysParamBool(flag++, 1, cc); //铺粉轴伺服无异常 + m_SignalStateWrapper->m_PrintUpDownPosBelowPlatform = new SysParamBool(flag++, 1, cc, "打印顶升轴位置低于基板缸平面"); + m_SignalStateWrapper->m_ArmTorqueInsideLimit = new SysParamBool(flag++, 1, cc, "扭力值在扭力范围内"); + m_SignalStateWrapper->m_ArmPosInsideSoftFrontLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软前限"); + m_SignalStateWrapper->m_ArmPosInsideSoftBackLimit = new SysParamBool(flag++, 1, cc, "轴位置没超过软后限"); + m_SignalStateWrapper->m_ArmPosInsideFrontLimit = new SysParamBool(flag++, 1, cc, "前限位没触发"); + m_SignalStateWrapper->m_ArmPosInsideBackLimit = new SysParamBool(flag++, 1, cc, "后限位没触发"); + m_SignalStateWrapper->m_ArmServoNoAlarm = new SysParamBool(flag++, 1, cc, "铺粉轴伺服无异常"); + m_plcMp.insert(make_pair("PrintUpDownPosBelowPlatform", DValue(m_SignalStateWrapper->m_PrintUpDownPosBelowPlatform))); + m_plcMp.insert(make_pair("ArmTorqueInsideLimit", DValue(m_SignalStateWrapper->m_ArmTorqueInsideLimit))); + m_plcMp.insert(make_pair("ArmPosInsideSoftFrontLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideSoftFrontLimit))); + m_plcMp.insert(make_pair("ArmPosInsideSoftBackLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideSoftBackLimit))); + m_plcMp.insert(make_pair("ArmPosInsideFrontLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideFrontLimit))); + m_plcMp.insert(make_pair("ArmPosInsideBackLimit", DValue(m_SignalStateWrapper->m_ArmPosInsideBackLimit))); + m_plcMp.insert(make_pair("ArmServoNoAlarm", DValue(m_SignalStateWrapper->m_ArmServoNoAlarm))); m_SignalStateWrapper->m_KeepAliveCommand = new KeepAliveCommand(cc); m_SignalStateWrapper->m_KeepAliveCommand->m_PCKeepAlice = m_SignalStateWrapper->m_PCKeepAlice; diff --git a/PrintS/Machine/Machine.h b/PrintS/Machine/Machine.h index db8d8a4..5975149 100644 --- a/PrintS/Machine/Machine.h +++ b/PrintS/Machine/Machine.h @@ -19,10 +19,34 @@ #include #include "../DataManage/ClientInfo.h" #include "../LanguageManager.h" - - using namespace std; + +struct DValue { + DValue(SysParamBool* p) + : sysParamB(p), sysParamW(nullptr), sysParamI(nullptr), sysParamF(nullptr){ + //printf("SysParamBool init"); + } + DValue(SysParamWord* p) + : sysParamB(nullptr), sysParamW(p), sysParamI(nullptr), sysParamF(nullptr) { + //printf("SysParamWord init"); + } + DValue(SysParamInt* p) + : sysParamB(nullptr), sysParamW(nullptr), sysParamI(p), sysParamF(nullptr) { + //printf("SysParamInt init"); + } + DValue(SysParamFloat* p) + : sysParamB(nullptr), sysParamW(nullptr), sysParamI(nullptr), sysParamF(p) { + //printf("SysParamFloat init"); + } + + SysParamBool* sysParamB; + SysParamWord* sysParamW; + SysParamInt* sysParamI; + SysParamFloat* sysParamF; + +}; + class Machine { typedef void(*IoVersionCheck)(vector&, IOCfgWrapper*, string str, int type); public: @@ -253,6 +277,9 @@ protected: vector m_AxisTabs; list m_clientUser; //连接客户端 + + std::map m_plcMp; + }; diff --git a/PrintS/PLC/SysParam.cpp b/PrintS/PLC/SysParam.cpp index b1931f0..f880367 100644 --- a/PrintS/PLC/SysParam.cpp +++ b/PrintS/PLC/SysParam.cpp @@ -3,10 +3,11 @@ //#include "CoreCommunication.h" -SysParam::SysParam(int addr, int num, PLCReveiver* cc) - :PLCCommand(cc) +SysParam::SysParam(int addr, int num, PLCReveiver* cc,const string& context) + : PLCCommand(cc) , m_Addr(addr) , m_DBNumber(num) + , m_context(context) { } @@ -23,7 +24,7 @@ SysParam::SysParam(SysParam* sp) :PLCCommand(sp->m_Receiver) } -SysParamFloat::SysParamFloat(int addr, int num, PLCReveiver* cc) :SysParam(addr, num, cc) +SysParamFloat::SysParamFloat(int addr, int num, PLCReveiver* cc, const string& context) :SysParam(addr, num, cc,context) { m_CtrlCommand = new S7Command(S7_COMMAND_WRITE, 1); TS7DataItem* pItem = m_CtrlCommand->getDataItems(); @@ -59,7 +60,7 @@ SysParamFloat::~SysParamFloat() delete m_CtrlCommand; } -SysParamWord::SysParamWord(int addr, int num, PLCReveiver* cc) :SysParam(addr, num, cc) +SysParamWord::SysParamWord(int addr, int num, PLCReveiver* cc, const string& context) :SysParam(addr, num, cc,context) { m_CtrlCommand = new S7Command(S7_COMMAND_WRITE, 1); TS7DataItem* pItem = m_CtrlCommand->getDataItems(); @@ -93,7 +94,7 @@ SysParamWord::~SysParamWord() delete m_CtrlCommand; } -SysParamBool::SysParamBool(int addr, int num, PLCReveiver* cc) : SysParam(addr, num, cc) +SysParamBool::SysParamBool(int addr, int num, PLCReveiver* cc,const string& context) : SysParam(addr, num, cc, context) { m_CtrlCommand = new S7Command(S7_COMMAND_WRITE, 1); TS7DataItem* pItem = m_CtrlCommand->getDataItems(); @@ -122,7 +123,7 @@ void SysParamBool::SetValue(bool value) //m_cc->AddCmd(m_CtrlCommand); } -SysParamInt::SysParamInt(int addr, int num, PLCReveiver* cc) : SysParam(addr, num, cc) +SysParamInt::SysParamInt(int addr, int num, PLCReveiver* cc, const string& context) : SysParam(addr, num, cc,context) { m_CtrlCommand = new S7Command(S7_COMMAND_WRITE, 1); TS7DataItem* pItem = m_CtrlCommand->getDataItems(); diff --git a/PrintS/PLC/SysParam.h b/PrintS/PLC/SysParam.h index c7cd996..cb9649a 100644 --- a/PrintS/PLC/SysParam.h +++ b/PrintS/PLC/SysParam.h @@ -4,6 +4,7 @@ #include "Command/PLCComand.h" #include #include "Command/PLCReceiver.h" +#include using namespace std; //class CoreCommunication; @@ -11,7 +12,7 @@ class SysParam :public PLCCommand { public: - SysParam(int addr, int num, PLCReveiver* cc); + SysParam(int addr, int num, PLCReveiver* cc, const string& context = ""); virtual ~SysParam(); SysParam(SysParam*); @@ -20,6 +21,7 @@ public: protected: int m_Addr; int m_DBNumber; + string m_context; //名称内容 //S7Command* m_CtrlCommand; //PLCReveiver* m_cc; }; @@ -27,7 +29,7 @@ protected: class SysParamFloat :public SysParam { public: - SysParamFloat(int addr, int num, PLCReveiver* cc); + SysParamFloat(int addr, int num, PLCReveiver* cc, const string& context = ""); virtual ~SysParamFloat(); SysParamFloat(SysParamFloat* sp) :SysParam(sp) {} void SetReatimeValue(float value) { m_RealtimeValue = value; } @@ -51,7 +53,7 @@ class SysParamWord :public SysParam { public: - SysParamWord(int addr, int num, PLCReveiver* cc); + SysParamWord(int addr, int num, PLCReveiver* cc,const string& context = ""); ~SysParamWord(); SysParamWord(SysParamWord* sp) :SysParam(sp) {} void SetReatimeValue(short value) { m_RealtimeValue = value; } @@ -74,7 +76,7 @@ class SysParamBool :public SysParam { public: - SysParamBool(int addr, int num, PLCReveiver* cc); + SysParamBool(int addr, int num, PLCReveiver* cc,const string& context = ""); ~SysParamBool(); void SetReatimeValue(bool value) { m_RealtimeValue = value; } void SetValue(bool value); @@ -87,7 +89,7 @@ class SysParamInt :public SysParam { public: - SysParamInt(int addr, int num, PLCReveiver* cc); + SysParamInt(int addr, int num, PLCReveiver* cc, const string& context = ""); ~SysParamInt(); void SetReatimeValue(int value) { m_RealtimeValue = value; } void SetValue(int value); diff --git a/PrintS/PrintS.vcxproj b/PrintS/PrintS.vcxproj index 68e1204..0a80dcf 100644 --- a/PrintS/PrintS.vcxproj +++ b/PrintS/PrintS.vcxproj @@ -137,7 +137,7 @@ Console true true - DebugFastLink + false ./lib;./lib/absl libprotobuf.lib;libprotobuf-lite.lib;libprotoc.lib;address_sorting.lib;cares.lib;gpr.lib;crypto.lib;grpc++.lib;grpc++_alts.lib;grpc++_error_details.lib;grpc++_reflection.lib;grpc++_unsecure.lib;grpc.lib;grpcpp_channelz.lib;grpc_authorization_provider.lib;grpc_plugin_support.lib;grpc_unsecure.lib;upb.lib;upb_collections_lib.lib;upb_json_lib.lib;upb_textformat_lib.lib;utf8_range_lib.lib;re2.lib;ssl.lib;testing.lib;zlib.lib;zlibstatic.lib;absl_bad_any_cast_impl.lib;absl_bad_optional_access.lib;absl_bad_variant_access.lib;absl_base.lib;absl_city.lib;absl_civil_time.lib;absl_cord.lib;absl_cordz_functions.lib;absl_cordz_handle.lib;absl_cordz_info.lib;absl_cordz_sample_token.lib;absl_cord_internal.lib;absl_crc32c.lib;absl_crc_cord_state.lib;absl_crc_cpu_detect.lib;absl_crc_internal.lib;absl_debugging_internal.lib;absl_demangle_internal.lib;absl_die_if_null.lib;absl_examine_stack.lib;absl_exponential_biased.lib;absl_failure_signal_handler.lib;absl_flags.lib;absl_flags_commandlineflag.lib;absl_flags_commandlineflag_internal.lib;absl_flags_config.lib;absl_flags_internal.lib;absl_flags_marshalling.lib;absl_flags_parse.lib;absl_flags_private_handle_accessor.lib;absl_flags_program_name.lib;absl_flags_reflection.lib;absl_flags_usage.lib;absl_flags_usage_internal.lib;absl_graphcycles_internal.lib;absl_hash.lib;absl_hashtablez_sampler.lib;absl_int128.lib;absl_kernel_timeout_internal.lib;absl_leak_check.lib;absl_log_entry.lib;absl_log_flags.lib;absl_log_globals.lib;absl_log_initialize.lib;absl_log_internal_check_op.lib;absl_log_internal_conditions.lib;absl_log_internal_format.lib;absl_log_internal_globals.lib;absl_log_internal_log_sink_set.lib;absl_log_internal_message.lib;absl_log_internal_nullguard.lib;absl_log_internal_proto.lib;absl_log_severity.lib;absl_log_sink.lib;absl_low_level_hash.lib;absl_malloc_internal.lib;absl_periodic_sampler.lib;absl_random_distributions.lib;absl_random_internal_distribution_test_util.lib;absl_random_internal_platform.lib;absl_random_internal_pool_urbg.lib;absl_random_internal_randen.lib;absl_random_internal_randen_hwaes.lib;absl_random_internal_randen_hwaes_impl.lib;absl_random_internal_randen_slow.lib;absl_random_internal_seed_material.lib;absl_random_seed_gen_exception.lib;absl_random_seed_sequences.lib;absl_raw_hash_set.lib;absl_raw_logging_internal.lib;absl_scoped_set_env.lib;absl_spinlock_wait.lib;absl_stacktrace.lib;absl_status.lib;absl_statusor.lib;absl_strerror.lib;absl_strings.lib;absl_strings_internal.lib;absl_string_view.lib;absl_str_format_internal.lib;absl_symbolize.lib;absl_synchronization.lib;absl_throw_delegate.lib;absl_time.lib;absl_time_zone.lib;Ws2_32.lib;utf8_range.lib;utf8_validity.lib;opengl32.lib;sqlite3.lib;Rpcrt4.lib;ws2_32.lib;winmm.lib;dbghelp.lib;version.lib;gdiplus.lib;GxIAPICPPEx.lib;MVSDKmd.lib;jpeg-static.lib;turbojpeg-static.lib;RTC5DLLx64.lib;opencv_world455.lib;expat.lib;%(AdditionalDependencies) crypto.lib diff --git a/PrintS/main.cpp b/PrintS/main.cpp index 3e0b800..2c4578a 100644 --- a/PrintS/main.cpp +++ b/PrintS/main.cpp @@ -2,13 +2,11 @@ #include "global.h" #include "SystemInfo.h" #include "Logger.h" -#include "LanguageManager.h" #include "Toast.h" -#include "config/ConfigManager.h" #include +#include UserType g_Admin; - string g_AppPath; string g_AppDisk; Logger* g_log; @@ -19,35 +17,46 @@ uint32_t g_ScanSerial; string g_gno; SystemInfo* g_SystemInfo; -void usage() { +class HBDSystem { +public: + HBDSystem() {} + ~HBDSystem() { + DELP(g_log); + DELP(g_SystemInfo); + DELP(g_Toast); + DELP(g_LngManager); + } + void Init(){ + char szFilePath[MAX_PATH + 1] = { 0 }; + GetModuleFileName(NULL, szFilePath, MAX_PATH); + (strrchr(szFilePath, '\\'))[1] = 0; + g_AppPath = szFilePath; + g_AppDisk = g_AppPath.substr(0, 2); -} + g_Admin = ADMIN; + + g_isDebug = false; + g_log = new Logger(); + g_log->m_LogDao->Init(); + g_SystemInfo = new SystemInfo(); + g_Toast = new Toast(); + } +}; int main(int argc, char** argv) { - char szFilePath[MAX_PATH + 1] = { 0 }; - GetModuleFileName(NULL, szFilePath, MAX_PATH); - (strrchr(szFilePath, '\\'))[1] = 0; - g_AppPath = szFilePath; - g_AppDisk = g_AppPath.substr(0, 2); - - g_Admin = ADMIN; - - g_isDebug = false; - g_log = new Logger(); - g_log->m_LogDao->Init(); - g_SystemInfo = new SystemInfo(); - g_Toast = new Toast(); + HBDSystem* hbd = new HBDSystem(); + hbd->Init(); DataHandle* dataHandle = new DataHandle(); dataHandle->Init(); printf("服务器已启动，请输入命令："); - std::string userInput; while (true) { std::getline(std::cin, userInput); // 读取用户输入 + //std::cin.ignore(std::numeric_limits::max(), '\n');// 清除输入缓冲区中的多余字符 if (userInput == "r" || userInput == "run") { printf("service is running...\n"); @@ -55,7 +64,7 @@ int main(int argc, char** argv) { } else if (userInput == "exit" || userInput == "e") { dataHandle->Stop(); - delete dataHandle; + DELP(dataHandle); printf("service is exited...\n"); break; } @@ -64,9 +73,7 @@ int main(int argc, char** argv) { } } - delete g_log; - delete g_SystemInfo; - delete g_Toast; - delete g_LngManager; + DELP(dataHandle); + DELP(hbd); return 0; } \ No newline at end of file diff --git a/PrintS/output/Release/config.hbd b/PrintS/output/Release/config.hbd index 0be433d44f10886dda2b0a374beb652e2e0e1a05..9ededc6f173910dd3a5dd99b3d647caed993cc2d 100644 GIT binary patch delta 41310 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 delta 28925 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