SHJX_cod/SHJX.Service.Control/ServiceController/SettingController.cs

using System;
using System.Linq;
using SHJX.Service.Dao;
using SHJX.Service.Model.Control;
using System.Collections.Generic;
using SHJX.Service.Common.ReadXML;
using SHJX.Service.Model.Dao;
namespace SHJX.Service.Control.ServiceController
{
    public class SettingController
    {
        private readonly SettingDataManager _settingDataManager;

        public SettingController(ReadConfigUtil config)
        {
            _settingDataManager = new SettingDataManager(config);
        }

        /// <summary>
        /// 设置速度
        /// </summary>
        /// <param name="speed"></param>
        /// <returns></returns>
        public bool SetSpeed(MotorSpeed speed)
        {
            var speedArgs = new PortArgs()
            {
                TypeName = speed.NodeName,
                Distance = speed.Speed,
                WriteWay = WriteWay.Speed

            };
            var res = DataCentre.GetClient.Factory(speed.NodeName).Write(speedArgs);

            #region 加速度
            var acSpeedArgs = new PortArgs()
            {
                TypeName = speed.NodeName,
                Distance = speed.AcSpeed,
                WriteWay = WriteWay.AcSpeed

            };
            res = res && DataCentre.GetClient.Factory(speed.NodeName).Write(acSpeedArgs);
            #endregion

            #region 减速度
            PortArgs deSpeedArgs = new()
            {
                TypeName = speed.NodeName,
                Distance = speed.DeSpeed,
                WriteWay = WriteWay.DeSpeed

            };
            res = res && DataCentre.GetClient.Factory(speed.NodeName).Write(deSpeedArgs);
            #endregion

            return res;
        }

        public bool SettingTemperature(int temperature)
        {
            var args = new PortArgs
            {
                TypeName = "Heat",
                Distance = temperature
            };

            return DataCentre.GetClient.Factory("Heat").Write(args);
        }

        /// <summary>
        /// 获取数据
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <returns></returns>
        public List<T> GetData<T>() where T : class
        {
            var data = _settingDataManager.Query<T>().ToList();
            return data;
        }

        public List<Wavekey> GetWavekeys()
        {
            return _settingDataManager.GetWavekeys();
        }
        //public double GetBlankValue(Wavekey WaveKey, string level,string item)
        //{
        //    var _balanceVals = DataCentre.GetBalanceValue;
        //    var blankTasks = DataCentre._dataManager.GetTaskByWaveKey(WaveKey.WaveKey, level, "空白") ?? DataCentre._dataManager.GetLastOtherTaskByWaveKey("空白", level);
        //    GetBDBlankTaskResult(blankTasks,_balanceVals.MaxVolume, out var noneValue);
        //    return noneValue;
        //}
        public double GetBlankCalibrationValue(string WaveKey, string level, string item)
        {
            var _balanceVals = DataCentre.GetBalanceValue;
            var bdTasks = DataCentre._dataManager.GetTaskByWaveKey(WaveKey, level, item) ?? DataCentre._dataManager.GetLastOtherTaskByWaveKey(item, level);
            tempCount = 0;
            if (item == "标定")
            { GetBDTaskResult(item, bdTasks, _balanceVals.MaxVolume, out var bdValue); return bdValue; }
            else
            {
                GetBlankTaskResult(item, bdTasks, _balanceVals.MaxVolume, out var bdValue);
                return bdValue;
            }
        }
        private double[] temp = new double[50];
        int tempCount = 0;
        public  void GetBlankTaskResult( string type, List<EquipmentTask> noneTasks, double maxVolume, out double blankValue)
        {
            if (noneTasks?.Count > 1)
            {
                var noneMaxValue = noneTasks.Max(item => item.Amount);
                var noneMinValue = noneTasks.Min(item => item.Amount);
                if (noneMaxValue >= maxVolume)
                {
                    GetBlankTaskResult(type, noneTasks.Where(item => item.Amount != noneMaxValue).ToList(), maxVolume, out blankValue);
                }
                if (type == "空白" && noneMaxValue - noneMinValue > 0.8)
                {
                    GetBlankTaskResult(type, noneTasks.Where(item => item.Amount != noneMinValue).ToList(), maxVolume, out blankValue);
                }
                temp[tempCount++] = Math.Round(noneTasks.Average(item => item.Amount), 2);
                blankValue = temp[0];
            }
            else
            {
                var first = noneTasks?.FirstOrDefault();
                //temp[tempCount++] = Math.Round(first?.Amount ?? 0, 2);
                if (first?.Amount >= maxVolume)
                {
                    temp[tempCount++] = 0;
                }
                else
                    temp[tempCount++] = Math.Round(first?.Amount ?? 0, 2);
                blankValue = temp[0];
            }
        }
        public void GetBDTaskResult(string type, List<EquipmentTask> bdTasks, double maxVolume, out double bdValue)
        {
            if (bdTasks is not null && bdTasks.Any())
            {
                for (int i = 0; i < bdTasks.Count; i++)
                {
                    if (bdTasks[i].Amount >= maxVolume)
                    {
                        bdTasks.Remove(bdTasks[i]);
                        i--;
                    }
                }
                if (bdTasks.Count == 0)
                {
                    bdValue = Math.Round(maxVolume, 2);
                }
                else
                {
                    var bdAmount = bdTasks.Average(item => Convert.ToDouble(item.Amount));
                    bdValue = Math.Round(bdAmount, 2);
                }
            }
            else
            {
                var first = bdTasks?.FirstOrDefault();
                if (first?.Amount >= maxVolume)
                    bdValue = 0;
                else
                    bdValue = Math.Round(first?.Amount ?? 0, 2);
            }
        }
        //public void GetBDTaskResult( List<EquipmentTask> bdTasks, double maxVolume, out double bdValue)
        //{

        //    if (bdTasks is not null && bdTasks.Any())
        //    {
        //        for (int i = 0; i < bdTasks.Count; i++)
        //        {
        //            if (bdTasks[i].Amount >= maxVolume)
        //                bdTasks.Remove(bdTasks[i]);
        //        }
        //        var bdAmount = bdTasks.Average(item => Convert.ToDouble(item.Amount));
        //    }
        //    else
        //    {
        //        var first = bdTasks?.FirstOrDefault();
        //        bdValue = first?.Amount ?? 0;
        //    }
        //}
        /// <summary>
        /// 更新信息
        /// </summary>
        /// <param name="lists"></param>
        /// <returns></returns>
        public bool UpdateValues<T>(List<T> lists) where T : class, new()
        {
            var row = _settingDataManager.Update(lists);
            return row > 0;
        }
    }
}