feat(机器人任务): 实现换盘任务假电芯补充逻辑

wanshenmean

10 小时以前 ad64840cc04dac2278ca02f22ddc02b1a218e9cf

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

@@ -1,3 +1,4 @@
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using WIDESEA_Core;
using WIDESEAWCS_Common;
@@ -68,6 +69,19 @@
        private readonly HttpClientHelper _httpClientHelper;

        /// <summary>
        /// 假电芯平面点位服务
        /// </summary>
        /// <remarks>
        /// 用于管理假电芯平面点位的分配和状态。
        /// </remarks>
        private readonly IFakeBatteryPositionService _fakeBatteryPositionService;

        /// <summary>
        /// 日志记录器
        /// </summary>
        private readonly ILogger _logger;

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="socketClientGateway">Socket 网关</param>
@@ -75,18 +89,23 @@
        /// <param name="robotTaskService">机器人任务服务</param>
        /// <param name="taskService">通用任务服务</param>
        /// <param name="httpClientHelper">HTTP 客户端帮助类</param>
        /// <param name="logger">日志记录器</param>
        public RobotTaskProcessor(
            ISocketClientGateway socketClientGateway,
            RobotStateManager stateManager,
            IRobotTaskService robotTaskService,
            ITaskService taskService,
            HttpClientHelper httpClientHelper)
            HttpClientHelper httpClientHelper,
            ILogger logger,
            IFakeBatteryPositionService fakeBatteryPositionService)
        {
            _socketClientGateway = socketClientGateway;
            _stateManager = stateManager;
            _robotTaskService = robotTaskService;
            _taskService = taskService;
            _httpClientHelper = httpClientHelper;
            _logger = logger;
            _fakeBatteryPositionService = fakeBatteryPositionService;
        }

        /// <summary>
@@ -101,6 +120,20 @@
        public Dt_RobotTask? GetTask(RobotCraneDevice robotCrane)
        {
            return _robotTaskService.QueryRobotCraneTask(robotCrane.DeviceCode);
        }

        /// <summary>
        /// 按设备编码获取当前机器人的执行中任务
        /// </summary>
        /// <remarks>
        /// 从数据库中查询指定设备编码的执行中机器人任务。
        /// 当RobotArmObject为1（有物料）且没有待处理任务时调用。
        /// </remarks>
        /// <param name="robotCrane">机器人设备信息，包含设备编码</param>
        /// <returns>执行中的任务对象，如果没有则返回 null</returns>
        public Dt_RobotTask? GetExecutingTask(RobotCraneDevice robotCrane)
        {
            return _robotTaskService.QueryRobotCraneExecutingTask(robotCrane.DeviceCode);
        }

        /// <summary>
@@ -141,8 +174,9 @@

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

                // 更新任务状态为"机器人执行中"
                task.RobotTaskState = TaskRobotStatusEnum.RobotExecuting.GetHashCode();
@@ -157,6 +191,80 @@
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                // 发送失败，记录 Error 日志
                _logger.LogError("下发取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
            }
        }

        /// <summary>
        /// 下发假电芯取货指令到机器人客户端
        /// </summary>
        /// <remarks>
        /// 发送格式：Pickbattery,5,{startPosition}-{endPosition}
        /// 例如：Pickbattery,5,1-3 表示从假电芯位置5抓取，平面点位1到3
        ///
        /// 下发成功后：
        /// 1. 标记点位为已使用
        /// 2. 更新任务状态为"机器人执行中"
        /// 3. 安全更新状态到 Redis
        /// </remarks>
        /// <param name="task">要下发的任务对象</param>
        /// <param name="state">机器人当前状态</param>
        /// <param name="positions">要抓取的平面点位列表</param>
        public async Task SendSocketRobotFakeBatteryPickAsync(Dt_RobotTask task, RobotSocketState state, List<int> positions)
        {
            if (positions == null || positions.Count == 0)
            {
                _logger.LogWarning("SendSocketRobotFakeBatteryPickAsync：平面点位列表为空，任务号: {TaskNum}", task.RobotTaskNum);
                return;
            }

            // 计算点位范围，格式：1-3
            int startPos = positions.Min();
            int endPos = positions.Max();
            string taskString = $"Pickbattery,5,{startPos}-{endPos}";

            // 标记点位为已使用
            _fakeBatteryPositionService.MarkAsUsed(positions);

            // 通过 Socket 网关发送指令到机器人客户端
            bool result = await _socketClientGateway.SendToClientAsync(state.IPAddress, taskString);

            if (result)
            {
                _logger.LogInformation("下发假电芯取货指令成功，指令: {TaskString}，点位: {Positions}，设备: {DeviceName}",
                    taskString, string.Join(",", positions), state.RobotCrane?.DeviceName);
                QuartzLogger.Info($"下发假电芯取货指令成功，指令: {taskString}", state.RobotCrane?.DeviceName);

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

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

                if (_stateManager.TryUpdateStateSafely(state.IPAddress, state))
                {
                    await _robotTaskService.UpdateRobotTaskAsync(task);
                }
            }
            else
            {
                _logger.LogError("下发假电芯取货指令失败，指令: {TaskString}，设备: {DeviceName}", taskString, state.RobotCrane?.DeviceName);
                QuartzLogger.Error($"下发假电芯取货指令失败，指令: {taskString}", state.RobotCrane?.DeviceName);
            }
        }

        /// <summary>
        /// 获取下N个可用的假电芯平面点位
        /// </summary>
        /// <param name="count">需要获取的点位数量</param>
        /// <returns>可用点位列表</returns>
        public List<int> GetNextAvailableFakeBatteryPositions(int count)
        {
            return _fakeBatteryPositionService.GetNextAvailable(count);
        }

        /// <summary>
@@ -182,6 +290,8 @@
            var currentTask = state.CurrentTask;
            if (currentTask == null)
            {
                _logger.LogDebug("HandleInboundTaskAsync：当前任务为空");
                QuartzLogger.Debug($"HandleInboundTaskAsync：当前任务为空", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

@@ -190,7 +300,7 @@

            // 根据巷道名称判断仓库 ID
            // ZYRB1 -> 1, HPRB001 -> 2, 其他 -> 3
            int warehouseId = currentTask.RobotRoadway == "ZYRB1" ? 1 : currentTask.RobotRoadway == "HPRB001" ? 2 : 3;
            int warehouseId = currentTask.RobotRoadway == "注液组盘机械手" ? 1 : currentTask.RobotRoadway == "HPRB001" ? 2 : 3;

            // 任务类型（0 表示未定义，稍后根据任务类型设置）
            int taskType = 0;
@@ -213,6 +323,8 @@
                {
                    case RobotTaskTypeEnum.GroupPallet:
                        // 组盘任务不使用源地址，直接返回 false
                        _logger.LogDebug("HandleInboundTaskAsync：组盘任务不使用源地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：组盘任务不使用源地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return false;

                    case RobotTaskTypeEnum.ChangePallet:
@@ -237,6 +349,8 @@

                    case RobotTaskTypeEnum.SplitPallet:
                        // 拆盘任务不使用目标地址
                        _logger.LogDebug("HandleInboundTaskAsync：拆盘任务不使用目标地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：拆盘任务不使用目标地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return true;
                }
            }
@@ -253,12 +367,18 @@
                TaskType = taskType                         // 任务类型（入库/空托盘入库）
            };

            // 记录日志：开始调用 WMS 创建入库任务
            _logger.LogInformation("HandleInboundTaskAsync：调用WMS创建入库任务，托盘码: {PalletCode}，任务类型: {TaskType}", PalletCode, taskType);
            QuartzLogger.Info($"调用WMS创建入库任务，托盘码: {PalletCode}，任务类型: {taskType}", state.RobotCrane?.DeviceName ?? "Unknown");

            // 调用 WMS 接口创建入库任务
            var result = _httpClientHelper.Post<WebResponseContent>(nameof(ConfigKey.CreateTaskInboundAsync), taskDto.ToJson());

            // 如果调用失败或返回错误状态
            if (!result.Data.Status && result.IsSuccess)
            {
                _logger.LogError("HandleInboundTaskAsync：WMS返回错误状态，Status: {Status}", result.Data.Status);
                QuartzLogger.Error($"HandleInboundTaskAsync：WMS返回错误状态", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

@@ -269,11 +389,14 @@
            var content = _taskService.ReceiveWMSTask(new List<WMSTaskDTO> { taskDTO });
            if (!content.Status)
            {
                _logger.LogError("HandleInboundTaskAsync：接收WMS任务失败");
                QuartzLogger.Error($"HandleInboundTaskAsync：接收WMS任务失败", state.RobotCrane?.DeviceName ?? "Unknown");
                return false;
            }

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

            // 获取源地址
            string sourceAddress = taskDTO.SourceAddress;
@@ -292,12 +415,14 @@
                // 设置输送线的任务号
                conveyorLine.SetValue(ConveyorLineDBNameNew.TaskNo, taskInfo.TaskNum, sourceAddress);

                // 触发输送线开始执行（写入 WCS_STB = 1）
                conveyorLine.SetValue(ConveyorLineDBNameNew.WCS_STB, 1, 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;
                }
            }
@@ -331,6 +456,9 @@
                // 目标输送线编号
                TargetLineNo = state.CurrentTask.RobotTargetAddressLineCode,

                // 巷道编号(机器人名称)
                Roadway = state.CurrentTask.RobotRoadway,

                // 电池位置详情列表
                // 过滤掉位置为 0 或负数的无效数据
                // 按位置编号排序
@@ -341,7 +469,7 @@
                    .Select((x, idx) => new StockDetailDTO
                    {
                        // 数量：如果已有任务总数，使用任务总数+当前位置数；否则只使用当前位置数
                        Quantity = state.RobotTaskTotalNum > 0 ? state.RobotTaskTotalNum + positions.Length : positions.Length,
                        Quantity = 1,

                        // 通道/位置编号
                        Channel = x,