添加日志信息

xby-y

7 天以前 b3ff80e45d24a821ca0731983b1546b48570cdf1

 ÏîÄ¿´úÂë/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/StackerCraneJob/CommonStackerCraneJob.cs

@@ -45,9 +45,10 @@
        private readonly ICacheService _cacheService; private readonly IRepository<Dt_Router> _routerRepository;
        private readonly IRepository<Dt_StationManger> _stationMangerRepository;
        private readonly IRepository<Dt_Task> _taskRepository;
        private readonly CommonConveyorLineJob _lineJob;
        //bool SCres = false;

        public CommonStackerCraneJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, ICacheService cacheService, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository, IRepository<Dt_Task> taskRepository)
        public CommonStackerCraneJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, ICacheService cacheService, IRepository<Dt_Router> routerRepository, IRepository<Dt_StationManger> stationMangerRepository, IRepository<Dt_Task> taskRepository, CommonConveyorLineJob lineJob)
        {
            _taskService = taskService;
            _routerService = routerService;
@@ -55,6 +56,7 @@
            _routerService = routerService;
            _stationMangerRepository = stationMangerRepository;
            _taskRepository = taskRepository;
            _lineJob = lineJob;
        }

        public Task Execute(IJobExecutionContext context)
@@ -111,97 +113,6 @@
         }
       

        /*
        // æ·»åŠ äº‹ä»¶è®¢é˜…状态标记
        private static readonly Dictionary<string, bool> _eventSubscribedMap = new Dictionary<string, bool>();
        private static readonly object _lockObject = new object();
        public Task Execute(IJobExecutionContext context)
        {
            try
            {
                SpeStackerCrane speStackerCrane = (SpeStackerCrane)context.JobDetail.JobDataMap.Get("JobParams");
                if (speStackerCrane != null)
                {
                    GetStackerObject getStackerObject = new GetStackerObject(speStackerCrane);

                    // ä½¿ç”¨é”ç¡®ä¿çº¿ç¨‹å®‰å…¨çš„事件订阅
                    lock (_lockObject)
                    {
                        string deviceKey = speStackerCrane.DeviceCode;
                        if (!_eventSubscribedMap.ContainsKey(deviceKey) || !_eventSubscribedMap[deviceKey])
                        {
                            getStackerObject.StackerCraneTaskCompletedEventHandler += CommonStackerCrane_StackerCraneTaskCompletedEventHandler;
                            _eventSubscribedMap[deviceKey] = true;
                        }
                    }

                    getStackerObject.CheckStackerCraneTaskCompleted();
                    if (getStackerObject.StackerCraneStatusValue == StackerCraneStatus.Normal)
                    {
                        Dt_Task? task = GetTasks(speStackerCrane);
                        if (task != null)
                        {
                            WriteInfo("查找堆垛机任务号", $"任务信息,任务号:{task.TaskNum}，堆垛机编号{speStackerCrane.DeviceCode}");
                            bool sendFlag = true;
                            if (sendFlag)
                            {
                                StackerCraneTaskCommand? stackerCraneTaskCommand = ConvertToStackerCraneTaskCommand(task); //转换为堆垛机任务
                                if (stackerCraneTaskCommand != null)
                                {
                                    sendFlag = getStackerObject.SendCommand(stackerCraneTaskCommand); //发送堆垛机任务
                                    if (sendFlag)
                                    {
                                        speStackerCrane.SetValue(StackerCraneDBName.CommandSend, 1);//启动命令
                                        speStackerCrane.LastTaskType = task.TaskType;
                                        task.Dispatchertime = DateTime.Now;
                                        task.ExceptionMessage = "";

                                        WebResponseContent webResponseContent = _taskService.UpdateTaskStatusToNext(task.TaskNum);
                                        //延时1s
                                        Thread.Sleep(1000);
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                WriteError("堆垛机任务执行异常", ex.Message);
                throw;
            }
            return Task.CompletedTask;
        }

        private void CommonStackerCrane_StackerCraneTaskCompletedEventHandler(object? sender, StackerCraneTaskCompletedEventArgs e)
        {
            SpeStackerCrane? speStackerCrane = sender as SpeStackerCrane;
            if (speStackerCrane != null)
            {
                // ä½¿ç”¨é”ç¡®ä¿åŒä¸€ä»»åŠ¡ä¸ä¼šè¢«å¹¶å‘处理
                lock (_lockObject)
                {
                    if (speStackerCrane.GetValue<StackerCraneDBName, short>(StackerCraneDBName.WorkType) != 5)
                    {
                        var currentTaskNum = speStackerCrane.GetValue<StackerCraneDBName, Int32>(StackerCraneDBName.CurrentTaskNum);
                        WriteInfo("堆垛机任务完成", $"PLC任务号:{currentTaskNum}, ç³»ç»Ÿä»»åŠ¡å·:{e.TaskNum}, æ—¶é—´:{DateTime.Now:yyyy-MM-dd HH:mm:ss.fff}");

                        _taskService.StackCraneTaskCompleted(e.TaskNum);
                        WriteInfo("堆垛机任务完成反馈任务号", $"任务信息,任务号:{e.TaskNum}");
                        speStackerCrane.SetValue(StackerCraneDBName.WorkType, 5);

                        WriteInfo("堆垛机任务状态更新", $"任务{e.TaskNum}完成状态已设置");
                    }
                    else
                    {
                        WriteInfo("堆垛机任务重复完成事件", $"任务号:{e.TaskNum} å·²è¢«å¤„理，忽略重复事件");
                    }
                }
            }
        }
        */

        private void CommonStackerCrane_StackerCraneTaskCompletedEventHandler(object? sender, StackerCraneTaskCompletedEventArgs e)
        {
            SpeStackerCrane? speStackerCrane = sender as SpeStackerCrane;
@@ -232,6 +143,13 @@
        private Dt_Task? GetTasks(SpeStackerCrane commonStackerCrane)
        {
            Dt_Task? task;
            // PLC状态检查：WorkType必须为0（空闲状态）
            var workType = commonStackerCrane.GetValue<StackerCraneDBName, byte>(StackerCraneDBName.StackerCraneWorkStatus);
            //var workType = commonStackerCrane.GetValue<StackerCraneDBName, byte>(StackerCraneDBName.StackerCraneWorkStatus);
            if (workType != 0)
            {
                return null;
            }

            //堆垛机执行中
            if (_taskRepository.QueryFirst(x => x.DeviceCode == commonStackerCrane.DeviceCode && x.TaskState == TaskStatusEnum.SC_Executing.ObjToInt()) != null)
@@ -242,26 +160,25 @@
            task = _taskService.QueryStackerCraneInTask(commonStackerCrane.DeviceCode);         //获取入库任务
            List<Dt_Task> YKtasks = _taskService.QueryStackerCraneYKTasks(commonStackerCrane.DeviceCode);


            if (task != null)
            {
                if(task.Roadway=="SC02") return task;    //如果有任务则直接下发给堆垛机
                if(task.Depth==1) return task;
                //2深位进行判断是否要移库

                Dt_Task dt_Task = _taskService.RequestWMSTaskMovelibrary(task);
                if (task.Roadway == "SC02") return task;    //如果有任务则直接下发给堆垛机
                if (task.Depth == 1) return task;
                //2深位进行判断是否要移库
                Dt_Task dt_Task = OutTaskMovelibrary(task);
                if (dt_Task != null) return dt_Task;
            }
            else if (YKtasks.Count > 0)
            else if (YKtasks.Count > 0) //库位调拨
            {
                foreach (var item in YKtasks)
                {
                        if (item.Roadway == "SC01")
                        {
                            if (item.Depth == 1) return item;
                            //调取WMS接口进行判断是否需要进行移库
                            Dt_Task dt_Task = OutTaskMovelibrary(item);
                            if (dt_Task != null) return dt_Task;
                    if (item.Roadway == "SC01")
                    {
                        if (item.Depth == 1) return item;
                        //调取WMS接口进行判断是否需要进行移库
                        Dt_Task dt_Task = OutTaskMovelibrary(item);
                        if (dt_Task != null) return dt_Task;

                        else
                        {
@@ -275,33 +192,42 @@
            {
                //进行获取堆垛机出库任务
                List<Dt_Task> tasks = _taskService.QueryStackerCraneOutTasks(commonStackerCrane.DeviceCode);
                foreach (var item in tasks)
                {
                    if (OutTaskStationIsOccupied(item) != null)
                    foreach (var item in tasks)
                    {
                        if (item.Roadway == "SC01")
                    if (OutTaskStationIsOccupied(item) != null)
                        {
                            if (item.Depth == 1) return item;
                            //调取WMS接口进行判断是否需要进行移库
                            Dt_Task dt_Task = OutTaskMovelibrary(item);
                            if (dt_Task != null) return dt_Task;
                            if (item.Roadway == "SC01")
                            {
                                if (item.Depth == 1) return item;
                                //调取WMS接口进行判断是否需要进行移库
                                Dt_Task dt_Task = OutTaskMovelibrary(item);
                                if (dt_Task != null) return dt_Task;

                            }
                            else
                            {
                                return item;
                            }
                        }
                        else
                        {
                            return item;
                        }
                    }
                    
                }
            }


            return task;
        }

        private Dt_Task? OutTaskMovelibrary([NotNull] Dt_Task task)
        {
            string[] targetCodes = task.SourceAddress.Split("-");
            string[] targetCodes;
            if (task.TaskType == (int)TaskInboundTypeEnum.Inbound)
            {
                targetCodes = task.TargetAddress.Split("-");

            }
            else
            {
                targetCodes = task.SourceAddress.Split("-");

            }
            if (targetCodes[1] == "001")
            {
                targetCodes[1] = "002";
@@ -337,15 +263,37 @@
                if (device != null)
                {
                    OtherDevice conveyorLine = (OtherDevice)device;
                    DeviceProDTO? deviceProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == task.NextAddress && x.DeviceProParamName == "IsOccupied");    //根据堆垛机地址，地址名称找协议
                    if (deviceProDTO != null)

                    if (task.TargetAddress == "2021" || task.TargetAddress == "2020" || task.TargetAddress == "2009")
                    {
                        bool B_Event_Test = conveyorLine.Communicator.Read<bool>(deviceProDTO.DeviceProAddress);        //判断输送线是否允许放货信号
                        if (!B_Event_Test)
                        DeviceProDTO? deviceProDTO2007 = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == "2007" && x.DeviceProParamName == "IsOccupied");    //根据堆垛机地址，地址名称找协议
                        DeviceProDTO? deviceProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == task.NextAddress && x.DeviceProParamName == "IsOccupied");    //根据堆垛机地址，地址名称找协议

                        if (deviceProDTO != null)
                        {
                            return task;
                            bool B_Event_Test = conveyorLine.Communicator.Read<bool>(deviceProDTO.DeviceProAddress);        //判断输送线是否允许放货信号
                            bool B_Event_Test2007 = conveyorLine.Communicator.Read<bool>(deviceProDTO2007.DeviceProAddress);        //判断2007输送线是否允许放货信号

                            if (!B_Event_Test && !B_Event_Test2007)
                            {
                                return task;
                            }
                        }

                    }
                    else
                    {
                        DeviceProDTO? deviceProDTO = conveyorLine.DeviceProDTOs.FirstOrDefault(x => x.DeviceChildCode == task.NextAddress && x.DeviceProParamName == "IsOccupied");    //根据堆垛机地址，地址名称找协议
                        if (deviceProDTO != null)
                        {
                            bool B_Event_Test = conveyorLine.Communicator.Read<bool>(deviceProDTO.DeviceProAddress);        //判断输送线是否允许放货信号
                            if (!B_Event_Test)
                            {
                                return task;
                            }
                        }
                    }

                }
            }
            catch (Exception ex)