BPASmartClient/BPASmartClient.MorkT_HQ/Control_MorkTHQ.cs

using BPA.Message;
using BPA.Message.Enum;
using BPASmartClient.Device;
using BPASmartClient.DRCoffee;
using BPASmartClient.EventBus;
using BPASmartClient.GSIceCream;
using BPASmartClient.Helper;
using BPASmartClient.Lebai;
using BPASmartClient.LebaiRobot;
using BPASmartClient.Message;
using BPASmartClient.Model;
using BPASmartClient.Model.乐白机器人;
using BPASmartClient.Model.冰淇淋.Enum;
using BPASmartClient.Model.单片机;
using BPASmartClient.Model.单片机.Enum;
using BPASmartClient.Peripheral;
using Robotc;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using static BPASmartClient.EventBus.EventBus;

namespace BPASmartClient.MorkTHQ
{
    public class Control_MorkTHQ : BaseDevice
    {
        public override global::BPA.Message.Enum.DeviceClientType DeviceType { get { return BPA.Message.Enum.DeviceClientType.MORKT; } }

        GLV_MorkTHQ morkT = new GLV_MorkTHQ();
        int[] devStatusBy = new int[2] { 0, 0 };

        public override void DoMain()
        {
            if(Json<KeepDataBase>.Data.IsVerify)
            {
                IsHealth = true;
            }
            IsHealth = true;
            ServerInit();
            DataParse();
            EventBus.EventBus.GetInstance().Subscribe<KLMCoffee_CoffeEndCookEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (morkT.MakeCoffeeOrder != null)
                    morkT.MakeCoffeeOrder.OrderStatus = 1;
            });
            int i = 0;
            EventBus.EventBus.GetInstance().Publish(new GSIceCream_ModeSetEvent { DeviceId = DeviceId, Mode = MORKI_MODE.制冷模式 });

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

        }

        public override void ResetProgram()
        {
            morkT = null;
            morkT = new GLV_MorkTHQ();
        }


        private void GetStatus(string key, Action<object> action)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    action?.Invoke(peripheralStatus[key]);
                }
            }
        }

        public override void MainTask()
        {
           //制作咖啡
            MakeCoffeeProcess();
            //制作果汁
            MakeJuiceProcess();
            //制作冰淇淋
            MakeIceCreamProcess();
            //制作完取咖啡
            MakeCoffeeComplete();
           


        }

        public override void ReadData()
        {
            GetStatus("RobotIsConnected", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.RobotIsConnected = b;
                }
            }));

            GetStatus("RobotMode", new Action<object>((o) =>
            {
                if (o is ELebaiRModel  eLebaiRModel)
                {
                    morkT.RobotMode = eLebaiRModel;
                }
            }));


            GetStatus("IceCreamIsConnected", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.IceCreamIsConnected = b;
                }
            }));

            GetStatus("IceCreamYLWD", new Action<object>((o) =>
            {
                if (o is short s)
                {
                    morkT.YLWD = s;
                }
            }));

            GetStatus("IceCreamHQWD", new Action<object>((o) =>
            {
                if (o is short s)
                {
                    morkT.HQWD = s;
                }
            }));

            GetStatus("IceCreamDL", new Action<object>((o) =>
            {
                if (o is short s)
                {
                    morkT.DL = s;
                }
            }));

            GetStatus("IceCreamDY", new Action<object>((o) =>
            {
                if (o is short s)
                {
                    morkT.DY = s;
                }
            }));

            GetStatus("IceCreamCXB", new Action<object>((o) =>
            {
                if (o is byte bt)
                {
                    morkT.CBX = bt;
                }
            }));

            GetStatus("IceCreamCurrentMode", new Action<object>((o) =>
            {
                if (o is MORKI_MODE mORKI_MODE)
                {
                    morkT.IceCreamMode = mORKI_MODE;
                }
            }));

            GetStatus("IceCreamFault", new Action<object>((o) =>
            {
                if (o is MORKI_FAULT mORKI_FAULT)
                {
                    morkT.IceCreamFault = mORKI_FAULT;
                }
            }));

            GetStatus("IceCreamDLCompleted", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.DLCompleted = b;
                }
            }));

            GetStatus("CoffeeIsConnected", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.CoffeeIsConnected = b;
                }
            }));

            GetStatus("CoffeeStatus", new Action<object>((o) =>
            {
                if (o is DrCoffeeStatus coffeeStatus)
                {
                    morkT.DrCoffeeStatus = coffeeStatus;
                }
            }));

            GetStatus("CoffeeAppStatus", new Action<object>((o) =>
            {
                if (o is DrCoffeeAppStatus appStatus)
                {
                    morkT.CoffeeAppStatus = appStatus;
                }
            }));

            GetStatus("CoffeeWarning", new Action<object>((o) =>
            {
                if (o is DrCoffeeWarning coffeeWarning)
                {
                    morkT.CoffeeWarning = coffeeWarning;
                }
            }));
            GetStatus("CoffeeFault", new Action<object>((o) =>
            {
                if (o is DrCoffeeFault coffeeFault)
                {
                    morkT.CaffeeFault = coffeeFault;
                }
            }));
            GetStatus("Coffeeprogress", new Action<object>((o) =>
            {
                if (o is int coffeeFault)
                {
                    morkT.Coffeeprogress = coffeeFault;
                }
            }));

            GetStatus("SCChipIsConnect", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.SCChipIsConnect = b;
                }
            }));
            GetStatus("JuiceIsConnect", new Action<object>((o) =>
            {
                if (o is bool b)
                {
                    morkT.JuiceIsConnect = b;
                }
            }));
        }



        public override void Stop()
        {
        }


        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;
                }
            });
        }

        /// <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++;
                    DeviceProcessLogShow($"接收到{OrderCount}次订单");
                    //构建所有商品物料信息
                    morkT.batchings = PolymerBatching.BuildAll();
                    //商品类型
                    GOODS_TYPE currentGoodsType = GOODS_TYPE.NEITHER;
                    
                    foreach (var item in order.MorkOrder.GoodBatchings)
                    {
                        var res = orderMaterialDelivery?.BatchingInfo?.FirstOrDefault(p => p.BatchingId == item.BatchingId);
                        if (res != null)
                        {
                            //验证商品是咖啡还是冰淇淋
                            if (ValidateGoodsByBatching(res.BatchingLoc) != GOODS_TYPE.NEITHER)
                            {
                                //获取当前物料所属商品类型
                                currentGoodsType = ValidateGoodsByBatching(res.BatchingLoc);
                            }
                            string loc_Goods = string.Empty;
                            //获取主料和容器位置
                            if (morkT.batchings[res.BatchingLoc].BatchingClass == BATCHING_CLASS.MAIN_MATERIAL) loc_Goods = res.BatchingLoc;
                            if (!string.IsNullOrEmpty(loc_Goods))
                            {
                                switch (currentGoodsType)
                                {
                                    case GOODS_TYPE.COFFEE:
                                        if (morkT.morkOrderPushesCoffee.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                        {
                                            morkT.morkOrderPushesCoffee.Enqueue(new OrderLocInfo()
                                            {
                                                SuborderId = order.MorkOrder.SuborderId,
                                                BatchingId = res.BatchingId,
                                                Loc = loc_Goods,
                                                GoodsName = order.MorkOrder.GoodsName,
                                                SortNum = order.MorkOrder.SortNum
                                            });
                                        }
                                        break;
                                    case GOODS_TYPE.ICECREAM:
                                        if (morkT.morkOrderPushesIceCream.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)
                                        {
                                            morkT.morkOrderPushesIceCream.Enqueue(new OrderLocInfo()
                                            {
                                                SuborderId = order.MorkOrder.SuborderId,
                                                BatchingId = res.BatchingId,
                                                Loc = loc_Goods,
                                                GoodsName = order.MorkOrder.GoodsName,
                                                SortNum = order.MorkOrder.SortNum
                                            });
                                        }
                                        break;
                                    case GOODS_TYPE.JUICE:
                                        if(morkT.morkOrderPushesIceCream.FirstOrDefault(p=>p.SuborderId == order?.MorkOrder.SuborderId) == null)
                                        {
                                            morkT.GuMake = order.MorkOrder.MakeID == "2";
                                            morkT.morkOrderPushesJuice.Enqueue(new OrderLocInfo()
                                            {
                                                SuborderId = order.MorkOrder.SuborderId,
                                                BatchingId = res.BatchingId,
                                                Loc = loc_Goods,
                                                GoodsName = order.MorkOrder.GoodsName,
                                                SortNum = order.MorkOrder.SortNum
                                            });
                                        }
                                        break;
                                    case GOODS_TYPE.NEITHER:
                                        DeviceProcessLogShow("未知的商品类型");
                                        break;
                                }
                            }
                           
                        }
                    }
                }
            });
        }
        /// <summary>
        /// 验证当前是做咖啡还是做冰淇淋
        /// </summary>
        /// <param name="batchingLoc">物料位置</param>
        private GOODS_TYPE ValidateGoodsByBatching(string batchingLoc)
        {
            if (morkT.batchings.ContainsKey(batchingLoc))
                return morkT.batchings[batchingLoc].GoodsType;
            return GOODS_TYPE.NEITHER;
        }
      

       

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

        private void Wait(int value = 101)
        {
            while (!((bool)peripheralStatus["RobotOK"] && (int)peripheralStatus["RobotValue"] == value))
            {
                Thread.Sleep(5);
            }
        }

        #region 咖啡
        /// <summary>
        /// 是否可以开始制作咖啡
        /// </summary>
        /// <returns></returns>
        private bool CoffeeCanMake()
        {
            bool canMake = (IsHealth && morkT.morkOrderPushesCoffee.Count > 0 && !morkT.IsCoffeeMake) ? true : false;
            return canMake;

        }

        /// <summary>
        /// 制作咖啡流程
        /// </summary>
        private void MakeCoffeeProcess()
        {
            if (CoffeeCanMake())
            {
                if (morkT.morkOrderPushesCoffee.TryDequeue(out OrderLocInfo orderLoc))
                {
                    DeviceProcessLogShow($"开始制作 [咖啡] 订单[{orderLoc.SortNum}]");
                    GetAndCheeckCoffe(orderLoc);//取咖啡杯
                    if (!morkT.GetCoffeeCup) return;
                    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10051}); //接咖啡后回原点
                    Wait();
                    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
                    EventBus.EventBus.GetInstance().Publish(new KLMCoffee_MakeCoffeeEvent() {DeviceId = DeviceId, DrinkCode = (Model.咖啡机.Enum.DrinkType)int.Parse(orderLoc.Loc) });//接咖啡控制
                    DeviceProcessLogShow($"发送咖啡机制作{orderLoc.Loc}!");
                    morkT.IsCoffeeMake = true; morkT.MakeCoffeeOrder = orderLoc;
                }

            }
            


        }
        /// <summary>
        /// 咖啡机制作完咖啡，取走并放到取餐口，最后回原点
        /// </summary>
        private void MakeCoffeeComplete()
        {
            if (morkT.IsCoffeeMake && IsHealth)
            {
                if (morkT.MakeCoffeeOrder != null && morkT.MakeCoffeeOrder.OrderStatus == 1)
                {
                    DeviceProcessLogShow($"将咖啡移动到取餐位 [咖啡] 订单[{morkT.MakeCoffeeOrder.SortNum}]");
                    DoCoffeeQC(morkT.MakeCoffeeOrder);
                    morkT.MakeCoffeeOrder = null;
                    morkT.IsCoffeeMake = false;
                }
            }
        }


        /// <summary>
        /// 将咖啡杯从咖啡机 取走到 取餐口
        /// </summary>
        private void DoCoffeeQC(OrderLocInfo order)
        {
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10052 }); //SENCE_取咖啡出餐
            Wait();
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
            //订单状态改变：完成
            OrderChange(order.SuborderId, ORDER_STATUS.COMPLETED_COOK);
            morkT.waitMorkOrder = order;
            DeviceProcessLogShow($"{order.GoodsName}等待取餐");
            //WaitTakeMealOrder.Enqueue(order);

        }

        /// <summary>
        /// 取咖啡杯&&咖啡杯检测 若检测失败机器人回原点
        /// </summary>
        /// <param name="order"></param>
        private void GetAndCheeckCoffe(OrderLocInfo order)
        {
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 },(o)=>{ });
            OrderChange(order.SuborderId, ORDER_STATUS.COOKING);
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10031 }); //SENCE_取咖啡杯
            Wait();
            Thread.Sleep(500);
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
         
            morkT.GetCoffeeCup = true;
            DeviceProcessLogShow("取咖啡杯完成");
        }
        #endregion

        #region 冰淇淋
        /// <summary>
        /// 冰淇淋是否可以开始制作
        /// </summary>
        /// <returns></returns>
        private bool IceCreamCanMake()
        {
            bool canMake = (IsHealth && morkT.morkOrderPushesIceCream.Count > 0) ? true : false;
            return canMake;
        }

        /// <summary>
        /// 制作冰淇淋流程
        /// </summary>
        private void MakeIceCreamProcess()
        {
            if (IceCreamCanMake())
            {
                if (peripheralStatus.ContainsKey("IceCreamCurrentMode"))
                {
                    if ((MORKI_MODE)peripheralStatus["IceCreamCurrentMode"] != MORKI_MODE.制冷模式) EventBus.EventBus.GetInstance().Publish(new GSIceCream_ModeSetEvent { DeviceId = DeviceId, Mode = MORKI_MODE.制冷模式 });
                }

                if (peripheralStatus.ContainsKey("IceCreamCXB"))
                {
                    if ((byte)peripheralStatus["IceCreamCXB"] >= 86 && morkT.morkOrderPushesIceCream.Count > 0)//成型比大于86才可以制作
                    {
                        bool result = true;
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_GetInputEvent { DeviceId = DeviceId, Pin = 3 }, (res) =>
                        {
                            if (res[0] is bool resultValue)
                            {
                                result = resultValue;
                            }
                        });
                        if (result)
                        {
                            if (morkT.IceIsOK) DeviceProcessLogShow("请检查冰淇淋出料口有无遮挡");
                            morkT.IceIsOK = false;
                        }
                        else if (morkT.morkOrderPushesIceCream.TryDequeue(out OrderLocInfo order))
                        {
                            morkT.IceIsOK = true;
                            DeviceProcessLogShow($"开始制作 [冰淇淋] 订单[{order.SortNum}]");
                            DoIceCream(order);
                        }
                    }
                }

            }
        }


        /// <summary>
        /// 做冰淇淋
        /// </summary>
        private void DoIceCream(OrderLocInfo order)
        {
            GetIceCreamCup();
            //CheckICeCreaCup();
            GetIceCream(order);
            PutIceCream(order);
           
        }

        /// <summary>
        /// 取冰淇淋杯
        /// </summary>
        private void GetIceCreamCup()
        {
            MessageLog.GetInstance.Show("准备开始制作冰淇淋");
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }, (o) => { });
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10032 }); //SENCE_取冰淇淋杯
            Wait();
            Thread.Sleep(500);
            DeviceProcessLogShow("尝试取冰淇淋杯!");

        }

        /// <summary>
        /// 冰淇淋杯检测，失败后机器人回到原点
        /// </summary>
        private void CheckICeCreaCup()
        {
            int count = 2;
            bool result = true;
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
        p:
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10034 }); //SENCE_冰淇淋杯检测
            Wait();
            Thread.Sleep(500);
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => 
            {
                if (o != null && o.Length > 0 && o[0] is SignalResult res)
                {
                    MessageLog.GetInstance.Show(res.ToString());
                }
            });
            while((int)peripheralStatus["RobotValue"] != 0)
            {
                Thread.Sleep(10);
            }
            MessageLog.GetInstance.Show($"乐白机器人信号值{peripheralStatus["RobotValue"].ToString()}");
            
            //while ((ELebaiRModel)peripheralStatus["RobotMode"] !=ELebaiRModel.空闲状态)
            //{
            //    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 });
            //    Thread.Sleep(500);
            //}

            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_GetTCPInputEvent { DeviceId = DeviceId, Pin = 1 }, (o) =>
            {
                if (o != null && o.Length > 0 && o[0] is bool resultValue)
                {
                    result = resultValue;
                }
            });
            if (!result)
            {
                if (count >= 3)
                {
                    //退出循环回到初始位置
                    DeviceProcessLogShow($"执行{count}次取冰淇淋杯,仍未成功,订单默认废弃,机器人回到初始位置!");
                    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10049 }); //SENCE_冰淇淋杯回原点
                    Wait();
                    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 },(o) => { });
                    morkT.GetIceCreamCup = false;
                    return;
                }
                DeviceProcessLogShow($"执行{count}次取冰淇淋杯!");
                EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10036 }); //SENCE_二次取冰淇淋杯
                EventBus.EventBus.GetInstance().Equals(new SCChip_TakeCupEvent { DeviceId = DeviceId, Cup = IC_CUP.CUP_ICECREAM });//落碗控制
                Wait();
                EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
                count++;
                goto p;
            }
            morkT.GetIceCreamCup = true;
            DeviceProcessLogShow("冰淇淋杯检测完成");
        }

        /// <summary>
        /// 机器人取接冰淇淋
        /// </summary>
        /// <param name="order"></param>
        private void GetIceCream(OrderLocInfo order)
        {
            //制冷模式
            //EventBus.EventBus.GetInstance().Publish(new GSIceCream_ModeSetEvent {DeviceId = DeviceId, Mode = MORKI_MODE.制冷模式 });
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }, (o) => { });
            OrderChange(order.SuborderId, ORDER_STATUS.COOKING);
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10055 }); //SENCE_接1号冰淇淋
            Wait();
            bool doItResult = true;

            ////出料
            //EventBus.EventBus.GetInstance().Publish(new SCChip_RotorSwitchEvent { DeviceId = DeviceId, TurnOn = true });
            //Thread.Sleep(500);
            //EventBus.EventBus.GetInstance().Publish(new SCChip_RotorSwitchEvent { DeviceId = DeviceId, TurnOn = false });
            //Thread.Sleep(500);
            //EventBus.EventBus.GetInstance().Publish(new SCChip_MakeIceCreamEvent { DeviceId = DeviceId, SteeringEngine = IC_SE.SE_2 });//冰淇淋出料
            //DeviceProcessLogShow("开始等待6s");
            //Thread.Sleep(5000);

           // 出料
            EventBus.EventBus.GetInstance().Publish(new GSIceCream_DischargeEvent { DeviceId = DeviceId }, (o) =>
             {
                 doItResult = (bool)o[0];
             });
            if (doItResult)
            {
                IceCreamCookCheck();
            }
            else
            {
                int count_1 = 0;

                while ((byte)peripheralStatus["IceCreamCXB"] <= 86)
                {
                    Thread.Sleep(5);
                    count_1++;
                    if (count_1 >= 2000)
                        break;
                }
                IceCreamCookCheck();
            }
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
        }

        /// <summary>
        /// 把冰淇淋放到取餐位后回原点
        /// </summary>
        /// <param name="order"></param>
        private void PutIceCream(OrderLocInfo order)
        {
            bool resultValue = true;
            while (resultValue)
            {
                EventBus.EventBus.GetInstance().Publish(new LebaiRobot_GetInputEvent { DeviceId = DeviceId, Pin = 0 }, (res) =>
                {
                    if (res[0] is bool b)
                    {
                        resultValue = b;
                    }
                });
                Thread.Sleep(500);
            }
          
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 10056 }); //SENCE_放冰淇淋位置
            Wait();
            EventBus.EventBus.GetInstance().Publish(new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 1 }, (o) => { });
            //订单状态改变：完成
            OrderChange(order.SuborderId, ORDER_STATUS.COMPLETED_COOK);
            morkT.waitMorkOrder = order;
            DeviceProcessLogShow($"{order.GoodsName}等待取餐");
            //WaitTakeMealOrder.Enqueue(order);

        }

        /// <summary>
        /// 冰淇淋机器制作冰淇淋
        /// </summary>
        public void IceCreamCookCheck()
        {
            bool result = false;
            int retry = 3;
            DateTime beginTime = DateTime.Now;
           
            while (!result)
            {
                EventBus.EventBus.GetInstance().Publish(new LebaiRobot_GetInputEvent { DeviceId = DeviceId, Pin = 3 }, (res) =>
                {
                    if (res[0] is bool resultValue)
                    {
                        result = resultValue;
                    }
                });
                if (retry <= 0 || DateTime.Now.Subtract(beginTime).TotalSeconds >= 10)
                {
                    DeviceProcessLogShow("超时未出料，重试次数用尽");
                    break;
                }
                if (DateTime.Now.Subtract(beginTime).TotalSeconds > 5)
                {
                    DeviceProcessLogShow("超时未出料，重新发送打料指令");
                    EventBus.EventBus.GetInstance().Publish( new GSIceCream_ModeSetEvent() { DeviceId =DeviceId, Mode = MORKI_MODE.打料 });
                    beginTime = DateTime.Now;
                    retry--;
                }
                Thread.Sleep(10);
            }
            DeviceProcessLogShow("开始等待6s");
            Thread.Sleep(5000);

        }
        #endregion

        #region 果汁
        /// <summary>
        /// 制作果汁流程
        /// </summary>
        private void MakeJuiceProcess()
        {
            if(morkT.morkOrderPushesJuice.TryDequeue(out OrderLocInfo order))
            {
                OrderChange(order.SuborderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
                EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = 11111 });//SENCE_取果汁杯位置
                int JuicerNum1 = int.Parse(order.Loc);
                switch (JuicerNum1)
                {
                    case 52:
                        if (morkT.GuMake)
                        {
                            morkT.JuicerNum = 0x00;
                        }
                        else
                        {
                            morkT.JuicerNum = 0x01;
                        }
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接果汁公共位置 });
                        Wait();

                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接1号果汁位置 });
                        Wait();
                        break;
                    case 53:
                        if (morkT.GuMake)
                        {
                            morkT.JuicerNum = 0x02;
                        }
                        else
                        {
                            morkT.JuicerNum = 0x03;
                        }
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接果汁公共位置 });
                        Wait();

                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接2号果汁位置 });
                        Wait();
                        break;
                    case 54:
                        if (morkT.GuMake)
                        {
                            morkT.JuicerNum = 0x04;
                        }
                        else
                        {
                            morkT.JuicerNum = 0x05;
                        }
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接果汁公共位置 });
                        Wait();

                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接3号果汁位置 });
                        Wait();
                        break;
                    case 55:
                        if (morkT.GuMake)
                        {
                            morkT.JuicerNum = 0x06;
                        }
                        else
                        {
                            morkT.JuicerNum = 0x07;
                        }
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接果汁公共位置 });
                        Wait();

                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接4号果汁位置 });
                        Wait();
                        break;
                    default:
                        morkT.JuicerNum = 0x00;
                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接果汁公共位置 });
                        Wait();

                        EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_接1号果汁位置 });
                        Wait();
                        break;
                }
                var devStatus = GetDeviceStatus<int[]>("GetDeviceStatus");
                var devStatus1 = Convert.ToString(devStatus[0], 2);
                var devStatus2 = devStatus[1];

                if (devStatus1.IndexOf("0") == 1 && devStatus2 == 0)
                {
                    EventBus.EventBus.GetInstance().Publish(new WriteJuicer() { Value = morkT.JuicerNum });
                    Thread.Sleep(100);
                    devStatusBy = GetDeviceStatus<int[]>("GetDeviceStatus");
                    while (!(devStatusBy[1] == 0))
                    {
                        Thread.Sleep(100);
                        devStatusBy = GetDeviceStatus<int[]>("GetDeviceStatus");
                        while (devStatusBy.Length != 2)
                        {
                            Thread.Sleep(100);
                            devStatusBy = GetDeviceStatus<int[]>("GetDeviceStatus");
                        }
                    }
                    devStatusBy = GetDeviceStatus<int[]>("GetDeviceStatus");
                    Thread.Sleep(5000);
                    EventBus.EventBus.GetInstance().Publish(new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = Lebai_HQ.SENCE_放果汁杯位置后回原点 });
                    Wait();

                    OrderChange(order.SuborderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                    MessageLog.GetInstance.Show("果汁制作完成");
                }
            }
           

            
        }

        private T GetDeviceStatus<T>(string key)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    return (T)(peripheralStatus[key]);
                }
            }
            return default;
        }
        #endregion
        public override void SimOrder()
        {
            
        }
    }
}