bpa
/
BPASmartClient
2
0
Fork 0
Code Issues 0 Pull-Requests 0 Releases 0 Wiki Aktivität
终端一体化运控平台
Du kannst nicht mehr als 25 Themen auswählen Themen müssen entweder mit einem Buchstaben oder einer Ziffer beginnen. Sie können Bindestriche („-“) enthalten und bis zu 35 Zeichen lang sein.
333 Commits
7 Branches
118 MiB
 
 
 
Struktur: a532aa47bc
Branches Tags
${ item.name }
Erstelle Branch ${ searchTerm }
von „a532aa47bc“
${ noResults }
BPASmartClient/BPASmartClient.MorkT.Lebai.JC/Control_MORKJC2.cs

870 Zeilen
33 KiB
Originalformat Blame Verlauf 

  1. using System;

  2. using System.Collections.Generic;

  3. using System.Configuration;

  4. using System.Linq;

  5. using System.Threading;

  6. using System.Collections.Concurrent;

  7. using System.Diagnostics;

  8. using System.Threading.Tasks;

  9. using BPASmartClient.Device;

  10. using BPA.Message.Enum;

  11. using BPA.Message;

  12. using BPASmartClient.Helper;

  13. using BPASmartClient.Model.咖啡机.Enum;

  14. using BPASmartClient.Model;

  15. using BPASmartClient.EventBus;

  16. using static BPASmartClient.EventBus.EventBus;

  17. using BPASmartClient.Message;

  18. using BPASmartClient.Model.乐白机器人;

  19. using BPASmartClient.Model.单片机;

  20. 

  21. namespace BPASmartClient.MorkTLebaiJC

  22. {

  23.     /*

  24.      * 冰淇淋咖啡机组合套装

  25.      * 物料位置：

  26.      * 1：冰淇料

  27.      * 2：冰淇淋杯

  28.      * 5：咖啡

  29.      * 6：咖啡杯

  30.      * 9: 茶

  31.      * 10: 茶杯

  32.      */

  33.     public class Control_MORKJC2 : BaseDevice

  34.     {

  35.         //private CoffeEndCook coffeEndCook = new CoffeEndCook();//模拟咖啡制作成功

  36.         //咖啡机主控程序

  37.         //private CoffeeMachine coffeeMachine;

  38.         //物料存放位置

  39.         private Dictionary<string, PolymerBatching> batchings = new Dictionary<string, PolymerBatching>();

  40.         //容器位置

  41.         private string holderLoc;

  42.         /// <summary>

  43.         /// 获取乐百机器人的数据

  44.         /// </summary>

  45.         //SignalResult lebai = new SignalResult();

  46.         //主料位置

  47.         private string mainMaterialLoc;

  48.         //子订单ID

  49.         private string subOrderId;

  50. 

  51.         private bool enableFunny = false;

  52.         private DateTime lastRecvdOrder = DateTime.Now;

  53.         private bool working = false;

  54.         /// <summary>

  55.         /// 果汁机做法，true:热饮，false:冷饮

  56.         /// </summary>

  57.         private bool GuMake = false;

  58. 

  59.         //private SerialPortClient commProxy;

  60.         public void ConnectOk()

  61.         {

  62. 

  63.         }

  64.         ConcurrentQueue<MorkOrderPush> morkOrderPushes = new ConcurrentQueue<MorkOrderPush>();

  65.         public void Init()

  66.         {

  67.             //ActionManage.GetInstance.Register(new Action<object>((s) =>

  68.             //{

  69.             //    if (s is DrCoffeeDrinksCode cf)

  70.             //    {

  71.             //        DoCoffee();

  72.             //    }

  73.             //    else if (s is Dictionary<string, string> ms)

  74.             //    {

  75.             //        if (ms.ContainsKey("Button"))

  76.             //        {

  77.             //            switch (ms["Button"])

  78.             //            {

  79.             //                case "启动示教":

  80.             //                    JuicerModel.GetInstance.StartTeachMode();

  81.             //                    break;

  82.             //                case "停止示教":

  83.             //                    JuicerModel.GetInstance.EndtTeachMode();

  84.             //                    break;

  85.             //                case "启动机器人":

  86.             //                    JuicerModel.GetInstance.StartRobot();

  87.             //                    break;

  88.             //                case "急停":

  89.             //                    JuicerModel.GetInstance.EStopRobot();

  90.             //                    break;

  91.             //                default:

  92.             //                    break;

  93.             //            }

  94.             //        }

  95.             //    }

  96.             //}), "SimCoffee");

  97. 

  98.             //构建所有商品物料信息

  99.             batchings = PolymerBatching.BuildAll();

  100. 

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

  102. 

  103.             System.Configuration.Configuration config = System.Configuration.ConfigurationManager.OpenExeConfiguration(System.Configuration.ConfigurationUserLevel.None);

  104.             //一系列外围基础配置

  105.             var com_Coffee = config.AppSettings.Settings["COM_Coffee"].Value;

  106.             var baud_Coffee = config.AppSettings.Settings["BAUD_Coffee"].Value;

  107.             //咖啡机创建

  108.             //coffeeMachine = new CoffeeMachine(com_Coffee, (BaudRates)Enum.Parse(typeof(BaudRates), baud_Coffee));

  109. 

  110.             Main();

  111.             ReadData();

  112.             ThreadManage.GetInstance().StartLong(new Action(() =>

  113.             {

  114.                 while (IsHealth && (morkOrderPushes.Count > 0))

  115.                 {

  116.                     working = true;

  117.                     if (morkOrderPushes.TryDequeue(out MorkOrderPush order))

  118.                     {

  119.                         MessageLog.GetInstance.Show($"开始制作订单[{order.SortNum}]");

  120.                         //商品类型

  121.                         GOODS_TYPE currentGoodsType = GOODS_TYPE.NEITHER;

  122.                         //子订单ID

  123.                         subOrderId = order.SuborderId;

  124.                         //遍历物料

  125.                         foreach (var item in order.GoodBatchings)

  126.                         {

  127.                             var res = Json<BatchingInfoPar>.Data.orderMaterialDelivery.BatchingInfo.FirstOrDefault(p => p.BatchingId == item.BatchingId);

  128.                             if (res != null)

  129.                             {

  130.                                 //获取主料和容器位置

  131.                                 switch (batchings[res.BatchingLoc].BatchingClass)

  132.                                 {

  133.                                     case BATCHING_CLASS.HOLDER:

  134.                                         holderLoc = res.BatchingLoc;

  135.                                         break;

  136.                                     case BATCHING_CLASS.MAIN_MATERIAL:

  137.                                         // mainMaterialLoc ="1";

  138.                                         mainMaterialLoc = res.BatchingLoc;

  139.                                         //验证商品是咖啡还是冰淇淋

  140.                                         if (ValidateGoodsByBatching(res.BatchingLoc) != GOODS_TYPE.NEITHER)

  141.                                         {

  142.                                             //获取当前物料所属商品类型

  143.                                             currentGoodsType = ValidateGoodsByBatching(res.BatchingLoc);

  144.                                         }

  145.                                         break;

  146.                                 }

  147.                             }

  148.                         }

  149. 

  150.                         //根据商品类型执行具体制作流程

  151.                         switch (currentGoodsType)

  152.                         {

  153.                             case GOODS_TYPE.COFFEE:

  154.                                 DoCoffee();

  155.                                 break;

  156.                             case GOODS_TYPE.JUICE:

  157.                                 GuMake = order.MakeID == "2";

  158.                                 DoJuicer();

  159.                                 break;

  160.                             case GOODS_TYPE.TEA:

  161.                                 DoTea();

  162.                                 break;

  163.                             case GOODS_TYPE.WATER:

  164.                                 DoWater();

  165.                                 break;

  166.                             case GOODS_TYPE.NEITHER:

  167.                                 MessageLog.GetInstance.Show("未知的商品类型");

  168.                                 break;

  169.                         }

  170.                     }

  171.                     working = false;

  172.                     lastRecvdOrder = DateTime.Now;

  173.                 }

  174.                 Thread.Sleep(1000);

  175.             }), "订单制作");

  176.         }

  177. 

  178.         public void Main()

  179.         {

  180.             //咖啡机开启主线程

  181.             //coffeeMachine.Start();

  182.             //开始心跳刷新，根据咖啡机及冰淇淋机来判断

  183.             ThreadManage.GetInstance().StartLong(new Action(() =>

  184.             {

  185.                 //GeneralConfig.Healthy =

  186.                 //         JuicerModel.GetInstance.IsConnected &&

  187.                 //         MorkCStatus.GetInstance().CanDo &&

  188.                 //         JuicerHelper.GetInstance.IsOpen &&

  189.                 //         MCUSerialHelper.GetInstance.IsOpen;

  190.                 //GeneralConfig.Healthy = true;

  191.                 Thread.Sleep(100);

  192.             }), "MORK-IC心跳刷新");

  193.             //ThreadManage.GetInstance.Start(new Action(() =>

  194.             //{

  195.             //    while (!JuicerModel.GetInstance.IsConnected)

  196.             //    {

  197.             //        Thread.Sleep(10);

  198.             //    }

  199.             //    //Sence(JuicerModel.SENCE_欢迎);

  200.             //}), "MORK-JC欢迎");

  201.         }

  202. 

  203.         private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)

  204.         {

  205.             EventBus.EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });

  206.         }

  207. 

  208.         public void DataParse<T>(T order)

  209.         {

  210.             if (order is MorkOrderPush morkOrderPush)

  211.             {

  212.                 morkOrderPushes.Enqueue(morkOrderPush);

  213.             }

  214.         }

  215. 

  216.         /// <summary>

  217.         /// 验证当前是做咖啡还是做冰淇淋

  218.         /// </summary>

  219.         /// <param name="batchingLoc">物料位置</param>

  220.         private GOODS_TYPE ValidateGoodsByBatching(string batchingLoc)

  221.         {

  222.             if (batchings.ContainsKey(batchingLoc))

  223.                 return batchings[batchingLoc].GoodsType;

  224.             return GOODS_TYPE.NEITHER;

  225.         }

  226. 

  227.         private AutoResetEvent are = new AutoResetEvent(false);

  228. 

  229.         private void Wait(int value = 101)

  230.         {

  231.             while (!((bool)peripheralStatus["RobotOK"] && (int)peripheralStatus["RobotValue"] == value))

  232.             {

  233.                 Thread.Sleep(5);

  234.             }

  235.             new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  236.         }

  237. 

  238.         private void Sence(int sen)

  239.         {

  240.             new LebaiRobot_LebaiSenceEvent { DeviceId = DeviceId, LebaiSence = sen }.Publish();

  241.         }

  242. 

  243.         private T GetStatus<T>(string key)

  244.         {

  245.             if (peripheralStatus.ContainsKey(key))

  246.             {

  247.                 if (peripheralStatus[key] != null)

  248.                 {

  249.                     return (T)(peripheralStatus[key]);

  250.                 }

  251.             }

  252.             return default;

  253.         }

  254. 

  255.         int[] devStatusBy = new int[2] { 0, 0 };

  256.         bool outCupCheck = false;//放纸杯位置有无判断

  257.         /// <summary>

  258.         /// 传感器的输入信号 0:无意义 1：有信号 2：无信号 3：信号不正确

  259.         /// </summary>

  260.         int bSensorInput;

  261.         /// <summary>

  262.         /// 延迟的超时时间

  263.         /// </summary>

  264.         DateTime delayTimeOut;

  265.         /// <summary>

  266.         /// 做咖啡

  267.         /// </summary>

  268.         private void DoCoffee()

  269.         {

  270. 

  271.             #region 接咖啡流程

  272.             are.Reset();

  273.             while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  274.             {

  275.                 if (!outCupCheck)

  276.                     MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  277.                 outCupCheck = true;

  278.             }

  279.             outCupCheck = false;

  280.             OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);

  281.             int resultTakeCup = takeCup();

  282.             if (resultTakeCup == 1)

  283.             {

  284.                 MessageLog.GetInstance.Show("咖啡杯取杯完成");

  285.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  286.                 Sence(JuicerModel.JUICE2_接咖啡);

  287.                 Wait();

  288. 

  289.                 new DRCoffee_MakeCoffeeEvent() { DrinkCode = (DrCoffeeDrinksCode)int.Parse(mainMaterialLoc) }.Publish();  //接咖啡控制 //DrCoffeeDrinksCode.热水

  290.                 //Task.Delay(10000).Wait();//模拟接咖啡

  291.                 //coffeEndCook.Publish();//模拟咖啡制作完成

  292.                 are.WaitOne(1000 * 360);

  293.                 while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  294.                 {

  295.                     if (!outCupCheck)

  296.                         MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  297.                     outCupCheck = true;

  298.                 }

  299.                 outCupCheck = false;

  300.                 while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  301.                 {

  302.                     if (!outCupCheck)

  303.                         MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  304.                     outCupCheck = true;

  305.                 }

  306.                 outCupCheck = false;

  307.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  308.                 Sence(JuicerModel.JUICE2_放咖啡杯);

  309.                 Wait();

  310.                 OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);

  311.                 MessageLog.GetInstance.Show("咖啡制作完成");

  312. 

  313.             }

  314.             else

  315.             {

  316.                 return;

  317.             }

  318.             #endregion

  319.         }

  320.         /// <summary>

  321.         /// 做茶

  322.         /// </summary>

  323.         private void DoTea()

  324.         {

  325.             #region 接茶流程

  326.             while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  327.             {

  328.                 if (!outCupCheck)

  329.                     MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  330.                 outCupCheck = true;

  331.             }

  332.             outCupCheck = false;

  333.             OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);

  334.             int resultTakeCup = takeCup();

  335.             if (resultTakeCup == 1)

  336.             {

  337.                 MessageLog.GetInstance.Show("取茶杯完成");

  338.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  339.                 Sence(JuicerModel.JUICE2_接茶叶);

  340.                 Wait();

  341. 

  342.                 new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();

  343.                 Thread.Sleep(1000);

  344.                 new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 150 }.Publish();

  345.                 Thread.Sleep(1000);

  346.                 new WriteMcu() { TagName = "ServoControl", Address = "1", Value = 90 }.Publish();

  347. 

  348.                 Thread.Sleep(3000);

  349.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  350.                 Sence(JuicerModel.JUICE2_接茶水);

  351.                 Wait();

  352. 

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

  354. 

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

  356.                 Thread.Sleep(100);

  357.                 new WriteMcu() { TagName = "OutputControl", Address = "0", Value = true }.Publish();

  358.                 Thread.Sleep(3000);

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

  360.                 Thread.Sleep(100);

  361. 

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

  363.                 Thread.Sleep(100);

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

  365.                 Thread.Sleep(500);

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

  367.                 Thread.Sleep(46000);

  368.                 while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  369.                 {

  370.                     if (!outCupCheck)

  371.                         MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  372.                     outCupCheck = true;

  373.                 }

  374.                 outCupCheck = false;

  375.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  376.                 Sence(JuicerModel.JUICE2_放水杯);

  377.                 Wait();

  378. 

  379. 

  380.                 OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);

  381.                 MessageLog.GetInstance.Show("茶水制作完成");

  382. 

  383.             }

  384.             else

  385.             {

  386.                 return;

  387.             }

  388.             #endregion

  389.         }

  390. 

  391.         /// <summary>

  392.         /// 接开水

  393.         /// </summary>

  394.         private void DoWater()

  395.         {

  396.             #region 接水流程

  397.             while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  398.             {

  399.                 if (!outCupCheck)

  400.                     MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  401.                 outCupCheck = true;

  402.             }

  403.             outCupCheck = false;

  404.             OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);

  405.             int resultTakeCup = takeCup();

  406.             if (resultTakeCup == 1)

  407.             {

  408.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  409.                 Sence(JuicerModel.JUICE2_接水);

  410.                 Wait();

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

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

  413.                 Thread.Sleep(100);

  414.                 new WriteMcu() { TagName = "OutputControl", Address = "0", Value = true }.Publish();

  415.                 Thread.Sleep(3000);

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

  417.                 Thread.Sleep(100);

  418. 

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

  420.                 Thread.Sleep(100);

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

  422.                 Thread.Sleep(500);

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

  424.                 Thread.Sleep(46000);

  425.                 while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  426.                 {

  427.                     if (!outCupCheck)

  428.                         MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  429.                     outCupCheck = true;

  430.                 }

  431.                 outCupCheck = false;

  432.                 //添加控制接水机构程序

  433.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  434.                 Sence(JuicerModel.JUICE2_放水杯);

  435.                 Wait();

  436.                 OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);

  437.                 MessageLog.GetInstance.Show("纯净水制作完成");

  438. 

  439.             }

  440.             else

  441.             {

  442.                 return;

  443.             }

  444.             #endregion

  445.         }

  446.         /// <summary>

  447.         /// 果汁机控制信号

  448.         /// </summary>

  449.         private byte JuicerNum;

  450.         /// <summary>

  451.         /// 做果汁

  452.         /// </summary>

  453.         private void DoJuicer()

  454.         {

  455.             #region 接果汁流程

  456.             are.Reset();

  457.             while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  458.             {

  459.                 if (!outCupCheck)

  460.                     MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  461.                 outCupCheck = true;

  462.             }

  463.             OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COOKING);

  464.             int resultTakeCup = takeCup();

  465.             if (resultTakeCup == 1)

  466.             {

  467.                 int JuicerNum1 = int.Parse(mainMaterialLoc);

  468.                 switch (JuicerNum1)

  469.                 {

  470.                     case 52:

  471.                         if (GuMake)

  472.                         {

  473.                             JuicerNum = 0x00;

  474.                         }

  475.                         else

  476.                         {

  477.                             JuicerNum = 0x01;

  478.                         }

  479.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  480.                         Sence(JuicerModel.JUICE2_接果汁公共位);

  481.                         Wait();

  482. 

  483.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  484.                         Sence(JuicerModel.JUICE2_接1号果汁);

  485.                         Wait();

  486. 

  487.                         break;

  488.                     case 53:

  489.                         if (GuMake)

  490.                         {

  491.                             JuicerNum = 0x02;

  492.                         }

  493.                         else

  494.                         {

  495.                             JuicerNum = 0x03;

  496.                         }

  497.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  498.                         Sence(JuicerModel.JUICE2_接果汁公共位);

  499.                         Wait();

  500. 

  501.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  502.                         Sence(JuicerModel.JUICE2_接2号果汁);

  503.                         Wait();

  504. 

  505.                         break;

  506.                     case 54:

  507.                         if (GuMake)

  508.                         {

  509.                             JuicerNum = 0x04;

  510.                         }

  511.                         else

  512.                         {

  513.                             JuicerNum = 0x05;

  514.                         }

  515.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  516.                         Sence(JuicerModel.JUICE2_接果汁公共位);

  517.                         Wait();

  518. 

  519.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  520.                         Sence(JuicerModel.JUICE2_接3号果汁);

  521.                         Wait();

  522. 

  523.                         break;

  524.                     case 55:

  525.                         if (GuMake)

  526.                         {

  527.                             JuicerNum = 0x06;

  528.                         }

  529.                         else

  530.                         {

  531.                             JuicerNum = 0x07;

  532.                         }

  533.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  534.                         Sence(JuicerModel.JUICE2_接果汁公共位);

  535.                         Wait();

  536. 

  537.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  538.                         Sence(JuicerModel.JUICE2_接4号果汁); ;

  539.                         Wait();

  540. 

  541.                         break;

  542.                     default:

  543.                         JuicerNum = 0x00;

  544.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  545.                         Sence(JuicerModel.JUICE2_接果汁公共位);

  546.                         Wait();

  547. 

  548.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  549.                         Sence(JuicerModel.JUICE_接1号果汁);

  550.                         Wait();

  551. 

  552.                         break;

  553.                 }

  554.                 var devStatus = GetStatus<int[]>("GetDeviceStatus");

  555.                 var devStatus1 = Convert.ToString(devStatus[0], 2);

  556.                 var devStatus2 = devStatus[1];

  557. 

  558.                 if (devStatus1.IndexOf("0") == 1 && devStatus2 == 0)

  559.                 {

  560.                     new WriteJuicer() { Value = JuicerNum }.Publish();

  561.                     Thread.Sleep(100);

  562.                     devStatusBy = GetStatus<int[]>("GetDeviceStatus");

  563.                     while (!(devStatusBy[1] == 0))

  564.                     {

  565.                         Thread.Sleep(100);

  566.                         devStatusBy = GetStatus<int[]>("GetDeviceStatus");

  567.                         while (devStatusBy.Length != 2)

  568.                         {

  569.                             Thread.Sleep(100);

  570.                             devStatusBy = GetStatus<int[]>("GetDeviceStatus");

  571.                         }

  572.                     }

  573.                     devStatusBy = GetStatus<int[]>("GetDeviceStatus");

  574.                     Thread.Sleep(5000);

  575.                     while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  576.                     {

  577.                         if (!outCupCheck)

  578.                             MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  579.                         outCupCheck = true;

  580.                     }

  581.                     outCupCheck = false;

  582.                     new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  583.                     Sence(JuicerModel.JUICE2_放果汁杯);

  584.                     Wait();

  585. 

  586.                     OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);

  587.                     MessageLog.GetInstance.Show("果汁制作完成");

  588. 

  589.                 }

  590.                 ////模拟果汁

  591.                 //Thread.Sleep(15000);

  592.                 //while (GetStatus<bool>("RobotValue1"))//判断放杯位置是否有物品

  593.                 //{

  594.                 //    if (!outCupCheck)

  595.                 //        MessageLog.GetInstance.ShowEx("成品处有纸杯存在，请取走！！");

  596.                 //    outCupCheck = true;

  597.                 //}

  598.                 //outCupCheck = false;

  599.                 //new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  600.                 //Sence(JuicerModel.JUICE2_放果汁杯);

  601.                 //Wait();

  602. 

  603.                 //OrderChange(subOrderId, BPA.Message.Enum.ORDER_STATUS.COMPLETED_TAKE);

  604.                 //MessageLog.GetInstance.Show("果汁制作完成");

  605.             }

  606.             else

  607.             {

  608.                 return;

  609.             }

  610.             #endregion

  611.         }

  612.         /// <summary>

  613.         /// 取杯的次数

  614.         /// </summary>

  615.         private int nCnt;

  616.         private int checkCnt;//检测次数

  617. 

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

  619. 

  620.         /// <summary>

  621.         /// 取杯流程

  622.         /// </summary>

  623.         /// <returns>0:无意义，1：取杯成功 2：取杯失败</returns>

  624.         private int takeCup()

  625.         {

  626.             try

  627.             {

  628. 

  629.                 nCnt = 0;

  630.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  631.                 Sence(JuicerModel.JUICE2_初始位);

  632.                 Wait();

  633. 

  634. 

  635.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  636.                 Sence(JuicerModel.JUICE2_取纸杯);

  637.                 Wait();

  638. 

  639. 

  640.                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  641.                 Sence(JuicerModel.JUICE2_纸杯检测);

  642.                 Wait();

  643. 

  644.                 nCnt++;

  645.                 Thread.Sleep(2000);

  646.                 while (checkCnt < 3)

  647.                 {

  648.                     if (!GetStatus<bool>("GetInput"))

  649.                     {

  650.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  651.                         Sence(JuicerModel.JUICE2_再检测);

  652.                         Wait();

  653.                     }

  654.                     else

  655.                     {

  656.                         break;

  657.                     }

  658.                     checkCnt++;

  659.                 }

  660.                 checkCnt = 0;

  661.                 while (!GetStatus<bool>("GetInput")) //读取传感器的值

  662.                 {

  663.                     if (nCnt > 3)

  664.                     {

  665.                         nCnt = 0;

  666.                         MessageLog.GetInstance.ShowEx("三次取杯失败，回原点");

  667.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  668.                         Sence(JuicerModel.JUICE2_检测位回原点);

  669.                         Wait();

  670.                         return 2;

  671.                     }

  672.                     else

  673.                     {

  674. 

  675. 

  676.                         nCnt++;

  677.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  678.                         Sence(JuicerModel.JUICE2_二次取杯);

  679.                         Wait();

  680. 

  681.                         new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  682.                         Sence(JuicerModel.JUICE2_纸杯检测);

  683.                         Wait();

  684.                         checkCnt = 0;

  685.                         while (checkCnt < 3)

  686.                         {

  687.                             if (!GetStatus<bool>("GetInput"))

  688.                             {

  689.                                 new LebaiRobot_SetValueEvent { DeviceId = DeviceId, RobotSetValue = 0 }.Publish();

  690.                                 Sence(JuicerModel.JUICE2_再检测);

  691.                                 Wait();

  692.                             }

  693.                             else

  694.                             {

  695.                                 checkCnt = 0;

  696.                                 return 1;

  697. 

  698.                             }

  699.                             checkCnt++;

  700.                         }

  701. 

  702.                     }

  703.                     Thread.Sleep(1000);

  704.                 }

  705.             }

  706.             catch (Exception ex)

  707.             {

  708.                 MessageLog.GetInstance.Show(ex.ToString());

  709.             }

  710. 

  711.             return 1;

  712.         }

  713.         /// <summary>

  714.         /// 放杯

  715.         /// </summary>

  716.         /// <returns>0:无意义 1：放杯成功 2：执行失败(传感器还有信号) 3：放杯异常</returns>

  717.         private int putCup()

  718.         {

  719.             try

  720.             {

  721.                 if (GetStatus<bool>("RobotValue1")) return 2;

  722.                 Sence(JuicerModel.JUICE_放杯);

  723.                 Wait();

  724.                 new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();

  725.                 Sence(JuicerModel.JUICE_放杯检测);

  726.                 Wait();

  727.                 new LebaiRobot_SetValueEvent() { RobotSetValue = 1 }.Publish();

  728.                 if (GetStatus<bool>("GetInput2"))

  729.                 {

  730.                     return 1;

  731.                 }

  732.                 else

  733.                 {

  734.                     return 3;

  735.                 }

  736.             }

  737.             catch (Exception ex)

  738.             {

  739.                 MessageLog.GetInstance.Show(ex.ToString());

  740.                 return 0;

  741.             }

  742.         }

  743. 

  744.         /// <summary>

  745.         /// 检测放杯位，是否有杯子

  746.         /// </summary>

  747.         /// <returns>0：无意义 1：没有杯子  2：有杯子 </returns>

  748.         private int checkCup()

  749.         {

  750.             try

  751.             {

  752.                 while (GetStatus<bool>("RobotValue1"))

  753.                 {

  754.                     Thread.Sleep(100);

  755.                     if (DateTime.Now.Subtract(delayTimeOut).TotalSeconds >= 1) return 2;

  756.                 }

  757.                 MessageLog.GetInstance.Show("放杯位有杯子未取走，等待取走，最多等待60s，即跳出流程");

  758.                 return 1;

  759.             }

  760.             catch (Exception ex)

  761.             {

  762.                 MessageLog.GetInstance.Show(ex.ToString());

  763.                 return 0;

  764.             }

  765.         }

  766. 

  767.         private void CoffeEndCookHandle(IEvent @event, EventCallBackHandle callBack)

  768.         {

  769.             are.Set();

  770.         }

  771. 

  772. 

  773.         //public void ReadData()

  774.         //{

  775.         //    //ThreadManage.GetInstance.StartLong(new Action(() =>

  776.         //    //{

  777.         //    //    lebai = JuicerModel.GetInstance.GetValueAsync();

  778.         //    //    JuicerModel.GetInstance.GetRobotModeStatus();

  779.         //    //    //JuicerModel.GetInstance.GetInput();

  780. 

  781. 

  782.         //    //    Thread.Sleep(100);

  783.         //    //}), "乐百机器人数据读取", true);

  784.         //}

  785. 

  786.         public void SimOrder<T>(T simOrder)

  787.         {

  788.             //if (morkOrderPushes.Count > 0)

  789.             //{

  790.             //    morkOrderPushes.Clear();

  791.             //}

  792.             //morkOrderPushes.Enqueue(simOrder as MorkOrderPush);

  793.         }

  794. 

  795. 

  796. 

  797.         /// <summary>

  798.         /// IOT 广播消息命令

  799.         /// </summary>

  800.         //public void IotBroadcast<T>(T broadcast)

  801.         //{

  802.         //    if (broadcast != null && broadcast is IOTCommandModel iOTCommand)

  803.         //    {

  804.         //        switch (iOTCommand.CommandName)

  805.         //        {

  806.         //            case 0://控制类

  807.         //                if (iOTCommand.CommandValue != null)

  808.         //                {

  809.         //                    if (iOTCommand.CommandValue.ContainsKey("SimOrder"))

  810.         //                    {

  811.         //                        //SimOrder(new SimOrderData { NoodleLoc = 1, BowlLoc = 10 });

  812.         //                    }

  813.         //                }

  814.         //                break;

  815.         //            case 1://设置属性

  816. 

  817.         //                break;

  818.         //            case 2://通知消息

  819. 

  820.         //                break;

  821.         //            default:

  822.         //                break;

  823.         //        }

  824.         //    }

  825.         //}

  826. 

  827.         public override void DoMain()

  828.         {

  829.         }

  830. 

  831.         public override void Stop()

  832.         {

  833.         }

  834. 

  835.         public override void ReadData()

  836.         {

  837. 

  838.         }

  839. 

  840.         public override void MainTask()

  841.         {

  842.         }

  843. 

  844.         public override void ResetProgram()

  845.         {

  846.         }

  847. 

  848.         public override void SimOrder()

  849.         {

  850.         }

  851. 

  852.         public class SimOrderData

  853.         {

  854.             public string id { get; set; }

  855. 

  856.             public int OrderStatus { get; set; }

  857. 

  858.             public string Loc { get; set; }

  859. 

  860.             public MorkOrderPush morkOrder { get; set; }

  861. 

  862.             public SimOrderData()

  863.             {

  864.                 id = Guid.NewGuid().ToString();

  865.                 OrderStatus = 0;

  866.             }

  867.         }

  868.     }

  869. }