1

Huangxiaoqiang-03

2024-11-11 d100db102ded4dc2047f1b92f4ed0ed4c18d8ee4

 ´úÂë¹ÜÀí/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/StackerCraneJob/GetStackerObject.cs

@@ -17,76 +17,81 @@
{
    public class GetStackerObject
    {
        private SpeStackerCrane _speStackerCrane;

        public GetStackerObject(SpeStackerCrane speStackerCrane)
        {
            _speStackerCrane = speStackerCrane;
        }
        /// <summary>
        /// è®¾å¤‡çŠ¶æ€
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public StackerCraneStatus StackerCraneStatusValue(SpeStackerCrane speStackerCrane) => GetStackerCraneStatus(speStackerCrane);
        public StackerCraneStatus StackerCraneStatusValue => GetStackerCraneStatus();

        /// <summary>
        /// å·¥ä½œæ¨¡å¼
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public StackerCraneAutoStatus StackerCraneAutoStatusValue(SpeStackerCrane speStackerCrane) => GetStackerCraneAutoStatus(speStackerCrane);
        public StackerCraneAutoStatus StackerCraneAutoStatusValue => GetStackerCraneAutoStatus();

        /// <summary>
        /// å·¥ä½œçŠ¶æ€
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public StackerCraneWorkStatus StackerCraneWorkStatusValue(SpeStackerCrane speStackerCrane) => GetStackerCraneWorkStatus(speStackerCrane);
        public StackerCraneWorkStatus StackerCraneWorkStatusValue => GetStackerCraneWorkStatus();

        /// <summary>
        /// ä»»åŠ¡å®Œæˆ
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public StackerCraneTaskCompleted StackerCraneTaskCompletedValue(SpeStackerCrane speStackerCrane) => GetStackerCraneTaskCompleted(speStackerCrane);
        public StackerCraneTaskCompleted StackerCraneTaskCompletedValue => GetStackerCraneTaskCompleted();

        /// <summary>
        /// ä½œä¸šå‘½ä»¤
        /// </summary>
        /// <param name="speStackerCrane"></param>
        /// <returns></returns>
        public int WorkCommandValue(SpeStackerCrane speStackerCrane) => speStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkCommand);
        public int WorkCommandValue() => _speStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkCommand);

        /// <summary>
        /// èŽ·å–堆垛机设备状态
        /// </summary>
        /// <returns></returns>
        private StackerCraneStatus GetStackerCraneStatus(SpeStackerCrane speStackerCrane)
        private StackerCraneStatus GetStackerCraneStatus()
        {
            return Enum.Parse<StackerCraneStatus>(GetStatus(nameof(StackerCraneStatus), speStackerCrane));
            return Enum.Parse<StackerCraneStatus>(GetStatus(nameof(StackerCraneStatus)));
        }

        /// <summary>
        /// èŽ·å–堆垛机手自动状态
        /// </summary>
        /// <returns></returns>
        private StackerCraneAutoStatus GetStackerCraneAutoStatus(SpeStackerCrane speStackerCrane)
        private StackerCraneAutoStatus GetStackerCraneAutoStatus()
        {
            return Enum.Parse<StackerCraneAutoStatus>(GetStatus(nameof(StackerCraneAutoStatus), speStackerCrane));
            return Enum.Parse<StackerCraneAutoStatus>(GetStatus(nameof(StackerCraneAutoStatus)));
        }

        /// <summary>
        /// èŽ·å–堆垛机工作状态
        /// </summary>
        /// <returns></returns>
        private StackerCraneWorkStatus GetStackerCraneWorkStatus(SpeStackerCrane speStackerCrane)
        private StackerCraneWorkStatus GetStackerCraneWorkStatus()
        {
            return Enum.Parse<StackerCraneWorkStatus>(GetStatus(nameof(StackerCraneWorkStatus), speStackerCrane));
            return Enum.Parse<StackerCraneWorkStatus>(GetStatus(nameof(StackerCraneWorkStatus)));
        }

        /// <summary>
        /// èŽ·å–堆垛机任务状态
        /// </summary>
        /// <returns></returns>
        private StackerCraneTaskCompleted GetStackerCraneTaskCompleted(SpeStackerCrane speStackerCrane)
        private StackerCraneTaskCompleted GetStackerCraneTaskCompleted()
        {
            return Enum.Parse<StackerCraneTaskCompleted>(GetStatus(nameof(StackerCraneTaskCompleted), speStackerCrane));
            return Enum.Parse<StackerCraneTaskCompleted>(GetStatus(nameof(StackerCraneTaskCompleted)));
        }

        private string GetEnumDes<T>(T value) where T : Enum
@@ -104,18 +109,18 @@
            return "未知";
        }

        private string GetStatus(string protocolParamType, SpeStackerCrane speStackerCrane)
        private string GetStatus(string protocolParamType)
        {
            List<DeviceProDTO> devicePros = speStackerCrane.DeviceProDTOs.Where(x => x.DeviceProParamType == protocolParamType).ToList();
            List<DeviceProDTO> devicePros = _speStackerCrane.DeviceProDTOs.Where(x => x.DeviceProParamType == protocolParamType).ToList();
            if (devicePros.Count == 0)
            {
                throw new Exception("未获取到协议信息");
            }
            for (int i = 0; i < devicePros.Count; i++)
            {
                object readStatus = speStackerCrane.Communicator.ReadAsObj(devicePros[i].DeviceProAddress, devicePros[i].DeviceDataType);
                DeviceProtocolDetailDTO? deviceProtocolDetail = speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamName) ?? throw new Exception();
                deviceProtocolDetail = speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamType && x.ProtocalDetailValue.Equals(readStatus.ToString()));
                object readStatus = _speStackerCrane.Communicator.ReadAsObj(devicePros[i].DeviceProAddress, devicePros[i].DeviceDataType);
                DeviceProtocolDetailDTO? deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamName) ?? throw new Exception();
                deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePros[i].DeviceProParamType && x.ProtocalDetailValue.Equals(readStatus.ToString()));
                if (deviceProtocolDetail != null)
                {
                    return deviceProtocolDetail.ProtocolDetailType;
@@ -124,5 +129,110 @@
            }
            return StackerCraneStatus.Unkonw.ToString();
        }

        /// <summary>
        /// å †åž›æœºä»»åŠ¡å®Œæˆäº‹ä»¶
        /// </summary>
        public event EventHandler<StackerCraneTaskCompletedEventArgs> StackerCraneTaskCompletedEventHandler;


        /// <summary>
        /// å †åž›æœºå®Œæˆäº‹ä»¶æ˜¯å¦å·²è®¢é˜…
        /// </summary>
        public bool IsEventSubscribed => StackerCraneTaskCompletedEventHandler != null;


        private bool _isChecked = false;

        /// <summary>
        /// ç›‘测堆垛机任务是否完成
        /// </summary>
        public void CheckStackerCraneTaskCompleted()
        {
            if (_isChecked)
                return;

            Task.Run(() =>
            {
                _isChecked = true;
                try
                {
                    DeviceProDTO? devicePro = _speStackerCrane.DeviceProDTOs.FirstOrDefault(x => x.DeviceProParamName == nameof(StackerCraneTaskCompleted));
                    if (devicePro != null)
                    {
                        DeviceProtocolDetailDTO? deviceProtocolDetail = _speStackerCrane.DeviceProtocolDetailDTOs.FirstOrDefault(x => x.DeviceProParamName == devicePro.DeviceProParamName && x.ProtocolDetailType == StackerCraneTaskCompleted.WorkCompleted.ToString());
                        if (deviceProtocolDetail != null)
                        {
                            OperateResult<TimeSpan> operateResult = new OperateResult<TimeSpan>();
                            TypeCode typeCode = SiemensDBDataType.GetTypeCode(devicePro.DeviceDataType);
                            switch (typeCode)
                            {
                                case TypeCode.Boolean:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToBoolean(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Byte:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToByte(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Int16:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToInt16(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.Int32:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToInt32(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.UInt16:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToUInt16(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                case TypeCode.UInt32:
                                    operateResult = _speStackerCrane.Communicator.Wait(devicePro.DeviceProAddress, 500, 10 * 6000, Convert.ToUInt32(deviceProtocolDetail.ProtocalDetailValue));
                                    break;
                                default:
                                    break;
                            }
                            int taskNum = _speStackerCrane.CurrentTaskNum;
                            if (operateResult.IsSuccess)
                            {
                                StackerCraneTaskCompletedEventArgs args = new(taskNum);
                                StackerCraneTaskCompletedEventHandler?.Invoke(_speStackerCrane, args);
                            }
                        }
                    }
                }
                catch (Exception ex)
                {

                }
                finally
                {
                    _isChecked = false;
                }
            });
        }

        public bool SendCommand(StackerCraneTaskCommand command)
        {
            try
            {
                if(_speStackerCrane.IsConnected)
                {
                    _speStackerCrane.SetValue(StackerCraneDBName.TaskNum, command.TaskNum);
                    _speStackerCrane.SetValue(StackerCraneDBName.StartRow, command.StartRow);
                    _speStackerCrane.SetValue(StackerCraneDBName.StartColumn, command.StartColumn);
                    _speStackerCrane.SetValue(StackerCraneDBName.StartLayer, command.StartLayer);
                    _speStackerCrane.SetValue(StackerCraneDBName.EndRow, command.EndRow);
                    _speStackerCrane.SetValue(StackerCraneDBName.EndColumn, command.EndColumn);
                    _speStackerCrane.SetValue(StackerCraneDBName.EndLayer, command.EndLayer);
                    _speStackerCrane.SetValue(StackerCraneDBName.Barcode, command.Barcode);
                    _speStackerCrane.SetValue(StackerCraneDBName.WorkType, command.WorkType);
                    _speStackerCrane.SetValue(StackerCraneDBName.TrayType, command.TrayType);
                    return true;
                }
                return false;

            }
            catch (Exception ex)
            {
                return false;
            }
        }
    }
}