LimitCellCollection.cs

using FLY.Thick.Blowing.IService;
using Misc;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace FLY.Thick.Blowing.Server
{
    /// <summary>
    /// 处理转向信号
    /// </summary>
    public class LimitCellCollection:INotifyPropertyChanged
    {
        #region MARKNO
        const int MARKNO_DELAY0 = 1;
        const int MARKNO_DELAY1 = 2;
        #endregion


        /// <summary>
        /// 正反信号滤波时间 150ms
        /// </summary>
        const int SIGN_DELAY_MS = 150;

        #region 参数
        /// <summary>
        /// 转向信号100ms 滤波
        /// </summary>
        public bool IsSignFilter { get; set; }
        /// <summary>
        /// 缺少信号模式
        /// 正反信号线接得不好，有时候会丢失了。 
        /// 当前的旋转时间是上一次的1.1倍时，在以前的位置增加信号！！！！
        /// 当有连续两次相同的信号，且信号差刚好是旋转时间的1.9~2.1倍时，证明真的是缺少信号
        /// </summary>
        public bool IsLackSignMode { get; set; }

        /// <summary>
        /// 信号模式， 短信号模式（只撞一下），长信号模式（只要是转着，信号就长亮，直到换向）
        /// </summary>
        public BlowingSignType SignType { get; set; } = BlowingSignType.Short;

        /// <summary>
        /// 信号0 撞2次。 这个能自动设置。 两个撞同一信号 间隔30秒内，算一个换向信号。 
        /// 旋转架快过头，冲过了转向开关，转向开关回弹了， 旋转架回来时，再撞转向开关肯定是在第1次撞的开始位置。
        /// 当为2次撞时：  StartTime = 第1次撞的StartTime， EndTime = 第2次撞的StartTime
        /// </summary>
        public bool IsSign0Double { get; set; }

        /// <summary>
        /// 信号1 撞2次。 这个能自动设置。
        /// </summary>
        public bool IsSign1Double { get; set; }


        public TimeSpan DefaultRPeriod { get; set; } = TimeSpan.FromMinutes(8);


        #endregion

        /// <summary>
        /// 离开限位 到 撞下一个限位  的 旋转架转动时间， 需要初始值，以后测量出来的
        /// </summary>
        public TimeSpan RenZiJiaPeriod { get; private set; } = TimeSpan.FromMinutes(8);

        /// <summary>
        /// 撞限位 到 离开限位 的时间， 需要初始值，以后测量出来的
        /// </summary>
        public TimeSpan LimitSignTime { get; private set; } = TimeSpan.FromSeconds(4);


        /// <summary>
        /// 转向信号列表
        /// </summary>
        public RList<LimitCell> mLimitList { get; private set; }
        public event Action<LimitCell> AddEvent;
        public event PropertyChangedEventHandler PropertyChanged;

        /// <summary>
        /// 还没处理的信号0 列表
        /// </summary>
        List<SignData> mSign0ListNoJudge = new List<SignData>();

        /// <summary>
        /// 还没处理的信号1 列表
        /// </summary>
        List<SignData> mSign1ListNoJudge = new List<SignData>();

        public LimitCellCollection()
        {
            mLimitList = new Misc.RList<LimitCell>(20);//人字架转10次的信号
            Misc.BindingOperations.SetBinding(this, nameof(DefaultRPeriod), this, nameof(RenZiJiaPeriod));
        }

        public void Clear() 
        {

            mLimitList.Clear();
            mSign0ListNoJudge.Clear();
            mSign1ListNoJudge.Clear();

            RenZiJiaPeriod = DefaultRPeriod;
            LimitSignTime = TimeSpan.FromSeconds(4);
        }
        public void AddLimit(SignData sd)
        {
            int no = sd.No;
            if (IsSignFilter)
            {
                //信号滤波
                if (no == 0)
                {
                    mSign0ListNoJudge.Add(sd);
                    //等100ms再触发
                    FObjBase.PollModule.Current.Poll_Config(FObjBase.PollModule.POLL_CONFIG.ADD,
                        () =>
                        {
                            PopSign(0);
                        },
                        TimeSpan.FromMilliseconds(SIGN_DELAY_MS), true, false, this, MARKNO_DELAY0, true);
                }
                else
                {
                    mSign1ListNoJudge.Add(sd);
                    //等100ms再触发
                    FObjBase.PollModule.Current.Poll_Config(FObjBase.PollModule.POLL_CONFIG.ADD,
                        () =>
                        {
                            PopSign(1);
                        },
                        TimeSpan.FromMilliseconds(SIGN_DELAY_MS), true, false, this, MARKNO_DELAY1, true);
                }
            }
            else
            {
                update_limit(sd);
            }
        }

        public void OnPoll()
        {

            //--------------------------------------------------------------------
            //添加虚拟信号
            if (IsLackSignMode)
                OnPoll_Virtual();

            //--------------------------------------------------------------------
            //正反向信号撞两次的超时判断
            OnPoll_checkDouble();
        }
        /// <summary>
        /// 虚拟信号添加
        /// </summary>
        void OnPoll_Virtual()
        {
            DateTime now = DateTime.Now;

            //--------------------------------------------------------------------
            //正反向信号撞两次的超时判断
            if (mLimitList.Count == 0)
                return;

            LimitCell lc = mLimitList.Last();
            if (lc.isVirtual)//上一个不能是虚拟信号
                return;

            if (lc.dt_end == DateTime.MinValue)
                return;//上一个信号还没完成

            if (now - lc.dt_end < TimeSpan.FromSeconds(RenZiJiaPeriod.TotalSeconds + 20))
                return;//时间还不够长

            //已经大于上一次旋转信号+20s，都没有信号了
            //添加虚拟信号
            int no = (lc.no == 0) ? 1 : 0;
            DateTime dt = lc.dt_end + RenZiJiaPeriod;

            var cell = new LimitCell()
            {
                no = no,
                dt_begin = dt,
                dt_end = dt + LimitSignTime,
                isVirtual = true
            };

            mLimitList.RAdd(cell);
            AddEvent?.Invoke(cell);

        }

        /// <summary>
        /// 正反向信号撞两次的超时判断
        /// </summary>
        void OnPoll_checkDouble()
        {
            if (mLimitList.Count == 0)
                return;

            LimitCell lc = mLimitList.Last();
            //需要撞两次的超时判断！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！
            if (!lc.isDouble)
                return;

            if (lc.dt_end != DateTime.MinValue)
                return;//已经结束了

            //第2次还没撞
            if (DateTime.Now - lc.dt_begin < TimeSpan.FromSeconds(30))
                return;

            //长时间第2次都没撞， 看来只需要撞一次而已
            lc.isDouble = false;
            if (lc.no == 0)
                IsSign0Double = lc.isDouble;
            else
                IsSign1Double = lc.isDouble;
            
            lc.dt_end = lc.dt_mid;
            lc.dt_mid = DateTime.MinValue;
            limitCellDtEndChanged();

            
        }

        /// <summary>
        /// 转向信号 的 结束时间被修改了
        /// </summary>
        void limitCellDtEndChanged() 
        {
            if (mLimitList.Count == 0)
                return;
            DateTime dt1 = mLimitList[mLimitList.Count - 1].dt_begin;
            DateTime dt2 = mLimitList[mLimitList.Count - 1].dt_end;

            if (dt1 == DateTime.MinValue || dt2 == DateTime.MinValue)
                return;

            if (dt2 > dt1) {
                var ts = dt2 - dt1;

                if (ts > TimeSpan.FromSeconds(30))
                {
                    LimitSignTime = TimeSpan.FromSeconds(4);
                }

                LimitSignTime = ts;//更新撞信号的耗时
            }
        }

        /// <summary>
        /// 转向信号 的 开始时间被修改了
        /// </summary>
        void limitCellDtBeginChanged()
        {
            if (mLimitList.Count < 2)
                return;
            DateTime dt1 = mLimitList[mLimitList.Count - 1].dt_begin;
            DateTime dt2 = mLimitList[mLimitList.Count - 2].dt_end;

            if (dt1 == DateTime.MinValue || dt2 == DateTime.MinValue)
                return;

            if (dt1 > dt2)
            {
                RenZiJiaPeriod = dt1 - dt2;//只有这个是正确的！！！
                                           //触发修正事件！！！！！
            }
        }

        /// <summary>
        /// 判断信号是否毛刺，最后会调用update_limit
        /// </summary>
        /// <param name="no"></param>
        void PopSign(int no)
        {
            List<SignData> noJudgeList;
            if (no == 0)
                noJudgeList = mSign0ListNoJudge;
            else
                noJudgeList = mSign1ListNoJudge;

            if (noJudgeList.Count() == 0)
            {
                //没有信号,异常
                noJudgeList.Clear();
                return;
            }

            if (noJudgeList.Count() == 1)
            {
                //只有一个信号，它持续了100ms，是信号不是毛刺
                update_limit(noJudgeList.First());
            }
            else
            {
                SignData sd0 = noJudgeList.First();
                SignData sd1 = noJudgeList.Last();
                if (sd0.On == sd1.On)
                {
                    //状态一样， 不应该会发生的情况，AD卡坏了？
                    //异常处理：两次信号间的都只是毛刺，触发第1个信号
                    update_limit(sd0);
                }
                else
                {
                    if (sd1.Time - sd0.Time >= TimeSpan.FromMilliseconds(SIGN_DELAY_MS))
                    {
                        //两个信号时间差大于 100ms 
                        //触发它们
                        update_limit(sd0);
                        update_limit(sd1);
                    }
                    else
                    {
                        //时间差在100ms内，只是毛刺而已
                    }
                }
            }
            //判断完，清空列表！！！
            noJudgeList.Clear();
        }


        /// <summary>
        /// 添加正反转信号到 列表
        /// </summary>
        /// <param name="s"></param>
        void update_limit(SignData s)
        {
            //上一个是虚拟信号
            //1.当接收的信号与虚拟信号相同时，把虚拟信号删除！！！！！
            //2.当接收的信号与虚拟信号不同时，更新旋转时间！！！！！
            if (!update_limit_virtual(s))
            {
                switch (SignType)
                {
                    case BlowingSignType.Short:
                        update_limit_short(s);
                        break;
                    default:
                        update_limit_long(s);
                        break;
                }
            }

        }

        /// <summary>
        /// 处理上一个是虚拟信号的正反转信号，它可能是多余的，返回true，新来的真实信号已经被处理
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="no"></param>
        /// <param name="status"></param>
        /// <returns></returns>
        bool update_limit_virtual(SignData s)
        {
            DateTime dt = s.Time;
            int no = s.No;
            bool status = s.On;

            if (mLimitList.Count() == 0)
                return false;

            LimitCell lc_v = mLimitList.Last();
            if (lc_v.isVirtual == false)//不是虚拟信号，不用再判断了
                return false;

            if (lc_v.no == no)//有真实的信号，与虚拟信号一样
            {
                if (status != true)
                    return false;//异常， 不可能在 真实的信号中间插了个虚拟信号

                //上一个信号是多余的
                lc_v.isVirtual = false;
                lc_v.dt_begin = dt;
                lc_v.dt_end = DateTime.MinValue;
                limitCellDtBeginChanged();
                return true;
            }
            else
            {
                //更新旋转时间！！！！！！
                if (mLimitList.Count() > 1)
                {
                    DateTime dt2 = mLimitList[mLimitList.Count - 2].dt_end;

                    var renZiJiaPeriod = TimeSpan.FromTicks((dt - dt2 - LimitSignTime).Ticks / 2);//只有这个是正确的！！！
                    lc_v.dt_begin = dt2 + renZiJiaPeriod;
                    lc_v.dt_end = lc_v.dt_begin + LimitSignTime;
                    limitCellDtBeginChanged();
                }
            }
            return false;
        }


        /// <summary>
        /// 处理短信号
        /// </summary>
        /// <param name="s"></param>
        void update_limit_short(SignData s)
        {
            DateTime dt = s.Time;//信号发生的时间
            int no = s.No;//信号序号
            bool status = s.On;//信号的状态 true开始， false结束

            //把信号加入到列表

            if (status == true)//添加，写入开始时间
            {
                if (mLimitList.Count > 0)
                {
                    LimitCell lc = mLimitList.Last();
                    if (lc.no == no)//连续撞了两次相同限位
                    {
                        if (lc.isDouble)
                        {
                            lc.dt_end = dt;//信号结束了
                            limitCellDtEndChanged();
                        }
                        else
                        {
                            if (lc.dt_end == DateTime.MinValue)//上一个限位还没离开
                            {
                                //异常，AD卡出错了，或者断开连接了，清空！！！
                                mLimitList.Clear();
                                LimitList_Add(dt, no);
                            }
                            else
                            {
                                //判断两次的时间差
                                if ((dt - lc.dt_end) < TimeSpan.FromSeconds(30))
                                {
                                    //这是同一个转向信号
                                    lc.isDouble = true;
                                    if (lc.no == 0)
                                        IsSign0Double = lc.isDouble;
                                    else
                                        IsSign1Double = lc.isDouble;

                                    lc.dt_mid = lc.dt_end;
                                    lc.dt_end = dt;
                                    limitCellDtEndChanged();
                                }
                                else
                                {
                                    //时间差很大， 异常，旋转架重新转启
                                    //异常，AD卡出错了，或者断开连接了，清空！！！
                                    mLimitList.Clear();
                                    LimitList_Add(dt, no);
                                }
                            }
                        }
                    }
                    else
                    {
                        //一个新的 信号
                        if (lc.dt_end == DateTime.MinValue)//上一个转向还没离开
                        {
                            if (lc.isDouble)
                            {
                                if (lc.dt_mid != DateTime.MinValue)
                                {
                                    //没事， 只是从需要撞两次，变成只撞一次就可以了

                                    lc.isDouble = false;
                                    if (lc.no == 0)
                                        IsSign0Double = lc.isDouble;
                                    else
                                        IsSign1Double = lc.isDouble;

                                    lc.dt_end = lc.dt_mid;
                                    lc.dt_mid = DateTime.MinValue;
                                    limitCellDtEndChanged();
                                }
                                else
                                {
                                    //异常 输入口没有结束
                                    //AD卡出错了，或者断开连接了，清空！！！
                                    mLimitList.Clear();
                                    LimitList_Add(dt, no);
                                }
                            }
                            else
                            {
                                //异常 输入口没有结束
                                //AD卡出错了，或者断开连接了，清空！！！
                                mLimitList.Clear();
                                LimitList_Add(dt, no);
                            }
                        }
                        else
                        {
                            //一个新的信号
                            LimitList_Add(dt, no);
                        }
                    }
                }
                else
                {
                    //一个新的信号
                    LimitList_Add(dt, no);
                }
            }
            else //写入 结束时间
            {
                if (mLimitList.Count > 0)
                {
                    LimitCell lc = mLimitList.Last();
                    if (lc.no == no)
                    {
                        if (lc.isDouble)
                        {
                            //需要撞2次
                            if (lc.dt_mid == DateTime.MinValue)
                            {
                                lc.dt_mid = dt;//完成撞第1次
                            }
                            else if (lc.dt_end != DateTime.MinValue)
                            {
                                //完成撞第2次
                            }
                            else
                            {
                                //异常， 撞第2次 还没开始，就结束了
                                //AD卡出错了，或者断开连接了，清空！！！
                                mLimitList.Clear();
                            }
                        }
                        else
                        {
                            if (lc.dt_end == DateTime.MinValue)
                            {
                                lc.dt_end = dt;//完成一次信号
                                limitCellDtEndChanged();
                            }
                            else
                            {
                                //异常，连续2次结束
                                mLimitList.Clear();
                            }
                        }
                    }
                    else
                    {
                        //异常，还没开始，就结束了
                        mLimitList.Clear();
                    }
                }
                else
                {
                    //异常，还没开始，就结束了
                }
            }
        }


        /// <summary>
        /// 处理长信号， 只关心 status=true
        /// </summary>
        /// <param name="s"></param>
        void update_limit_long(SignData s)
        {

            DateTime dt = s.Time;
            int no = s.No;
            bool status = s.On;

            //把信号加入到列表
            if (status == true)//添加，写入开始时间
            {
                if (mLimitList.Count > 0)
                {
                    LimitCell lc = mLimitList.Last();
                    if (lc.no == no)//连续撞了两次相同限位, 可能重新在转
                    {
                        mLimitList.Clear();
                    }
                }

                LimitList_Add(dt, dt + LimitSignTime, no);
            }
        }
        void LimitList_Add(DateTime dt, DateTime dt_end, int no)
        {
            var cell = new LimitCell()
            {
                no = no,
                dt_begin = dt,
                dt_end = dt_end
            };
            limitCellDtBeginChanged();
            limitCellDtEndChanged();

            mLimitList.RAdd(cell);
            
            
            AddEvent?.Invoke(cell);
        }
        void LimitList_Add(DateTime dt, int no)
        {
            var cell = new LimitCell()
            {
                dt_begin = dt,
                no = no,
                isDouble = (no == 0) ? IsSign0Double : IsSign1Double
            };
            limitCellDtBeginChanged();


            mLimitList.RAdd(cell);
            AddEvent?.Invoke(cell);
        }
    }
}