GM_BlowingFix.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.ComponentModel;
using System.IO;
using System.Xml.Serialization;
using System.Threading;

using Misc;
using FlyADBase;
using FLY.Thick.BulkDataModule;
using FLY.Thick.Base.Common;
using FLY.Thick.Base.IService;
using FLY.Thick.Base.Server;
using FLY.Thick.Blowing.IService;
using MathNet.Numerics.LinearAlgebra.Double;
using FObjBase;
using Newtonsoft.Json;
using FLY.Thick.Blowing.Common;
using FLY.Thick.Blowing.Server.Model;

namespace FLY.Thick.Blowing.Server
{
    /// <summary>
    /// 
    /// </summary>
    public class GM_BlowingFix : GM_Base, IBlowingFixService, ISaveToXml
    {
        NLog.Logger logger = NLog.LogManager.GetCurrentClassLogger();

        const int MARKNO_PROFILE_ADD = 87;
        const int MARKNO_PROFILE_CHANGED = 88;

        HistoryDb mHistoryDb;
        BulkDb mBulkDb;

        #region 延时操作，markno
        const int MARKNO_SAVE = 1;
        const int MARKNO_CALFRAME = 2;
        #endregion

        /// <summary>
        /// 人字架角度 &amp; 膜走带位置检测
        /// </summary>
        public BlowingDetect mPDetect;
        #region ISaveToXml
        public string[] GetSavePropertyNames()
        {
            return new string[]{
                "ChannelCnt",
                "BPC",
                "OrgBoltNo",
                "EPCType",
                "SampleConsume",
                "SampleInterval",
                "BackEdgeWait",
                "IsBtnSelfHold",
                "IsUsedMap",
                "Map"
            };
        }
        #endregion

        #region IRenZiJiaService

        #region 分区设定


        /// <summary>
        /// 加热通道数
        /// </summary>
        public int ChannelCnt { get; set; } = 88;

        /// <summary>
        /// 分区数/加热通道数
        /// </summary>
        public int BPC { get; set; } = 1;

        /// <summary>
        /// 风环螺丝数
        /// </summary>
        public int NBolts => ChannelCnt * BPC;


        /// <summary>
        /// 复位时，探头测量的位置对应分区号
        /// </summary>
        public int OrgBoltNo { get; set; } = 1;


        /// <summary>
        /// 第1个螺丝号
        /// </summary>
        public int BoltNo1st=1;
        /// <summary>
        /// 使用分区表
        /// </summary>
        public bool IsUsedMap { get; set; }
        bool IsNeedMap()
        {
            if (IsUsedMap && Map.Count() > 0)
                return true;
            else
                return false;
        }
        private List<BoltMapCell> map = new List<BoltMapCell>();
        /// <summary>
        /// 分区表,必须保证不能为null
        /// </summary>
        public List<BoltMapCell> Map
        {
            get { return map; }
            set {
                //检测是否不一样
                if (value == null)
                    return;
                if (checkNoSame_map(map,value))
                {
                    if (!checkParamErr_map(value))
                    {
                        IsUsedMap = false;
                        map = new List<BoltMapCell>();
                    }
                    else
                    {
                        map = value;
                    }
                }
            }
        }

        #endregion


        #region IRenZiJiaFixService

        /// <summary>
        /// 追边开始按钮自锁
        /// </summary>
        public bool IsBtnSelfHold 
        {
            get {
                return mEPCA10.IsBtnSelfHold;
            }
            set {
                mEPCA10.IsBtnSelfHold = value;
            }
        }
        
        /// <summary>
        /// 温修对位硬件类型
        /// </summary>
        public RenZiJiaFixEPCType EPCType { get; set; } = RenZiJiaFixEPCType.Null;
        /// <summary>
        /// 采样时间， 默认2s
        /// </summary>
        public TimeSpan SampleConsume
        {
            get { return mEPCA10.SampleConsume; }
            set
            {
                mEPCA10.SampleConsume = value;
            }
        }

        /// <summary>
        /// 温修间隔，默认45分钟
        /// </summary>
        public TimeSpan SampleInterval
        {
            get { return mEPCA10.SampleInterval; }
            set
            {
                mEPCA10.SampleInterval = value;
            }
        }

        /// <summary>
        /// 当前温修计时，大于温修间隔就会去温修
        /// </summary>
        public TimeSpan SampleTimer 
        {
            get {
                return mEPCA10.SampleTimer;
            }
        }



        /// <summary>
        /// 回到边界后，再等待一段时间，那就肯定找到边界了。 默认5s
        /// </summary>
        public TimeSpan BackEdgeWait 
        {
            get {
                return mEPCA10.BackEdgeWait;
            }
            set {
                mEPCA10.BackEdgeWait = value;
            }
        }

        /// <summary>
        /// 采样得到的样品AD
        /// </summary>
        public int SampleAD 
        {
            get
            {
                return mEPCA10.SampleAD;
            }           
        }
        /// <summary>
        /// 追边运行中！
        /// </summary>
        public bool EPCIsRunning 
        {
            get {
                return mEPCA10.IsRunning;
            }
        }

        #endregion

        /// <summary>
        /// 应用
        /// </summary>
        public void Apply() 
        {
            
            Save();
        }
        public event RenZiJiaDataEventHandler DataEvent;
        #endregion

        #region EPC
        public delegate void EPCSampledEventHandler(int ad);

        class EPCA10:INotifyPropertyChanged
        {
            /// <summary>
            /// EPC-A10 警报 对应输入位
            /// </summary>
            const int in_epc_alarm_bit = 12;
            /// <summary>
            /// EPC启动 对应输入位
            /// </summary>
            const int in_epc_enable_bit = 6;
            /// <summary>
            /// EPC启动状态 对应输出位
            /// </summary>
            const int out_epc_isrunning_bit = 1;
            /// <summary>
            /// 控制EPC-A10 到温修点 对应输出位
            /// </summary>
            const int out_epc_sample_bit = 2;
            #region public成员

            public bool Enable { get; set; } = false;

            /// <summary>
            /// 温修时间，默认2秒
            /// </summary>
            public TimeSpan SampleConsume { get; set; } = TimeSpan.FromSeconds(2);


            /// <summary>
            /// 温修间隔，默认45分钟
            /// </summary>
            public TimeSpan SampleInterval { get; set; } = TimeSpan.FromMinutes(45);


            /// <summary>
            /// 当前温修计时，大于温修间隔就会去温修
            /// </summary>
            public TimeSpan SampleTimer { get; set; }= TimeSpan.Zero;

            /// <summary>
            /// 回到边界，再等待1段时间
            /// </summary>
            public TimeSpan BackEdgeWait { get; set; } = TimeSpan.FromSeconds(5);



            /// <summary>
            /// 追边开始按钮自锁
            /// </summary>
            public bool IsBtnSelfHold { get; set; } = true;



            /// <summary>
            /// 采样得到的样品AD
            /// </summary>
            public int SampleAD { get; set; } = -1;


            /// <summary>
            /// 追边运行中！
            /// </summary>
            public bool IsRunning { get; set; } = false;

            public event EPCSampledEventHandler Sampled;
            #endregion





            /// <summary>
            /// 采样开始时间
            /// </summary>
            /// <returns></returns>
            DateTime SampleBegin;

            /// <summary>
            /// 回去膜边开始时间
            /// </summary>
            DateTime GoBackBegin;

            /// <summary>
            /// 去采样开始时间
            /// </summary>
            DateTime GoSampleBegin;

            /// <summary>
            /// 去采样消耗的时间
            /// </summary>
            TimeSpan GoSampleConsume;



            IFlyAD mFlyAD;

            List<int> sampledata = new List<int>();
            TimeSpan sampleConsumeTimer = TimeSpan.Zero;
            public EPCA10(IFlyAD flyad)
            {
                mFlyAD = flyad;
                mFlyAD.IStatusChangedEvent += new IStatusChangedEventHandler(mFlyAD_IStatusChangedEvent);
                mFlyAD.TimeGridEvent += new FlyADBase.TimeGridEventHandler(mFlyAD_TimeGridEvent);
                this.PropertyChanged += EPCA10_PropertyChanged;
            }

            private void EPCA10_PropertyChanged(object sender, PropertyChangedEventArgs e)
            {
                if (e.PropertyName == "Enable")
                {
                    //TODO, 错的！！！！
                    if(!Enable)
                        Stop();
                }
            }

            void mFlyAD_TimeGridEvent(object sender, FlyADBase.TimeGridEventArgs e)
            {
                if (!Enable)
                    return;

                if (State != STATE.SAMPLE)
                    return;

                TimeSpan ts = e.Ts;//准确

                DateTime dt = e.Time;//准确
                int[] data = e.Data;

                if (dt < SampleBegin)
                    return;

                sampledata.AddRange(data);
                sampleConsumeTimer += TimeSpan.FromTicks(ts.Ticks * data.Length);

                if (sampleConsumeTimer >= SampleConsume)
                {
                    int ad = Misc.MyMath.Avg(sampledata.ToArray());
                    if (Misc.MyBase.ISVALIDATA(ad))
                    {
                        SampleAD = ad;
                        if (Sampled != null)
                            Sampled(SampleAD);
                    }
                    else 
                    {
                        SampleAD = -1;
                    }
                    FinishSample();
                }
            }

            void mFlyAD_IStatusChangedEvent(object sender, IStatusChangedEventArgs e)
            {
                if (!Enable)
                    return;

                if (Misc.MyBase.CHECKBIT(e.IChanged, in_epc_enable_bit - 1))
                {
                    if (IsBtnSelfHold)
                    {
                        if (!Misc.MyBase.CHECKBIT(e.IStatus, in_epc_enable_bit - 1))
                        {
                            if (!IsRunning)
                            {
                                Start();
                            }
                        }
                        else
                        {
                            if (IsRunning)
                            {
                                Stop();
                            }
                        }
                    }
                    else 
                    {
                        if (!Misc.MyBase.CHECKBIT(e.IStatus, in_epc_enable_bit - 1))
                        {
                            if (!IsRunning)
                            {
                                Start();
                            }
                            else
                            {
                                Stop();
                            }
                        }
                    }
                }
            }
            enum STATE
            {
                /// <summary>
                /// 没动作
                /// </summary>
                STOP,
                /// <summary>
                /// 准备去温修
                /// </summary>
                START,
                /// <summary>
                /// 去温修过程中，记录耗费的时间 
                /// </summary>
                WAITFOR_SAMPLE,
                /// <summary>
                /// 已经到达温修点，温修中,采样 N秒
                /// </summary>
                SAMPLE,
                /// <summary>
                /// 等待 耗费的时间+N秒
                /// </summary>
                WAITFOR_EDGE,
                /// <summary>
                /// 测量中，等待N分钟，下次会进入START
                /// </summary>
                WAITFOR_NEXT,
            }
            /// <summary>
            /// 追边状态
            /// </summary>
            STATE State = STATE.STOP;

            public void Start()
            {
                if (!Enable)
                    return;
                State = STATE.START;
                SetRunning();
            }
            public void Stop()
            {
                if (!Enable)
                    return;
                State = STATE.STOP;
                ClearRunning();
                GoBack();
            }
            void SetRunning()
            {
                IsRunning = true;
                mFlyAD.SetOutput(
                    (UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1),
                    (UInt16)~Misc.MyBase.BIT(out_epc_isrunning_bit - 1));
            }
            void ClearRunning()
            {
                IsRunning = false;
                mFlyAD.SetOutput(
                    (UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1),
                    (UInt16)Misc.MyBase.BIT(out_epc_isrunning_bit - 1));
            }
            bool CheckIsRunning() 
            {
                if (!Misc.MyBase.CHECKBIT(mFlyAD.OStatus, out_epc_isrunning_bit - 1))
                    return true;
                else
                    return false;
            }
            void GoSample()
            {
                mFlyAD.SetOutput(
                    (UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1),
                    (UInt16)~Misc.MyBase.BIT(out_epc_sample_bit - 1));

            }
            void GoBack()
            {
                mFlyAD.SetOutput(
                    (UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1),
                    (UInt16)Misc.MyBase.BIT(out_epc_sample_bit - 1));
            }
            bool IsAlarm()
            {
                if (!Misc.MyBase.CHECKBIT(mFlyAD.IStatus, in_epc_alarm_bit - 1))
                    return true;
                else
                    return false;
            }
            public bool IsSampling()
            {

                switch (State)
                {
                    case STATE.WAITFOR_SAMPLE:
                    case STATE.SAMPLE:
                    case STATE.WAITFOR_EDGE:
                        return true;
                    default:
                        return false;
                }
            }

            void FinishSample()
            {
                State = STATE.WAITFOR_EDGE;
                GoBack();
                GoBackBegin = DateTime.Now;
            }
            /// <summary>
            /// 应该放在完成一幅图时触发
            /// </summary>
            public void CheckToSample()
            {
                if (!Enable)
                    return;
                if (!IsRunning)
                    return;

                if(SampleTimer >= SampleInterval)
                {
                    Start();
                }
            }

            /// <summary>
            /// 0.1秒触发一次
            /// </summary>
            public void OnPoll()
            {
                if (!Enable)
                    return;
                
                switch (State)
                {
                    case STATE.STOP:
                        if (CheckIsRunning())
                            ClearRunning();//这是不正常的，灭了它
                        break;
                    case STATE.START:
                        {
                            sampledata.Clear();
                            SampleTimer = TimeSpan.Zero;
                            GoSample();
                            GoSampleBegin = DateTime.Now;
                            
                            State = STATE.WAITFOR_SAMPLE;
                        } break;
                    case STATE.WAITFOR_SAMPLE:
                        {
                            if (IsAlarm())
                            {
                                GoSampleConsume = DateTime.Now - GoSampleBegin;
                                //已经到达
                                State = STATE.SAMPLE;
                                SampleBegin = DateTime.Now;
                                sampleConsumeTimer = TimeSpan.Zero;
                            }
                        } break;
                    case STATE.SAMPLE:
                        {

                        } break;
                    case STATE.WAITFOR_EDGE:
                        {
                            TimeSpan ts = DateTime.Now - GoBackBegin;
                            if (ts >= GoSampleConsume + BackEdgeWait)
                            {
                                //完成
                                State = STATE.WAITFOR_NEXT;
                            }
                        } break;
                    case STATE.WAITFOR_NEXT:
                        {
                            if (SampleTimer < SampleInterval)
                            {
                                SampleTimer += TimeSpan.FromSeconds(1);
                            }
                        }break;
                }
            }

            public event PropertyChangedEventHandler PropertyChanged;

        }
        EPCA10 mEPCA10;
        #endregion

        #region 吹膜定点解方程用

        /// <summary>
        /// 测量模式， 决定是否解方程
        /// </summary>
        public MeasureMode MMode { get; set; } = MeasureMode.Edge;

        /// <summary>
        /// 膜宽 单位 mm
        /// </summary>
        public int FilmWidth { get; set; } = 1500;


        /// <summary>
        /// 探头所在膜的横向位置 单位 mm
        /// </summary>
        public int FilmPosH { get; set; } = 70;

        /// <summary>
        /// 探头测量位置，袋折叠的宽度 单位 mm
        /// </summary>
        public int BagFold0 { get; set; } = 405;

        /// <summary>
        /// 另一端 袋折叠的宽度 单位 mm
        /// </summary>
        public int BagFold1 { get; set; } = 415;

        #endregion


        IBulkDataServiceAdd mBulkData;
        DynArea mDynArea;
        BlowingFixProfileParam mProfileParam;
        /// <summary>
        /// 当前正在处理的 ADList 里面的数据.No
        /// </summary>
        int mADListToDoNo;
        /// <summary>
        /// 处理放入filminfo 的数据.No
        /// </summary>
        int mADListToDoNo_ToFilmInfo;
        
        /// <summary>
        /// 1s一个数据，
        /// </summary>

        RList<ADCell> mADList;
        


        /// <summary>
        /// 1条方程
        /// </summary>
        class Formula
        {
            /// <summary>
            /// n元方程
            /// </summary>
            public int n;
            /// <summary>
            /// 方程 xi前面的 ai
            /// </summary>
            public double[] ai;
            /// <summary>
            /// 方程 y 值
            /// </summary>
            public double y;
            public Formula(int no_x)
            {
                int i;
                n = no_x;
                ai = new double[no_x];
                for (i = 0; i < n; i++) ai[i] = 0;
                y = 0;
            }
            public bool AddData(IEnumerable<int> idxs, int thick)
            {
                foreach(int idx in idxs)
                    if ((idx < 0) || (idx >= n)) return false;

                foreach(int idx in idxs)
                    ai[idx]++;
                
                y += thick;
                return true;
            }
        }
        class FRAME_INFO//一幅数据信息
        {
            
            public DateTime StartTime;//开始时间
            public DateTime EndTime;//结束时间
            public int NoStartAD;//在AD列表 处理的数据开始点
            public int NoEndAD;//在AD列表 处理的数据结束点
            public DIRECTION direction;//当前幅数据，方向
            public double velocity;//线速度 m/min
            public int rotationCnt;//人字架旋转次数
            /// <summary>
            /// 对应bulkdata 的数据, -1, 没有对应的bookmark，因为从来都没数据
            /// </summary>
            public int bookmark = -1;
            /// <summary>
            /// 对应数据库的 id
            /// </summary>
            public Int64? scandata_id = null;
            /// <summary>
            /// 分区数据 N*long
            /// </summary>
            public int[] frame;
            /// <summary>
            /// 经过分区表后的结果
            /// </summary>
            public int[] frame_map;
            /// <summary>
            /// 推送出去的数据，也是数据库中的数据
            /// </summary>
            public RenZiJiaDataEventArgs renZiJiaDataEventArgs;
            /// <summary>
            /// 推送出去的数据 被修改了
            /// </summary>
            public bool renZiJiaDataEventArgsHasChanged = false;


            int frame_sum = 0;
            int frame_cnt = 0;

            static int virtual_nbolts = 88;
            static List<Formula> virtual_formulas = new List<Formula>();
            static void UpdateVirtualFormulas()
            {
                virtual_formulas.Clear();
                for (int i = 0; i < virtual_nbolts; i++)
                {
                    int boltindex1 = i;
                    int boltindex2 = i + 1;
                    if (boltindex2 >= virtual_nbolts)
                        boltindex2 = 0;

                    Formula fm = new Formula(virtual_nbolts);
                    fm.ai[boltindex1] = 1;
                    fm.ai[boltindex2] = -1;
                    virtual_formulas.Add(fm);
                }
            }
            static FRAME_INFO()
            {
                UpdateVirtualFormulas();
            }
            public void SetNBolt(int nbolts) 
            {
                frame = new int[nbolts];
                appeared = new bool[nbolts];
                for (int i = 0; i < nbolts; i++)
                {
                    ClearFrameValue(i);
                }
            }

            void ClearFrameValue(int index) 
            {
                frame[index] = Misc.MyBase.NULL_VALUE;
                appeared[index] = false;
            }
            public void Clear() 
            {
                for (int i = 0; i < frame.Count(); i++)
                {
                    ClearFrameValue(i);
                }
                IsValid = true;
                HasChanged = true;
                index_last = -1;
                frame_cnt = 0;
                frame_sum = 0;
                mFormulas.Clear();
                last_solvedt = DateTime.MinValue;
                isTimeToSolve = false;
                canSolve = false;
            }
            
            public bool HasChanged = false;//数据被改变了！！！，是时候更新bulkdata
            public bool IsValid = true;//是合法数据
            /// <summary>
            /// 提交，完成一次操作。清除状态
            /// </summary>
            public void Submit() 
            {
                HasChanged = false;
            }
            public void CheckForValid() 
            {
                if (rotationCnt == 0)//旋转次数=0，肯定是不完整的数据
                {
                    HasChanged = true;
                    IsValid = false;
                    return;
                }
                //所有的数据都应该大于10
                for (int i = 0; i < frame.Count(); i++) 
                {
                    if (Misc.MyBase.ISVALIDATA(frame[i])) 
                    {
                        if (frame[i] < 1000)
                        {
                            HasChanged = true;
                            IsValid = false;
                            return;
                        }
                    }
                }
            }
            /// <summary>
            /// 上一次解方程的时间
            /// </summary>
            DateTime last_solvedt = DateTime.MinValue;
            /// <summary>
            /// 是时候解方程
            /// </summary>
            bool isTimeToSolve = false;
            /// <summary>
            /// 方程多了，能解方程
            /// </summary>
            bool canSolve = false;
            /// <summary>
            /// 每个区号，是否有出现
            /// </summary>
            bool[] appeared;
            /// <summary>
            /// 方程组
            /// </summary>
            List<Formula> mFormulas = new List<Formula>();
            public void SolveFormula()
            {
                if (!canSolve)//没有新方程，没法解
                    return;

                int nbolts = frame.Count();
                if (virtual_nbolts!= nbolts)
                {
                    virtual_nbolts = nbolts;
                    UpdateVirtualFormulas();
                }
                //TODO 能否解得方程检查
                int nrow = mFormulas.Count() + virtual_formulas.Count();
                
                //if (nrow < NBolts) return;

                //Console.WriteLine("Total get {0} formular", nrow);
                //转换为 DenseMatrix 与 DenseVector
                DenseMatrix matrixA = new DenseMatrix(nrow, nbolts);
                DenseMatrix matrixAT = new DenseMatrix(nbolts, nrow);
                DenseVector vectorB = new DenseVector(nrow);
                DenseVector vectorATB = new DenseVector(nbolts);

                int rowindex = 0;
                foreach (Formula fm in mFormulas)
                {
                    matrixA.SetRow(rowindex, fm.ai);
                    matrixAT.SetColumn(rowindex, fm.ai);
                    vectorB[rowindex] = fm.y;
                    rowindex++;
                }
                foreach (Formula fm in virtual_formulas)
                {
                    matrixA.SetRow(rowindex, fm.ai);
                    matrixAT.SetColumn(rowindex, fm.ai);
                    vectorB[rowindex] = fm.y;
                    rowindex++;
                }
                DenseMatrix ATA = (DenseMatrix)matrixA.TransposeThisAndMultiply(matrixA);
                DenseVector ATB = (DenseVector)matrixA.TransposeThisAndMultiply(vectorB);

                DenseVector X = (DenseVector)ATA.Solve(ATB);

                for (int i = 0; i < nbolts; i++)
                {
                    int d = (appeared[i]) ? (int)X[i] : Misc.MyBase.NULL_VALUE;
                    frame[i] = d;// (int)X[i];
                }
                HasChanged = true;

                isTimeToSolve = false;
                canSolve = false;
            }

            /// <summary>
            /// 检查是否需要更新
            /// </summary>
            public void CheckToSolveFormula()
            {
                if(isTimeToSolve)
                {
                    SolveFormula();
                }
            }


            int index_last = -1;
            public void SetFrameValue(int index, int value, DateTime dt)
            {
                int nbolts = frame.Count();

                if (index >= nbolts)
                    return;//异常
                else if (index < 0)
                    return;//异常
                else if (!Misc.MyBase.ISVALIDATA(value))
                    return;//异常

                if (index_last != index)
                {
                    index_last = index;
                    HasChanged = true;
                    frame_cnt = 0;
                    frame_sum = 0;
                }

                frame_sum += value;
                frame_cnt++;

                frame[index] = frame_sum / frame_cnt;
            }
            /// <summary>
            /// 解方程方式更新 frame
            /// </summary>
            /// <param name="indexs"></param>
            /// <param name="value"></param>
            /// <param name="dt"></param>
            public void SetFrameValue(IEnumerable<int> indexs, int value, DateTime dt)
            {
                int nbolts = frame.Count();
                foreach (int index in indexs)
                {
                    if (index >= nbolts)
                        return;//异常
                    else if (index < 0)
                        return;//异常
                }

                if (!Misc.MyBase.ISVALIDATA(value))
                    return;//异常
                
                Formula fm = new Formula(nbolts);
                fm.AddData(indexs, value);
                mFormulas.Add(fm);

                foreach (int index in indexs)
                    appeared[index] = true;
                
                canSolve = true;

                //5秒解一次方程
                if ((index_last != indexs.First()) && ((dt - last_solvedt) >= TimeSpan.FromSeconds(5)))
                {
                    index_last = indexs.First();
                    last_solvedt = dt;
                    isTimeToSolve = true;
                }
            }
        }
        RList<FRAME_INFO> mFrameInfoList;


        AD2ThickHandler AD2Thick;

        public event EPCSampledEventHandler EPCSampled 
        {
            add {
                mEPCA10.Sampled += value;
            }
            remove {
                mEPCA10.Sampled -= value;              
            }
        }

        void checkParamErr() 
        {
            if (ChannelCnt < 20 || ChannelCnt > 160)
            {
                ChannelCnt = 44;
            }
            
            if (BPC < 1 || BPC > 4)
            {
                BPC = 2;
            }

            if (OrgBoltNo < 1 || OrgBoltNo > NBolts)
            {
                OrgBoltNo = 1;
            }

            if (!checkParamErr_map(Map))
            {
                IsUsedMap = false;
                Map = new List<BoltMapCell>();
            }
        }

        /// <summary>
        /// 检测通过，返回true
        /// </summary>
        /// <returns></returns>
        bool checkParamErr_map(List<BoltMapCell> mapCells)
        {
            bool map_err = false;
            bool g_o = false;
            bool g_n = false;
            //Map 检测
            //OldNo,NewNo不能 <1 >NBolts
            //Map OldNo 必须从小到大环形排列
            //Map NewNo 必须从小到大环形排列
            for (int i = 0; i < mapCells.Count(); i++)
            {
                var mapCell = mapCells[i];
                if (mapCell.NewNo < 1 || mapCell.NewNo > NBolts)
                {
                    map_err = true;
                    break;
                }
                if (mapCell.OldNo < 1 || mapCell.OldNo > NBolts)
                {
                    map_err = true;
                    break;
                }

                int i_next = i + 1;
                if (i_next >= mapCells.Count())
                    i_next = 0;

                var mapCell_next = mapCells[i_next];
                if (mapCell.OldNo >= mapCell_next.OldNo)
                {
                    if (!g_o)
                        g_o = true;
                    else
                    {
                        map_err = true;
                        break;
                    }

                }

                if (mapCell.NewNo >= mapCell_next.NewNo)
                {
                    if (!g_n)
                        g_n = true;
                    else
                    {
                        map_err = true;
                        break;
                    }

                }
            }

            if (map_err)
            {
                return false;
            }
            else
            {
                return true;
            }
        }
        bool checkNoSame_map(List<BoltMapCell> mapCells1, List<BoltMapCell> mapCells2)
        {
            if (mapCells1.Count() != mapCells2.Count())
                return true;
            for (int i = 0; i < mapCells1.Count(); i++)
            {
                var mapCell1 = mapCells1[i];
                var mapCell2 = mapCells2[i];

                if (mapCell1.NewNo != mapCell2.NewNo)
                    return true;
                if (mapCell1.OldNo != mapCell2.OldNo)
                    return true;
            }
            return false;
        }

        static GM_BlowingFix()
        {
            Misc.SaveToXmlHepler.Regist(typeof(BoltMapCell));
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="flyad"></param>
        public GM_BlowingFix(FlyAD7 flyad)
            :base(flyad)
        {
            GMState = CTRL_STATE.FIX;
            
            mPDetect = new BlowingDetect();
            mEPCA10 = new EPCA10(flyad);
            
            mPDetect.Load();
            Load();


            //检测参数
            mPDetect.CheckParamErr();
            checkParamErr();

            mEPCA10.Enable = (EPCType == RenZiJiaFixEPCType.EPCA10);
            mEPCA10.PropertyChanged += new PropertyChangedEventHandler(mEPCA10_PropertyChanged);
            InitList();

            PropertyChanged += new PropertyChangedEventHandler(RenZiJiaFix_PropertyChanged);
            
            mPDetect.FilmInfoChangedEvent += new BlowingDetect.FilmInfoChangedEventHandler(mPDetect_FilmInfoChangedEvent);
            mPDetect.ClearEvent += new BlowingDetect.ClearEventHandler(mPDetect_ClearEvent);


            mFlyAD.TimeGridEvent += new FlyADBase.TimeGridEventHandler(flyad_TimeGridEvent);

            mPDetect.Init(flyad);
        }

        void mEPCA10_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if ((e.PropertyName == "SampleConsume") ||
                (e.PropertyName == "SampleInterval") ||
                (e.PropertyName == "SampleTimer") ||
                (e.PropertyName == "BackEdgeWait") ||
                (e.PropertyName == "IsBtnSelfHold"))
            {
                NotifyPropertyChanged(e.PropertyName);
            }
            else if (e.PropertyName == "IsRunning")
            {
                NotifyPropertyChanged("EPCIsRunning");
            }
        }


        /// <summary>
        /// 作废的功能
        /// </summary>
        public void EPCStart() 
        {
            if(EPCType == RenZiJiaFixEPCType.EPCA10)
                mEPCA10.Start();
        }

        /// <summary>
        /// 作废的功能
        /// </summary>
        public void EPCStop()
        {
            if (EPCType == RenZiJiaFixEPCType.EPCA10)
                mEPCA10.Stop();
        }

        void mPDetect_ClearEvent(object sender)
        {
            //没信号，清空所有数据！！！
        }
        /// <summary>
        /// 从1幅数据，获取头部，尾部，为于 ADList 的位置
        /// </summary>
        /// <param name="frameinfo"></param>
        /// <param name="index_start"></param>
        /// <param name="index_end"></param>
        /// <returns>false 数据不存在</returns>
        bool GetFilmInfoADIndex(FRAME_INFO frameinfo, out int index_start, out int index_end) 
        {
            index_start = mADList.No2Index(frameinfo.NoStartAD);
            
            index_end = mADList.No2Index(frameinfo.NoEndAD);
            
            if ((index_start < 0)||(index_end <0)||
                (index_start >= mADList.Count)||(index_end >= mADList.Count))
            {
                //数据已经不存在，删除
                return false;
            }
            return true;
        }

        void mPDetect_FilmInfoChangedEvent(object sender, BlowingDetect.FilmInfoChangedEventArgs e)
        {
            var ret = ADListFastSearchIndex(e.Time, out int idx);
            switch (ret) 
            {
                case ADListFastSearchIndexResult.Before://发送在过去
                    {
                        mADListToDoNo = mADList.Index2No(0);
                        mADListToDoNo_ToFilmInfo = mADListToDoNo;
                    }
                    break;
                case ADListFastSearchIndexResult.Now://发生在列表时间内
                    {
                        mADListToDoNo = mADList.Index2No(idx);
                        mADListToDoNo_ToFilmInfo = mADListToDoNo;
                    }
                    break;
                case ADListFastSearchIndexResult.Future:
                    {
                        //未来的，不处理
                    }
                    break;
            }
            
        }

        void RenZiJiaFix_PropertyChanged(object sender, PropertyChangedEventArgs e)
        {
            if (e.PropertyName == "NBolts")
            {
                //所有数据删除
                mFrameInfoList.Clear();

            }
            else if (e.PropertyName == "EPCType")
            {
                mEPCA10.Enable = (EPCType == RenZiJiaFixEPCType.EPCA10);
            }
            else if (e.PropertyName == "OrgBoltNo")
            {
                //TODO 只处理3幅图
                int idx = mFrameInfoList.Count - 3;
                if (idx < 0)
                    idx = 0;

                if (idx >= mFrameInfoList.Count)
                    return;
                mADListToDoNo_ToFilmInfo = mFrameInfoList[idx].NoStartAD;
            }
            else if ((e.PropertyName == "FilmWidth") || (e.PropertyName == "FilmPosH") ||
                (e.PropertyName == "SolveEnable"))
            {
                //重新计算当前幅数据
                UpdateCurrFrame();
            }
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="bulkdata"></param>
        /// <param name="func_ad2thick"></param>
        /// <param name="dynarea"></param>
        /// <param name="profileParam"></param>
        /// <param name="historyDB"></param>
        /// <param name="bulkDB"></param>
        public void Init(
            IBulkDataServiceAdd bulkdata, AD2ThickHandler func_ad2thick, DynArea dynarea,
            BlowingFixProfileParam profileParam,
            HistoryDb historyDB, BulkDb bulkDB
            )
        {
            AD2Thick = func_ad2thick;
            mBulkData = bulkdata;
            mDynArea = dynarea;
            mProfileParam = profileParam;
            mHistoryDb = historyDB;
            mBulkDb = bulkDB;

            Misc.BindingOperations.SetBinding(profileParam, "MMode", this, "MMode");
            Misc.BindingOperations.SetBinding(profileParam, "FilmWidth", this, "FilmWidth");
            Misc.BindingOperations.SetBinding(profileParam, "FilmPosH", this, "FilmPosH");
            Misc.BindingOperations.SetBinding(profileParam, "BagFold0", this, "BagFold0");
            Misc.BindingOperations.SetBinding(profileParam, "BagFold1", this, "BagFold1");

            Misc.BindingOperations.SetBinding(mPDetect, "FilmVelocity", mDynArea, "FilmVelocity");

            Misc.BindingOperations.SetBinding(this, "NBolts", () =>
            {
                mBulkData.NBolts = NBolts;

                mDynArea.NBolts = NBolts;
                mDynArea.FirstBoltNo = 1;

                mDynArea.DataBoltNoBegin = 1;
                mDynArea.DataBoltNoEnd = NBolts;
                mDynArea.ScanBoltNoBegin = 1;
                mDynArea.ScanBoltNoEnd = NBolts;
            });
            
            profileParam.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == "K")
                {
                    //重新计算当前幅数据
                    UpdateCurrFrame();
                }
            };
            mDynArea.PropertyChanged += (s, e) =>
            {
                if (e.PropertyName == "SampleAD")
                {
                    //重新计算当前幅数据
                    UpdateCurrFrame();
                }
            };

            //记录调试数据
            MarkDebugInit();
        }


        #region 记录测试数据
        DateTime markdebug_dt = DateTime.MinValue;
        void MarkDebugInit()
        {
            if (markdebug_dt == DateTime.MinValue)
                markdebug_dt = DateTime.Now;

            //启动1分钟定时器
            FObjBase.PollModule.Current.Poll_Config(
                FObjBase.PollModule.POLL_CONFIG.ADD,
                ()=>
                {
                    mPDetect.GetSignList(markdebug_dt, (asyncState, retData) =>
                    {
                        var reponse = retData as GetSignListReponse;
                        var cells = reponse.datas;
                        if (cells.Count > 0)
                        {
                            mHistoryDb.AddSignData(
                                new Lc_Sign()
                                {
                                    Time = cells.First().Time,
                                    Signs = cells.ToArray()
                                });
                        }
                    }, null);
                    mPDetect.GetRollList(markdebug_dt, (asyncState, retData) =>
                    {
                        var reponse = retData as GetRollListReponse;
                        var cells = reponse.datas;
                        if (cells.Count > 0)
                        {
                            mHistoryDb.AddRollData(
                                new Lc_Roll()
                                {
                                    Time = cells.First().dt,
                                    Signs = cells.ToArray()
                                });
                        }
                    }, null);
                    this.GetADList(markdebug_dt, (asyncState, retData) =>
                    {
                        var reponse = retData as GetADListReponse;
                        var cells = reponse.datas;
                        if (cells.Count > 0)
                        {
                            var thicks = ToRealThicks(cells.Select(c => AD2Thick(c.thick)));
                            mHistoryDb.AddTrendData(
                                new Lc_TrendData(){
                                    Time = cells.First().dt,
                                    K = mProfileParam.K,
                                
                                    Thicks = thicks
                                });
                        }
                    }, null);
                    markdebug_dt = DateTime.Now;
                },
                TimeSpan.FromMinutes(1));
        }
        #endregion

        void UpdateCurrFrame() 
        {
            FObjBase.PollModule.Current.Poll_JustOnce(
                new FObjBase.PollModule.PollHandler(delegate()
                {
                    if (mFrameInfoList.Count > 0) 
                    {
                        mADListToDoNo_ToFilmInfo = mFrameInfoList.Last().NoStartAD;
                    }

                }), this, MARKNO_CALFRAME);
        } 


        
        TimeSpan datOf1s_ts = TimeSpan.Zero;
        TimeSpan datOf1s_interval = TimeSpan.FromSeconds(1);
        List<int> datOf1s = new List<int>();

        void flyad_TimeGridEvent(object sender, FlyADBase.TimeGridEventArgs e)
        {
            bool issample = false;
            if (EPCType == RenZiJiaFixEPCType.EPCA10)
            {
                if (mEPCA10.IsSampling())
                {
                    issample = true;
                }
            }

            TimeSpan ts = e.Ts;//准确
 
            DateTime dt = e.Time;//准确
            int[] data = e.Data;

            DateTime datOf100ms_dt = DateTime.MinValue;
            for(int i=0;i<data.Length;i++)
            {
                if (issample)//采样中，数据都是无效的
                {
                    datOf1s.Add(Misc.MyBase.NULL_VALUE);
                }
                else if (data[i] > UInt16.MaxValue)
                {
                    datOf1s.Add(Misc.MyBase.NULL_VALUE);
                }
                else if (data[i] < 0)
                {
                    datOf1s.Add(Misc.MyBase.NULL_VALUE);
                }
                else
                {
                    datOf1s.Add(data[i]);
                }

                datOf1s_ts = datOf1s_ts + ts;

                if (datOf100ms_dt == DateTime.MinValue)
                    datOf100ms_dt = dt;
                else 
                    datOf100ms_dt = datOf100ms_dt + ts;
                
                if (datOf1s_ts>= datOf1s_interval)//1s 一个数据
                {
                    datOf1s_ts = datOf1s_ts - datOf1s_interval;

                    int avgad = Misc.MyBase.NULL_VALUE;

                    if (datOf1s.Count() > 0)
                    {
                        avgad = Misc.MyMath.Avg(datOf1s.ToArray());
                        datOf1s.Clear();
                    }
                    else if (mADList.Count() > 0)
                    {
                        avgad = mADList.Last().Ad;
                    }


                    mADList.RAdd(
                        new ADCell()
                        {
                            Time = datOf100ms_dt,
                            Ad = avgad
                        });
                    
                }
            }
        }


        private void InitList()//初始化列表
        {
            if (mADList == null)
            {
                mADList = new RList<ADCell>(4000);
                mADListToDoNo = mADList.GetLastNo();
                mADListToDoNo_ToFilmInfo = mADListToDoNo;
            }   
            if(mFrameInfoList==null)
		        mFrameInfoList=new RList<FRAME_INFO>(6);
        }


        
        //复位
        void Clear()
        {
            if(mADList!=null)
		        mADList.Clear();
            if (mFrameInfoList != null)
            {
                mFrameInfoList.Clear();
            }
        }

        int Angle2BoltIndex(double angle)
        {
            if(angle<0)
            {
                angle+=360;
            }

            int boltindex = (int)(OrgBoltNo - BoltNo1st +angle*NBolts/360);
            if (boltindex >= NBolts)
            {
                boltindex -= NBolts;
            }
            else if (boltindex < 0)//不应该发生，可能是 OrgBoltNo 出错了。
            {
                boltindex += NBolts;
            }
            return boltindex;
        }

        enum ADListFastSearchIndexResult 
        {
            /// <summary>
            /// 时间点在列表以前;
            /// </summary>
            Before = -1,
            /// <summary>
            /// 时间点在列表中;
            /// </summary>
            Now = 0,
            /// <summary>
            /// 时间点在列表的未来;
            /// </summary>
            Future = 1
        }
        /// <summary>
        /// 找到在 dt 前最近的 ADList 序号；
        /// 当ADList 没有数据，返回 Future；
        /// 已知AD列表每个数据之间的时间差，快速推断结果；
        /// </summary>
        /// <param name="dt"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        ADListFastSearchIndexResult ADListFastSearchIndex(DateTime dt, out int index)
        {
            index = 0;

            if (mADList.Count <= 0)//列表没有数据， 只能当它在未来
                return ADListFastSearchIndexResult.Future;


            if (dt > mADList.Last().Time)
                return ADListFastSearchIndexResult.Future;
            else if (dt < mADList.First().Time)
                return ADListFastSearchIndexResult.Before;
            else
            {

                int offset = (int)((mADList.Last().Time - dt).TotalSeconds / datOf1s_interval.TotalSeconds);
                index = mADList.Count - offset - 1;//大约在这个位置附近

                //安全限制
                if (index >= mADList.Count)
                    index = mADList.Count() - 1;
                else if (index < 0)
                    index = 0;
                
                if (mADList[index].Time == dt)
                {
                    //已经找到就是它！！！！
                }
                else if (mADList[index].Time > dt)
                {
                    while (true)
                    {
                        index--;
                        if (index <= 0)
                        {
                            index = 0;//最前面一个了
                            break;
                        }
                        if (mADList[index].Time <= dt) 
                        {
                            //找到了
                            break;
                        }
                    }
                }
                else
                {
                    while(true)
                    {
                        index++;//测试一下
                        if (index >= mADList.Count)
                        {
                            //到顶了，不找了
                            index--;
                            break;
                        }
                        else if (mADList[index].Time == dt)
                        {
                            //找到了，就是它
                            break;
                        }
                        else if (mADList[index].Time > dt)
                        {
                            //上一个小于，现在大于，上一个就对了
                            index--;
                            break;
                        }
                    }
                }
                
                return ADListFastSearchIndexResult.Now;
            }
        }




        void OnPoll_UpdateADList() 
        {
            
            int adlist_index = mADList.No2Index(mADListToDoNo);
            if (adlist_index >= mADList.Count)
                return;//没有数据需要处理
            if (adlist_index < 0)
                adlist_index = 0;


            for (int i = adlist_index; i < mADList.Count; i++)
            {
                mADListToDoNo = mADList.Index2No(i);

                //被测膜模式选择
                switch (MMode)
                {
                    case MeasureMode.Edge:
                        {
                            if (!OnPoll_UpdateADList_Edge(i))
                                return;
                        }
                        break;
                    case MeasureMode.Normal:
                        {
                            if (!OnPoll_UpdateADList_Normal(i))
                                return;
                        }
                        break;
                    default:
                    //case MeasureMode.Bag:
                        {
                            if (!OnPoll_UpdateADList_Bag(i))
                                return;
                        }
                        break;
                }
            }
            mADListToDoNo = mADList.Index2No(mADList.Count);
        }

        #region 不同测量模式的ADList数据更新
        bool OnPoll_UpdateADList_Edge(int idx)
        {
            BlowingDetect.FilmInfo filminfo;
            int ret = mPDetect.GetFilmInfo(out filminfo, mADList[idx].Time, 2.3, 0);
            if (ret == 1)//发生在未来
            {
                return false;
            }
            if (filminfo == null)//异常，FilmPosH 错误
            {
                return false;
            }
            if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
            {
                return false;
            }


            ADCell adcell = mADList[idx];
            adcell.Angles.Clear();
            adcell.Angles.Add(filminfo.angle1);
            adcell.Direction = filminfo.direction;
            adcell.Velocity = filminfo.filmVelocity;
            adcell.RotationCnt = filminfo.rotationCnt;
            adcell.InCV = filminfo.inCV;
            return true;
        }
        bool OnPoll_UpdateADList_Normal(int idx)
        {
            BlowingDetect.FilmInfo filminfo;
            int ret = mPDetect.GetFilmInfo(out filminfo, mADList[idx].Time, FilmWidth, FilmPosH);
            if (ret == 1)//发生在未来
            {
                return false;
            }
            if (filminfo == null)//异常，FilmPosH 错误
            {
                return false;
            }
            if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
            {
                return false;
            }

            ADCell adcell = mADList[idx];
            adcell.Angles.Clear();
            adcell.Angles.Add(filminfo.angle1);
            adcell.Angles.Add(filminfo.angle2);
            adcell.Direction = filminfo.direction;
            adcell.Velocity = filminfo.filmVelocity;
            adcell.RotationCnt = filminfo.rotationCnt;
            adcell.InCV = filminfo.inCV;
            return true;
        }
        bool OnPoll_UpdateADList_Bag(int idx)
        {
            double filmWidth = FilmWidth + BagFold0 + BagFold1;

            //最内2层
            BlowingDetect.FilmInfo filminfo0;
            double filmPosH0 = BagFold0 - FilmPosH;

            int ret = mPDetect.GetFilmInfo(out filminfo0, mADList[idx].Time, filmWidth, filmPosH0);
            if (ret == 1)//发生在未来
            {
                return false;
            }
            if (filminfo0 == null)//异常，FilmPosH 错误
            {
                return false;
            }
            if (mADListToDoNo != mADList.Index2No(idx))//触发了事件
            {
                return false;
            }

            //最外2层
            BlowingDetect.FilmInfo filminfo1;
            double filmPosH1 = BagFold0 + FilmPosH;
            mPDetect.GetFilmInfo(out filminfo1, mADList[idx].Time, filmWidth, filmPosH1);

            ADCell adcell = mADList[idx];
            adcell.Angles.Clear();
            adcell.Angles.Add(filminfo1.angle1);
            adcell.Angles.Add(filminfo0.angle1);
            adcell.Angles.Add(filminfo0.angle2);
            adcell.Angles.Add(filminfo1.angle2);


            //下面的参数 filminfo0 与 filminfo1 一样
            adcell.Direction = filminfo0.direction;
            adcell.Velocity = filminfo0.filmVelocity;
            adcell.RotationCnt = filminfo0.rotationCnt;
            adcell.InCV = filminfo0.inCV;

            return true;
        }
        #endregion
        /// <summary>
        /// 状态不一样，人字架已经转了新一圈，需要增加新一幅数据
        /// </summary>
        /// <param name="adcell"></param>
        /// <param name="frameinfo"></param>
        /// <returns></returns>
        bool FrameInfoCheckToNew(ADCell adcell, FRAME_INFO frameinfo) 
        {
            if ((adcell.Direction != frameinfo.direction) ||
                (adcell.RotationCnt != frameinfo.rotationCnt) )
                //(Math.Abs(adcell.velocity - frameinfo.velocity) > 2))
            {
                return true;
            }
            else 
            {
                return false;
            }
        }

        
        FR_DATA_TYPE Direction2FR_DATA_TYPE(Misc.DIRECTION direction) 
        {
            if (direction == DIRECTION.FORWARD)
                return FR_DATA_TYPE.INVALID;
            else
                return FR_DATA_TYPE.VALID;
        }

        /// <summary>
        /// 输出的数据都必须是稳定，可靠的。 生成一幅幅测厚仪数据！！！！！！！！！！！！
        /// </summary>
        void OnPoll_UpdateFrameInfo() 
        {
            RenZiJiaDataEventArgs renZiJiaDataEventArgs=null;//当数据被修改，推送事件！！！，当只有最后一幅图被推送


            int adlist_index = mADList.No2Index(mADListToDoNo_ToFilmInfo);//当前在处理的 数据点
            if (adlist_index >= mADList.Count)
                return;//没有数据需要处理

            if (adlist_index < 0)//全部都要处理
                adlist_index = 0;
            
            //当没有任何一幅数据时， frameinfo_index = mFrameInfoList.Count = 0
            int frameinfo_index = Math.Max(mFrameInfoList.Count - 1, 0); 

            //查找adlist_index 属于哪个frameinfo;
            //当找到，清空里面的.frame,一切重新开始！！！
            //当不能找到，说明只是接着上次的处理而已，不需要重新开始
            for (int i = 0; i < mFrameInfoList.Count; i++)
            {
                int index_start;
                int index_end;
                FRAME_INFO frameinfo = mFrameInfoList[i];
                if (!GetFilmInfoADIndex(frameinfo, out index_start, out index_end))
                {
                    //数据已经不存在，删除
                    mFrameInfoList.RemoveAt(i);
                    i--;
                    continue;
                }
                if (adlist_index <= index_end)
                {
                    //要处理的数据点，位于 这幅数据 (frameinfo)； 重新计算整幅数据 
                    frameinfo_index = i;
                    //adlist_index = mADList.No2Index(frameinfo.NoStartAD);
                    break;
                }
            }

            int adlist_todo_index = mADList.No2Index(mADListToDoNo);//已经成功获取完位置信息的数据尽头
            for (int i = adlist_index; (i < mADList.Count && i<adlist_todo_index); i++)
            {
                ADCell adcell = mADList[i];
                //mADListToDoNo_ToFilmInfo = mADList.Index2No(i);
                 
                
                FRAME_INFO frameinfo;
                //--------------------------------------------------------------------------------------------------------
                //条件检测
                if (frameinfo_index >= mFrameInfoList.Count)//根本没数据，新建
                {
                    frameinfo = new FRAME_INFO();
                    frameinfo.StartTime = adcell.Time;
                    frameinfo.EndTime = adcell.Time;
                    frameinfo.direction = adcell.Direction;
                    frameinfo.velocity = adcell.Velocity;
                    frameinfo.rotationCnt = adcell.RotationCnt;
                    frameinfo.NoStartAD = mADList.Index2No(i);
                    frameinfo.NoEndAD = mADList.Index2No(i);
                    frameinfo.SetNBolt(NBolts);
                    mFrameInfoList.RAdd(frameinfo);
                    frameinfo_index = mFrameInfoList.Count - 1;
                }
                else 
                {
                    frameinfo = mFrameInfoList[frameinfo_index];
                    if (i <= mADList.No2Index(frameinfo.NoEndAD)) 
                    {
                        //当为新数据， i应该>mADList.No2Index(frameinfo.NoEndAD)
                        //能进这里，证明是要重新计算
                        //清空数据，重新来过
                        
                        frameinfo.StartTime = adcell.Time;
                        frameinfo.EndTime = adcell.Time;
                        frameinfo.direction = adcell.Direction;
                        frameinfo.velocity = adcell.Velocity;
                        frameinfo.rotationCnt = adcell.RotationCnt;
                        frameinfo.NoStartAD = mADList.Index2No(i);
                        frameinfo.NoEndAD = mADList.Index2No(i);
                        frameinfo.Clear();
                    }
                }
                //--------------------------------------------------------------------------------------------------------


                if (FrameInfoCheckToNew(adcell, frameinfo))
                {
                    //一幅数据已经完成
                    switch (MMode)
                    {
                        case MeasureMode.Normal:
                        case MeasureMode.Bag:
                            {
                                //最后检查一下是否需要解方程
                                frameinfo.SolveFormula();
                            }
                            break;
                    }

                    
                    //重新分区
                    if (IsNeedMap())
                    {
                        Dictionary<int, int> m = new Dictionary<int, int>();
                        for (int j = 0; j < Map.Count(); j++)
                            m.Add(Map[j].OldNo - 1, Map[j].NewNo - 1);
                        frameinfo.frame_map = Misc.MyMath.Map(frameinfo.frame, m);
                    }

                    //更新数据库内容
                    {
                        int[] frame;
                        List<BoltMapCell> map;
                        if (IsNeedMap())
                        {
                            frame = frameinfo.frame_map;
                            map = new List<BoltMapCell>();
                            foreach (var m in Map)
                                map.Add(m.Clone());
                        }
                        else
                        {
                            frame = frameinfo.frame;
                            map = null;
                        }
                        var realthicks = ToRealThicks(frame);

                        frameinfo.renZiJiaDataEventArgs = new RenZiJiaDataEventArgs()
                        {
                            Time = frameinfo.StartTime,
                            EndTime = frameinfo.EndTime,
                            IsBackw = frameinfo.direction == DIRECTION.BACKWARD,
                            RPeriod = mPDetect.RenZiJiaPeriod,
                            RCnt = frameinfo.rotationCnt,
                            OrgBoltNo = OrgBoltNo,
                            RAngle = Math.Round(mPDetect.RAngle,2),
                            FilmLength = Math.Round(mPDetect.FilmLength,2),
                            FilmVelocity = Math.Round(mPDetect.FilmVelocity,2),
                            K = Math.Round(mProfileParam.K,3),
                            Thicks = realthicks,
                            Boltmap = map
                        };
                        frameinfo.renZiJiaDataEventArgsHasChanged = true;
                    }

                    renZiJiaDataEventArgs = frameinfo.renZiJiaDataEventArgs;
                    //更新到下一个frameinfo
                    frameinfo_index++;


                    i--;
                    continue;
                }

                int thick = AD2Thick(adcell.Ad);
                switch (MMode)
                {
                    case MeasureMode.Edge:
                        {
                            //均值，更新frameinfo.frame
                            frameinfo.SetFrameValue(Angle2BoltIndex(adcell.Angles.First()), thick , adcell.Time);
                        }
                        break;
                    case MeasureMode.Normal:
                        {
                            //解方程，更新frameinfo.frame
                            var list = from a in adcell.Angles select Angle2BoltIndex(a);
                            frameinfo.SetFrameValue(list, thick * 2, adcell.Time);
                        }
                        break;
                    default:
                    //case MeasureMode.Bag:
                        {
                            //解方程，更新frameinfo.frame
                            var list = from a in adcell.Angles select Angle2BoltIndex(a);
                            frameinfo.SetFrameValue(list, thick * 4, adcell.Time);
                        }
                        break;
                }

                frameinfo.EndTime = adcell.Time;
                frameinfo.NoEndAD = mADList.Index2No(i);
            }
            mADListToDoNo_ToFilmInfo = mADListToDoNo;
            

            //检测数据更新情况，放入bulkdata
            for (int i = 0; i < mFrameInfoList.Count; i++) 
            {
                FRAME_INFO frameinfo = mFrameInfoList[i];
                switch (MMode)
                {
                    case MeasureMode.Normal:
                    case MeasureMode.Bag:
                        {
                            //最后检查一下是否需要解方程
                            frameinfo.SolveFormula();
                        }
                        break;
                }

                if (frameinfo.HasChanged)//数据检测过，需要更新bulkdata里面的数据, 大部分发生在扫描过程中，还没结束一幅图
                {
                    //重新分区
                    if (IsNeedMap())
                    {
                        Dictionary<int, int> m = new Dictionary<int, int>();
                        for (int j = 0; j < Map.Count(); j++)
                            m.Add(Map[j].OldNo - 1, Map[j].NewNo - 1);
                        frameinfo.frame_map = Misc.MyMath.Map(frameinfo.frame, m);
                    }

                    int[] thicks = IsNeedMap() ? frameinfo.frame_map : frameinfo.frame;

                    if (frameinfo.bookmark != -1)
                    {
                        if (!mBulkData.Change(frameinfo.bookmark, 0, thicks,
                                Direction2FR_DATA_TYPE(frameinfo.direction),
                                frameinfo.StartTime)) 
                        {
                            //修改失败，肯定是 bulkdata被清空了
                            frameinfo.bookmark = -1;
                        }
                    }

                    if (frameinfo.bookmark == -1)
                    {
                        mBulkData.Save();
                        //添加新的
                        frameinfo.bookmark = mBulkData.Add(thicks,
                            Direction2FR_DATA_TYPE(frameinfo.direction),
                            frameinfo.StartTime);
                        if (EPCType == RenZiJiaFixEPCType.EPCA10)
                            mEPCA10.CheckToSample();
                    }
                }
            }

            if(mFrameInfoList.Count()>0)
            {
                FRAME_INFO frameinfo = null;
                try
                {
                    frameinfo = mFrameInfoList.Last(f => f.HasChanged);
                }
                catch
                {

                }
                if (frameinfo != null)
                {
                    int[] thicks = IsNeedMap() ? frameinfo.frame_map : frameinfo.frame;

                    mBulkDb.SetTempFrame(0, ToRealThicks(thicks));
                }
            }

            foreach (var frameinfo in mFrameInfoList)
            {
                frameinfo.Submit();
            }

            #region sqlite3 历史数据保存
            if (mFrameInfoList.Any((frameinfo) => frameinfo.renZiJiaDataEventArgsHasChanged))
            {
                //下辊检测
                if (mHistoryDb.localDb.IsProfileFinished)
                {
                    AddProfile();
                }
            }

            //检测数据更新情况，放入数据库, 数据不能被修改

            foreach (var frameinfo in mFrameInfoList)
            {
                if (frameinfo.renZiJiaDataEventArgsHasChanged)
                {
                    frameinfo.renZiJiaDataEventArgsHasChanged = false;

                    if (frameinfo.scandata_id == null)
                    {
                        //添加数据
                        var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(frameinfo.renZiJiaDataEventArgs);
                        mHistoryDb.AddScanData(lc_scandata);
                        frameinfo.scandata_id = lc_scandata.ID;
                    }
                    else
                    {
                        //修改数据
                        var lc_scandata = Lc_AutoMapperProfile.Mapper.Map<Lc_ScanData>(frameinfo.renZiJiaDataEventArgs);
                        lc_scandata.ID = (Int64)frameinfo.scandata_id;
                        mHistoryDb.UpdateScanData(lc_scandata);
                    }
                }
            }
            #endregion
            //当数据被修改，只推送最后一次的数据
            if (renZiJiaDataEventArgs != null)
                DataEvent?.Invoke(this, renZiJiaDataEventArgs);
        }

        double[] ToRealThicks(IEnumerable<int> frame)
        {
            return frame.Select(t =>
            {
                if (Misc.MyBase.ISVALIDATA(t))
                    return t / 100.0;
                else
                    return double.NaN;
            }).ToArray();
        }
        protected override void OnPoll()
        {
            if (EPCType == RenZiJiaFixEPCType.EPCA10)
                mEPCA10.OnPoll();

            OnPoll_UpdateADList();
            OnPoll_UpdateFrameInfo();
        }

        public override bool Start()
        {
            //以前的 Start()
            IsRunning = true;
            mBulkData.InitPush();
            //清空临时数据
            mBulkDb.SetTempFrame(0, null);

            #region sqlite3 历史数据保存
            CheckProfile();
            mProfileParam.PropertyChanged += MProfileParam_PropertyChanged;
            #endregion

            FObjBase.PollModule.Current.Poll_Config(
                FObjBase.PollModule.POLL_CONFIG.ADD,
                onpoll_func,
                TimeSpan.FromSeconds(1));
            return true;
        }
        #region sqlite3 历史数据保存
        string[] profile_propertynames_add = new string[]{
                "PName",
                "OrderNo",
                "Number"
            };
        string[] profile_propertynames_update = new string[]{
                "Target",
                "TolerancePercent"
            };
        void CheckProfile()
        {
            if (mHistoryDb.localDb.IsProfileFinished)
            {
                //复位 膜纵向位置
                AddProfile();
            }
            else
            {
                if (mHistoryDb.localDb.CurrProfile != null)
                {
                    Db_Profile dB_Profile = mHistoryDb.localDb.CurrProfile;
                    if ((dB_Profile.PName != mProfileParam.PName) ||
                    (dB_Profile.OrderNo != mProfileParam.OrderNo) ||
                    (dB_Profile.Number != mProfileParam.Number))
                    {
                        AddProfile();
                    }
                    else
                    {
                        //继续上一次生产！！！！
                        UpdateProfile();


                    }
                }
                else
                {
                    //异常
                    AddProfile();
                }

            }
        }
        void AddProfile()
        {
            mHistoryDb.AddProfile(new Db_Profile()
            {
                PName = mProfileParam.PName,
                OrderNo = mProfileParam.OrderNo,
                Number = mProfileParam.Number,
                Target = mProfileParam.Target,
                TolerancePercent = mProfileParam.TolerancePercent,
                StartTime = DateTime.Now,
                EndTime = DateTime.Now
            });
        }
        void UpdateProfile()
        {
            mHistoryDb.UpdateProfile(new Db_Profile()
            {
                PName = mProfileParam.PName,
                OrderNo = mProfileParam.OrderNo,
                Number = mProfileParam.Number,
                Target = mProfileParam.Target,
                TolerancePercent = mProfileParam.TolerancePercent,
            });
        }
        private void MProfileParam_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
        {
            if (profile_propertynames_add.Contains(e.PropertyName))
            {
                FObjBase.PollModule.Current.Poll_JustOnce(
                    () =>
                    {
                        if (!mHistoryDb.localDb.IsProfileFinished)
                        {
                            mHistoryDb.FinishProfile();
                        }
                        AddProfile();//新
                    }, this, MARKNO_PROFILE_ADD);
            }
            else if (profile_propertynames_update.Contains(e.PropertyName))
            {
                FObjBase.PollModule.Current.Poll_JustOnce(
                    () =>
                    {
                        UpdateProfile();//修改
                    }, this, MARKNO_PROFILE_CHANGED);
            }
        }
        #endregion
        bool Load()
        {
            return Misc.SaveToXmlHepler.Load("renzijiafix.xml",this);
        }
        void Save()
        {
            Misc.SaveToXmlHepler.Save("renzijiafix.xml", this);
        }

        /// <summary>
        /// 获取 厚度列表
        /// </summary>
        /// <param name="begin">开始时间</param>
        /// <param name="AsyncDelegate">retdata = GetRollListReponse</param>
        /// <param name="AsyncState"></param>
        public void GetADList(DateTime begin, AsyncCBHandler AsyncDelegate, object AsyncState)
        {
            var p = new GetADListReponse
            {
                datas = mADList.FindAll(a => a.Time >= begin).Select(a => new ADSingle() { dt = a.Time,
                    thick = AD2Thick(a.Ad) }).ToList()
            };

            AsyncDelegate(AsyncState, p);
        }

    }

}