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

using System;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using SHJX.Service.Model.Dao;
using SHJX.Service.Model.Control;
using System.Collections.Generic;
using SHJX.Service.Common.ReadXML;
using SHJX.Service.Common.Extend;
using SHJX.Service.Dao;

namespace SHJX.Service.Control.ServiceController
{
    public class ManualController
    {
        private readonly ManualDataManager _manualDataManager;

        public ManualController(ReadConfigUtil config)
        {
            _manualDataManager = new ManualDataManager(config);
        }

        public List<EquipmentArea> GetAreaInfo()
        {
            var areas = _manualDataManager.Query<EquipmentArea>().ToList();
            if (areas.Any()) return areas;
            return null;
        }

        /// <summary>
        /// 更新区域信息
        /// </summary>
        /// <param name="area"></param>
        /// <returns></returns>
        public bool UpdateAreaInfo(EquipmentArea area)
        {
            try
            {
                var row = _manualDataManager.Update(area);
                return row > 0;
            }
            catch (Exception)
            {
                return false;
            }
        }

        /// <summary>
        /// 加热
        /// </summary>
        /// <param name="settingTemperature"></param>
        public bool SetHeating(int settingTemperature)
        {
            var portArgs = new PortArgs
            {
                TypeName = "Heat",
                Reserve = _manualDataManager.GetPreheatPid(),
                Distance = settingTemperature
            };
            return DataCentre.GetClient.Factory("Heat").Write(portArgs);
        }

        /// <summary>
        /// 吸液
        /// </summary>
        /// <param name="name"></param>
        /// <param name="amount"></param>
        public async Task<bool> ManualPumpInLiquidAsync(string name, int amount)
        {
            var res = await Task.Factory.StartNew(() =>
            {
                amount = name switch
                {
                    "PotassiumDichromate_Low" or "PotassiumDichromate_High" => -1 * Math.Abs(amount),
                    "SilverSulfate" => Math.Abs(amount),
                    _ => amount,
                };
                return DataCentre.GetPumpContent.Factory(name).LiquidOperation("In", amount);
            });
            return res;
        }


        /// <summary>
        /// 手动打开风扇
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public bool ManualFanStrat(object Name)
        {
            string opName = Name switch
            {
                "样品" => "SampleFan",
                "消解" => "DissolveFan",
                _ => throw new ArgumentNullException(Name.ToString()),
            };
            return DataCentre.GetStorageContent.Factory(opName).Start();
        }

        /// <summary>
        /// 手动关闭风扇
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public bool ManualFanStop(object Name)
        {
            string opName = Name switch
            {
                "样品" => "SampleFan",
                "消解" => "DissolveFan",
                _ => throw new ArgumentNullException(Name.ToString()),
            };
            return DataCentre.GetStorageContent.Factory(opName).Stop();
        }

        /// <summary>
        /// 手动开启搅拌
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public bool ManualStirStrat(object Name)
        {
            string opName = Name switch
            {
                "消解" => "LiquidStir",
                "滴定" => "TitrationStir",
                //"滴定(高)" => "TitrationStir2",
                _ => throw new ArgumentNullException(Name.ToString()),
            };
            return DataCentre.GetStorageContent.Factory(opName).Start();
        }

        /// <summary>
        /// 手动关闭搅拌
        /// </summary>
        /// <param name="Name"></param>
        /// <returns></returns>
        public bool ManualStirStop(object Name)
        {
            string opName = Name switch
            {
                "消解" => "LiquidStir",
                "滴定" => "TitrationStir",
                //"滴定(高)" => "TitrationStir2",
                _ => throw new ArgumentNullException(Name.ToString()),
            };
            return DataCentre.GetStorageContent.Factory(opName).Stop();
        }

        /// <summary>
        /// 泵液
        /// </summary>
        /// <param name="name"></param>
        /// <param name="second"></param>
        public async Task<bool> ManualStorageOutLiquidAsync(string name, int second, string waterName = "R1")
        {
            return await Task.Factory.StartNew(() =>
              {
                  var res = true;
                  res = res && DataCentre.GetStorageContent.Factory("Timer").Start();
                  Thread.Sleep(2000);
                  res = res && DataCentre.GetStorageContent.Factory("Timer").Stop();

                  res = res && DataCentre.GetStorageContent.Factory(name).Start(waterName);
                  Thread.Sleep(Convert.ToInt32(1000 * second));
                  res = res && DataCentre.GetStorageContent.Factory(name).Stop(waterName);
                  return res;
              });
        }

        /// <summary>
        /// 泵液
        /// </summary>
        /// <param name="name"></param>
        /// <param name="amount"></param>
        public async Task<bool> ManualPumpOutLiquidAsync(string name, int amount)
        {
            var res = await Task.Factory.StartNew(() =>
            {
                amount = name switch
                {
                    "PotassiumDichromate" or "PotassiumDichromate_Low" or "PotassiumDichromate_High" => Math.Abs(amount),
                    "SilverSulfate_1" or "SilverSulfate_13" => -1 * Math.Abs(amount),
                    _ => amount,
                };
                string pipeName = name.Equals("SilverSulfate_1") ? "2" : name.Equals("SilverSulfate_13") ? "3" : "Out";
                if (name.In("SilverSulfate_1", "SilverSulfate_13"))
                {
                    name = "SilverSulfate";
                }
                return DataCentre.GetPumpContent.Factory(name).LiquidOperation(pipeName, amount);
            });
            return res;
        }

        /// <summary>
        /// 单点移动
        /// </summary>
        /// <param name="point"></param>
        public void SinglePointMove(EquipmentArea point)
        {
            var first = DataCentre.GetAreas.FirstOrDefault(item => item.PointName.Equals(point.PointName));//检查点位是否可用
            if (first != null && DataCentre.GetAreas != null && first.Status.Equals(false))
                return;
            if (_manualDataManager.GetDoingTask())//包含正在执行或已下发的任务，不能进行手动操作
                return;
            var task = point.PointName.NewSinglePointTask();
            _manualDataManager.Insert(task);
        }

        /// <summary>
        /// 手动移动
        /// </summary>
        /// <param name="name"></param>
        /// <param name="value"></param>
        public async Task<bool> ManualMove(string name, double value)
        {
            var motor = DataCentre.GetMotor.FirstOrDefault(item => item.EquipmentName.Equals(name));
            var convertValue = motor.ConvertRatio;
            var portArgs = new PortArgs()
            {
                WriteWay = WriteWay.Move,
                TypeName = name,
                Distance = Convert.ToInt32(Math.Round(value * convertValue))
            };
            var res = await Task.Factory.StartNew(() => DataCentre.GetClient.Factory(name).Write(portArgs));
            if (!res) return false;
            motor.FinalPoint -= value;
            motor.FinalPoint = motor.FinalPoint < 0 ? 0 : motor.FinalPoint;
            _manualDataManager.Update(motor);
            return true;
        }

        /// <summary>
        /// 返回原点
        /// </summary>
        /// <param name="name"></param>
        /// <returns></returns>
        public async Task<bool> MotorGoBackAsync(string name)
        {
            var motor = DataCentre.GetMotor.FirstOrDefault(item => item.EquipmentName.Equals(name));
            if (motor is null) return false;
            var portArgs = new PortArgs()
            {
                ManualOrAuto="Manul",
                WriteWay = name.Equals("Dissolve") ? WriteWay.Antiposition : WriteWay.GoBack,
                TypeName = name,
                Distance = Convert.ToInt32(Math.Round((motor.FinalPoint * motor.ConvertRatio)))
            };
            if (name == "MotorX" || name == "MotorY")
            {
                PortArgs portArg = new()
                {
                    WriteWay = WriteWay.GoBack,
                    TypeName = "MotorZ",
                    Distance = "MotorZ".MotorFinal()
                };
                var res1 = DataCentre.GetClient.Factory("MotorZ").Write(portArg);
            }
            var res = await Task.Factory.StartNew(() => DataCentre.GetClient.Factory(name).Write(portArgs));
            if (res) motor.FinalPoint = 0;
            _manualDataManager.Update(motor);
            return res;
        }

       
        /// <summary>
        /// 冷凝管
        /// </summary>
        /// <param name="way"></param>
        /// <returns></returns>
        public async Task<bool> CageManualOperate(WriteWay way)
        {
            var opName = "Cage";
            var portArgs = new PortArgs()
            {
                WriteWay = way,
                TypeName = opName
            };
            return await Task.Factory.StartNew(() => DataCentre.GetClient.Factory(opName).Write(portArgs));
        }

        /// <summary>
        /// 机械抓手手动操作
        /// </summary>
        /// <returns></returns>
        public async Task<bool> ManiManual(WriteWay way)
        {
            const string opName = "Mani";
            var portArgs = new PortArgs
            {
                TypeName = opName,
                WriteWay = way
            };
            return await Task.Factory.StartNew(() => DataCentre.GetClient.Factory(opName).Write(portArgs));
        }

        /// <summary>
        /// 滴嘴手动操作
        /// </summary>
        /// <param name="way"></param>
        /// <returns></returns>
        public bool DripNozzleManual(string way)
        {
            bool res = false;
            switch (way)
            {
                case "Arrive":
                    res = DataCentre.GetStorageContent.Factory("DripNozzle").Start();
                    break;
                case "GoBack":
                    res = DataCentre.GetStorageContent.Factory("DripNozzle").Stop();
                    break;
            }
            return res;
        }

        /// <summary>
        /// 机械手停止
        /// </summary>
        /// <param name="motorName"></param>
        /// <returns></returns>
        public async Task<bool> MotorStop(string motorName)
        {
            PortArgs portArgs = new PortArgs
            {
                TypeName = motorName,
                WriteWay = WriteWay.Stop
            };
            return await Task.Factory.StartNew(() => DataCentre.GetClient.Factory(motorName).Write(portArgs));
        }
    }
}