RCS / RCS_Differential_Slam_Changsha · Files

using RCS.Communication;
using RCS.Model.Comm;
using RCS.Model.Entity;
using RCS.Model.PLC;
using RCS.WinClient.Common;
using SqlSugar;

namespace RCS.WinClient.Service
{
    /// <summary>
    /// 站台管理
    /// </summary>
    public class EquipmentManage
    {
        /// <summary>
        /// RCS清除站台信号
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult ClearRequest(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【清除站台信号】失败，设备【{stationName}】不存在，请检查设备表！");
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【清除站台信号】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return ClearRequestByHuaheng(equipment);
                    //case EnumPLC.EquipmentType.ShearsIn:
                    //case EnumPLC.EquipmentType.ShearsOut:
                    //    return ClearRequestByShears(equipment);
                    //case EnumPLC.EquipmentType.Door:
                    //    return ClearRequestByDoor(equipment);
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【清除站台信号】失败.异常：{ex.Message}");
            }
        }

        #region 站台操作

        /// <summary>
        /// PLC心跳处理
        /// </summary>
        /// <param name="equipmentProps"></param>
        /// <returns>心跳是否都成功，心跳成功的IP</returns>
        public BllResult Heart(Base_EquipmentProp equipmentProp)
        {
            try
            {
                if (equipmentProp.Value == EnumPLC.PLCBool.True.ToString())
                {
                    equipmentProp.Value = EnumPLC.PLCBool.False.ToString();
                }
                else
                {
                    equipmentProp.Value = EnumPLC.PLCBool.True.ToString();
                }
                var writesResult = PLCHelper.Instance.Writes(equipmentProp);
                if (!writesResult.IsSuccess)
                {
                    var msg = $"写入PLC心跳失败，原因：{writesResult.Message}";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                return BllResult.Success();
            }
            catch (Exception ex)
            {
                var msg = $"写入心跳出现异常：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// PLC心跳
        /// </summary>
        /// <param name="equipmentProps"></param>
        /// <returns>心跳是否都成功，心跳成功的IP</returns>
        public BllResult<List<string>> Heart(List<Base_EquipmentProp> equipmentProps)
        {
            try
            {
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"心跳处理，读取PLC失败！");
                //    return;
                //}
                var result = BllResult<List<string>>.Success();
                foreach (var equipmentProp in equipmentProps)
                {
                    if (equipmentProp.Value == EnumPLC.PLCBool.True.ToString())
                    {
                        equipmentProp.Value = EnumPLC.PLCBool.False.ToString();
                    }
                    else
                    {
                        equipmentProp.Value = EnumPLC.PLCBool.True.ToString();
                    }
                    var writesResult = PLCHelper.Instance.Writes(equipmentProp);
                    if (writesResult.IsSuccess)
                    {
                        result.Data.Add(equipmentProp.Equipment.Ip);
                    }
                    else
                    {
                        var msg = $"写入PLC心跳失败，原因：{writesResult.Message}";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        result.IsSuccess = false;
                    }
                }
                return result;
            }
            catch (Exception ex)
            {
                var msg = $"写入心跳出现异常：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult<List<string>>.Error(msg);

            }
        }

        /// <summary>
        /// RCS请求预占
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult RequestPlaceholder(string stationName, params object[] requestValues)
        {
            try
            {
                string rcsPlaceholderValue = requestValues.FirstOrDefault() as string;
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【请求预占】失败，设备【{stationName}】不存在，请检查设备表！");
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【请求预占】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return RequestPlaceholder(equipment, rcsPlaceholderValue);
                    case EnumPLC.EquipmentType.ShearsIn:
                        return BllResult.Error($"RCS处理【请求预占】失败，设备【{equipment.Name}】不支持请求预占！");
                    case EnumPLC.EquipmentType.ShearsOut:
                        return BllResult.Error($"RCS处理【请求预占】失败，设备【{equipment.Name}】不支持请求预占！");
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【取货】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// RCS取货检查
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult PickCheck(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【取货检查】失败，设备【{stationName}】不存在，请检查设备表！");
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【取货检查】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return PickCheckByHuaheng(equipment);
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【取货检查】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// RCS取货请求
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult RequestPick(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    //return BllResult.Error($"RCS处理【取货】失败，设备【{stationName}】不存在，请检查设备表！");
                    return BllResult.Success();
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【取货】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return RequestPickByHuaheng(equipment);
                    //case EnumPLC.EquipmentType.ShearsIn:
                    //    return BllResult.Error($"RCS处理【取货】失败，设备【{equipment.Name}】只能放货，不能取货！");
                    //case EnumPLC.EquipmentType.ShearsOut:
                    //    return RequestPickByShearsOut(equipment);
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【取货】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// RCS取货完成
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult CompletePick(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    //return BllResult.Error($"RCS处理【取货完成】失败，设备【{stationName}】不存在，请检查设备表！");
                    return BllResult.Success();
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【取货完成】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return CompletePickByHuaheng(equipment);
                    //case EnumPLC.EquipmentType.ShearsIn:
                    //    return BllResult.Error($"RCS处理【取货完成】失败，设备【{equipment.Name}】只能放货，不能取货！");
                    //case EnumPLC.EquipmentType.ShearsOut:
                    //    return CompletePickByShearsOut(equipment);
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【取货完成】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// RCS放货检查
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult PutCheck(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【放货检查】失败，设备【{stationName}】不存在，请检查设备表！");
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【放货检查】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return PutCheckByHuaheng(equipment);
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【放货检查】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// RCS放货请求
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        public BllResult RequestPut(string stationName, params object[] requestValues)
        {
            try
            {
                string? barcodeValue = requestValues.FirstOrDefault() as string;
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    //return BllResult.Error($"RCS处理【放货】失败，设备【{stationName}】不存在，请检查设备表！");
                    return BllResult.Success();
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【放货】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return RequestPutByHuaheng(equipment, barcodeValue);
                    //case EnumPLC.EquipmentType.ShearsIn:
                    //    return RequestPutByShearsIn(equipment);
                    //case EnumPLC.EquipmentType.ShearsOut:
                    //    return BllResult.Error($"RCS处理【放货】失败，设备【{equipment.Name}】只能取货，不能放货！");
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【放货】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// AGV放货完成
        /// </summary>
        /// <param name="stationName"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        public BllResult CompletePut(string stationName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == stationName);
                if (equipment == null)
                {
                    //return BllResult.Error($"RCS处理【放货完成】失败，设备【{stationName}】不存在，请检查设备表！");
                    return BllResult.Success();
                }
                if (!Enum.TryParse(equipment.Type, out EnumPLC.EquipmentType equipmentType))
                {
                    return BllResult.Error($"RCS处理【放货完成】失败，设备类型【{equipment.Type}】不支持！");
                }
                switch (equipmentType)
                {
                    case EnumPLC.EquipmentType.HuaHengStation:
                        return CompletePutByHuaheng(equipment);
                    //case EnumPLC.EquipmentType.ShearsIn:
                    //    return CompletePutByShearsIn(equipment);
                    //case EnumPLC.EquipmentType.ShearsOut:
                    //    return BllResult.Error($"RCS处理【放货完成】失败，设备【{equipment.Name}】只能取货，不能放货！");
                    default: return BllResult.Error();
                }
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{stationName}】的【放货完成】失败.异常：{ex.Message}");
            }
        }

        #endregion

        #region 门的操作

        /// <summary>
        /// 开门请求
        /// </summary>
        /// <param name="equipmentName">设备编码</param>
        /// <returns></returns>
        public BllResult OpenDoor(string equipmentName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == equipmentName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【清除站台信号】失败，设备【{equipmentName}】不存在，请检查设备表！");
                }
                //var result = PLCHelper.Instance.Reads(equipment.EquipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理站台【{barcode}】的设备【{equipment.Name}】开门请求，读取PLC发生错误：{result.Msg}");
                //    return BllResult.Error();
                //}
                return OpenDoor(equipment);
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{equipmentName}】的【开门请求】失败.异常：{ex.Message}");
            }
        }

        /// <summary>
        /// 关门
        /// </summary>
        /// <param name="equipmentName">设备编码</param>
        /// <returns></returns>
        public BllResult CloseDoor(string equipmentName)
        {
            try
            {
                var equipment = App.EquipmentList.FirstOrDefault(t => t.Name == equipmentName);
                if (equipment == null)
                {
                    return BllResult.Error($"RCS处理【关门】失败，设备【{equipmentName}】不存在，请检查设备表！");
                }
                //var result = PLCHelper.Instance.Reads(equipment.EquipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理站台【{barcode}】的设备【{equipment.Name}】关门请求，读取PLC发生错误：{result.Msg}");
                //    return BllResult.Error();
                //}
                return CloseDoor(equipment);
            }
            catch (Exception ex)
            {
                return BllResult.Error($"RCS处理站台【{equipmentName}】的【关门请求】失败.异常：{ex.Message}");
            }
        }

        #endregion

        #region 生益门的处理

        /// <summary>
        /// 开门
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        private BllResult OpenDoor(Base_Equipment equipment)
        {
            try
            {
                var openDoor = equipment[EnumPLC.PLCDoorProps.OpenDoor.ToString()];
                var rcsOpenDoor = equipment[EnumPLC.RCSDoorProps.RCSOpenDoor.ToString()];
                var rcsCloseDoor = equipment[EnumPLC.RCSDoorProps.RCSCloseDoor.ToString()];

                #region 开门请求
                if (rcsCloseDoor.Value == EnumPLC.PLCBool.True.ToString() || rcsOpenDoor.Value == EnumPLC.PLCBool.False.ToString())
                {
                    rcsOpenDoor.Value = EnumPLC.PLCBool.True.ToString();
                    rcsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { rcsOpenDoor, rcsCloseDoor });
                    if (result.IsSuccess)
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【开门请求】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【开门请求】失败，原因：{result.Message}";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                if (openDoor.Value == EnumPLC.PLCBool.True.ToString())
                {
                    var msg = $"PLC处理设备【{equipment.Name}】开门请求成功，门已经打开";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】写入【开门】成功，等待门打开";
                    //App.ExFile.MessageLog("PLCHelperWaiting", msg);
                    return BllResult.Error(msg);
                }
                #endregion

                #region 旧开门请求
                //开门完成才成功,清除开门请求
                //if (openDoor.Value == EnumPLC.PLCBool.True.ToString())
                //{
                //    if (rcsOpenDoor.Value == EnumPLC.PLCBool.False.ToString())
                //    {
                //        return BllResult.Sucess("门已经是开的！");
                //    }
                //    rcsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    var result = PLCHelper.Instance.Writes(rcsOpenDoor);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【开门请求】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Sucess(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【开门请求】失败，原因：{result.Msg}";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                //else
                //{
                //    // 先写入开门请求，等待开门
                //    if (rcsOpenDoor.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        return BllResult.Error("RCS已经向PLC写入【开门请求】信号，等待PLC响应");
                //    }
                //    rcsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    rcsOpenDoor.Value = EnumPLC.PLCBool.True.ToString();                   
                //    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { rcsCloseDoor, rcsOpenDoor}); 
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】写入【开门请求】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】写入【开门请求】失败，原因：{result.Msg}";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}

                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【开门请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 关门
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        private BllResult CloseDoor(Base_Equipment equipment)
        {
            try
            {
                var closeDoor = equipment[EnumPLC.PLCDoorProps.CloseDoor.ToString()];
                var rcsCloseDoor = equipment[EnumPLC.RCSDoorProps.RCSCloseDoor.ToString()];
                var rcsOpenDoor = equipment[EnumPLC.RCSDoorProps.RCSOpenDoor.ToString()];

                #region 开门前检查是否还有信号未清除，如果有就清除
                //List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();
                //var requestCodes = new string[] { EnumPLC.ACSDoorProps.ACSOpenDoor.ToString(), EnumPLC.ACSDoorProps.ACSCloseDoor.ToString() };

                //foreach (var item in requestCodes)
                //{
                //    var prop = equipment[item];
                //    if (prop.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        prop.Value = EnumPLC.PLCBool.False.ToString();
                //        props.Add(prop);
                //    }
                //}
                //// 如果有请求信号没清除，就全部清除
                //if (props.Count > 0)
                //{
                //    // 只要有残留信号，就把请求也清除一遍
                //    rcsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(rcsOpenDoor);
                //    rcsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(rcsCloseDoor);
                //    var result = PLCHelper.Instance.Writes(props);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【开门信号】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【开门信号】失败，原因：{result.Msg}";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                #endregion

                #region 关门请求
                if (rcsOpenDoor.Value == EnumPLC.PLCBool.True.ToString() || rcsCloseDoor.Value == EnumPLC.PLCBool.False.ToString())
                {
                    rcsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                    rcsCloseDoor.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { rcsOpenDoor, rcsCloseDoor });
                    if (result.IsSuccess)
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【关门请求】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【关门请求】失败，原因：{result.Message}";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                if (closeDoor.Value == EnumPLC.PLCBool.True.ToString())
                {
                    var msg = $"PLC处理设备【{equipment.Name}】关门请求成功，门已经关闭";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】写入【关门】成功，等待门关闭";
                    //App.ExFile.MessageLog("PLCHelperWaiting", msg);
                    return BllResult.Error(msg);
                }

                #endregion

                #region 旧的关门代码
                //if (closeDoor.Value == EnumPLC.PLCBool.True.ToString())
                //{
                //    if (rcsCloseDoor.Value == EnumPLC.PLCBool.False.ToString())
                //    {
                //        return BllResult.Sucess("门已经关闭");
                //    }
                //    //开门完成才成功，清除关门请求
                //    rcsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    var result = PLCHelper.Instance.Writes(rcsCloseDoor);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【关门请求】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Sucess(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【关门请求】失败，原因：{result.Msg}";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                //else
                //{
                //    // 先写入关门请求，等待关门
                //    if (rcsCloseDoor.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        return BllResult.Error("RCS已经向PLC写入【关门请求】信号，等待PLC响应");
                //    }
                //    rcsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    rcsCloseDoor.Value = EnumPLC.PLCBool.True.ToString();
                //    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { rcsOpenDoor, rcsCloseDoor });
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】写入【关门请求】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】写入【关门请求】失败，原因：{result.Msg}";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【关门请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 清空门的信号
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        private BllResult ClearRequestByDoor(Base_Equipment equipment)
        {
            try
            {
                var equipmentProps = equipment.EquipmentProps.Where(t => t.Code.StartsWith("RCS")).ToList();
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】清除信号，读取PLC失败！");
                //    return BllResult.Error();
                //}
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();
                foreach (var item in equipmentProps)
                {
                    if (item.Value == EnumPLC.PLCBool.True.ToString())
                    {
                        item.Value = EnumPLC.PLCBool.False.ToString();
                        props.Add(item);
                    }
                }
                if (props.Count == 0)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号成功，没有需要清除的信号!";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                if (result.IsSuccess)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】清除信号发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        #endregion

        #region 剪床站台处理

        /// <summary>
        /// AGV【清除信号】
        /// </summary>
        /// <param name="stationName"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult ClearRequestByShears(Base_Equipment equipment)
        {
            try
            {
                var equipmentProps = App.EquipmentList.Where(t => t.CADCode == equipment.CADCode)
                                                      .SelectMany(t => t.EquipmentProps)
                                                      .Where(t => t.Code.StartsWith("RCS"))
                                                      .ToList();
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】清除信号，读取PLC失败！");
                //    return BllResult.Error();
                //}
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();
                foreach (var item in equipmentProps)
                {
                    if (item.Value == EnumPLC.PLCBool.True.ToString())
                    {
                        item.Value = EnumPLC.PLCBool.False.ToString();
                        props.Add(item);
                    }
                }
                if (props.Count == 0)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号成功，没有需要清除的信号!";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                if (result.IsSuccess)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }

            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】清除信号发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// AGV【放货请求】：RCS清除残留信号==>RCS给【放货请求】==>剪床给【允许放货】（交互完成）
        /// </summary>
        /// <param name="stationName"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult RequestPutByShearsIn(Base_Equipment equipment)
        {
            try
            {
                //var equipmentProps = App.Equipments.Where(t => t.CADCode == equipment.CADCode)
                //                                   .SelectMany(t => t.EquipmentProps)
                //                                   .Where(t => t.Code.StartsWith("RCS") || t.Code == EnumPLC.PLCShearsProps.ShearsReadyPut.ToString())
                //                                   .ToList(); 
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】放货请求，读取PLC失败！");
                //    return BllResult.Error();
                //}
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();

                var rcsRequestPut = equipment[EnumPLC.RCSShearsProps.RCSRequestPut.ToString()];
                var shearsReadyPut = equipment[EnumPLC.PLCShearsProps.ShearsReadyPut.ToString()];

                #region 1.检查是否还有未清除的请求信号，如果有就清除

                //foreach (var item in equipmentProps.Where(t => t.Code != rcsRequestPut.Code))
                //{
                //    if (item.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        item.Value = EnumPLC.PLCBool.False.ToString();
                //        props.Add(item);
                //    }
                //}
                //// 如果有请求信号没清除，就全部清除
                //if (props.Count > 0)
                //{
                //    // 只要有残留信号，就把请求也清除一遍
                //    rcsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(rcsRequestPut);

                //    result = PLCHelper.Instance.Writes(props);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【请求信号】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【请求信号】失败，{result.Msg}！";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                #endregion

                #region 2.判断是否允许放货，如果没有请求放货，就写入放货请求
                if (shearsReadyPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    return BllResult.Success();
                }
                if (rcsRequestPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    return BllResult.Error("RCS已经向PLC写入【放货请求】信号，等待PLC响应");
                }
                rcsRequestPut.Value = EnumPLC.PLCBool.True.ToString();
                var result = PLCHelper.Instance.Writes(rcsRequestPut);
                if (result.IsSuccess)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】写入【放货请求】成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】写入【放货请求】失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }

                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// AGV【放货完成】：RCS清除残留信号==>剪床给【允许放货】==>RCS清除【放货请求】（交互完成）
        /// </summary>
        /// <param name="stationName"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult CompletePutByShearsIn(Base_Equipment equipment)
        {
            try
            {
                //var result = PLCHelper.Instance.Reads(equipment.EquipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】放货请求，读取PLC失败！");
                //    return BllResult.Error();
                //}
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();

                var rcsRequestPut = equipment[EnumPLC.RCSShearsProps.RCSRequestPut.ToString()];
                var completePick = equipment[EnumPLC.PLCShearsProps.CompletePick.ToString()];

                #region 1.检查是否还有未清除的请求信号，如果有就清除
                //var requestCodes = new string[]  {  EnumPLC.ACSShearsProps.ACSReadyPick.ToString(),
                //                                    EnumPLC.ACSShearsProps.ACSCompletePick.ToString()};
                //foreach (var item in requestCodes)
                //{
                //    var prop = equipment[item];
                //    if (prop.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        prop.Value = EnumPLC.PLCBool.False.ToString();
                //        props.Add(prop);
                //    }
                //}
                //// 如果有请求信号没清除，就全部清除
                //if (props.Count > 0)
                //{
                //    // 只要有残留信号，就把请求也清除一遍
                //    rcsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(rcsRequestPut);

                //    result = PLCHelper.Instance.Writes(props);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【请求信号】成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【请求信号】失败，原因：{result.Msg}！";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                #endregion

                #region 2.判断是否清除了放货请求，如果没有清除就清除掉
                if (rcsRequestPut.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Success();
                }
                if (completePick.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error($"RCS等待剪床给出完成信号！");
                }
                rcsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                var result = PLCHelper.Instance.Writes(rcsRequestPut);
                if (result.IsSuccess)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除【放货请求】成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除【放货请求】失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }

                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// AGV【取货请求】：RCS清除残留信号==>RCS给【取货请求】==>剪床给【允许取货】（交互完成）
        /// </summary>
        /// <param name="stationName"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult RequestPickByShearsOut(Base_Equipment equipment)
        {
            try
            {
                //var equipmentProps = App.Equipments.Where(t => t.CADCode == equipment.CADCode)
                //                                   .SelectMany(t => t.EquipmentProps)
                //                                   .Where(t => t.Code.StartsWith("RCS") || t.Code == EnumPLC.PLCShearsProps.ShearsRequestPut.ToString())
                //                                   .ToList();
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】取货请求，读取PLC失败！");
                //    return BllResult.Error();
                //}

                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();
                var shearsRequestPut = equipment[EnumPLC.PLCShearsProps.ShearsRequestPut.ToString()];
                var rcsReadyPick = equipment[EnumPLC.RCSShearsProps.RCSReadyPick.ToString()];

                #region 1.检查是否还有未清除的允许信号，如果有就清除

                //foreach (var item in equipmentProps.Where(t => t.Code != rcsReadyPick.Code))
                //{
                //    if (item.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        item.Value = EnumPLC.PLCBool.False.ToString();
                //        props.Add(item);
                //    }
                //}
                //// 如果有请求信号没清除，就全部清除
                //if (props.Count > 0)
                //{
                //    // 只要有残留信号，就把【允许放货】信号也清除一遍
                //    rcsReadyPick.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(rcsReadyPick);

                //    result = PLCHelper.Instance.Writes(props);
                //    if (result.Success)
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【允许放货】信号成功";
                //        App.ExFile.MessageLog("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //    else
                //    {
                //        var msg = $"RCS处理设备【{equipment.Name}】清除【允许放货】信号失败，原因：{result.Msg}！";
                //        App.ExFile.MessagePLC("PLCHelper", msg);
                //        return BllResult.Error(msg);
                //    }
                //}
                #endregion

                #region 2.如果剪床请求放货，且RCS没有允许放货，就写入允许信号
                if (shearsRequestPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    rcsReadyPick.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(rcsReadyPick);
                    if (result.IsSuccess)
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【允许放货】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Success(msg);
                    }
                    else
                    {
                        var msg = $"RCS处理设备【{equipment.Name}】写入【允许放货】失败，原因：{result.Message}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                else
                {
                    return BllResult.Error($"设备【{equipment.Name}】没有请求放货，AGV等待剪床【请求放货】信号");
                }
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【取货请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// AGV【取货完成】：RCS给【取货完成】==>剪床清除【放货请求】==>RCS清除【取货完成】
        /// </summary>
        /// <param name="stationName"></param>
        /// <returns></returns>
        private BllResult CompletePickByShearsOut(Base_Equipment equipment)
        {
            try
            {
                //var result = PLCHelper.Instance.Reads(equipment.EquipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理设备【{equipment.Name}】取货完成，读取PLC失败！");
                //    return BllResult.Error();
                //}
                BllResult<List<string>> result;
                var shearsRequestPut = equipment[EnumPLC.PLCShearsProps.ShearsRequestPut.ToString()];
                var rcsReadyPick = equipment[EnumPLC.RCSShearsProps.RCSReadyPick.ToString()];
                var rcsCompletePick = equipment[EnumPLC.RCSShearsProps.RCSCompletePick.ToString()];
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();

                #region 如果剪床还有【放货请求】， RCS没有发出【取货完成】信号就发送，如果已经发送就等待剪床清除【放货请求】
                if (shearsRequestPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    if (rcsCompletePick.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        rcsReadyPick.Value = EnumPLC.PLCBool.False.ToString();
                        rcsCompletePick.Value = EnumPLC.PLCBool.True.ToString();
                        props.Add(rcsReadyPick);
                        props.Add(rcsCompletePick);
                        result = PLCHelper.Instance.Writes(props);
                        if (result.IsSuccess)
                        {
                            var msg = $"RCS处理设备【{equipment.Name}】写入【取货完成】成功";
                            App.ExFile.MessageLog("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                        else
                        {
                            var msg = $"RCS处理设备【{equipment.Name}】写入【取货完成】失败，原因：{result.Message}！";
                            App.ExFile.MessagePLC("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                    }
                    else
                    {
                        var msg = $"RCS已经给设备【{equipment.Name}】发送了【取货完成】信号，等待剪床取消放货请求！";
                        return BllResult.Error(msg);
                    }
                }
                #endregion

                #region 如果剪床清除了【放货请求】，RCS也清除全部信号
                props.Clear();
                if (rcsReadyPick.Value == EnumPLC.PLCBool.True.ToString())
                {
                    rcsReadyPick.Value = EnumPLC.PLCBool.False.ToString();
                    props.Add(rcsReadyPick);
                }
                if (rcsCompletePick.Value == EnumPLC.PLCBool.True.ToString())
                {
                    rcsCompletePick.Value = EnumPLC.PLCBool.False.ToString();
                    props.Add(rcsCompletePick);
                }
                if (props.Count == 0)
                {
                    return BllResult.Success();
                }
                result = PLCHelper.Instance.Writes(props);
                if (result.IsSuccess)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除【取货完成】成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除【取货完成】失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }

                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【取货完成】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        #endregion

        #region 华恒站台的处理

        /// <summary>
        /// 清除华恒站台信号
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        public BllResult ClearRequestByHuaheng(Base_Equipment equipment)
        {
            try
            {
                //所有RCS开头的都是RCS写入的设备属性
                var equipmentProps = equipment.EquipmentProps.Where(t => t.Code.StartsWith("RCS")).ToList();
                //var result = PLCHelper.Instance.Reads(equipmentProps);
                //if (!result.Success)
                //{
                //    App.ExFile.MessagePLC("PLCHelper", $"RCS处理站台【{equipment.Name}】的设备【{equipment.Name}】清除信号，读取PLC失败！");
                //    return BllResult.Error();
                //}
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();
                foreach (var prop in equipmentProps)
                {
                    if (prop.Value == EnumPLC.PLCBool.True.ToString())
                    {
                        prop.Value = EnumPLC.PLCBool.False.ToString();
                        props.Add(prop);
                    }
                }
                if (props.Count == 0)
                {
                    var msg = $"RCS处理设备【{equipment.Name}】清除信号成功，没有需要清除的信号!";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                if (result.IsSuccess)
                {
                    var msg = $"RCS清除设备【{equipment.Name}】信号成功！";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"RCS清除设备【{equipment.Name}】信号失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】清除信号发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 请求预占（一个站台又出又入，提供多个AGV共用，就要抢占，不然都去放货就卡死）
        /// </summary>
        /// <param name="equipment">设备</param>
        /// <param name="ACSPlaceholderValue">是否占用</param>
        /// <returns></returns>
        private BllResult RequestPlaceholder(Base_Equipment equipment, string rcsPlaceholderValue)
        {
            try
            {
                //BllResult<List<string>> result;
                //var operate = rcsPlaceholderValue == EnumPLC.ACSPlaceholder.出库预占.GetIndexString() ? "写入" : "清除";
                //var rcsPlaceholder = equipment[EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString()];
                //if (rcsPlaceholder.Value != EnumPLC.ACSPlaceholder.无预占.GetIndexString())
                //{
                //    var msg = $"RCS处理设备【{equipment.Name}】{operate}【请求预占】失败，因为站台的预占状态不是【{EnumPLC.ACSPlaceholder.无预占}】，不能更改！";
                //    App.ExFile.MessagePLC("PLCHelper", msg);
                //return BllResult.Error(msg);
                //}
                //rcsPlaceholder.Value = rcsPlaceholderValue;
                //result = PLCHelper.Instance.Writes(rcsPlaceholder);
                //if (result.Success)
                //{

                //    var msg = $"RCS处理设备【{equipment.Name}】{operate}【请求预占】成功";
                //    App.ExFile.MessageLog("PLCHelper", msg);
                //    return BllResult.Sucess(msg);
                //}
                //else
                //{
                //    var msg = $"RCS处理设备【{equipment.Name}】{operate}【请求预占】失败，原因：{result.Msg}！";
                //    App.ExFile.MessagePLC("PLCHelper", msg);
                //    return BllResult.Error(msg);
                //}
                return BllResult.Success();
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【请求预占】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【取货检查】：检查是否有货
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        private BllResult PickCheckByHuaheng(Base_Equipment equipment)
        {
            try
            {
                //var placeholder = equipment[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                //if (placeholder == null)
                //{
                //    return BllResult.Error($"设备【{equipment.Name}】没有是否有货信号！");
                //}
                //if (placeholder.Value == EnumPLC.PLCBool.False.ToString())
                //{
                //    return BllResult.Error($"设备【{equipment.Name}】无货不能取货！");
                //}
                //else
                //{
                    return BllResult.Success();
                //}
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【取货检查】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【取货请求】：RCS给【取货请求】==>PLC给【允许取货】
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        private BllResult RequestPickByHuaheng(Base_Equipment equipment)
        {
            try
            {
                var pickAllow = equipment[EnumPLC.PLCHuaHengProps.PickAllow.ToString()];
                var rcsPickRequest = equipment[EnumPLC.RCSHuaHengProps.RCSPickRequest.ToString()];
                var rcsPickRuning = equipment[EnumPLC.RCSHuaHengProps.RCSPickRuning.ToString()];
                var rcsPickDone = equipment[EnumPLC.RCSHuaHengProps.RCSPickDone.ToString()];
                var safety = equipment[EnumPLC.RCSHuaHengProps.RCSDevicessafety.ToString()];

                var msg = string.Empty;
                #region 1.判断是否允许取货，如果没有允许取货，且没有请求取货，就写入取货请求
                if (pickAllow.Value == EnumPLC.PLCBool.False.ToString())
                {
                    if (rcsPickRequest.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        rcsPickRequest.Value = EnumPLC.PLCBool.True.ToString();
                        safety.Value = EnumPLC.PLCBool.False.ToString();
                        var resultp = PLCHelper.Instance.Writes([rcsPickRequest,safety]);
                        if (resultp.IsSuccess)
                        {
                            msg = $"ACS处理设备【{equipment.Name}】写入【取货请求】成功";
                            App.ExFile.MessageLog("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                        else
                        {
                            msg = $"ACS处理设备【{equipment.Name}】写入【取货请求】失败，原因：{resultp.Message}！";
                            App.ExFile.MessagePLC("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                    }
                    return BllResult.Error("RCS已经向PLC写入【请求取货】信号，等待PLC响应");
                }
                #endregion
                
                #region 2.如果允许取货，就写入滚动信号
                rcsPickRuning.Value = EnumPLC.PLCBool.True.ToString();
                var result = PLCHelper.Instance.Writes([rcsPickRequest, safety,rcsPickRuning]);
                if (result.IsSuccess)
                {
                    msg = $"ACS处理设备【{equipment.Name}】写入【取货中】成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    msg = $"ACS处理设备【{equipment.Name}】写入【取货中】失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【取货请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【取货完成】：PLC给【取货完成】==>RCS清除【取货请求】
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        private BllResult CompletePickByHuaheng(Base_Equipment equipment)
        {
            try
            {
                #region 如果ACS没有发送取货完成，就发送取货完成
                var pickAllow = equipment[EnumPLC.PLCHuaHengProps.PickAllow.ToString()];
                var rcsPickRequest = equipment[EnumPLC.RCSHuaHengProps.RCSPickRequest.ToString()];
                var rcsPickRuning = equipment[EnumPLC.RCSHuaHengProps.RCSPickRuning.ToString()];
                var rcsPickDone = equipment[EnumPLC.RCSHuaHengProps.RCSPickDone.ToString()];
                var safety = equipment[EnumPLC.RCSHuaHengProps.RCSDevicessafety.ToString()];

                //如果没有ACS取货完成信号，也没有ACS请求取货信号，就直接完成
                if (rcsPickDone.Value == EnumPLC.PLCBool.False.ToString())
                {
                    if (rcsPickRequest.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】发现没有【取货请求】，不用给【取货完成】信号";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Success(msg);
                    }
                    rcsPickDone.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes([rcsPickRuning, rcsPickRequest, rcsPickDone, safety]);
                    if (result.IsSuccess)
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】写入【取货完成】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】写入【取货完成】失败，原因：{result.Message}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                #endregion

                #region 如果ACS已经写入完成信号，等PLC已经处理完成信号后，ACS再清除完成信号
                if (pickAllow.Value == EnumPLC.PLCBool.False.ToString())
                {
                    rcsPickRuning.Value = EnumPLC.PLCBool.False.ToString();
                    rcsPickRequest.Value = EnumPLC.PLCBool.False.ToString();
                    rcsPickDone.Value = EnumPLC.PLCBool.False.ToString();
                    safety.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { rcsPickRuning, rcsPickRequest, rcsPickDone,safety });
                    if (result.IsSuccess)
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】清除【取货完成、取货中、取货请求】信号成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Success(msg);
                    }
                    else
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】清除【取货完成、取货中、取货请求】信号失败，原因：{result.Message}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                else
                {
                    return BllResult.Error("ACS已经向PLC写入【取货完成】信号，等待PLC响应");
                }
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【取货完成】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【放货检查】：检查是否无货
        /// </summary>
        /// <param name="equipment"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult PutCheckByHuaheng(Base_Equipment equipment)
        {
            try
            {
                //var placeholder = equipment[EnumPLC.PLCHuaHengProps.Placeholder.ToString()];
                //if (placeholder == null)
                //{
                //    return BllResult.Error($"设备【{equipment.Name}】没有是否有货信号！");
                //}
                //if (placeholder.Value == EnumPLC.PLCBool.True.ToString())
                //{
                //    return BllResult.Error($"设备【{equipment.Name}】有货不能放货！");
                //}
                //else
                //{
                    return BllResult.Success();
                //}
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货检查】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【放货请求】：RCS给【放货请求】==>PLC给【允许放货】
        /// </summary>
        /// <param name="equipment"></param>
        /// <param name="barcodeValue"></param>
        /// <returns></returns>
        private BllResult RequestPutByHuaheng(Base_Equipment equipment, string? barcodeValue)
        {
            try
            {
                var putAllow = equipment[EnumPLC.PLCHuaHengProps.PutAllow.ToString()];
                var rcsPutRequest = equipment[EnumPLC.RCSHuaHengProps.RCSPutRequest.ToString()];
                var rcsPutRuning = equipment[EnumPLC.RCSHuaHengProps.RCSPutRuning.ToString()];
                var rcsBarcode = equipment[EnumPLC.RCSHuaHengProps.RCSCode.ToString()];
                var safety = equipment[EnumPLC.RCSHuaHengProps.RCSDevicessafety.ToString()];

                #region 1.判断是否允许放货，如果没有请求放货，就写入放货请求
                if (putAllow.Value == EnumPLC.PLCBool.False.ToString())
                {
                    if (rcsPutRequest.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        rcsPutRequest.Value = EnumPLC.PLCBool.True.ToString();
                        //var resultp = PLCHelper.Instance.Writes(rcsRequestPut);
                        var resultp = PLCHelper.Instance.Writes([rcsPutRequest, safety]);

                        if (resultp.IsSuccess)
                        {
                            var msg = $"ACS处理设备【{equipment.Name}】写入【放货请求】成功";
                            App.ExFile.MessageLog("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                        else
                        {
                            var msg = $"ACS处理设备【{equipment.Name}】写入【放货请求】失败，原因：{resultp.Message}！";
                            App.ExFile.MessagePLC("PLCHelper", msg);
                            return BllResult.Error(msg);
                        }
                    }
                    return BllResult.Error("ACS已经向PLC写入【放货请求】信号，等待PLC响应");
                }
                #endregion

                #region 2.如果允许放货，就写入滚动信号和条码
                List<Base_EquipmentProp> props =
                [
                    //写入请求信号，请求信号目前不支持保存需要一起写入
                    rcsPutRequest,
                ];
                //写入滚动信号
                rcsPutRuning.Value = EnumPLC.PLCBool.True.ToString();
                props.Add(rcsPutRuning);
                //写入安全信号
                safety.Value = EnumPLC.PLCBool.False.ToString();
                props.Add(safety);

                ////给条码赋值，根据当前执行的任务来取任务里面的条码值
                //var task = App.TaskList.FirstOrDefault(t => t.Target == equipment.Name && t.IsSubmit == true);// && t.SubTaskList.FirstOrDefault()?.ActionType == EnumMsg.ActionType.升降到指定高度);
                //barcodeValue = task.TaskPallet;

                if (!string.IsNullOrEmpty(barcodeValue))
                {
                    rcsBarcode.Value = barcodeValue;
                    props.Add(rcsBarcode);
                }
                var result = PLCHelper.Instance.Writes(props);
                if (result.IsSuccess)
                {
                    var msg = $"ACS处理设备【{equipment.Name}】写入【放货中、条码】信号成功";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Success(msg);
                }
                else
                {
                    var msg = $"ACS处理设备【{equipment.Name}】写入【放货中、条码】失败，原因：{result.Message}！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货请求】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }

        /// <summary>
        /// 华恒站台【放货完成】：PLC给出【放货完成】==>RCS清除【放货请求】
        /// </summary>
        /// <param name="equipment"></param>
        /// <returns></returns>
        private BllResult CompletePutByHuaheng(Base_Equipment equipment)
        {
            try
            {
                var putAllow = equipment[EnumPLC.PLCHuaHengProps.PutAllow.ToString()];
                var rcsPutRequest = equipment[EnumPLC.RCSHuaHengProps.RCSPutRequest.ToString()];
                var rcsPutRuning = equipment[EnumPLC.RCSHuaHengProps.RCSPutRuning.ToString()];
                var rcsPutDone = equipment[EnumPLC.RCSHuaHengProps.RCSPutDone.ToString()];
                var rcsBarcode = equipment[EnumPLC.RCSHuaHengProps.RCSCode.ToString()];
                var safety = equipment[EnumPLC.RCSHuaHengProps.RCSDevicessafety.ToString()];

                var props = new List<Base_EquipmentProp>();

                #region 1.如果ACS没有发送放货完成，就发送放货完成
                //如果没有ACS放货完成信号
                if (rcsPutDone.Value == EnumPLC.PLCBool.False.ToString())
                {
                    // 没有ACS请求放货信号，就直接完成
                    if (rcsPutRequest.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】发现没有【放货请求】，不用给【放货完成】信号";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Success(msg);
                    }
                    
                    rcsPutDone.Value = EnumPLC.PLCBool.True.ToString();
                    
                    var result = PLCHelper.Instance.Writes([rcsPutDone,rcsPutRequest,rcsPutRuning,safety]);
                    if (result.IsSuccess)
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】写入【放货完成】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】写入【放货完成】失败，原因：{result.Message}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                #endregion

                #region 2.如果ACS已经写入完成信号，等PLC清除完成信号后，ACS再清除完成信号
                if (putAllow.Value == EnumPLC.PLCBool.False.ToString())
                {
                    rcsBarcode.Value = "";
                    rcsPutRuning.Value = EnumPLC.PLCBool.False.ToString();
                    rcsPutRequest.Value = EnumPLC.PLCBool.False.ToString();
                    rcsPutDone.Value = EnumPLC.PLCBool.False.ToString();
                    safety.Value = EnumPLC.PLCBool.True.ToString();

                    props.Add(rcsBarcode);
                    props.Add(rcsPutRuning);
                    props.Add(rcsPutRequest);
                    props.Add(rcsPutDone);
                    props.Add(safety);

                    var result = PLCHelper.Instance.Writes(props);
                    if (result.IsSuccess)
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】清除【放货中、请求放货、放货完成】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Success(msg);
                    }
                    else
                    {
                        var msg = $"ACS处理设备【{equipment.Name}】清除【放货中、请求放货、放货完成】失败，原因：{result.Message}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                else
                {
                    return BllResult.Error("ACS已经向PLC写入【放货完成】信号，等待PLC响应");
                }
                #endregion
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货完成】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }
        #endregion
    }
}