feat(机械手任务): 实现换盘任务多阶段处理逻辑

wanshenmean

12 小时以前 2f7c7a0621ee2e84c47ccd054889a71e8ce4fdd0

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/RobotJob/Workflow/RobotSimpleCommandHandler.cs

@@ -143,35 +143,72 @@
                        // 判断任务类型
                        var robotTaskType = (RobotTaskTypeEnum)currentTask.RobotTaskType;

                        // 换盘任务：仅当所有阶段完成时才处理入库
                        // 换盘任务：根据阶段区分处理
                        if (robotTaskType == RobotTaskTypeEnum.ChangePallet)
                        {
                            if (state.ChangePalletPhase == 0)
                            // 调用批量拆盘确认接口
                            var sourcePallet = state.CurrentTask.RobotSourceAddressPalletCode;
                            var confirmResult = _taskProcessor.PostSplitPalletConfirmAsync(sourcePallet, state.RobotCrane?.DeviceName);
                            if (!confirmResult.IsSuccess)
                            {
                                // 调用批量拆盘确认接口（换盘取完阶段）
                                var sourcePallet = state.CurrentTask.RobotSourceAddressPalletCode;
                                var confirmResult = _taskProcessor.PostSplitPalletConfirmAsync(sourcePallet, state.RobotCrane?.DeviceName);
                                if (!confirmResult.IsSuccess)
                                {
                                    QuartzLogger.Error($"批量拆盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                }

                                // 所有阶段完成，处理入库
                                if (await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                                {
                                    // 入库成功，删除任务记录
                                    _taskProcessor.DeleteTask(currentTask.RobotTaskId);
                                    await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                                    QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);

                                    // 重置批次状态
                                    state.ChangePalletPhase = 0;
                                    state.CurrentBatchIndex = 1;
                                    state.IsInFakeBatteryMode = false;
                                    return true;
                                }
                                QuartzLogger.Error($"批量拆盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }
                            // 中间阶段不处理，仅更新状态

                            if (state.ChangePalletPhase == 5)
                            {
                                // FlowB 最终阶段：假电芯取完，源空托盘回库 HCSC1
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                                {
                                    return false;
                                }

                                if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                                {
                                    QuartzLogger.Error($"allpickfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                    return false;
                                }

                                await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                                QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);

                                state.CurrentTask = null;
                                state.RobotTaskTotalNum = 0;
                                state.CellBarcode = new List<string>();
                                state.ChangePalletPhase = 0;
                                state.CurrentBatchIndex = 1;
                                state.IsInFakeBatteryMode = false;
                                return true;
                            }
                            else if (state.ChangePalletPhase != 0)
                            {
                                // FlowA 中间阶段：正常电芯取完，源空托盘回库 GWSC1
                                // 不删除任务，不重置状态，继续 Phase 3-4 假电芯流程
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                                {
                                    return false;
                                }
                                return true;
                            }

                            // Phase == 0: 非批次模式（目标总数==48）
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                            {
                                return false;
                            }

                            if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                            {
                                QuartzLogger.Error($"allpickfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                            QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);

                            state.ChangePalletPhase = 0;
                            state.CurrentBatchIndex = 1;
                            state.IsInFakeBatteryMode = false;
                            return true;
                        }

@@ -184,16 +221,24 @@
                            if (!confirmResult.IsSuccess)
                            {
                                QuartzLogger.Error($"批量拆盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            if (await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                            {
                                // 入库成功，删除任务记录
                                _taskProcessor.DeleteTask(currentTask.RobotTaskId);
                                await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                                QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);
                                return true;
                                return false;
                            }

                            // 入库成功，删除任务记录
                            if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                            {
                                QuartzLogger.Error($"allpickfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                            QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);
                            return true;
                        }
                        return false;
                    }
@@ -214,41 +259,77 @@
                        // 判断任务类型
                        var robotTaskType = (RobotTaskTypeEnum)currentTask.RobotTaskType;

                        // 换盘任务：仅当所有阶段完成时才处理入库
                        // 换盘任务：根据阶段区分处理
                        if (robotTaskType == RobotTaskTypeEnum.ChangePallet)
                        {
                            if (state.ChangePalletPhase == 0)
                            // 调用批量组盘确认接口
                            var targetPallet = state.CurrentTask.RobotTargetAddressPalletCode;
                            var confirmResult = _taskProcessor.PostGroupPalletConfirmAsync(targetPallet, state.RobotCrane?.DeviceName);
                            if (!confirmResult.IsSuccess)
                            {
                                // 调用批量组盘确认接口（换盘放完阶段）
                                var targetPallet = state.CurrentTask.RobotTargetAddressPalletCode;
                                var confirmResult = _taskProcessor.PostGroupPalletConfirmAsync(targetPallet, state.RobotCrane?.DeviceName);
                                if (!confirmResult.IsSuccess)
                                {
                                    QuartzLogger.Error($"批量组盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                }

                                // 所有阶段完成，处理入库
                                if (await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                                {
                                    // 入库成功，删除任务记录
                                    _taskProcessor.DeleteTask(currentTask.RobotTaskId);

                                    // 清理状态，为下一个任务做准备
                                    state.CurrentTask = null;           // 清除当前任务
                                    state.RobotTaskTotalNum = 0;        // 重置任务计数
                                    state.CellBarcode = new List<string>();  // 清空条码列表

                                    await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Group,diskFinished");
                                    QuartzLogger.Info($"发送消息：【Group,diskFinished】", state.RobotCrane.DeviceName);

                                    // 重置批次状态
                                    state.ChangePalletPhase = 0;
                                    state.CurrentBatchIndex = 1;
                                    state.IsInFakeBatteryMode = false;
                                    return true;
                                }
                                QuartzLogger.Error($"批量组盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }
                            // 中间阶段不处理，仅更新状态

                            if (state.ChangePalletPhase == 5)
                            {
                                // FlowA 最终阶段：假电芯放完，目标托盘满48入库 HCSC1
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                                {
                                    return false;
                                }

                                if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                                {
                                    QuartzLogger.Error($"allputfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                    return false;
                                }

                                state.CurrentTask = null;
                                state.RobotTaskTotalNum = 0;
                                state.CellBarcode = new List<string>();

                                await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                                QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);

                                state.ChangePalletPhase = 0;
                                state.CurrentBatchIndex = 1;
                                state.IsInFakeBatteryMode = false;
                                return true;
                            }
                            else if (state.ChangePalletPhase != 0)
                            {
                                // FlowB 中间阶段：正常电芯放完，有货托盘组盘入库 GWSC1
                                // 不删除任务，不重置状态，继续 Phase 3-4 假电芯流程
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                                {
                                    return false;
                                }
                                return true;
                            }

                            // Phase == 0: 非批次模式（目标总数==48）
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                            {
                                return false;
                            }

                            if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                            {
                                QuartzLogger.Error($"allputfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            state.CurrentTask = null;
                            state.RobotTaskTotalNum = 0;
                            state.CellBarcode = new List<string>();

                            await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Swap,diskFinished");
                            QuartzLogger.Info($"发送消息：【Swap,diskFinished】", state.RobotCrane.DeviceName);

                            state.ChangePalletPhase = 0;
                            state.CurrentBatchIndex = 1;
                            state.IsInFakeBatteryMode = false;
                            return true;
                        }

@@ -256,25 +337,36 @@
                        if (robotTaskType == RobotTaskTypeEnum.GroupPallet)
                        {
                            // 调用批量组盘确认接口
                            //var targetPallet = state.CurrentTask.RobotTargetAddressPalletCode;
                            //_taskProcessor.PostGroupPalletConfirmAsync(targetPallet, state.RobotCrane?.DeviceName);
                            var targetPallet = state.CurrentTask.RobotTargetAddressPalletCode;
                            var confirmResult = _taskProcessor.PostGroupPalletConfirmAsync(targetPallet, state.RobotCrane?.DeviceName);
                            if (!confirmResult.IsSuccess)
                            {
                                QuartzLogger.Error($"批量组盘确认失败: {confirmResult.ErrorMessage}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            // 处理入库任务回传
                            // useSourceAddress: false 表示使用目标地址（组盘场景）
                            if (await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                            {
                                // 入库成功，删除任务记录
                                _taskProcessor.DeleteTask(currentTask.RobotTaskId);

                                // 清理状态，为下一个任务做准备
                                state.CurrentTask = null;           // 清除当前任务
                                state.RobotTaskTotalNum = 0;        // 重置任务计数
                                state.CellBarcode = new List<string>();  // 清空条码列表

                                await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Group,diskFinished");
                                QuartzLogger.Info($"发送消息：【Group,diskFinished】", state.RobotCrane.DeviceName);
                                return true;
                                return false;
                            }

                            // 入库成功，删除任务记录
                            if (_taskProcessor.DeleteTask(currentTask.RobotTaskId) != true)
                            {
                                QuartzLogger.Error($"allputfinished：删除任务记录失败，任务号: {currentTask.RobotTaskNum}", state.RobotCrane?.DeviceName ?? "Unknown");
                                return false;
                            }

                            // 清理状态，为下一个任务做准备
                            state.CurrentTask = null;           // 清除当前任务
                            state.RobotTaskTotalNum = 0;        // 重置任务计数
                            state.CellBarcode = new List<string>();  // 清空条码列表

                            await _socketClientGateway.SendToClientAsync(state.IPAddress, $"Group,diskFinished");
                            QuartzLogger.Info($"发送消息：【Group,diskFinished】", state.RobotCrane.DeviceName);
                            return true;
                        }
                        return false;
                    }