bpa
/
BPASmartClient
2
0
Forkuj 0
Kod Zgłoszenia 0 Oczekujące zmiany 0 Wydania 0 Wiki Aktywność
终端一体化运控平台
Nie możesz wybrać więcej, niż 25 tematów Tematy muszą się zaczynać od litery lub cyfry, mogą zawierać myślniki ('-') i mogą mieć do 35 znaków.
1415 Commity
7 Gałęzie
118 MiB
 
 
 
Drzewo: c59da79fc4
Gałęzie Tagi
${ item.name }
Utwórz gałąź ${ searchTerm }
z 'c59da79fc4'
${ noResults }
BPASmartClient/BPASmartClient.MorkCL/Control_MorkCL.cs

1265 wiersze
69 KiB
Czysty Wina Historia 

  1. 

  2. using BPA.Message.Enum;

  3. using BPASmartClient.CustomResource.Pages.Model;

  4. using BPASmartClient.CustomResource.UserControls.MessageShow;

  5. using BPASmartClient.Device;

  6. using BPASmartClient.MorkCL.HelpClass;

  7. using BPASmartClient.MorkCL.Model.DB;

  8. using BPASmartClient.MorkCL.Model.Json;

  9. using BPASmartClient.MorkCL.Server;

  10. using Newtonsoft.Json.Linq;

  11. using Opc.Ua;

  12. using SqlSugar;

  13. using System;

  14. using System.Collections.Generic;

  15. using System.Linq;

  16. using System.Net.WebSockets;

  17. using System.Reflection;

  18. using System.Text;

  19. using System.Threading.Tasks;

  20. 

  21. namespace BPASmartClient.MorkCL

  22. {

  23.     public class Control_MorkCL : BaseDevice

  24.     {

  25.         public override DeviceClientType DeviceType => DeviceClientType.MORKCL;

  26. 

  27.         GVL_MorkCL morkCL = new GVL_MorkCL();

  28.         Alarm alarm = new Alarm();

  29.         /// <summary>

  30.         /// 设备信息集合

  31.         /// </summary>

  32.         ConcurrentDictionary<EDeviceType, IModbus> devices { get; set; } = new();

  33. 

  34.         /// <summary>

  35.         /// 任务集合

  36.         /// </summary>

  37.         ConcurrentDictionary<EDeviceType, TaskServer> TaskList { get; set; } = new();

  38. 

  39.         List<PropertyInfo>? propertyInfos;

  40. 

  41.         public override void DoMain()

  42.         {

  43.             MonitorViewModel.DeviceId = DeviceId;

  44. 

  45.             SqliteHelper.GetInstance.Init();

  46. 

  47.             #region 读取本地文件数据

  48.             Json<RecipesInfo>.Read();

  49.             Json<ItemStorageInfo>.Read();

  50.             Json<ConnectPar>.Read();

  51.             #endregion

  52. 

  53.             //注册本地配方接收

  54.             ActionManage.GetInstance.Register(new Action<object>(o =>

  55.             {

  56.                 DeviceProcessLogShow($"接收到一个新配方任务。");

  57.                 if (o != null && o is ControlData cd)

  58.                 {

  59. 

  60. 

  61.                     morkCL.cds.Enqueue(cd);

  62.                     DeviceProcessLogShow($"新配方任务{cd.Id}解析完成，已加入配方队列。");

  63.                 }

  64.                 else

  65.                 {

  66.                     DeviceProcessLogShow($"新配方任务解析失败。");

  67.                 }

  68.             }), NotifyTopic.FormulaDistribution);

  69. 

  70.             //初始化通讯对象

  71.             devices.TryAdd(EDeviceType.炒锅1, new FryingPanServer());

  72.             devices.TryAdd(EDeviceType.炒锅2, new FryingPanServer());

  73.             devices.TryAdd(EDeviceType.机器人, new RobotServer());

  74.             devices.TryAdd(EDeviceType.压力锅, new PressureCookerServer());

  75.             devices.TryAdd(EDeviceType.外部设备, new OtherServer());

  76. 

  77.             morkCL.IsUseSplitStorage = Json<ConnectPar>.Data.IsUseSplitStorage;

  78. 

  79. #if !FORMAL

  80.             if (Json<ConnectPar>.Data.FryPanConnect_1)

  81.             {

  82.                 devices[EDeviceType.炒锅1].Init(Json<ConnectPar>.Data.FryingPanIP1);

  83.             }

  84.             if (Json<ConnectPar>.Data.FryPanConnect_2)

  85.             {

  86.                 devices[EDeviceType.炒锅2].Init(Json<ConnectPar>.Data.FryingPanIP2);

  87.             }

  88.             if (Json<ConnectPar>.Data.RobotConnet)

  89.             {

  90.                 devices[EDeviceType.机器人].Init(Json<ConnectPar>.Data.RobotIP);

  91.             }

  92.             if (Json<ConnectPar>.Data.PressureCookerConnect)

  93.             {

  94.                 devices[EDeviceType.压力锅].Init(Json<ConnectPar>.Data.PressureCookerIP);

  95.             }

  96.             if (Json<ConnectPar>.Data.OtherDeviceConnect)

  97.             {

  98.                 devices[EDeviceType.外部设备].Init(PortName: Json<ConnectPar>.Data.ESPortName);

  99.             }

  100. #endif

  101.             ManualActionRegiester();

  102.         }

  103. 

  104.         public override void MainTask()

  105.         {

  106.             //检查到有任务完成后将对已完成的任务进行清理

  107.             var res = TaskList.FirstOrDefault(p => p.Value.IsComplete).Key;

  108.             if (TaskList.ContainsKey(res))

  109.                 TaskList.TryRemove(res, out _);

  110. 

  111.             if (TaskList.IsEmpty)

  112.             {

  113.                 morkCL.CanItemStorage = true;

  114.             }

  115.             else

  116.             {

  117.                 morkCL.CanItemStorage = false;

  118.             }

  119. 

  120.             //分配任务，这段程序必须写最后。

  121.             if (morkCL.cds.Count > 0)

  122.             {

  123.                 #region 修改为在下配方时选择使用哪个锅，这段程序不需要使用了。

  124.                 //var dishType = morkCL.cds.ElementAt(0).DishType;

  125.                 //var devieceType = EDeviceType.无;

  126.                 //if (dishType == Model.Recipe.EDishType.炒菜)

  127.                 //{

  128.                 //    //如果任务队列里，炒锅1已经有任务了，就看炒锅2是否有任务，没任务就设置为炒锅2执行，如果两个锅都有任务则返回该次任务。

  129.                 //    if (TaskList.ContainsKey(EDeviceType.炒锅1))

  130.                 //    {

  131.                 //        if (TaskList.ContainsKey(EDeviceType.炒锅2))

  132.                 //        {

  133.                 //            return;

  134.                 //        }

  135.                 //        else

  136.                 //        { devieceType = EDeviceType.炒锅2; }

  137.                 //    }

  138.                 //    else

  139.                 //    {

  140.                 //        devieceType = EDeviceType.炒锅1;

  141.                 //    }

  142.                 //}

  143.                 //else

  144.                 //{

  145.                 //    devieceType = EDeviceType.压力锅;

  146.                 //}

  147. 

  148.                 #endregion

  149. 

  150.                 //这里判定主要是针对压力锅。

  151.                 //修改为炒锅和机器人不允许下单情况下，就不下单。

  152.                 if (!TaskList.ContainsKey(morkCL.cds.ElementAt(0).DeviceType)&&GetFryPanAndRobotIsAuto(morkCL.cds.ElementAt(0).DeviceType))

  153.                 {

  154.                     if (morkCL.cds.TryDequeue(out ControlData cd))

  155.                     {

  156.                         //cd.DeviceType = devieceType;

  157.                         //cd.DeviceType = EDeviceType.炒锅1;

  158.                         TaskList.TryAdd(cd.DeviceType, new TaskServer());

  159.                         TaskList[cd.DeviceType].TaskName = $"{cd.DeviceType.ToString()}-{cd.Name}";

  160.                         TaskList[cd.DeviceType].RunTask = new Task(new Action(() => { FryingPanControl(cd.DeviceType, cd); }));

  161.                         TaskList[cd.DeviceType].RunTask.Start();

  162.                     }

  163.                 }

  164. 

  165.             }

  166.         }

  167. 

  168.         #region 日志修改前

  169.         //private async void FryingPanControl(EDeviceType et, ControlData cd)

  170.         //{

  171.         //    DeviceProcessLogShow($"【{et}】开始执行-{cd.Name} 任务");

  172.         //    if (TaskList.ContainsKey(et) && TaskList[et].Cts.IsCancellationRequested)

  173.         //        return;

  174.         //    while (cd.ControlFuncs.Count > 0)

  175.         //    {

  176.         //        if (cd.ControlFuncs.TryDequeue(out FuncModel fm))

  177.         //        {

  178.         //            var device = (FryingPanServer)devices[et];

  179.         //            var robot = (RobotServer)devices[EDeviceType.机器人];

  180.         //            var otherDevice = (OtherServer)devices[EDeviceType.外部设备];

  181.         //            int index = (ushort)et - 1;

  182.         //            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}。");

  183.         //            switch (fm.eFunc)

  184.         //            {

  185.         //                case EFunc.搅拌启动:

  186.         //                    device.StirStartOrStop = false;

  187. 

  188.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入搅拌频率-{fm.funcPars.ElementAt(0).ParValue.ToString()}HZ。");

  189.         //                    device.MixingFrequencySet(fm.funcPars.ElementAt(0).ParValue.ToString());

  190.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入搅拌频率-{fm.funcPars.ElementAt(0).ParValue.ToString()}HZ完成。");

  191. 

  192.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入开始搅拌。");

  193.         //                    device.StirStartOrStop = true;

  194.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入开始搅拌完成。");

  195. 

  196.         //                    break;

  197.         //                case EFunc.搅拌停止:

  198.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入停止搅拌。");

  199.         //                    device.StirStartOrStop = false;

  200.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-写入停止搅拌完成。");

  201.         //                    break;

  202.         //                case EFunc.加热启动:

  203.         //                    device.HeatStartOrStop = false;

  204. 

  205.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置加热挡位-【{fm.funcPars.ElementAt(0).ParValue.ToString()}】。");

  206.         //                    device.HeatingGearSet(fm.funcPars.ElementAt(0).ParValue.ToString());

  207.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置加热挡位完成，设置加热启动。");

  208. 

  209.         //                    device.HeatStartOrStop = true;

  210.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置加热启动完成。");

  211.         //                    break;

  212.         //                case EFunc.加热停止:

  213.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置加热停止。");

  214.         //                    device.HeatStartOrStop = false;

  215.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置加热停止完成。");

  216.         //                    break;

  217.         //                case EFunc.添加调料:

  218.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-查找调料【{fm.funcPars.ElementAt(0).Id}】。");

  219.         //                    var Seasoning = SqliteHelper.GetInstance.GetSeasoning().FirstOrDefault(p => p.Id == fm.funcPars.ElementAt(0).Id);

  220.         //                    if (Seasoning != null)

  221.         //                    {

  222.         //                        device.FryingPanToSeasoningLoc = false;

  223. 

  224.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅到调料投料位置。");

  225.         //                        device.FryingPanToSeasoningLoc = true;

  226.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅到调料投料位置完成。");

  227. 

  228.         //                        //回到投料位置就复位。

  229. 

  230.         //                        Thread.Sleep(50);

  231.         //                        device.FeedingSeasoningLocFB.Wait(Cts: TaskList[et].Cts);

  232.         //                        device.FryingPanToSeasoningLoc = false;

  233.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-炒锅已到达调料投料位置。");

  234. 

  235.         //                        device.CuttingControl(Seasoning.Loc.ToString(), fm.funcPars.ElementAt(1).ParValue.ToString());

  236.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-执行下料，下料位置：{Seasoning.Loc.ToString()}，下料重量：【{fm.funcPars.ElementAt(1).ParValue.ToString()}】。");

  237.         //                    }

  238.         //                    else

  239.         //                    {

  240.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-查找调料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】调料。任务取消。");

  241.         //                        TaskList[et].Cts.Cancel();

  242.         //                    }

  243. 

  244.         //                    break;

  245.         //                case EFunc.添加主料:

  246.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-查找主料【{fm.funcPars.ElementAt(0).Id}】。");

  247. 

  248.         //                    if (float.TryParse(fm.funcPars.ElementAt(1).ParValue.ToString(), out float weight))

  249.         //                    {

  250.         //                        //查找主料库位符合条件的物料库位，主要根据物料ID和物料重量查找。

  251.         //                        var ingre_index = Array.FindIndex(Json<ItemStorageInfo>.Data.IngredientsStorage,

  252.         //                        item => item.MaterialID == fm.funcPars.ElementAt(0).Id/* && item.Weight == weight*/);

  253.         //                        if (ingre_index >= 0)

  254.         //                        {

  255.         //                            //device.CuttingControl(Seasoning.Loc.ToString(), fm.funcPars.ElementAt(1).ParValue.ToString());

  256.         //                            var ingredientes = Json<ItemStorageInfo>.Data.IngredientsStorage[ingre_index];

  257. 

  258.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-执行下料，控制取{ingre_index + 1}库物料，下料名称：{ingredientes.Name.ToString()}，下料重量：【{fm.funcPars.ElementAt(1).ParValue.ToString()}】。");

  259.         //                            device.FryingPanHome = false;

  260. 

  261.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(ingre_index + 1).ToString()}】，子任务【{et}】。");

  262. 

  263.         //                            robot.RobotTaskControl((ingre_index + 1).ToString(), et);

  264.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(ingre_index + 1).ToString()}】，子任务【{et}】完成。");

  265. 

  266.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置。");

  267.         //                            device.FryingPanHome = true;

  268.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置完成。");

  269. 

  270.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置。");

  271.         //                            device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);//等待炒锅到投料位置

  272.         //                            device.FryingPanHome = false;

  273.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置完成。");

  274. 

  275. 

  276.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待机器人到投料位置。");

  277.         //                            robot.MaterialPouringRequest[index].Wait(Cts: TaskList[et].Cts);  //等待机器人到投料位置也就是发出倒料请求。

  278.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待机器人到投料位置完成。");

  279. 

  280.         //                            //目前程序在炒锅在投料位置时，会自动发出允许倒料信息。

  281.         //                            //DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置允许机器人开始投料。");

  282.         //                            //robot.AllowPourVegetables(et);//允许机器人开始投料

  283.         //                            //DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置允许机器人开始投料完成。");

  284. 

  285.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-开始等待机器人投料完成。");

  286.         //                            robot.MaterialPouringComplete[index].Wait(Cts: TaskList[et].Cts);    //等待机器人投料完成

  287.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-机器人投料完成。");

  288. 

  289.         //                            Json<ItemStorageInfo>.Data.IngredientsStorage[ingre_index] = new ItemStorage();

  290.         //                            Json<ItemStorageInfo>.Save();

  291.         //                            ActionManage.GetInstance.Send("RefreshItemStorage");

  292.         //                        }

  293.         //                        else

  294.         //                        {

  295.         //                            //TODO:暂定为直接取消任务，后期再说。

  296.         //                            DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-查找主料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】主料。任务取消。");

  297.         //                            TaskList[et].Cts.Cancel();

  298.         //                        }

  299.         //                    }

  300.         //                    break;

  301.         //                case EFunc.添加辅料:

  302.         //                    MaterialBase mb = SqliteHelper.GetInstance.GetAccessories().FirstOrDefault(p => p.Id == fm.funcPars.ElementAt(0).Id);

  303.         //                    if (mb != null)

  304.         //                    {

  305.         //                        //先复位变量。防止上一次是异常结束，设为True时，不会响应。

  306.         //                        device.FryingPanHome = false;

  307. 

  308.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(mb.Loc + 12).ToString()}】，子任务【{et}】。");

  309.         //                        robot.RobotTaskControl((mb.Loc + 12).ToString(), et);

  310.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(mb.Loc + 12).ToString()}】，子任务【{et}】完成。");

  311. 

  312.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置。");

  313.         //                        device.FryingPanHome = true;

  314.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置完成。");

  315. 

  316.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置。");

  317.         //                        device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);//等待炒锅到投料位置

  318.         //                        device.FryingPanHome = false;

  319.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置完成。");

  320. 

  321.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待机器人到投料位置。");

  322.         //                        robot.MaterialPouringRequest[index].Wait(Cts: TaskList[et].Cts);  //等待机器人到投料位置

  323.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待机器人到投料位置完成。");

  324. 

  325.         //                        //DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置允许机器人开始投料。");

  326.         //                        //robot.AllowPourVegetables(et);//允许机器人开始投料

  327.         //                        //DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置允许机器人开始投料完成。");

  328. 

  329.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-开始等待机器人投料完成。");

  330.         //                        robot.MaterialPouringComplete[index].Wait(Cts: TaskList[et].Cts);    //等待机器人投料完成

  331.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-机器人投料完成。");

  332. 

  333.         //                    }

  334.         //                    else

  335.         //                    {

  336.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-查找主料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】辅料。任务取消。");

  337.         //                        TaskList[et].Cts.Cancel();

  338.         //                    }

  339.         //                    break;

  340.         //                case EFunc.炒锅回原点位:

  341.         //                    device.FryingPanFeedingLoc = false;

  342.         //                    device.FryingPanHome = false;

  343.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回原点。");

  344.         //                    device.FryingPanHome = true;

  345.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅回原点完成。");

  346. 

  347.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待回原点完成。");

  348.         //                    device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);

  349.         //                    device.FryingPanHome = false;

  350. 

  351.         //                    break;

  352.         //                case EFunc.出餐启动:

  353. 

  354.         //                    device.DiningOutStart = false;

  355.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人取空盆。");

  356.         //                    //TODO：暂时修改，后期优化。

  357.         //                    while (true)

  358.         //                    {

  359.         //                        var emptyPanIndex = Array.FindIndex(otherDevice.BoxDetection, i => i == true);

  360.         //                        if (emptyPanIndex >= 0)

  361.         //                        {

  362.         //                            robot.RobotTaskControl((21 + emptyPanIndex).ToString(), et);//取空盆

  363.         //                            break;

  364.         //                        }

  365.         //                        await Task.Delay(3000);

  366.         //                        DeviceProcessLogShow("无空盆，请添加空盆！");

  367.         //                    }

  368.         //                    //robot.RobotTaskControl("21", et);//取空盆

  369.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置机器人取空盆完成，等待机器人到出菜位置。");

  370. 

  371.         //                    robot.DiningOutRequest[index].Wait(Cts: TaskList[et].Cts);//等待机器人到出菜位置

  372.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-机器人已到出餐位置，出餐启动。");

  373.         //                    device.DiningOutStart = true;

  374. 

  375.         //                    device.OutDinningSlowDownFlag.Wait(Cts: TaskList[et].Cts);

  376.         //                    robot.ModerateInPlace(et);

  377.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-到达出餐减速位。");

  378. 

  379.         //                    device.OutDinningFinsh.Wait(Cts: TaskList[et].Cts);

  380.         //                    robot.DiningOutComplete(et);

  381. 

  382.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-出餐完成。");

  383.         //                    //回到投料位置就复位。

  384.         //                    Thread.Sleep(50);

  385.         //                    device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);

  386.         //                    device.DiningOutStart = false;

  387.         //                    break;

  388.         //                case EFunc.炒锅清洗:

  389.         //                    device.FryingPanClear = false;

  390. 

  391.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅清洗。");

  392.         //                    device.FryingPanClear = true;

  393.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-炒锅清洗已写入。");

  394. 

  395.         //                    Thread.Sleep(500);

  396.         //                    device.CleanFinish.Wait(Cts: TaskList[et].Cts);

  397.         //                    device.FryingPanClear = false;

  398.         //                    break;

  399.         //                case EFunc.炒锅回调料投料位置:

  400.         //                    device.FryingPanToSeasoningLoc = false;

  401. 

  402.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅到调料投料位置。");

  403.         //                    device.FryingPanToSeasoningLoc = true;

  404.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置炒锅到调料投料位置完成。");

  405. 

  406.         //                    //回到投料位置就复位。

  407. 

  408.         //                    Thread.Sleep(50);

  409.         //                    device.FeedingSeasoningLocFB.Wait(Cts: TaskList[et].Cts);

  410.         //                    device.FryingPanToSeasoningLoc = false;

  411.         //                    break;

  412.         //                case EFunc.去指定炒制位:

  413.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置去指定炒制位。");

  414.         //                    device.SetStirFryingLoc(fm.funcPars.ElementAt(0).ParValue.ToString());

  415.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-设置去指定炒制位【{fm.funcPars.ElementAt(0).ParValue.ToString()}】完成。");

  416.         //                    break;

  417.         //                case EFunc.炒制:

  418. 

  419.         //                    if (int.TryParse(fm.funcPars.ElementAt(0).ParValue.ToString(), out int time))

  420.         //                    {

  421.         //                        DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-等待炒制【{time}】秒。");

  422.         //                        Task.Delay(time * 1000).Wait(TaskList[et].Cts.Token);

  423.         //                    }

  424. 

  425.         //                    DeviceProcessLogShow($"{cd.Name}-任务执行-{fm.eFunc.ToString()}-炒制完成。");

  426.         //                    break;

  427.         //                default:

  428.         //                    break;

  429.         //            }

  430.         //        }

  431.         //    }

  432.         //    DeviceProcessLogShow($"【{et}】任务-{cd.Name} 执行完成");

  433.         //} 

  434.         #endregion

  435. 

  436.         #region 炒锅流程控制日志修改后

  437.         private async void FryingPanControl(EDeviceType et, ControlData cd)

  438.         {

  439.             DeviceProcessLogShow($"【{et}】开始执行-{cd.Name} 任务");

  440.             if (TaskList.ContainsKey(et) && TaskList[et].Cts.IsCancellationRequested)

  441.                 return;

  442.             while (cd.ControlFuncs.Count > 0 && !TaskList[et].Cts.IsCancellationRequested)

  443.             {

  444.                 if (cd.ControlFuncs.TryDequeue(out FuncModel fm))

  445.                 {

  446.                     var device = (FryingPanServer)devices[et];

  447.                     var robot = (RobotServer)devices[EDeviceType.机器人];

  448.                     var otherDevice = (OtherServer)devices[EDeviceType.外部设备];

  449.                     int index = (ushort)et - 1;

  450.                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}。");

  451.                     try

  452.                     {

  453.                         switch (fm.eFunc)

  454.                         {

  455.                             #region 搅拌启动与停止

  456. 

  457.                             case EFunc.搅拌启动:

  458.                                 device.StirStartOrStop = false;

  459. 

  460.                                 device.MixingFrequencySet(fm.funcPars.ElementAt(0).ParValue.ToString());

  461.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-写入搅拌频率-{fm.funcPars.ElementAt(0).ParValue.ToString()}HZ完成。");

  462.                                 await Task.Delay(400);

  463.                                 device.StirStartOrStop = true;

  464.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-写入开始搅拌完成。");

  465. 

  466.                                 break;

  467.                             case EFunc.搅拌停止:

  468.                                 device.StirStartOrStop = false;

  469.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-写入停止搅拌完成。");

  470.                                 break; 

  471. 

  472.                             #endregion

  473. 

  474.                             #region 加热启动与停止

  475. 

  476.                             case EFunc.加热启动:

  477.                                 device.HeatStartOrStop = false;

  478.                                 await Task.Delay(400);

  479. 

  480.                                 device.HeatingGearSet(fm.funcPars.ElementAt(0).ParValue.ToString());

  481.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置加热挡位-【{fm.funcPars.ElementAt(0).ParValue.ToString()}】完成，等待设置加热启动。");

  482. 

  483.                                 device.HeatStartOrStop = true;

  484.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置加热启动完成。");

  485.                                 break;

  486.                             case EFunc.加热停止:

  487.                                 device.HeatStartOrStop = false;

  488.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置加热停止完成。");

  489.                                 break; 

  490.                             #endregion

  491. 

  492.                             #region 添加调料

  493.                             case EFunc.添加调料:

  494.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-查找调料【{fm.funcPars.ElementAt(0).Id}】。");

  495.                                 var Seasoning = SqliteHelper.GetInstance.GetSeasoning().FirstOrDefault(p => p.Id == fm.funcPars.ElementAt(0).Id);

  496.                                 if (Seasoning != null)

  497.                                 {

  498.                                     device.FryingPanToSeasoningLoc = false;

  499.                                     await Task.Delay(400);

  500. 

  501.                                     device.FryingPanToSeasoningLoc = true;

  502.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅到调料投料位置完成，等待炒锅到达调料投料位置。");

  503. 

  504.                                     //回到投料位置就复位。

  505. 

  506.                                     await Task.Delay(400);

  507. 

  508.                                     device.FeedingSeasoningLocFB.Wait(Cts: TaskList[et].Cts);

  509.                                     device.FryingPanToSeasoningLoc = false;

  510.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒锅已到达调料投料位置。");

  511. 

  512.                                     device.CuttingControl(Seasoning.Loc.ToString(), fm.funcPars.ElementAt(1).ParValue.ToString(), TaskList[et].Cts);

  513.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-执行下料，下料位置：{Seasoning.Loc.ToString()}，下料重量：【{fm.funcPars.ElementAt(1).ParValue.ToString()}】。");

  514. 

  515.                                     //去炒制位

  516.                                     string stirFryLoc = fm.funcPars.ElementAt(2).ParValue.ToString();

  517.                                     GoStirFryLoc(stirFryLoc);

  518. 

  519.                                     //炒制

  520.                                     if (int.TryParse(fm.funcPars.ElementAt(3).ParValue.ToString(), out int time1))

  521.                                     {

  522.                                         StirFry(time1);

  523.                                     }

  524.                                 }

  525.                                 else

  526.                                 {

  527.                                     MessageNotify.GetInstance.ShowDialog($"任务【{cd.Name}】查找调料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】调料，任务即将取消。", DialogType.Warning);

  528.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-查找调料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】调料。任务取消。");

  529.                                     TaskList[et].Cts.Cancel();

  530.                                 }

  531. 

  532.                                 break; 

  533.                             #endregion

  534. 

  535.                             #region 添加主料

  536.                             case EFunc.添加主料:

  537.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-查找主料【{fm.funcPars.ElementAt(0).Id}】。");

  538. 

  539.                                 if (float.TryParse(fm.funcPars.ElementAt(1).ParValue.ToString(), out float weight))

  540.                                 {

  541.                                     robot.IsIdle.Wait(Cts: TaskList[et].Cts);

  542.                                     //查找主料库位符合条件的物料库位，主要根据物料ID和物料重量查找。

  543.                                     var ingre_index = Array.FindIndex(Json<ItemStorageInfo>.Data.IngredientsStorage,

  544.                                     item => item.MaterialID == fm.funcPars.ElementAt(0).Id/* && item.Weight == weight*/);

  545.                                     if (ingre_index >= 0)

  546.                                     {

  547.                                         var ingredientes = Json<ItemStorageInfo>.Data.IngredientsStorage[ingre_index];

  548. 

  549.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-执行下料，控制取{ingre_index + 1}库物料，下料名称：{ingredientes.Name.ToString()}，下料重量：【{fm.funcPars.ElementAt(1).ParValue.ToString()}】。");

  550.                                         device.FryingPanHome = false;

  551. 

  552. 

  553.                                         robot.RobotTaskControl((ingre_index + 1).ToString(), et);

  554.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(ingre_index + 1).ToString()}】，子任务【{et}】完成。");

  555.                                         await Task.Delay(400);

  556. 

  557.                                         device.FryingPanHome = true;

  558.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置完成，等待炒锅回到主料辅料投料位置");

  559. 

  560.                                         device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);//等待炒锅到投料位置

  561.                                         await Task.Delay(400);

  562. 

  563.                                         device.FryingPanHome = false;

  564.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置完成。");

  565. 

  566. 

  567.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-等待机器人到投料位置。");

  568.                                         robot.MaterialPouringRequest[index].Wait(Cts: TaskList[et].Cts);  //等待机器人到投料位置也就是发出倒料请求。

  569. 

  570.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-机器人已到达投料位置，等待机器人投料完成。");

  571.                                         robot.MaterialPouringComplete[index].Wait(Cts: TaskList[et].Cts);    //等待机器人投料完成

  572.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-机器人投料完成。");

  573. 

  574.                                         Json<ItemStorageInfo>.Data.IngredientsStorage[ingre_index] = new ItemStorage();

  575.                                         Json<ItemStorageInfo>.Save();

  576.                                         ActionManage.GetInstance.Send("RefreshItemStorage");

  577. 

  578.                                         //去炒制位

  579.                                         string stirFryLoc = fm.funcPars.ElementAt(2).ParValue.ToString();

  580.                                         GoStirFryLoc(stirFryLoc);

  581. 

  582.                                         //炒制

  583.                                         if (int.TryParse(fm.funcPars.ElementAt(3).ParValue.ToString(), out int time2))

  584.                                         {

  585.                                             StirFry(time2);

  586.                                         }

  587.                                     }

  588.                                     else

  589.                                     {

  590.                                         MessageNotify.GetInstance.ShowDialog($"任务【{cd.Name}】查找主料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】主料，任务即将取消。", DialogType.Warning);

  591. 

  592.                                         //TODO:暂定为直接取消任务，后期再说。

  593.                                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-查找主料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】主料。任务取消。");

  594.                                         TaskList[et].Cts.Cancel();

  595.                                     }

  596.                                 }

  597.                                 break; 

  598.                             #endregion

  599. 

  600.                             #region 添加辅料

  601.                             case EFunc.添加辅料:

  602.                                 #region 根据配置文件选择每个炒锅的最大最小辅料位置，暂时没使用。

  603.                                 var minloc = 1;

  604.                                 var maxloc = 8;

  605.                                 if (morkCL.IsUseSplitStorage)

  606.                                 {

  607.                                     if (et == EDeviceType.炒锅1)

  608.                                     {

  609.                                         minloc = Json<ConnectPar>.Data.FryPanAccessoriesMin_1;

  610.                                         maxloc = Json<ConnectPar>.Data.FryPanAccessoriesMax_1;

  611.                                     }

  612.                                     else if (et == EDeviceType.炒锅2)

  613.                                     {

  614.                                         minloc = Json<ConnectPar>.Data.FryPanAccessoriesMin_2;

  615.                                         maxloc = Json<ConnectPar>.Data.FryPanAccessoriesMax_2;

  616.                                     }

  617.                                 }

  618.                                 else

  619.                                 {

  620.                                     minloc = 1;

  621.                                     maxloc = 8;

  622.                                 }

  623. 

  624.                                 #endregion

  625. 

  626.                                 MaterialBase mb = SqliteHelper.GetInstance.GetAccessories().FirstOrDefault(p => p.Loc >= minloc && p.Loc <= maxloc && p.Id == fm.funcPars.ElementAt(0).Id);

  627.                                 if (mb != null)

  628.                                 {

  629.                                     robot.IsIdle.Wait(Cts: TaskList[et].Cts);

  630.                                     //先复位变量。防止上一次是异常结束，设为True时，不会响应。

  631.                                     device.FryingPanHome = false;

  632. 

  633.                                     robot.RobotTaskControl((mb.Loc + 12).ToString(), et);

  634.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置机器人任务【{(mb.Loc + 12).ToString()}】，子任务【{et}】完成。");

  635. 

  636.                                     await Task.Delay(400);

  637.                                     device.FryingPanHome = true;

  638.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅回投料位置完成，开始等待炒锅到投料位置。");

  639. 

  640.                                     device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);//等待炒锅到投料位置

  641.                                     await Task.Delay(400);

  642.                                     device.FryingPanHome = false;

  643.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-等待炒锅到投料位置完成，等待机器人到投料位置。");

  644. 

  645.                                     robot.MaterialPouringRequest[index].Wait(Cts: TaskList[et].Cts);  //等待机器人到投料位置

  646.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-机器人到达投料位置完成，开始等待机器人投料完成。");

  647. 

  648.                                     robot.MaterialPouringComplete[index].Wait(Cts: TaskList[et].Cts);    //等待机器人投料完成

  649.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-机器人投料完成。");

  650. 

  651.                                     //去炒制位

  652.                                     string stirFryLoc = fm.funcPars.ElementAt(1).ParValue.ToString();

  653.                                     GoStirFryLoc(stirFryLoc);

  654. 

  655.                                     //炒制

  656.                                     if (int.TryParse(fm.funcPars.ElementAt(2).ParValue.ToString(), out int time3))

  657.                                     {

  658.                                         StirFry(time3);

  659.                                     }

  660. 

  661.                                 }

  662.                                 else

  663.                                 {

  664.                                     MessageNotify.GetInstance.ShowDialog($"任务【{cd.Name}】查找辅料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】辅料，任务即将取消。", DialogType.Warning);

  665.                                     DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-查找辅料失败，未查找到【{fm.funcPars.ElementAt(0).Id}】辅料。任务取消。");

  666.                                     TaskList[et].Cts.Cancel();

  667.                                 }

  668.                                 break;

  669.                             #endregion

  670.                             case EFunc.炒锅回原点位:

  671.                                 GoHome();

  672. 

  673.                                 break;

  674. 

  675.                             #region 出餐启动

  676.                             case EFunc.出餐启动:

  677. 

  678.                                 device.DiningOutStart = false;

  679.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置机器人取空盆。");

  680. 

  681.                                 robot.IsIdle.Wait(Cts: TaskList[et].Cts);

  682.                                 //TODO：暂时修改，后期优化。

  683.                                 while (!TaskList[et].Cts.IsCancellationRequested)

  684.                                 {

  685.                                     var emptyPanIndex = Array.FindIndex(otherDevice.BoxDetection, i => i == true);

  686.                                     if (emptyPanIndex >= 0)

  687.                                     {

  688.                                         robot.RobotTaskControl((21 + emptyPanIndex).ToString(), et);//取空盆

  689.                                         break;

  690.                                     }

  691.                                     await Task.Delay(3000);

  692.                                     DeviceProcessLogShow("无空盆，请添加空盆！");

  693.                                 }

  694.                                 //robot.RobotTaskControl("21", et);//取空盆

  695.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置机器人取空盆完成，等待机器人到出菜位置。");

  696. 

  697.                                 robot.DiningOutRequest[index].Wait(Cts: TaskList[et].Cts);//等待机器人到出菜位置

  698.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-机器人已到出餐位置，出餐启动。");

  699.                                 await Task.Delay(400);

  700.                                 device.DiningOutStart = true;

  701. 

  702.                                 device.OutDinningSlowDownFlag.Wait(Cts: TaskList[et].Cts);

  703.                                 robot.ModerateInPlace(et);

  704.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-到达出餐减速位。");

  705. 

  706.                                 device.OutDinningFinsh.Wait(Cts: TaskList[et].Cts);

  707.                                 robot.DiningOutComplete(et);

  708. 

  709.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-出餐完成。");

  710.                                 //回到投料位置就复位。

  711.                                 Thread.Sleep(50);

  712.                                 device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);

  713.                                 await Task.Delay(400);

  714.                                 device.DiningOutStart = false;

  715.                                 break;

  716.                             #endregion

  717.                             #region 炒锅清洗--基本没用

  718.                             case EFunc.炒锅清洗:

  719.                                 device.FryingPanClear = false;

  720. 

  721.                                 //DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅清洗。");

  722.                                 await Task.Delay(400);

  723.                                 device.FryingPanClear = true;

  724.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒锅清洗已写入，等待炒锅清洗完成。");

  725. 

  726.                                 Thread.Sleep(500);

  727.                                 device.CleanFinish.Wait(Cts: TaskList[et].Cts);

  728.                                 await Task.Delay(400);

  729.                                 device.FryingPanClear = false;

  730.                                 DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒锅清洗完成。");

  731.                                 break;

  732.                             #endregion

  733. 

  734.                             #region 

  735.                             case EFunc.去指定炒制位:

  736.                                 //DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置去指定炒制位。");

  737.                                 string loc = fm.funcPars.ElementAt(0).ParValue.ToString();

  738.                                 GoStirFryLoc(loc);

  739. 

  740. 

  741.                                 break;

  742.                             case EFunc.炒制:

  743. 

  744.                                 if (int.TryParse(fm.funcPars.ElementAt(0).ParValue.ToString(), out int time))

  745.                                 {

  746.                                     StirFry(time);

  747.                                 }

  748. 

  749.                                 break;

  750.                             #endregion

  751.                             default:

  752.                                 break;

  753.                         }

  754. 

  755.                         #region 回原点

  756.                         void GoHome()

  757.                         {

  758.                             device.FryingPanFeedingLoc = false;

  759.                             device.FryingPanHome = false;

  760.                             //DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅回原点。");

  761.                             Task.Delay(400).Wait();

  762.                             device.FryingPanHome = true;

  763.                             DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置炒锅回原点完成，等待炒锅回原点。");

  764. 

  765.                             //DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-等待回原点完成。");

  766.                             device.FeedingLocFB.Wait(Cts: TaskList[et].Cts);

  767.                             Task.Delay(400).Wait();

  768.                             device.FryingPanHome = false;

  769.                             DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒锅回原点完成。");

  770.                         }

  771.                         #endregion

  772. 

  773.                         #region 去指定炒制位

  774.                         //去指定炒制位

  775.                         void GoStirFryLoc(string loc)

  776.                         {

  777.                             device.SetStirFryingLoc(loc, TaskList[et].Cts);

  778.                             DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-设置去指定炒制位【{fm.funcPars.ElementAt(0).ParValue.ToString()}】完成。");

  779. 

  780.                             //TODO:根据情况看是否需要等待反馈变量。

  781.                             //device.StirFryingLocFB[int.Parse(fm.funcPars.ElementAt(0).ParValue.ToString())].Wait();

  782.                             //DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒锅到达炒制位【{fm.funcPars.ElementAt(0).ParValue.ToString()}】。");

  783.                         }

  784.                         #endregion

  785. 

  786.                         #region 炒制延时

  787.                         //炒制延时。

  788.                         void StirFry(int time)

  789.                         {

  790.                             DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-等待炒制【{time}】秒。");

  791. 

  792.                             Task.Delay(time * 1000).Wait(TaskList[et].Cts.Token);

  793.                             DeviceProcessLogShow($"{cd.Name}-【{et}#】任务执行-{fm.eFunc.ToString()}-炒制完成。");

  794.                         } 

  795.                         #endregion

  796. 

  797.                     }

  798.                     catch (TaskCanceledException)

  799.                     {

  800.                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务被取消。");

  801.                     }

  802.                     catch (OperationCanceledException)

  803.                     {

  804.                         DeviceProcessLogShow($"{cd.Name}-【{et}#】任务被手动取消。");

  805.                     }

  806.                 }

  807.             }

  808.             DeviceProcessLogShow($"【{et}】任务-{cd.Name} 执行完成");

  809.             TaskList[et].IsComplete = true;

  810.         }

  811.         #endregion

  812. 

  813.         public override void ReadData()

  814.         {

  815.             if (propertyInfos is null || propertyInfos.Count==0)

  816.             {

  817.                 propertyInfos = morkCL.GetType().GetProperties().ToList();

  818.             }

  819.             morkCL.RecipeQueueCount = morkCL.cds.Count;

  820.             morkCL.FryingPanTaskCount_1 = morkCL.cds.Count(data => data.DeviceType == EDeviceType.炒锅1);

  821.             morkCL.FryingPanTaskCount_2 = morkCL.cds.Count(data => data.DeviceType == EDeviceType.炒锅2);

  822. 

  823.             var fryingPan1 = (FryingPanServer)devices[EDeviceType.炒锅1];

  824.             var fryingPan2 = (FryingPanServer)devices[EDeviceType.炒锅2];

  825.             var robot = (RobotServer)devices[EDeviceType.机器人];

  826.             var pressureCooker = (PressureCookerServer)devices[EDeviceType.压力锅];

  827.             var otherDevice = (OtherServer)devices[EDeviceType.外部设备];

  828. 

  829.             alarm.EStop1 = fryingPan1.EStopAlarm;

  830.             alarm.FryingPanFowardLimit1 = fryingPan1.FryingPanFowardLimit;

  831.             alarm.FryingPanReverseLimit1 = fryingPan1.FryingPanReverseLimit;

  832.             alarm.FryingPanEncoderCommError1 = fryingPan1.FryingPanEncoderCommError;

  833.             alarm.StirMotorCommError1 = fryingPan1.StirMotorCommError;

  834.             alarm.RollingMotorCommError1 = fryingPan1.RollingMotorCommError;

  835.             alarm.StirMotorError1 = fryingPan1.StirMotorErrorCode != "无故障" ? true : false;

  836.             alarm.TurnMotorError1 = fryingPan1.TurnMotorErrorCode != "无故障" ? true : false;

  837. 

  838.             alarm.EStop2 = fryingPan2.EStopAlarm;

  839.             alarm.FryingPanFowardLimit2 = fryingPan2.FryingPanFowardLimit;

  840.             alarm.FryingPanReverseLimit2 = fryingPan2.FryingPanReverseLimit;

  841.             alarm.FryingPanEncoderCommError2 = fryingPan2.FryingPanEncoderCommError;

  842.             alarm.StirMotorCommError2 = fryingPan2.StirMotorCommError;

  843.             alarm.RollingMotorCommError2 = fryingPan2.RollingMotorCommError;

  844.             alarm.StirMotorError2 = fryingPan2.StirMotorErrorCode != "无故障" ? true : false;

  845.             alarm.TurnMotorError2 = fryingPan2.TurnMotorErrorCode != "无故障" ? true : false;

  846. 

  847.             //这是字段。直接赋值

  848.             morkCL.FeedingSeasoningLocFB1 = fryingPan1.FeedingSeasoningLocFB;

  849.             morkCL.FeedingSeasoningLocFB2 = fryingPan2.FeedingSeasoningLocFB;

  850. 

  851.             morkCL.FeedingLocFB1 = fryingPan1.FeedingLocFB;

  852.             morkCL.FeedingLocFB2 = fryingPan2.FeedingLocFB;

  853. 

  854.             morkCL.CleanFinish1 = fryingPan1.CleanFinish;

  855.             morkCL.CleanFinish2 = fryingPan2.CleanFinish;

  856.             

  857.             morkCL.OutDinningFinsh1 = fryingPan1.OutDinningFinsh;

  858.             morkCL.OutDinningFinsh2 = fryingPan2.OutDinningFinsh;

  859. 

  860.             morkCL.OutDinningSlowDownFlag1 = fryingPan1.OutDinningSlowDownFlag;

  861.             morkCL.OutDinningSlowDownFlag2 = fryingPan2.OutDinningSlowDownFlag;

  862. 

  863.             morkCL.BoxDetection = otherDevice.BoxDetection;

  864.             morkCL.IsIdle = robot.IsIdle;

  865. 

  866. #if !FORMAL

  867.             if (fryingPan1.FeedingLocFB)

  868.             {

  869.                 robot.AllowPourVegetables(EDeviceType.炒锅1);

  870.             }

  871.             else

  872.             {

  873.                 robot.DisablePourVegetables(EDeviceType.炒锅1);

  874.             }

  875. 

  876.             if (fryingPan2.FeedingLocFB)

  877.             {

  878.                 robot.AllowPourVegetables(EDeviceType.炒锅2);

  879.             }

  880.             else

  881.             {

  882.                 robot.DisablePourVegetables(EDeviceType.炒锅2);

  883.             }

  884. 

  885. 

  886.             foreach (var property in propertyInfos)

  887.             {

  888.                 var att = property.GetCustomAttribute<VariableMonitorAttribute>();

  889.                 if (att != null)

  890.                 {

  891.                     if (att.Notes.Contains("1号炒锅"))

  892.                     {

  893.                         var p = fryingPan1.GetType().GetProperty(property.Name.TrimEnd('1'));

  894.                         if (p != null)

  895.                         {

  896.                             property.SetValue(morkCL, p.GetValue(fryingPan1));

  897.                         }

  898. 

  899.                     }

  900.                     else if (att.Notes.Contains("2号炒锅"))

  901.                     {

  902.                         var p = fryingPan2.GetType().GetProperty(property.Name.TrimEnd('2'));

  903.                         if (p != null)

  904.                         {

  905.                             property.SetValue(morkCL, p.GetValue(fryingPan2));

  906.                         }

  907. 

  908.                     }

  909.                     else if (att.Notes.Contains("机器人"))

  910.                     {

  911.                         var p = robot.GetType().GetProperty(property.Name);

  912.                         if (p != null)

  913.                         {

  914.                             property.SetValue(morkCL, p.GetValue(robot));

  915.                         }

  916.                     }

  917.                     else if (att.Notes.Contains("电子秤"))

  918.                     {

  919.                         var p = otherDevice.GetType().GetProperty(property.Name);

  920.                         if (p != null)

  921.                         {

  922.                             var res = p.GetValue(otherDevice);

  923.                             property.SetValue(morkCL, res);

  924.                             if (p.Name== "CurrentWeight")

  925.                             {

  926.                                 ActionManage.GetInstance.Send("SendCurrentWeight", res);

  927.                             }

  928.                         }

  929.                     }

  930.                     else if (att.Notes.Contains("高压锅"))

  931.                     {

  932.                         var p = pressureCooker.GetType().GetProperty(property.Name);

  933.                         if (p != null)

  934.                         {

  935.                             property.SetValue(morkCL, p.GetValue(pressureCooker));

  936.                         }

  937.                     }

  938.                 }

  939.             }

  940. 

  941. #endif

  942.         }

  943. 

  944.         public override void ResetProgram()

  945.         {

  946.             morkCL = null;

  947.             morkCL = new GVL_MorkCL();

  948.         }

  949. 

  950.         public override void SimOrder()

  951.         {

  952.         }

  953. 

  954.         public override void Stop()

  955.         {

  956.         }

  957.         private bool GetFryPanAndRobotIsAuto(EDeviceType fryPan)

  958.         {

  959.             //目前拿不到机器人的远程状态，只能拿到炒锅的。

  960.             var device = (FryingPanServer)devices[fryPan];

  961.             var robot = (RobotServer)devices[EDeviceType.机器人];

  962.             return device.InitComplete && device.StatusMode && device.EStop && robot.RemoteMode;

  963.            

  964.         }

  965.         void ManualActionRegiester()

  966.         {

  967.             //主料入库委托。

  968.             ActionManage.GetInstance.Register((object o) =>

  969.             {

  970.                 if (!morkCL.CanItemStorage)

  971.                 {

  972.                     MessageNotify.GetInstance.ShowDialog("当前有炒菜任务正在排队，为避免影响菜品口味，不可入库，请稍后再试。", DialogType.Warning);

  973.                     NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "入库失败", $"物料入库失败，当前正在制作菜品。");

  974.                     return;

  975.                 }

  976.                 var robot = (RobotServer)devices[EDeviceType.机器人];

  977.                 if (robot.IsIdle==false)

  978.                 {

  979.                     MessageNotify.GetInstance.ShowDialog("当前机器人未在空闲状态，稍后再试。", DialogType.Warning);

  980.                     return;

  981.                 }

  982.                 TaskManage.GetInstance.Start(() =>

  983.                 {

  984.                     if (o != null && o is IngredientsTB ingredients)

  985.                     {

  986. 

  987.                         var index = Array.FindIndex(Json<ItemStorageInfo>.Data.IngredientsStorage, i => i.IsEmploy == false);

  988.                         if (index >= 0)

  989.                         {

  990.                             if (!MessageNotify.GetInstance.ShowDialog($"请确认库位【{index+1}】上无物品，否则可能会造成碰撞事故！",DialogType.Warning))

  991.                             {

  992. 

  993.                                 DeviceProcessLogShow($"物料[{ingredients.Name}]，ID:[{ingredients.Id}]，库位[{index+1}]入库失败，未确认库位无异物。");

  994.                                 Application.Current.Dispatcher.Invoke(() =>

  995.                                 {

  996.                                     NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "入库失败", $"物料{ingredients.Name}入库失败。");

  997.                                 });

  998.                                 return;

  999.                             }

  1000. 

  1001.                             var item = Json<ItemStorageInfo>.Data.IngredientsStorage[index];

  1002. 

  1003.                             item.MaterialID = ingredients.Id;

  1004.                             item.Name = ingredients.Name;

  1005.                             item.IsEmploy = true;

  1006.                             item.Weight = ((OtherServer)devices[EDeviceType.外部设备]).CurrentWeight;

  1007. 

  1008.                             var loc = (index + 1).ToString();

  1009. #if !FORMAL

  1010.                             

  1011.                             robot.WarehousingControl(loc,null);

  1012.                             DeviceProcessLogShow($"已下发机器人物料入{loc}号库任务，等待机器人入库操作完成");

  1013.                             robot.WarehousingComplete[(Convert.ToInt32(loc) - 1)].Wait();

  1014. #endif

  1015.                             Json<ItemStorageInfo>.Save();

  1016. 

  1017.                             ActionManage.GetInstance.Send("RefreshItemStorage");

  1018. 

  1019.                             DeviceProcessLogShow($"物料[{ingredients.Name}]，ID:[{ingredients.Id}]，库位[{index + 1}]入库成功。");

  1020.                             Application.Current.Dispatcher.Invoke(() =>

  1021.                             {

  1022.                                 NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "入库成功", $"物料{ingredients.Name}入库成功。");

  1023. 

  1024.                             });

  1025.                             return;

  1026.                         }

  1027.                         else

  1028.                         {

  1029.                             Application.Current.Dispatcher.Invoke(() =>

  1030.                             {

  1031.                                 NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "入库失败", $"物料库已满。");

  1032.                             });

  1033.                         }

  1034.                     }

  1035.                     else

  1036.                     {

  1037.                         Application.Current.Dispatcher.Invoke(() =>

  1038.                         {

  1039.                             NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "入库失败", $"物料入库失败。");

  1040.                         });

  1041.                     }

  1042.                 }, "ItemStorageTask");

  1043. 

  1044.             }, NotifyTopic.ItemStorage, true);

  1045. 

  1046.             ActionManage.GetInstance.Register(() =>

  1047.             {

  1048.                 if (ActionManage.GetInstance.SendResult("SystemIsBusy") is bool isBusy)

  1049.                 {

  1050.                     if (isBusy == true)

  1051.                     {

  1052.                         NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "失败", $"当前还有配方任务在排队制作，请稍后后再试。");

  1053.                         return;

  1054.                     }

  1055.                     Task.Run(() =>

  1056.                     {

  1057.                         var robot = (RobotServer)devices[EDeviceType.机器人];

  1058.                         robot.GoCleanLoc();

  1059.                         Application.Current.Dispatcher.Invoke(() =>

  1060.                         {

  1061.                             NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "设置成功", $"设置机器人去清洗位置成功。");

  1062.                         });

  1063. 

  1064.                         robot.AtCleanLoc.Wait();

  1065.                         Application.Current.Dispatcher.Invoke(() =>

  1066.                         {

  1067.                             NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "成功", $"机器人已到达清洗位置。");

  1068.                         });

  1069.                     });

  1070. 

  1071.                 }

  1072.             }, "RobotGoCleanLoc", true);

  1073. 

  1074.             ActionManage.GetInstance.Register(() =>

  1075.             {

  1076.                 Task.Run(() =>

  1077.                 {

  1078.                     var robot = (RobotServer)devices[EDeviceType.机器人];

  1079.                     bool isSuccuess=  robot.SendCleanFinish();

  1080.                     if (isSuccuess)

  1081.                     {

  1082.                         Application.Current.Dispatcher.Invoke(() =>

  1083.                         {

  1084.                             NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "通知成功", $"通知机器人清洗完成成功。");

  1085.                         });

  1086.                     }

  1087.                     

  1088.                 });

  1089.             }, "RobotCleanFinish", true);

  1090. 

  1091.             #region 暂时弃用

  1092.             ActionManage.GetInstance.Register((object location) =>

  1093.                {

  1094.                    var loc = location.ToString();

  1095.                    if (!String.IsNullOrEmpty(loc) && loc.Length >= 0)

  1096.                    {

  1097.                        var robot = (RobotServer)devices[EDeviceType.机器人];

  1098.                        //Thread.Sleep(5000);

  1099.                        robot.WarehousingControl(loc,null);

  1100.                        //会卡死。

  1101.                        robot.WarehousingComplete[(Convert.ToInt32(loc) - 1)].Wait();

  1102.                    }

  1103.                }, "ItemStorage", true); 

  1104.             #endregion

  1105. 

  1106.             ActionManage.GetInstance.Register((object[] o) =>

  1107.             {

  1108.                 if (o is not null && o is object[] para)

  1109.                 {

  1110.                     var device =(EDeviceType)Enum.Parse(typeof(EDeviceType), para[0].ToString());

  1111.                     var channelIndex = para[1].ToString();

  1112.                     var demandValue = para[2].ToString();

  1113.                     ((FryingPanServer)devices[device]).CuttingControl(channelIndex, demandValue,null);

  1114.                 }

  1115.             },"DeviceCuttingControl",true);

  1116. 

  1117.             ActionManage.GetInstance.Register((object o) =>

  1118.             {

  1119.                 if (o is not null)

  1120.                 {

  1121.                     var device = (EDeviceType)Enum.Parse(typeof(EDeviceType), o.ToString());

  1122.                     if (TaskList.ContainsKey(device))

  1123.                     {

  1124.                         TaskList[device].Cts.Cancel();

  1125.                         DeviceProcessLogShow($"取消{device}当前任务成功。");

  1126.                     }

  1127.                     else

  1128.                     {

  1129.                         DeviceProcessLogShow($"[{device}]当前无任务。");

  1130.                     }

  1131.                 }

  1132.                 

  1133.             }, "CancelFryPanTask", true);

  1134. 

  1135.             ActionManage.GetInstance.Register((object o) =>

  1136.             {

  1137.                 if (o is not null)

  1138.                 {

  1139.                     var device = (EDeviceType)Enum.Parse(typeof(EDeviceType), o.ToString());

  1140.                     //TODO : 把所有属于该炒锅的任务全部删除。

  1141.                 }

  1142. 

  1143.             }, "ClearFryPanTask", true);

  1144. 

  1145.             ActionManage.GetInstance.Register(() =>

  1146.             {

  1147.                 //电子秤去皮

  1148.                 var weghier = (OtherServer)devices[EDeviceType.外部设备];

  1149.                 if (weghier.WeigherTare())

  1150.                 {

  1151.                     Application.Current.Dispatcher.Invoke(() =>

  1152.                     {

  1153.                         NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "去皮成功", $"电子秤除皮操作成功。");

  1154.                     });

  1155.                     DeviceProcessLogShow($"电子秤除皮操作成功。");

  1156.                 }

  1157.                 else

  1158.                 {

  1159.                     Application.Current.Dispatcher.Invoke(() =>

  1160.                     {

  1161.                         NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "去皮失败", $"电子秤除皮操作失败。");

  1162.                     });

  1163.                     DeviceProcessLogShow($"电子秤除皮操作失败。");

  1164.                 }

  1165.                

  1166. 

  1167.             },"WeighrTare",true);

  1168. 

  1169.             ActionManage.GetInstance.Register(() =>

  1170.             {

  1171.                 //电子秤置零

  1172.                 var weghier = (OtherServer)devices[EDeviceType.外部设备];

  1173.                 if (weghier.WeigherZero())

  1174.                 {

  1175.                     Application.Current.Dispatcher.Invoke(() =>

  1176.                     {

  1177.                         NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "置零成功", $"电子秤置零操作成功。");

  1178.                     });

  1179.                         DeviceProcessLogShow($"电子秤置零操作成功。");

  1180.                 }

  1181.                 else

  1182.                 {

  1183.                     Application.Current.Dispatcher.Invoke(() =>

  1184.                     {

  1185.                         NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "置零失败", $"电子秤置零操作失败。");

  1186.                     });

  1187.                         DeviceProcessLogShow($"电子秤置零操作失败。");

  1188.                 }

  1189. 

  1190.             }, "WeighrZero", true);

  1191. 

  1192.             ActionManage.GetInstance.Register((object o) =>

  1193.             {

  1194.                 if (o != null && o is WriteModel<bool> write)

  1195.                 {

  1196.                     if (!TaskList.ContainsKey(write.DeviceType))

  1197.                     {

  1198.                         devices[write.DeviceType].WriteValue<bool>(write.Address, write.Value);

  1199.                         DeviceProcessLogShow($"设备[{write.DeviceType}]--手动写入地址[{write.Address}]，值[{write.Value}]");

  1200.                     }

  1201.                 }

  1202.             }, "WriteBool", true);

  1203. 

  1204. 

  1205.             ActionManage.GetInstance.Register((object o) =>

  1206.             {

  1207.                 if (o != null && o is WriteModel<ushort> write)

  1208.                 {

  1209.                     if (!TaskList.ContainsKey(write.DeviceType))

  1210.                     {

  1211.                         devices[write.DeviceType].WriteValue<ushort>(write.Address, write.Value);

  1212.                         DeviceProcessLogShow($"设备[{write.DeviceType}]--手动写入地址[{write.Address}]，值[{write.Value}]");

  1213.                     }

  1214.                     //else

  1215.                     //{

  1216.                     //    //MessageNotify.GetInstance.ShowDialog("当前有炒菜任务，不可手动操作，请稍后再试。", DialogType.Warning);

  1217.                     //    NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "操作失败", $"手动操作失败，当前正在制作菜品。");

  1218.                     //    return;

  1219.                     //}

  1220.                 }

  1221.             }, "WriteUshort", true);

  1222. 

  1223.             ActionManage.GetInstance.Register(frypanIsIdle, "GetDeviceIsIdle", true);

  1224. 

  1225.             ActionManage.GetInstance.Register(() =>

  1226.             {

  1227.                 var robot = (RobotServer)devices[EDeviceType.机器人];

  1228.                 if (robot.InitVariable())

  1229.                 {

  1230.                     Application.Current.Dispatcher.Invoke(() => { NoticeDemoViewModel.OpenMsg(EnumPromptType.Success, Application.Current.MainWindow, "成功", $"复位所有由上位机下发至机器人的变量成功。"); });

  1231.                     DeviceProcessLogShow($"复位所有由上位机下发至机器人的变量成功。");

  1232.                 }

  1233.                 else

  1234.                 {

  1235.                     Application.Current.Dispatcher.Invoke(() => { NoticeDemoViewModel.OpenMsg(EnumPromptType.Error, Application.Current.MainWindow, "失败", $"复位所有由上位机下发至机器人的变量失败。"); });

  1236.                     DeviceProcessLogShow($"复位所有由上位机下发至机器人的变量失败。");

  1237.                 }

  1238.             }, "InitRobotAllVar", true);

  1239. 

  1240.             ActionManage.GetInstance.Register<Func<object>>(() =>

  1241.             {

  1242.                 if (morkCL.RecipeQueueCount > 0 || morkCL.FryingPanTaskCount_1 > 0 || morkCL.FryingPanTaskCount_2 > 0)

  1243.                 {

  1244.                     return true;

  1245.                 }

  1246.                 return false;

  1247.             },"SystemIsBusy",true);

  1248.         }

  1249. 

  1250.         Func<object, object> frypanIsIdle => (o) =>

  1251.         {

  1252.             if (o is not null)

  1253.             {

  1254.                 var device = (EDeviceType)Enum.Parse(typeof(EDeviceType), o.ToString());

  1255.                 if (!TaskList.ContainsKey(device))

  1256.                 {

  1257.                     return true;

  1258.                 }

  1259.             }

  1260.             return false;

  1261.         };

  1262.         

  1263.     }

  1264. }