wanshenmean
8 天以前 fd18eaba5e1c086a588509371f91310e7aafff9c
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.LogHelper;
using WIDESEAWCS_Tasks.Workflow.Abstractions;
 
namespace WIDESEAWCS_Tasks.Workflow
{
    /// <summary>
    /// 简单命令处理器
    /// </summary>
    /// <remarks>
    /// 迁移原 RobotMessageHandler 中的简单命令分支,不改变业务语义。
    ///
    /// 简单命令是指不需要额外参数的状态更新命令,如运行状态、模式切换等。
    /// 与前缀命令(需要解析位置参数)相对。
    ///
    /// 处理完成后返回 true;无法识别的命令返回 false。
    /// </remarks>
    public class RobotSimpleCommandHandler : IRobotSimpleCommandHandler
    {
        /// <summary>
        /// 机器人任务处理器
        /// </summary>
        /// <remarks>
        /// 用于处理 allpickfinished 和 allputfinished 命令时,
        /// 调用任务入库和删除逻辑。
        /// </remarks>
        private readonly RobotTaskProcessor _taskProcessor;
 
        /// <summary>
        /// Socket 网关
        /// </summary>
        /// <remarks>
        /// 用于向客户端发送响应消息。
        /// </remarks>
        private readonly ISocketClientGateway _socketClientGateway;
 
        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="taskProcessor">任务处理器实例</param>
        public RobotSimpleCommandHandler(RobotTaskProcessor taskProcessor, ISocketClientGateway socketClientGateway)
        {
            _taskProcessor = taskProcessor;
            _socketClientGateway = socketClientGateway;
        }
 
        /// <summary>
        /// 处理简单命令
        /// </summary>
        /// <remarks>
        /// 根据消息内容更新机器人的运行状态、模式、手臂对象等属性。
        /// 某些命令(如 allpickfinished、allputfinished)会触发实际的业务逻辑。
        ///
        /// 命令列表:
        /// - homing: 回零中
        /// - homed: 已回零
        /// - running: 运行中
        /// - pausing: 暂停中
        /// - warming: 预热中
        /// - emstoping: 急停中
        /// - picking: 取货中
        /// - puting: 放货中
        /// - runmode,1: 运行模式切换到手动
        /// - runmode,2: 运行模式切换到自动
        /// - controlmode,1: 控制模式切换到客户端控制
        /// - controlmode,2: 控制模式切换到其他
        /// - armobject,1: 手臂有物料
        /// - armobject,0: 手臂无物料
        /// - allpickfinished: 全部取货完成
        /// - allputfinished: 全部放货完成
        /// </remarks>
        /// <param name="message">消息内容(小写形式)</param>
        /// <param name="state">机器人当前状态(会被修改)</param>
        /// <returns>是否成功处理;无法识别的命令返回 false</returns>
        public async Task<bool> HandleAsync(string message, RobotSocketState state)
        {
            // 使用 switch 表达式进行模式匹配,提高可读性和性能
            switch (message)
            {
                // ==================== 运行状态命令 ====================
 
                // 机器人正在回零
                case "homing":
                    state.Homed = "Homing";
                    return true;
 
                // 机器人已完成回零
                case "homed":
                    state.Homed = "Homed";
                    return true;
 
                // 机器人正在运行
                case "running":
                    state.OperStatus = "Running";
                    return true;
 
                // 机器人正在暂停
                case "pausing":
                    state.OperStatus = "Pausing";
                    return true;
 
                // 机器人正在预热
                case "warming":
                    state.OperStatus = "Warming";
                    return true;
 
                // 机器人正在急停
                case "emstoping":
                    state.OperStatus = "Emstoping";
                    return true;
 
                // 机器人正在取货
                case "picking":
                    state.CurrentAction = "Picking";
                    return true;
 
                // 机器人正在放货
                case "puting":
                    state.CurrentAction = "Putting";
                    return true;
 
                // ==================== 全部完成命令 ====================
 
                // 全部取货完成
                case "allpickfinished":
                    {
                        // 更新当前动作为"全部取货完成"
                        state.CurrentAction = "AllPickFinished";
 
                        // 获取当前关联的任务
                        var currentTask = state.CurrentTask;
                        if (currentTask == null)
                        {
                            // 没有任务关联,返回 false
                            return false;
                        }
 
                        // 判断任务类型
                        var robotTaskType = (RobotTaskTypeEnum)currentTask.RobotTaskType;
 
                        // 只有拆盘或换盘任务需要处理入库
                        if (robotTaskType == RobotTaskTypeEnum.SplitPallet || robotTaskType == RobotTaskTypeEnum.ChangePallet)
                        {
                            // 处理入库任务回传
                            // 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;
                    }
 
                // 全部放货完成
                case "allputfinished":
                    {
                        // 更新当前动作为"全部放货完成"
                        state.CurrentAction = "AllPutFinished";
 
                        // 获取当前关联的任务
                        var currentTask = state.CurrentTask;
                        if (currentTask == null)
                        {
                            return false;
                        }
 
                        // 判断任务类型
                        var robotTaskType = (RobotTaskTypeEnum)currentTask.RobotTaskType;
 
                        // 只有组盘或换盘任务需要处理入库
                        if (robotTaskType == RobotTaskTypeEnum.GroupPallet || robotTaskType == RobotTaskTypeEnum.ChangePallet)
                        {
                            // 处理入库任务回传
                            // 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;
                    }
 
                // ==================== 模式切换命令 ====================
 
                // 运行模式切换为手动(模式1)
                case "runmode,1":
                    state.RobotRunMode = 1;
                    return true;
 
                // 运行模式切换为自动(模式2)
                case "runmode,2":
                    state.RobotRunMode = 2;
                    return true;
 
                // 控制模式切换为客户端控制(模式1)
                case "controlmode,1":
                    state.RobotControlMode = 1;
                    return true;
 
                // 控制模式切换为其他(模式2)
                case "controlmode,2":
                    state.RobotControlMode = 2;
                    return true;
 
                // ==================== 手臂对象命令 ====================
 
                // 手臂有物料(抓取到货物)
                case "armobject,1":
                    state.RobotArmObject = 1;
                    return true;
 
                // 手臂无物料(手臂空闲)
                case "armobject,0":
                    state.RobotArmObject = 0;
                    return true;
 
                // ==================== 默认情况 ====================
 
                // 无法识别的命令,返回 false
                default:
                    return false;
            }
        }
    }
}