pry
/
HBLConsole
1
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.
72 Commits
1 Branch
5.1 MiB
 
 
Tree: 07a4f828d7
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '07a4f828d7'
${ noResults }
HBLConsole/HBLConsole.Business/Devices/MORKS.cs

619 lines
23 KiB
Raw Blame History 

  1. ////#define test

  2. //using BPA.Message;

  3. //using HBLConsole.Communication;

  4. //using HBLConsole.Factory;

  5. //using HBLConsole.Interface;

  6. //using HBLConsole.Model;

  7. //using HBLConsole.Service;

  8. //using System;

  9. //using System.Collections.Generic;

  10. //using System.Linq;

  11. //using System.Text;

  12. //using System.Threading;

  13. //using System.Threading.Tasks;

  14. //using BPA.Message.Enum;

  15. //using BPA.Models;

  16. 

  17. //namespace HBLConsole.Business.Devices

  18. //{

  19. //    public class MORKS : IControl

  20. //    {

  21. //        private volatile static MORKS _Instance;

  22. //        public static MORKS GetInstance => _Instance ?? (_Instance = new MORKS());

  23. //        private MORKS() { }

  24. 

  25. //        public GVL.MORKS mORKS { get; set; } = new GVL.MORKS();

  26. 

  27. //        public void Init()

  28. //        {

  29. //            //模拟订单

  30. //            SimOrder();

  31. //            Test();

  32. //        }

  33. 

  34. //        public void ConnectOk()

  35. //        {

  36. //            WriteRecipeBoms();

  37. //            ReadData();

  38. //            Main();

  39. //            //ResetProgram();

  40. //            MessageLog.GetInstance.Show("MORKS 设备初始化完成");

  41. //        }

  42. 

  43. //        /// <summary>

  44. //        /// 测试程序

  45. //        /// </summary>

  46. //        private void Test()

  47. //        {

  48. //#if test

  49. //            ThreadManagerment.GetInstance.StartLong(new Action(() =>

  50. //            {

  51. //                while (Json<MorkOrderPushPar>.GetInstance.Base.morkOrderPushes.Count > 0)

  52. //                {

  53. //                    var result = Json<MorkOrderPushPar>.GetInstance.Base.morkOrderPushes.ElementAt(0);

  54. 

  55. //                    SimpleFactory.GetInstance.OrderChanged(result.OrderPush.SuborderId, ORDER_STATUS.COOKING);

  56. //                    MessageLog.GetInstance.Show($"{result.OrderPush.GoodsName},{ORDER_STATUS.COOKING}");

  57. //                    Thread.Sleep(5000);

  58. 

  59. //                    SimpleFactory.GetInstance.OrderChanged(result.OrderPush.SuborderId, ORDER_STATUS.COMPLETED_COOK);

  60. //                    MessageLog.GetInstance.Show($"{result.OrderPush.GoodsName},{ORDER_STATUS.COMPLETED_COOK}");

  61. //                    Thread.Sleep(5000);

  62. 

  63. //                    SimpleFactory.GetInstance.OrderChanged(result.OrderPush.SuborderId, ORDER_STATUS.COMPLETED_TAKE);

  64. //                    MessageLog.GetInstance.Show($"{result.OrderPush.GoodsName},{ORDER_STATUS.COMPLETED_TAKE}");

  65. //                    Thread.Sleep(5000);

  66. 

  67. //                    Json<MorkOrderPushPar>.GetInstance.Base.morkOrderPushes.RemoveAt(0);

  68. //                }

  69. //                Thread.Sleep(500);

  70. //            }), "test");

  71. //#endif

  72. //        }

  73. 

  74. //        private void Readbool(ushort startAddress, ushort len, Action<bool[]> action)

  75. //        {

  76. //            object result;

  77. //            result = ModbusTcpHelper.GetInstance.Read(startAddress, ReadType.Coils, len);

  78. //            if (result != null)

  79. //            {

  80. //                if (result is bool[] bools)

  81. //                {

  82. //                    if (bools.Length == len)

  83. //                    {

  84. //                        action(bools);

  85. //                    }

  86. //                }

  87. //            }

  88. //        }

  89. 

  90. //        /// <summary>

  91. //        /// 复位程序

  92. //        /// </summary>

  93. //        private void ResetProgram()

  94. //        {

  95. //            ThreadManagerment.GetInstance.StartLong(new Action(() =>

  96. //            {

  97. //                if (RTrig.GetInstance("ResetProgram").Start(mORKS.DeviceIniting))

  98. //                {

  99. //                    ThreadManagerment.GetInstance.StopTask("MainTask", new Action(() =>

  100. //                     {

  101. //                         mORKS.AllowRun = false;

  102. //                         TakeBowlId = string.Empty;

  103. //                         IngredientsCompleteId = string.Empty;

  104. //                         CookNodelId = new string[6] { string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, };

  105. //                         mORKS.RobotTaskInterlock = false;

  106. //                         OutMealId = string.Empty;

  107. //                         mORKS.TakeBowlInterlock = false;

  108. //                         mORKS.TakeNoodleInterlock = false;

  109. //                         mORKS.OutNoodleing = false;

  110. //                         Main();

  111. //                     }));

  112. //                }

  113. //                Thread.Sleep(10);

  114. //            }), "ResetProgram");

  115. //        }

  116. 

  117. //        /// <summary>

  118. //        /// 数据读取

  119. //        /// </summary>

  120. //        public void ReadData()

  121. //        {

  122. //            ThreadManagerment.GetInstance.StartLong(new Action(() =>

  123. //            {

  124. //                Readbool(323, 3, new Action<bool[]>((bools) =>

  125. //                  {

  126. //                      mORKS.RobotTakeNoodle = bools[0];

  127. //                      mORKS.RobotOutMeal = bools[1];

  128. //                      mORKS.MoveTurntable = bools[2];

  129. //                  }));

  130. 

  131. //                Readbool(1120, 16, new Action<bool[]>((bools) =>

  132. //                {

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

  134. //                    mORKS.TakeBowlIdle = bools[1];

  135. //                    mORKS.TemperatureReached = bools[2];

  136. //                    mORKS.AllowFallNoodle = bools[3];

  137. //                    mORKS.RbTakeNoodleComplete = bools[4];

  138. //                    mORKS.RbFallNoodleComplete = bools[5];

  139. //                    mORKS.RbOutMealComplete = bools[6];

  140. //                    mORKS.RobotIdle = bools[7];

  141. //                    mORKS.TakeMealDetect = bools[8];

  142. //                    mORKS.MissingBowl = bools[9];

  143. //                    mORKS.DeviceIniting = bools[10];

  144. //                    mORKS.TurntableLowerLimit = bools[11];

  145. //                    mORKS.MissingBowlSignal2 = bools[12];

  146. //                    mORKS.TurntableUpLimit = bools[13];

  147. //                    mORKS.TurntableMoveInPlace = bools[15];

  148. //                }));

  149. 

  150. //                Readbool(1136, 6, new Action<bool[]>((bools) =>

  151. //                {

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

  153. //                    {

  154. //                        mORKS.NoodleCookerStatus[i] = bools[i];

  155. //                    }

  156. //                }));

  157. 

  158. //                Readbool(1144, 6, new Action<bool[]>((bools) =>

  159. //                {

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

  161. //                    {

  162. //                        mORKS.CookNoodlesComplete[i] = bools[i];

  163. //                    }

  164. //                }));

  165. 

  166. //                Thread.Sleep(500);

  167. //            }), "ReadPLCData");

  168. //        }

  169. 

  170. //        public ushort NoodleLoc { get; set; }

  171. //        public ushort BowlLoc { get; set; }

  172. //        public void SimOrder()

  173. //        {

  174. //            ActionManagerment.GetInstance.Register(new Action<object>((o) =>

  175. //            {

  176. //                if (o != null)

  177. //                {

  178. //                    if (o is SimOrderData simOrderData)

  179. //                    {

  180. //                        string subId = Guid.NewGuid().ToString();

  181. //                        if (simOrderData.NoodleIsEnableRandom)

  182. //                            NoodleLoc = (ushort)(new Random().Next(1, 6));

  183. //                        else

  184. //                            NoodleLoc = (ushort)simOrderData.NoodleLoc;

  185. 

  186. 

  187. //                        if (simOrderData.BowlIsEnableRandom)

  188. //                            BowlLoc = (ushort)(new Random().Next(10, 12));

  189. //                        else

  190. //                            BowlLoc = (ushort)simOrderData.BowlLoc;

  191. //                        mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo() { Loc = NoodleLoc, SuborderId = subId });

  192. //                        mORKS.TakeBowlTask.Enqueue(new OrderLocInfo() { Loc = BowlLoc, SuborderId = subId });

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

  194. //                    }

  195. //                }

  196. //            }), "SimOrder");

  197. //        }

  198. 

  199. //        /// <summary>

  200. //        /// 数据解析

  201. //        /// </summary>

  202. //        public void DataParse<T>(T order)

  203. //        {

  204. //            if (order is MorkOrderPush morkOrderPush)

  205. //            {

  206. //                foreach (var item in morkOrderPush.GoodBatchings)

  207. //                {

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

  209. //                    if (res != null)

  210. //                    {

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

  212. //                        {

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

  214. //                            {

  215. //                                mORKS.RBTakeNoodleTask.Enqueue(new OrderLocInfo() { Loc = loc, SuborderId = morkOrderPush.SuborderId, BatchingId = res.BatchingId });

  216. //                            }

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

  218. //                            {

  219. //                                int index = Array.FindIndex(Json<BatchingInfoPar>.Data.recipeBoms.RecipeIds.ToArray(), p => p.RecipeId == morkOrderPush.RecipeId);

  220. //                                index++;

  221. //                                mORKS.TakeBowlTask.Enqueue(new OrderLocInfo() { Loc = loc, SuborderId = morkOrderPush.SuborderId, RecipeNumber = (index >= 1 && index <= 10) ? (ushort)index : (ushort)0 });

  222. //                            }

  223. //                        }

  224. //                    }

  225. //                }

  226. //            }

  227. //        }

  228. 

  229. //        #region 临时变量

  230. //        /// <summary>

  231. //        /// 取碗订单ID

  232. //        /// </summary>

  233. //        string TakeBowlId = string.Empty;

  234. 

  235. //        /// <summary>

  236. //        /// 配料完成订单ID

  237. //        /// </summary>

  238. //        string IngredientsCompleteId = string.Empty;

  239. 

  240. //        /// <summary>

  241. //        /// 煮面口对应的订单ID

  242. //        /// </summary>

  243. //        string[] CookNodelId = new string[6] { string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty, };

  244. 

  245. //        /// <summary>

  246. //        /// 出餐订单ID

  247. //        /// </summary>

  248. //        string OutMealId = string.Empty;

  249. 

  250. //        /// <summary>

  251. //        /// 转台位置轮询

  252. //        /// </summary>

  253. //        List<ushort> TurntableLoc = new List<ushort>();

  254. 

  255. //        #endregion

  256. 

  257. //        public void Main()

  258. //        {

  259. //            ThreadManagerment.GetInstance.StartLong(new Action(() =>

  260. //            {

  261. //                mORKS.AllowRun = mORKS.InitComplete && !mORKS.TemperatureReached;

  262. 

  263. //                TakeBowlTask();

  264. 

  265. //                TakeNoodleTask();

  266. 

  267. //                OutNoodleTask();

  268. 

  269. //                SingleDetect();

  270. 

  271. //                TurntableControl();

  272. 

  273. //                Thread.Sleep(100);

  274. 

  275. //            }), "MainTask");

  276. //        }

  277. 

  278. //        /// <summary>

  279. //        /// 取碗控制

  280. //        /// </summary>

  281. //        private void TakeBowlTask()

  282. //        {

  283. //            if (mORKS.AllowRun && mORKS.TakeBowlTask.Count > 0 && !mORKS.TakeBowlIdle && !mORKS.TakeBowlInterlock)

  284. //            {

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

  286. //                {

  287. //                    TakeBowlId = orderLocInfo.SuborderId;

  288. //                    TakeBowlControl(orderLocInfo.Loc);

  289. //                    SetRecipeNumber(orderLocInfo.RecipeNumber);

  290. //                    SimpleFactory.GetInstance.OrderChanged(TakeBowlId, ORDER_STATUS.COOKING);

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

  292. //                }

  293. //                mORKS.TakeBowlInterlock = true;

  294. //            }

  295. //        }

  296. 

  297. //        /// <summary>

  298. //        /// 转台控制

  299. //        /// </summary>

  300. //        private void TurntableControl()

  301. //        {

  302. //            if (mORKS.TurntableMoveInPlace && mORKS.InitComplete && !mORKS.AllowTakeNoodle && mORKS.RBTakeNoodleTask.Count > 0)

  303. //            {

  304. 

  305. //                if (mORKS.TurntableLowerLimit)

  306. //                {

  307. //                    SetTurntableLoc(mORKS.RBTakeNoodleTask.ElementAt(0).Loc);

  308. //                    MoveTurntable();

  309. //                    mORKS.AllowTakeNoodle = true;

  310. //                    TurntableLoc.Clear();

  311. //                    MessageLog.GetInstance.Show("转台位置OK");

  312. //                }

  313. //                else

  314. //                {

  315. 

  316. //                    if (!mORKS.TurntableInterlock)

  317. //                    {

  318. //                        var result = Json<BatchingInfoPar>.Data.orderMaterialDelivery.BatchingInfo.Where(p => p.BatchingId == mORKS.RBTakeNoodleTask.ElementAt(0).BatchingId).ToList();

  319. //                        if (result != null)

  320. //                        {

  321. //                            foreach (var item in result)

  322. //                            {

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

  324. //                                {

  325. //                                    if (TurntableLoc.Contains(loc))

  326. //                                    {

  327. //                                        SetTurntableLoc(loc);

  328. //                                        MoveTurntable();

  329. //                                        mORKS.TurntableInterlock = true;

  330. //                                        TurntableLoc.Add(loc);

  331. //                                        return;

  332. //                                    }

  333. //                                }

  334. //                            }

  335. //                            MessageLog.GetInstance.Show("转台位置缺少物料");

  336. //                        }

  337. //                    }

  338. //                }

  339. //            }

  340. //        }

  341. 

  342. //        /// <summary>

  343. //        /// 取面任务

  344. //        /// </summary>

  345. //        private void TakeNoodleTask()

  346. //        {

  347. //            //取面控制

  348. //            if (mORKS.AllowRun && mORKS.RobotIdle && !mORKS.RobotTaskInterlock && mORKS.AllowTakeNoodle && mORKS.TurntableMoveInPlace && !mORKS.TakeNoodleInterlock && !mORKS.OutNoodleing && mORKS.RBTakeNoodleTask.Count > 0)

  349. //            {

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

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

  352. //                {

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

  354. //                    {

  355. //                        //设置转台位置

  356. //                        SetTurntableLoc(orderLocInfo.Loc);

  357. //                        //设置倒面位置

  358. 

  359. //                        CookNodelId[loc] = orderLocInfo.SuborderId;

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

  361. 

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

  363. //                        RobotTakeNoodle();

  364. //                        SimpleFactory.GetInstance.OrderChanged(orderLocInfo.SuborderId, ORDER_STATUS.COOKING);

  365. //                        MessageLog.GetInstance.Show($"订单【{orderLocInfo.SuborderId}】,转台:[{orderLocInfo}],煮面栏：[{loc + 1}]");

  366. //                        mORKS.TakeNoodleInterlock = true;

  367. //                    }

  368. //                }

  369. 

  370. //            }

  371. //        }

  372. 

  373. //        /// <summary>

  374. //        /// 出餐控制

  375. //        /// </summary>

  376. //        private void OutNoodleTask()

  377. //        {

  378. //            if (mORKS.AllowFallNoodle && mORKS.RobotTaskInterlock && !mORKS.TakeNoodleInterlock && mORKS.RobotIdle && !mORKS.TakeMealDetect)

  379. //            {

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

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

  382. //                {

  383. //                    if (mORKS.CookNoodlesComplete[loc])

  384. //                    {

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

  386. //                        RobotOutMeal();

  387. //                        CookNoodleStatusReset((ushort)(loc + 1));

  388. //                        ResetAllowFallNoodle();

  389. //                        OutMealId = IngredientsCompleteId;

  390. //                        IngredientsCompleteId = string.Empty;

  391. //                        CookNodelId[loc] = string.Empty;

  392. //                        MessageLog.GetInstance.Show($"{loc + 1}号位置出餐控制");

  393. //                        mORKS.OutNoodleing = true;

  394. //                    }

  395. //                }

  396. //            }

  397. //        }

  398. 

  399. //        /// <summary>

  400. //        /// 信号检测

  401. //        /// </summary>

  402. //        private void SingleDetect()

  403. //        {

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

  405. //            if (RTrig.GetInstance("AllowFallNoodle").Start(mORKS.AllowFallNoodle))

  406. //            {

  407. //                IngredientsCompleteId = TakeBowlId;

  408. //                TakeBowlId = string.Empty;

  409. //                MessageLog.GetInstance.Show($"允许到面,{IngredientsCompleteId}");

  410. //                mORKS.TakeBowlInterlock = false;

  411. //            }

  412. 

  413. //            //出餐完成信号检测

  414. //            if (RTrig.GetInstance("CompleteChange").Start(mORKS.RbOutMealComplete))

  415. //            {

  416. //                SimpleFactory.GetInstance.OrderChanged(OutMealId, ORDER_STATUS.COMPLETED_COOK);

  417. //                MessageLog.GetInstance.Show($"订单【{OutMealId}】制作完成");

  418. //                mORKS.OutNoodleing = false;

  419. //            }

  420. 

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

  422. //            if (DelayRTrig.GetInstance("CompleteChange1").Start(mORKS.RbOutMealComplete && !mORKS.TakeMealDetect, 2))

  423. //            {

  424. //                SimpleFactory.GetInstance.OrderChanged(OutMealId, ORDER_STATUS.COMPLETED_TAKE);

  425. //                MessageLog.GetInstance.Show($"订单【{OutMealId}】取餐完成");

  426. //                var RemoveItem = Json<MorkOrderPushPar>.Data.morkOrderPushes.FirstOrDefault(p => p.OrderPush.SuborderId == OutMealId);

  427. //                if (RemoveItem != null)

  428. //                {

  429. //                    Json<MorkOrderPushPar>.Data.morkOrderPushes.Remove(RemoveItem);

  430. //                }

  431. //                ResetCookComplete();

  432. //                OutMealId = string.Empty;

  433. //            }

  434. 

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

  436. //            if (RTrig.GetInstance("TakeNoodleComplete").Start(mORKS.RbTakeNoodleComplete))

  437. //            {

  438. //                mORKS.TakeNoodleInterlock = false;

  439. //                mORKS.AllowTakeNoodle = false;

  440. //                MessageLog.GetInstance.Show("取面完成");

  441. //                TakeNoodleCompleteReset();

  442. //            }

  443. 

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

  445. //            if (RTrig.GetInstance("TurntableInPlace").Start(mORKS.TurntableMoveInPlace))

  446. //            {

  447. //                mORKS.TurntableInterlock = false;

  448. //            }

  449. 

  450. //            int OutMealRequstCount = mORKS.CookNoodlesComplete.Where(p => p == true).ToList().Count;

  451. //            int mlCount = mORKS.NoodleCookerStatus.Where(p => p == true).ToList().Count;

  452. //            mORKS.RobotTaskInterlock = OutMealRequstCount > 0 && mORKS.AllowFallNoodle && (mlCount >= 2 || mORKS.RBTakeNoodleTask.Count == 0);

  453. //        }

  454. 

  455. 

  456. //        #region PLC 控制函数

  457. 

  458. //        /// <summary>

  459. //        /// 写入配方数据到 PLC

  460. //        /// </summary>

  461. //        private void WriteRecipeBoms()

  462. //        {

  463. //            List<ushort> recipeBoms = new List<ushort>();

  464. //            foreach (var item in Json<BatchingInfoPar>.Data.recipeBoms.RecipeIds)

  465. //            {

  466. //                foreach (var rec in item.Recipes)

  467. //                {

  468. //                    recipeBoms.Add((ushort)rec);

  469. //                }

  470. //            }

  471. //            if (recipeBoms.Count > 0)

  472. //            {

  473. //                if (ModbusTcpHelper.GetInstance.Write(1100, WriteType.HoldingRegisters, recipeBoms.ToArray()))

  474. //                {

  475. //                    MessageLog.GetInstance.Show("成功写入配方数据");

  476. //                }

  477. //            }

  478. //        }

  479. 

  480. //        /// <summary>

  481. //        /// 转台移动

  482. //        /// </summary>

  483. //        private void MoveTurntable()

  484. //        {

  485. //            ModbusTcpHelper.GetInstance.Write(325, WriteType.Coils, true);

  486. //        }

  487. 

  488. //        /// <summary>

  489. //        /// 取面完成复位

  490. //        /// </summary>

  491. //        private void TakeNoodleCompleteReset()

  492. //        {

  493. //            ModbusTcpHelper.GetInstance.Write(1124, WriteType.Coils, false);

  494. //        }

  495. 

  496. //        /// <summary>

  497. //        /// 指定煮面口状态复位

  498. //        /// </summary>

  499. //        /// <param name="num"></param>

  500. //        private void CookNoodleStatusReset(int num)

  501. //        {

  502. //            if (num >= 1 && num <= 6)

  503. //            {

  504. //                ushort addRess = (ushort)(1136 + num - 1);

  505. //                ModbusTcpHelper.GetInstance.Write(addRess, WriteType.Coils, false);

  506. //                MessageLog.GetInstance.Show($"{num}号煮面口占用复位");

  507. //            }

  508. 

  509. //        }

  510. 

  511. //        /// <summary>

  512. //        /// 写配方编号

  513. //        /// </summary>

  514. //        /// <param name="num"></param>

  515. //        private void SetRecipeNumber(ushort num)

  516. //        {

  517. //            ModbusTcpHelper.GetInstance.Write(100, WriteType.HoldingRegisters, num);

  518. //        }

  519. 

  520. //        /// <summary>

  521. //        /// 设置转台位置

  522. //        /// </summary>

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

  524. //        private void SetTurntableLoc(ushort loc)

  525. //        {

  526. //            ModbusTcpHelper.GetInstance.Write(101, WriteType.HoldingRegisters, loc);

  527. //        }

  528. 

  529. //        /// <summary>

  530. //        /// 设置倒面位置

  531. //        /// </summary>

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

  533. //        private void SetFallNoodleLoc(ushort loc)

  534. //        {

  535. //            ModbusTcpHelper.GetInstance.Write(102, WriteType.HoldingRegisters, loc);

  536. //        }

  537. 

  538. //        /// <summary>

  539. //        /// 设置取面位置

  540. //        /// </summary>

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

  542. //        private void SetTakeNoodleLoc(ushort loc)

  543. //        {

  544. //            ModbusTcpHelper.GetInstance.Write(103, WriteType.HoldingRegisters, loc);

  545. //        }

  546. 

  547. //        /// <summary>

  548. //        /// 取碗控制

  549. //        /// </summary>

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

  551. //        private void TakeBowlControl(ushort loc)

  552. //        {

  553. //            if (loc == 10)

  554. //            {

  555. //                ModbusTcpHelper.GetInstance.Write(321, WriteType.Coils, true);

  556. //            }

  557. //            else if (loc == 11)

  558. //            {

  559. //                ModbusTcpHelper.GetInstance.Write(322, WriteType.Coils, true);

  560. //            }

  561. //        }

  562. 

  563. //        /// <summary>

  564. //        /// 机器人取面

  565. //        /// </summary>

  566. //        private void RobotTakeNoodle()

  567. //        {

  568. //            ModbusTcpHelper.GetInstance.Write(323, WriteType.Coils, true);

  569. //        }

  570. 

  571. //        /// <summary>

  572. //        /// 机器人取餐

  573. //        /// </summary>

  574. //        private void RobotOutMeal()

  575. //        {

  576. //            ModbusTcpHelper.GetInstance.Write(324, WriteType.Coils, true);

  577. //            var result = ModbusTcpHelper.GetInstance.Read(324, ReadType.Coils);

  578. //            if (result is bool res)

  579. //                while (!res)

  580. //                {

  581. //                    ModbusTcpHelper.GetInstance.Write(324, WriteType.Coils, true);

  582. //                }

  583. //        }

  584. 

  585. //        /// <summary>

  586. //        /// 制作完成信号复位

  587. //        /// </summary>

  588. //        private void ResetCookComplete()

  589. //        {

  590. //            ModbusTcpHelper.GetInstance.Write(1126, WriteType.Coils, false);

  591. //        }

  592. 

  593. //        /// <summary>

  594. //        /// 复位允许取面信号

  595. //        /// </summary>

  596. //        private void ResetAllowFallNoodle()

  597. //        {

  598. //            ModbusTcpHelper.GetInstance.Write(1123, WriteType.Coils, false);

  599. //        }

  600. 

  601. //        /// <summary>

  602. //        /// 设备初始化

  603. //        /// </summary>

  604. //        public async void DeviceInit()

  605. //        {

  606. //            ModbusTcpHelper.GetInstance.Write(320, WriteType.Coils, true);

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

  608. //            ModbusTcpHelper.GetInstance.Write(320, WriteType.Coils, false);

  609. 

  610. //        }

  611. //        #endregion

  612. 

  613. 

  614. 

  615. //    }

  616. 

  617. //}