RotarySystem.cs


using FLY.Thick.Blowing.RotaryMachine.IService;
using Newtonsoft.Json;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;

using WinderAccessory = FLY.DownBlowing.Common.WinderAccessory;

namespace FLY.DownBlowing.Server
{
    public class RotarySystem : IRotarySerivce
    {
        /// <summary>
        /// 方向相反
        /// </summary>
        public bool IsReversed { get; set; } = true;
        #region  状态
        /// <summary>
        /// 正方向运行 (逆时针旋转 counter-clockwise)
        /// </summary>
        public bool IsForw { get; set; }

        /// <summary>
        /// 反方向运行 （顺时针旋转 clockwise)
        /// </summary>
        public bool IsBackw { get; set; }

        /// <summary>
        /// 转向信号0 撞了它， 变为 正方向运行 
        /// </summary>
        public bool IsTurnSign0 { get; set; }

        /// <summary>
        /// 复位原点信号 (撞了它后， 证明在中间)
        /// </summary>
        public bool IsOrgSign { get; set; }

        /// <summary>
        /// 转向信号1 撞了它， 变为 反方向运行 
        /// </summary>
        public bool IsTurnSign1 { get; set; }

        /// <summary>
        /// 旋转塔电机频率设定(Hz)  就是速度 脉冲/秒
        /// </summary>
        public double RotaryFreqSet { get; set; }

        /// <summary>
        /// 旋转塔电机当前速度 脉冲/秒, +为正方向, -为反反向
        /// </summary>
        public double RSpeed { get; set; }

        /// <summary>
        /// 旋转塔顺时针换向信号发生时， 旋转架脉冲 （小值）
        /// </summary>
        public double RPosAtTurnSign0 { get; set; } = double.NaN;

        /// <summary>
        /// 旋转塔顺复位原点信号发生时， 旋转架脉冲 （中值）
        /// </summary>
        public double RPosAtOrgSign { get; set; } = double.NaN;

        /// <summary>
        /// 从换向信号1 到 原点信号, 灭到亮 发生时， 旋转架脉冲 （中值）
        /// </summary>
        public double RPosAtOrgSign1 { get; set; } = double.NaN;

        /// <summary>
        /// 旋转塔逆时针换向信号发生时， 旋转架脉冲（大值）
        /// </summary>
        public double RPosAtTurnSign1 { get; set; } = double.NaN;

        /// <summary>
        ///旋转架全局脉冲， 当前旋转架脉冲 = GlobalRPos - OrgRPos;
        /// </summary>
        public double RPosGlobal { get; set; } = 0;
        public double RPosOfR { get; set; } = 10000;

        public double Angle { get; set; }

        /// <summary>
        /// 旋转塔开启指示
        /// </summary>
        public bool IsRotaryOn { get; set; }

        /// <summary>
        /// 牵引速度显示(m/min)
        /// </summary>
        public double TractionVelocity { get; set; }
        #endregion

        public int TurnSign0Cnt { get; set; }

        public List<SignCell> Signs = new List<SignCell>();

        WinderAccessory winderAccessory;
        DispatcherTimer dispatcherTimer;
        Stopwatch stopwatch_rpos;

        public RotarySystem()
        {

        }
        public void Init(WinderAccessory _winderAccessory)
        {
            winderAccessory = _winderAccessory;

            if (!Load())
                Save();

            Misc.BindingOperations.SetBinding(winderAccessory, nameof(winderAccessory.T1Velocity), () =>
            {
                TractionVelocity = winderAccessory.T1Velocity;
            });

            Misc.BindingOperations.SetBinding(winderAccessory, nameof(winderAccessory.IsRotaryOn), this, nameof(IsRotaryOn));

            Misc.BindingOperations.SetBinding(winderAccessory,
                new string[]{
                nameof(winderAccessory.IsRotaryForw),
                nameof(winderAccessory.IsRotaryBackw),
                nameof(winderAccessory.IsRotaryForwTurn),
                nameof(winderAccessory.IsRotaryBackwTurn)},
                updateSign);

            Misc.BindingOperations.SetBinding(winderAccessory, nameof(winderAccessory.IsRotaryOrgSign), this, nameof(IsOrgSign));


            Misc.BindingOperations.SetBinding(winderAccessory, nameof(winderAccessory.RotaryFreqSet), () =>
            {
                RotaryFreqSet = winderAccessory.RotaryFreqSet;
            });

            Misc.BindingOperations.SetBinding(winderAccessory, nameof(winderAccessory.RotaryFreq), () =>
            {
                updateRSpeed();
            });

            this.PropertyChanged += RotarySystem_PropertyChanged;

            dispatcherTimer = new DispatcherTimer();
            dispatcherTimer.Interval = TimeSpan.FromSeconds(0.1);
            dispatcherTimer.Tick += DispatcherTimer_Tick;
            stopwatch_rpos = new Stopwatch();
        }
        void updateSign()
        {
            if (!IsReversed)
            {
                IsForw = winderAccessory.IsRotaryForw;
                IsBackw = winderAccessory.IsRotaryBackw;
                IsTurnSign0 = winderAccessory.IsRotaryForwTurn;
                IsTurnSign1 = winderAccessory.IsRotaryBackwTurn;
            }
            else
            {
                IsForw = winderAccessory.IsRotaryBackw;
                IsBackw = winderAccessory.IsRotaryForw;
                IsTurnSign0 = winderAccessory.IsRotaryBackwTurn;
                IsTurnSign1 = winderAccessory.IsRotaryForwTurn;
            }
        }
        void updateRSpeed()
        {
            if (IsForw)
            {
                RSpeed = winderAccessory.RotaryFreq;
            }
            else if (IsBackw)
            {
                RSpeed = -winderAccessory.RotaryFreq;
            }
            else
            {
                RSpeed = 0;
            }
        }
        private void DispatcherTimer_Tick(object sender, EventArgs e)
        {
            double totalSeconds = stopwatch_rpos.Elapsed.TotalSeconds;
            stopwatch_rpos.Restart();

            if (!IsBackw && !IsForw)
            {
                //没有运行
                return;
            }

            if (IsTurnSign0 || IsTurnSign1)
            {
                //转向信号触发时， 脉冲没有变化
                return;
            }
            RPosGlobal += RSpeed * totalSeconds;

            double p = RPosGlobal - RPosAtTurnSign0;

            Angle = 360 * (p - RPosOfR / 2) / RPosOfR;
        }

        public void StartMeasureRPos()
        {
            stopwatch_rpos.Restart();
            dispatcherTimer.Start();
        }
        public void StopMeasureRPos()
        {
            stopwatch_rpos.Stop();
            dispatcherTimer.Stop();
        }

        void AddSign(SignCell sign)
        {
            Signs.Insert(0, sign);
            while (Signs.Count > 100)
                Signs.RemoveAt(Signs.Count() - 1);
        }
        void AddSign(int no)
        {
            AddSign(new SignCell() { No = no, RPosGlobal = RPosGlobal, Time = DateTime.Now, RPos = RPosGlobal - RPosAtTurnSign0, RotaryFreqSet = RotaryFreqSet });
        }
        private void RotarySystem_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == nameof(IsReversed))
            {
                updateSign();
            }
            else if (e.PropertyName == nameof(IsTurnSign0))
            {
                if (IsTurnSign0)
                {
                    RPosAtTurnSign0 = RPosGlobal;
                    AddSign(0);
                    TurnSign0Cnt++;
                }
            }
            else if (e.PropertyName == nameof(IsTurnSign1))
            {
                if (IsTurnSign1)
                {
                    RPosAtTurnSign1 = RPosGlobal;
                    RPosOfR = RPosAtTurnSign1 - RPosAtTurnSign0;
                    AddSign(1);
                }
            }
            else if (e.PropertyName == nameof(IsOrgSign))
            {
                if (IsForw)
                {
                    if (IsOrgSign)
                    {
                        RPosAtOrgSign = RPosGlobal;
                        AddSign(20);
                    }
                    else
                    {
                        RPosAtOrgSign1 = RPosGlobal;
                        AddSign(21);
                    }
                }
                else if (IsBackw)
                {
                    if (IsOrgSign)
                    {
                        RPosAtOrgSign1 = RPosGlobal;
                        AddSign(21);
                    }
                    else if (!IsOrgSign)
                    {
                        RPosAtOrgSign = RPosGlobal;
                        AddSign(20);
                    }
                }
            }
            else if (e.PropertyName == nameof(IsForw))
            {
                updateRSpeed();
            }
            else if (e.PropertyName == nameof(IsBackw))
            {
                updateRSpeed();
            }
        }

        string filePath = "rotary.json";

        public event PropertyChangedEventHandler PropertyChanged;

        public bool Save()
        {
            return RotarySystemJsonDb.Save(this, filePath);
        }
        bool Load()
        {
            return RotarySystemJsonDb.Load(this, filePath);
        }
    }
    public class RotarySystemJsonDb
    {


        /// <summary>
        /// 加载历史数据
        /// </summary>
        /// <returns></returns>
        public static bool Load(RotarySystem src, string file_path)
        {
            if (File.Exists(file_path))
            {
                try
                {
                    string json = File.ReadAllText(file_path);
                    var jsonDb = JsonConvert.DeserializeObject<RotarySystemJsonDb>(json);
                    src.IsReversed = jsonDb.IsReversed;
                    return true;
                }
                catch
                {
                    //异常，没有json 解码失败

                }

            }
            return false;
        }

        /// <summary>
        /// 保存
        /// </summary>
        public static bool Save(RotarySystem src, string file_path)
        {
            try
            {
                var jsonDb = new RotarySystemJsonDb() { IsReversed = src.IsReversed };
                string json = JsonConvert.SerializeObject(jsonDb, Formatting.Indented);
                File.WriteAllText(file_path, json);
                return true;
            }
            catch
            {
                //异常，没有json 编码失败

            }
            return false;
        }

        public bool IsReversed = true;
    }

    public class SignCell : INotifyPropertyChanged
    {
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// 信号
        /// </summary>
        public int No { get; set; }

        /// <summary>
        /// 全局脉冲
        /// </summary>
        public double RPosGlobal { get; set; }

        /// <summary>
        /// 时间
        /// </summary>
        public DateTime Time { get; set; }

        /// <summary>
        /// 相对脉冲
        /// </summary>
        public double RPos { get; set; }

        /// <summary>
        /// 旋转频率设置Hz
        /// </summary>
        public double RotaryFreqSet { get; set; }
    }

}