fix: 修复PLC通信及任务处理中的多个问题

wanshenmean

10 小时以前 f319fd5d5e5e0332c4c7e209df64c351dfbe6887

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/RobotTaskProcessor.cs

@@ -79,7 +79,7 @@
        /// <summary>
        /// 日志记录器
        /// </summary>
        private readonly ILogger _logger;
        private readonly ILogger _logger;


        /// <summary>
        /// 构造函数
@@ -146,7 +146,7 @@
        /// <returns>删除是否成功</returns>
        public bool? DeleteTask(int ID)
        {
            return _robotTaskService.Repository.DeleteDataById(ID);
            return _robotTaskService.DeleteRobotTask(ID);
        }

        /// <summary>
@@ -170,36 +170,35 @@
            // 构建取货指令，格式：Pickbattery,{源地址}
            string taskString = $"Pickbattery,{task.RobotSourceAddress}";

            // 通过 Socket 网关发送指令到机器人客户端
            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);
            // 更新任务状态为"机器人执行中"
            task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

            if (result)
            // 将任务关联到状态对象
            state.CurrentTask = task;

            if (isScanNG)
            {
                // 发送成功，记录 Info 日志
                QuartzLogHelper.LogInfo(_logger, $"下发取货指令成功，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                // 更新任务状态为"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

                // 将任务关联到状态对象
                state.CurrentTask = task;

                if (isScanNG)
                {
                    state.IsScanNG = true;
                }

                // 保持原语义：仅在状态安全写入成功后再更新任务状态
                // 这样可以确保状态和任务记录的一致性
                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
                state.IsScanNG = true;
            }
            else

            // 保持原语义：仅在状态安全写入成功后再更新任务状态
            // 这样可以确保状态和任务记录的一致性
            if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
            {
                // 发送失败，记录 Error 日志
                QuartzLogHelper.LogError(_logger, $"下发取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                QuartzLogHelper.LogInfo(_logger, $"状态更新成功，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                // 通过 Socket 网关发送指令到机器人客户端
                bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);
                if (result)
                {
                    // 发送成功，记录 Info 日志
                    QuartzLogHelper.LogInfo(_logger, $"下发取货指令成功，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                    //await _robotTaskService.UpdateRobotTaskAsync(task);
                }
                else
                {
                    // 发送失败，记录 Error 日志
                    QuartzLogHelper.LogError(_logger, $"下发取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                }
            }
        }

@@ -234,27 +233,26 @@
            // 标记点位为已使用
            _fakeBatteryPositionService.MarkAsUsed(positions);

            // 通过 Socket 网关发送指令到机器人客户端
            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);
            // 更新任务状态为"机器人执行中"
            task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

            if (result)
            // 将任务关联到状态对象
            state.CurrentTask = task;

            if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
            {
                QuartzLogHelper.LogInfo(_logger, $"下发假电芯取货指令成功，指令: {taskString}，点位: {string.Join(",", positions)}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                // 通过 Socket 网关发送指令到机器人客户端
                bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

                // 更新任务状态为"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();

                // 将任务关联到状态对象
                state.CurrentTask = task;

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                if (result)
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                    QuartzLogHelper.LogInfo(_logger, $"下发假电芯取货指令成功，指令: {taskString}，点位: {string.Join(",", positions)}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                    //await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                QuartzLogHelper.LogError(_logger, $"下发假电芯取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                else
                {
                    QuartzLogHelper.LogError(_logger, $"下发假电芯取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                }
            }
        }

@@ -307,31 +305,31 @@
        /// <param name="batchEnd">批次结束编号</param>
        public async Task SendPickWithBatchAsync(Dt_RobotTask task, RobotSocketState state, string position, int batchStart, int batchEnd)
        {
            // 先发送总数指令
            string totalNumCmd = $"PickTotalNum,{task.RobotTaskTotalNum}";
            await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);

            // 再发送批次取货指令
            string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
            string taskString = $"Pickbattery,{position},{range}";
            task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
            state.CurrentTask = task;

            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
            {
                QuartzLogHelper.LogInfo(_logger, $"下发批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                // 先发送总数指令
                string totalNumCmd = $"PickTotalNum,{task.RobotTaskTotalNum}";
                await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;
                // 再发送批次取货指令
                string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
                string taskString = $"Pickbattery,{position},{range}";

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

                if (result)
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                    QuartzLogHelper.LogInfo(_logger, $"下发批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                    //await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                QuartzLogHelper.LogError(_logger, $"下发批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                else
                {
                    QuartzLogHelper.LogError(_logger, $"下发批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                }
            }
        }

@@ -351,31 +349,31 @@
        /// <param name="batchEnd">批次结束编号</param>
        public async Task SendFakeBatteryPickWithBatchAsync(Dt_RobotTask task, RobotSocketState state, int batchStart, int batchEnd)
        {
            // 先发送总数指令
            string totalNumCmd = $"PickTotalNum,{task.RobotTaskTotalNum}";
            await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);
            task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
            state.CurrentTask = task;

            // 再发送批次取货指令（假电芯固定从5号位取）
            string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
            string taskString = $"Pickbattery,5,{range}";

            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
            {
                QuartzLogHelper.LogInfo(_logger, $"下发假电芯批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                // 先发送总数指令
                string totalNumCmd = $"PickTotalNum,{task.RobotTaskTotalNum}";
                await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;
                // 再发送批次取货指令（假电芯固定从5号位取）
                string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
                string taskString = $"Pickbattery,5,{range}";

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

                if (result)
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                    QuartzLogHelper.LogInfo(_logger, $"下发假电芯批次取货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                    //await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                QuartzLogHelper.LogError(_logger, $"下发假电芯批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                else
                {
                    QuartzLogHelper.LogError(_logger, $"下发假电芯批次取货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                }
            }
        }

@@ -396,31 +394,31 @@
        /// <param name="batchEnd">批次结束编号</param>
        public async Task SendPutWithBatchAsync(Dt_RobotTask task, RobotSocketState state, string position, int batchStart, int batchEnd)
        {
            // 先发送总数指令
            string totalNumCmd = $"PutTotalNum,{task.RobotTaskTotalNum}";
            await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);
            task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
            state.CurrentTask = task;

            // 再发送批次放货指令
            string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
            string taskString = $"Putbattery,{position},{range}";

            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
            {
                QuartzLogHelper.LogInfo(_logger, $"下发放货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                // 先发送总数指令
                string totalNumCmd = $"PutTotalNum,{task.RobotTaskTotalNum}";
                await _socketClientGateway.SendToClientAsync(state.IPAddress, totalNumCmd);

                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
                state.CurrentTask = task;
                // 再发送批次放货指令
                string range = batchEnd == 0 ? $"{batchStart}-0" : $"{batchStart}-{batchEnd}";
                string taskString = $"Putbattery,{position},{range}";

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

                if (result)
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                    QuartzLogHelper.LogInfo(_logger, $"下发放货指令成功，指令: {taskString}，批次: {range}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);

                    //await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                QuartzLogHelper.LogError(_logger, $"下发放货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                else
                {
                    QuartzLogHelper.LogError(_logger, $"下发放货指令失败，指令: {taskString}，设备: {state.RobotCrane?.DeviceName}", state.RobotCrane?.DeviceName);
                }
            }
        }

@@ -592,39 +590,6 @@
                return false;
            }

            // 解析返回的任务信息
            //var taskInfos = JsonConvert.DeserializeObject<List<Dt_Task>>(content.Data.ToJson() ?? string.Empty) ?? new List<Dt_Task>();
            //var taskInfo = taskInfos.FirstOrDefault();

            //// 获取源地址
            //string sourceAddress = taskDTO.SourceAddress;

            //// 查找源地址对应的输送线设备
            //IDevice? device = Storage.Devices.FirstOrDefault(x => x.DeviceProDTOs.Any(d => d.DeviceChildCode == sourceAddress));

            //if (device != null)
            //{
            //    // 将设备转换为输送线类型
            //    CommonConveyorLine conveyorLine = (CommonConveyorLine)device;

            //    // 设置输送线的目标地址
            //    conveyorLine.SetValue(ConveyorLineDBNameNew.Target, taskInfo.NextAddress, sourceAddress);

            //    // 设置输送线的任务号
            //    conveyorLine.SetValue(ConveyorLineDBNameNew.TaskNo, taskInfo.TaskNum, sourceAddress);

            //    // 触发输送线开始执行（写入 WCS_ACK = 1）
            //    conveyorLine.SetValue(ConveyorLineDBNameNew.WCS_ACK, (short)1, sourceAddress);

            //    // 更新任务状态到下一阶段
            //    if (_taskService.UpdateTaskStatusToNext(taskInfo).Status)
            //    {
            //        _logger.LogInformation("HandleInboundTaskAsync：入库任务处理成功，任务号: {TaskNum}", taskInfo.TaskNum);
            //        QuartzLogger.Info($"HandleInboundTaskAsync：入库任务处理成功，任务号: {taskInfo.TaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
            //        return true;
            //    }
            //}

            return true;
        }

@@ -785,5 +750,11 @@

            return result;
        }

        public bool UpdateRobotTask(Dt_RobotTask task)
        {
            WebResponseContent content = _robotTaskService.UpdateData(task);
            return content.Status;
        }
    }
}