BPASmartClient/BPASmartClient.MorkT.Lebai.JC/Control_MORKJC2.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Threading;
using System.Collections.Concurrent;
using System.Diagnostics;
using System.Threading.Tasks;
using BPASmartClient.Device;
using BPA.Message.Enum;
using BPA.Message;
using BPASmartClient.Helper;
using BPASmartClient.Model.咖啡机.Enum;
using BPASmartClient.Model;
using BPASmartClient.EventBus;
using static BPASmartClient.EventBus.EventBus;
using BPASmartClient.Message;
using BPASmartClient.Model.乐白机器人;
using BPASmartClient.Model.单片机;

namespace BPASmartClient.MorkTLebaiJC
{
    /*
     * 冰淇淋咖啡机组合套装
     * 物料位置：
     * 1：冰淇料
     * 2：冰淇淋杯
     * 5：咖啡
     * 6：咖啡杯
     * 9: 茶
     * 10: 茶杯
     */
    public class Control_MORKJC2 : BaseDevice
    {
        //private CoffeEndCook coffeEndCook = new CoffeEndCook();//模拟咖啡制作成功
        //咖啡机主控程序
        //private CoffeeMachine coffeeMachine;
        //物料存放位置
        private Dictionary<string, PolymerBatching> batchings = new Dictionary<string, PolymerBatching>();
        //容器位置
        private string holderLoc;
        /// <summary>
        /// 获取乐百机器人的数据
        /// </summary>
        //SignalResult lebai = new SignalResult();
        //主料位置
        private string mainMaterialLoc;
        //子订单ID
        private string subOrderId;

        private bool enableFunny = false;
        private DateTime lastRecvdOrder = DateTime.Now;
        private bool working = false;
        /// <summary>
        /// 果汁机做法，true:热饮，false:冷饮
        /// </summary>
        private bool GuMake = false;

        //private SerialPortClient commProxy;
        public void ConnectOk()
        {

        }
        ConcurrentQueue<MorkOrderPush> morkOrderPushes = new ConcurrentQueue<MorkOrderPush>();
        public void Init()
        {
            //ActionManage.GetInstance.Register(new Action<object>((s) =>
            //{
            //    if (s is DrCoffeeDrinksCode cf)
            //    {
            //        DoCoffee();
            //    }
            //    else if (s is Dictionary<string, string> ms)
            //    {
            //        if (ms.ContainsKey("Button"))
            //        {
            //            switch (ms["Button"])
            //            {
            //                case "启动示教":
            //                    JuicerModel.GetInstance.StartTeachMode();
            //                    break;
            //                case "停止示教":
            //                    JuicerModel.GetInstance.EndtTeachMode();
            //                    break;
            //                case "启动机器人":
            //                    JuicerModel.GetInstance.StartRobot();
            //                    break;
            //                case "急停":
            //                    JuicerModel.GetInstance.EStopRobot();
            //                    break;
            //                default:
            //                    break;
            //            }
            //        }
            //    }
            //}), "SimCoffee");

            //构建所有商品物料信息
            batchings = PolymerBatching.BuildAll();

            EventBus.EventBus.GetInstance().Subscribe<DRCoffee_CoffeEndCookEvent>(DeviceId, CoffeEndCookHandle);

            System.Configuration.Configuration config = System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None);
            //一系列外围基础配置
            var com_Coffee = config.AppSettings.Settings["COM_Coffee"].Value;
            var baud_Coffee = config.AppSettings.Settings["BAUD_Coffee"].Value;
            //咖啡机创建
            //coffeeMachine = new CoffeeMachine(com_Coffee, (BaudRates)Enum.Parse(typeof(BaudRates), baud_Coffee));

            Main();
            ReadData();
            ThreadManage.GetInstance().StartLong(new Action(() =>
            {
                while (IsHealth && (morkOrderPushes.Count > 0))
                {
                    working = true;
                    if (morkOrderPushes.TryDequeue(out MorkOrderPush order))
                    {
                        MessageLog.GetInstance.Show($"开始制作订单[{order.SortNum}]");
                        //商品类型
                        GOODS_TYPE currentGoodsType = GOODS_TYPE.NEITHER;
                        //子订单ID
                        subOrderId = order.SuborderId;
                        //遍历物料
                        foreach (var item in order.GoodBatchings)
                        {
                            var res = Json<BatchingInfoPar>.Data.orderMaterialDelivery.BatchingInfo.FirstOrDefault(p => p.BatchingId == item.BatchingId);
                            if (res != null)
                            {
                                //获取主料和容器位置
                                switch (batchings[res.BatchingLoc].BatchingClass)
                                {
                                    case BATCHING_CLASS.HOLDER:
                                        holderLoc = res.BatchingLoc;
                                        break;
                                    case BATCHING_CLASS.MAIN_MATERIAL:
                                        // mainMaterialLoc ="1";
                                        mainMaterialLoc = res.BatchingLoc;
                                        //验证商品是咖啡还是冰淇淋
                                        if (ValidateGoodsByBatching(res.BatchingLoc) != GOODS_TYPE.NEITHER)
                                        {
                                            //获取当前物料所属商品类型
                                            currentGoodsType = ValidateGoodsByBatching(res.BatchingLoc);
                                        }
                                        break;
                                }
                            }
                        }

                        //根据商品类型执行具体制作流程
                        switch (currentGoodsType)
                        {
                            case GOODS_TYPE.COFFEE:
                                DoCoffee();
                                break;
                            case GOODS_TYPE.JUICE:
                                GuMake = order.MakeID == "2";
                                DoJuicer();
                                break;
                            case GOODS_TYPE.TEA:
                                DoTea();
                                break;
                            case GOODS_TYPE.WATER:
                                DoWater();
                                break;
                            case GOODS_TYPE.NEITHER:
                                MessageLog.GetInstance.Show("未知的商品类型");
                                break;
                        }
                    }
                    working = false;
                    lastRecvdOrder = DateTime.Now;
                }
                Thread.Sleep(1000);
            }), "订单制作");
        }

        public void Main()
        {
            //咖啡机开启主线程
            //coffeeMachine.Start();
            //开始心跳刷新，根据咖啡机及冰淇淋机来判断
            ThreadManage.GetInstance().StartLong(new Action(() =>
            {
                //GeneralConfig.Healthy =
                //         JuicerModel.GetInstance.IsConnected &&
                //         MorkCStatus.GetInstance().CanDo &&
                //         JuicerHelper.GetInstance.IsOpen &&
                //         MCUSerialHelper.GetInstance.IsOpen;
                //GeneralConfig.Healthy = true;
                Thread.Sleep(100);
            }), "MORK-IC心跳刷新");
            //ThreadManage.GetInstance.Start(new Action(() =>
            //{
            //    while (!JuicerModel.GetInstance.IsConnected)
            //    {
            //        Thread.Sleep(10);
            //    }
            //    //Sence(JuicerModel.SENCE_欢迎);
            //}), "MORK-JC欢迎");
        }

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

        public void DataParse<T>(T order)
        {
            if (order is MorkOrderPush morkOrderPush)
            {
                morkOrderPushes.Enqueue(morkOrderPush);
            }
        }

        /// <summary>
        /// 验证当前是做咖啡还是做冰淇淋
        /// </summary>
        /// <param name="batchingLoc">物料位置</param>
        private GOODS_TYPE ValidateGoodsByBatching(string batchingLoc)
        {
            if (batchings.ContainsKey(batchingLoc))
                return batchings[batchingLoc].GoodsType;
            return GOODS_TYPE.NEITHER;
        }

        private AutoResetEvent are = new AutoResetEvent(false);

        private void Wait(int value = 101)
        {
            while (!((bool)peripheralStatus["RobotOK"] && (int)peripheralStatus["RobotValue"] == value))
            {
                Thread.Sleep(5);
            }
            new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
        }

        private void Sence(int sen)
        {
            new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = sen }.Publish();
        }

        private T GetStatus<T>(string key)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    return (T)(peripheralStatus[key]);
                }
            }
            return default;
        }

        int[] devStatusBy = new int[2] { 0, 0 };
        bool outCupCheck = false;//放纸杯位置有无判断
        /// <summary>
        /// 传感器的输入信号 0:无意义 1：有信号 2：无信号 3：信号不正确
        /// </summary>
        int bSensorInput;
        /// <summary>
        /// 延迟的超时时间
        /// </summary>
        DateTime delayTimeOut;
        /// <summary>
        /// 做咖啡
        /// </summary>
        private void DoCoffee()
        {

            #region 接咖啡流程
            are.Reset();
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
            int resultTakeCup = takeCup();
            if (resultTakeCup == 1)
            {
                MessageLog.GetInstance.Show("咖啡杯取杯完成");
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_接咖啡);
                Wait();

                new DRCoffee_MakeCoffeeEvent() { DrinkCode = (DrCoffeeDrinksCode)int.Parse(mainMaterialLoc) }.Publish();  //接咖啡控制 //DrCoffeeDrinksCode.热水
                //Task.Delay(10000).Wait();//模拟接咖啡
                //coffeEndCook.Publish();//模拟咖啡制作完成
                are.WaitOne(1000 * 360);
                while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                {
                    if (!outCupCheck)
                        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                    outCupCheck = true;
                }
                outCupCheck = false;
                while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                {
                    if (!outCupCheck)
                        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                    outCupCheck = true;
                }
                outCupCheck = false;
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_放咖啡杯);
                Wait();
                OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                MessageLog.GetInstance.Show("咖啡制作完成");

            }
            else
            {
                return;
            }
            #endregion
        }
        /// <summary>
        /// 做茶
        /// </summary>
        private void DoTea()
        {
            #region 接茶流程
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
            int resultTakeCup = takeCup();
            if (resultTakeCup == 1)
            {
                MessageLog.GetInstance.Show("取茶杯完成");
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_接茶叶);
                Wait();

                new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();
                Thread.Sleep(1000);
                new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 150 }.Publish();
                Thread.Sleep(1000);
                new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();

                Thread.Sleep(3000);
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_接茶水);
                Wait();

                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();

                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = false }.Publish();
                Thread.Sleep(100);
                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = true }.Publish();
                Thread.Sleep(3000);
                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = false }.Publish();
                Thread.Sleep(100);

                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();
                Thread.Sleep(100);
                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = true }.Publish();
                Thread.Sleep(500);
                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();
                Thread.Sleep(46000);
                while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                {
                    if (!outCupCheck)
                        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                    outCupCheck = true;
                }
                outCupCheck = false;
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_放水杯);
                Wait();


                OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                MessageLog.GetInstance.Show("茶水制作完成");

            }
            else
            {
                return;
            }
            #endregion
        }

        /// <summary>
        /// 接开水
        /// </summary>
        private void DoWater()
        {
            #region 接水流程
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            outCupCheck = false;
            OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
            int resultTakeCup = takeCup();
            if (resultTakeCup == 1)
            {
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_接水);
                Wait();
                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();
                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = false }.Publish();
                Thread.Sleep(100);
                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = true }.Publish();
                Thread.Sleep(3000);
                new WriteMcu() { TagName = "OutputControl", Address = "0", Value = false }.Publish();
                Thread.Sleep(100);

                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();
                Thread.Sleep(100);
                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = true }.Publish();
                Thread.Sleep(500);
                new WriteMcu() { TagName = "OutputControl", Address = "1", Value = false }.Publish();
                Thread.Sleep(46000);
                while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                {
                    if (!outCupCheck)
                        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                    outCupCheck = true;
                }
                outCupCheck = false;
                //添加控制接水机构程序
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_放水杯);
                Wait();
                OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                MessageLog.GetInstance.Show("纯净水制作完成");

            }
            else
            {
                return;
            }
            #endregion
        }
        /// <summary>
        /// 果汁机控制信号
        /// </summary>
        private byte JuicerNum;
        /// <summary>
        /// 做果汁
        /// </summary>
        private void DoJuicer()
        {
            #region 接果汁流程
            are.Reset();
            while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
            {
                if (!outCupCheck)
                    MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                outCupCheck = true;
            }
            OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);
            int resultTakeCup = takeCup();
            if (resultTakeCup == 1)
            {
                int JuicerNum1 = int.Parse(mainMaterialLoc);
                switch (JuicerNum1)
                {
                    case 52:
                        if (GuMake)
                        {
                            JuicerNum = 0x00;
                        }
                        else
                        {
                            JuicerNum = 0x01;
                        }
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接果汁公共位);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接1号果汁);
                        Wait();

                        break;
                    case 53:
                        if (GuMake)
                        {
                            JuicerNum = 0x02;
                        }
                        else
                        {
                            JuicerNum = 0x03;
                        }
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接果汁公共位);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接2号果汁);
                        Wait();

                        break;
                    case 54:
                        if (GuMake)
                        {
                            JuicerNum = 0x04;
                        }
                        else
                        {
                            JuicerNum = 0x05;
                        }
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接果汁公共位);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接3号果汁);
                        Wait();

                        break;
                    case 55:
                        if (GuMake)
                        {
                            JuicerNum = 0x06;
                        }
                        else
                        {
                            JuicerNum = 0x07;
                        }
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接果汁公共位);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接4号果汁); ;
                        Wait();

                        break;
                    default:
                        JuicerNum = 0x00;
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_接果汁公共位);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE_接1号果汁);
                        Wait();

                        break;
                }
                var devStatus = GetStatus<int[]>("GetDeviceStatus");
                var devStatus1 = Convert.ToString(devStatus[0], 2);
                var devStatus2 = devStatus[1];

                if (devStatus1.IndexOf("0") == 1 && devStatus2 == 0)
                {
                    new WriteJuicer() { Value = JuicerNum }.Publish();
                    Thread.Sleep(100);
                    devStatusBy = GetStatus<int[]>("GetDeviceStatus");
                    while (!(devStatusBy[1] == 0))
                    {
                        Thread.Sleep(100);
                        devStatusBy = GetStatus<int[]>("GetDeviceStatus");
                        while (devStatusBy.Length != 2)
                        {
                            Thread.Sleep(100);
                            devStatusBy = GetStatus<int[]>("GetDeviceStatus");
                        }
                    }
                    devStatusBy = GetStatus<int[]>("GetDeviceStatus");
                    Thread.Sleep(5000);
                    while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                    {
                        if (!outCupCheck)
                            MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                        outCupCheck = true;
                    }
                    outCupCheck = false;
                    new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                    Sence(JuicerModel.JUICE2_放果汁杯);
                    Wait();

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

                }
                ////模拟果汁
                //Thread.Sleep(15000);
                //while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品
                //{
                //    if (!outCupCheck)
                //        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");
                //    outCupCheck = true;
                //}
                //outCupCheck = false;
                //new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                //Sence(JuicerModel.JUICE2_放果汁杯);
                //Wait();

                //OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);
                //MessageLog.GetInstance.Show("果汁制作完成");
            }
            else
            {
                return;
            }
            #endregion
        }
        /// <summary>
        /// 取杯的次数
        /// </summary>
        private int nCnt;
        private int checkCnt;//检测次数

        public override DeviceClientType DeviceType => throw new NotImplementedException();

        /// <summary>
        /// 取杯流程
        /// </summary>
        /// <returns>0:无意义，1：取杯成功 2：取杯失败</returns>
        private int takeCup()
        {
            try
            {

                nCnt = 0;
                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_初始位);
                Wait();


                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_取纸杯);
                Wait();


                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                Sence(JuicerModel.JUICE2_纸杯检测);
                Wait();

                nCnt++;
                Thread.Sleep(2000);
                while (checkCnt < 3)
                {
                    if (!GetStatus<bool>("GetInput"))
                    {
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_再检测);
                        Wait();
                    }
                    else
                    {
                        break;
                    }
                    checkCnt++;
                }
                checkCnt = 0;
                while (!GetStatus<bool>("GetInput")) //读取传感器的值
                {
                    if (nCnt > 3)
                    {
                        nCnt = 0;
                        MessageLog.GetInstance.ShowEx("三次取杯失败，回原点");
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_检测位回原点);
                        Wait();
                        return 2;
                    }
                    else
                    {


                        nCnt++;
                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_二次取杯);
                        Wait();

                        new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                        Sence(JuicerModel.JUICE2_纸杯检测);
                        Wait();
                        checkCnt = 0;
                        while (checkCnt < 3)
                        {
                            if (!GetStatus<bool>("GetInput"))
                            {
                                new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();
                                Sence(JuicerModel.JUICE2_再检测);
                                Wait();
                            }
                            else
                            {
                                checkCnt = 0;
                                return 1;

                            }
                            checkCnt++;
                        }

                    }
                    Thread.Sleep(1000);
                }
            }
            catch (Exception ex)
            {
                MessageLog.GetInstance.Show(ex.ToString());
            }

            return 1;
        }
        /// <summary>
        /// 放杯
        /// </summary>
        /// <returns>0:无意义 1：放杯成功 2：执行失败(传感器还有信号) 3：放杯异常</returns>
        private int putCup()
        {
            try
            {
                if (GetStatus<bool>("RobotValue1")) return 2;
                Sence(JuicerModel.JUICE_放杯);
                Wait();
                new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();
                Sence(JuicerModel.JUICE_放杯检测);
                Wait();
                new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();
                if (GetStatus<bool>("GetInput2"))
                {
                    return 1;
                }
                else
                {
                    return 3;
                }
            }
            catch (Exception ex)
            {
                MessageLog.GetInstance.Show(ex.ToString());
                return 0;
            }
        }

        /// <summary>
        /// 检测放杯位，是否有杯子
        /// </summary>
        /// <returns>0：无意义 1：没有杯子  2：有杯子 </returns>
        private int checkCup()
        {
            try
            {
                while (GetStatus<bool>("RobotValue1"))
                {
                    Thread.Sleep(100);
                    if (DateTime.Now.Subtract(delayTimeOut).TotalSeconds >= 1) return 2;
                }
                MessageLog.GetInstance.Show("放杯位有杯子未取走，等待取走，最多等待60s，即跳出流程");
                return 1;
            }
            catch (Exception ex)
            {
                MessageLog.GetInstance.Show(ex.ToString());
                return 0;
            }
        }

        private void CoffeEndCookHandle(IEvent @event, EventCallBackHandle callBack)
        {
            are.Set();
        }


        //public void ReadData()
        //{
        //    //ThreadManage.GetInstance.StartLong(new Action(() =>
        //    //{
        //    //    lebai = JuicerModel.GetInstance.GetValueAsync();
        //    //    JuicerModel.GetInstance.GetRobotModeStatus();
        //    //    //JuicerModel.GetInstance.GetInput();


        //    //    Thread.Sleep(100);
        //    //}), "乐百机器人数据读取", true);
        //}

        public void SimOrder<T>(T simOrder)
        {
            //if (morkOrderPushes.Count > 0)
            //{
            //    morkOrderPushes.Clear();
            //}
            //morkOrderPushes.Enqueue(simOrder as MorkOrderPush);
        }



        /// <summary>
        /// IOT 广播消息命令
        /// </summary>
        //public void IotBroadcast<T>(T broadcast)
        //{
        //    if (broadcast != null && broadcast is IOTCommandModel iOTCommand)
        //    {
        //        switch (iOTCommand.CommandName)
        //        {
        //            case 0://控制类
        //                if (iOTCommand.CommandValue != null)
        //                {
        //                    if (iOTCommand.CommandValue.ContainsKey("SimOrder"))
        //                    {
        //                        //SimOrder(new SimOrderData { NoodleLoc = 1, BowlLoc = 10 });
        //                    }
        //                }
        //                break;
        //            case 1://设置属性

        //                break;
        //            case 2://通知消息

        //                break;
        //            default:
        //                break;
        //        }
        //    }
        //}

        public override void DoMain()
        {
        }

        public override void Stop()
        {
        }

        public override void ReadData()
        {

        }

        public override void MainTask()
        {
        }

        public override void ResetProgram()
        {
        }

        public override void SimOrder()
        {
        }

        public class SimOrderData
        {
            public string id { get; set; }

            public int OrderStatus { get; set; }

            public string Loc { get; set; }

            public MorkOrderPush morkOrder { get; set; }

            public SimOrderData()
            {
                id = Guid.NewGuid().ToString();
                OrderStatus = 0;
            }
        }
    }
}