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.Success)
                {
                    var msg = $"写入PLC心跳失败，原因：{writesResult.Msg}";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                return BllResult.Sucess();
            }
            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>>.Sucess();
                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.Success)
                    {
                        result.Data.Add(equipmentProp.Equipment.Ip);
                    }
                    else
                    {
                        var msg = $"写入PLC心跳失败，原因：{writesResult.Msg}";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        result.Success = 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 acsPlaceholderValue = 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, acsPlaceholderValue);
                    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}】不存在，请检查设备表！");
                }
                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}】不存在，请检查设备表！");
                }
                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}】不存在，请检查设备表！");
                }
                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}】不存在，请检查设备表！");
                }
                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 acsOpenDoor = equipment[EnumPLC.ACSDoorProps.ACSOpenDoor.ToString()];
                var acsCloseDoor = equipment[EnumPLC.ACSDoorProps.ACSCloseDoor.ToString()];

                #region 开门请求
                if (acsCloseDoor.Value == EnumPLC.PLCBool.True.ToString() || acsOpenDoor.Value == EnumPLC.PLCBool.False.ToString())
                {
                    acsOpenDoor.Value = EnumPLC.PLCBool.True.ToString();
                    acsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsOpenDoor, acsCloseDoor });
                    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);
                    }
                }
                if (openDoor.Value == EnumPLC.PLCBool.True.ToString())
                {
                    var msg = $"PLC处理设备【{equipment.Name}】开门请求成功，门已经打开";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Sucess(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 (acsOpenDoor.Value == EnumPLC.PLCBool.False.ToString())
                //    {
                //        return BllResult.Sucess("门已经是开的！");
                //    }
                //    acsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    var result = PLCHelper.Instance.Writes(acsOpenDoor);
                //    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 (acsOpenDoor.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        return BllResult.Error("RCS已经向PLC写入【开门请求】信号，等待PLC响应");
                //    }
                //    acsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    acsOpenDoor.Value = EnumPLC.PLCBool.True.ToString();                   
                //    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsCloseDoor, acsOpenDoor}); 
                //    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 acsCloseDoor = equipment[EnumPLC.ACSDoorProps.ACSCloseDoor.ToString()];
                var acsOpenDoor = equipment[EnumPLC.ACSDoorProps.ACSOpenDoor.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)
                //{
                //    // 只要有残留信号，就把请求也清除一遍
                //    acsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(acsOpenDoor);
                //    acsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(acsCloseDoor);
                //    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 (acsOpenDoor.Value == EnumPLC.PLCBool.True.ToString() || acsCloseDoor.Value == EnumPLC.PLCBool.False.ToString())
                {
                    acsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                    acsCloseDoor.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsOpenDoor, acsCloseDoor });
                    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);
                    }
                }
                if (closeDoor.Value == EnumPLC.PLCBool.True.ToString())
                {
                    var msg = $"PLC处理设备【{equipment.Name}】关门请求成功，门已经关闭";
                    App.ExFile.MessageLog("PLCHelper", msg);
                    return BllResult.Sucess(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 (acsCloseDoor.Value == EnumPLC.PLCBool.False.ToString())
                //    {
                //        return BllResult.Sucess("门已经关闭");
                //    }
                //    //开门完成才成功，清除关门请求
                //    acsCloseDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    var result = PLCHelper.Instance.Writes(acsCloseDoor);
                //    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 (acsCloseDoor.Value == EnumPLC.PLCBool.True.ToString())
                //    {
                //        return BllResult.Error("RCS已经向PLC写入【关门请求】信号，等待PLC响应");
                //    }
                //    acsOpenDoor.Value = EnumPLC.PLCBool.False.ToString();
                //    acsCloseDoor.Value = EnumPLC.PLCBool.True.ToString();
                //    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsOpenDoor, acsCloseDoor });
                //    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.Sucess(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                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);
                }
            }
            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.Sucess(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                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);
                }

            }
            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 acsRequestPut = equipment[EnumPLC.ACSShearsProps.ACSRequestPut.ToString()];
                var shearsReadyPut = equipment[EnumPLC.PLCShearsProps.ShearsReadyPut.ToString()];

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

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

                //    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.Sucess();
                }
                if (acsRequestPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    return BllResult.Error("RCS已经向PLC写入【放货请求】信号，等待PLC响应");
                }
                acsRequestPut.Value = EnumPLC.PLCBool.True.ToString();
                var result = PLCHelper.Instance.Writes(acsRequestPut);
                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>
        /// 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 acsRequestPut = equipment[EnumPLC.ACSShearsProps.ACSRequestPut.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)
                //{
                //    // 只要有残留信号，就把请求也清除一遍
                //    acsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                //    props.Add(acsRequestPut);

                //    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 (acsRequestPut.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Sucess();
                }
                if (completePick.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error($"RCS等待剪床给出完成信号！");
                }
                acsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                var result = PLCHelper.Instance.Writes(acsRequestPut);
                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);
                }

                #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 acsReadyPick = equipment[EnumPLC.ACSShearsProps.ACSReadyPick.ToString()];

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

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

                //    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())
                {
                    acsReadyPick.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(acsReadyPick);
                    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
                {
                    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 acsReadyPick = equipment[EnumPLC.ACSShearsProps.ACSReadyPick.ToString()];
                var acsCompletePick = equipment[EnumPLC.ACSShearsProps.ACSCompletePick.ToString()];
                List<Base_EquipmentProp> props = new List<Base_EquipmentProp>();

                #region 如果剪床还有【放货请求】， RCS没有发出【取货完成】信号就发送，如果已经发送就等待剪床清除【放货请求】
                if (shearsRequestPut.Value == EnumPLC.PLCBool.True.ToString())
                {
                    if (acsCompletePick.Value == EnumPLC.PLCBool.False.ToString())
                    {
                        acsReadyPick.Value = EnumPLC.PLCBool.False.ToString();
                        acsCompletePick.Value = EnumPLC.PLCBool.True.ToString();
                        props.Add(acsReadyPick);
                        props.Add(acsCompletePick);
                        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);
                        }
                    }
                    else
                    {
                        var msg = $"RCS已经给设备【{equipment.Name}】发送了【取货完成】信号，等待剪床取消放货请求！";
                        return BllResult.Error(msg);
                    }
                }
                #endregion

                #region 如果剪床清除了【放货请求】，RCS也清除全部信号
                props.Clear();
                if (acsReadyPick.Value == EnumPLC.PLCBool.True.ToString())
                {
                    acsReadyPick.Value = EnumPLC.PLCBool.False.ToString();
                    props.Add(acsReadyPick);
                }
                if (acsCompletePick.Value == EnumPLC.PLCBool.True.ToString())
                {
                    acsCompletePick.Value = EnumPLC.PLCBool.False.ToString();
                    props.Add(acsCompletePick);
                }
                if (props.Count == 0)
                {
                    return BllResult.Sucess();
                }
                result = PLCHelper.Instance.Writes(props);
                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);
                }

                #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 != EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString() &&
                                                                         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.Sucess(msg);
                }
                var result = PLCHelper.Instance.Writes(props);
                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);
                }
            }
            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 acsPlaceholderValue)
        {
            try
            {
                BllResult<List<string>> result;
                var operate = acsPlaceholderValue == EnumPLC.ACSPlaceholder.出库预占.GetIndexString() ? "写入" : "清除";
                var acsPlaceholder = equipment[EnumPLC.ACSHuaHengProps.ACSPlaceholder.ToString()];
                if (acsPlaceholder.Value != EnumPLC.ACSPlaceholder.无预占.GetIndexString())
                {
                    var msg = $"RCS处理设备【{equipment.Name}】{operate}【请求预占】失败，因为站台的预占状态不是【{EnumPLC.ACSPlaceholder.无预占}】，不能更改！";
                    App.ExFile.MessagePLC("PLCHelper", msg);
                    return BllResult.Error(msg);
                }
                acsPlaceholder.Value = acsPlaceholderValue;
                result = PLCHelper.Instance.Writes(acsPlaceholder);
                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);
                }
            }
            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.Sucess();
                }
            }
            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 acsRequestPick = equipment[EnumPLC.ACSHuaHengProps.ACSRequestPick.ToString()];
                var converyorReadyPick = equipment[EnumPLC.PLCHuaHengProps.ConveryorReadyPick.ToString()];

                var msg = string.Empty;
                if (acsRequestPick.Value == EnumPLC.PLCBool.False.ToString())
                {
                    acsRequestPick.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(acsRequestPick);
                    if (result.Success)
                    {
                        msg = $"RCS处理设备【{equipment.Name}】写入【取货请求】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        msg = $"RCS处理设备【{equipment.Name}】写入【取货请求】失败，原因：{result.Msg}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                if (converyorReadyPick.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error("RCS已经向PLC写入【取货请求】信号，等待PLC响应");
                }
                msg = $"RCS处理设备【{equipment.Name}】的【取货请求】成功，设备现在允许取货";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Sucess(msg);
            }
            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
            {
                var acsRequestPick = equipment[EnumPLC.ACSHuaHengProps.ACSRequestPick.ToString()];
                var completePick = equipment[EnumPLC.PLCHuaHengProps.CompletePick.ToString()];
                var converyorReadyPick = equipment[EnumPLC.PLCHuaHengProps.ConveryorReadyPick.ToString()];

                if (converyorReadyPick.Value == EnumPLC.PLCBool.True.ToString() && completePick.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error("等待PLC给出【取货完成】信号！");
                }
                acsRequestPick.Value = EnumPLC.PLCBool.False.ToString();
                var result = PLCHelper.Instance.Writes(acsRequestPick);
                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);
                }
            }
            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.Sucess();
                }
            }
            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 acsBarcode = equipment[EnumPLC.ACSHuaHengProps.ACSBarcode.ToString()];
                var acsRequestPut = equipment[EnumPLC.ACSHuaHengProps.ACSRequestPut.ToString()];
                var converyorReadyPut = equipment[EnumPLC.PLCHuaHengProps.ConveryorReadyPut.ToString()];

                var msg = string.Empty;
                if (acsRequestPut.Value == EnumPLC.PLCBool.False.ToString())
                {
                    acsBarcode.Value = barcodeValue;
                    acsRequestPut.Value = EnumPLC.PLCBool.True.ToString();
                    var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsBarcode, acsRequestPut });
                    if (result.Success)
                    {
                        msg = $"RCS处理设备【{equipment.Name}】写入【放货请求、条码】成功";
                        App.ExFile.MessageLog("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                    else
                    {
                        msg = $"RCS处理设备【{equipment.Name}】写入【放货请求、条码】失败，原因：{result.Msg}！";
                        App.ExFile.MessagePLC("PLCHelper", msg);
                        return BllResult.Error(msg);
                    }
                }
                if (converyorReadyPut.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error("RCS已经向PLC写入【放货请求】信号，等待PLC响应");
                }
                msg = $"RCS处理设备【{equipment.Name}】的【放货请求】成功，设备现在允许放货";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Sucess(msg);
            }
            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 acsBarcode = equipment[EnumPLC.ACSHuaHengProps.ACSBarcode.ToString()];
                var acsRequestPut = equipment[EnumPLC.ACSHuaHengProps.ACSRequestPut.ToString()];
                var converyorReadyPut = equipment[EnumPLC.PLCHuaHengProps.ConveryorReadyPut.ToString()];
                var completePut = equipment[EnumPLC.PLCHuaHengProps.CompletePut.ToString()];

                if (converyorReadyPut.Value == EnumPLC.PLCBool.True.ToString() && completePut.Value == EnumPLC.PLCBool.False.ToString())
                {
                    return BllResult.Error("等待PLC给出【放货完成】信号！");
                }
                acsBarcode.Value = "";
                acsRequestPut.Value = EnumPLC.PLCBool.False.ToString();
                var result = PLCHelper.Instance.Writes(new List<Base_EquipmentProp> { acsBarcode, acsRequestPut });
                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);
                }
            }
            catch (Exception ex)
            {
                var msg = $"RCS处理设备【{equipment.Name}】的【放货完成】发生异常，异常信息：{ex.Message}，堆栈：{ex.StackTrace}";
                App.ExFile.MessageLog("PLCHelper", msg);
                return BllResult.Error(msg);
            }
        }



        #endregion


    }
}