HeatCellServiceClient.cs

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

namespace FLY.FeedbackRenZiJia.Client
{
    public class HeatCellServiceClient : FObj, IHeatCell
    {
        IFConn mConn;
        UInt32 mServerID;

        #region IHeatCell 接口 成员变量

        #region 参数
        private double kp = 3;
        /// <summary>
        /// HeatOffset = ThickPercent * Kp
        /// </summary>
        public double Kp
        {
            get { return kp; }
            set
            {
                if (kp != value)
                {
                    kp = value;
                    NotifyPropertyChanged("Kp");
                }
            }
        }

        bool isAutoONo = false;
        /// <summary>
        /// 自动对位
        /// </summary>
        public bool IsAutoONo
        {
            get { return isAutoONo; }
            set
            {
                if (isAutoONo != value)
                {
                    isAutoONo = value;
                    NotifyPropertyChanged("IsAutoONo");
                }
            }
        }

        double autoONoKp = 5;
        /// <summary>
        /// 自动对位的Kp
        /// </summary>
        public double AutoONoKp
        {
            get { return autoONoKp; }
            set
            {
                if (autoONoKp != value)
                {
                    autoONoKp = value;
                    NotifyPropertyChanged("AutoONoKp");
                }
            }
        }


        private double thresholdheatsigma = 10;
        /// <summary>
        /// 平滑的阀值，只有超出阀值，才平滑
        /// </summary>
        public double ThresholdHeatSigma
        {
            get
            {
                return thresholdheatsigma;
            }
            set
            {
                if (thresholdheatsigma != value)
                {
                    thresholdheatsigma = value;
                    NotifyPropertyChanged("ThresholdHeatSigma");
                }
            }
        }

        bool isForbidUpDown = false;
        /// <summary>
        /// 自控时，不能调整总体上升下降
        /// </summary>
        public bool IsForbidUpDown
        {
            get { return isForbidUpDown; }
            set
            {
                if (isForbidUpDown != value)
                {
                    isForbidUpDown = value;
                    NotifyPropertyChanged("IsForbidUpDown");
                }
            }
        }


        int ctrlline;
        /// <summary>
        /// 厚度控制线 ， 厚度% 大于 厚度控制线 自动才会加热控制  
        /// </summary>
        public int CtrlLine
        {
            get { return ctrlline; }
            set
            {
                if (ctrlline != value)
                {
                    ctrlline = value;
                    NotifyPropertyChanged("CtrlLine");
                }
            }
        }
        private bool isBreakUpMode = false;
        /// <summary>
        /// 开启打散模式, 打散模式下，以打散度小为目标，控制2sigma在 控制线内
        /// </summary>
        public bool IsBreakUpMode
        {
            get { return isBreakUpMode; }
            set
            {
                if (isBreakUpMode != value)
                {
                    isBreakUpMode = value;
                    NotifyPropertyChanged("IsBreakUpMode");
                }
            }
        }
        #endregion

        #region 状态
        int[] thickpercents;
        /// <summary>
        /// 对应的100% 数据，单位是% 数量是BoltCnt, 数据肯定是完整的！！！！！
        /// </summary>
        public int[] ThickPercents
        {
            get
            {
                return thickpercents;
            }
            set
            {
                thickpercents = value;
                NotifyPropertyChanged("ThickPercents");
            }
        }

        int[] heats;
        /// <summary>
        /// 当前方向的加热策略，必须保证 0~100
        /// </summary>
        public int[] Heats
        {
            get
            {
                return heats;
            }
            protected set
            {
                heats = value;
                NotifyPropertyChanged("Heats");
            }
        }

        private int _base = 0;
        private int Base
        {
            get
            {
                return _base;
            }
            set
            {
                if (_base != value)
                {
                    _base = value;
                    NotifyPropertyChanged("Base");
                }
            }
        }


        int[] offsets;
        /// <summary>
        /// 加热偏移量
        /// </summary>
        public int[] Offsets
        {
            get
            {
                return offsets;
            }
            protected set
            {
                offsets = value;
                NotifyPropertyChanged("Offsets");
            }
        }

        int[] preheats;
        /// <summary>
        /// Heats+Offsets+Base
        /// </summary>
        public int[] PreHeats
        {
            get
            {
                return preheats;
            }
            protected set
            {
                preheats = value;
                NotifyPropertyChanged("PreHeats");
            }
        }

        private double maxheatsigma = 0;
        /// <summary>
        /// 加热量 每3个计算的sigma,最大值
        /// </summary>
        public double MaxHeatSigma
        {
            private set
            {
                if (maxheatsigma != value)
                {
                    maxheatsigma = value;
                    NotifyPropertyChanged("MaxHeatSigma");
                }
            }
            get
            {
                return maxheatsigma;
            }
        }

        private bool isInAutoONo = false;
        /// <summary>
        /// 当前正在自动对位模式
        /// </summary>
        public bool IsInAutoONo
        {
            get
            {
                return isInAutoONo;
            }
            protected set
            {
                if (isInAutoONo != value)
                {
                    isInAutoONo = value;
                    NotifyPropertyChanged("IsInAutoONo");
                }
            }
        }
        #endregion
        #endregion

        public HeatCellServiceClient()
        {
            mServerID = OBJ_INTERFACE_ID.HEATCELL_ID;

        }




        #region IHeatCell 函数
        public void ModifyOffset(int idx, int change)
        {
            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_MODIFYHEATOFFSET,
               new HEATCELL_OBJ_INTERFACE.Pack_ModifyHeatOffset()
               {
                   index = idx,
                   heatoffset = change
               }.ToBytes());
        }

        public void ModifyBase(int change)
        {
            FObjSys.Current.CallFunctionEx(
              mConn, mServerID, ID,
              HEATCELL_OBJ_INTERFACE.CALL_MODIFYBASE,
              new HEATCELL_OBJ_INTERFACE.Pack_ModifyBase()
              {
                  change = change
              }.ToBytes());
        }


        public void ClearOffsets()
        {
            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_CLEARHEATOFFSETS,
                     null
                );
        }

        public void ClearPreHeats()
        {
            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_CLEARHEATS, null
                );
        }

        public void Cal()
        {
            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_CAL, null
                );
        }

        public void Smooth()
        {
            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_SMOOTH,
                     new HEATCELL_OBJ_INTERFACE.Pack_CallSmoothRequest()
                     {
                         thresholdHeatSigma = ThresholdHeatSigma
                     }.ToBytes()
                );
        }
    

        public void HeatApply()
        {
            FObjSys.Current.CallFunctionEx(
                mConn, mServerID, ID,
                HEATCELL_OBJ_INTERFACE.CALL_HEATAPPLY, null
                );
        }
        #endregion



        #region IFObj
        public override void ConnectNotify(IFConn from)
        {
            mConn = from;
            if (from.IsConnected)
            {

                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_PARAMS);
                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_STATE);

                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_THICKS);
                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_HEATS);
                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_OFFSETS);
                FObjSys.Current.GetValueEx(mConn, mServerID, ID, HEATCELL_OBJ_INTERFACE.GET_PREHEATS);
                
                FObjSys.Current.SenseConfigEx(mConn, mServerID, ID, 0xffffffff, SENSE_CONFIG.ADD);
            }
        }


        public override void PushGetValue(IFConn from, uint srcid, ushort memid, byte[] infodata)
        {
            switch (memid)
            {
                case HEATCELL_OBJ_INTERFACE.GET_PARAMS:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Params p = new HEATCELL_OBJ_INTERFACE.Pack_Params();
                        if (!p.TryParse(infodata))
                            return;

                        Kp = p.kp;
                        AutoONoKp = p.autoONoKp;
                        ThresholdHeatSigma = p.thresholdHeatSigma;
                        CtrlLine = p.ctrlLine;
                        IsAutoONo = p.isAutoONo;
                        IsForbidUpDown = p.isForbidUpDown;
                        IsBreakUpMode = p.isBreakUpMode;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_STATE:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Status p = new HEATCELL_OBJ_INTERFACE.Pack_Status();
                        if (!p.TryParse(infodata))
                            return;
                        IsInAutoONo = p.isInAutoONo;
                        MaxHeatSigma = p.maxHeatSigma;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_THICKS:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Frame p = new HEATCELL_OBJ_INTERFACE.Pack_Frame();
                        if (!p.TryParse(infodata))
                            return;
                        ThickPercents = p.frame;
                    }
                    break;

                case HEATCELL_OBJ_INTERFACE.GET_OFFSETS:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Frame p = new HEATCELL_OBJ_INTERFACE.Pack_Frame();
                        if (!p.TryParse(infodata))
                            return;
                        Offsets = p.frame;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_HEATS:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Frame p = new HEATCELL_OBJ_INTERFACE.Pack_Frame();
                        if (!p.TryParse(infodata))
                            return;
                        Heats = p.frame;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_PREHEATS:
                    {
                        HEATCELL_OBJ_INTERFACE.Pack_Frame p = new HEATCELL_OBJ_INTERFACE.Pack_Frame();
                        if (!p.TryParse(infodata))
                            return;
                        PreHeats = p.frame;
                    }
                    break;
            }
        }
        public override void PushInfo(IFConn from, uint srcid, ushort infoid, byte[] infodata)
        {
            PushGetValue(from, srcid, infoid, infodata);
        }
        public override void Dispose()
        {
            FObjSys.Current.SenseConfigEx(mConn, mServerID, ID, 0xffffffff, SENSE_CONFIG.REMOVE);
            base.Dispose();
        }
        #endregion


        public void Apply()
        {
            FObjSys.Current.SetValueEx(
              mConn, mServerID, ID,
              HEATCELL_OBJ_INTERFACE.SET_PARAMS,
              new HEATCELL_OBJ_INTERFACE.Pack_Params()
              {
                  kp = Kp,
                  autoONoKp = AutoONoKp,
                  thresholdHeatSigma = ThresholdHeatSigma,
                  ctrlLine = CtrlLine,
                  isAutoONo = IsAutoONo,
                  isForbidUpDown = IsForbidUpDown,
                  isBreakUpMode = IsBreakUpMode
              }.ToBytes());
        }

        #region INotifyPropertyChanged 成员

        public event PropertyChangedEventHandler PropertyChanged;
        protected void NotifyPropertyChanged(string propertyname)
        {
            if (PropertyChanged != null)
            {
                PropertyChanged.Invoke(this, new PropertyChangedEventArgs(propertyname));
            }
        }




        #endregion
    }
}