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 : FObjServiceClient, IHeatCellService
    {


        #region IHeatCell 接口 成员变量

        #region 参数
        /// <summary>
        /// HeatOffset = ThickPercent * Kp
        /// </summary>
        public double Kp { get; set; } = 3;


        /// <summary>
        /// 自动对位
        /// </summary>
        public bool IsAutoONo { get; set; }


        /// <summary>
        /// 自动对位的Kp
        /// </summary>
        public double AutoONoKp { get; set; } = 5;


        /// <summary>
        /// 平滑的阀值，只有超出阀值，才平滑
        /// </summary>
        public double ThresholdHeatSigma { get; set; } = 10;


        /// <summary>
        /// 自控时，不能调整总体上升下降
        /// </summary>
        public bool IsForbidUpDown { get; set; }


        /// <summary>
        /// 厚度控制线 ， 厚度% 大于 厚度控制线 自动才会加热控制  
        /// </summary>
        public int CtrlLine { get; set; }

        /// <summary>
        /// 开启打散模式, 打散模式下，以打散度小为目标，控制2sigma在 控制线内
        /// </summary>
        public bool IsBreakUpMode { get; set; }

        #endregion

        #region 状态

        /// <summary>
        /// 对应的100% 数据，单位是% 数量是BoltCnt, 数据肯定是完整的！！！！！
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public int[] ThickPercents { get; set; }


        /// <summary>
        /// 当前方向的加热策略，必须保证 0~100
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public int[] Heats { get; set; }


        private int Base { get; set; }



        /// <summary>
        /// 加热偏移量
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public int[] Offsets { get; protected set; }


        /// <summary>
        /// Heats+Offsets+Base
        /// </summary>
        [PropertyChanged.DoNotCheckEquality]
        public int[] PreHeats { get; protected set; }


        /// <summary>
        /// 加热量 每3个计算的sigma,最大值
        /// </summary>
        public double MaxHeatSigma { get; private set; }


        /// <summary>
        /// 当前正在自动对位模式
        /// </summary>
        public bool IsInAutoONo { get; protected set; }

        #endregion
        #endregion

        public HeatCellServiceClient(UInt32 serviceId) : base(serviceId) { }
        public HeatCellServiceClient(UInt32 serviceId, string connName) : base(serviceId, connName) { }
    




        #region IHeatCell 函数
        public void ModifyOffset(int idx, int change)
        {
            var p = new HEATCELL_OBJ_INTERFACE.Pack_ModifyHeatOffset()
            {
                index = idx,
                heatoffset = change
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(p);

            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_MODIFYHEATOFFSET,
               Misc.Converter.StringToBytes(json));
        }

        public void ModifyBase(int change)
        {
            var p = new HEATCELL_OBJ_INTERFACE.Pack_ModifyBase()
            {
                change = change
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(p);

            FObjSys.Current.CallFunctionEx(
              mConn, mServerID, ID,
              HEATCELL_OBJ_INTERFACE.CALL_MODIFYBASE,
              Misc.Converter.StringToBytes(json));
        }


        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()
        {
            var p = new HEATCELL_OBJ_INTERFACE.Pack_CallSmoothRequest()
            {
                thresholdHeatSigma = ThresholdHeatSigma
            };
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(p);

            FObjSys.Current.CallFunctionEx(
               mConn, mServerID, ID,
               HEATCELL_OBJ_INTERFACE.CALL_SMOOTH,
               Misc.Converter.StringToBytes(json));
        }
    

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



        #region IFObj
        public override void ConnectNotify(IFConn from)
        {
            base.ConnectNotify(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:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Params>(json);

                        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:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Status>(json);

                        IsInAutoONo = p.isInAutoONo;
                        MaxHeatSigma = p.maxHeatSigma;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_THICKS:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Frame>(json);

                        ThickPercents = p.frame;
                    }
                    break;

                case HEATCELL_OBJ_INTERFACE.GET_OFFSETS:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Frame>(json);

                        Offsets = p.frame;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_HEATS:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Frame>(json);

                        Heats = p.frame;
                    }
                    break;
                case HEATCELL_OBJ_INTERFACE.GET_PREHEATS:
                    {
                        string json = Misc.Converter.BytesToString(infodata);

                        var p = Newtonsoft.Json.JsonConvert.DeserializeObject<HEATCELL_OBJ_INTERFACE.Pack_Frame>(json);

                        PreHeats = p.frame;
                    }
                    break;
            }
        }
        public override void PushInfo(IFConn from, uint srcid, ushort infoid, byte[] infodata)
        {
            PushGetValue(from, srcid, infoid, infodata);
        }

        #endregion


        public void Apply()
        {
            var p = new HEATCELL_OBJ_INTERFACE.Pack_Params()
            {
                kp = Kp,
                autoONoKp = AutoONoKp,
                thresholdHeatSigma = ThresholdHeatSigma,
                ctrlLine = CtrlLine,
                isAutoONo = IsAutoONo,
                isForbidUpDown = IsForbidUpDown,
                isBreakUpMode = IsBreakUpMode
            };

            
            string json = Newtonsoft.Json.JsonConvert.SerializeObject(p);


            FObjSys.Current.SetValueEx(
              mConn, mServerID, ID,
              HEATCELL_OBJ_INTERFACE.SET_PARAMS,
              Misc.Converter.StringToBytes(json));
        }

    }
}