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; }
        /// <summary>
        /// 最小一圈脉冲
        /// </summary>
        const int MinRPosOfR = 8000;



        #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>
        /// 1圈分钟数 RPosOfR/RSpeed/60.0
        /// </summary>
        public double MinuteOfR { get; set; } = double.NaN;

        /// <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; } = MinRPosOfR;

        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; }

        /// <summary>
        /// PLC的方向 寄存器 IsForw IsBackw 接反了
        /// </summary>
        public bool IsPlcRegDirectionError { get; set; }


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

        WinderAccessory winderAccessory;
        DispatcherTimer dispatcherTimer;
        Stopwatch stopwatch_rpos;
        double rposOfRInFile;

        //数据是真实的
        bool isReal_RPosAtTurnSign0 = false;
        bool isReal_RPosAtOrgSign = false;
        bool isReal_RPosAtTurnSign1 = false;
        bool isCurrentForw;

        public RotarySystem()
        {

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

            if (!Load())
                Save();

            rposOfRInFile = LoadRPosOfR();
            if (double.IsNaN(rposOfRInFile))
            {
                rposOfRInFile = 14000;
                SaveRPosOfR(rposOfRInFile);
            }

            if (!double.IsNaN(rposOfRInFile) && rposOfRInFile > MinRPosOfR)
                RPosOfR = rposOfRInFile;

            RPosAtOrgSign = 0;
            RPosAtTurnSign0 = -RPosOfR / 2;
            RPosAtTurnSign1 = RPosOfR / 2;


            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;
            });

            updateMinuteOfR();
            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 (!IsRotaryOn)
            {
                RSpeed = 0;
                return;
            }

            if (IsForw)
            {
                isCurrentForw = true;
                RSpeed = RotaryFreqSet;
            }
            else if (IsBackw)
            {
                isCurrentForw = false;
                RSpeed = -RotaryFreqSet;
            }
            else
            {
                RSpeed = 0;
            }
        }
        void updateMinuteOfR()
        {
            if (RotaryFreqSet > 0 && RPosOfR >= MinRPosOfR)
            {
                MinuteOfR = RPosOfR / RotaryFreqSet / 60;
            }
            else
            {
                MinuteOfR = double.NaN;
            }
        }
        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 updateRPosOfR()
        {
            double rposOfR = (int)(RPosAtTurnSign1 - RPosAtTurnSign0);
            if (!double.IsNaN(rposOfRInFile))
            {
                if (Math.Abs(rposOfRInFile - rposOfR) > 100)
                {
                    //变化量大于1°保存
                    rposOfRInFile = rposOfR;
                    SaveRPosOfR(rposOfRInFile);
                }
            }
            else
            {
                rposOfRInFile = rposOfR;
                SaveRPosOfR(rposOfRInFile);
            }

            RPosOfR = rposOfR;
        }
        void updateRPosAtTurnSign0()
        {
            RPosAtTurnSign0 = RPosGlobal;
            isReal_RPosAtTurnSign0 = true;

            if (isReal_RPosAtTurnSign1)
            {
                updateRPosOfR();
            }

            //-------------------------------------------------------------
            //位置预测
            if (!isReal_RPosAtTurnSign1)
            {
                if (!isReal_RPosAtOrgSign)//原点信号 还没发生
                {
                    RPosAtOrgSign = RPosAtTurnSign0 + RPosOfR / 2;
                }
                else //原点信号 发生了
                {
                    RPosOfR = (RPosAtOrgSign - RPosAtTurnSign0) * 2;
                }
                RPosAtTurnSign1 = RPosAtTurnSign0 + RPosOfR;
            }
            //-------------------------------------------------------------

            AddSign(0);
            TurnSign0Cnt++;
        }
        void updateRPosAtTurnSign1()
        {
            RPosAtTurnSign1 = RPosGlobal;
            isReal_RPosAtTurnSign1 = true;

            if (isReal_RPosAtTurnSign0)
            {
                updateRPosOfR();
            }

            //-------------------------------------------------------------
            //位置预测
            if (!isReal_RPosAtTurnSign0)
            {
                if (!isReal_RPosAtOrgSign)//原点信号 还没发生
                {
                    RPosAtOrgSign = RPosAtTurnSign1 - RPosOfR / 2;
                }
                else //原点信号 发生了
                {
                    RPosOfR = (RPosAtTurnSign1 - RPosAtOrgSign) * 2;
                }
                RPosAtTurnSign0 = RPosAtTurnSign1 - RPosOfR;
            }
            //-------------------------------------------------------------

            AddSign(1);
        }


        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)
                {
                    if (!isCurrentForw)
                    {
                        //这是对的
                        IsPlcRegDirectionError = false;
                        updateRPosAtTurnSign0();
                    }
                    else
                    {
                        //只是错的， 肯定是 方向寄存器 与 转向信号反了
                        IsPlcRegDirectionError = true;

                        //只是临时的将就
                        updateRPosAtTurnSign1();
                    }
                }
            }
            else if (e.PropertyName == nameof(IsTurnSign1))
            {
                if (IsTurnSign1)
                {
                    if (isCurrentForw)
                    {
                        //这是对的
                        IsPlcRegDirectionError = false;
                        updateRPosAtTurnSign1();
                    }
                    else
                    {
                        //只是错的， 肯定是 方向寄存器 与 转向信号反了
                        IsPlcRegDirectionError = true;

                        //只是临时的将就
                        updateRPosAtTurnSign0();
                    }
                }
            }
            else if (e.PropertyName == nameof(IsOrgSign))
            {
                if (IsForw)
                {
                    if (IsOrgSign)
                    {
                        RPosAtOrgSign = RPosGlobal;
                        isReal_RPosAtOrgSign = true;
                        AddSign(20);
                    }
                    else
                    {
                        RPosAtOrgSign1 = RPosGlobal;
                        if (!isReal_RPosAtOrgSign)
                        {
                            RPosAtOrgSign = RPosGlobal;
                            isReal_RPosAtOrgSign = true;
                        }
                        AddSign(21);
                    }
                }
                else if (IsBackw)
                {
                    if (IsOrgSign)
                    {
                        RPosAtOrgSign1 = RPosGlobal;
                        if (!isReal_RPosAtOrgSign)
                        {
                            RPosAtOrgSign = RPosGlobal;
                            isReal_RPosAtOrgSign = true;
                        }
                        AddSign(21);
                    }
                    else if (!IsOrgSign)
                    {
                        RPosAtOrgSign = RPosGlobal;
                        isReal_RPosAtOrgSign = true;
                        AddSign(20);
                    }
                }
                else
                {
                    if (IsOrgSign)
                    {
                        //现在既不是正向，也不是反向,停机复位状态

                        if (!isReal_RPosAtOrgSign)
                        {
                            RPosAtOrgSign = RPosGlobal;
                            isReal_RPosAtOrgSign = true;
                        }
                    }
                }

                //-------------------------------------------------------------
                //位置预测
                if (isReal_RPosAtOrgSign)//有复位信号
                {
                    if (!isReal_RPosAtTurnSign0 && !isReal_RPosAtTurnSign1)//信号0，信号1 都还没发生
                    {
                        RPosAtTurnSign0 = RPosAtOrgSign - RPosOfR / 2;
                        RPosAtTurnSign1 = RPosAtTurnSign0 + RPosOfR;
                    }
                    else if (isReal_RPosAtTurnSign0 && !isReal_RPosAtTurnSign1) //信号0 发生了，信号1 还没发生
                    {
                        RPosOfR = (RPosAtOrgSign - RPosAtTurnSign0) * 2;
                        RPosAtTurnSign1 = RPosAtTurnSign0 + RPosOfR;
                    }
                    else if (!isReal_RPosAtTurnSign0 && isReal_RPosAtTurnSign1) //信号0 还没发生，信号1 发生了
                    {
                        RPosOfR = (RPosAtOrgSign - RPosAtTurnSign0) * 2;
                        RPosAtTurnSign0 = RPosAtTurnSign1 - RPosOfR;
                    }
                }
                //-------------------------------------------------------------
            }
            else if (e.PropertyName == nameof(IsForw))
            {
                updateRSpeed();
            }
            else if (e.PropertyName == nameof(IsBackw))
            {
                updateRSpeed();
            }
            else if (e.PropertyName == nameof(RPosOfR))
            {
                updateMinuteOfR();
            }
            else if (e.PropertyName == nameof(RotaryFreqSet))
            {
                updateMinuteOfR();
                updateRSpeed();
            }
            else if (e.PropertyName == nameof(IsRotaryOn)) {
                updateRSpeed(); 
            }
        }

        string filePath = "rotary.json";

        public event PropertyChangedEventHandler PropertyChanged;

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

        void SaveRPosOfR(double rposOfR)
        {
            string file_path = "RPosOfR.json";
            try
            {
                string json = JsonConvert.SerializeObject(rposOfR, Formatting.Indented);
                File.WriteAllText(file_path, json);

            }
            catch
            {
                //异常，没有json 编码失败

            }
        }
        double LoadRPosOfR()
        {
            string file_path = "RPosOfR.json";

            if (File.Exists(file_path))
            {
                try
                {
                    string json = File.ReadAllText(file_path);
                    return JsonConvert.DeserializeObject<double>(json);
                }
                catch
                {
                    //异常，没有json 解码失败

                }

            }
            return double.NaN;
        }
    }
    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;
    }

    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; }
    }


}