SHJX_GM/SHJX.Service.Control/Execute/LiquidPipeSwitch.cs

using SHJX.Service.Control.Common.Assets;

namespace SHJX.Service.Control.Execute
{
    public class LiquidPipeSwitch
    {
        #region Fields
        private string _liquidName;
        private static readonly object obj_locker = new();
        private static readonly ILogger logger = LogFactory.BuildLogger(typeof(LiquidPipeSwitch));
        #endregion

        private LiquidPipeSwitch() { }

        public static LiquidPipeSwitch StartNew
        {
            get
            {
                lock (obj_locker)
                {
                    return new();
                }
            }
        }

        /// <summary>
        /// 是否原点
        /// </summary>
        public bool IsArriveEndPoint
        {
            get
            {
                lock (obj_locker)
                {
                    char[] readRes = _liquidName.MotorRead();
                    if (readRes is null or { Length: 0 })
                    {
                        return false;
                    }
                    bool arriveEndPoint = readRes[2].Equals('0');
                    return arriveEndPoint;
                }
            }
        }
             

        /// <summary>
        /// 设置液体名称
        /// </summary>
        /// <param name="liquidName"></param>
        /// <returns></returns>
        public LiquidPipeSwitch SetLiquidName(string liquidName)
        {
            _liquidName = liquidName;
            return this;
        }

        /// <summary>
        /// 检查是否在原点
        /// </summary>
        /// <returns></returns>
        public LiquidPipeSwitch CheckWhetherArriveEndPoint(LiquidSwitchPattern pattern = LiquidSwitchPattern.In)
        {
            bool arriveEndPoint = IsArriveEndPoint;
            if (!arriveEndPoint )
            {
                LiquidMotorGoBack(pattern);//如果不在原点，则切换为出液模式
            }
            return this;
        }
       
       
                /// <summary>
                /// 液体电机返回原点
                /// </summary>
                /// <param name="pattern"></param>
                /// <returns></returns>
        public bool LiquidMotorGoBack(LiquidSwitchPattern pattern)
        {
            SetPattern(pattern); //如果不在原点，则切换为出液模式
            var res = _liquidName.MotorGoBack();
            try
            {
                int register = ConfigInstance.GetPortRegister(_liquidName);
                int retryCount = 0;
                for (; ; )
                {
                    Thread.Sleep(2 * 1000);//如果返回成功，则休眠两秒再次读取
                    char[] judgeRes = _liquidName.MotorRead();
                    if (judgeRes is null or not { Length: 8 })
                    {
                        return false;
                    }
                    bool reread = judgeRes[register - 1].Equals('0');
                    if (reread)
                    {
                        break;
                    }
                    retryCount++;
                    logger.LogInformation($"下发返回原点成功后，再次读取原点信号为false，重发返回原点指令第{retryCount}次");
                    res = _liquidName.MotorGoBack();
                }
                return res;
            }
            catch (Exception ex)
            {
                logger.LogInformation($"Error：液体电机返回原点异常。Exception:{ex}");
                return false;
            }
        }

        /// <summary>
        /// 执行液体操作
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        public bool Execute(object value)
        {
            bool res = Execute(LiquidSwitchPattern.In, value);
            //return res && Execute(LiquidSwitchPattern.Out, value);
            return res && Executeout();
        }

        public bool Execute(LiquidSwitchPattern pattern, object value)
        {
            SetPattern(pattern);
            int writeData = pattern switch
            {
                LiquidSwitchPattern.In => -Math.Abs(Convert.ToInt32(value)),
                LiquidSwitchPattern.Out => Math.Abs(Convert.ToInt32(value)),
                _ => throw new ArgumentNullException(nameof(pattern)),
            };
            logger.LogInformation(_liquidName + "****高锰酸钾移动****" + pattern.ToString() + writeData.ToString());
            return _liquidName.LiquidMotorMove(writeData);
        }
        public bool Executeout()
        {
            SetPattern(LiquidSwitchPattern.Out);
            logger.LogInformation(_liquidName + "****高锰酸钾回原点****" + LiquidSwitchPattern.Out.ToString());
            return LiquidMotorGoBack(LiquidSwitchPattern.Out); 
        }



        /// <summary>
        /// 设置液体模式
        /// </summary>
        /// <returns></returns>
        public void SetPattern(LiquidSwitchPattern pattern)
        {
            char[] states = _liquidName.MotorRead();
            if (states is null or  { Length: 0 })
            {
                throw new ArgumentException($"{pattern}无法读取数据！");
            }
            OptPipe(() =>
            {
                char[] readRes = _liquidName.MotorRead();
                if (readRes is null or  { Length: 0 })
                {
                    Thread.Sleep(1000);
                    return false;
                }
                bool res = pattern switch
                {
                    LiquidSwitchPattern.In => readRes[6].Equals('0'),
                    LiquidSwitchPattern.Out => readRes[7].Equals('0'),
                    _ => false,
                };
                return res;
            }, pattern.Equals(LiquidSwitchPattern.In) ? -1 : 1);
        }

        /// <summary>
        /// 选择管道（出 or 吸）
        /// </summary>
        /// <param name="func"></param>
        private void OptPipe(Func<bool> func, int orientation)
        {
            bool res = func.Invoke();
            if (res)
            {
                return;
            }
            OpenRegister();
            Policy.HandleResult<bool>(arg => arg.Equals(false)).RetryForever(_ =>
            {
                _liquidName.LiquidMotorMove(110 * orientation);
            }).Execute(func);
            CloseRegister();
        }

        /// <summary>
        /// 打开寄存器
        /// </summary>
        private void OpenRegister()
        {
            bool openRes;
            do
            {
                openRes = string.Concat(_liquidName, "Switch").RegisterOpen();
                Thread.Sleep(1000);
            } while (!openRes);
        }

        /// <summary>
        /// 关闭寄存器
        /// </summary>
        private void CloseRegister()
        {
            bool closeRes;
            do
            {
                closeRes = string.Concat(_liquidName, "Switch").RegisterClose();
                Thread.Sleep(1000);
            } while (!closeRes);
        }
    }
}