feat: 更新机器人任务处理逻辑和接口配置

wanshenmean

13 小时以前 b6c983ac19c0c80744795e122575f4b9ac145414

feat: 更新机器人任务处理逻辑和接口配置

fix(机器人任务): 修复PLC字符串解析异常处理
feat(任务处理): 添加手动创建机器人任务功能
refactor(任务模型): 优化字段描述和命名
fix(HTTP配置): 修正开发和生产环境API地址
perf(任务流程): 优化组盘和拆盘任务处理逻辑
style(代码): 清理无用注释和代码
docs(接口文档): 添加MES系统对接接口文档

 Code/.omc/state/last-tool-error.json

@@ -1,7 +1,7 @@
{
  "tool_name": "Read",
  "tool_input_preview": "{\"file_path\":\"D:\\\\Git\\\\ShanMeiXinNengYuan\\\\Code\\\\WMS\\\\WIDESEA_WMSServer\\\\WIDESEA_TaskInfoService\\\\WCS\\\\TaskService.cs\"}",
  "error": "File does not exist. Note: your current working directory is D:\\Git\\ShanMeiXinNengYuan\\Code.",
  "timestamp": "2026-04-18T07:45:29.125Z",
  "tool_name": "Bash",
  "tool_input_preview": "{\"command\":\"cd D:\\\\Git\\\\ShanMeiXinNengYuan\\\\Code\\\\WCS\\\\WIDESEAWCS_Client && npm run build 2>&1 | head -30\",\"timeout\":120000}",
  "error": "Exit code 1\n/usr/bin/bash: line 1: cd: D:GitShanMeiXinNengYuanCodeWCSWIDESEAWCS_Client: No such file or directory",
  "timestamp": "2026-04-19T07:15:17.022Z",
  "retry_count": 1
}

 Code/.omc/state/subagent-tracking.json

@@ -772,5 +772,5 @@
  "total_spawned": 83,
  "total_completed": 83,
  "total_failed": 0,
  "last_updated": "2026-04-18T14:04:59.113Z"
  "last_updated": "2026-04-18T14:41:25.052Z"
}

 Code/WCS/WIDESEAWCS_Client/.omc/project-memory.json

@@ -177,6 +177,19 @@
      ]
    }
  },
  "hotPaths": [],
  "hotPaths": [
    {
      "path": "src\\views\\system\\Sys_User.vue",
      "accessCount": 1,
      "lastAccessed": 1776583114779,
      "type": "file"
    },
    {
      "path": "src\\views\\taskinfo\\robotTask.vue",
      "accessCount": 1,
      "lastAccessed": 1776583136953,
      "type": "file"
    }
  ],
  "userDirectives": []
}

 Code/WCS/WIDESEAWCS_Client/src/api/http.js

@@ -15,11 +15,11 @@
    axios.defaults.baseURL = 'http://127.0.0.1:9292/';
}
else if (process.env.NODE_ENV == 'debug') {
    axios.defaults.baseURL = 'http://127.0.0.1:8098/';
    axios.defaults.baseURL = 'http://127.0.0.1:9292/';
}

else if (process.env.NODE_ENV == 'production') {
    axios.defaults.baseURL = 'http://115.159.85.185:9292/';
    axios.defaults.baseURL = 'http://192.168.60.30:9292/';
}
if (!axios.defaults.baseURL.endsWith('/')) {
    axios.defaults.baseURL+="/";

 Code/WCS/WIDESEAWCS_Client/src/views/taskinfo/robotTask.vue

@@ -28,9 +28,67 @@
      sortName: "createDate",       // é»˜è®¤æŽ’序字段
    });

    // ç¼–辑表单字段（初始为空，根据实际编辑需求配置）
    const editFormFields = ref({});
    const editFormOptions = ref([]);
    // ç¼–辑表单字段
    const editFormFields = ref({
      robotTaskNum: "",
      robotRoadway: "",
      robotTaskType: "",
      robotTaskState: "",
      robotTaskTotalNum: "",
      robotSourceAddress: "",
      robotTargetAddress: "",
      robotSourceAddressLineCode: "",
      robotTargetAddressLineCode: "",
      robotSourceAddressPalletCode: "",
      robotTargetAddressPalletCode: "",
      robotGrade: 2,
    });

    // ç¼–辑表单配置
    const editFormOptions = ref([
      [
        { title: "任务编号", field: "robotTaskNum", type: "int", required: true },
        { title: "巷道", field: "robotRoadway", type: "string", required: true },
        { title: "任务总数", field: "robotTaskTotalNum", type: "int", required: true },
        {
          title: "优先级",
          field: "robotGrade",
          type: "select",
          data: [
            { key: 1, value: "低" },
            { key: 2, value: "普通" },
            { key: 3, value: "高" },
            { key: 4, value: "紧急" },
          ],
        },
      ],
      [
        {
          title: "任务类型",
          field: "robotTaskType",
          type: "select",
          dataKey: "taskType",
          data: [],
          required: true,
        },
        {
          title: "任务状态",
          field: "robotTaskState",
          type: "select",
          dataKey: "taskState",
          data: [],
          required: true,
        },
        { title: "来源地址", field: "robotSourceAddress", type: "string", required: true },
        { title: "目标地址", field: "robotTargetAddress", type: "string", required: true },
      ],
      [
        { title: "来源线代码", field: "robotSourceAddressLineCode", type: "string" },
        { title: "目标线代码", field: "robotTargetAddressLineCode", type: "string" },
        { title: "来源托盘代码", field: "robotSourceAddressPalletCode", type: "string" },
        { title: "目标托盘代码", field: "robotTargetAddressPalletCode", type: "string" },
      ],
    ]);

    // æœç´¢è¡¨å•å­—段
    const searchFormFields = ref({

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Model/Models/TaskInfo/Dt_RobotTask.cs

@@ -64,27 +64,27 @@
        public string RobotTargetAddress { get; set; }

        /// <summary>
        /// æœºå™¨äººæ¥æºåœ°å€çº¿ä»£ç 
        /// æœºå™¨äººæ¥æºåœ°å€è¾“送线编号
        /// </summary>
        [SugarColumn(Length = 20, ColumnDescription = "机器人来源地址线代码")]
        [SugarColumn(Length = 20, ColumnDescription = "机器人来源地址输送线编号")]
        public string RobotSourceAddressLineCode { get; set; }

        /// <summary>
        /// æœºå™¨äººç›®æ ‡åœ°å€çº¿ä»£ç 
        /// æœºå™¨äººç›®æ ‡åœ°å€è¾“送线编号
        /// </summary>
        [SugarColumn(Length = 20, ColumnDescription = "机器人目标地址线代码")]
        [SugarColumn(Length = 20, ColumnDescription = "机器人目标地址输送线编号")]
        public string RobotTargetAddressLineCode { get; set; }

        /// <summary>
        /// æœºå™¨äººæ¥æºåœ°å€çº¿æ‰˜ç›˜ä»£ç 
        /// æœºå™¨äººæ¥æºåœ°å€è¾“送线托盘号
        /// </summary>
        [SugarColumn(Length = 20, ColumnDescription = "机器人来源地址线托盘代码")]
        [SugarColumn(Length = 20, ColumnDescription = "机器人来源地址输送线托盘号")]
        public string RobotSourceAddressPalletCode { get; set; }

        /// <summary>
        /// æœºå™¨äººç›®æ ‡åœ°å€çº¿æ‰˜ç›˜ä»£ç 
        /// æœºå™¨äººç›®æ ‡åœ°å€çº¿æ‰˜ç›˜å·
        /// </summary>
        [SugarColumn(Length = 20, ColumnDescription = "机器人目标地址线托盘代码")]
        [SugarColumn(Length = 20, ColumnDescription = "机器人目标地址线托盘号")]
        public string RobotTargetAddressPalletCode { get; set; }

        /// <summary>

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_QuartzJob/DeviceBase/DeviceCommand.cs

@@ -166,7 +166,14 @@
                            //throw new Exception($"读取PLC字符串定义长度【{Content[index]}】与对象【{GetType().Name}】属性【{propertyInfo.Name}】特性定义字符串长度【{dataLength}】不一致");
                            //QuartzLogger.Debug($"读取PLC字符串定义长度【{Content[index]}】与对象【{GetType().Name}】属性【{propertyInfo.Name}】特性定义字符串长度【{dataLength}】不一致");

                            try
                            {
                                propertyInfo.SetValue(this, Encoding.Default.GetString(Content, index + 2, Content[index + 1] > 0 ? Content[index + 1] : dataLength - 2).Trim().Replace("\0", "").Replace("\\u000", "").Trim());
                            }
                            catch
                            {
                            propertyInfo.SetValue(this, Encoding.Default.GetString(Content, index, dataLength).Trim().Replace("\0", "").Replace("\\u000","").Trim());
                            }
                            index += dataLength;
                            break;
                        }

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/HostedService/ApiRouteCacheWarmupHostedService.cs

@@ -46,9 +46,9 @@

        public Task StartAsync(CancellationToken cancellationToken)
        {
            const string cacheKey = $"{RedisPrefix.Code}";
            //const string cacheKey = $"{RedisPrefix.Code}";

            _cache.RemoveByPrefix($"{cacheKey}");
            //_cache.RemoveByPrefix($"{cacheKey}");




 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/Properties/PublishProfiles/FolderProfile.pubxml

@@ -4,14 +4,18 @@
-->
<Project>
  <PropertyGroup>
    <DeleteExistingFiles>false</DeleteExistingFiles>
    <DeleteExistingFiles>true</DeleteExistingFiles>
    <ExcludeApp_Data>false</ExcludeApp_Data>
    <LaunchSiteAfterPublish>true</LaunchSiteAfterPublish>
    <LastUsedBuildConfiguration>Release</LastUsedBuildConfiguration>
    <LastUsedBuildConfiguration>Debug</LastUsedBuildConfiguration>
    <LastUsedPlatform>Any CPU</LastUsedPlatform>
    <PublishProvider>FileSystem</PublishProvider>
    <PublishUrl>bin\Release\net6.0\publish\</PublishUrl>
    <PublishUrl>bin\Debug\net6.0\publish\</PublishUrl>
    <WebPublishMethod>FileSystem</WebPublishMethod>
    <_TargetId>Folder</_TargetId>
    <SiteUrlToLaunchAfterPublish />
    <TargetFramework>net8.0</TargetFramework>
    <ProjectGuid>487fa45b-ea1a-4aca-bb5b-0f6708f462c0</ProjectGuid>
    <SelfContained>false</SelfContained>
  </PropertyGroup>
</Project>

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Server/dotnet-tools.json

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,5 @@
{
  "version": 1,
  "isRoot": true,
  "tools": {}
}

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_TaskInfoService/RobotTaskService.cs

@@ -28,6 +28,7 @@
using WIDESEAWCS_Core;
using WIDESEAWCS_Core.BaseServices;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_Core.Utilities;
using WIDESEAWCS_DTO.Stock;
using WIDESEAWCS_DTO.TaskInfo;
using WIDESEAWCS_ITaskInfoRepository;
@@ -234,6 +235,49 @@
            return stock;
        }

        public override WebResponseContent AddData(SaveModel saveModel)
        {
            try
            {
                if (saveModel == null || saveModel.MainData == null || saveModel.MainData.Count == 0)
                {
                    return WebResponseContent.Instance.Error("传参错误,参数不能为空");
                }

                string validResult = typeof(Dt_RobotTask).ValidateDicInEntity(saveModel.MainData, true, TProperties);
                if (!string.IsNullOrEmpty(validResult))
                {
                    return WebResponseContent.Instance.Error(validResult);
                }

                object? taskNumObj = saveModel.MainData[nameof(Dt_RobotTask.RobotTaskNum)];
                if (taskNumObj != null)
                {
                    int taskNum = Convert.ToInt32(taskNumObj);
                    if (BaseDal.QueryFirst(x => x.RobotTaskNum == taskNum) != null)
                    {
                        return WebResponseContent.Instance.Error($"任务编号 {taskNum} å·²å­˜åœ¨");
                    }
                }

                Dt_RobotTask entity = saveModel.MainData.DicToModel<Dt_RobotTask>();
                entity.Creater = "手动创建";
                entity.CreateDate = DateTime.Now;

                if (saveModel.DetailData == null || saveModel.DetailData.Count == 0)
                {
                    BaseDal.AddData(entity);
                    return WebResponseContent.Instance.OK("新增成功", entity);
                }

                return base.AddData(saveModel);
            }
            catch (Exception ex)
            {
                return WebResponseContent.Instance.Error($"新增失败,错误信息:{ex.Message}");
            }
        }

        /// <summary>
        /// æ ¹æ®ç›®æ ‡åœ°å€æŒ‰ã€Œç²¾ç¡® > å›žé€€å€¼ã€è§£æžè§„则值。
        /// </summary>

 Code/WCS/WIDESEAWCS_Server/WIDESEAWCS_Tasks/ConveyorLineNewJob/CommonConveyorLineNewJob.cs

@@ -1,4 +1,5 @@
using MapsterMapper;
using Masuit.Tools;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
@@ -40,6 +41,12 @@
        /// ä»»åŠ¡æœåŠ¡
        /// </summary>
        private readonly ITaskService _taskService;


        /// <summary>
        /// æœºå™¨äººä»»åŠ¡æœåŠ¡
        /// </summary>
        private readonly IRobotTaskService _robotTaskService;

        /// <summary>
        /// ä»»åŠ¡æ‰§è¡Œæ˜Žç»†æœåŠ¡
@@ -93,7 +100,7 @@
        /// <param name="mapper">对象映射器</param>
        /// <param name="httpClientHelper">HTTP å®¢æˆ·ç«¯å¸®åŠ©ç±»</param>
        /// <param name="logger">日志记录器</param>
        public CommonConveyorLineNewJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, HttpClientHelper httpClientHelper, ILogger<CommonConveyorLineNewJob> logger)
        public CommonConveyorLineNewJob(ITaskService taskService, ITaskExecuteDetailService taskExecuteDetailService, IRouterService routerService, IMapper mapper, HttpClientHelper httpClientHelper, ILogger<CommonConveyorLineNewJob> logger, IRobotTaskService robotTaskService)
        {
            _taskService = taskService;
            _taskExecuteDetailService = taskExecuteDetailService;
@@ -101,6 +108,7 @@
            _mapper = mapper;
            _httpClientHelper = httpClientHelper;
            _logger = logger;
            _robotTaskService = robotTaskService;

            // åˆå§‹åŒ–调度处理器
            _conveyorLineDispatch = new ConveyorLineDispatchHandler(_taskService, _taskExecuteDetailService, _routerService, _mapper, _logger);
@@ -247,6 +255,36 @@
                                    ProcessTaskState(conveyorLine, command, task, childDeviceCode);
                                    return Task.CompletedTask;
                                }
                                else if (command.TaskNo == 1 && !command.Barcode.IsNullOrEmpty() && childDeviceCode == "11068")
                                {
                                    if (_robotTaskService.Db.Queryable<Dt_RobotTask>().Any(x => x.RobotTargetAddressPalletCode == command.Barcode))
                                    {
                                        return Task.CompletedTask;
                                    }

                                    Random rnd = new Random();
                                    int num = rnd.StrictNext();//产生真随机数
                                                               // æ²¡æœ‰ä»»åŠ¡å·ä½†æœ‰æ¡ç å¹¶ä¸”在11068位置，直接添加机械手组盘任务
                                    Dt_RobotTask robotTask = new Dt_RobotTask
                                    {
                                        RobotTargetAddressPalletCode = command.Barcode,
                                        RobotSourceAddress = "1",
                                        RobotTargetAddress = "2", // æœºæ¢°æ‰‹ç›®æ ‡åœ°å€
                                        RobotTaskType = (int)RobotTaskTypeEnum.GroupPallet, // ç»„盘任务
                                        RobotTaskState = (int)TaskRobotStatusEnum.RobotNew, // å¾…执行
                                        RobotTaskTotalNum = 48,
                                        RobotGrade = 1,
                                        RobotRoadway = "注液组盘机械手",
                                        RobotTargetAddressLineCode = childDeviceCode,
                                        RobotTaskNum = num, // ç”Ÿæˆä»»åŠ¡å·
                                        RobotDispatchertime = DateTime.Now,

                                    };
                                    if (_robotTaskService.AddData(robotTask).Status)
                                    {
                                        conveyorLine.SetValue(ConveyorLineDBNameNew.WCS_ACK, (short)1, childDeviceCode);
                                    }
                                }
                            }
                        }
                        catch (Exception innerEx)

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

@@ -135,6 +135,7 @@
            // å¦‚果缓存中不存在或状态为 null，忽略此消息
            if (!_cache.TryGetValue(cacheKey, out RobotSocketState? cachedState) || cachedState == null)
            {
                _logger.LogInformation($"缓存中不存在或状态为 null，忽略此消息");
                return null;
            }

@@ -150,7 +151,6 @@
            {
                // å¤„理成功后，将原消息回写到客户端（保持原有行为）
                await _socketClientGateway.SendMessageAsync(client, message);
                _logger.LogInformation($"发送消息【{message}】");
                QuartzLogger.Info($"发送消息：【{message}】", state.RobotCrane.DeviceName);

                // å®‰å…¨æ›´æ–°çŠ¶æ€åˆ° Redis

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

@@ -456,7 +456,7 @@
        /// <param name="state">机器人当前状态</param>
        /// <param name="useSourceAddress">是否使用源地址（true è¡¨ç¤ºæ‹†ç›˜/换盘场景，false è¡¨ç¤ºç»„盘/换盘场景）</param>
        /// <returns>处理是否成功</returns>
        public async Task<bool> HandleInboundTaskAsync(RobotSocketState state, bool useSourceAddress)
        public async Task<bool> HandleInboundTaskAsync(RobotSocketState state, bool useSourceAddress, string isRoadway = null)
        {
            // èŽ·å–当前关联的任务
            var currentTask = state.CurrentTask;
@@ -468,18 +468,17 @@
            }

            // èŽ·å–巷道代码
            string roadway = currentTask.RobotSourceAddressLineCode;
            string roadway = string.Empty;

            // æ ¹æ®å··é“名称判断仓库 ID
            // ZYRB1 -> 1, HPRB001 -> 2, å…¶ä»– -> 3
            int warehouseId = currentTask.RobotRoadway == "注液组盘机械手" ? 1 : currentTask.RobotRoadway == "HPRB001" ? 2 : 3;

            // ä»»åŠ¡ç±»åž‹ï¼ˆ0 è¡¨ç¤ºæœªå®šä¹‰ï¼Œç¨åŽæ ¹æ®ä»»åŠ¡ç±»åž‹è®¾ç½®ï¼‰
            int taskType = 0;
            int warehouseId = 0;

            // æºåœ°å€å’Œç›®æ ‡åœ°å€ï¼ˆåˆå§‹åŒ–）
            string SourceAddress = currentTask.RobotTargetAddressLineCode;
            string TargetAddress = currentTask.RobotSourceAddressLineCode;

            // ä»»åŠ¡ç±»åž‹ï¼ˆ0 è¡¨ç¤ºæœªå®šä¹‰ï¼Œç¨åŽæ ¹æ®ä»»åŠ¡ç±»åž‹è®¾ç½®ï¼‰
            int taskType = 0;

            // æ‰˜ç›˜ä»£ç ï¼ˆåˆå§‹åŒ–为空）
            string PalletCode = string.Empty;
@@ -494,16 +493,33 @@
                switch (robotTaskType)
                {
                    case RobotTaskTypeEnum.GroupPallet:
                        // ç»„盘任务不使用源地址，直接返回 false
                        _logger.LogDebug("HandleInboundTaskAsync：组盘任务不使用源地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：组盘任务不使用源地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return false;
                        warehouseId = 1;
                        roadway = "GWSC1";
                        break;

                    case RobotTaskTypeEnum.ChangePallet:
                        // æ¢ç›˜/拆盘场景：托盘需要入库
                        taskType = TaskTypeEnum.InEmpty.GetHashCode();  // ç©ºæ‰˜ç›˜å…¥åº“
                        PalletCode = currentTask.RobotSourceAddressPalletCode;  // ä½¿ç”¨æºåœ°å€çš„托盘码
                        if (isRoadway == "HWSC1")
                        {
                            warehouseId = 2;
                            roadway = "HWSC1";
                        }
                        else if (isRoadway == "GWSC1")
                        {
                            warehouseId = 1;
                            roadway = "GWSC1";
                        }

                        break;
                    case RobotTaskTypeEnum.SplitPallet:
                        // æ¢ç›˜/拆盘场景：托盘需要入库
                        taskType = TaskTypeEnum.InEmpty.GetHashCode();  // ç©ºæ‰˜ç›˜å…¥åº“
                        PalletCode = currentTask.RobotSourceAddressPalletCode;  // ä½¿ç”¨æºåœ°å€çš„托盘码

                        warehouseId = 3;
                        roadway = "CWSC1";
                        break;
                }
            }
@@ -513,17 +529,34 @@
                switch (robotTaskType)
                {
                    case RobotTaskTypeEnum.ChangePallet:
                        // æ¢ç›˜/组盘场景：货物需要入库
                        taskType = TaskTypeEnum.Inbound.GetHashCode();  // æˆå“å…¥åº“
                        PalletCode = currentTask.RobotTargetAddressPalletCode;  // ä½¿ç”¨ç›®æ ‡åœ°å€çš„托盘码

                        if (isRoadway == "HWSC1")
                        {
                            warehouseId = 2;
                            roadway = "HWSC1";
                        }
                        else if (isRoadway == "GWSC1")
                        {
                            warehouseId = 1;
                            roadway = "GWSC1";
                        }

                        break;
                    case RobotTaskTypeEnum.GroupPallet:
                        // æ¢ç›˜/组盘场景：货物需要入库
                        taskType = TaskTypeEnum.Inbound.GetHashCode();  // æˆå“å…¥åº“
                        PalletCode = currentTask.RobotTargetAddressPalletCode;  // ä½¿ç”¨ç›®æ ‡åœ°å€çš„托盘码

                        warehouseId = 1;
                        roadway = "GWSC1";
                        break;

                    case RobotTaskTypeEnum.SplitPallet:
                        // æ‹†ç›˜ä»»åŠ¡ä¸ä½¿ç”¨ç›®æ ‡åœ°å€
                        _logger.LogDebug("HandleInboundTaskAsync：拆盘任务不使用目标地址");
                        QuartzLogger.Debug($"HandleInboundTaskAsync：拆盘任务不使用目标地址", state.RobotCrane?.DeviceName ?? "Unknown");
                        return true;

                        break;
                }
            }

@@ -532,8 +565,8 @@
            {
                PalletCode = PalletCode,                    // æ‰˜ç›˜æ¡ç 
                SourceAddress = SourceAddress ?? string.Empty,  // æºåœ°å€
                TargetAddress = TargetAddress ?? string.Empty,  // ç›®æ ‡åœ°å€
                Roadway = roadway,                          // å··é“
                TargetAddress = roadway ?? string.Empty,  // ç›®æ ‡åœ°å€
                Roadway = roadway ?? string.Empty,             // å··é“
                WarehouseId = warehouseId,                   // ä»“库 ID
                PalletType = 1,                             // æ‰˜ç›˜ç±»åž‹ï¼ˆé»˜è®¤ä¸º1）
                TaskType = taskType                         // ä»»åŠ¡ç±»åž‹ï¼ˆå…¥åº“/空托盘入库）

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

@@ -1,6 +1,7 @@
using System.Net.Sockets;
using WIDESEAWCS_Common.HttpEnum;
using WIDESEAWCS_Common.TaskEnum;
using WIDESEAWCS_Core.Helper;
using WIDESEAWCS_ITaskInfoService;
using WIDESEAWCS_Model.Models;
using WIDESEAWCS_Tasks.Workflow.Abstractions;

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

@@ -158,7 +158,7 @@
                            if (state.ChangePalletPhase == 5)
                            {
                                // FlowB æœ€ç»ˆé˜¶æ®µï¼šå‡ç”µèŠ¯å–完，源空托盘回库 HCSC1
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true, isRoadway: "HCSC1"))
                                {
                                    return false;
                                }
@@ -184,15 +184,16 @@
                            {
                                // FlowA ä¸­é—´é˜¶æ®µï¼šæ­£å¸¸ç”µèŠ¯å–完，源空托盘回库 GWSC1
                                // ä¸åˆ é™¤ä»»åŠ¡ï¼Œä¸é‡ç½®çŠ¶æ€ï¼Œç»§ç»­ Phase 3-4 å‡ç”µèŠ¯æµç¨‹
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true, isRoadway: "GWSC1"))
                                {
                                    return false;
                                }
                                return true;
                            }

                            List<string> str = new List<string>() { "11001", "11010" };
                            // Phase == 0: éžæ‰¹æ¬¡æ¨¡å¼ï¼ˆç›®æ ‡æ€»æ•°==48）
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true))
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: true, isRoadway: str.Contains(currentTask.RobotSourceAddressLineCode) ? "GWSC1" : "HCSC1"))
                            {
                                return false;
                            }
@@ -274,7 +275,7 @@
                            if (state.ChangePalletPhase == 5)
                            {
                                // FlowA æœ€ç»ˆé˜¶æ®µï¼šå‡ç”µèŠ¯æ”¾å®Œï¼Œç›®æ ‡æ‰˜ç›˜æ»¡48入库 HCSC1
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false, isRoadway: "HCSC1"))
                                {
                                    return false;
                                }
@@ -301,15 +302,16 @@
                            {
                                // FlowB ä¸­é—´é˜¶æ®µï¼šæ­£å¸¸ç”µèŠ¯æ”¾å®Œï¼Œæœ‰è´§æ‰˜ç›˜ç»„盘入库 GWSC1
                                // ä¸åˆ é™¤ä»»åŠ¡ï¼Œä¸é‡ç½®çŠ¶æ€ï¼Œç»§ç»­ Phase 3-4 å‡ç”µèŠ¯æµç¨‹
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                                if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false, isRoadway: "GWSC1"))
                                {
                                    return false;
                                }
                                return true;
                            }

                            List<string> str = new List<string>() { "11001", "11010" };
                            // Phase == 0: éžæ‰¹æ¬¡æ¨¡å¼ï¼ˆç›®æ ‡æ€»æ•°==48）
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false))
                            if (!await _taskProcessor.HandleInboundTaskAsync(state, useSourceAddress: false, str.Contains(currentTask.RobotTargetAddressLineCode) ? "GWSC1" : "HCSC1"))
                            {
                                return false;
                            }

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

@@ -352,7 +352,7 @@
                        // æ¡ç é‡å¤ï¼Œè®°å½•é”™è¯¯æ—¥å¿—并停止后续操作(后续放货时会用到这些条码信息，供后续放货时使用，调试后可能会取消此逻辑)

                        // å‘送取货指令 æ ‡è®°æ‰«ç NG，放货时不使用这些条码，并放入NG口
                        await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate, true);
                        //await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate, true);
                        return;
                    }
                    else
@@ -367,7 +367,6 @@
                        };
                    }


                    // è®°å½•æ—¥å¿—：读取托盘条码成功
                    _logger.LogInformation("HandlePutFinishedStateAsync：读取托盘条码成功: {Barcode1}+{Barcode2}，任务号: {TaskNum}", trayBarcode1, trayBarcode2, task.RobotTaskNum);
                    QuartzLogger.Info($"读取托盘条码成功: {trayBarcode1}+{trayBarcode2}", stateForUpdate.RobotCrane.DeviceName);
@@ -378,12 +377,12 @@
                else
                {
                    // æ¡ç è¯»å–失败，记录错误日志
                    _logger.LogError("HandlePutFinishedStateAsync：读取托盘条码失败，任务号: {TaskNum}", task.RobotTaskNum);
                    QuartzLogger.Error($"读取托盘条码失败", stateForUpdate.RobotCrane.DeviceName);
                    _logger.LogError("HandlePutFinishedStateAsync：读取托盘条码失败，任务号: {TaskNum}，一号位: {trayBarcode1}，二号位: {trayBarcode2}", task.RobotTaskNum,trayBarcode1,trayBarcode2);
                    QuartzLogger.Error($"读取托盘条码失败,一号位：{trayBarcode1},二号位：{trayBarcode2}", stateForUpdate.RobotCrane.DeviceName);


                    // å‘送取货指令 æ ‡è®°æ‰«ç NG，放货时不使用这些条码，并放入NG口
                    await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate, true);
                    //await _taskProcessor.SendSocketRobotPickAsync(task, stateForUpdate, true);
                    return;
                }
            }

 Code/WMS/WIDESEA_WMSServer/WIDESEA_WMSServer/Properties/PublishProfiles/FolderProfile.pubxml

@@ -14,7 +14,7 @@
    <WebPublishMethod>FileSystem</WebPublishMethod>
    <_TargetId>Folder</_TargetId>
    <SiteUrlToLaunchAfterPublish />
    <TargetFramework>net6.0</TargetFramework>
    <TargetFramework>net8.0</TargetFramework>
    <ProjectGuid>d81a65b5-47d1-40c1-8fde-7d24ff003f51</ProjectGuid>
    <SelfContained>false</SelfContained>
  </PropertyGroup>

 ÏîÄ¿×ÊÁÏ/É豸ЭÒé/ÉÏλϵͳ¶Ô½Ó/ÉÂÎ÷Çê¿ÌÄÜÔ´¿Æ¼¼MESϵͳ¶Ô½Ó½Ó¿Ú.pdf

Binary files differ