BlowingDetectServiceClient.cs

using FLY.Thick.Blowing.IService;
using FLY.Thick.Blowing.OBJ_INTERFACE;
using FObjBase;
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Linq;
using System.Text;

namespace FLY.Thick.Blowing.Client
{
    /// <summary>
    /// 旋转架及膜位置检测模拟
    /// </summary>
    public class BlowingDetectServiceClient: FObj, IBlowingDetect
    {
        IFConn mConn;
        UInt32 mServerID;

        #region IBlowingDetect 成员
        #region 参数
        private double rangle = 350;
        /// <summary>
        /// 离开限位 到 撞下一个限位 的 旋转架转动总角度 单位°
        /// </summary>
        public double RAngle
        {
            get
            {
                return rangle;
            }
            set
            {
                if (rangle != value)
                {
                    rangle = value;
                    NotifyPropertyChanged("RAngle");
                }
            }
        }

        private TimeSpan defaultRPeriod;
        /// <summary>
        /// 人字架 旋转1周 设置 时间。 
        /// 刚开机时，RenZiJiaPeriod = DefaultRPeriod；
        /// 异常时，RenZiJiaPeriod = DefaultRPeriod；
        /// </summary>
        public TimeSpan DefaultRPeriod
        {
            get { return defaultRPeriod; }
            set
            {
                if (defaultRPeriod != value)
                {
                    defaultRPeriod = value;
                    NotifyPropertyChanged("DefaultRPeriod");
                }
            }
        }

        private TimeSpan accdectime;
        /// <summary>
        /// 加速减速时间， 加速减速时间+正反转冷却时间 = 撞限位 到 离开限位 的时间
        /// </summary>
        public TimeSpan AccDecTime
        {
            get
            {
                return accdectime;
            }
            set
            {
                if (accdectime != value)
                {
                    accdectime = value;
                    NotifyPropertyChanged("AccDecTime");
                }
            }
        }

        private bool isSign0Double = false;
        /// <summary>
        /// 信号0 撞2次。 这个能自动设置。 两个撞同一信号 间隔30秒内，算一个换向信号。 
        /// 当为2次撞时：  StartTime = 第1次撞的StartTime， EndTime = 第2次撞的EndTime
        /// </summary>
        public bool IsSign0Double
        {
            get { return isSign0Double; }
            set
            {
                if (isSign0Double != value)
                {
                    isSign0Double = value;
                    NotifyPropertyChanged("IsSign0Double");
                }
            }
        }

        private bool isSign1Double = false;
        /// <summary>
        /// 信号1 撞2次。 这个能自动设置。 两个撞同一信号 间隔30秒内，算一个换向信号。 
        /// 当为2次撞时：  StartTime = 第1次撞的StartTime， EndTime = 第2次撞的EndTime
        /// </summary>
        public bool IsSign1Double
        {
            get { return isSign1Double; }
            set
            {
                if (isSign1Double != value)
                {
                    isSign1Double = value;
                    NotifyPropertyChanged("IsSign1Double");
                }
            }
        }


        private BlowingSignType signtype = BlowingSignType.Short;
        /// <summary>
        /// 信号模式， 短信号模式（只撞一下），长信号模式（只要是转着，信号就长亮，直到换向）
        /// </summary>
        public BlowingSignType SignType
        {
            get { return signtype; }
            set
            {
                if (signtype != value)
                {
                    signtype = value;
                    NotifyPropertyChanged("SignType");
                }
            }
        }

        private TimeSpan limitsigntime;
        /// <summary>
        /// 撞限位 到 离开限位 的时间， 需要初始值，以后测量出来的
        /// </summary>
        public TimeSpan LimitSignTime
        {
            get { return limitsigntime; }
            set
            {
                if (limitsigntime != value)
                {
                    limitsigntime = value;
                    NotifyPropertyChanged("LimitSignTime");
                }
            }
        }


        private double filmlength = 26;
        /// <summary>
        /// 人字架到测厚仪膜长 单位m
        /// </summary>
        public double FilmLength
        {
            get
            {
                return filmlength;
            }
            set
            {
                if (filmlength != value)
                {
                    filmlength = value;
                    NotifyPropertyChanged("FilmLength");
                }
            }
        }

        private double rollperimeter = 314;
        /// <summary>
        /// 辊周长，单位mm
        /// </summary>
        public double RollPerimeter
        {
            get
            {
                return rollperimeter;
            }
            set
            {
                if (rollperimeter != value)
                {
                    rollperimeter = value;
                    NotifyPropertyChanged("RollPerimeter");
                }
            }
        }

        private bool issignfilter = false;
        /// <summary>
        /// 转向信号100ms 滤波
        /// </summary>
        public bool IsSignFilter
        {
            get { return issignfilter; }
            set
            {
                if (issignfilter != value)
                {
                    issignfilter = value;
                    NotifyPropertyChanged("IsSignFilter");
                }
            }
        }

        private bool isLackSignMode = false;
        /// <summary>
        /// 缺少信号模式
        /// 正反信号线接得不好，有时候会丢失了。 
        /// 当前的旋转时间是上一次的1.1倍时，在以前的位置增加信号！！！！
        /// 当有连续两次相同的信号，且信号差刚好是旋转时间的1.9~2.1倍时，证明真的是缺少信号
        /// </summary>
        public bool IsLackSignMode
        {
            get { return isLackSignMode; }
            set
            {
                if (isLackSignMode != value)
                {
                    isLackSignMode = value;
                    NotifyPropertyChanged("IsLackSignMode");
                }
            }
        }
        #endregion

        #region 状态
        private double angle = 0;
        /// <summary>
        /// 当前旋转架旋转角度
        /// </summary>
        public double Angle
        {
            get
            {
                return angle;
            }
            protected set
            {
                if (angle != value)
                {
                    angle = value;
                    NotifyPropertyChanged("Angle");
                }
            }
        }
        private Misc.DIRECTION direction = Misc.DIRECTION.FORWARD;
        /// <summary>
        /// 当前方向
        /// </summary>
        public Misc.DIRECTION Direction
        {
            get
            {
                return direction;
            }
            protected set
            {
                if (direction != value)
                {
                    direction = value;
                    NotifyPropertyChanged("Direction");
                }
            }
        }


        private int rotationcnt;
        /// <summary>
        /// 当前缓冲区数量
        /// </summary>
        public int RotationCnt
        {
            get
            {
                return rotationcnt;
            }
            protected set
            {
                if (rotationcnt != value)
                {
                    rotationcnt = value;
                    NotifyPropertyChanged("RotationCnt");
                }
            }
        }

        private int lastlimitno;
        /// <summary>
        /// 最新的限位信号序号
        /// </summary>
        public int LastLimitNo
        {
            get
            {
                return lastlimitno;
            }
            protected set
            {
                if (lastlimitno != value)
                {
                    lastlimitno = value;
                    NotifyPropertyChanged("LastLimitNo");
                }
            }
        }
        private TimeSpan pasttime;
        /// <summary>
        /// 最后一次撞限位，或离开限位信号 到当前已经消耗的时间
        /// </summary>
        public TimeSpan PastTime
        {
            get
            {
                return pasttime;
            }
            protected set
            {
                if (pasttime != value)
                {
                    pasttime = value;
                    NotifyPropertyChanged("PastTime");
                }
            }
        }


        private double filmvelocity = 0;
        /// <summary>
        /// 当前线速度,单位 m/min
        /// </summary>
        public double FilmVelocity
        {
            get
            {
                return filmvelocity;
            }
            set
            {
                if (filmvelocity != value)
                {
                    filmvelocity = value;
                    NotifyPropertyChanged("FilmVelocity");
                }
            }
        }

        private TimeSpan renzijiaperiod;

        /// <summary>
        /// 离开限位 到 撞下一个限位  的 旋转架转动时间， 需要初始值，以后测量出来的
        /// </summary>
        public TimeSpan RenZiJiaPeriod
        {
            get
            {
                return renzijiaperiod;
            }
            protected set
            {
                if (renzijiaperiod != value)
                {
                    renzijiaperiod = value;
                    NotifyPropertyChanged("RenZiJiaPeriod");
                }
            }
        }

        private TimeSpan swapCoolTime;
        /// <summary>
        /// 正反转冷却时间， 加速减速时间 * 2 +正反转冷却时间 = 撞限位 到 离开限位 的时间 
        /// </summary>
        public TimeSpan SwapCoolTime
        {
            get { return swapCoolTime; }
            protected set {
                if (swapCoolTime != value)
                {
                    swapCoolTime = value;
                    NotifyPropertyChanged("SwapCoolTime");
                }
            }
        }
        #endregion

        #region 信号列表
        private int firstsignbm = -1;
        /// <summary>
        /// 信号列表第一个记录序号
        /// </summary>
        public int FirstSignBM
        {
            get { return firstsignbm; }
            protected set
            {
                if (firstsignbm != value)
                {
                    firstsignbm = value;
                    NotifyPropertyChanged("FirstSignBM");
                }
            }
        }
        private int lastsignbm = -1;
        /// <summary>
        /// 信号列表最后一个记录序号
        /// </summary>
        public int LastSignBM
        {
            get { return lastsignbm; }
            protected set
            {
                if (lastsignbm != value)
                {
                    lastsignbm = value;
                    NotifyPropertyChanged("LastSignBM");
                }
            }
        }
        #endregion

        #endregion

        /// <summary>
        /// 
        /// </summary>
        public BlowingDetectServiceClient()
        {
            mServerID = FLY.Thick.Blowing.OBJ_INTERFACE.OBJ_INTERFACE_ID.BDETECT_ID;
        }


        #region IBlowingDetect 函数
        #region 功能

        /// <summary>
        /// 应用
        /// </summary>
        public void Apply()
        {
            CurrObjSys.SetValueEx(
                mConn, mServerID, ID,
                BLOWING_DETECT_OBJ_INTERFACE.SET_PARAMS,
                new BLOWING_DETECT_OBJ_INTERFACE.Pack_Params()
                {
                    rangle = RAngle,
                    period = DefaultRPeriod,
                    rollPerimeter = RollPerimeter,
                    filmLength = FilmLength,
                    accDecTime = AccDecTime,
                    limitSignTime = LimitSignTime,
                    isSign0Double = IsSign0Double,
                    isSign1Double = IsSign1Double,
                    signType = SignType,
                    isSignFilter = IsSignFilter,
                    isLackSignMode = IsLackSignMode
                }.ToBytes());
        }
        /// <summary>
        /// 获取 信号列表
        /// </summary>
        /// <param name="AsyncDelegate">retdata = GetBufListReponse</param>
        /// <param name="AsyncState"></param>
        public void GetSignList(AsyncCBHandler AsyncDelegate, object AsyncState)
        {
            CurrObjSys.CallFunctionEx(mConn, mServerID, ID,
                BLOWING_DETECT_OBJ_INTERFACE.CALL_GETSIGNLIST,
                null,
                AsyncDelegate, AsyncState);
        }

        #endregion
        #endregion


        #region INotifyPropertyChanged 成员
        protected void NotifyPropertyChanged(string propertyName)
        {
            if (PropertyChanged != null)
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyName));
        }
        public event PropertyChangedEventHandler PropertyChanged;
        #endregion

        public override void Dispose()
        {
            CurrObjSys.ObjRemove(
                this, mConn);
        }
        public override void ConnectNotify(IFConn from)
        {
            mConn = from;

            if (from.IsConnected)
            {
                //获取所有数据，设置推送
                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BLOWING_DETECT_OBJ_INTERFACE.GET_PARAMS);

                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BLOWING_DETECT_OBJ_INTERFACE.GET_STATE);

                CurrObjSys.GetValueEx(
                    mConn, mServerID, ID,
                    BLOWING_DETECT_OBJ_INTERFACE.GET_SIGNBM);


                CurrObjSys.SenseConfigEx(
                    mConn, mServerID, ID, 0xffffffff,
                    SENSE_CONFIG.ADD);
            }
        }
        public override void PushGetValue(IFConn from, uint srcid, ushort memid, byte[] infodata)
        {
            switch (memid)
            {
                case BLOWING_DETECT_OBJ_INTERFACE.GET_PARAMS:
                    {
                        BLOWING_DETECT_OBJ_INTERFACE.Pack_Params p = new BLOWING_DETECT_OBJ_INTERFACE.Pack_Params();
                        if (!p.TryParse(infodata))
                            break;

                        RAngle = p.rangle;//旋转架转动角度
                        DefaultRPeriod = p.period;
                        RollPerimeter = p.rollPerimeter;
                        FilmLength = p.filmLength;
                        AccDecTime = p.accDecTime;
                        LimitSignTime = p.limitSignTime;
                        IsSign0Double = p.isSign0Double;
                        IsSign1Double = p.isSign1Double;
                        SignType = p.signType;
                        IsSignFilter = p.isSignFilter;
                        IsLackSignMode = p.isLackSignMode;
                    }
                    break;

                case BLOWING_DETECT_OBJ_INTERFACE.GET_STATE:
                    {
                        BLOWING_DETECT_OBJ_INTERFACE.Pack_CurrState p = new BLOWING_DETECT_OBJ_INTERFACE.Pack_CurrState();
                        if (!p.TryParse(infodata))
                            break;
                        LastLimitNo = p.limitno;
                        PastTime = p.pasttime;
                        RotationCnt = p.rotationCnt;
                        FilmVelocity = p.filmvelocity;
                        Angle = p.angle;
                        Direction = p.direction;
                        RenZiJiaPeriod = p.period;
                        SwapCoolTime = p.swapCoolTime;
                    }
                    break;
                case BLOWING_DETECT_OBJ_INTERFACE.GET_SIGNBM:
                    {
                        BLOWING_DETECT_OBJ_INTERFACE.Pack_BM p = new BLOWING_DETECT_OBJ_INTERFACE.Pack_BM();
                        if (!p.TryParse(infodata))
                            break;

                        FirstSignBM = p.firstbm;
                        LastSignBM = p.lastbm;
                    }
                    break;
            }
        }
        public override void PushInfo(IFConn from, uint srcid, ushort infoid, byte[] infodata)
        {
            switch (infoid)
            {
                default:
                    PushGetValue(from, srcid, infoid, infodata);
                    break;
            }
        }
        public override void PushCallFunction(IFConn from, uint srcid, uint magic, ushort funcid, byte[] retdata, object AsyncDelegate, object AsyncState)
        {
            switch (funcid)
            {
                case BLOWING_DETECT_OBJ_INTERFACE.CALL_GETSIGNLIST:
                    {
                        GetSignListReponse p = new GetSignListReponse();
                        if (!p.TryParse(retdata))
                            return;
                        ((AsyncCBHandler)AsyncDelegate)(AsyncState, p);
                    }
                    break;
            }
        }


    }
}