ZZ-EFEM/Framework/SimulatorCore/RFMatchs/SimSerenRfMatch.cs

using MECF.Framework.Simulator.Core.Driver;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Timers;

namespace MECF.Framework.Simulator.Core.RFMatchs
{
    class SimSerenRfMatch : SerialPortDeviceSimulator
    {
        public bool Failed { get; set; }

        public bool IsOn { get; set; }

        public bool IsHalo { get; set; }

        public bool IsContinueAck { get; set; }

        Stopwatch _timer = new Stopwatch();

        private System.Timers.Timer _tick;
        Random _rd = new Random();

        private object _locker = new object();

        public string ResultValue { get; set; }

        public SimSerenRfMatch(string port)
            : base(port, -1, "\r", ' ', true)
        {
            ResultValue = "";

            _tick = new System.Timers.Timer();
            _tick.Interval = 200;

            _tick.Elapsed += _tick_Elapsed;
            _tick.Start();

        }

        private void _tick_Elapsed(object sender, ElapsedEventArgs e)
        {

            lock (_locker)
            {
                if (_timer.IsRunning && _timer.Elapsed > TimeSpan.FromSeconds(10))
                {
                    _timer.Stop();
                }
            }

        }

        List<byte> _cached = new List<byte>();

        private int _mode;
        private int _powerSetPoint;

        private bool _isLoadAuto;
        private bool _isTuneAuto;
        private int _tuneSetpoint;
        private int _loadSetpoint;
        private float _tunePreset;
        private float _loadPreset;

        private bool _presetEnable = true;

        protected override void ProcessUnsplitMessage(string message)
        {
            switch (message)
            {
                case "PHS\r":
                    OnWriteMessage("333\r");
                    return;
                case "QDP\r":
                    OnWriteMessage("-222\r");
                    return;
                case "QRP\r":
                    OnWriteMessage("-111\r");
                    return;
                case "MAG\r":
                    OnWriteMessage("555\r");
                    return;
                case "QPMD\r":
                    if (_presetEnable)
                        OnWriteMessage("1\r");
                    else
                    {
                        OnWriteMessage("0\r");
                    }
                    return;
                case "INT\r":
                    _presetEnable = true;
                    OnWriteMessage("\r");
                    return;
                case "OFF\r":
                    _presetEnable = false;
                    OnWriteMessage("\r");
                    return;

                case "QP1L\r":
                    OnWriteMessage($"{_loadPreset*10+1}\r");
                    return;

                case "QP1T\r":
                    OnWriteMessage($"{_tunePreset * 10+2}\r");
                    return;

            }
            if (message == "ALD\r")
            {
                _isLoadAuto = true;
                OnWriteMessage("\r");
                return;
            }

            if (message == "MLD\r")
            {
                _isLoadAuto = false;
                OnWriteMessage("\r");
                return;
            }

            if (message == "MTN\r")
            {
                _isTuneAuto = false;
                OnWriteMessage("\r");
                return;
            }

            if (message.Contains("MVLD"))
            {
                int.TryParse(message.Replace("MVLD", "").Replace("\r", "").Replace(" ", ""), out _loadSetpoint);
                OnWriteMessage("\r");
                return;
            }

            if (message.Contains("MVTN"))
            {
                int.TryParse(message.Replace("MVTN", "").Replace("\r", "").Replace(" ", ""), out _tuneSetpoint);
                OnWriteMessage("\r");
                return;
            }

            if (message == "ATN\r")
            {
                _isTuneAuto = true;
                OnWriteMessage("\r");
                return;
            }

            if (message.Contains("CPLP") || message.Contains("LPS?"))
            {
                OnWriteMessage($"{_loadSetpoint}\r");
                return;
            }

            if (message.Contains("CPTP") || message.Contains("TPS?"))
            {
                OnWriteMessage($"{_tuneSetpoint}\r");
                return;
            }

            if (message == ("QAML\r"))
            {
                if (_isLoadAuto)
                    OnWriteMessage("A\r");
                else
                {
                    OnWriteMessage("M\r");

                }
                return;
            }

            if (message == ("QAMT\r"))
            {
                if (_isLoadAuto)
                    OnWriteMessage("A\r");
                else
                {
                    OnWriteMessage("M\r");

                }
                return;
            }

            if (message.Contains("MPL"))
            {
                var paras = message.Split(' ');
                if (paras.Length > 1)
                {
                    float.TryParse(paras[0], out _loadPreset);
                }
                OnWriteMessage("\r");
            }

            if (message.Contains("MPT"))
            {
                var paras = message.Split(' ');
                if (paras.Length > 1)
                {
                    float.TryParse(paras[0], out _tunePreset);
                }
                OnWriteMessage("\r");
            }

            if (message.Contains("GOTO"))
            {
                _loadSetpoint = (int)_loadPreset;
                _tuneSetpoint = (int)_tunePreset;
                OnWriteMessage("\r");
            }

            OnWriteMessage("\r");
            return;


        }

        protected override void ProcessUnsplitMessage(byte[] message1)
        {
            _cached.AddRange(message1);

            if (_cached[0] == 0x06)
                _cached.RemoveAt(0);

            if (_cached.Count < 3)
                return;

            byte[] msgIn = _cached.ToArray();

            _cached.Clear();

            List<byte> lstAck = new List<byte>();
            lstAck.Add(0x06);



            switch (msgIn[1])
            {
                case 1:
                    IsOn = false;
                    break;
                case 2:
                    IsOn = true;
                    break;
                case 3: //reg mode
                    _mode = msgIn[2];
                    break;
                case 8:
                    _powerSetPoint = msgIn[2] + (msgIn[3] << 8);
                    break;
                case 155://mode comm
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], new byte[] { 0x8 });
                    break;
                case 162://status 
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], new byte[] { IsOn ? (byte)0x40 : (byte)0, 0, 0, 0 });
                    break;
                case 164: //setpoint
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], new byte[] { (byte)_powerSetPoint, (byte)(_powerSetPoint >> 8), (byte)_mode });
                    break;
                case 165: //forward
                    int forward = (int)(_powerSetPoint * 0.8);
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], new byte[] { (byte)forward, (byte)(forward >> 8) });
                    break;
                case 166: //reflect
                    int reflect = (int)(_powerSetPoint * 0.2);
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], new byte[] { (byte)reflect, (byte)(reflect >> 8) });
                    break;
                case 221://pin
                    List<byte> pin = new List<byte>();
                    for (int i = 0; i < 32; i++)
                    {
                        if (i == 20 && IsHalo)
                        {
                            pin.Add(0x31);
                            continue;
                        }
                        pin.Add(0);
                    }
                    //response = BuildMessage((byte)(msgIn[0] >> 3), msgIn[1], pin.ToArray());
                    break;
            }

            if (!IsContinueAck)
            {
                OnWriteMessage(lstAck.ToArray());
                //OnWriteMessage(response);
            }
            else
            {
                //lstAck.AddRange(response);
                OnWriteMessage(lstAck.ToArray());
            }


        }



    }
}