bpa
/
BPASmartClient
2
0
Atdalīts 0
Kods Problēmas 0 Izmaiņu pieprasījumi 0 Laidieni 0 Vikivietne Aktivitāte
终端一体化运控平台
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
1469 Revīzijas
7 Atzari
118 MiB
 
 
 
Atzars: 一拖四味魔方配料系统
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '一拖四味魔方配料系统'
${ noResults }
BPASmartClient/BPASmartClient.MorkCL/Control_MorkCL.cs

1210 rindas
70 KiB
Neapstrādāts Patstāvīgā saite Vainot Vēsture 

  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.                             case EFunc.搅拌启动:

  456.                                 device.StirStartOrStop = false;

  457. 

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

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

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

  461.                                 await Task.Delay(400);

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

  463.                                 device.StirStartOrStop = true;

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

  465. 

  466.                                 break;

  467.                             case EFunc.搅拌停止:

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

  469.                                 device.StirStartOrStop = false;

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

  471.                                 break;

  472.                             case EFunc.加热启动:

  473.                                 device.HeatStartOrStop = false;

  474.                                 await Task.Delay(400);

  475. 

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

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

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

  479. 

  480.                                 device.HeatStartOrStop = true;

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

  482.                                 break;

  483.                             case EFunc.加热停止:

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

  485.                                 device.HeatStartOrStop = false;

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

  487.                                 break;

  488.                             case EFunc.添加调料:

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

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

  491.                                 if (Seasoning != null)

  492.                                 {

  493.                                     device.FryingPanToSeasoningLoc = false;

  494.                                     await Task.Delay(400);

  495. 

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

  497.                                     device.FryingPanToSeasoningLoc = true;

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

  499. 

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

  501. 

  502.                                     await Task.Delay(400);

  503. 

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

  505.                                     device.FryingPanToSeasoningLoc = false;

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

  507. 

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

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

  510.                                 }

  511.                                 else

  512.                                 {

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

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

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

  516.                                 }

  517. 

  518.                                 break;

  519.                             case EFunc.添加主料:

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

  521. 

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

  523.                                 {

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

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

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

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

  528.                                     if (ingre_index >= 0)

  529.                                     {

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

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

  532. 

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

  534.                                         device.FryingPanHome = false;

  535. 

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

  537. 

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

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

  540.                                         await Task.Delay(400);

  541. 

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

  543.                                         device.FryingPanHome = true;

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

  545. 

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

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

  548.                                         await Task.Delay(400);

  549. 

  550.                                         device.FryingPanHome = false;

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

  552. 

  553. 

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

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

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

  557. 

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

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

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

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

  562. 

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

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

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

  566. 

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

  568.                                         Json<ItemStorageInfo>.Save();

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

  570.                                     }

  571.                                     else

  572.                                     {

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

  574. 

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

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

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

  578.                                     }

  579.                                 }

  580.                                 break;

  581.                             case EFunc.添加辅料:

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

  583.                                 var minloc = 1;

  584.                                 var maxloc = 8;

  585.                                 if (morkCL.IsUseSplitStorage)

  586.                                 {

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

  588.                                     {

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

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

  591.                                     }

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

  593.                                     {

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

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

  596.                                     }

  597.                                 }

  598.                                 else

  599.                                 {

  600.                                     minloc = 1;

  601.                                     maxloc = 8;

  602.                                 }

  603. 

  604.                                 #endregion

  605. 

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

  607.                                 if (mb != null)

  608.                                 {

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

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

  611.                                     device.FryingPanHome = false;

  612. 

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

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

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

  616. 

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

  618.                                     await Task.Delay(400);

  619.                                     device.FryingPanHome = true;

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

  621. 

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

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

  624.                                     await Task.Delay(400);

  625.                                     device.FryingPanHome = false;

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

  627. 

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

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

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

  631. 

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

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

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

  635. 

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

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

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

  639. 

  640.                                 }

  641.                                 else

  642.                                 {

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

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

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

  646.                                 }

  647.                                 break;

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

  649.                                 device.FryingPanFeedingLoc = false;

  650.                                 device.FryingPanHome = false;

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

  652.                                 await Task.Delay(400);

  653.                                 device.FryingPanHome = true;

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

  655. 

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

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

  658.                                 await Task.Delay(400);

  659.                                 device.FryingPanHome = false;

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

  661.                                 break;

  662.                             case EFunc.出餐启动:

  663. 

  664.                                 device.DiningOutStart = false;

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

  666.                                 

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

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

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

  670.                                 {

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

  672.                                     if (emptyPanIndex >= 0)

  673.                                     {

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

  675.                                         break;

  676.                                     }

  677.                                     await Task.Delay(3000);

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

  679.                                 }

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

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

  682. 

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

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

  685.                                 await Task.Delay(400);

  686.                                 device.DiningOutStart = true;

  687. 

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

  689.                                 robot.ModerateInPlace(et);

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

  691. 

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

  693.                                 robot.DiningOutComplete(et);

  694. 

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

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

  697.                                 Thread.Sleep(50);

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

  699.                                 await Task.Delay(400);

  700.                                 device.DiningOutStart = false;

  701.                                 break;

  702.                             case EFunc.炒锅清洗:

  703.                                 device.FryingPanClear = false;

  704. 

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

  706.                                 await Task.Delay(400);

  707.                                 device.FryingPanClear = true;

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

  709. 

  710.                                 Thread.Sleep(500);

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

  712.                                 await Task.Delay(400);

  713.                                 device.FryingPanClear = false;

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

  715.                                 break;

  716.                                 //该功能废弃，添加调料时，自动回到调料投料位置。

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

  718.                             //    device.FryingPanToSeasoningLoc = false;

  719. 

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

  721.                             //    await Task.Delay(400);

  722.                             //    device.FryingPanToSeasoningLoc = true;

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

  724. 

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

  726. 

  727.                             //    Thread.Sleep(50);

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

  729.                             //    await Task.Delay(400);

  730.                             //    device.FryingPanToSeasoningLoc = false;

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

  732.                             //    break;

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

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

  735.                                 device.SetStirFryingLoc(fm.funcPars.ElementAt(0).ParValue.ToString(),  TaskList[et].Cts);

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

  737. 

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

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

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

  741.                                 break;

  742.                             case EFunc.炒制:

  743. 

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

  745.                                 {

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

  747. 

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

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

  750.                                 }

  751. 

  752.                                 break;

  753.                             default:

  754.                                 break;

  755.                         }

  756.                     }

  757. 

  758.                     catch (TaskCanceledException)

  759.                     {

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

  761.                     }

  762.                     catch (OperationCanceledException)

  763.                     {

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

  765.                     }

  766.                 }

  767.             }

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

  769.             TaskList[et].IsComplete = true;

  770.         }

  771.         #endregion

  772. 

  773.         public override void ReadData()

  774.         {

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

  776.             {

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

  778.             }

  779.             morkCL.RecipeQueueCount = morkCL.cds.Count;

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

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

  782. 

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

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

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

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

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

  788. 

  789.             alarm.EStop1 = fryingPan1.EStopAlarm;

  790.             alarm.FryingPanFowardLimit1 = fryingPan1.FryingPanFowardLimit;

  791.             alarm.FryingPanReverseLimit1 = fryingPan1.FryingPanReverseLimit;

  792.             alarm.FryingPanEncoderCommError1 = fryingPan1.FryingPanEncoderCommError;

  793.             alarm.StirMotorCommError1 = fryingPan1.StirMotorCommError;

  794.             alarm.RollingMotorCommError1 = fryingPan1.RollingMotorCommError;

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

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

  797. 

  798.             alarm.EStop2 = fryingPan2.EStopAlarm;

  799.             alarm.FryingPanFowardLimit2 = fryingPan2.FryingPanFowardLimit;

  800.             alarm.FryingPanReverseLimit2 = fryingPan2.FryingPanReverseLimit;

  801.             alarm.FryingPanEncoderCommError2 = fryingPan2.FryingPanEncoderCommError;

  802.             alarm.StirMotorCommError2 = fryingPan2.StirMotorCommError;

  803.             alarm.RollingMotorCommError2 = fryingPan2.RollingMotorCommError;

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

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

  806. 

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

  808.             morkCL.FeedingSeasoningLocFB1 = fryingPan1.FeedingSeasoningLocFB;

  809.             morkCL.FeedingSeasoningLocFB2 = fryingPan2.FeedingSeasoningLocFB;

  810. 

  811.             morkCL.FeedingLocFB1 = fryingPan1.FeedingLocFB;

  812.             morkCL.FeedingLocFB2 = fryingPan2.FeedingLocFB;

  813. 

  814.             morkCL.CleanFinish1 = fryingPan1.CleanFinish;

  815.             morkCL.CleanFinish2 = fryingPan2.CleanFinish;

  816.             

  817.             morkCL.OutDinningFinsh1 = fryingPan1.OutDinningFinsh;

  818.             morkCL.OutDinningFinsh2 = fryingPan2.OutDinningFinsh;

  819. 

  820.             morkCL.OutDinningSlowDownFlag1 = fryingPan1.OutDinningSlowDownFlag;

  821.             morkCL.OutDinningSlowDownFlag2 = fryingPan2.OutDinningSlowDownFlag;

  822. 

  823.             morkCL.BoxDetection = otherDevice.BoxDetection;

  824.             morkCL.IsIdle = robot.IsIdle;

  825. 

  826. #if !FORMAL

  827.             if (fryingPan1.FeedingLocFB)

  828.             {

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

  830.             }

  831.             else

  832.             {

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

  834.             }

  835. 

  836.             if (fryingPan2.FeedingLocFB)

  837.             {

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

  839.             }

  840.             else

  841.             {

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

  843.             }

  844. 

  845. 

  846.             foreach (var property in propertyInfos)

  847.             {

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

  849.                 if (att != null)

  850.                 {

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

  852.                     {

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

  854.                         if (p != null)

  855.                         {

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

  857.                         }

  858. 

  859.                     }

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

  861.                     {

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

  863.                         if (p != null)

  864.                         {

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

  866.                         }

  867. 

  868.                     }

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

  870.                     {

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

  872.                         if (p != null)

  873.                         {

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

  875.                         }

  876.                     }

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

  878.                     {

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

  880.                         if (p != null)

  881.                         {

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

  883.                             property.SetValue(morkCL, res);

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

  885.                             {

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

  887.                             }

  888.                         }

  889.                     }

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

  891.                     {

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

  893.                         if (p != null)

  894.                         {

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

  896.                         }

  897.                     }

  898.                 }

  899.             }

  900. 

  901. #endif

  902.         }

  903. 

  904.         public override void ResetProgram()

  905.         {

  906.             morkCL = null;

  907.             morkCL = new GVL_MorkCL();

  908.         }

  909. 

  910.         public override void SimOrder()

  911.         {

  912.         }

  913. 

  914.         public override void Stop()

  915.         {

  916.         }

  917.         private bool GetFryPanAndRobotIsAuto(EDeviceType fryPan)

  918.         {

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

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

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

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

  923.            

  924.         }

  925.         void ManualActionRegiester()

  926.         {

  927.             //主料入库委托。

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

  929.             {

  930.                 if (!morkCL.CanItemStorage)

  931.                 {

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

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

  934.                     return;

  935.                 }

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

  937.                 if (robot.IsIdle==false)

  938.                 {

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

  940.                     return;

  941.                 }

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

  943.                 {

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

  945.                     {

  946. 

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

  948.                         if (index >= 0)

  949.                         {

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

  951.                             {

  952. 

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

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

  955.                                 {

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

  957.                                 });

  958.                                 return;

  959.                             }

  960. 

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

  962. 

  963.                             item.MaterialID = ingredients.Id;

  964.                             item.Name = ingredients.Name;

  965.                             item.IsEmploy = true;

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

  967. 

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

  969. #if !FORMAL

  970.                             

  971.                             robot.WarehousingControl(loc,null);

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

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

  974. #endif

  975.                             Json<ItemStorageInfo>.Save();

  976. 

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

  978. 

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

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

  981.                             {

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

  983. 

  984.                             });

  985.                             return;

  986.                         }

  987.                         else

  988.                         {

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

  990.                             {

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

  992.                             });

  993.                         }

  994.                     }

  995.                     else

  996.                     {

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

  998.                         {

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

  1000.                         });

  1001.                     }

  1002.                 }, "ItemStorageTask");

  1003. 

  1004.             }, NotifyTopic.ItemStorage, true);

  1005. 

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

  1007.             {

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

  1009.                 {

  1010.                     if (isBusy == true)

  1011.                     {

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

  1013.                         return;

  1014.                     }

  1015.                     Task.Run(() =>

  1016.                     {

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

  1018.                         robot.GoCleanLoc();

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

  1020.                         {

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

  1022.                         });

  1023.                     });

  1024. 

  1025.                 }

  1026.             }, "RobotGoCleanLoc", true);

  1027. 

  1028.             #region 暂时弃用

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

  1030.                {

  1031.                    var loc = location.ToString();

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

  1033.                    {

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

  1035.                        //Thread.Sleep(5000);

  1036.                        robot.WarehousingControl(loc,null);

  1037.                        //会卡死。

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

  1039.                    }

  1040.                }, "ItemStorage", true); 

  1041.             #endregion

  1042. 

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

  1044.             {

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

  1046.                 {

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

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

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

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

  1051.                 }

  1052.             },"DeviceCuttingControl",true);

  1053. 

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

  1055.             {

  1056.                 if (o is not null)

  1057.                 {

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

  1059.                     if (TaskList.ContainsKey(device))

  1060.                     {

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

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

  1063.                     }

  1064.                     else

  1065.                     {

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

  1067.                     }

  1068.                 }

  1069.                 

  1070.             }, "CancelFryPanTask", true);

  1071. 

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

  1073.             {

  1074.                 if (o is not null)

  1075.                 {

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

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

  1078.                 }

  1079. 

  1080.             }, "ClearFryPanTask", true);

  1081. 

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

  1083.             {

  1084.                 //电子秤去皮

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

  1086.                 if (weghier.WeigherTare())

  1087.                 {

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

  1089.                     {

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

  1091.                     });

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

  1093.                 }

  1094.                 else

  1095.                 {

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

  1097.                     {

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

  1099.                     });

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

  1101.                 }

  1102.                

  1103. 

  1104.             },"WeighrTare",true);

  1105. 

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

  1107.             {

  1108.                 //电子秤置零

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

  1110.                 if (weghier.WeigherZero())

  1111.                 {

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

  1113.                     {

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

  1115.                     });

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

  1117.                 }

  1118.                 else

  1119.                 {

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

  1121.                     {

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

  1123.                     });

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

  1125.                 }

  1126. 

  1127.             }, "WeighrZero", true);

  1128. 

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

  1130.             {

  1131. 

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

  1133.                 {

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

  1135.                     {

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

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

  1138.                     }

  1139.                     //else

  1140.                     //{

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

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

  1143.                     //    return;

  1144.                     //}

  1145.                 }

  1146.             }, "WriteBool", true);

  1147. 

  1148. 

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

  1150.             {

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

  1152.                 {

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

  1154.                     {

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

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

  1157.                     }

  1158.                     //else

  1159.                     //{

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

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

  1162.                     //    return;

  1163.                     //}

  1164.                 }

  1165.             }, "WriteUshort", true);

  1166. 

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

  1168. 

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

  1170.             {

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

  1172.                 if (robot.InitVariable())

  1173.                 {

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

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

  1176.                 }

  1177.                 else

  1178.                 {

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

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

  1181.                 }

  1182.             }, "InitRobotAllVar", true);

  1183. 

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

  1185.             {

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

  1187.                 {

  1188.                     return true;

  1189.                 }

  1190.                 return false;

  1191.             },"SystemIsBusy",true);

  1192.         }

  1193. 

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

  1195.         {

  1196.             if (o is not null)

  1197.             {

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

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

  1200.                 {

  1201.                     return true;

  1202.                 }

  1203.             }

  1204.             return false;

  1205.         };

  1206. 

  1207.         

  1208.     }

  1209. }