using System; using System.Collections.Generic; using System.IO.Ports; using Aitex.Core.Common.DeviceData; using Aitex.Core.RT.DataCenter; using Aitex.Core.RT.Event; using Aitex.Core.RT.Log; using Aitex.Core.RT.OperationCenter; using Aitex.Core.RT.SCCore; using Aitex.Core.Util; using MECF.Framework.Common.Communications; using MECF.Framework.Common.Device.Bases; namespace MECF.Framework.RT.EquipmentLibrary.HardwareUnits.RFMatchs.Serens { public class SerenRfMatch : RfMatchBase { public override EnumRfMatchTuneMode TuneMode1 { get; set; } public override EnumRfMatchTuneMode TuneMode2 { get; set; } public EnumRfMatchTuneMode LoadMode1 { get; set; } public EnumRfMatchTuneMode LoadMode2 { get; set; } public override float LoadPosition1 { get; set; } public override float LoadPosition2 { get; set; } public override float TunePosition1 { get; set; } public bool Connect() { return _connection.Connect(); } public bool Disconnect() { return _connection.Disconnect(); } public override bool IsConnected => Connection != null && Connection.IsConnected && !_connection.IsCommunicationError; public override AITRfMatchData DeviceData { get { AITRfMatchData data = new AITRfMatchData() { DeviceName = Name, DeviceSchematicId = DeviceID, DisplayName = Display, LoadPosition1 = LoadPosition1, LoadPosition2 = LoadPosition2, LoadPosition1SetPoint = LoadPosition1Setpoint, TunePosition1 = TunePosition1, TunePosition2 = TunePosition2, TunePosition1SetPoint = TunePosition1Setpoint, TuneMode1 = TuneMode1, TuneMode2 = TuneMode2, BiasPeak = BiasPeak, DCBias = DCBias, }; return data; } } public override bool IsStable { get { if (_scStableCriteria == null || _scStableCriteria.DoubleValue == 0) return false; if (LoadPosition1Setpoint == 0 || TunePosition1Setpoint == 0) return true; if (100 * LoadPosition1 / LoadPosition1Setpoint < _scStableCriteria.DoubleValue) _stableTimer.Stop(); if (100 * TunePosition1 / TunePosition1Setpoint < _scStableCriteria.DoubleValue) _stableTimer.Stop(); if (_stableTimer.IsIdle() && 100 * TunePosition1 / TunePosition1Setpoint >= _scStableCriteria.DoubleValue && 100 * LoadPosition1 / LoadPosition1Setpoint >= _scStableCriteria.DoubleValue) _stableTimer.Start(_stableTime * 1000); return _stableTimer.IsTimeout(); } } public SerenRfMatchConnection Connection { get { return _connection; } } private SerenRfMatchConnection _connection; private EnumRfMatchTuneMode _tuneMode1; private EnumRfMatchTuneMode _tuneMode2; private RD_TRIG _trigRfOnOff = new RD_TRIG(); private R_TRIG _trigError = new R_TRIG(); private R_TRIG _trigWarningMessage = new R_TRIG(); private R_TRIG _trigCommunicationError = new R_TRIG(); private R_TRIG _trigRetryConnect = new R_TRIG(); private PeriodicJob _thread; private LinkedList _executionHandler = new LinkedList(); private LinkedList _idleHandler = new LinkedList(); private object _locker = new object(); private bool _enableLog = true; public int MagnitudeError { get; set; } public int PhaseError { get; set; } public int DCVoltage { get; set; } public int RFVoltage { get; set; } public string MatchType { get; set; } //ATS or MC2 private string _scRoot; private bool _isPresetEnabled; private float _loadPresetPosition; private float _tunePresetPosition; public SerenRfMatch(string module, string name, string scRoot, string type = "ATS") : base(module, name) { MatchType = type; _scRoot = scRoot; } public bool Initialize(string portName, int baudRate = 9600, int dataBits = 8, Parity parity = Parity.None, StopBits stopBits = StopBits.One) { base.Initialize(); _enableLog = true; _connection = new SerenRfMatchConnection(portName, baudRate, dataBits, parity, stopBits); _connection.EnableLog(_enableLog); if (_connection.Connect()) { EV.PostInfoLog(Module, $"{Module}.{Name} connected"); InitStatus(); } _thread = new PeriodicJob(100, OnTimer, $"{Module}.{Name} MonitorHandler", true); return true; } public override bool Initialize() { base.Initialize(); string portName = SC.GetStringValue($"{_scRoot}.Address"); int bautRate = SC.GetValue($"{_scRoot}.BaudRate"); int dataBits = SC.GetValue($"{_scRoot}.DataBits"); Enum.TryParse(SC.GetStringValue($"{_scRoot}.Parity"), out Parity parity); Enum.TryParse(SC.GetStringValue($"{_scRoot}.StopBits"), out StopBits stopBits); _enableLog = SC.GetValue($"{_scRoot}.EnableLogMessage"); _connection = new SerenRfMatchConnection(portName, bautRate, dataBits, parity, stopBits); _connection.EnableLog(_enableLog); if (_connection.Connect()) { EV.PostInfoLog(Module, $"{Module}.{Name} connected"); InitStatus(); } DATA.Subscribe($"{Module}.{Name}.IsConnected", () => IsConnected); DATA.Subscribe($"{Module}.{Name}.Address", () => SC.GetStringValue($"{_scRoot}.Address")); DATA.Subscribe($"{Module}.{Name}.MagnitudeError", () => MagnitudeError); DATA.Subscribe($"{Module}.{Name}.PhaseError", () => PhaseError); DATA.Subscribe($"{Module}.{Name}.DCVoltage", () => DCVoltage); DATA.Subscribe($"{Module}.{Name}.RFVoltage", () => RFVoltage); DATA.Subscribe($"{Module}.{Name}.IsPresetEnable", () => _isPresetEnabled); DATA.Subscribe($"{Module}.{Name}.LoadPresetPosition", () => _loadPresetPosition); DATA.Subscribe($"{Module}.{Name}.TunePresetPosition", () => _tunePresetPosition); OP.Subscribe($"{Module}.{Name}.MatchEnablePreset", (out string reason, int time, object[] args) => { reason = ""; bool enable = Convert.ToBoolean(args[0]); string text = enable ? "enable" : "disable"; if (!PerformMatchMode1EnablePreset(out reason, time, enable)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not {text} preset mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} {text} match preset mode"); return true; }); OP.Subscribe($"{Module}.{Name}.MatchMode1", (out string reason, int time, object[] args) => { reason = ""; if (!Enum.TryParse((string)args[0], out EnumRfMatchTuneMode mode)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not mode, {args[0]} is not a valid mode value"); return false; } if (!PerformMatchMode1(out reason, time, mode)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match mode1 to {mode}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchLoad1", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); if (!PerformSetMatchLoad1(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match load1 to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchLoadPresetPosition", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); SC.SetItemValue($"{Module}.{Name}.MatchLoadPresetPosition", value); if (!PerformSetMatchLoadPresetPosition(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set preset load position, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match load preset position to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchTunePresetPosition", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); SC.SetItemValue($"{Module}.{Name}.MatchTunePresetPosition", value); if (!PerformSetMatchTunePresetPosition(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set preset tune position, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match tune preset position to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchTune1", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); if (!PerformSetMatchTune1(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match tune1 to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.MatchMode2", (out string reason, int time, object[] args) => { reason = ""; if (!Enum.TryParse((string)args[0], out EnumRfMatchTuneMode mode)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not mode, {args[0]} is not a valid mode value"); return false; } if (!PerformMatchMode2(out reason, time, mode)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match mode2 to {mode}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchLoad2", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); if (!PerformSetMatchLoad2(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match load2 to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.SetMatchTune2", (out string reason, int time, object[] args) => { reason = ""; float value = Convert.ToSingle((string)args[0]); if (!PerformSetMatchTune2(out reason, time, value)) { EV.PostAlarmLog(Module, $"{Module}.{Name} Can not set mode, {reason}"); return false; } EV.PostInfoLog(Module, $"{Module}.{Name} set match tune2 to {value}"); return true; }); OP.Subscribe($"{Module}.{Name}.Reconnect", (string cmd, object[] args) => { Disconnect(); Reset(); Connect(); return true; }); _thread = new PeriodicJob(300, OnTimer, $"{Module}.{Name} MonitorHandler", true); return true; } private bool OnTimer() { try { _connection.MonitorTimeout(); if (!_connection.IsConnected || _connection.IsCommunicationError) { lock (_locker) { _executionHandler.Clear(); _idleHandler.Clear(); } _trigRetryConnect.CLK = !_connection.IsConnected; if (_trigRetryConnect.Q) { _connection.SetPortAddress(SC.GetStringValue($"{ScBasePath}.{Name}.Address")); if (!_connection.Connect()) { EV.PostAlarmLog(Module, $"Can not connect with {_connection.Address}, {Module}.{Name}"); } } return true; } HandlerBase handler = null; if (!_connection.IsBusy) { lock (_locker) { if (_executionHandler.Count == 0) { if (_idleHandler.Count == 0) { _idleHandler.AddLast(new SerenRfMatchGetMagnitudeErrorHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetPhaseErrorHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetDCVoltageHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetRFVoltageHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetTunePositionHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetLoadPositionHandler(this)); _idleHandler.AddLast(new SerenRfMatchGetTuneControlModeHandler(this)); } else { handler = _idleHandler.First.Value; _idleHandler.RemoveFirst(); } } else { handler = _executionHandler.First.Value; _executionHandler.RemoveFirst(); } } if (handler != null) { _connection.Execute(handler); } } } catch (Exception ex) { LOG.Write(ex); } return true; } public override void Monitor() { try { _connection.EnableLog(_enableLog); _trigCommunicationError.CLK = _connection.IsCommunicationError; if (_trigCommunicationError.Q) { EV.PostAlarmLog(Module, $"{Module}.{Name} communication error, {_connection.LastCommunicationError}"); } } catch (Exception ex) { LOG.Write(ex); } } public override void Reset() { _trigError.RST = true; _trigWarningMessage.RST = true; _connection.SetCommunicationError(false, ""); _trigCommunicationError.RST = true; _enableLog = SC.GetValue($"{_scRoot}.EnableLogMessage"); _trigRetryConnect.RST = true; base.Reset(); } internal void NoteError(string reason) { _trigWarningMessage.CLK = true; if (_trigWarningMessage.Q) { EV.PostWarningLog(Module, $"{Module}.{Name} error, {reason}"); } } internal void NoteLoadControlMode(bool isAuto) { LoadMode1 = isAuto ? EnumRfMatchTuneMode.Auto : EnumRfMatchTuneMode.Manual; } internal void NotePresetMode(string mode) { _isPresetEnabled = mode == "1"; } internal void NoteTuneControlMode(bool isAuto) { TuneMode1 = isAuto ? EnumRfMatchTuneMode.Auto : EnumRfMatchTuneMode.Manual; } internal void NoteLoadPosition(float position) { LoadPosition1 = position; } internal void NoteTunePosition(float position) { TunePosition1 = position; } internal void NoteLoadPresetPosition(float position) { _loadPresetPosition = position; } internal void NoteTunePresetPosition(float position) { _tunePresetPosition = position; } internal void NoteMagnitudeError(int error) { MagnitudeError = error; } internal void NotePhaseError(int error) { PhaseError = error; } internal void NoteDCVoltage(int voltage) { DCVoltage = voltage; } internal void NoteRFVoltage(int voltage) { RFVoltage = voltage; } private bool PerformSetMatchTune1(out string reason, int time, float value) { reason = string.Empty; return true; } private bool PerformSetMatchLoad1(out string reason, int time, float value) { reason = string.Empty; return true; } private bool PerformSetMatchLoadPresetPosition(out string reason, int time, float value) { reason = string.Empty; lock (_locker) { _executionHandler.AddLast(new SerenRfMatchSetLoadPreset1PositionHandler(this, value)); _executionHandler.AddLast(new SerenRfMatchGetLoadPreset1PositionHandler(this)); } return true; } private bool PerformSetMatchTunePresetPosition(out string reason, int time, float value) { reason = string.Empty; lock (_locker) { _executionHandler.AddLast(new SerenRfMatchSetTunePreset1PositionHandler(this, value)); _executionHandler.AddLast(new SerenRfMatchGetTunePreset1PositionHandler(this)); } return true; } private bool PerformMatchMode1(out string reason, int time, EnumRfMatchTuneMode mode) { SetLoadMode1(mode); SetTuneMode1(mode); reason = string.Empty; return true; } private bool PerformMatchMode1EnablePreset(out string reason, int time, bool enable) { reason = string.Empty; lock (_locker) { _executionHandler.AddLast(new SerenRfMatchEnablePresetHandler(this, enable)); _executionHandler.AddLast(new SerenRfMatchGetPresetHandler(this)); } return true; } private bool PerformMatchMode2(out string reason, int time, EnumRfMatchTuneMode mode) { reason = string.Empty; return true; } private bool PerformSetMatchLoad2(out string reason, int time, float value) { reason = string.Empty; return true; } private bool PerformSetMatchTune2(out string reason, int time, float value) { reason = string.Empty; return true; } public void InitStatus() { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchGetPresetHandler(this)); _executionHandler.AddLast(new SerenRfMatchGetTuneControlModeHandler(this)); _executionHandler.AddLast(new SerenRfMatchGetTunePreset1PositionHandler(this)); _executionHandler.AddLast(new SerenRfMatchGetLoadPreset1PositionHandler(this)); } } public override void EnablePreset1(bool enable) { PerformMatchMode1EnablePreset(out _, 0, enable); } public override void SetLoadMode1(EnumRfMatchTuneMode mode) { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchSetLoadControlModeHandler(this, mode == EnumRfMatchTuneMode.Auto)); } } public override void SetTuneMode1(EnumRfMatchTuneMode mode) { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchSetTuneControlModeHandler(this, mode == EnumRfMatchTuneMode.Auto)); _executionHandler.AddLast(new SerenRfMatchGetTuneControlModeHandler(this)); } } public override void SetLoadPresetPosition(float position) { PerformSetMatchLoadPresetPosition(out _, 0, position); } public override void SetTunePresetPosition(float position) { PerformSetMatchTunePresetPosition(out _, 0, position); } public override void SetLoad1(float position) { LoadPosition1Setpoint = position; lock (_locker) { if (MatchType == "ATS") { //_lstHandler.AddLast(new SerenRfMatchSetLoadControlModeHandler(this, false)); _executionHandler.AddLast(new SerenRfMatchSetLoadPositionHandler(this, position)); } else { // _lstHandler.AddLast(new SerenRfMatchSetLoadControlModeHandler(this, false)); _executionHandler.AddLast(new SerenRfMatchSetLoadPreset1PositionHandler(this, position)); _executionHandler.AddLast(new SerenRfMatchGotoHandler(this)); } } } public override void SetTune1(float position) { TunePosition1Setpoint = position; lock (_locker) { if (MatchType == "ATS") { // _lstHandler.AddLast(new SerenRfMatchSetTuneControlModeHandler(this, false)); _executionHandler.AddLast(new SerenRfMatchSetTunePositionHandler(this, position)); } else { // _lstHandler.AddLast(new SerenRfMatchSetTuneControlModeHandler(this, false)); _executionHandler.AddLast(new SerenRfMatchSetTunePreset1PositionHandler(this, position)); _executionHandler.AddLast(new SerenRfMatchGotoHandler(this)); } } } public void GetTune1() { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchGetTunePositionHandler(this)); } } public void GetLoad1() { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchGetLoadPositionHandler(this)); } } public void GetLoad1Mode() { lock (_locker) { _executionHandler.AddLast(new SerenRfMatchGetLoadControlModeHandler(this)); } } } }