bpa
/
BPASmartClient
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
终端一体化运控平台
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1379 Commits
6 Branches
118 MiB
 
 
 
Tree: bd840e91fb
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bd840e91fb'
${ noResults }
BPASmartClient/BPASmartClient.MorkSUpgrade.../Control_MorkSUpgradedVer - ...

875 lines
39 KiB
Raw Blame History 

  1. //using System;

  2. //using System.Collections.Generic;

  3. //using BPA.Message.Enum;

  4. //using BPASmartClient.Device;

  5. //

  6. //using BPASmartClient.Model;

  7. //using BPASmartClient.Peripheral;

  8. //

  9. //using BPA.Helper;

  10. //using System.Threading;

  11. // 

  12. //using BPA.Message;

  13. //using System.Linq;

  14. //using BPASmartClient.Model.PLC;

  15. //using System.Threading.Tasks;

  16. //using System.Reflection;

  17. //using BPASmartClient.MorkSUpgradedVer.Model;

  18. //using System.Collections.ObjectModel;

  19. //using BPASmartClient.MorkSUpgradedVer.ViewModel;

  20. //using BPASmartClient.Business;

  21. //using BPASmartClient.Model.小炒机;

  22. //using BPA.Models;

  23. //using System.Windows.Forms;

  24. //using System.Media;

  25. //using BPASmartClient.CustomResource;

  26. ////using BPA.Helper;

  27. 

  28. //namespace BPASmartClient.MorkSUpgradedVer

  29. //{

  30. //    public class Control_MorkSUpgradedVer : BaseDevice

  31. //    {

  32. //        public override DeviceClientType DeviceType => DeviceClientType.MORKS;

  33. //        GVL_MorkSUpgradedVer mORKS = new GVL_MorkSUpgradedVer();

  34. //        Alarm alarm = new Alarm();

  35. 

  36. //        public override void DoMain()

  37. //        {

  38. //            MonitorViewModel.DeviceId = DeviceId;

  39. //            ServerInit();

  40. //            DataParse();

  41. //            Json<MorksPar>.Read();

  42. //            Json<OrderStatistics>.Read();

  43. //            if (Json<MorksPar>.Data.parSets == null) Json<MorksPar>.Data.parSets = new ObservableCollection<ParSet>();

  44. //            if (Json<MorksPar>.Data.parSets.Count < 6)

  45. //            {

  46. //                Json<MorksPar>.Data.parSets.Clear();

  47. //                for (int i = 0; i < 6; i++)

  48. //                {

  49. //                    Json<MorksPar>.Data.parSets.Add(new ParSet()

  50. //                    {

  51. //                        CheckBoxContext = $"煮面口{i + 1}屏蔽",

  52. //                        Minute = 1,

  53. //                        Second = 0,

  54. //                        IsShield = false,

  55. //                        TextBlockContext = $"煮面口{i + 1}时间设定"

  56. //                    });

  57. //                }

  58. //            }

  59. 

  60. //            ActionManage.GetInstance.Register(new Action<object[]>((o) =>

  61. //            {

  62. //                if (o.Length > 0)

  63. //                {

  64. //                    Random rd = new Random();

  65. //                    TaskManage.GetInstance.StartLong(new Action(() =>

  66. //                    {

  67. //                        int NoodleLoc = (int)o[0] == 0 ? rd.Next(1, 6) : (int)o[0];

  68. //                        int BowlLoc = (int)o[1] == 0 ? rd.Next(10, 12) : (int)o[1];

  69. 

  70. //                        string guid = new Guid().ToString();

  71. 

  72. //                        mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo() { Loc = (ushort)NoodleLoc, SuborderId = guid });

  73. //                        MessageLog.GetInstance.Show($"添加订单：面条位置【{NoodleLoc}】");

  74. 

  75. //                        mORKS.TakeBowlTask.Enqueue(new OrderLocInfo() { Loc = (ushort)BowlLoc, SuborderId = guid });

  76. //                        MessageLog.GetInstance.Show($"添加订单：碗位置【{BowlLoc}】");

  77. //                        Thread.Sleep(60000);

  78. //                    }), "ForOrder");

  79. //                }

  80. //            }), "EnableForOrder");

  81. 

  82. //            ActionManage.GetInstance.Register(new Action<object>((o) =>

  83. //            {

  84. //                if (o != null && o is WritePar writePar) WriteData(writePar.Address, writePar.Value);

  85. //            }), "WriteVW");

  86. //            ActionManage.GetInstance.Register(new Action<object>((o) =>

  87. //            {

  88. //                if (o != null && o is WritePar writePar) WriteData(writePar.Address, writePar.Value);

  89. //            }), "WriteBools");

  90. //            ActionManage.GetInstance.Register(new Action(() => { DeviceInit(); }), "InitDevice");

  91. //        }

  92. 

  93. //        public override void ResetProgram()

  94. //        {

  95. //            mORKS = null;

  96. //            mORKS = new GVL_MorkSUpgradedVer();

  97. //        }

  98. 

  99. //        public override void Stop()

  100. //        {

  101. 

  102. //        }

  103. 

  104. //        private void ServerInit()

  105. //        {

  106. //            //物料信息

  107. //            EventBus.GetInstance().Subscribe<MaterialDeliveryEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)

  108. //             {

  109. //                 if (@event == null) return;

  110. //                 if (@event is MaterialDeliveryEvent material)

  111. //                 {

  112. //                     orderMaterialDelivery = material.orderMaterialDelivery;

  113. //                 }

  114. //             });

  115. 

  116. //            //配方数据信息

  117. //            EventBus.GetInstance().Subscribe<RecipeBomEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)

  118. //            {

  119. //                if (@event == null) return;

  120. //                if (@event is RecipeBomEvent recipe)

  121. //                {

  122. //                    recipeBoms = recipe.recipeBoms;

  123. //                }

  124. //            });

  125. 

  126. 

  127. //        }

  128. 

  129. //        private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)

  130. //        {

  131. //            var res = mORKS.doOrderEvents.FirstOrDefault(p => p.MorkOrder.SuborderId == subid);

  132. //            string goodName = string.Empty;

  133. //            string SortNum = string.Empty;

  134. //            if (res != null)

  135. //            {

  136. //                goodName = res.MorkOrder.GoodsName;

  137. //                SortNum = res.MorkOrder.SortNum.ToString();

  138. //            }

  139. 

  140. //            //if (mORKS.doe.ContainsKey(subid))

  141. //            //{

  142. //            //    goodName = mORKS.doe[subid].MorkOrder.GoodsName;

  143. //            //    SortNum = mORKS.doe[subid].MorkOrder.SortNum.ToString();

  144. //            if (!string.IsNullOrEmpty(goodName) && !string.IsNullOrEmpty(SortNum))

  145. //            {

  146. //                EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { SortNum = SortNum, GoodName = goodName, Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });

  147. //                var index = DataServer.GetInstance.morkS.MakeOrder.FindIndex(p => p.SortNum == SortNum);

  148. //                if (index >= 0 && index < DataServer.GetInstance.morkS.MakeOrder.Count)

  149. //                {

  150. //                    if (oRDER_STATUS == ORDER_STATUS.COMPLETED_COOK)

  151. //                    {

  152. //                        DataServer.GetInstance.morkS.MakeOrder.RemoveAt(index);

  153. //                        DataServer.GetInstance.morkS.MakeOrderOver.Add(new OrderMakeModel()

  154. //                        {

  155. //                            Status = oRDER_STATUS,

  156. //                            GoodName = goodName,

  157. //                            SortNum = SortNum,

  158. //                            StopTime = DateTime.Now.ToString("HH:mm:ss")

  159. //                        });

  160. //                    }

  161. //                    else if (oRDER_STATUS == ORDER_STATUS.COMPLETED_TAKE)

  162. //                    {

  163. //                        var temp = DataServer.GetInstance.morkS.MakeOrderOver.FirstOrDefault(p => p.SortNum == SortNum);

  164. //                        if (temp != null) DataServer.GetInstance.morkS.MakeOrderOver.Remove(temp);

  165. //                    }

  166. //                    else

  167. //                    {

  168. //                        DataServer.GetInstance.morkS.MakeOrder.ElementAt(index).Status = oRDER_STATUS;

  169. //                    }

  170. //                }

  171. //                else

  172. //                {

  173. //                    DataServer.GetInstance.morkS.MakeOrder.Add(new OrderMakeModel()

  174. //                    {

  175. //                        Status = oRDER_STATUS,

  176. //                        GoodName = goodName,

  177. //                        SortNum = SortNum,

  178. //                        StartTime = DateTime.Now.ToString("HH:mm:ss")

  179. //                    });

  180. //                }

  181. //                //mORKS.doe.Remove(subid, out _);

  182. //            }

  183. //            //}

  184. 

  185. 

  186. 

  187. //            //var res = mORKS.doOrderEvents.FirstOrDefault(p => p.MorkOrder.SuborderId == subid);

  188. //            //string goodName = string.Empty;

  189. //            //string SortNum = string.Empty;

  190. //            //if (res != null)

  191. //            //{

  192. //            //    goodName = res.MorkOrder.GoodsName;

  193. //            //    SortNum = res.MorkOrder.SortNum.ToString();

  194. //            //}

  195. 

  196. //            //EventBus.GetInstance().Publish(new OrderStatusChangedEvent() { SortNum = SortNum, GoodName = goodName, Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });

  197. 

  198. //            //var index = DataServer.GetInstance.morkS.MakeOrder.FindIndex(p => p.SortNum == SortNum);

  199. //            //if (index >= 0 && index < DataServer.GetInstance.morkS.MakeOrder.Count)

  200. //            //{

  201. //            //    if (oRDER_STATUS == ORDER_STATUS.COMPLETED_COOK)

  202. //            //    {

  203. //            //        DataServer.GetInstance.morkS.MakeOrder.RemoveAt(index);

  204. //            //        DataServer.GetInstance.morkS.MakeOrderOver.Add(new OrderMakeModel()

  205. //            //        {

  206. //            //            Status = oRDER_STATUS,

  207. //            //            GoodName = goodName,

  208. //            //            SortNum = SortNum,

  209. //            //            StopTime = DateTime.Now.ToString("HH:mm:ss")

  210. //            //        });

  211. //            //    }

  212. //            //    else if (oRDER_STATUS == ORDER_STATUS.COMPLETED_TAKE)

  213. //            //    {

  214. //            //        var temp = DataServer.GetInstance.morkS.MakeOrderOver.FirstOrDefault(p => p.SortNum == SortNum);

  215. //            //        if (temp != null) DataServer.GetInstance.morkS.MakeOrderOver.Remove(temp);

  216. //            //    }

  217. //            //    else

  218. //            //    {

  219. //            //        DataServer.GetInstance.morkS.MakeOrder.ElementAt(index).Status = oRDER_STATUS;

  220. //            //    }

  221. //            //}

  222. //            //else

  223. //            //{

  224. //            //    DataServer.GetInstance.morkS.MakeOrder.Add(new OrderMakeModel()

  225. //            //    {

  226. //            //        Status = oRDER_STATUS,

  227. //            //        GoodName = goodName,

  228. //            //        SortNum = SortNum,

  229. //            //        StartTime = DateTime.Now.ToString("HH:mm:ss")

  230. //            //    });

  231. //            //}

  232. //        }

  233. 

  234. //        private void GetStatus(string key, Action<object> action)

  235. //        {

  236. //            if (peripheralStatus.ContainsKey(key))

  237. //            {

  238. //                if (peripheralStatus[key] != null)

  239. //                {

  240. //                    action?.Invoke(peripheralStatus[key]);

  241. //                }

  242. //            }

  243. //        }

  244. 

  245. //        public override void ReadData()

  246. //        {

  247. //            DataServer.GetInstance.morkS.Alarm.Clear();

  248. //            alarms.ForEach(item =>

  249. //            {

  250. //                DataServer.GetInstance.morkS.Alarm.Add(new AlarmModel()

  251. //                {

  252. //                    AlarmTime = $"{item.Date} {item.Time}",

  253. //                    AlarmMs = item.Info

  254. //                });

  255. //            });

  256. 

  257. //            GetStatus("M0.1", new Action<object>((obj) =>

  258. //             {

  259. //                 if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 7)

  260. //                 {

  261. //                     Initing = !bools[0];

  262. //                     mORKS.InitComplete = bools[0];

  263. //                     mORKS.MoveScrewRodInitCom = bools[1];

  264. //                     mORKS.SacrificialVesselInitCom = bools[2];

  265. //                     mORKS.CylinderInitCom = bools[3];

  266. //                     mORKS.NoodleCookerInitCom = bools[4];

  267. //                     mORKS.RobotInitCom = bools[5];

  268. //                     mORKS.SiloInitCom = bools[6];

  269. 

  270. //                     alarm.DeviceNoInit = !mORKS.InitComplete;

  271. //                     alarm.MoveScrewRodNoInit = !mORKS.MoveScrewRodInitCom;

  272. //                     alarm.SacrificialVesselNoInit = !mORKS.SacrificialVesselInitCom;

  273. //                     alarm.CylinderNoInit = !mORKS.CylinderInitCom;

  274. //                     alarm.NoodleCookerNoInit = !mORKS.NoodleCookerInitCom;

  275. //                     alarm.RobotNoInit = !mORKS.RobotInitCom;

  276. //                     alarm.SiloNoInit = !mORKS.SiloInitCom;

  277. //                 }

  278. //             }));

  279. 

  280. //            GetStatus("M10.0", new Action<object>((obj) =>

  281. //            {

  282. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 2)

  283. //                {

  284. //                    mORKS.AllowInvertedFace = bools[0];

  285. //                    mORKS.DiningComplete = bools[1];

  286. //                }

  287. //            }));

  288. 

  289. //            GetStatus("M10.4", new Action<object>((obj) =>

  290. //            {

  291. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)

  292. //                {

  293. //                    mORKS.DropBowlMechanismStatus = bools[0];

  294. //                }

  295. //            }));

  296. 

  297. //            GetStatus("M12.2", new Action<object>((obj) =>

  298. //            {

  299. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)

  300. //                {

  301. //                    mORKS.FixedFlag = bools[0];

  302. //                }

  303. //            }));

  304. 

  305. //            GetStatus("M13.5", new Action<object>((obj) =>

  306. //            {

  307. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)

  308. //                {

  309. //                    mORKS.SiloInPlace = bools[0];

  310. //                }

  311. //            }));

  312. 

  313. //            GetStatus("M16.7", new Action<object>((obj) =>

  314. //            {

  315. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)

  316. //                {

  317. //                    mORKS.RobotTakeNoodleCom = bools[0];

  318. //                }

  319. //            }));

  320. 

  321. //            GetStatus("M17.4", new Action<object>((obj) =>

  322. //            {

  323. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 1)

  324. //                {

  325. //                    mORKS.RobotStatus = bools[0];

  326. //                }

  327. //            }));

  328. 

  329. //            GetStatus("M18.0", new Action<object>((obj) =>

  330. //            {

  331. //                if (obj is bool[] bools && bools.Length > 0 && bools.Length <= 5)

  332. //                {

  333. //                    mORKS.SmallBowlYesOrNoCheck = bools[0];

  334. //                    mORKS.LargeBowYesOrNoCheck = bools[1];

  335. //                    mORKS.TurntableLowPosition = bools[2];

  336. //                    mORKS.TurntableHighPosition = bools[3];

  337. //                    alarm.Supply2_LossBowl = !mORKS.SmallBowlYesOrNoCheck;

  338. //                    alarm.Supply1_LossBowl = !mORKS.LargeBowYesOrNoCheck;

  339. //                }

  340. //            }));

  341. 

  342. //            GetStatus("VW17", new Action<object>((obj) =>

  343. //            {

  344. //                if (obj is ushort[] ushorts && ushorts.Length > 0 && ushorts.Length <= 1)

  345. //                {

  346. //                    var tt = ushorts.UshortsToBytes(true).BytesToUshorts();

  347. 

  348. //                    for (byte i = 0; i < 6; i++)

  349. //                    {

  350. //                        if (RTrig.GetInstance($"CookNoodleCom{i + 1}").Start(tt[0].GetBitValue((byte)(i + 1))))

  351. //                        {

  352. //                            if (!string.IsNullOrEmpty(mORKS.CookNodelId[i]))

  353. //                                mORKS.CookNoodleCom[i] = true;

  354. //                        }

  355. //                    }

  356. 

  357. //                    //mORKS.CookNoodleCom[0] = tt[0].GetBitValue(1);

  358. //                    //mORKS.CookNoodleCom[1] = tt[0].GetBitValue(2);

  359. //                    //mORKS.CookNoodleCom[2] = tt[0].GetBitValue(3);

  360. //                    //mORKS.CookNoodleCom[3] = tt[0].GetBitValue(4);

  361. //                    //mORKS.CookNoodleCom[4] = tt[0].GetBitValue(5);

  362. //                    //mORKS.CookNoodleCom[5] = tt[0].GetBitValue(6);

  363. //                    mORKS.Heating = ushorts[0].GetBitValue(15);

  364. //                    mORKS.TemperatureReaches = ushorts[0].GetBitValue(16);

  365. 

  366. //                    alarm.MachineLowTemperature = !mORKS.TemperatureReaches;

  367. //                }

  368. 

  369. //            }));

  370. 

  371. //            GetStatus("VW770", new Action<object>((obj) =>

  372. //            {

  373. //                if (obj is ushort[] ushorts && ushorts.Length > 0 && ushorts.Length <= 1)

  374. //                {

  375. //                    mORKS.CurrentFeedbackLoc = ushorts[0];

  376. //                }

  377. 

  378. //            }));

  379. 

  380. //            mORKS.TakeBowlTaskCount = mORKS.TakeBowlTask.Count;

  381. //            mORKS.RBTakeNoodleTaskCount = mORKS.RBTakeNoodleTask.Count;

  382. 

  383. //            for (int i = 0; i < Json<MorksPar>.Data.parSets.Count; i++)

  384. //            {

  385. //                mORKS.nsm.ElementAt(i).IsShield = Json<MorksPar>.Data.parSets.ElementAt(i).IsShield;

  386. //                mORKS.nsm.ElementAt(i).NoodleCookerStatus = mORKS.NoodleCookerStatus[i];

  387. //            }

  388. 

  389. //        }

  390. 

  391. //        /// <summary>

  392. //        /// 数据解析

  393. //        /// </summary>

  394. //        private void DataParse()

  395. //        {

  396. //            EventBus.GetInstance().Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)

  397. //             {

  398. //                 if (@event == null) return;

  399. //                 if (@event is DoOrderEvent order)

  400. //                 {

  401. //                     mORKS.doOrderEvents.Add(order);

  402. //                     //mORKS.doe.TryAdd(order.MorkOrder.SuborderId, order);

  403. //                     if (order.MorkOrder.GoodBatchings == null) return;

  404. //                     if (mORKS.HistorySuborderId.Contains(order.MorkOrder.SuborderId)) return;

  405. //                     OrderCount++;

  406. //                     if (DateTime.Now.Subtract(Json<OrderStatistics>.Data.StatisticsTime).Days != 0)

  407. //                         Json<OrderStatistics>.Data.Count = 0;

  408. //                     Json<OrderStatistics>.Data.StatisticsTime = DateTime.Now;

  409. //                     Json<OrderStatistics>.Data.Count++;

  410. //                     Json<OrderStatistics>.Save();

  411. //                     OrderChange(order.MorkOrder.SuborderId, ORDER_STATUS.WAIT);

  412. //                     DeviceProcessLogShow($"接收到{OrderCount}次订单，订单ID：{order.MorkOrder.SuborderId}");

  413. //                     mORKS.HistorySuborderId.Add(order.MorkOrder.SuborderId);

  414. //                     foreach (var item in order.MorkOrder.GoodBatchings)

  415. //                     {

  416. //                         var res = orderMaterialDelivery?.BatchingInfo?.FirstOrDefault(p => p.BatchingId == item.BatchingId);

  417. //                         if (res != null)

  418. //                         {

  419. //                             if (ushort.TryParse(res.BatchingLoc, out ushort loc))

  420. //                             {

  421. //                                 if (loc >= 1 && loc <= 5)

  422. //                                 {

  423. //                                     if (mORKS.RBTakeNoodleTask.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)

  424. //                                         mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo()

  425. //                                         {

  426. //                                             GoodName = order.MorkOrder.GoodsName,

  427. //                                             Loc = ushort.Parse(res.BatchingLoc),

  428. //                                             SuborderId = order.MorkOrder.SuborderId,

  429. //                                             SortNum = order.MorkOrder.SortNum,

  430. //                                             BatchingId = res.BatchingId

  431. //                                         });

  432. //                                 }

  433. //                                 else if (loc >= 10 && loc <= 11)

  434. //                                 {

  435. //                                     int index = 0;

  436. //                                     if (recipeBoms != null)

  437. //                                     {

  438. //                                         index = Array.FindIndex(recipeBoms.RecipeIds?.ToArray(), p => p.RecipeId == order.MorkOrder.RecipeId);

  439. //                                         index++;

  440. //                                     }

  441. //                                     if (mORKS.TakeBowlTask.FirstOrDefault(p => p.SuborderId == order.MorkOrder.SuborderId) == null)

  442. //                                         mORKS.TakeBowlTask.Enqueue(new OrderLocInfo()

  443. //                                         {

  444. //                                             BatchingId = res.BatchingId,

  445. //                                             GoodName = order.MorkOrder.GoodsName,

  446. //                                             Loc = ushort.Parse(res.BatchingLoc),

  447. //                                             SuborderId = order.MorkOrder.SuborderId,

  448. //                                             SortNum = order.MorkOrder.SortNum,

  449. //                                             RecipeNumber = (index >= 1 && index <= 10) ? (ushort)index : (ushort)0

  450. //                                         });

  451. //                                 }

  452. //                             }

  453. //                         }

  454. //                     }

  455. //                 }

  456. //             });

  457. //        }

  458. 

  459. //        public override void MainTask()

  460. //        {

  461. //            mORKS.AllowRun = mORKS.InitComplete;

  462. //            if (Json<KeepDataBase>.Data.IsVerify)

  463. //                IsHealth = mORKS.InitComplete;

  464. //            else

  465. //                IsHealth = true;

  466. 

  467. //            TakeBowlTask();

  468. 

  469. //            TakeNoodleTask();

  470. 

  471. //            OutNoodleTask();

  472. 

  473. //            SingleDetect();

  474. 

  475. //            TurntableControl();

  476. //        }

  477. 

  478. //        private void BowlControl(OrderLocInfo orderLocInfo)

  479. //        {

  480. //            if (orderLocInfo.Loc >= 10 && orderLocInfo.Loc <= 11)

  481. //            {

  482. //                mORKS.TakeBowlId = orderLocInfo.SuborderId;

  483. //                mORKS.TakeBowName = orderLocInfo.GoodName;

  484. //                mORKS.TakeBowSortNum = orderLocInfo.SortNum;

  485. //                TakeBowlControl(orderLocInfo.Loc);

  486. //                OrderChange(mORKS.TakeBowlId, ORDER_STATUS.COOKING);

  487. //                DeviceProcessLogShow($"订单【{mORKS.TakeBowlId}】执行取碗控制,位置:[{orderLocInfo.Loc}]");

  488. //                mORKS.TakeBowlInterlock = true;

  489. //            }

  490. //        }

  491. 

  492. //        /// <summary>

  493. //        /// 取碗控制

  494. //        /// </summary>

  495. //        private void TakeBowlTask()

  496. //        {

  497. //            if (mORKS.AllowRun && mORKS.TakeBowlTask.Count > 0 && !mORKS.DropBowlMechanismStatus && !mORKS.TakeBowlInterlock)

  498. //            {

  499. //                ushort BowLoc = 0;

  500. //                var res = orderMaterialDelivery?.BatchingInfo?.Where(p => p.BatchingId == mORKS.TakeBowlTask.ElementAt(0).BatchingId).ToList();

  501. //                if (res == null || res?.Count == 0)

  502. //                {

  503. //                    if (mORKS.TakeBowlTask.TryDequeue(out OrderLocInfo orderLocInfo)) BowlControl(orderLocInfo);

  504. //                }

  505. //                else

  506. //                {

  507. //                    foreach (var item in res)

  508. //                    {

  509. //                        if (ushort.TryParse(item.BatchingLoc, out ushort loc))

  510. //                        {

  511. //                            if (loc == 10 && mORKS.SmallBowlYesOrNoCheck)

  512. //                            {

  513. //                                BowLoc = loc;

  514. //                                break;

  515. //                            }

  516. //                            else if (loc == 11 && mORKS.LargeBowYesOrNoCheck)

  517. //                            {

  518. //                                BowLoc = loc;

  519. //                                break;

  520. //                            }

  521. //                        }

  522. //                    }

  523. 

  524. //                    if (BowLoc >= 10 && BowLoc <= 11)

  525. //                    {

  526. //                        if (mORKS.TakeBowlTask.TryDequeue(out OrderLocInfo orderLocInfo))

  527. //                        {

  528. //                            orderLocInfo.Loc = BowLoc;

  529. //                            BowlControl(orderLocInfo);

  530. //                        }

  531. //                    }

  532. //                }

  533. //            }

  534. //        }

  535. 

  536. //        /// <summary>

  537. //        /// 转台控制

  538. //        /// </summary>

  539. //        private void TurntableControl()

  540. //        {

  541. //            if (Global.EnableLocalSimOrder)

  542. //            {

  543. //                //不做轮询，直接取面，模拟订单使用

  544. //                if (mORKS.SiloInPlace && !mORKS.Feeding && mORKS.InitComplete && !mORKS.AllowTakeNoodle && mORKS.RBTakeNoodleTask.Count > 0)

  545. //                {

  546. //                    if (mORKS.TurntableLowPosition)

  547. //                    {

  548. //                        TurntableStart(mORKS.RBTakeNoodleTask.ElementAt(0).Loc);

  549. //                        mORKS.TurntableLocLists.Clear();

  550. //                        mORKS.AllowTakeNoodle = true;

  551. //                        DeviceProcessLogShow($"控制机器人去转台【{mORKS.RBTakeNoodleTask.ElementAt(0).Loc}】号位置取面");

  552. //                    }

  553. //                }

  554. //            }

  555. //            else

  556. //            {

  557. //                //正常轮询

  558. //                if (Delay.GetInstance("到位检测延时").Start(mORKS.SiloInPlace, 2))

  559. //                {

  560. //                    if (mORKS.SiloInPlace && !mORKS.Feeding && mORKS.InitComplete && !mORKS.AllowTakeNoodle && mORKS.RBTakeNoodleTask.Count > 0)

  561. //                    {

  562. 

  563. //                        var result = orderMaterialDelivery.BatchingInfo.Where(p => p.BatchingId == mORKS.RBTakeNoodleTask.ElementAt(0).BatchingId).ToList();

  564. //                        if (result != null)

  565. //                        {

  566. //                            var res = result.FirstOrDefault(P => P.BatchingLoc == mORKS.CurrentFeedbackLoc.ToString());

  567. //                            if (mORKS.TurntableLowPosition && res != null)

  568. //                            {

  569. //                                TurntableStart(mORKS.CurrentFeedbackLoc);

  570. //                                mORKS.TurntableLocLists.Clear();

  571. //                                mORKS.AllowTakeNoodle = true;

  572. //                                DeviceProcessLogShow($"控制机器人去转台【{mORKS.CurrentFeedbackLoc}】号位置取面");

  573. //                            }

  574. //                            else

  575. //                            {

  576. //                                if (!mORKS.TurntableInterlock)

  577. //                                {

  578. //                                    foreach (var item in result)

  579. //                                    {

  580. //                                        if (ushort.TryParse(item.BatchingLoc, out ushort loc))

  581. //                                        {

  582. //                                            if (mORKS.CurrentFeedbackLoc != loc && !mORKS.TurntableLocLists.Contains(loc))

  583. //                                            {

  584. //                                                if (!mORKS.TurntableLowPosition)

  585. //                                                {

  586. //                                                    DeviceProcessLogShow($"执行了转台启动互锁信号复位");

  587. //                                                }

  588. //                                                TurntableStart(loc);

  589. //                                                DeviceProcessLogShow($"没有物料检测的启动转台控制,转台位置：[{loc}]");

  590. //                                                break;

  591. //                                            }

  592. //                                            else if (mORKS.CurrentFeedbackLoc == loc && !mORKS.TurntableLocLists.Contains(loc)) mORKS.TurntableLocLists.Add(loc);

  593. //                                        }

  594. //                                    }

  595. //                                }

  596. //                            }

  597. //                        }

  598. //                        else DeviceProcessLogShow("未找到可用的物料信息");

  599. //                    }

  600. //                }

  601. //            }

  602. 

  603. //            //补料中检测

  604. //            if (RTrig.GetInstance("mORKS.Feeding").Start(mORKS.Feeding))

  605. //            {

  606. //                mORKS.AllowTakeNoodle = false;

  607. //                mORKS.TakeNoodleInterlock = false;

  608. //            }

  609. 

  610. //            //转台到位检测

  611. //            if (RTrig.GetInstance("TurntableInPlace").Start(mORKS.SiloInPlace && mORKS.CurrentLoc == mORKS.CurrentFeedbackLoc))

  612. //            {

  613. 

  614. //                mORKS.TurntableInterlock = false;

  615. //                DeviceProcessLogShow("转台到位检测");

  616. //            }

  617. 

  618. //            //补料完成检测

  619. //            if (RTrig.GetInstance("FeedComplete").Start(mORKS.FeedComplete))

  620. //            {

  621. //                if (!mORKS.AllowTakeNoodle && mORKS.TurntableLocLists.Count > 0)

  622. //                {

  623. //                    mORKS.TurntableLocLists.Clear();

  624. //                    mORKS.TurntableInterlock = false;

  625. //                    DeviceProcessLogShow("补料完成检测");

  626. //                }

  627. //            }

  628. 

  629. //        }

  630. 

  631. //        /// <summary>

  632. //        /// 取面任务

  633. //        /// </summary>

  634. //        private void TakeNoodleTask()

  635. //        {

  636. //            //取面控制

  637. //            if (mORKS.AllowRun && mORKS.RobotStatus && !mORKS.Feeding && !mORKS.RobotTaskInterlock && mORKS.AllowTakeNoodle && mORKS.SiloInPlace && !mORKS.TakeNoodleInterlock && mORKS.RBTakeNoodleTask.Count > 0)

  638. //            {

  639. //                if (mORKS.CurrentLoc == mORKS.CurrentFeedbackLoc)

  640. //                {

  641. //                    //int loc = Array.FindIndex(mORKS.NoodleCookerStatus, p => p == false);//查找煮面炉空闲位置

  642. //                    int loc = mORKS.nsm.ToList().FindIndex(p => p.NoodleCookerStatus == false && p.IsShield == false);//查找煮面炉空闲位置

  643. //                    if (loc >= 0 && loc <= 5)

  644. //                    {

  645. //                        //if (!Json<MorksPar>.Data.parSets.ElementAt(loc).IsShield)//检查该煮面篮是否被屏蔽

  646. //                        //{

  647. //                        if (mORKS.RBTakeNoodleTask.TryDequeue(out OrderLocInfo orderLocInfo))

  648. //                        {

  649. //                            //写入煮面时间

  650. //                            //List<ushort> values = new List<ushort>();

  651. //                            //values.Add(Json<MorksPar>.Data.parSets.ElementAt(loc).Minute);

  652. //                            //values.Add(Json<MorksPar>.Data.parSets.ElementAt(loc).Second);

  653. //                            //WriteData($"VW{324 + (loc * 4)}", values.ToArray());

  654. //                            if (mORKS.CurrentFeedbackLoc >= 1 && mORKS.CurrentFeedbackLoc <= 5) {

  655. //                                var x = Json<MorksPar>.Data.DishLibraryParSets.FirstOrDefault(p => p.TextBlockContext == mORKS.CurrentFeedbackLoc.ToString());

  656. //                                if (x != null) {

  657. //                                    List<ushort> values = new List<ushort>();

  658. //                                    values.Add(x.Minute);

  659. //                                    values.Add(x.Second);

  660. //                                    WriteData($"VW{324 + (loc * 4)}", values.ToArray());

  661. //                                    DeviceProcessLogShow($"转盘位置[{mORKS.CurrentFeedbackLoc}]：写入煮面时间{x.Minute}分{x.Second}秒。");

  662. //                                }

  663. //                            }

  664. 

  665. //                            mORKS.CurrentLoc = 0;

  666. //                            mORKS.CookNodelId[loc] = orderLocInfo.SuborderId;

  667. //                            mORKS.NoodleCookerStatus[loc] = true;

  668. //                            SetFallNoodleLoc((ushort)(loc + 1));

  669. //                            //机器人开始取面

  670. //                            OrderChange(orderLocInfo.SuborderId, ORDER_STATUS.COOKING);

  671. //                            DeviceProcessLogShow($"订单【{orderLocInfo.SuborderId}】,机器人倒面至【{loc + 1}】号煮面栏");

  672. 

  673. //                            mORKS.TakeNoodleInterlock = true;

  674. //                        }

  675. //                    }

  676. //                }

  677. //            }

  678. //        }

  679. 

  680. //        /// <summary>

  681. //        /// 出餐控制

  682. //        /// </summary>

  683. //        private void OutNoodleTask()

  684. //        {

  685. //            if (mORKS.AllowInvertedFace && mORKS.RobotTaskInterlock && !mORKS.TakeNoodleInterlock && mORKS.RobotStatus)

  686. //            {

  687. //                int loc = Array.FindIndex(mORKS.CookNodelId, p => p == mORKS.IngredientsCompleteId && p.Length > 0);

  688. //                if (loc >= 0 && loc <= 5)

  689. //                {

  690. //                    if (mORKS.CookNoodleCom[loc])

  691. //                    {

  692. //                        SetTakeNoodleLoc((ushort)(loc + 1));

  693. //                        mORKS.NoodleCookerStatus[loc] = false;

  694. //                        WriteData($"VW260", (ushort)0);//设置出汤时间

  695. //                        OrderChange(mORKS.IngredientsCompleteId, ORDER_STATUS.COMPLETED_COOK);

  696. //                        DeviceProcessLogShow($"订单【{mORKS.IngredientsCompleteId}】制作完成");

  697. //                        mORKS.CookCompleteFlatBit = true;

  698. //                        mORKS.OutMealId = mORKS.IngredientsCompleteId;

  699. //                        mORKS.OutMealName = mORKS.IngredientsCompleteName;

  700. //                        mORKS.OutMealSortNum = mORKS.IngredientsCompleteSortNum;

  701. //                        mORKS.IngredientsCompleteId = string.Empty;

  702. //                        mORKS.CookNodelId[loc] = string.Empty;

  703. //                        DeviceProcessLogShow($"{loc + 1} 号位置出餐控制,订单ID：{mORKS.OutMealId}");

  704. //                        mORKS.CookNoodleCom[loc] = false;

  705. //                    }

  706. //                }

  707. //            }

  708. //        }

  709. 

  710. //        /// <summary>

  711. //        /// 信号检测

  712. //        /// </summary>

  713. //        private void SingleDetect()

  714. //        {

  715. //            //允许倒面信号检测

  716. //            if (RTrig.GetInstance("AllowFallNoodle").Start(mORKS.AllowInvertedFace))

  717. //            {

  718. //                mORKS.IngredientsCompleteId = mORKS.TakeBowlId;

  719. //                mORKS.IngredientsCompleteName = mORKS.TakeBowName;

  720. //                mORKS.IngredientsCompleteSortNum = mORKS.TakeBowSortNum;

  721. //                mORKS.TakeBowSortNum = 0;

  722. //                mORKS.TakeBowlId = string.Empty;

  723. //                mORKS.TakeBowName = string.Empty;

  724. //                DeviceProcessLogShow($"碗到位，允许到面,{mORKS.IngredientsCompleteId}");

  725. //                mORKS.TakeBowlInterlock = false;

  726. //            }

  727. 

  728. //            //取餐完成逻辑处理

  729. //            if (RTrig.GetInstance("CompleteChange1").Start(mORKS.DiningComplete) && mORKS.CookCompleteFlatBit == true)

  730. //            {

  731. //                OrderChange(mORKS.OutMealId, ORDER_STATUS.COMPLETED_TAKE);

  732. //                DeviceProcessLogShow($"订单【{mORKS.OutMealId}】取餐完成");

  733. //                WriteData("M10.1", false);

  734. //                DeviceProcessLogShow($"出餐订单序号【{mORKS.OutMealSortNum}】");

  735. //                VoiceAPI.Speak(mORKS.OutMealSortNum.ToString());

  736. //                //DeviceProcessLogShow($"叫号系统通知主题【MORKS/VoiceCall/{DeviceId}】");

  737. //                //Plugin.GetInstance().GetPlugin<MQTTMgr>().Publish($"MORKS/VoiceCall/{DeviceId}", mORKS.OutMealSortNum.ToString());

  738. //                mORKS.CookCompleteFlatBit = false;

  739. //                mORKS.OutMealId = string.Empty;

  740. //                mORKS.OutMealName = string.Empty;

  741. //                mORKS.OutMealSortNum = 0;

  742. //            }

  743. 

  744. //            //机器人取面完成信号检测

  745. //            if (RTrig.GetInstance("TakeNoodleComplete").Start(mORKS.RobotTakeNoodleCom))

  746. //            {

  747. //                mORKS.TakeNoodleInterlock = false;

  748. //                mORKS.AllowTakeNoodle = false;

  749. //                mORKS.TurntableInterlock = false;

  750. //                DeviceProcessLogShow("机器人取面完成信号检测");

  751. //            }

  752. 

  753. //            int OutMealRequstCount = mORKS.CookNoodleCom.Where(p => p == true).ToList().Count;

  754. //            //int mlCount = mORKS.NoodleCookerStatus.Where(p => p == true).ToList().Count - Json<MorksPar>.Data.parSets.Where(x => x.IsShield == true).ToList().Count;

  755. //            int mlCount = mORKS.nsm.Where(p => p.NoodleCookerStatus == true && p.IsShield == false).ToList().Count;

  756. //            int index = Array.FindIndex(mORKS.CookNodelId, p => p == mORKS.IngredientsCompleteId);

  757. 

  758. //            bool isok = index >= 0 && index < mORKS.CookNoodleCom.Length && mORKS.CookNoodleCom[index];

  759. 

  760. //            mORKS.PriorityJudgment = Delay.GetInstance("取餐优先级判断").Start(mORKS.TurntableLocLists.Count > 0 && !mORKS.TurntableLowPosition, 4);

  761. //            //mORKS.RobotTaskInterlock = OutMealRequstCount > 0 && mORKS.AllowInvertedFace && (mlCount >= 2 || mORKS.RBTakeNoodleTask.Count == 0 || mORKS.PriorityJudgment);

  762. //            mORKS.RobotTaskInterlock = isok && mORKS.AllowInvertedFace && (mlCount >= 2 || mORKS.RBTakeNoodleTask.Count == 0 || mORKS.PriorityJudgment);

  763. 

  764. 

  765. //        }

  766. //        /// <summary>

  767. //        /// 语音提醒取餐

  768. //        /// </summary>

  769. //        /// <param name="meal"></param>

  770. //        private void WaitMeaLSpeak(string meal)

  771. //        {

  772. //            //VoiceAPI.m_SystemPlayWav(@"Vioce\电子提示音.wav");

  773. //            //Thread.Sleep(1000);

  774. //            //if (meal != null) mORKS.speech.Speak(meal);

  775. //            //VoiceAPI.m_SystemPlayWav(@"Vioce\取餐通知.wav");

  776. //        }

  777. 

  778. //        #region PLC 控制函数

  779. 

  780. //        private void WriteData(string address, object value)

  781. //        {

  782. //            EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });

  783. //        }

  784. 

  785. //        /// <summary>

  786. //        /// 设备初始化

  787. //        /// </summary>

  788. //        public async void DeviceInit()

  789. //        {

  790. //            WriteData("M0.0", true);

  791. //            await Task.Delay(1000);

  792. //            WriteData("M0.0", false);

  793. //        }

  794. 

  795. //        /// <summary>

  796. //        /// 取碗控制

  797. //        /// </summary>

  798. //        /// <param name="loc"></param>

  799. //        private void TakeBowlControl(ushort loc)

  800. //        {

  801. //            if (loc == 10)//一次性碗

  802. //            {

  803. //                WriteData("M9.1", true);

  804. //            }

  805. //            else if (loc == 11)//大碗

  806. //            {

  807. //                WriteData("M9.0", true);

  808. //            }

  809. //        }

  810. 

  811. //        /// <summary>

  812. //        /// 启动转台

  813. //        /// </summary>

  814. //        /// <param name="loc"></param>

  815. //        private void TurntableStart(ushort loc)

  816. //        {

  817. //            if (loc >= 1 && loc <= 5)

  818. //            {

  819. //                mORKS.CurrentLoc = loc;

  820. //                mORKS.TurntableInterlock = true;

  821. //                mORKS.TurntableLocLists.Add(loc);

  822. //                WriteData($"M13.{loc - 1}", true);

  823. //            }

  824. //        }

  825. 

  826. //        /// <summary>

  827. //        /// 设置倒面位置

  828. //        /// </summary>

  829. //        /// <param name="loc"></param>

  830. //        private void SetFallNoodleLoc(ushort loc)

  831. //        {

  832. //            if (loc >= 1 && loc <= 6)

  833. //                WriteData($"M14.{loc - 1}", true);

  834. //        }

  835. 

  836. //        /// <summary>

  837. //        /// 设置取面位置

  838. //        /// </summary>

  839. //        /// <param name="loc"></param>

  840. //        private void SetTakeNoodleLoc(ushort loc)

  841. //        {

  842. //            if (loc >= 1 && loc <= 6)

  843. //                WriteData($"M15.{loc - 1}", true);

  844. //        }

  845. 

  846. 

  847. 

  848. //        public override void SimOrder()

  849. //        {

  850. //            EventBus.GetInstance().Subscribe<MorksSimorderModel>(0, delegate (IEvent @event, EventCallBackHandle callBackHandle)

  851. //            {

  852. //                if (@event != null && @event is MorksSimorderModel msm)

  853. //                {

  854. //                    string guid = Guid.NewGuid().ToString();

  855. //                    if (msm.NoodleLoc >= 1 && msm.NoodleLoc <= 5)

  856. //                    {

  857. //                        mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo() { Loc = (ushort)msm.NoodleLoc, SuborderId = guid });

  858. //                        MessageLog.GetInstance.Show($"添加订单：面条位置【{(ushort)msm.NoodleLoc}】");

  859. //                    }

  860. 

  861. //                    if (msm.Bowloc >= 10 && msm.Bowloc <= 11)

  862. //                    {

  863. //                        mORKS.TakeBowlTask.Enqueue(new OrderLocInfo() { Loc = (ushort)msm.Bowloc, SuborderId = guid });

  864. //                        MessageLog.GetInstance.Show($"添加订单：碗位置【{(ushort)msm.Bowloc}】");

  865. //                    }

  866. 

  867. //                }

  868. //            });

  869. //        }

  870. //        #endregion

  871. 

  872. 

  873. //    }

  874. //}