From 1c4426810c71eead57084be8a18ade8d314dd8c4 Mon Sep 17 00:00:00 2001
From: patrick <patrick.xu@broconcentric.com>
Date: 星期二, 10 十二月 2019 14:24:31 +0800
Subject: [PATCH] 1. 重构项目

---
 src/A032.Process/ProcessControl_Method.cs | 1801 ++++++++++++++++++++++-----------------------------------
 1 files changed, 698 insertions(+), 1,103 deletions(-)

diff --git a/src/A032.Process/ProcessControl_Method.cs b/src/A032.Process/ProcessControl_Method.cs
index dc0d8c8..45a0f4f 100644
--- a/src/A032.Process/ProcessControl_Method.cs
+++ b/src/A032.Process/ProcessControl_Method.cs
@@ -1,350 +1,13 @@
-锘縰sing Bro.Common.Base;
-using Bro.Common.Helper;
+锘縰sing Bro.Common.Helper;
 using Bro.Common.Interface;
 using Bro.Common.Model;
-using Bro.Device.AuboRobot;
-using Bro.Device.HikCamera;
-using Bro.Device.SeerAGV;
-using HalconDotNet;
-using System;
-using System.Collections.Generic;
-using System.ComponentModel;
-using System.Drawing;
-using System.IO;
 using System.Linq;
-using System.Text;
-using System.Threading;
-using System.Threading.Tasks;
 
 namespace A032.Process
 {
     public partial class ProcessControl
     {
-        const int WAITTIME = 5000;
-
-        Dictionary<int, int> machineFullTrayDict = new Dictionary<int, int>();
-        Dictionary<int, int> machineEmptyTrayDict = new Dictionary<int, int>();
-        List<TaskAssignInfo> taskAssignedList = new List<TaskAssignInfo>();
-
-        #region AGV浜嬩欢
-        private void OnAGVBatteryLvlChanged(SeerAGVDriver agv, float preBatteryLvl, float batteryLvl)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.AGVId == agv.Id);
-            SeerAGVInitialConfig iConfig = agv.InitialConfig as SeerAGVInitialConfig;
-            if (batteryLvl <= iConfig.BatteryLvlToCharge && preBatteryLvl > iConfig.BatteryLvlToCharge)
-            {
-                Task.Run(() =>
-                {
-                    var position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.Charge);
-
-                    if (position == null)
-                    {
-                        throw new ProcessException("鏈壘鍒板厖鐢靛湴鐐�");
-                    }
-
-                    while (bind.UnitStatus != TaskStatus.Available)
-                    {
-                        if (bind.SetAGVStatus(TaskStatus.Running))
-                        {
-                            bind.AGV.TaskOrder(position.PositionCode);
-                            break;
-                        }
-
-                        Thread.Sleep(WAITTIME);
-                    }
-                });
-
-                return;
-            }
-
-            if (batteryLvl >= iConfig.BatteryLvlChargeDone && preBatteryLvl < iConfig.BatteryLvlChargeDone)
-            {
-                var position = Config.PositionCollection.FirstOrDefault(u => u.PositionCode == agv.CurrentPosition);
-
-                if (position != null && position.Description == PathPositionDefinition.Charge)
-                {
-                    bind.SetAGVStatus(TaskStatus.Available);
-                }
-                return;
-            }
-        }
-
-        private void OnAGVTaskStatusChanged(SeerAGVDriver agv, AGVTaskStatus taskStatus)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.AGVId == agv.Id);
-
-            if (bind == null)
-            {
-                throw new ProcessException("鏈兘鏍规嵁AGV淇℃伅鑾峰彇缁戝畾璁惧淇℃伅", null);
-            }
-
-            if (bind.AGVDest == agv.CurrentPosition && taskStatus == AGVTaskStatus.Completed)
-            {
-                //PathPosition loadEmptyTrayPosition = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
-
-                //if (bind.AGVDest == loadEmptyTrayPosition.PositionCode)
-                //{
-                //    bind.RobotStatus = TaskStatus.Running;
-                //}
-
-                bind.SetAGVStatus(TaskStatus.Available);
-            }
-        }
-
-        private void OnAGVPositionChanged(SeerAGVDriver agv, string positionCode)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.AGVId == agv.Id);
-
-            if (bind == null)
-            {
-                throw new ProcessException("鏈兘鏍规嵁AGV淇℃伅鑾峰彇缁戝畾璁惧淇℃伅", null);
-            }
-
-            if (bind.AGVDest == positionCode && agv.TaskStatus == AGVTaskStatus.Completed)
-            {
-                //PathPosition loadEmptyTrayPosition = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
-
-                //if (bind.AGVDest == loadEmptyTrayPosition.PositionCode)
-                //{
-                //    bind.RobotStatus = TaskStatus.Running;
-                //}
-
-                bind.SetAGVStatus(TaskStatus.Available);
-                LogAsync(DateTime.Now, $"AGV鍒颁綅{positionCode}", "");
-
-                PathPosition position = Config.PositionCollection.FirstOrDefault(p => p.PositionCode == bind.AGVDest);
-                switch (position.Description)
-                {
-                    case PathPositionDefinition.LoadEmptyTray:
-                        LogAsync(DateTime.Now, $"AGV瀹屾垚锛屽噯澶囦笂绌篢ray", "");
-                        Robot_LoadEmptyTray(bind.Id, position);
-                        break;
-                    case PathPositionDefinition.LoadFullTray:
-                        LogAsync(DateTime.Now, $"AGV瀹屾垚锛屽噯澶囦笂婊ray", "");
-                        Robot_LoadFullTraySnap(bind.Id, position);
-                        break;
-                    case PathPositionDefinition.UnloadEmptyTray:
-                        LogAsync(DateTime.Now, $"AGV瀹屾垚锛屽噯澶囦笅绌篢ray", "");
-                        Robot_UnloadEmptyTraySnap(bind.Id, position);
-                        break;
-                    case PathPositionDefinition.UnloadFullTray:
-                        LogAsync(DateTime.Now, $"AGV瀹屾垚锛屽噯澶囦笅婊ray", "");
-                        Robot_UnloadFullTraySnap(bind.Id, position);
-                        break;
-                    default:
-                        break;
-                }
-            }
-        }
-        #endregion
-
-        private void OnRobotMsgReceived(DateTime dt, AuboRobotDriver robot, RobotMsg msg)
-        {
-            LogAsync(dt, robot.Name + "鎺ユ敹淇℃伅", msg.GetDisplayText());
-
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robot.Id);
-
-            if (bind == null)
-            {
-                throw new ProcessException("鏈兘鏍规嵁鏈哄櫒浜轰俊鎭幏鍙栫粦瀹氳澶囦俊鎭�", null);
-            }
-
-            //List<AGVTaskModel> models = new List<AGVTaskModel>();
-
-            switch (msg.Action)
-            {
-                case RobotMsgAction.Load:
-                    {
-                        switch (msg.Para1)
-                        {
-                            case RobotMsgParas.EmptyTray:
-                                {
-                                    bind.RobotStatus = bind.AGVStatus = TaskStatus.Available;
-                                }
-                                break;
-                            case RobotMsgParas.FullTray:
-                                {
-                                    machineFullTrayDict[msg.Para2]--;
-                                    bind.CurrentFullTray = int.Parse(msg.Datas[1]);
-
-                                    if (machineFullTrayDict[msg.Para2] > 0 && !bind.IsFullTrayFull)
-                                    {
-                                        RobotMsg_UnloadEmptyTray.Para2 = msg.Para2;
-                                        robot.SendMsg(RobotMsg_UnloadEmptyTray, true);
-                                    }
-                                    else
-                                    {
-                                        bind.RobotStatus = TaskStatus.Available;
-                                    }
-                                }
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                    break;
-                case RobotMsgAction.Unload:
-                    {
-                        switch (msg.Para1)
-                        {
-                            case RobotMsgParas.EmptyTray:
-                                {
-                                    machineEmptyTrayDict[msg.Para2]++;
-                                    bind.CurrentEmptyTray = int.Parse(msg.Datas[0]);
-
-                                    if (machineEmptyTrayDict[msg.Para2] < Config.Machine_EmptyTrayNum)
-                                    {
-                                        //bind.RobotIOHandle.Reset();
-                                        //bind.RobotIOHandle.WaitOne();
-                                        bind.Robot.MonitorHandle.WaitOne();
-                                        //bind.Robot.IOChangedHandle.WaitOne();
-                                        Thread.Sleep((bind.Robot.InitialConfig as AuboRobotInitialConfig).ScanInterval);
-
-                                        if (!bind.IsFullTrayFull)
-                                        {
-                                            RobotMsg_UnloadEmptyTray.Para2 = msg.Para2;
-                                            robot.SendMsg(RobotMsg_UnloadEmptyTray, true);
-                                        }
-                                        else
-                                        {
-                                            bind.RobotStatus = TaskStatus.Available;
-                                        }
-                                    }
-                                    else
-                                    {
-                                        bind.RobotStatus = TaskStatus.Available;
-                                    }
-                                }
-                                break;
-                            case RobotMsgParas.FullTray:
-                                {
-                                    bind.CurrentFullTray = int.Parse(msg.Datas[1]);
-
-                                    //bind.RobotIOHandle.Reset();
-                                    //bind.RobotIOHandle.WaitOne();
-                                    bind.Robot.MonitorHandle.WaitOne();
-                                    //bind.Robot.IOChangedHandle.WaitOne();
-                                    Thread.Sleep((bind.Robot.InitialConfig as AuboRobotInitialConfig).ScanInterval);
-
-                                    if (!bind.IsFullTrayEmpty)
-                                    {
-                                        Camera_UnloadFullTray(robot.Id, msg.Para2);
-                                    }
-                                    else
-                                    {
-                                        bind.RobotStatus = TaskStatus.Available;
-                                    }
-                                }
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                    break;
-                case RobotMsgAction.Move:
-                    {
-                        switch (msg.Para1)
-                        {
-                            case RobotMsgParas.LineSnap:
-                                {
-                                    Camera_UnloadFullTray(robot.Id, msg.Para2);
-                                }
-                                break;
-                            case RobotMsgParas.LoadFullTraySnap:
-                                {
-                                    Camera_LoadFullTray(robot.Id, msg.Para2);
-                                }
-                                break;
-                            case RobotMsgParas.UnloadEmptyTraySnap:
-                                {
-                                    Camera_UnloadEmptyTray(robot.Id, msg.Para2);
-                                }
-                                break;
-                            case RobotMsgParas.Home:
-                                {
-                                    bind.RobotStatus = TaskStatus.Available;
-                                }
-                                break;
-                            default:
-                                break;
-                        }
-                    }
-                    break;
-                case RobotMsgAction.Calibration:
-                    {
-                        _calibReply.CalibIndex = int.Parse(msg.Datas[4]);
-                        _calibReply.CalibPositionNo = msg.Para2;
-                        _calibReply.RobotPosition = new CustomizedPoint(float.Parse(msg.Datas[0]), float.Parse(msg.Datas[1]));
-
-                        _calibReply.CalibHandle.Set();
-                    }
-                    break;
-                case RobotMsgAction.StandardPoint:
-                    {
-                        _calibReply.CalibPositionNo = msg.Para2;
-                        _calibReply.CalibHandle.Set();
-                    }
-                    break;
-                default:
-                    break;
-            }
-
-            //if (models.Count > 0)
-            //{
-            //    models.ForEach(model =>
-            //    {
-            //        if (!bind.TaskList.Any(t => t.MethodName == model.MethodName))
-            //        {
-            //            model.OpConfig = new AGVBindOpConfig(bind.Id);
-            //            bind.AddTask(model);
-            //        }
-            //    });
-            //}
-        }
-
-        public void QueryRobotIO()
-        {
-            RobotDict.Values.ToList().ForEach(r =>
-            {
-                r.SendMsg(RobotMsgAction.IO, RobotMsgParas.Query, 0);
-            });
-        }
-
-        //private void OnBindUnitTaskInvoke(AGVTaskModel task)
-        //{
-        //    InvokeMethodDict[task.MethodName].Invoke(this, new object[] { task.OpConfig, task.Device });
-
-        //    //var response = task.MethodFunc.Invoke(task.OpConfig, task.Device);
-        //}
-
         #region Robot鐩戝惉浜嬩欢
-        //private void AddNewTaskToBind(string robotId, List<AGVTaskModel> models)
-        //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
-
-        //    if (bind == null)
-        //    {
-        //        throw new ProcessException("鏈兘鏍规嵁鏈哄櫒浜轰俊鎭幏鍙栫粦瀹氳澶囦俊鎭�", null);
-        //    }
-
-        //    AddNewTaskToBind(bind, models);
-        //}
-
-        //private void AddNewTaskToBind(AGVBindUnit bind, List<AGVTaskModel> models)
-        //{
-        //    if (models.Count > 0)
-        //    {
-        //        models.ForEach(model =>
-        //        {
-        //            if (!bind.TaskList.Any(t => t.MethodName == model.MethodName))
-        //            {
-        //                model.OpConfig = new AGVBindOpConfig(bind.Id);
-        //                bind.AddTask(model);
-        //            }
-        //        });
-        //    }
-        //}
-
         [ProcessMethod("", "Robot_Monitor_Alarm", "鏈哄櫒浜虹洃鍚簨浠�-鎶ヨ", true)]
         public ProcessResponse Robot_Monitor_Alarm(IOperationConfig config, IDevice device)
         {
@@ -352,11 +15,11 @@
 
             if (bind == null)
             {
-                throw new ProcessException("鏈兘鏍规嵁鏈哄櫒浜轰俊鎭幏鍙栫粦瀹氳澶囦俊鎭�", null);
+                throw new ProcessException($"鏈兘鑾峰彇{device.Name}鐨勭粦瀹氳澶囦俊鎭�");
             }
 
-            bind.AGV.PauseTask();
-            bind.RobotStatus = TaskStatus.Warning;
+            bind.AGV.CancelTask();
+            bind.UnitState = AGVState.Warning;
 
             return new ProcessResponse(true);
         }
@@ -364,92 +27,58 @@
         [ProcessMethod("", "Robot_Monitor_EmptyTrayEmpty", "鏈哄櫒浜虹洃鍚簨浠�-绌篢ray鍖哄煙娓呯┖", true)]
         public ProcessResponse Robot_Monitor_EmptyTrayEmpty(IOperationConfig config, IDevice device)
         {
-            bool isEmptyTrayEmpty = config.InputPara[0] == 0;
             var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == device.Id);
-            if (isEmptyTrayEmpty)
+
+            if (bind == null)
             {
-                bind.IsEmptyTrayEmpty = true;
-
-                Task.Run(() =>
-                {
-                    //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_LoadEmptyTray;
-                    while (bind.IsEmptyTrayEmpty && !bind.IsEmptyTrayTaskAssigned)
-                    {
-                        //if (bind.TaskList.Count == 0)
-                        if (bind.UnitStatus == TaskStatus.Available)
-                        {
-                            //List<AGVTaskModel> models = new List<AGVTaskModel>();
-                            //models.Add(new AGVTaskModel(TaskAvailableLevel.Both, "AGV_LoadEmptyTray"));
-                            //models.Add(new AGVTaskModel(TaskAvailableLevel.AGV, "AfterEmptyTrayPositionArrived"));
-
-                            //AddNewTaskToBind(device.Id, models);
-
-                            if (AGV_LoadEmptyTray(bind.Id))
-                            {
-                                bind.IsEmptyTrayTaskAssigned = true;
-                            }
-                        }
-                        else
-                        {
-                            Thread.Sleep(WAITTIME);
-                        }
-                    }
-                });
+                throw new ProcessException($"鏈兘鑾峰彇{device.Name}鐨勭粦瀹氳澶囦俊鎭�");
             }
-            else
-            {
-                bind.IsEmptyTrayEmpty = false;
-                bind.IsEmptyTrayTaskAssigned = false;
-            }
+
+            bind.EmptyTrayNum = 0;
+
+            TrayTask task = new TrayTask();
+            task.TaskType = TaskType.LoadEmptyTrayToAGV;
+            //task.Priority = 10;
+            task.SourceDeviceId = device.Id;
+            //task.SourceDeviceName = device.Name;
+
+            //濡傛灉鐩墠鍦板潃琚崰鐢紝鍦板潃鏈夊彲鑳戒负绌猴紝闇�瑕佸湪浠诲姟鎸囨淳鏃跺啀娆$‘璁�
+            task.Location = Config.PositionCollection.FirstOrDefault(u => !u.IsOccupied && u.Description == PathPositionDefinition.LoadEmptyTray);
+
+            InsertTask(task);
 
             return new ProcessResponse(true);
         }
 
+        /// <summary>
+        /// 淇″彿瑕佹眰闀夸俊鍙疯Е鍙戯紝閬垮厤璇Е鍙�
+        /// </summary>
+        /// <param name="config"></param>
+        /// <param name="device"></param>
+        /// <returns></returns>
         [ProcessMethod("", "Robot_Monitor_FullTrayFull", "鏈哄櫒浜虹洃鍚簨浠�-婊ray鍖哄煙鏀炬弧", true)]
         public ProcessResponse Robot_Monitor_FullTrayFull(IOperationConfig config, IDevice device)
         {
-            //(device as AuboRobotDriver).IOChangedHandle.Reset();
-            bool isFullTrayFull = config.InputPara[0] == 1;
             var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == device.Id);
-            if (isFullTrayFull)
+
+            if (bind == null)
             {
-                bind.IsFullTrayFull = true;
-
-                Task.Run(() =>
-                {
-                    //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_UnloadFullTray;
-                    while (bind.IsFullTrayFull && !bind.IsFullTrayTaskAssigned)
-                    {
-                        //if (bind.TaskList.Count == 0)
-                        if (bind.UnitStatus == TaskStatus.Available)
-                        {
-                            //List<AGVTaskModel> models = new List<AGVTaskModel>();
-                            //models.Add(new AGVTaskModel(TaskAvailableLevel.Both, "AGV_UnloadFullTray"));
-                            //models.Add(new AGVTaskModel(TaskAvailableLevel.AGV, "Robot_UnloadFullTray"));
-
-                            //AddNewTaskToBind(device.Id, models);
-
-                            if (AGV_UnloadFullTray(bind.Id))
-                            {
-                                bind.IsFullTrayTaskAssigned = true;
-                            }
-                        }
-                        else
-                        {
-                            Thread.Sleep(WAITTIME);
-                        }
-                    }
-                });
-            }
-            else
-            {
-                bind.IsFullTrayFull = false;
-                bind.IsFullTrayTaskAssigned = false;
+                throw new ProcessException($"鏈兘鑾峰彇{device.Name}鐨勭粦瀹氳澶囦俊鎭�");
             }
 
-            //(device as AuboRobotDriver).IOChangedHandle.Set();
+            //if (bind.FullTrayNum >= Config.AGVAvailableTrayNums)
+            {
+                bind.FullTrayNum = Config.AGVAvailableTrayNums;
 
-            //bind.RobotIOHandle.Set();
+                TrayTask task = new TrayTask();
+                task.TaskType = TaskType.UnloadFullTrayToLine;
+                task.SourceDeviceId = device.Id;
+
+                //濡傛灉鐩墠鍦板潃琚崰鐢紝鍦板潃鏈夊彲鑳戒负绌猴紝闇�瑕佸湪浠诲姟鎸囨淳鏃跺啀娆$‘璁�
+                task.Location = Config.PositionCollection.FirstOrDefault(u => !u.IsOccupied && u.Description == PathPositionDefinition.UnloadFullTray);
+
+                InsertTask(task);
+            }
 
             return new ProcessResponse(true);
         }
@@ -457,13 +86,14 @@
         [ProcessMethod("", "Robot_Monitor_FullTrayEmpty", "鏈哄櫒浜虹洃鍚簨浠�-婊ray鍖哄煙娓呯┖", true)]
         public ProcessResponse Robot_Monitor_FullTrayEmpty(IOperationConfig config, IDevice device)
         {
-            //(device as AuboRobotDriver).IOChangedHandle.Reset();
-            bool isFullTrayEmpty = config.InputPara[0] == 0;
             var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == device.Id);
-            bind.IsFullTrayEmpty = isFullTrayEmpty;
 
-            //(device as AuboRobotDriver).IOChangedHandle.Set();
-            //bind.RobotIOHandle.Set();
+            if (bind == null)
+            {
+                throw new ProcessException($"鏈兘鑾峰彇{device.Name}鐨勭粦瀹氳澶囦俊鎭�");
+            }
+
+            bind.FullTrayNum = 0;
 
             return new ProcessResponse(true);
         }
@@ -499,27 +129,103 @@
 
             if (bind == null)
             {
-                throw new ProcessException("鏈兘鏍规嵁鏈哄櫒浜轰俊鎭幏鍙栫粦瀹氳澶囦俊鎭�", null);
+                throw new ProcessException($"鏈兘鑾峰彇{device.Name}鐨勭粦瀹氳澶囦俊鎭�");
             }
             bind.AGV.CancelTask();
 
-            //isEmptyTrayTaskAssigned = false;
-            //isFullTrayTaskAssigned = false;
-
-            taskAssignedList.RemoveAll(u => u.AgvId == device.Id);
-
-            //bind.ClearTask();
-            bind.RobotStatus = bind.AGVStatus = TaskStatus.Available;
+            Reset(bind.Id);
 
             return new ProcessResponse(true);
         }
         #endregion
 
-        #region 绌篢ray涓婃枡
-        //[ProcessMethod("", "AGV_LoadEmptyTray", "AGV鍘诲線绌篢ray涓婃枡", true)]
-        //public ProcessResponse AGV_LoadEmptyTray(IOperationConfig config, IDevice device)
+        #region PLC鐩戝惉浜嬩欢
+        [ProcessMethod("", "PLC_NoticeEmptyTray", "PLC閫氱煡闇�瑕佷笂绌篢ray", true)]
+        public ProcessResponse PLC_NoticeEmptyTray(IOperationConfig config, IDevice device)
+        {
+            TrayTask task = new TrayTask();
+            task.TaskType = TaskType.UnloadEmptyTrayToMachine;
+            task.SourceDeviceId = device.Id;
+            //task.SourceDeviceName = device.Name;
+            task.Location = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray && u.DeviceOwner == device.Id);
+
+            InsertTask(task);
+
+            return new ProcessResponse(true);
+        }
+
+        [ProcessMethod("", "PLC_NoticeFullTray", "PLC閫氱煡婊ray闇�瑕佸彇璧�", true)]
+        public ProcessResponse PLC_NoticeFullTray(IOperationConfig config, IDevice device)
+        {
+            TrayTask task = new TrayTask();
+            task.TaskType = TaskType.LoadFullTrayFromMachine;
+            task.SourceDeviceId = device.Id;
+            //task.SourceDeviceName = device.Name;
+            task.Location = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.DeviceOwner == device.Id);
+
+            InsertTask(task);
+
+            return new ProcessResponse(true);
+        }
+        #endregion
+
+        [ProcessMethod("OperationTest", "OperationDemo", "鍗曟娴嬭瘯鏂规硶", true)]
+        public ProcessResponse OperationDemo(IOperationConfig config, IDevice device)
+        {
+            string s = (-1).ToString("D2");
+            string a = (1).ToString("D2");
+
+            OperationTestConfig opConfig = config as OperationTestConfig;
+
+            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.AGVId == opConfig.AGVId);
+            if (bind == null)
+                throw new ProcessException("鏈兘鑾峰彇鎸囧畾AGV淇℃伅鎴朅GV缁戝畾鐨勮澶囦俊鎭�");
+
+            switch (opConfig.TaskInfo.TaskType)
+            {
+                case TaskType.LoadEmptyTrayToAGV:
+                    LoadEmptyTrayToAGV(opConfig.TaskInfo, bind);
+                    break;
+                case TaskType.LoadFullTrayFromMachine:
+                    LoadFullTrayFromMachine(opConfig.TaskInfo, bind);
+                    break;
+                case TaskType.UnloadEmptyTrayToMachine:
+                    UnloadEmptyTrayToMachine(opConfig.TaskInfo, bind);
+                    break;
+                case TaskType.UnloadFullTrayToLine:
+                    UnloadFullTrayToLine(opConfig.TaskInfo, bind);
+                    break;
+                default:
+                    throw new ProcessException($"鏈兘鎸囧畾{opConfig.TaskInfo.TaskType.ToString()}鐨勫搴旀柟娉�");
+            }
+
+            return new ProcessResponse(true);
+        }
+
+        #region old
+        //#region 绌篢ray涓婃枡
+        ////[ProcessMethod("", "AGV_LoadEmptyTray", "AGV鍘诲線绌篢ray涓婃枡", true)]
+        ////public ProcessResponse AGV_LoadEmptyTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
+
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓婃枡鐐�");
+        ////    }
+
+        ////    bind.AGVDest = position.PositionCode;
+        ////    bind.AGV.TaskOrder(position.PositionCode);
+
+        ////    bind.AGVStatus = TaskStatus.Running;
+
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public bool AGV_LoadEmptyTray(string bindId)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
         //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
 
         //    if (position == null)
@@ -527,42 +233,45 @@
         //        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓婃枡鐐�");
         //    }
 
-        //    bind.AGVDest = position.PositionCode;
-        //    bind.AGV.TaskOrder(position.PositionCode);
+        //    if (bind.SetAGVStatus(TaskStatus.Running))
+        //    {
+        //        bind.AGVDest = position.PositionCode;
+        //        bind.AGV.TaskOrder(position.PositionCode);
 
-        //    bind.AGVStatus = TaskStatus.Running;
-
-        //    return new ProcessResponse(true);
+        //        return true;
+        //    }
+        //    else
+        //    {
+        //        return false;
+        //    }
         //}
 
-        public bool AGV_LoadEmptyTray(string bindId)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
+        ////[ProcessMethod("", "AfterEmptyTrayPositionArrived", "鍒拌揪绌篢ray涓婃枡鐐�", true)]
+        ////public ProcessResponse AfterEmptyTrayPositionArrived(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
 
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓婃枡鐐�");
-            }
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓婃枡鐐�", null);
+        ////    }
 
-            if (bind.SetAGVStatus(TaskStatus.Running))
-            {
-                bind.AGVDest = position.PositionCode;
-                bind.AGV.TaskOrder(position.PositionCode);
+        ////    if (bind.AGV.CurrentPosition != position.PositionCode)
+        ////    {
+        ////        throw new ProcessException("AGV灏氭湭鍒拌揪绌篢ray涓婃枡鐐�", null);
+        ////    }
 
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
+        ////    bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.EmptyTray, 0);
+        ////    bind.RobotStatus = TaskStatus.Running;
 
-        //[ProcessMethod("", "AfterEmptyTrayPositionArrived", "鍒拌揪绌篢ray涓婃枡鐐�", true)]
-        //public ProcessResponse AfterEmptyTrayPositionArrived(IOperationConfig config, IDevice device)
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public void Robot_LoadEmptyTray(string bindId, PathPosition position)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
-        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
+        //    //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
 
         //    if (position == null)
         //    {
@@ -576,160 +285,166 @@
 
         //    bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.EmptyTray, 0);
         //    bind.RobotStatus = TaskStatus.Running;
-
-        //    return new ProcessResponse(true);
         //}
 
-        public void Robot_LoadEmptyTray(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadEmptyTray);
+        ////[ProcessMethod("", "EmptyTrayReady", "绌篢ray涓婃枡瀹屾垚", true)]
+        ////public ProcessResponse EmptyTrayReady(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    bind.RobotStatus = bind.AGVStatus = TaskStatus.Available;
 
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓婃枡鐐�", null);
-            }
+        ////    return new ProcessResponse(true);
+        ////}
+        //#endregion
 
-            if (bind.AGV.CurrentPosition != position.PositionCode)
-            {
-                throw new ProcessException("AGV灏氭湭鍒拌揪绌篢ray涓婃枡鐐�", null);
-            }
+        //#region 绌篢ray寰�鏈哄彴涓嬫枡
+        ////bool isEmptyTrayNeed = false;
+        ////bool isEmptyTrayTaskAssigned = false;
+        //RobotMsg RobotMsg_UnloadEmptyTray = new RobotMsg();
 
-            bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.EmptyTray, 0);
-            bind.RobotStatus = TaskStatus.Running;
-        }
-
-        //[ProcessMethod("", "EmptyTrayReady", "绌篢ray涓婃枡瀹屾垚", true)]
-        //public ProcessResponse EmptyTrayReady(IOperationConfig config, IDevice device)
+        //private async void CheckUnloadEmptyTrayTask(int positionNo)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
-        //    bind.RobotStatus = bind.AGVStatus = TaskStatus.Available;
+        //    await Task.Run(() =>
+        //    {
+        //        var taskStatus = taskAssignedList.FirstOrDefault(u => u.PositionNo == positionNo);
 
-        //    return new ProcessResponse(true);
+        //        if (taskStatus == null)
+        //            return;
+
+        //        while (taskStatus.IsTaskNeed && !taskStatus.IsTaskAssgined)
+        //        {
+        //            //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_UnloadEmptyTray;
+
+        //            //if (!Config.AGVBindCollection.Any(b => b.TaskList.Any(t => t.MethodName == "AGV_UnloadEmptyTray")))
+        //            {
+        //                var bind = Config.AGVBindCollection.FirstOrDefault(u => u.UnitStatus == TaskStatus.Available);
+        //                if (bind != null)
+        //                {
+        //                    var position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNo);
+        //                    //AGVTaskModel model_AGV = new AGVTaskModel(TaskAvailableLevel.Both, "AGV_UnloadEmptyTray", new AGVBindOpConfig(bind.Id, position));
+        //                    //AGVTaskModel model_Robot = new AGVTaskModel(TaskAvailableLevel.AGV, "Robot_UnloadEmptyTray", new AGVBindOpConfig(bind.Id));
+
+        //                    //bind.AddTask(model_AGV);
+        //                    //bind.AddTask(model_Robot);
+
+        //                    if (AGV_UnloadEmptyTray(bind.Id, position))
+        //                    {
+        //                        taskStatus.IsTaskAssgined = true;
+        //                        taskStatus.AgvId = bind.AGVId;
+        //                    }
+        //                }
+        //            }
+
+        //            Thread.Sleep(WAITTIME);
+        //        }
+        //    });
         //}
-        #endregion
 
-        #region 绌篢ray寰�鏈哄彴涓嬫枡
-        //bool isEmptyTrayNeed = false;
-        //bool isEmptyTrayTaskAssigned = false;
-        RobotMsg RobotMsg_UnloadEmptyTray = new RobotMsg();
-
-        [ProcessMethod("", "PLC_NoticeEmptyTray", "PLC閫氱煡闇�瑕佷笂绌篢ray", true)]
-        public ProcessResponse PLC_NoticeEmptyTray(IOperationConfig config, IDevice device)
-        {
-            if (config.InputPara == null || config.InputPara.Count == 0)
-            {
-                throw new ProcessException("涓婄┖Tray鏂规硶鏈厤缃緭鍏ュ弬鏁�", null);
-            }
-
-            bool isEmptyTrayNeed = config.InputPara[0] == 1;
-
-            if (isEmptyTrayNeed)
-            {
-                var position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray && u.DeviceOwner == device.Id);
-
-                machineEmptyTrayDict[position.PositionNo] = 0;
-
-                if (!taskAssignedList.Any(u => u.PositionNo == position.PositionNo))
-                {
-                    taskAssignedList.Add(new TaskAssignInfo()
-                    {
-                        IsTaskNeed = true,
-                        IsTaskAssgined = false,
-                        PositionNo = position.PositionNo,
-                    });
-                }
-
-                CheckUnloadEmptyTrayTask(position.PositionNo);
-            }
-
-            return new ProcessResponse(true);
-        }
-
-        private async void CheckUnloadEmptyTrayTask(int positionNo)
-        {
-            await Task.Run(() =>
-            {
-                var taskStatus = taskAssignedList.FirstOrDefault(u => u.PositionNo == positionNo);
-
-                if (taskStatus == null)
-                    return;
-
-                while (taskStatus.IsTaskNeed && !taskStatus.IsTaskAssgined)
-                {
-                    //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_UnloadEmptyTray;
-
-                    //if (!Config.AGVBindCollection.Any(b => b.TaskList.Any(t => t.MethodName == "AGV_UnloadEmptyTray")))
-                    {
-                        var bind = Config.AGVBindCollection.FirstOrDefault(u => u.UnitStatus == TaskStatus.Available);
-                        if (bind != null)
-                        {
-                            var position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNo);
-                            //AGVTaskModel model_AGV = new AGVTaskModel(TaskAvailableLevel.Both, "AGV_UnloadEmptyTray", new AGVBindOpConfig(bind.Id, position));
-                            //AGVTaskModel model_Robot = new AGVTaskModel(TaskAvailableLevel.AGV, "Robot_UnloadEmptyTray", new AGVBindOpConfig(bind.Id));
-
-                            //bind.AddTask(model_AGV);
-                            //bind.AddTask(model_Robot);
-
-                            if (AGV_UnloadEmptyTray(bind.Id, position))
-                            {
-                                taskStatus.IsTaskAssgined = true;
-                                taskStatus.AgvId = bind.AGVId;
-                            }
-                        }
-                    }
-
-                    Thread.Sleep(WAITTIME);
-                }
-            });
-        }
-
-        //[ProcessMethod("", "AGV_UnloadEmptyTray", "AGV鍘诲線鍗歌浇绌篢ray鏂欎綅缃�", true)]
-        public bool AGV_UnloadEmptyTray(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
-            }
-
-            if (bind.SetAGVStatus(TaskStatus.Running))
-            {
-                bind.AGVDest = position.PositionCode;
-                bind.AGV.TaskOrder(position.PositionCode);
-
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
-
-        //[ProcessMethod("", "Robot_UnloadEmptyTray", "鏈哄櫒浜鸿繍鍔ㄨ嚦绌篢ray鎷嶇収浣嶇疆", true)]
-        public void Robot_UnloadEmptyTraySnap(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray && u.PositionCode == bind.AGV.CurrentPosition);
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
-            }
-
-            taskAssignedList.RemoveAll(u => u.AgvId == bind.AGVId && u.PositionNo == position.PositionNo);
-
-            bind.RobotStatus = TaskStatus.Running;
-            bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.UnloadEmptyTraySnap, position.PositionNo);
-        }
-
-        //[ProcessMethod("", "Camera_UnloadEmptyTray", "鐩告満纭绌篢ray鍗歌浇鏈哄櫒浜轰綅缃皟鏁�", true)]
-        //public ProcessResponse Camera_UnloadEmptyTray(IOperationConfig config, IDevice device)
+        ////[ProcessMethod("", "AGV_UnloadEmptyTray", "AGV鍘诲線鍗歌浇绌篢ray鏂欎綅缃�", true)]
+        //public bool AGV_UnloadEmptyTray(string bindId, PathPosition position)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
 
-        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray);
+        //    if (position == null)
+        //    {
+        //        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
+        //    }
+
+        //    if (bind.SetAGVStatus(TaskStatus.Running))
+        //    {
+        //        bind.AGVDest = position.PositionCode;
+        //        bind.AGV.TaskOrder(position.PositionCode);
+
+        //        return true;
+        //    }
+        //    else
+        //    {
+        //        return false;
+        //    }
+        //}
+
+        ////[ProcessMethod("", "Robot_UnloadEmptyTray", "鏈哄櫒浜鸿繍鍔ㄨ嚦绌篢ray鎷嶇収浣嶇疆", true)]
+        //public void Robot_UnloadEmptyTraySnap(string bindId, PathPosition position)
+        //{
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
+        //    //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray && u.PositionCode == bind.AGV.CurrentPosition);
+
+        //    if (position == null)
+        //    {
+        //        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
+        //    }
+
+        //    taskAssignedList.RemoveAll(u => u.AgvId == bind.AGVId && u.PositionNo == position.PositionNo);
+
+        //    bind.RobotStatus = TaskStatus.Running;
+        //    bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.UnloadEmptyTraySnap, position.PositionNo);
+        //}
+
+        ////[ProcessMethod("", "Camera_UnloadEmptyTray", "鐩告満纭绌篢ray鍗歌浇鏈哄櫒浜轰綅缃皟鏁�", true)]
+        ////public ProcessResponse Camera_UnloadEmptyTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadEmptyTray);
+
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
+        ////    }
+
+        ////    if (bind.AGV.CurrentPosition != position.PositionCode)
+        ////    {
+        ////        throw new ProcessException("AGV褰撳墠鏈浜庣┖Tray涓嬫枡鐐�");
+        ////    }
+
+        ////    PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
+
+        ////    if (visionConfig == null)
+        ////    {
+        ////        throw new ProcessException("鏈厤缃鐩告満鐨勭┖Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
+        ////    }
+
+        ////    float x = 0;
+        ////    float y = 0;
+        ////    float angle = 0;
+
+        ////    using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadEmptyTray"))
+        ////    {
+        ////        string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
+        ////        if (!_halconToolDict.ContainsKey(toolPath))
+        ////        {
+        ////            throw new ProcessException($"鏈厤缃瓹amera_UnloadEmptyTray鐨勮瑙夌畻娉曡矾寰�");
+        ////        }
+
+        ////        var tool = _halconToolDict[toolPath];
+        ////        tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
+        ////        tool.RunProcedure();
+
+        ////        x = (float)tool.GetResultTuple("OUTPUT_X").D;
+        ////        y = (float)tool.GetResultTuple("OUTPUT_Y").D;
+        ////        angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        ////    }
+
+        ////    if (x <= 0 || y <= 0)
+        ////    {
+        ////        throw new ProcessException("Camera_UnloadEmptyTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
+        ////    }
+
+        ////    float dx = visionConfig.StandardPoint.X - x;
+        ////    float dy = visionConfig.StandardPoint.Y - y;
+
+        ////    HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
+
+        ////    bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.EmptyTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public ProcessResponse Camera_UnloadEmptyTray(string robotId, int positionNum)
+        //{
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
+
+        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNum);
 
         //    if (position == null)
         //    {
@@ -741,231 +456,162 @@
         //        throw new ProcessException("AGV褰撳墠鏈浜庣┖Tray涓嬫枡鐐�");
         //    }
 
-        //    PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
+        //    float adjust_X = 0.0f;
+        //    float adjust_Y = 0.0f;
+        //    float adjust_Angle = 0.0f;
 
-        //    if (visionConfig == null)
+        //    if (Config.IsEnableVisionGuide)
         //    {
-        //        throw new ProcessException("鏈厤缃鐩告満鐨勭┖Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
-        //    }
+        //        PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
 
-        //    float x = 0;
-        //    float y = 0;
-        //    float angle = 0;
-
-        //    using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadEmptyTray"))
-        //    {
-        //        string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
-        //        if (!_halconToolDict.ContainsKey(toolPath))
+        //        if (visionConfig == null)
         //        {
-        //            throw new ProcessException($"鏈厤缃瓹amera_UnloadEmptyTray鐨勮瑙夌畻娉曡矾寰�");
+        //            throw new ProcessException("鏈厤缃鐩告満鐨勭┖Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
         //        }
 
-        //        var tool = _halconToolDict[toolPath];
-        //        tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
-        //        tool.RunProcedure();
+        //        float x = 0;
+        //        float y = 0;
+        //        float angle = 0;
 
-        //        x = (float)tool.GetResultTuple("OUTPUT_X").D;
-        //        y = (float)tool.GetResultTuple("OUTPUT_Y").D;
-        //        angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        //        using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadEmptyTray"))
+        //        {
+        //            string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
+        //            if (!_halconToolDict.ContainsKey(toolPath))
+        //            {
+        //                throw new ProcessException($"鏈厤缃瓹amera_UnloadEmptyTray鐨勮瑙夌畻娉曡矾寰�");
+        //            }
+
+        //            var tool = _halconToolDict[toolPath];
+        //            tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
+        //            tool.RunProcedure();
+
+        //            x = (float)tool.GetResultTuple("OUTPUT_X").D;
+        //            y = (float)tool.GetResultTuple("OUTPUT_Y").D;
+        //            angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        //        }
+
+        //        if (x <= 0 || y <= 0)
+        //        {
+        //            throw new ProcessException("Camera_UnloadEmptyTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
+        //        }
+
+        //        float dx = visionConfig.StandardPoint.X - x;
+        //        float dy = visionConfig.StandardPoint.Y - y;
+
+        //        HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
+
+        //        adjust_X = (float)dx_Robot.D;
+        //        adjust_Y = (float)dy_Robot.D;
+        //        adjust_Angle = visionConfig.StandardPoint.Angle - angle;
         //    }
 
-        //    if (x <= 0 || y <= 0)
-        //    {
-        //        throw new ProcessException("Camera_UnloadEmptyTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
-        //    }
-
-        //    float dx = visionConfig.StandardPoint.X - x;
-        //    float dy = visionConfig.StandardPoint.Y - y;
-
-        //    HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
-
-        //    bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.EmptyTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+        //    //bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.EmptyTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+        //    RobotMsg_UnloadEmptyTray.Action = RobotMsgAction.Unload;
+        //    RobotMsg_UnloadEmptyTray.Para1 = RobotMsgParas.EmptyTray;
+        //    RobotMsg_UnloadEmptyTray.Para2 = position.PositionNo;
+        //    RobotMsg_UnloadEmptyTray.Datas = new List<float>() { adjust_X, adjust_Y, 0, adjust_Angle }.ConvertAll(s => s.ToString()).ToList();
+        //    bind.Robot.SendMsg(RobotMsg_UnloadEmptyTray, true);
 
         //    return new ProcessResponse(true);
         //}
+        //#endregion
 
-        public ProcessResponse Camera_UnloadEmptyTray(string robotId, int positionNum)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
+        //#region 浠庢満鍙颁笂婊ray
+        ////bool isFullTrayNeed = false;
+        ////bool isFullTrayTaskAssigned = false;
+        //RobotMsg RobotMsg_LoadFullTray = new RobotMsg();
 
-            PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNum);
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃┖Tray涓嬫枡鐐�");
-            }
-
-            if (bind.AGV.CurrentPosition != position.PositionCode)
-            {
-                throw new ProcessException("AGV褰撳墠鏈浜庣┖Tray涓嬫枡鐐�");
-            }
-
-            float adjust_X = 0.0f;
-            float adjust_Y = 0.0f;
-            float adjust_Angle = 0.0f;
-
-            if (Config.IsEnableVisionGuide)
-            {
-                PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
-
-                if (visionConfig == null)
-                {
-                    throw new ProcessException("鏈厤缃鐩告満鐨勭┖Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
-                }
-
-                float x = 0;
-                float y = 0;
-                float angle = 0;
-
-                using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadEmptyTray"))
-                {
-                    string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
-                    if (!_halconToolDict.ContainsKey(toolPath))
-                    {
-                        throw new ProcessException($"鏈厤缃瓹amera_UnloadEmptyTray鐨勮瑙夌畻娉曡矾寰�");
-                    }
-
-                    var tool = _halconToolDict[toolPath];
-                    tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
-                    tool.RunProcedure();
-
-                    x = (float)tool.GetResultTuple("OUTPUT_X").D;
-                    y = (float)tool.GetResultTuple("OUTPUT_Y").D;
-                    angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
-                }
-
-                if (x <= 0 || y <= 0)
-                {
-                    throw new ProcessException("Camera_UnloadEmptyTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
-                }
-
-                float dx = visionConfig.StandardPoint.X - x;
-                float dy = visionConfig.StandardPoint.Y - y;
-
-                HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
-
-                adjust_X = (float)dx_Robot.D;
-                adjust_Y = (float)dy_Robot.D;
-                adjust_Angle = visionConfig.StandardPoint.Angle - angle;
-            }
-
-            //bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.EmptyTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
-            RobotMsg_UnloadEmptyTray.Action = RobotMsgAction.Unload;
-            RobotMsg_UnloadEmptyTray.Para1 = RobotMsgParas.EmptyTray;
-            RobotMsg_UnloadEmptyTray.Para2 = position.PositionNo;
-            RobotMsg_UnloadEmptyTray.Datas = new List<float>() { adjust_X, adjust_Y, 0, adjust_Angle }.ConvertAll(s => s.ToString()).ToList();
-            bind.Robot.SendMsg(RobotMsg_UnloadEmptyTray, true);
-
-            return new ProcessResponse(true);
-        }
-        #endregion
-
-        #region 浠庢満鍙颁笂婊ray
-        //bool isFullTrayNeed = false;
-        //bool isFullTrayTaskAssigned = false;
-        RobotMsg RobotMsg_LoadFullTray = new RobotMsg();
-
-        [ProcessMethod("", "PLC_NoticeFullTray", "PLC閫氱煡婊ray闇�瑕佸彇璧�", true)]
-        public ProcessResponse PLC_NoticeFullTray(IOperationConfig config, IDevice device)
-        {
-            if (config.InputPara == null || config.InputPara.Count == 0)
-            {
-                throw new ProcessException("涓婄┖Tray鏂规硶鏈厤缃緭鍏ュ弬鏁�", null);
-            }
-
-            bool isFullTrayNeed = config.InputPara[0] == 1;
-            if (isFullTrayNeed)
-            {
-                var position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.DeviceOwner == device.Id);
-
-                machineFullTrayDict[position.PositionNo] = Config.Machine_FullTrayNum;
-
-                if (!taskAssignedList.Any(u => u.PositionNo == position.PositionNo))
-                {
-                    taskAssignedList.Add(new TaskAssignInfo()
-                    {
-                        IsTaskNeed = true,
-                        IsTaskAssgined = false,
-                        PositionNo = position.PositionNo,
-                    });
-                }
-
-                CheckFullTrayTask(position.PositionNo);
-            }
-
-            return new ProcessResponse(true);
-        }
-
-        private async void CheckFullTrayTask(int positionNo)
-        {
-            await Task.Run(() =>
-            {
-                var taskStatus = taskAssignedList.FirstOrDefault(u => u.PositionNo == positionNo);
-
-                if (taskStatus == null)
-                    return;
-
-                while (taskStatus.IsTaskNeed && !taskStatus.IsTaskAssgined)
-                {
-                    //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_LoadFullTray;
-
-                    //if (!Config.AGVBindCollection.Any(b => b.TaskList.Any(t => t.MethodFunc.Method.Name == action.Method.Name)))
-                    {
-                        var bind = Config.AGVBindCollection.FirstOrDefault(u => u.UnitStatus == TaskStatus.Available);
-                        if (bind != null)
-                        {
-                            var position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNo);
-                            //AGVTaskModel model_AGV = new AGVTaskModel(TaskAvailableLevel.Both, "AGV_LoadFullTray", new AGVBindOpConfig(bind.Id, position));
-                            //AGVTaskModel model_Robot = new AGVTaskModel(TaskAvailableLevel.AGV, "Robot_LoadFullTray", new AGVBindOpConfig(bind.Id));
-
-                            //bind.AddTask(model_AGV);
-                            //bind.AddTask(model_Robot);
-
-                            if (AGV_LoadFullTray(bind.Id, position))
-                            {
-                                taskStatus.IsTaskAssgined = true;
-                                taskStatus.AgvId = bind.AGVId;
-                            }
-                        }
-                    }
-
-                    Thread.Sleep(300);
-                }
-            });
-        }
-
-        //[ProcessMethod("", "AGV_LoadFullTray", "AGV鍘诲線婊ray涓婃枡浣嶇疆", true)]
-        public bool AGV_LoadFullTray(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-
-            //PathPosition position = (config as AGVBindOpConfig).Position;
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
-            }
-
-            if (bind.SetAGVStatus(TaskStatus.Running))
-            {
-                bind.AGVDest = position.PositionCode;
-                bind.AGV.TaskOrder(position.PositionCode);
-
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-
-            //return new ProcessResponse(true);
-        }
-
-        //[ProcessMethod("", "Robot_LoadFullTray", "鏈哄櫒浜鸿繍鍔ㄨ嚦婊ray鎷嶇収浣嶇疆", true)]
-        //public ProcessResponse Robot_LoadFullTray(IOperationConfig config, IDevice device)
+        //private async void CheckFullTrayTask(int positionNo)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
-        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.PositionCode == bind.AGV.CurrentPosition);
+        //    await Task.Run(() =>
+        //    {
+        //        var taskStatus = taskAssignedList.FirstOrDefault(u => u.PositionNo == positionNo);
+
+        //        if (taskStatus == null)
+        //            return;
+
+        //        while (taskStatus.IsTaskNeed && !taskStatus.IsTaskAssgined)
+        //        {
+        //            //Func<IOperationConfig, IDevice, ProcessResponse> action = AGV_LoadFullTray;
+
+        //            //if (!Config.AGVBindCollection.Any(b => b.TaskList.Any(t => t.MethodFunc.Method.Name == action.Method.Name)))
+        //            {
+        //                var bind = Config.AGVBindCollection.FirstOrDefault(u => u.UnitStatus == TaskStatus.Available);
+        //                if (bind != null)
+        //                {
+        //                    var position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNo);
+        //                    //AGVTaskModel model_AGV = new AGVTaskModel(TaskAvailableLevel.Both, "AGV_LoadFullTray", new AGVBindOpConfig(bind.Id, position));
+        //                    //AGVTaskModel model_Robot = new AGVTaskModel(TaskAvailableLevel.AGV, "Robot_LoadFullTray", new AGVBindOpConfig(bind.Id));
+
+        //                    //bind.AddTask(model_AGV);
+        //                    //bind.AddTask(model_Robot);
+
+        //                    if (AGV_LoadFullTray(bind.Id, position))
+        //                    {
+        //                        taskStatus.IsTaskAssgined = true;
+        //                        taskStatus.AgvId = bind.AGVId;
+        //                    }
+        //                }
+        //            }
+
+        //            Thread.Sleep(300);
+        //        }
+        //    });
+        //}
+
+        ////[ProcessMethod("", "AGV_LoadFullTray", "AGV鍘诲線婊ray涓婃枡浣嶇疆", true)]
+        //public bool AGV_LoadFullTray(string bindId, PathPosition position)
+        //{
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
+
+        //    //PathPosition position = (config as AGVBindOpConfig).Position;
+
+        //    if (position == null)
+        //    {
+        //        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
+        //    }
+
+        //    if (bind.SetAGVStatus(TaskStatus.Running))
+        //    {
+        //        bind.AGVDest = position.PositionCode;
+        //        bind.AGV.TaskOrder(position.PositionCode);
+
+        //        return true;
+        //    }
+        //    else
+        //    {
+        //        return false;
+        //    }
+
+        //    //return new ProcessResponse(true);
+        //}
+
+        ////[ProcessMethod("", "Robot_LoadFullTray", "鏈哄櫒浜鸿繍鍔ㄨ嚦婊ray鎷嶇収浣嶇疆", true)]
+        ////public ProcessResponse Robot_LoadFullTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.PositionCode == bind.AGV.CurrentPosition);
+
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
+        ////    }
+
+        ////    //if (bind.AGV.CurrentPosition != position.PositionCode)
+        ////    //{
+        ////    //    throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓婃枡鐐�");
+        ////    //}
+
+        ////    bind.RobotStatus = TaskStatus.Running;
+        ////    bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LoadFullTraySnap, position.PositionNo);
+
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public void Robot_LoadFullTraySnap(string bindId, PathPosition position)
+        //{
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
+        //    //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.PositionCode == bind.AGV.CurrentPosition);
 
         //    if (position == null)
         //    {
@@ -979,35 +625,73 @@
 
         //    bind.RobotStatus = TaskStatus.Running;
         //    bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LoadFullTraySnap, position.PositionNo);
-
-        //    return new ProcessResponse(true);
         //}
 
-        public void Robot_LoadFullTraySnap(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray && u.PositionCode == bind.AGV.CurrentPosition);
+        ////[ProcessMethod("", "Camera_LoadFullTray", "鐩告満纭婊ray涓婃枡鏈哄櫒浜轰綅缃皟鏁�", true)]
+        ////public ProcessResponse Camera_LoadFullTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
 
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
-            }
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray);
 
-            //if (bind.AGV.CurrentPosition != position.PositionCode)
-            //{
-            //    throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓婃枡鐐�");
-            //}
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
+        ////    }
 
-            bind.RobotStatus = TaskStatus.Running;
-            bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LoadFullTraySnap, position.PositionNo);
-        }
+        ////    if (bind.AGV.CurrentPosition != position.PositionCode)
+        ////    {
+        ////        throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓婃枡鐐�");
+        ////    }
 
-        //[ProcessMethod("", "Camera_LoadFullTray", "鐩告満纭婊ray涓婃枡鏈哄櫒浜轰綅缃皟鏁�", true)]
-        //public ProcessResponse Camera_LoadFullTray(IOperationConfig config, IDevice device)
+        ////    PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
+
+        ////    if (visionConfig == null)
+        ////    {
+        ////        throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓婃枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
+        ////    }
+
+        ////    float x = 0;
+        ////    float y = 0;
+        ////    float angle = 0;
+
+        ////    using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_LoadFullTray"))
+        ////    {
+        ////        string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
+        ////        if (!_halconToolDict.ContainsKey(toolPath))
+        ////        {
+        ////            throw new ProcessException($"鏈厤缃瓹amera_LoadFullTray鐨勮瑙夌畻娉曡矾寰�");
+        ////        }
+
+        ////        var tool = _halconToolDict[toolPath];
+        ////        tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
+        ////        tool.RunProcedure();
+
+        ////        x = (float)tool.GetResultTuple("OUTPUT_X").D;
+        ////        y = (float)tool.GetResultTuple("OUTPUT_Y").D;
+        ////        angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        ////    }
+
+        ////    if (x <= 0 || y <= 0)
+        ////    {
+        ////        throw new ProcessException("Camera_LoadFullTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
+        ////    }
+
+        ////    float dx = visionConfig.StandardPoint.X - x;
+        ////    float dy = visionConfig.StandardPoint.Y - y;
+
+        ////    HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
+
+        ////    bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.FullTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public ProcessResponse Camera_LoadFullTray(string robotId, int positionNum)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
 
-        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.LoadFullTray);
+        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNum);
 
         //    if (position == null)
         //    {
@@ -1019,130 +703,89 @@
         //        throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓婃枡鐐�");
         //    }
 
-        //    PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
+        //    float adjust_X = 0.0f;
+        //    float adjust_Y = 0.0f;
+        //    float adjust_Angle = 0.0f;
 
-        //    if (visionConfig == null)
+        //    if (Config.IsEnableVisionGuide)
         //    {
-        //        throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓婃枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
-        //    }
+        //        PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
 
-        //    float x = 0;
-        //    float y = 0;
-        //    float angle = 0;
-
-        //    using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_LoadFullTray"))
-        //    {
-        //        string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
-        //        if (!_halconToolDict.ContainsKey(toolPath))
+        //        if (visionConfig == null)
         //        {
-        //            throw new ProcessException($"鏈厤缃瓹amera_LoadFullTray鐨勮瑙夌畻娉曡矾寰�");
+        //            throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓婃枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
         //        }
 
-        //        var tool = _halconToolDict[toolPath];
-        //        tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
-        //        tool.RunProcedure();
+        //        float x = 0;
+        //        float y = 0;
+        //        float angle = 0;
 
-        //        x = (float)tool.GetResultTuple("OUTPUT_X").D;
-        //        y = (float)tool.GetResultTuple("OUTPUT_Y").D;
-        //        angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        //        using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_LoadFullTray"))
+        //        {
+        //            string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
+        //            if (!_halconToolDict.ContainsKey(toolPath))
+        //            {
+        //                throw new ProcessException($"鏈厤缃瓹amera_LoadFullTray鐨勮瑙夌畻娉曡矾寰�");
+        //            }
+
+        //            var tool = _halconToolDict[toolPath];
+        //            tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
+        //            tool.RunProcedure();
+
+        //            x = (float)tool.GetResultTuple("OUTPUT_X").D;
+        //            y = (float)tool.GetResultTuple("OUTPUT_Y").D;
+        //            angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
+        //        }
+
+        //        if (x <= 0 || y <= 0)
+        //        {
+        //            throw new ProcessException("Camera_LoadFullTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
+        //        }
+
+        //        float dx = visionConfig.StandardPoint.X - x;
+        //        float dy = visionConfig.StandardPoint.Y - y;
+
+        //        HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
+
+        //        adjust_X = (float)dx_Robot.D;
+        //        adjust_Y = (float)dy_Robot.D;
+        //        adjust_Angle = visionConfig.StandardPoint.Angle - angle;
         //    }
 
-        //    if (x <= 0 || y <= 0)
-        //    {
-        //        throw new ProcessException("Camera_LoadFullTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
-        //    }
-
-        //    float dx = visionConfig.StandardPoint.X - x;
-        //    float dy = visionConfig.StandardPoint.Y - y;
-
-        //    HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
-
-        //    bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.FullTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+        //    //bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.FullTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
+        //    RobotMsg_LoadFullTray.Action = RobotMsgAction.Load;
+        //    RobotMsg_LoadFullTray.Para1 = RobotMsgParas.FullTray;
+        //    RobotMsg_LoadFullTray.Para2 = position.PositionNo;
+        //    RobotMsg_LoadFullTray.Datas = new List<float>() { adjust_X, adjust_Y, 0, adjust_Angle }.ConvertAll(s => s.ToString()).ToList();
+        //    bind.Robot.SendMsg(RobotMsg_LoadFullTray, true);
 
         //    return new ProcessResponse(true);
         //}
+        //#endregion
 
-        public ProcessResponse Camera_LoadFullTray(string robotId, int positionNum)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
+        //#region 婊ray浜х嚎涓嬫枡
+        ////[ProcessMethod("", "AGV_UnloadFullTray", "AGV鍘诲線鍗歌浇婊ray鏂�", true)]
+        ////public ProcessResponse AGV_UnloadFullTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
 
-            PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.PositionNo == positionNum);
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
+        ////    }
 
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓婃枡鐐�");
-            }
+        ////    bind.AGVDest = position.PositionCode;
+        ////    bind.AGV.TaskOrder(position.PositionCode);
 
-            if (bind.AGV.CurrentPosition != position.PositionCode)
-            {
-                throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓婃枡鐐�");
-            }
+        ////    bind.AGVStatus = TaskStatus.Running;
 
-            float adjust_X = 0.0f;
-            float adjust_Y = 0.0f;
-            float adjust_Angle = 0.0f;
+        ////    return new ProcessResponse(true);
+        ////}
 
-            if (Config.IsEnableVisionGuide)
-            {
-                PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
-
-                if (visionConfig == null)
-                {
-                    throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓婃枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
-                }
-
-                float x = 0;
-                float y = 0;
-                float angle = 0;
-
-                using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_LoadFullTray"))
-                {
-                    string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
-                    if (!_halconToolDict.ContainsKey(toolPath))
-                    {
-                        throw new ProcessException($"鏈厤缃瓹amera_LoadFullTray鐨勮瑙夌畻娉曡矾寰�");
-                    }
-
-                    var tool = _halconToolDict[toolPath];
-                    tool.SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_X", new HTuple() }, { "OUTPUT_Y", new HTuple() }, { "OUTPUT_Angle", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
-                    tool.RunProcedure();
-
-                    x = (float)tool.GetResultTuple("OUTPUT_X").D;
-                    y = (float)tool.GetResultTuple("OUTPUT_Y").D;
-                    angle = (float)tool.GetResultTuple("OUTPUT_Angle").D;
-                }
-
-                if (x <= 0 || y <= 0)
-                {
-                    throw new ProcessException("Camera_LoadFullTray瑙嗚璁$畻鑾峰彇鐐逛綅涓嶅彲灏忎簬0");
-                }
-
-                float dx = visionConfig.StandardPoint.X - x;
-                float dy = visionConfig.StandardPoint.Y - y;
-
-                HOperatorSet.AffineTransPoint2d(new HTuple(visionConfig.Matrix[0], visionConfig.Matrix[1], 0, visionConfig.Matrix[3], visionConfig.Matrix[4], 0), dx, dy, out HTuple dx_Robot, out HTuple dy_Robot);
-
-                adjust_X = (float)dx_Robot.D;
-                adjust_Y = (float)dy_Robot.D;
-                adjust_Angle = visionConfig.StandardPoint.Angle - angle;
-            }
-
-            //bind.Robot.SendMsg(RobotMsgAction.Load, RobotMsgParas.FullTray, position.PositionNo, new List<float>() { (float)dx_Robot.D, (float)dy_Robot.D, angle });
-            RobotMsg_LoadFullTray.Action = RobotMsgAction.Load;
-            RobotMsg_LoadFullTray.Para1 = RobotMsgParas.FullTray;
-            RobotMsg_LoadFullTray.Para2 = position.PositionNo;
-            RobotMsg_LoadFullTray.Datas = new List<float>() { adjust_X, adjust_Y, 0, adjust_Angle }.ConvertAll(s => s.ToString()).ToList();
-            bind.Robot.SendMsg(RobotMsg_LoadFullTray, true);
-
-            return new ProcessResponse(true);
-        }
-        #endregion
-
-        #region 婊ray浜х嚎涓嬫枡
-        //[ProcessMethod("", "AGV_UnloadFullTray", "AGV鍘诲線鍗歌浇婊ray鏂�", true)]
-        //public ProcessResponse AGV_UnloadFullTray(IOperationConfig config, IDevice device)
+        //public bool AGV_UnloadFullTray(string bindId)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
         //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
 
         //    if (position == null)
@@ -1150,42 +793,45 @@
         //        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
         //    }
 
-        //    bind.AGVDest = position.PositionCode;
-        //    bind.AGV.TaskOrder(position.PositionCode);
+        //    if (bind.SetAGVStatus(TaskStatus.Running))
+        //    {
+        //        bind.AGVDest = position.PositionCode;
+        //        bind.AGV.TaskOrder(position.PositionCode);
 
-        //    bind.AGVStatus = TaskStatus.Running;
-
-        //    return new ProcessResponse(true);
+        //        return true;
+        //    }
+        //    else
+        //    {
+        //        return false;
+        //    }
         //}
 
-        public bool AGV_UnloadFullTray(string bindId)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
+        ////[ProcessMethod("", "Robot_UnloadFullTray", "鏈哄櫒浜哄嵏杞芥弧Tray", true)]
+        ////public ProcessResponse Robot_UnloadFullTray(IOperationConfig config, IDevice device)
+        ////{
+        ////    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
+        ////    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
 
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
-            }
+        ////    if (position == null)
+        ////    {
+        ////        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
+        ////    }
 
-            if (bind.SetAGVStatus(TaskStatus.Running))
-            {
-                bind.AGVDest = position.PositionCode;
-                bind.AGV.TaskOrder(position.PositionCode);
+        ////    if (bind.AGV.CurrentPosition != position.PositionCode)
+        ////    {
+        ////        throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓嬫枡鐐�");
+        ////    }
 
-                return true;
-            }
-            else
-            {
-                return false;
-            }
-        }
+        ////    bind.RobotStatus = TaskStatus.Running;
+        ////    bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LineSnap, position.PositionNo);
 
-        //[ProcessMethod("", "Robot_UnloadFullTray", "鏈哄櫒浜哄嵏杞芥弧Tray", true)]
-        //public ProcessResponse Robot_UnloadFullTray(IOperationConfig config, IDevice device)
+        ////    return new ProcessResponse(true);
+        ////}
+
+        //public void Robot_UnloadFullTraySnap(string bindId, PathPosition position)
         //{
-        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == (config as AGVBindOpConfig).BindId);
-        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
+        //    //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
 
         //    if (position == null)
         //    {
@@ -1199,148 +845,97 @@
 
         //    bind.RobotStatus = TaskStatus.Running;
         //    bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LineSnap, position.PositionNo);
+        //    //LogAsync(DateTime.Now, "Robot杩愬姩鑷充笅婊ray鎷嶇収", "");
+        //}
+
+        ////[ProcessMethod("", "Camera_UnloadFullTray", "鐩告満鎿嶄綔鍗歌浇婊ray", true)]
+        ////public ProcessResponse Camera_UnloadFullTray(IOperationConfig config, IDevice device)
+        //public ProcessResponse Camera_UnloadFullTray(string robotId, int positionNum)
+        //{
+        //    var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
+        //    PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray && u.PositionNo == positionNum);
+
+        //    if (position == null)
+        //    {
+        //        throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
+        //    }
+
+        //    if (bind.AGV.CurrentPosition != position.PositionCode)
+        //    {
+        //        throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓嬫枡鐐�");
+        //    }
+
+        //    //float adjust_X = 0.0f;
+        //    //float adjust_Y = 0.0f;
+        //    //float adjust_Angle = 0.0f;
+        //    bool isLineReady = false;
+
+        //    if (Config.IsEnableVisionGuide)
+        //    {
+        //        PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
+
+        //        if (visionConfig == null)
+        //        {
+        //            throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
+        //        }
+
+
+        //        int reTryTime = Config.LineBusyRetryTimes;
+
+        //        do
+        //        {
+        //            using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadFullTray"))
+        //            {
+        //                string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
+        //                if (!_halconToolDict.ContainsKey(toolPath))
+        //                {
+        //                    throw new ProcessException($"鏈厤缃瓹amera_UnloadFullTray鐨勮瑙夌畻娉曡矾寰�");
+        //                }
+
+        //                _halconToolDict[toolPath].SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_Result", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
+        //                _halconToolDict[toolPath].RunProcedure();
+
+        //                isLineReady = _halconToolDict[toolPath].GetResultTuple("OUTPUT_Result").I == 1;
+        //            }
+
+        //            if (!isLineReady)
+        //            {
+        //                Thread.Sleep(Config.LineBusyWaitInterval * 1000);
+        //                reTryTime--;
+        //            }
+        //            else
+        //            {
+        //                reTryTime = 0;
+        //            }
+        //        } while (reTryTime > 0);
+
+        //        //if (!isLineReady)
+        //        //{
+        //        //    bind.Robot.SendMsg(RobotMsgType.Send, -1, true, RobotMsgAction.State, RobotMsgParas.LineSnap, new List<string>() { "-1" });
+        //        //    throw new ProcessException("浜х嚎蹇欙紝绛夊緟瓒呮椂");
+        //        //}
+        //        //else
+        //        //{
+        //        //    bind.Robot.SendMsg(RobotMsgType.Send, -1, true, RobotMsgAction.State, RobotMsgParas.LineSnap, new List<string>() { "1" });
+        //        //}
+        //    }
+        //    else
+        //    {
+        //        isLineReady = true;
+        //    }
+
+        //    if (isLineReady)
+        //    {
+        //        bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.FullTray, position.PositionNo);
+        //    }
+        //    else
+        //    {
+        //        bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.Home, position.PositionNo);
+        //    }
 
         //    return new ProcessResponse(true);
         //}
-
-        public void Robot_UnloadFullTraySnap(string bindId, PathPosition position)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.Id == bindId);
-            //PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray);
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
-            }
-
-            if (bind.AGV.CurrentPosition != position.PositionCode)
-            {
-                throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓嬫枡鐐�");
-            }
-
-            bind.RobotStatus = TaskStatus.Running;
-            bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.LineSnap, position.PositionNo);
-            //LogAsync(DateTime.Now, "Robot杩愬姩鑷充笅婊ray鎷嶇収", "");
-        }
-
-        //[ProcessMethod("", "Camera_UnloadFullTray", "鐩告満鎿嶄綔鍗歌浇婊ray", true)]
-        //public ProcessResponse Camera_UnloadFullTray(IOperationConfig config, IDevice device)
-        public ProcessResponse Camera_UnloadFullTray(string robotId, int positionNum)
-        {
-            var bind = Config.AGVBindCollection.FirstOrDefault(u => u.RobotId == robotId);
-            PathPosition position = Config.PositionCollection.FirstOrDefault(u => u.Description == PathPositionDefinition.UnloadFullTray && u.PositionNo == positionNum);
-
-            if (position == null)
-            {
-                throw new ProcessException("璺緞閰嶇疆鏈缃弧Tray涓嬫枡鐐�");
-            }
-
-            if (bind.AGV.CurrentPosition != position.PositionCode)
-            {
-                throw new ProcessException("AGV褰撳墠鏈浜庢弧Tray涓嬫枡鐐�");
-            }
-
-            //float adjust_X = 0.0f;
-            //float adjust_Y = 0.0f;
-            //float adjust_Angle = 0.0f;
-            bool isLineReady = false;
-
-            if (Config.IsEnableVisionGuide)
-            {
-                PositionVisionConfig visionConfig = Config.VisionConfigCollection.FirstOrDefault(u => u.PositionCode == position.PositionCode && u.CameraId == bind.CameraId);
-
-                if (visionConfig == null)
-                {
-                    throw new ProcessException("鏈厤缃鐩告満鐨勬弧Tray涓嬫枡鐐圭殑瑙嗚鎿嶄綔閰嶇疆");
-                }
-
-
-                int reTryTime = Config.LineBusyRetryTimes;
-
-                do
-                {
-                    using (HObject hImage = CollectHImage(bind.Camera, visionConfig.CameraOpConfig, "Camera_UnloadFullTray"))
-                    {
-                        string toolPath = visionConfig.CameraOpConfig.AlgorithemPath;
-                        if (!_halconToolDict.ContainsKey(toolPath))
-                        {
-                            throw new ProcessException($"鏈厤缃瓹amera_UnloadFullTray鐨勮瑙夌畻娉曡矾寰�");
-                        }
-
-                        _halconToolDict[toolPath].SetDictionary(new Dictionary<string, HTuple>() { { "OUTPUT_Result", new HTuple() } }, new Dictionary<string, HObject>() { { "INPUT_Image", hImage } });
-                        _halconToolDict[toolPath].RunProcedure();
-
-                        isLineReady = _halconToolDict[toolPath].GetResultTuple("OUTPUT_Result").I == 1;
-                    }
-
-                    if (!isLineReady)
-                    {
-                        Thread.Sleep(Config.LineBusyWaitInterval * 1000);
-                        reTryTime--;
-                    }
-                    else
-                    {
-                        reTryTime = 0;
-                    }
-                } while (reTryTime > 0);
-
-                //if (!isLineReady)
-                //{
-                //    bind.Robot.SendMsg(RobotMsgType.Send, -1, true, RobotMsgAction.State, RobotMsgParas.LineSnap, new List<string>() { "-1" });
-                //    throw new ProcessException("浜х嚎蹇欙紝绛夊緟瓒呮椂");
-                //}
-                //else
-                //{
-                //    bind.Robot.SendMsg(RobotMsgType.Send, -1, true, RobotMsgAction.State, RobotMsgParas.LineSnap, new List<string>() { "1" });
-                //}
-            }
-            else
-            {
-                isLineReady = true;
-            }
-
-            if (isLineReady)
-            {
-                bind.Robot.SendMsg(RobotMsgAction.Unload, RobotMsgParas.FullTray, position.PositionNo);
-            }
-            else
-            {
-                bind.Robot.SendMsg(RobotMsgAction.Move, RobotMsgParas.Home, position.PositionNo);
-            }
-
-            return new ProcessResponse(true);
-        }
+        //#endregion
         #endregion
-    }
-
-    //[Device("AGVBind", "AGVBind", EnumHelper.DeviceAttributeType.OperationConfig)]
-    public class AGVBindOpConfig : OperationConfigBase
-    {
-        [Category("璁惧淇℃伅")]
-        [Description("鎿嶄綔鐩稿叧鐨勮澶囩紪鍙�")]
-        public string BindId { get; set; }
-
-        [Category("浣嶇疆淇℃伅")]
-        [Description("鎿嶄綔鐩稿叧鐨勪綅缃�")]
-        public PathPosition Position { get; set; }
-
-        public AGVBindOpConfig() { }
-
-        public AGVBindOpConfig(string bindId, PathPosition position = null)
-        {
-            BindId = bindId;
-            Position = position;
-        }
-    }
-
-    public class TaskAssignInfo
-    {
-        public int PositionNo { get; set; }
-
-        public bool IsTaskNeed { get; set; } = false;
-
-        public bool IsTaskAssgined { get; set; } = false;
-
-        public string AgvId { get; set; }
     }
 }

--
Gitblit v1.8.0