BPASmartClient/BPASmartClient.MorkF/Control_MorkF.cs

using BPA.Message;
using BPA.Message.Enum;
using BPASmartClient.Device;
using BPASmartClient.EventBus;
using BPASmartClient.Helper;
using BPASmartClient.Message;
using BPASmartClient.Model;
using BPASmartClient.Model.PLC;
using BPA.Models;
using static BPASmartClient.EventBus.EventBus;

namespace BPASmartClient.MorkF
{
    public class Control_MorkF : BaseDevice
    {
        public override DeviceClientType DeviceType => DeviceClientType.MORKSF;

        GVL_MorkF morkF = new GVL_MorkF();//全局对象声明
        public StirFryBom stirFryBom = new StirFryBom();//创建获取流程的对象
        //public bool ProcessError { get; set; }//流程错误
        /// <summary>
        /// 入口
        /// </summary>
        public override void DoMain()
        {
            ServerInit();
            DataParse();//数据解析
            ThreadManage.GetInstance().StartLong(new Action(() =>
            {
                IsHealth = true;
                ReadData();
                Thread.Sleep(10);
            }), "ReadPLCData");
            ThreadManage.GetInstance().StartLong(new Action(() =>
            {
                MainTask();
                Thread.Sleep(10);
            }), "MainTask");

            MessageLog.GetInstance.Show("MORKF 设备初始化完成");
        }

        public override void ResetProgram()
        {
            morkF = null;
            morkF = new GVL_MorkF();
        }

        /// <summary>
        /// PLC数据读取
        /// </summary>
        public override void ReadData()
        {
            //ThreadManage.GetInstance().StartLong(new Action(() =>
            //{
            GetStatus("M0.1", new Action<bool[]>((bools) =>
            {
                Initing = bools[0];
                morkF.InitialComplete = Initing;
            }));
            GetStatus("M1.0", new Action<bool[]>((bools) =>
            {
                morkF.ProvidePlateModule = bools[0];
                morkF.ProvidePlateComplete = bools[2];
                morkF.CleanModule = bools[3];
                morkF.CleanComplete = bools[5];
            }));
            GetStatus("M2.0", new Action<bool[]>((bools) =>
            {
                morkF.KitchenOneStatus = bools[1];
                morkF.FallOilComplete = bools[8];
            }));
            GetStatus("M8.0", new Action<bool[]>((bools) =>
            {
                morkF.TurnMachineUpComplete = bools[1];
                morkF.TurnMachineDownComplete = bools[3];
            }));
            GetStatus("M13.5", new Action<bool[]>((bools) =>
            {
                morkF.MaterialArriveComplete = bools[0];
            }));
            GetStatus("M16.0", new Action<bool[]>((bools) =>
            {
                morkF.PutPotToKitchenComlete = bools[1];
                morkF.TakeMaterialComplete = bools[2];
                morkF.PlaceRinseTableComplete = bools[5];
                morkF.RoobotIdle = bools[6];
            }));

            //    Thread.Sleep(500);
            //}), "ReadPLCData");
        }
        private void ServerInit()
        {
            //物料信息
            EventBus.EventBus.GetInstance().Subscribe<MaterialDeliveryEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (@event == null) return;
                if (@event is MaterialDeliveryEvent material)
                {
                    orderMaterialDelivery = material.orderMaterialDelivery;
                }
            });

            //配方数据信息
            EventBus.EventBus.GetInstance().Subscribe<RecipeBomEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (@event == null) return;
                if (@event is RecipeBomEvent recipe)
                {
                    recipeBoms = recipe.recipeBoms;
                    WriteRecipeBoms();
                }
            });
        }

        private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)
        {
            EventBus.EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { Status = oRDER_STATUS, SubOrderId = subid });
        }

        /// <summary>
        /// 写入配方数据到 PLC
        /// </summary>
        private void WriteRecipeBoms()
        {
            //List<ushort> recipeBoms = new List<ushort>();
            //if (this.recipeBoms == null) return;
            //foreach (var item in this.recipeBoms.RecipeIds)
            //{
            //    foreach (var rec in item.Recipes)
            //    {
            //        recipeBoms.Add((ushort)rec);
            //    }
            //}
            //if (recipeBoms.Count > 0)
            //{
            //    //配方数据地址范围：VW2000 - VW2278
            //    WriteData("VW2000", recipeBoms.ToArray());
            //}
            //else { MessageLog.GetInstance.Show("配方数据为空"); }
        }

        /// <summary>
        /// 数据解析
        /// </summary>
        private void DataParse()
        {
            EventBus.EventBus.GetInstance().Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {
                if (@event == null) return;
                if (@event is DoOrderEvent order)
                {
                    if (order.MorkOrder.GoodBatchings == null) return;
                    OrderCount++;
                    MessageLog.GetInstance.Show($"接收到{OrderCount}次订单");
                    foreach (var item in order.MorkOrder.GoodBatchings)
                    {
                        var res = orderMaterialDelivery?.BatchingInfo?.FirstOrDefault(p => p.BatchingId == item.BatchingId);
                        if (res != null)
                        {
                            if (ushort.TryParse(res.BatchingLoc, out ushort loc))
                            {
                                //if (morkF.TakeMaterialQueue.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                //将一个商品的ABC料位置存入队列
                                morkF.TakeMaterialQueue.Enqueue(new OrderLocInfo() { SuborderId = order.MorkOrder.SuborderId, BatchingId = res.BatchingId, MaterialLoc = ushort.Parse(res.BatchingLoc) });
                            }



                            //int index = 0;
                            //if (recipeBoms != null)
                            //{
                            //    index = Array.FindIndex(recipeBoms.RecipeIds?.ToArray(), p => p.RecipeId == order.MorkOrder.RecipeId);
                            //    index++;
                            //}
                            if (morkF.TakePlateQueue.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                morkF.TakePlateQueue.Enqueue(new OrderLocInfo()
                                {
                                    SuborderId = order.MorkOrder.SuborderId,
                                    BatchingId = res.BatchingId
                                    //RecipeNumber = (index >= 1 && index <= 10) ? (ushort)index : (ushort)0
                                });


                        }
                    }

                }
            });
        }



        //}
        /// <summary>
        /// 主任务
        /// </summary>
        public override void MainTask()
        {
            TakePlatelTask();
            TurntableControl();
            ProcessExecute();
            SingleProcess();
        }
        //机器人，锅灶流程执行
        public void ProcessExecute()
        {
            if (!morkF.ProcessExcuteLock)
            {
                morkF.ProcessExcuteLock = true;
                Task.Run(new Action(() =>
                {
                    if (!morkF.RoobotIdle && morkF.InitialComplete && morkF.TakeMaterialQueue.Count > 0 && morkF.TakePlateQueue.Count > 0)
                    {
                        foreach (var res in stirFryBom.StirFryActions)//遍历所有流程
                        {
                            MessageLog.GetInstance.Show($"执行流程{res.Time}");
                            //机器人线程
                            Task taskRobot = Task.Run(new Action(() =>
                            {
                                foreach (var temp in res.RobotActions)
                                {
                                    switch (temp)
                                    {
                                        case StirFryRobotAction.清洗槽取锅:
                                            TakePotTask();//执行取锅操作
                                            break;
                                        case StirFryRobotAction.取A料:
                                            TakeBurdenATask();//执行取A料操作
                                            break;
                                        case StirFryRobotAction.加入B料:
                                            TakeBurdenBTask();//执行取B料操作
                                            break;
                                        case StirFryRobotAction.加入C料:
                                            TakeBurdenCTask();//执行取C料操作
                                            break;
                                        case StirFryRobotAction.灶取锅:
                                            OutDishTask();//执行出餐操作
                                            CleanPotTask();//洗锅操作
                                            break;
                                    }
                                    // Task.Delay(2000).Wait();//单一操作延时
                                }

                            }));
                            //炒锅线程操作
                            Task taskPot = Task.Run(new Action(() =>
                            {
                                foreach (var temp in res.PotActions)
                                {
                                    switch (temp)
                                    {
                                        case StirFryPotAction.NONE:
                                            break;
                                        case StirFryPotAction.大火t1s:
                                            KitchenAdjustGears(3);
                                            Task.Delay(1000).Wait(); //大火加热1s//执行大火锅干操作
                                            break;
                                        case StirFryPotAction.加油:
                                            AddOil();//注油//执行加油操作
                                            break;
                                        case StirFryPotAction.中火t2s:
                                            KitchenAdjustGears(2);
                                            Task.Delay(2000).Wait();//执行操作
                                            break;
                                        case StirFryPotAction.小火持续:
                                            KitchenAdjustGears(1);
                                            break;
                                        case StirFryPotAction.大火持续:
                                            KitchenAdjustGears(3);
                                            break;
                                        case StirFryPotAction.停止火力:
                                            KitchenAdjustGears(0);//关闭灶加热
                                            break;
                                        case StirFryPotAction.搅拌臂上位:
                                            TurnUpStatusDetect();//执行搅拌臂上位操作
                                            break;
                                        case StirFryPotAction.搅拌臂下位:
                                            TurnDownStatusDetect();//执行搅拌臂下位操作
                                            break;
                                        case StirFryPotAction.低速旋转:
                                            TurnMachineGearsControl(1);//执行搅拌臂速度1挡操作
                                            break;
                                        case StirFryPotAction.快速旋转:
                                            TurnMachineGearsControl(3);//执行搅拌臂速度3挡操作
                                            break;
                                        case StirFryPotAction.停止旋转:
                                            TurnMachineGearsControl(0);//执行搅拌臂速度0挡操作
                                            break;
                                    }
                                    //  Task.Delay(2000).Wait();//单一操作延时
                                }
                            }));
                            Task.WhenAll(taskRobot, taskPot);//等待所有线程结束
                            Task.Delay(res.During).Wait();//当前流程延迟
                        }
                    }
                    else
                    {
                        morkF.ProcessExcuteLock = false;//解除流程互锁
                    }
                }));
            }

        }
        /// <summary>
        /// 信号处理
        /// </summary>
        private void SingleProcess()
        {


            //出餐完成，相应变量复位
            if (morkF.OutMealComplete)
            {
                morkF.TakePlateLock = false;
                morkF.TakePotLock = false;
                morkF.PotInPlace = false;
                morkF.ProcessExcuteLock = false;
            }

        }

        /// <summary>
        /// 转台控制
        /// </summary>
        private void TurntableControl()
        {
            //正常轮询
            if (morkF.TakeMaterialQueue.Count > 0 && !morkF.TurnTableLock)
            {
                var result = orderMaterialDelivery.BatchingInfo.Where(p => p.BatchingId == morkF.TakeMaterialQueue.ElementAt(0).BatchingId).ToList();
                if (result != null)
                {
                    if (ushort.TryParse(result[0].BatchingLoc, out ushort loc))
                    {
                        TurnMaterialStore(loc);
                        MessageLog.GetInstance.Show($"转台转到【{loc}】位置");
                        morkF.TurnTableLock = true;  //取料完成后置false
                    }
                }
                else MessageLog.GetInstance.Show("未找到可用的物料信息");
            }
        }


        /// <summary>
        /// 供盘
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void TakePlatelTask()
        {
            if (!morkF.RoobotIdle && morkF.InitialComplete && morkF.TakePlateQueue.Count > 0 && !morkF.ProvidePlateModule && !morkF.TakePlateLock)
            {

                if (morkF.TakePlateQueue.TryDequeue(out OrderLocInfo order))
                {
                    StartTakePlate();
                    morkF.CurrentOrderId = order.SuborderId;
                    morkF.TakePlateLock = true; //订单完成后置false
                    morkF.OutMealComplete = false;
                    OrderChange(morkF.CurrentOrderId, ORDER_STATUS.COOKING);
                    MessageLog.GetInstance.Show($"订单【{ morkF.CurrentOrderId}】执行取碗控制");
                }


            }
            else
            {
                MessageLog.GetInstance.ShowEx($"订单【{ morkF.CurrentOrderId}】取碗失败");
            }

        }

        /// <summary>
        /// 取锅到灶台
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private async void TakePotTask()
        {

            if (morkF.TakePlateQueue.Count > 0)
            {
                while (!(!morkF.CleanModule && morkF.CleanComplete && !morkF.KitchenOneStatus))//等待清洗1准备就绪
                {
                    Task.Delay(5).Wait();
                }
                while (morkF.RoobotIdle)//等待机器人空闲
                {
                    Task.Delay(5).Wait();
                }
                TakePotToKitchen();
                // morkF.TakePotLock = true; //订单完成后置false
                EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M1.5", Value = false });//清洗模组1完成复位
                MessageLog.GetInstance.Show($"订单【{ morkF.CurrentOrderId}】执行取锅到灶台控制");
                while (!morkF.PutPotToKitchenComlete)
                {
                    Task.Delay(5).Wait();
                }
                morkF.PotInPlace = morkF.PutPotToKitchenComlete;//锅到位

            }

        }
        /// <summary>
        /// 取素菜A料
        /// </summary>
        private void TakeBurdenATask()
        {
            if (morkF.TakeMaterialQueue.Count > 0)
            {
                TurnUpStatusDetect();
                //while (!morkF.TurnMachineUpComplete)//等待翻转机上升完成以及取料完成
                //{
                //    Task.Delay(5).Wait();
                //}
                //EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });//翻转机上升完成复位
                //MessageLog.GetInstance.Show($"翻转机上升执行完成");
                while (morkF.RoobotIdle || !morkF.PotInPlace)//等待机器人空闲以及锅到位
                {
                    Task.Delay(5).Wait();
                }
                if (morkF.TakeMaterialQueue.TryDequeue(out OrderLocInfo order))
                {
                    int loc = order.MaterialLoc;
                    TakeBurden(loc);
                    //morkF.TakeVegALock = true;//订单完成置false
                    // morkF.AllowTakeMaterial = false;

                    MessageLog.GetInstance.Show($"订单【{ order.SuborderId}，执行取A料");
                }
                //等待取料完成
                while (!morkF.TakeMaterialComplete)
                {
                    Task.Delay(5).Wait();
                }
                //转台互锁解除
                if (morkF.TurnTableLock)
                {
                    morkF.TurnTableLock = false;
                }
            }
        }
        ///// <summary>
        ///// 取荤菜A料
        ///// </summary>
        //private void TakeBurdenATask()
        //{
        //    if (!morkF.RoobotIdle && morkF.PotInPlace && morkF.TurnMachineUpComplete && morkF.TakeVegALock && !morkF.TakeMeatALock && morkF.AllowTakeMaterial&& morkF.TakeMaterialQueue.Count > 0)
        //    {
        //        if (morkF.TakeMaterialQueue.TryDequeue(out OrderLocInfo order))
        //        {
        //            int loc = 0;
        //            TakeBurden(loc);
        //            morkF.TakeMeatALock = true;//订单完成置false
        //            morkF.AllowTakeMaterial = false;
        //            MessageLog.GetInstance.Show($"订单【{ order.SuborderId}】,,翻转机上升完成,执行取荤菜A控制");
        //        }
        //    }
        //}
        /// <summary>
        /// 取素菜B料
        /// </summary>
        private void TakeBurdenBTask()
        {
            if (morkF.TakeMaterialQueue.Count > 0)
            {
                TurnUpStatusDetect();
                //while (!morkF.TurnMachineUpComplete)//等待翻转机上升完成以及取料完成
                //{
                //    Task.Delay(5).Wait();
                //}
                //EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });//翻转机上升完成复位
                //MessageLog.GetInstance.Show($"翻转机上升执行完成");
                while (morkF.RoobotIdle || !morkF.PotInPlace)//等待机器人空闲以及锅到位
                {
                    Task.Delay(5).Wait();
                }
                if (morkF.TakeMaterialQueue.TryDequeue(out OrderLocInfo order))
                {
                    int loc = order.MaterialLoc;
                    TakeBurden(loc);
                    //morkF.TakeVegBLock = true;//订单完成置false
                    //morkF.AllowTakeMaterial = false;
                    MessageLog.GetInstance.Show($"订单【{ order.SuborderId}】,,翻转机上升完成,执行取素菜B控制");
                }
                //等待取料完成
                while (!morkF.TakeMaterialComplete)
                {
                    Task.Delay(5).Wait();
                }
                //转台互锁解除
                if (morkF.TurnTableLock)
                {
                    morkF.TurnTableLock = false;
                }
            }
        }
        /// <summary>
        /// 取调味品C料
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void TakeBurdenCTask()
        {
            if (morkF.TakeMaterialQueue.Count > 0)
            {
                TurnUpStatusDetect();
                //while (!morkF.TurnMachineUpComplete)//等待翻转机上升完成以及取料完成
                //{
                //    Task.Delay(5).Wait();
                //}
                //EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });//翻转机上升完成复位
                //MessageLog.GetInstance.Show($"翻转机上升执行完成");
                while (morkF.RoobotIdle || !morkF.PotInPlace)//等待机器人空闲以及锅到位
                {
                    Task.Delay(5).Wait();
                }
                if (morkF.TakeMaterialQueue.TryDequeue(out OrderLocInfo order))
                {
                    int loc = order.MaterialLoc;
                    TakeBurden(loc);
                    //morkF.TakeBurdenCLcok = true;//订单完成置false
                    //morkF.AllowTakeMaterial = false;
                    //morkF.TakeAllBurdenComplete = false;
                    MessageLog.GetInstance.Show($"订单【{ order.SuborderId}】,,翻转机上升完成,执行取调味品C料控制");
                }
                //等待取料完成
                while (!morkF.TakeMaterialComplete)
                {
                    Task.Delay(5).Wait();
                }
                //转台互锁解除
                if (morkF.TurnTableLock)
                {
                    morkF.TurnTableLock = false;
                }
            }
        }
        /// <summary>
        /// 开始烹饪
        /// </summary>
        /// <exception cref="NotImplementedException"></exception>
        private void StartCookingTask()
        {
            if (morkF.InitialComplete && morkF.TakeMaterialQueue.Count > 0 && morkF.PutPotToKitchenComlete && !morkF.CookingLock)
            {
                MessageLog.GetInstance.Show($"订单【{morkF.CurrentOrderId}】开始烹饪");
                morkF.CookingLock = true;
                morkF.PotInPlace = morkF.PutPotToKitchenComlete;//锅到位
                Task.Run(new Action(() =>
                {
                    KitchenAdjustGears(3);
                    Task.Delay(1000).Wait(); //大火加热1s
                    AddOil();//注油
                    KitchenAdjustGears(2);
                    Task.Delay(2000).Wait(); //中火2s
                    TurnDownStatusDetect();//翻转机下降及检测
                    KitchenAdjustGears(1);//灶台1挡
                    TurnMachineGearsControl(1);//翻炒机1挡
                    Task.Delay(2000).Wait();
                    TurnMachineGearsControl(0);//关闭翻炒机
                    TurnUpStatusDetect();//翻转机上升及检测
                    TurnDownStatusDetect();//翻转机下降及检测
                    KitchenAdjustGears(3);//灶台3挡
                    TurnMachineGearsControl(3);//翻炒机3挡
                    Task.Delay(2000).Wait();//葱姜蒜断生
                    KitchenAdjustGears(1);//灶台1挡
                    TurnMachineGearsControl(0);//关闭翻炒机
                    TurnUpStatusDetect();//翻转机上升及检测
                    TurnDownStatusDetect();//翻转机下降及检测
                    KitchenAdjustGears(3);//灶台3挡
                    TurnMachineGearsControl(3);//翻炒机3挡
                    Task.Delay(2000).Wait();//B料断生
                    KitchenAdjustGears(1);//灶台1挡
                    TurnMachineGearsControl(0);//关闭翻炒机
                    TurnUpStatusDetect();//翻转机上升及检测
                    TurnDownStatusDetect();//翻转机下降及检测
                    KitchenAdjustGears(2);//灶台3挡
                    TurnMachineGearsControl(3);//翻炒机3挡
                    Task.Delay(2000).Wait();//煸炒入味
                    KitchenAdjustGears(0);//灶台0挡
                    TurnMachineGearsControl(0);//关闭翻炒机
                    TurnMachineOrientControl("Top");//翻转机上升
                    while (!morkF.TurnMachineUpComplete)
                    {
                        Task.Delay(5).Wait();
                    }
                    EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });
                    morkF.CookingComplete = true; //烹饪完成
                    MessageLog.GetInstance.Show($"订单【{morkF.CurrentOrderId}】烹饪完成");
                }));
            }
        }

        /// <summary>
        /// 出餐
        /// </summary>
        private void OutDishTask()
        {
            TurnUpStatusDetect();
            //while (!morkF.TurnMachineUpComplete)//等待翻转机上升完成以及取料完成
            //{
            //    Task.Delay(5).Wait();
            //}
            //EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });//翻转机上升完成复位
            //MessageLog.GetInstance.Show($"翻转机上升执行完成");
            while (morkF.RoobotIdle || morkF.CleanModule || !morkF.ProvidePlateComplete)//等待条件满足
            {
                Task.Delay(5).Wait();
            }
            RobotOutMeal();
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M1.2", Value = false });//供盘复位
            MessageLog.GetInstance.Show($"订单【{morkF.CurrentOrderId}】正在出餐");

        }

        /// <summary>
        /// 洗锅放锅
        /// </summary>
        private void CleanPotTask()
        {

            while (!morkF.PlaceRinseTableComplete || morkF.CleanModule)
            {
                Task.Delay(5).Wait();
            }
            OrderChange(morkF.CurrentOrderId, ORDER_STATUS.COMPLETED_COOK);
            MessageLog.GetInstance.Show($"订单【{morkF.CurrentOrderId}】出餐完成");
            CleanModuleControl("Start");
            morkF.OutMealComplete = true;
            Task.Delay(5000).Wait();
            CleanModuleControl("Stop");


        }
        /// <summary>
        /// 任务复位重启
        /// </summary>
        //private void ResetProgram()
        //{
        //    ThreadManage.GetInstance().StartLong(new Action(() =>
        //    {
        //        if (RTrig.GetInstance("ResetProgram").Start(morkF.DevicDataInite))
        //        {
        //            ThreadManage.GetInstance().StopTask("MainTask", new Action(() =>
        //            {
        //                ThreadManage.GetInstance().StopTask("ReadPLCData", new Action(() =>
        //                {
        //                    morkF = null;
        //                    morkF = new GVL_MorkF();
        //                    ActionManage.GetInstance.Send("ResetProgram");
        //                    ActionManage.GetInstance.Send("ClearOrders");
        //                    ReadData();
        //                    Main();
        //                }));
        //            }));
        //        }

        //        Thread.Sleep(10);
        //    }), "ResetProgram");
        //}
        /// <summary>
        /// 翻转机下降及状态检测
        /// </summary>
        public void TurnDownStatusDetect()
        {
            //if (ProcessError)
            //{
            //    return;
            //}
            if (morkF.PotInPlace)
            {
                //等待取料完成
                while (!morkF.TakeMaterialComplete)
                {
                    Task.Delay(5).Wait();
                }
                TurnMachineOrientControl("Down");

                while (!morkF.TurnMachineDownComplete)//等待翻转机下降完成
                {
                    Task.Delay(5).Wait();
                }
                EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.3", Value = false });//复位


                MessageLog.GetInstance.Show($"翻转机下降完成");
            }

        }
        /// <summary>
        /// 翻转机上升及状态检测
        /// </summary>
        public void TurnUpStatusDetect()
        {
            //if (ProcessError)
            //{
            //    return;
            //}
            if (morkF.PotInPlace)
            {
                TurnMachineOrientControl("Top");//翻转机上升
                while (!morkF.TurnMachineUpComplete || !morkF.TakeMaterialComplete)//等待翻转机上升完成以及取料完成
                {
                    Task.Delay(5).Wait();
                }
                EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.1", Value = false });
                MessageLog.GetInstance.Show("翻转机上升完成");
            }
        }
        private void GetStatus(string key, Action<bool[]> action)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                action((bool[])peripheralStatus[key]);//获取PLC指定地址的状态值
            }
        }
        /// <summary>
        /// 写数据
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        private void WriteData(string address, object value)
        {
            EventBus.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });
        }
        /// <summary>
        /// 灶台档位调节
        /// </summary>
        public void KitchenAdjustGears(int number)
        {
            //if (ProcessError)
            //{
            //    return;
            //}
            if (morkF.PotInPlace)
            {
                switch (number)
                {
                    case 0:
                        WriteData("352", new bool[] { false, false, false, false, false, false, false, false });//0000 0000
                        break;
                    case 1:
                        WriteData("352", new bool[] { true, false, false, false, false, false, false, false });//0000 0001
                        break;
                    case 2:
                        WriteData("352", new bool[] { false, true, false, false, false, false, false, false });//0000 0010
                        break;
                    case 3:
                        WriteData("352", new bool[] { true, true, false, false, false, false, false, false });//0000 0011
                        break;
                    case 4:
                        WriteData("352", new bool[] { false, false, true, false, false, false, false, false });//0000 0100
                        break;
                    case 5:
                        WriteData("352", new bool[] { true, false, true, false, false, false, false, false });//0000 0101
                        break;
                    case 6:
                        WriteData("352", new bool[] { false, true, true, false, false, false, false, false });//0000 0110
                        break;
                    case 7:
                        WriteData("352", new bool[] { true, true, true, false, false, false, false, false });//0000 0111
                        break;
                    case 8:
                        WriteData("355", new bool[] { false, false, false, true, false, false, false, false });//0000 1000
                        break;
                    case 9:
                        WriteData("352", new bool[] { true, false, false, true, false, false, false, false });//0000 1001
                        break;
                }
                MessageLog.GetInstance.Show($"订单【{morkF.CurrentOrderId}】,加热档位调至{number}挡");
            }
        }
        public void TurnMaterialStore(int loc)
        {
            switch (loc)
            {
                case 1:
                    WriteData("M13.0", true);
                    break;
                case 2:
                    WriteData("M13.1", true);
                    break;
                case 3:
                    WriteData("M13.2", true);
                    break;
                case 4:
                    WriteData("M13.3", true);
                    break;
                case 5:
                    WriteData("M13.4", true);
                    break;
            }

        }
        /// <summary>
        /// 供盘启动
        /// </summary>
        public void StartTakePlate()
        {
            WriteData("M1.1", true);
        }
        /// <summary>
        /// 取锅到灶台
        /// </summary>
        public void TakePotToKitchen()
        {
            WriteData("M14.0", true);
        }
        /// <summary>
        /// 机器人出餐并将锅放置清洗台位置
        /// </summary>
        public void RobotOutMeal()
        {
            WriteData("M14.2", true);
        }
        /// <summary>
        /// 注油
        /// </summary>
        public void AddOil()
        {
            //if (ProcessError)
            //{
            //    return;
            //}
            if (morkF.PotInPlace)
            {
                WriteData("M2.7", true);
                MessageLog.GetInstance.Show("开始注油");
                while (!morkF.FallOilComplete)
                {
                    Task.Delay(5).Wait();
                }
                MessageLog.GetInstance.Show("注油完成");
            }
        }
        /// <summary>
        /// 翻转机方向控制
        /// </summary>
        /// <param name="orientation"></param>
        public void TurnMachineOrientControl(string orientation)
        {
            switch (orientation)
            {
                case "Top": WriteData("M8.0", true); break;
                // case "Middle": WriteData("", 1); break;
                case "Down": WriteData("M8.2", true); break;
            }
            MessageLog.GetInstance.Show($"翻转机执行{orientation}操作");
        }
        /// <summary>
        /// 翻转机档位控制
        /// </summary>
        public void TurnMachineGearsControl(int gear)
        {
            //if (gear != 0)
            //{
            //    while (!morkF.TurnMachineDownComplete)//等待翻转机下降完成
            //    {
            //        Task.Delay(5).Wait();
            //    }
            //    EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.3", Value = false });//复位
            //    MessageLog.GetInstance.Show($"翻转机下降完成");
            //}
            //if (ProcessError)
            //{
            //    return;
            //}
            if (morkF.PotInPlace)
            {
                //while (!morkF.TurnMachineDownComplete)//等待翻转机下降完成
                //{
                //    Task.Delay(5).Wait();
                //}
                //EventBus.EventBus.GetInstance().Publish(new WriteModel() { Address = "M8.3", Value = false });//复位
                switch (gear)
                {
                    case 0: WriteData("M7.0", true); Task.Delay(1000).Wait(); break;//关闭翻炒机
                    case 1: WriteData("M7.1", true); break;//翻炒机1挡
                    case 2: WriteData("M7.2", true); break;//翻炒机2挡
                    case 3: WriteData("M7.3", true); break;//翻炒机3挡
                }

                MessageLog.GetInstance.Show($"翻转机档位调至{gear}挡");
            }
        }
        /// <summary>
        /// 取A,B,C料
        /// </summary>
        public void TakeBurden(int loc)
        {
            WriteData("M14.1", true);//机器人取料
        }
        /// <summary>
        /// 清洗模组1启停控制
        /// </summary>
        public void CleanModuleControl(string status)
        {
            if (status == "Start")
            {
                WriteData("M1.4", true);
            }
            if (status == "Stop")
            {
                WriteData("M1.4", false);
            }
            MessageLog.GetInstance.Show($"清洗模组执行【{status}】操作");
        }

        public override void Stop()
        {

        }
    }
}