Virgo_ST/VirgoRT/Devices/RevtechMatch.cs

using System;
using System.Collections;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Text;
using System.Text.RegularExpressions;
using Aitex.Core.Common.DeviceData;
using Aitex.Core.RT.DataCenter;
using Aitex.Core.RT.Event;
using Aitex.Core.RT.IOCore;
using Aitex.Core.RT.Log;
using Aitex.Core.RT.OperationCenter;
using Aitex.Core.RT.SCCore;
using Aitex.Core.RT.Tolerance;
using Aitex.Core.Util;
using MECF.Framework.Common.Communications;
using MECF.Framework.Common.DataCenter;
using MECF.Framework.Common.Device.Bases;
using MECF.Framework.Common.Equipment;
using VirgoCommon;
using VirgoRT.Modules;

namespace VirgoRT.Devices
{
    static class RevtechMatchMessage
    {
        public const string QUERY_STATE_INFORMATION = "MATCH:FETCH?";
        public const string SET_C1_POS = "MATCH:POS:C1";
        public const string SET_C2_POS = "MATCH:POS:C2";
        public const string SET_WORK_MODE = "MATCH:MODE";
        public const string PRE_SET = "MATCH:PSET:SET 00";
    }
    public enum MatchCommunicationType
    {
        RS232,
        Ethernet
    }
    public abstract class RevtechMatch : RfMatchBase
    {
        private readonly DeviceTimer _timerQueryStatus = new DeviceTimer();
        private int QUERY_INTERVAL = 1000;
        private Dictionary<string, string> _modeMap = new Dictionary<string, string>() {
            {"Preset", EnumRfMatchTuneMode.Auto.ToString() },
            {"Hold",EnumRfMatchTuneMode.Manual.ToString() }
        };
        [Subscription("MatchWorkMode")]
        public EnumRfMatchTuneMode WorkMode { get; set; }
        public float C1 { get; set; }
        public float C2 { get; set; }

        [Subscription("VPP")]
        public ushort VPP { get; set; }

        public override AITRfMatchData DeviceData
        {
            get
            {
                return new AITRfMatchData
                {
                };
            }
        }

        public RevtechMatch(ModuleName mod, string name, string configName = "") : base(mod.ToString(), name)
        {
            
        }

        public override bool Initialize()
        {
            base.Initialize();

            DATA.Subscribe($"{Module}.{Name}.C1", () => TunePosition1);
            DATA.Subscribe($"{Module}.{Name}.C2", () => TunePosition2);
            DATA.Subscribe($"{Module}.{Name}.MatchProcessMode", () => (int)WorkMode);

            OP.Subscribe($"{Module}.{Name}.SetC1", (func, args) =>
            {
                return true;
            });
            OP.Subscribe($"{Module}.{Name}.SetC2", (func, args) =>
            {
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetMatchPositionC1}", (out string reason, int time, object[] param) =>
            {
                SetMatchPositionC1((float)Convert.ToDouble(param[0]), out reason);
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetMatchPositionC2}", (out string reason, int time, object[] param) =>
            {
                SetMatchPositionC2((float)Convert.ToDouble(param[0]), out reason);
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetMatchPosition}", (out string reason, int time, object[] param) =>
            {
                SetMatchPosition((float)Convert.ToDouble(param[0]), (float)Convert.ToDouble(param[1]), out reason);
                return true;
            });

            OP.Subscribe($"{Module}.{Name}.{AITRfOperation.SetMatchProcessMode}", (out string reason, int time, object[] param) =>
            {
                var mode = EnumRfMatchTuneMode.Auto.ToString();
                if (_modeMap.ContainsKey((string)param[0]))
                    mode = _modeMap[(string)param[0]];
                SetMatchMode(mode, out reason);
                return true;
            });

            _timerQueryStatus.Start(QUERY_INTERVAL);
            return true;
        }

        public override void Monitor()
        {
            try
            {
                if (_timerQueryStatus.IsTimeout())
                {
                    this.SendCmd(RevtechMatchMessage.QUERY_STATE_INFORMATION);
                    _timerQueryStatus.Start(QUERY_INTERVAL);
                }
            }
            catch (Exception ex)
            {
                LOG.Write(ex);
            }
        }

        public override void Terminate()
        {
        }

        public override void Reset()
        {
        }

        public override void SetMatchPosition(float c1, float c2, out string reason)
        {
            reason = "";
            base.SetMatchPosition(c1, c2, out reason);
            ExecuteMatchPostion(c1, c2);
        }

        public override bool SetMatchMode(string mode, out string reason)
        {
            reason = string.Empty;
            if (mode == EnumRfMatchTuneMode.Manual.ToString())
                SetWorkMode(EnumRfMatchTuneMode.Manual);
            else
                SetWorkMode(EnumRfMatchTuneMode.Auto);
            return true;
        }

        public override void SetMatchPositionC1(float c1, out string reason)
        {
            reason = string.Empty;
            LoadPosition1 = c1;
            base.SetMatchPositionC1(c1, out reason);
            ushort val1 = (ushort)(c1);
            SendCmd(RevtechMatchMessage.SET_C1_POS + $" {val1.ToString("X3")}");
        }

        public override void SetMatchPositionC2(float c2, out string reason)
        {
            reason = string.Empty;
            LoadPosition2 = c2;
            base.SetMatchPositionC2(c2,out reason);
            ushort val2 = (ushort)(c2);
            SendCmd(RevtechMatchMessage.SET_C2_POS + $" {val2.ToString("X3")}");
        }

        private void ExecuteMatchPostion(float c1, float c2)
        {
            SetPosition(c1, c2);
        }

        private void SetPosition(float c1val, float c2val)
        {
            LoadPosition1 = c1val;
            LoadPosition2 = c2val;
            ushort val1 = (ushort)(c1val);
            ushort val2 = (ushort)(c2val);
            SendCmd(RevtechMatchMessage.SET_C1_POS + $" {val1.ToString("X3")}");
            SendCmd(RevtechMatchMessage.SET_C2_POS + $" {val2.ToString("X3")}");
        }

        private void SetWorkMode(EnumRfMatchTuneMode mode)
        {
            if (mode == EnumRfMatchTuneMode.Auto)
            {
                SendCmd("MATCH:MODE HAUTO");
            }
            else if (mode == EnumRfMatchTuneMode.Manual)
            {
                SendCmd("MATCH:MODE MANUAL");
            }
        }

        protected virtual void SendCmd(string str)
        {
            if (!str.Contains(RevtechMatchMessage.QUERY_STATE_INFORMATION))
            {
                LOG.Write($"{Module} {Name} Revtech match send {str}");
            }
        }
    }
}