1295 lines
42 KiB
C#
1295 lines
42 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using Aitex.Core.Common;
|
||
using Aitex.Core.RT.DataCenter;
|
||
using Aitex.Core.RT.Device;
|
||
using Aitex.Core.RT.Event;
|
||
using Aitex.Core.RT.Fsm;
|
||
using Aitex.Core.RT.OperationCenter;
|
||
using Aitex.Core.RT.Routine;
|
||
using Aitex.Core.Util;
|
||
using Aitex.Core.Utilities;
|
||
using MECF.Framework.Common.Equipment;
|
||
using MECF.Framework.Common.Fsm;
|
||
using MECF.Framework.Common.SubstrateTrackings;
|
||
using MECF.Framework.RT.Core.IoProviders;
|
||
using Mainframe.Buffers;
|
||
using Mainframe.LLs;
|
||
using Mainframe.TMs;
|
||
using SicPM;
|
||
using SicRT.Instances;
|
||
using SicRT.Modules;
|
||
using System.Linq;
|
||
using System.Threading.Tasks;
|
||
using Aitex.Core.RT.Device.Unit;
|
||
using Mainframe.Aligners;
|
||
using Mainframe.UnLoads;
|
||
using Mainframe.EFEMs;
|
||
using Mainframe.Cassettes;
|
||
using Aitex.Core.RT.SCCore;
|
||
using SicPM.Devices;
|
||
|
||
namespace SicRT.Equipments.Systems
|
||
{
|
||
public enum RtState
|
||
{
|
||
Init,
|
||
|
||
Initializing,
|
||
Idle,
|
||
|
||
Transfer,
|
||
AutoRunning,
|
||
AutoIdle,
|
||
|
||
Cycle,
|
||
|
||
PlatformCycle,
|
||
|
||
ReturnAllWafer,
|
||
|
||
Error,
|
||
ShutDown = 999
|
||
|
||
}
|
||
public class EquipmentManager : FsmDevice
|
||
{
|
||
public enum MSG
|
||
{
|
||
HOME,
|
||
RESET,
|
||
ABORT,
|
||
ERROR,
|
||
|
||
MoveWafer,
|
||
ReturnAllWafer,
|
||
PlatformCycle,
|
||
|
||
HomeUnit,
|
||
|
||
PauseAuto,
|
||
ResumeAuto,
|
||
|
||
Stop,
|
||
StopPlatformCycle,
|
||
|
||
StartCycle,
|
||
|
||
SetAutoMode,
|
||
SetManualMode,
|
||
|
||
CreateJob,
|
||
PauseJob,
|
||
ResumeJob,
|
||
StartJob,
|
||
StopJob,
|
||
AbortJob,
|
||
|
||
JobDone,
|
||
|
||
FAJobCommand,
|
||
|
||
SetOnline,
|
||
SetOffline,
|
||
|
||
ModuleError,
|
||
ShutDown = 999,
|
||
}
|
||
|
||
public Dictionary<ModuleName, ModuleFsmDevice> Modules { get; set; }
|
||
|
||
public bool IsAutoMode
|
||
{
|
||
get
|
||
{
|
||
return FsmState == (int)RtState.AutoRunning;
|
||
}
|
||
}
|
||
|
||
public bool IsInit
|
||
{
|
||
get { return FsmState == (int)RtState.Init; }
|
||
}
|
||
|
||
public bool IsOnline
|
||
{
|
||
get;
|
||
set;
|
||
}
|
||
|
||
public bool IsIdle
|
||
{
|
||
get { return FsmState == (int)RtState.Idle; }
|
||
}
|
||
public bool IsAlarm
|
||
{
|
||
get { return FsmState == (int)RtState.Error; }
|
||
}
|
||
|
||
public bool IsRunning
|
||
{
|
||
get
|
||
{
|
||
return FsmState == (int)RtState.Initializing
|
||
|| FsmState == (int)RtState.Transfer
|
||
|| FsmState == (int)RtState.Cycle
|
||
|| FsmState == (int)RtState.AutoRunning;
|
||
}
|
||
}
|
||
|
||
private ManualTransfer _manualTransfer;
|
||
private AutoTransfer _auto = null;
|
||
private HomeAll _homeAll;
|
||
|
||
private ReturnAllWafer _returnAll;
|
||
private List<string> _modules = new List<string>();
|
||
//readonly IEnumerable<PropertyInfo> IEntityModules;
|
||
|
||
private MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS _upsPM1A = null;
|
||
private MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS _upsPM1B = null;
|
||
|
||
private MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS _upsPM2A = null;
|
||
private MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS _upsPM2B = null;
|
||
|
||
private IoUPS _pm1UPS = null;
|
||
private IoUPS _pm2UPS = null;
|
||
//AETEmp
|
||
private MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Temps.AE.AETemp _aeTemp = null;
|
||
private SicAETemp _pmAETemp = null;
|
||
//
|
||
private IoInterLock _pmInterLock = null;
|
||
private Mainframe.Devices.IoInterLock _tmInterLock = null;
|
||
private IoSlitValve _pm1SlitValve = null;
|
||
private PeriodicJob _thread;
|
||
//
|
||
private SicPM.Devices.IoSignalTower _st = null;
|
||
//
|
||
private IoTC _tc = null;
|
||
private IoPTOffsetAndK _pt1, _pt2,_pt3,_pt4,_pt9,_pt10;
|
||
|
||
|
||
public EquipmentManager()
|
||
{
|
||
Module = "System";
|
||
Name = "System";
|
||
|
||
Modules = new Dictionary<ModuleName, ModuleFsmDevice>();
|
||
|
||
}
|
||
|
||
public override bool Initialize()
|
||
{
|
||
InitModules();
|
||
|
||
EnumLoop<RtState>.ForEach((item) =>
|
||
{
|
||
MapState((int)item, item.ToString());
|
||
});
|
||
|
||
EnumLoop<MSG>.ForEach((item) =>
|
||
{
|
||
MapMessage((int)item, item.ToString());
|
||
});
|
||
EnableFsm(100, RtState.Init);
|
||
|
||
BuildTransitionTable();
|
||
|
||
SubscribeDataVariable();
|
||
|
||
SubscribeOperation();
|
||
|
||
InitSetPSUY();
|
||
InitPTOffsetAndK();
|
||
|
||
Singleton<EventManager>.Instance.OnAlarmEvent += Instance_OnAlarmEvent;
|
||
|
||
_manualTransfer = new ManualTransfer();
|
||
_homeAll = new HomeAll();
|
||
_auto = new AutoTransfer();
|
||
_returnAll = new ReturnAllWafer();
|
||
|
||
return true;
|
||
}
|
||
|
||
private void InitModules()
|
||
{
|
||
var tm = new TMModule(ModuleName.TM);
|
||
|
||
Modules[ModuleName.TM] = tm;
|
||
tm.OnEnterError += OnModuleError;
|
||
|
||
var ll = new LoadLockModule(ModuleName.LoadLock);
|
||
Modules[ModuleName.LoadLock] = ll;
|
||
ll.OnEnterError += OnModuleError;
|
||
|
||
var unlaod = new UnLoadModule(ModuleName.UnLoad);
|
||
Modules[ModuleName.UnLoad] = unlaod;
|
||
unlaod.OnEnterError += OnModuleError;
|
||
|
||
var buffer = new BufferModule(ModuleName.Buffer);
|
||
Modules[ModuleName.Buffer] = buffer;
|
||
buffer.OnEnterError += OnModuleError;
|
||
|
||
|
||
var pm1 = new PMModule(ModuleName.PM1);
|
||
Modules[ModuleName.PM1] = pm1;
|
||
//pm1.OnEnterError += OnModuleError;
|
||
|
||
//var pm2 = new PMModule(ModuleName.PM2);
|
||
//Modules[ModuleName.PM2] = pm2;
|
||
//pm2.OnEnterError += OnModuleError;
|
||
|
||
var aligner = new AlignerModule(ModuleName.Aligner);
|
||
Modules[ModuleName.Aligner] = aligner;
|
||
aligner.OnEnterError += OnModuleError;
|
||
|
||
var efem = new EFEMModule(ModuleName.EFEM);
|
||
Modules[ModuleName.EFEM] = efem;
|
||
efem.OnEnterError += OnModuleError;
|
||
|
||
var cassal = new CassetteModule(ModuleName.CassAL, 25);
|
||
Modules[ModuleName.CassAL] = cassal;
|
||
cassal.OnEnterError += OnModuleError;
|
||
|
||
var cassar = new CassetteModule(ModuleName.CassAR, 25);
|
||
Modules[ModuleName.CassAR] = cassar;
|
||
cassar.OnEnterError += OnModuleError;
|
||
|
||
var cassbl = new CassetteModule(ModuleName.CassBL, 8);
|
||
Modules[ModuleName.CassBL] = cassbl;
|
||
cassbl.OnEnterError += OnModuleError;
|
||
|
||
_modules = new List<string>() { "System" };
|
||
foreach (var modulesKey in Modules.Keys)
|
||
{
|
||
_modules.Add(modulesKey.ToString());
|
||
}
|
||
|
||
foreach (var modulesValue in Modules.Values)
|
||
{
|
||
modulesValue.Initialize();
|
||
}
|
||
|
||
_pm1SlitValve = DEVICE.GetDevice<IoSlitValve>("TM.PM1Door");
|
||
_pmInterLock = DEVICE.GetDevice<IoInterLock>("PM1.PMInterLock");
|
||
_tmInterLock = DEVICE.GetDevice<Mainframe.Devices.IoInterLock>("TM.IoInterLock");
|
||
_upsPM1A = DEVICE.GetDevice<MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS>("PM1.ITAUPSA");
|
||
_upsPM1B = DEVICE.GetDevice<MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS>("PM1.ITAUPSB");
|
||
_pm1UPS = DEVICE.GetDevice<IoUPS>("PM1.UPS");
|
||
|
||
_upsPM2A = DEVICE.GetDevice<MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS>("PM2.ITAUPSA");
|
||
_upsPM2B = DEVICE.GetDevice<MECF.Framework.RT.EquipmentLibrary.HardwareUnits.UPS.ITAUPS>("PM2.ITAUPSB");
|
||
_pm2UPS = DEVICE.GetDevice<IoUPS>("PM2.UPS");
|
||
|
||
//AETemp
|
||
_aeTemp = DEVICE.GetDevice<MECF.Framework.RT.EquipmentLibrary.HardwareUnits.Temps.AE.AETemp>("PM1.AETemp");
|
||
_pmAETemp = DEVICE.GetDevice<SicAETemp>("PM1.PMAETemp");
|
||
//
|
||
_st = DEVICE.GetDevice<SicPM.Devices.IoSignalTower>("PM1.SignalTower");
|
||
_tc = DEVICE.GetDevice<IoTC>("PM1.TC1");
|
||
_pt1 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT1OffsetAndK");
|
||
_pt2 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT2OffsetAndK");
|
||
_pt3 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT3OffsetAndK");
|
||
_pt4 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT4OffsetAndK");
|
||
_pt9 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT9OffsetAndK");
|
||
_pt10 = DEVICE.GetDevice<IoPTOffsetAndK>("PM1.PT10OffsetAndK");
|
||
//
|
||
_thread = new PeriodicJob(200, OnTimer, "PmSlitDoor", false, true);
|
||
Task.Delay(15000).ContinueWith((a) => _thread.Start());
|
||
|
||
//IEntityModules = this.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public)
|
||
// .Where(t => t.PropertyType.GetInterfaces().Contains(typeof(IEntity)) && t.PropertyType.GetInterfaces().Contains(typeof(IModuleEntity)));
|
||
}
|
||
|
||
private void BuildTransitionTable()
|
||
{
|
||
//ShutDown
|
||
Transition(RtState.Init, MSG.ShutDown, FsmStartShutDown, RtState.ShutDown);
|
||
Transition(RtState.Idle, MSG.ShutDown, FsmStartShutDown, RtState.ShutDown);
|
||
Transition(RtState.AutoIdle, MSG.ShutDown, FsmStartShutDown, RtState.ShutDown);
|
||
EnterExitTransition<RtState, FSM_MSG>(RtState.ShutDown, FsmShutDown, null, null);
|
||
|
||
//Init sequence
|
||
Transition(RtState.Init, MSG.HOME, FsmStartHome, RtState.Initializing);
|
||
Transition(RtState.Idle, MSG.HOME, FsmStartHome, RtState.Initializing);
|
||
Transition(RtState.Error, MSG.HOME, FsmStartHome, RtState.Initializing);
|
||
|
||
// EnterExitTransition<RtState, FSM_MSG>(RtState.Initializing, fStartInit, FSM_MSG.NONE, null);
|
||
|
||
Transition(RtState.Initializing, FSM_MSG.TIMER, FsmMonitorHome, RtState.Idle);
|
||
Transition(RtState.Initializing, MSG.ERROR, fError, RtState.Error);
|
||
Transition(RtState.Initializing, MSG.ABORT, FsmAbort, RtState.Init);
|
||
|
||
|
||
//Online
|
||
Transition(RtState.Idle, MSG.SetOnline, FsmStartSetOnline, RtState.Idle);
|
||
Transition(RtState.Idle, MSG.SetOffline, FsmStartSetOffline, RtState.Idle);
|
||
|
||
//Reset
|
||
AnyStateTransition(MSG.RESET, fStartReset, RtState.Idle);
|
||
|
||
AnyStateTransition(MSG.ERROR, fError, RtState.Error);
|
||
AnyStateTransition((int)FSM_MSG.ALARM, fError, (int)RtState.Error);
|
||
|
||
//Auto/manual sequence
|
||
Transition(RtState.Idle, MSG.SetAutoMode, fStartAutoTransfer, RtState.AutoIdle);
|
||
|
||
Transition(RtState.AutoRunning, FSM_MSG.TIMER, fAutoTransfer, RtState.AutoRunning);
|
||
|
||
Transition(RtState.AutoRunning, MSG.ABORT, fAbortAutoTransfer, RtState.AutoIdle);
|
||
Transition(RtState.AutoRunning, MSG.JobDone, null, RtState.AutoIdle);
|
||
|
||
Transition(RtState.AutoRunning, MSG.FAJobCommand, FsmFAJobCommand, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.CreateJob, FsmCreateJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.StartJob, FsmStartJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.PauseJob, FsmPauseJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.ResumeJob, FsmResumeJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.StopJob, FsmStopJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoRunning, MSG.AbortJob, FsmAbortJob, RtState.AutoRunning);
|
||
|
||
Transition(RtState.AutoIdle, FSM_MSG.TIMER, FsmMonitorAutoIdle, RtState.AutoIdle);
|
||
Transition(RtState.AutoIdle, MSG.SetManualMode, FsmStartSetManualMode, RtState.Idle);
|
||
Transition(RtState.AutoIdle, MSG.FAJobCommand, FsmFAJobCommand, RtState.AutoIdle);
|
||
Transition(RtState.AutoIdle, MSG.CreateJob, FsmCreateJob, RtState.AutoIdle);
|
||
Transition(RtState.AutoIdle, MSG.StartJob, FsmStartJob, RtState.AutoRunning);
|
||
Transition(RtState.AutoIdle, MSG.ABORT, FsmAbort, RtState.AutoIdle);
|
||
Transition(RtState.AutoIdle, MSG.AbortJob, FsmAbortJob, RtState.AutoIdle);
|
||
|
||
EnterExitTransition<RtState, FSM_MSG>(RtState.AutoRunning, null, FSM_MSG.NONE, fExitAutoTransfer);
|
||
|
||
//return all wafer
|
||
Transition(RtState.Idle, MSG.ReturnAllWafer, FsmStartReturnAllWafer, RtState.ReturnAllWafer);
|
||
Transition(RtState.ReturnAllWafer, FSM_MSG.TIMER, FsmMonitorReturnAllWafer, RtState.Idle);
|
||
Transition(RtState.ReturnAllWafer, MSG.ABORT, FsmAbortReturnAllWafer, RtState.Idle);
|
||
|
||
|
||
//Transfer sequence
|
||
Transition(RtState.Idle, MSG.MoveWafer, fStartTransfer, RtState.Transfer);
|
||
Transition(RtState.Transfer, FSM_MSG.TIMER, fTransfer, RtState.Idle);
|
||
|
||
EnterExitTransition<RtState, FSM_MSG>(RtState.Transfer, null, FSM_MSG.NONE, fExitTransfer);
|
||
|
||
Transition(RtState.Transfer, MSG.ABORT, FsmAbort, RtState.Idle);
|
||
}
|
||
|
||
void SubscribeDataVariable()
|
||
{
|
||
DATA.Subscribe("Rt.Status", () => StringFsmStatus);
|
||
DATA.Subscribe("System.IsOnline", () => IsOnline);
|
||
DATA.Subscribe("System.IsIdle", () => IsIdle || IsInit);
|
||
DATA.Subscribe("System.IsAlarm", () => IsAlarm);
|
||
DATA.Subscribe("System.IsBusy", () => IsRunning);
|
||
DATA.Subscribe("System.IsAutoRunning", () => IsRunning);
|
||
DATA.Subscribe("System.Modules", () => _modules);
|
||
DATA.Subscribe("System.LiveAlarmEvent", () => EV.GetAlarmEvent());
|
||
}
|
||
|
||
void SubscribeOperation()
|
||
{
|
||
OP.Subscribe("CreateWafer", InvokeCreateWafer);
|
||
|
||
OP.Subscribe("DeleteWafer", InvokeDeleteWafer);
|
||
|
||
OP.Subscribe("ReturnWafer", InvokeReturnWafer);
|
||
|
||
OP.Subscribe("DeleteTray", InvokeDeleteTray);
|
||
|
||
OP.Subscribe("AlterWaferInfo", InvokeAlterWaferInfo);
|
||
|
||
|
||
OP.Subscribe("System.ReturnAllWafer", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.ReturnAllWafer);
|
||
});
|
||
|
||
OP.Subscribe("System.MoveWafer", (string cmd, object[] args) =>
|
||
{
|
||
if (!Enum.TryParse((string)args[0], out ModuleName source))
|
||
{
|
||
EV.PostWarningLog(Name, $"Parameter source {(string)args[0]} not valid");
|
||
return false;
|
||
}
|
||
|
||
if (!Enum.TryParse((string)args[2], out ModuleName destination))
|
||
{
|
||
EV.PostWarningLog(Name, $"Parameter destination {(string)args[1]} not valid");
|
||
return false;
|
||
}
|
||
if (args.Length > 9 )
|
||
{
|
||
if ((bool)args[9])
|
||
{
|
||
WaferManager.Instance.WaferMoved(source, (int)args[1], destination, (int)args[3]);
|
||
return true;
|
||
}
|
||
if ((bool)args[10])
|
||
{
|
||
WaferManager.Instance.TrayMoved(source, (int)args[1], destination, (int)args[3]);
|
||
return true;
|
||
}
|
||
|
||
}
|
||
if (args.Length >= 8)
|
||
{
|
||
return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3],
|
||
(bool)args[4], (int)args[5], (bool)args[6], (int)args[7]);
|
||
}
|
||
if (args.Length == 5)
|
||
{
|
||
return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3], (bool)args[4]);
|
||
}
|
||
|
||
return CheckToPostMessage((int)MSG.MoveWafer, source, (int)args[1], destination, (int)args[3]);
|
||
});
|
||
|
||
OP.Subscribe("System.HomeAll", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.HOME);
|
||
});
|
||
OP.Subscribe("System.Abort", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.ABORT);
|
||
});
|
||
|
||
OP.Subscribe("System.Reset", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.RESET);
|
||
});
|
||
|
||
OP.Subscribe("System.SetAutoMode", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.SetAutoMode);
|
||
});
|
||
OP.Subscribe("System.SetManualMode", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.SetManualMode);
|
||
});
|
||
|
||
OP.Subscribe("System.CreateJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.CreateJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.StartJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.StartJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.PauseJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.PauseJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.ResumeJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.ResumeJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.StopJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.StopJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.AbortJob", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.AbortJob, args[0]);
|
||
});
|
||
|
||
OP.Subscribe("System.SetOnline", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.SetOnline);
|
||
});
|
||
|
||
OP.Subscribe("System.SetOffline", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.SetOffline);
|
||
});
|
||
OP.Subscribe("System.ShutDown", (string cmd, object[] args) =>
|
||
{
|
||
return CheckToPostMessage((int)MSG.ShutDown, null);
|
||
});
|
||
//OP.Subscribe("System.StartAutoRun", (string cmd, object[] args) =>
|
||
//{
|
||
// return CheckToPostMessage((int)MSG.StartJob, args[0]);
|
||
//});
|
||
}
|
||
|
||
void InitSetPSUY()
|
||
{
|
||
Task.Delay(2000).ContinueWith(x=> _tc.SetPCPSUY());
|
||
}
|
||
void InitPTOffsetAndK()
|
||
{
|
||
Task.Delay(2000).ContinueWith(x => SetPTOffsetAndK());
|
||
}
|
||
|
||
void SetPTOffsetAndK()
|
||
{
|
||
_pt1.SetPTOffset();
|
||
_pt1.SetPTK();
|
||
|
||
_pt2.SetPTOffset();
|
||
_pt2.SetPTK();
|
||
|
||
_pt3.SetPTOffset();
|
||
_pt3.SetPTK();
|
||
|
||
_pt4.SetPTOffset();
|
||
_pt4.SetPTK();
|
||
|
||
_pt9.SetPTOffset();
|
||
_pt9.SetPTK();
|
||
|
||
_pt10.SetPTOffset();
|
||
_pt10.SetPTK();
|
||
}
|
||
|
||
//EventManager触发OnAlarmEvent事件，即EV.PostAlarmLog触发
|
||
//具体值到 EventManager里面找
|
||
//private void Instance_OnAlarmEvent(EventItem obj)
|
||
//{
|
||
// if (obj.EventEnum == "ALARM_EVENT")
|
||
// {
|
||
// //这里应该触发IoSignalTower的警报动作
|
||
// if (_st != null)
|
||
// {
|
||
// MECF.Framework.Common.Device.Bases.SignalLightBase islL = _st.CreateLight(MECF.Framework.Common.Device.Bases.LightType.Red);
|
||
// if (islL != null)
|
||
// {
|
||
// islL.StateSetPoint = MECF.Framework.Common.Device.Bases.TowerLightStatus.On;
|
||
// }
|
||
// //
|
||
// MECF.Framework.Common.Device.Bases.SignalLightBase islB = _st.CreateLight(MECF.Framework.Common.Device.Bases.LightType.Buzzer);
|
||
// if (islB != null)
|
||
// {
|
||
// islB.StateSetPoint = MECF.Framework.Common.Device.Bases.TowerLightStatus.On;
|
||
// }
|
||
// }
|
||
// }
|
||
//}
|
||
private void Instance_OnAlarmEvent(EventItem obj)
|
||
{
|
||
FSM_MSG msg = FSM_MSG.NONE;
|
||
if (obj.Level == EventLevel.Warning)
|
||
msg = FSM_MSG.WARNING;
|
||
else if (obj.Level == EventLevel.Alarm)
|
||
{
|
||
msg = FSM_MSG.ALARM;
|
||
|
||
switch (obj.Source)
|
||
{
|
||
case "PM1":
|
||
case "PM2":
|
||
case "EFEM":
|
||
case "TM":
|
||
default:
|
||
if (Modules.ContainsKey(ModuleHelper.Converter(obj.Source)))
|
||
{
|
||
Modules[ModuleHelper.Converter(obj.Source)]?.PostMsg(msg, obj.Id, obj.Description);
|
||
}
|
||
break;
|
||
}
|
||
|
||
if (_st != null)
|
||
{
|
||
_st.SwitchOffBuzzer(false);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
#region Init
|
||
private bool FsmStartHome(object[] objs)
|
||
{
|
||
return _homeAll.Start() == Result.RUN;
|
||
}
|
||
|
||
private bool FsmMonitorHome(object[] objs)
|
||
{
|
||
Result ret = _homeAll.Monitor();
|
||
if (ret == Result.DONE)
|
||
{
|
||
_homeAll.Clear();
|
||
return true;
|
||
}
|
||
if (ret == Result.FAIL)
|
||
{
|
||
_homeAll.Clear();
|
||
PostMsg(MSG.ERROR);
|
||
}
|
||
return false;
|
||
}
|
||
|
||
private bool fError(object[] objs)
|
||
{
|
||
IsOnline = false;
|
||
|
||
if (FsmState == (int)RtState.Transfer)
|
||
{
|
||
_manualTransfer.Clear();
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
#endregion
|
||
|
||
#region AutoTransfer
|
||
|
||
private bool FsmMonitorAutoIdle(object[] param)
|
||
{
|
||
//fMonitorFAJob(param);
|
||
|
||
Result ret = _auto.Monitor();
|
||
|
||
//if (!_auto.CheckAllJobDone())
|
||
//{
|
||
// return false;
|
||
//}
|
||
|
||
return ret == Result.DONE;
|
||
}
|
||
|
||
private bool FsmStartSetManualMode(object[] objs)
|
||
{
|
||
if (_auto.HasJobRunning)
|
||
{
|
||
EV.PostWarningLog("System", "Can not change to manual mode, abort running job first");
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool fStartAutoTransfer(object[] objs)
|
||
{
|
||
|
||
Result ret = _auto.Start(objs);
|
||
|
||
return ret == Result.RUN;
|
||
}
|
||
|
||
private bool fAutoTransfer(object[] objs)
|
||
{
|
||
Result ret = _auto.Monitor();
|
||
|
||
if (_auto.CheckAllJobDone())
|
||
{
|
||
if (!CheckToPostMessage((int)MSG.JobDone))
|
||
return false;
|
||
}
|
||
|
||
return ret == Result.DONE;
|
||
}
|
||
|
||
private bool fExitAutoTransfer(object[] objs)
|
||
{
|
||
_auto.Clear();
|
||
return true;
|
||
}
|
||
|
||
private bool fAbortAutoTransfer(object[] objs)
|
||
{
|
||
if (FsmState == (int)RtState.Transfer)
|
||
{
|
||
_manualTransfer.Clear();
|
||
}
|
||
|
||
if (FsmState == (int)RtState.AutoRunning)
|
||
{
|
||
_auto.Clear();
|
||
}
|
||
foreach (var modulesValue in Modules.Values)
|
||
{
|
||
if (!modulesValue.Module.Contains("PM"))
|
||
{
|
||
modulesValue.PostMsg(MSG.ABORT);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#endregion
|
||
|
||
#region cycle
|
||
|
||
private bool FsmAbortCycle(object[] param)
|
||
{
|
||
return true;
|
||
}
|
||
|
||
private bool FsmMonitorCycle(object[] param)
|
||
{
|
||
return _auto.Monitor() == Result.DONE;
|
||
}
|
||
|
||
private bool FsmStartCycle(object[] param)
|
||
{
|
||
return _auto.Start() == Result.RUN;
|
||
}
|
||
#endregion
|
||
|
||
#region return all wafer
|
||
|
||
private bool FsmAbortReturnAllWafer(object[] param)
|
||
{
|
||
//_returnAll.Clear();
|
||
return true;
|
||
}
|
||
|
||
private bool FsmMonitorReturnAllWafer(object[] param)
|
||
{
|
||
return _returnAll.Monitor() == Result.DONE;
|
||
}
|
||
|
||
private bool FsmStartReturnAllWafer(object[] param)
|
||
{
|
||
return _returnAll.Start() == Result.RUN;
|
||
}
|
||
#endregion
|
||
|
||
#region Transfer
|
||
private bool fStartTransfer(object[] objs)
|
||
{
|
||
Result ret = _manualTransfer.Start(objs);
|
||
if (ret == Result.FAIL || ret == Result.DONE)
|
||
return false;
|
||
return ret == Result.RUN;
|
||
}
|
||
|
||
|
||
private bool fTransfer(object[] objs)
|
||
{
|
||
Result ret = _manualTransfer.Monitor(objs);
|
||
if (ret == Result.FAIL)
|
||
{
|
||
PostMsg(MSG.ERROR);
|
||
return false;
|
||
}
|
||
return ret == Result.DONE;
|
||
}
|
||
|
||
private bool fExitTransfer(object[] objs)
|
||
{
|
||
_manualTransfer.Clear();
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool fAbortTransfer(object[] objs)
|
||
{
|
||
return true;
|
||
}
|
||
#endregion
|
||
|
||
#region reset
|
||
|
||
private bool fStartReset(object[] objs)
|
||
{
|
||
EV.ClearAlarmEvent();
|
||
|
||
if (FsmState == (int)RtState.AutoRunning)
|
||
{
|
||
_auto.ResetTask();
|
||
}
|
||
|
||
Singleton<DeviceEntity>.Instance.PostMsg(DeviceEntity.MSG.RESET);
|
||
|
||
foreach (var modulesValue in Modules.Values)
|
||
{
|
||
modulesValue.PostMsg(MSG.RESET);
|
||
}
|
||
|
||
|
||
IoProviderManager.Instance.Reset();
|
||
|
||
if (FsmState == (int)RtState.Error)
|
||
return true;
|
||
|
||
|
||
return false;
|
||
}
|
||
|
||
#endregion
|
||
|
||
private bool FsmFAJobCommand(object[] param)
|
||
{
|
||
switch ((string)param[0])
|
||
{
|
||
case "CreateProcessJob":
|
||
//_auto.CreateProcessJob((string)param[1], (string)param[2], (List<int>)param[3], (bool)param[4]);
|
||
break;
|
||
case "CreateControlJob":
|
||
//_auto.CreateControlJob((string)param[1], (string)param[2], (List<string>)param[3], (bool)param[4]);
|
||
CheckToPostMessage((int)MSG.StartJob, (string)param[1]);
|
||
break;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool FsmCreateJob(object[] param)
|
||
{
|
||
_auto.CreateJob((Dictionary<string, object>)param[0]);
|
||
|
||
return true;
|
||
}
|
||
|
||
|
||
|
||
private bool FsmAbortJob(object[] param)
|
||
{
|
||
_auto.AbortJob((string)param[0]);
|
||
return true;
|
||
}
|
||
|
||
private bool FsmStopJob(object[] param)
|
||
{
|
||
_auto.StopJob((string)param[0]);
|
||
return true;
|
||
}
|
||
|
||
private bool FsmResumeJob(object[] param)
|
||
{
|
||
_auto.ResumeJob((string)param[0]);
|
||
return true;
|
||
}
|
||
|
||
private bool FsmPauseJob(object[] param)
|
||
{
|
||
_auto.PauseJob((string)param[0]);
|
||
return true;
|
||
}
|
||
|
||
private bool FsmStartJob(object[] param)
|
||
{
|
||
_auto.StartJob((string)param[0]);
|
||
return true;
|
||
}
|
||
|
||
private bool FsmAbort(object[] param)
|
||
{
|
||
if (FsmState == (int)RtState.Transfer)
|
||
{
|
||
_manualTransfer.Clear();
|
||
}
|
||
|
||
if (FsmState == (int)RtState.AutoRunning)
|
||
{
|
||
_auto.Clear();
|
||
}
|
||
foreach (var modulesValue in Modules.Values)
|
||
{
|
||
if (!modulesValue.Module.Contains("PM"))
|
||
{
|
||
modulesValue.PostMsg(MSG.ABORT);
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private bool FsmStartSetOffline(object[] param)
|
||
{
|
||
IsOnline = false;
|
||
|
||
var tm = Modules[ModuleName.TM] as TMModule;
|
||
tm.InvokeOffline();
|
||
|
||
var ll = Modules[ModuleName.LoadLock] as LoadLockModule;
|
||
ll.InvokeOffline();
|
||
|
||
var buffer = Modules[ModuleName.Buffer] as BufferModule;
|
||
buffer.InvokeOffline();
|
||
|
||
var unLoad = Modules[ModuleName.UnLoad] as UnLoadModule;
|
||
unLoad.InvokeOffline();
|
||
|
||
var efem = Modules[ModuleName.EFEM] as EFEMModule;
|
||
efem.InvokeOffline();
|
||
|
||
var aligner = Modules[ModuleName.Aligner] as AlignerModule;
|
||
aligner.InvokeOffline();
|
||
|
||
var pm1 = Modules[ModuleName.PM1] as PMModule;
|
||
pm1.InvokeOffline();
|
||
|
||
var cassAL = Modules[ModuleName.CassAL] as CassetteModule;
|
||
cassAL.InvokeOffline();
|
||
|
||
var cassAR = Modules[ModuleName.CassAR] as CassetteModule;
|
||
cassAR.InvokeOffline();
|
||
|
||
var cassBL = Modules[ModuleName.CassBL] as CassetteModule;
|
||
cassBL.InvokeOffline();
|
||
|
||
//var pm2 = Modules[ModuleName.PM2] as PMModule;
|
||
//pm2.InvokeOffline();
|
||
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool FsmStartSetOnline(object[] param)
|
||
{
|
||
IsOnline = true;
|
||
|
||
var tm = Modules[ModuleName.TM] as TMModule;
|
||
tm.InvokeOnline();
|
||
|
||
var ll = Modules[ModuleName.LoadLock] as LoadLockModule;
|
||
ll.InvokeOnline();
|
||
|
||
var buffer = Modules[ModuleName.Buffer] as BufferModule;
|
||
buffer.InvokeOnline();
|
||
|
||
var unLoad = Modules[ModuleName.UnLoad] as UnLoadModule;
|
||
unLoad.InvokeOnline();
|
||
|
||
var efem = Modules[ModuleName.EFEM] as EFEMModule;
|
||
efem.InvokeOnline();
|
||
|
||
var aligner = Modules[ModuleName.Aligner] as AlignerModule;
|
||
aligner.InvokeOnline();
|
||
|
||
var pm1 = Modules[ModuleName.PM1] as PMModule;
|
||
pm1.InvokeOnline();
|
||
|
||
var cassAL = Modules[ModuleName.CassAL] as CassetteModule;
|
||
cassAL.InvokeOnline();
|
||
|
||
var cassAR = Modules[ModuleName.CassAR] as CassetteModule;
|
||
cassAR.InvokeOnline();
|
||
|
||
var cassBL = Modules[ModuleName.CassBL] as CassetteModule;
|
||
cassBL.InvokeOnline();
|
||
|
||
//var pm2 = Modules[ModuleName.PM2] as PMModule;
|
||
//pm2.InvokeOnline();
|
||
|
||
|
||
return true;
|
||
}
|
||
#region cassette popup menu
|
||
private bool InvokeReturnWafer(string arg1, object[] args)
|
||
{
|
||
ModuleName target = ModuleHelper.Converter(args[0].ToString());
|
||
int slot = (int)args[1];
|
||
|
||
if (ModuleHelper.IsLoadPort(target))
|
||
{
|
||
EV.PostInfoLog("System", string.Format("Wafer already at LoadPort {0} {1}, return operation is not valid", target.ToString(), slot + 1));
|
||
return false;
|
||
}
|
||
|
||
if (!WaferManager.Instance.IsWaferSlotLocationValid(target, slot))
|
||
{
|
||
EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", target.ToString(), slot.ToString()));
|
||
return false;
|
||
}
|
||
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(target, slot);
|
||
if (wafer.IsEmpty)
|
||
{
|
||
EV.PostInfoLog("System", string.Format("No wafer at {0} {1}, return operation is not valid", target.ToString(), slot + 1));
|
||
return false;
|
||
}
|
||
|
||
return CheckToPostMessage((int)MSG.MoveWafer,
|
||
target, slot,
|
||
(ModuleName)wafer.OriginStation, wafer.OriginSlot,
|
||
false, 0, false, 0);
|
||
}
|
||
|
||
|
||
private bool InvokeDeleteWafer(string arg1, object[] args)
|
||
{
|
||
ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
|
||
int slot = (int)args[1];
|
||
|
||
if (chamber == ModuleName.TrayRobot || chamber == ModuleName.CassBL)
|
||
{
|
||
if (WaferManager.Instance.CheckHasTray(chamber, slot))
|
||
{
|
||
WaferManager.Instance.DeleteWafer(chamber, slot);
|
||
EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferDelete, chamber.ToString(), slot + 1);
|
||
}
|
||
else
|
||
{
|
||
EV.PostInfoLog("System", string.Format("No wafer at {0} {1}, delete not valid", chamber.ToString(), slot + 1));
|
||
}
|
||
}
|
||
else if (WaferManager.Instance.CheckHasWafer(chamber, slot))
|
||
{
|
||
if (chamber == ModuleName.TMRobot || chamber == ModuleName.LoadLock || chamber == ModuleName.UnLoad || chamber == ModuleName.Buffer)
|
||
{
|
||
if (WaferManager.Instance.CheckHasTray(chamber, slot))
|
||
{
|
||
WaferManager.Instance.DeleteWaferOnly(chamber, slot);
|
||
}
|
||
else
|
||
{
|
||
WaferManager.Instance.DeleteWafer(chamber, slot);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
WaferManager.Instance.DeleteWafer(chamber, slot);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
|
||
return false;
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool InvokeCreateWafer(string arg1, object[] args)
|
||
{
|
||
ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
|
||
int slot = (int)args[1];
|
||
WaferStatus state = WaferStatus.Normal;
|
||
|
||
if (chamber == ModuleName.TrayRobot || chamber == ModuleName.CassBL)
|
||
{
|
||
if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
|
||
{
|
||
if (WaferManager.Instance.CheckHasTray(chamber, slot))
|
||
{
|
||
EV.PostInfoLog("System", string.Format("{0} slot {1} already has tray.create wafer is not valid", chamber, slot));
|
||
}
|
||
else if (WaferManager.Instance.CreateWafer(chamber, slot, state) != null)
|
||
{
|
||
EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
|
||
}
|
||
}
|
||
else
|
||
{
|
||
EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
|
||
return false;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
if (WaferManager.Instance.IsWaferSlotLocationValid(chamber, slot))
|
||
{
|
||
if (WaferManager.Instance.CheckHasWafer(chamber, slot))
|
||
{
|
||
EV.PostInfoLog("System", string.Format("{0} slot {1} already has wafer.create wafer is not valid", chamber, slot));
|
||
}
|
||
else if (WaferManager.Instance.CreateWafer(chamber, slot, state) != null)
|
||
{
|
||
EV.PostMessage(ModuleName.System.ToString(), EventEnum.WaferCreate, chamber.ToString(), slot + 1, state.ToString());
|
||
}
|
||
}
|
||
else
|
||
{
|
||
EV.PostWarningLog("System", string.Format("Invalid position，{0}，{1}", chamber.ToString(), slot.ToString()));
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
private bool InvokeDeleteTray(string arg1, object[] args)
|
||
{
|
||
ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
|
||
int slot = (int)args[1];
|
||
|
||
if (WaferManager.Instance.CheckHasTray(chamber, slot))
|
||
{
|
||
if (chamber == ModuleName.Buffer)
|
||
{
|
||
WaferManager.Instance.DeleteWafer(chamber, slot);
|
||
}
|
||
else if (WaferManager.Instance.CheckHasWafer(chamber, slot))
|
||
{
|
||
WaferManager.Instance.GetWafer(chamber, slot).TrayState = WaferTrayStatus.Empty;
|
||
}
|
||
else
|
||
{
|
||
WaferManager.Instance.DeleteWafer(chamber, slot);
|
||
}
|
||
}
|
||
|
||
return true;
|
||
}
|
||
|
||
private bool InvokeAlterWaferInfo(string arg1, object[] args)
|
||
{
|
||
ModuleName chamber = ModuleHelper.Converter(args[0].ToString());
|
||
int slot = (int)args[1];
|
||
string recipeName = args[2].ToString();
|
||
int trayProcessCount = (int)args[3];
|
||
WaferInfo wafer = WaferManager.Instance.GetWafer(chamber, slot);
|
||
if (WaferManager.Instance.CheckHasWafer(chamber, slot))
|
||
{
|
||
if(!String.IsNullOrEmpty(recipeName) && wafer != null && wafer.ProcessJob != null && wafer.ProcessJob.Sequence != null && wafer.ProcessState == EnumWaferProcessStatus.Idle)
|
||
{
|
||
for (int i = 0; i < wafer.ProcessJob.Sequence.Steps.Count; i++)
|
||
{
|
||
if (!String.IsNullOrEmpty(wafer.ProcessJob.Sequence.Steps[i].RecipeName))
|
||
{
|
||
wafer.ProcessJob.Sequence.Steps[i].RecipeName = recipeName;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (WaferManager.Instance.CheckHasTray(chamber, slot))
|
||
{
|
||
if (wafer != null)
|
||
{
|
||
wafer.TrayProcessCount = trayProcessCount;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
|
||
#endregion
|
||
|
||
private void OnModuleError(string module)
|
||
{
|
||
if (FsmState == (int)RtState.AutoRunning)
|
||
{
|
||
ModuleName mod = ModuleHelper.Converter(module);
|
||
|
||
PostMsg(MSG.ModuleError, module);
|
||
}
|
||
}
|
||
|
||
#region ShutDown
|
||
private bool FsmStartShutDown(object[] objs)
|
||
{
|
||
var InBusyModuleNames = this.GetType().GetProperties(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public)
|
||
.Where(t => t.PropertyType.GetInterfaces().Contains(typeof(IModuleEntity)) && ((IModuleEntity)t.GetValue(this, null)).IsBusy)
|
||
.Select(n => n.Name).ToArray();
|
||
|
||
if (InBusyModuleNames.Length > 0)
|
||
{
|
||
EV.PostWarningLog("System", $"Shut down fail , {string.Join(" , ", InBusyModuleNames)} is in busy");
|
||
return false;
|
||
}
|
||
|
||
Term();
|
||
EV.PostKickoutMessage("ShutDown");
|
||
return true;
|
||
}
|
||
|
||
private bool FsmShutDown(object[] objs)
|
||
{
|
||
Task.Delay(3000).ContinueWith(a =>
|
||
{
|
||
Environment.Exit(0);
|
||
});
|
||
return true;
|
||
}
|
||
|
||
protected void Term()
|
||
{
|
||
foreach (var modulesValue in Modules.Values)
|
||
{
|
||
modulesValue.Terminate();
|
||
}
|
||
}
|
||
|
||
|
||
public bool OnTimer()
|
||
{
|
||
//MonitorModuleAlarm();
|
||
MonitorPmTmInfo();
|
||
MonitorUPSAlarm();
|
||
MonitorAETemp(); //AE通断，DO220
|
||
return true;
|
||
}
|
||
|
||
//public void MonitorModuleAlarm()
|
||
//{
|
||
// var alarms = EV.GetAlarmEvent();
|
||
// if (alarms != null && StringFsmStatus != "Initializing")
|
||
// {
|
||
// foreach (var modulesNa in Modules.Keys)
|
||
// {
|
||
// if (alarms.FindAll(a => a.Level == EventLevel.Alarm && a.Source == modulesNa.ToString()).Count > 0 && Modules[modulesNa].StringFsmStatus.ToLower() != "error")
|
||
// {
|
||
// Modules[modulesNa].PostMsg(MSG.ERROR);
|
||
// }
|
||
// }
|
||
// }
|
||
//}
|
||
|
||
|
||
private void MonitorPmTmInfo()
|
||
{
|
||
if (_pm1SlitValve != null)
|
||
{
|
||
if (_pmInterLock != null && _pmInterLock.DoPMASlitDoorClosed != _pm1SlitValve.IsClose)
|
||
{
|
||
_pmInterLock.DoPMASlitDoorClosed = _pm1SlitValve.IsClose;
|
||
}
|
||
|
||
if (_tmInterLock != null && _pmInterLock != null)
|
||
{
|
||
if (_tmInterLock.DoPm1LidClosed != _pmInterLock.DiChamLidClosed)
|
||
{
|
||
_tmInterLock.DoPm1LidClosed = _pmInterLock.DiChamLidClosed;
|
||
}
|
||
|
||
if (_tmInterLock.DoRectorAATMTransferReady != _pmInterLock.DoReactorATMTransferReady)
|
||
{
|
||
_tmInterLock.DoRectorAATMTransferReady = _pmInterLock.DoReactorATMTransferReady;
|
||
}
|
||
if (_tmInterLock.DoRectorAProcessTransferReady != _pmInterLock.DoReactorVACTransferReady)
|
||
{
|
||
_tmInterLock.DoRectorAProcessTransferReady = _pmInterLock.DoReactorVACTransferReady;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
private void MonitorUPSAlarm()
|
||
{
|
||
string sReason;
|
||
if (_upsPM1A != null && _upsPM1B != null && _pm1UPS != null)
|
||
{
|
||
bool _power = !(_upsPM1A.UPSPowerAlarm || _upsPM1B.UPSPowerAlarm);
|
||
bool _lowerBattery = !(_upsPM1A.UPSLowerBatteryAlarm || _upsPM1B.UPSLowerBatteryAlarm);
|
||
|
||
|
||
if (_pm1UPS.UPSEnable == _power)
|
||
{
|
||
//_pm1UPS.UPSEnable = _power;
|
||
_pm1UPS.SetUPSEnable(_power, out sReason);
|
||
}
|
||
if (_pm1UPS.UPSLowBattery == _lowerBattery)
|
||
{
|
||
//_pm1UPS.UPSLowBattery = _lowerBattery;
|
||
_pm1UPS.SetUPSLowBattery(_lowerBattery, out sReason);
|
||
}
|
||
}
|
||
|
||
}
|
||
|
||
private void MonitorAETemp()
|
||
{
|
||
if (_aeTemp != null && _pmAETemp != null)
|
||
{
|
||
string sReason;
|
||
if (!_aeTemp.IsConnected)
|
||
{
|
||
_pmAETemp.SetPyroCommunicationError(true, out sReason);
|
||
}
|
||
else
|
||
{
|
||
_pmAETemp.SetPyroCommunicationError(false, out sReason);
|
||
}
|
||
}
|
||
|
||
}
|
||
#endregion
|
||
}
|
||
}
|