BPASmartClient/BPASmartClient.MorkMW/Control_MorkMW.cs

using BPA.Helper;
using BPA.Message.Enum;
using BPA.Models;
using BPASmartClient.Device;

using BPASmartClient.Modbus;
using BPASmartClient.Model;
using BPASmartClient.Model.PLC;
using BPASmartClient.Model.����;
using BPASmartClient.Model.���ƻ�;
using BPASmartClient.MorkMW.Model;
using Newtonsoft.Json;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Linq;
using System.Net.Http.Json;
using System.Reflection;
using System.Threading;
using System.Windows.Documents;
using static BPA.Helper.EventBus;

namespace BPASmartClient.MorkMW
{
    public class Control_MorkMW : BaseDevice
    {
        int id = 0;
        ModbusTcp modbus;
        public override DeviceClientType DeviceType => DeviceClientType.MORKMW;
        GVL_MorkMW morkMW = new GVL_MorkMW();
        public override void DoMain()
        {
            Json<KeepDataBase>.Read();
            VaribleMonitorDis();
            ConnectKlpRobot("192.168.0.100", 8001);
            ServerInit();
            DataParse();
            TaskManage.GetInstance.StartLong(new Action(() => { VariableMonitor(); Thread.Sleep(5); }), "�����˱���״̬����߳�", true);
        }

        private void VaribleMonitorDis()
        {
            PropertyInfo[] pros = morkMW.GetType().GetProperties();
            foreach (var item in pros)
            {
                var res = item.GetCustomAttribute<VariblesAttribute>();
                if (res != null)
                {
                    GVL_MorkMW.varibleInfos.Add(new VaribleModel { Id = id + 1, VaribleName = res.VarName, RobotAddress = res.RobotAddress, ModbusAddress = res.ModbusTcpAddress, Notes = res.Notes });
                    id++;
                }
            }
        }

        private void ServerInit()
        {
            //�䷽������Ϣ
            EventBus.GetInstance.Subscribe<MorkMWGoodsEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBack)
            {
                if (@event == null) return;
                if (@event is MorkMWGoodsEvent recipe)
                {
                    listMorkMWGoods = recipe.morkMWPushMessage?.MorkMWGoods;
                    DeviceProcessLogShow($"���յ����ƻ���{listMorkMWGoods?.Count}������Ʒ�䷽����");
                }
            });
        }

        public override void MainTask()
        {
            if (Json<KeepDataBase>.Data.IsVerify)
                IsHealth = modbus.Connected;
            else
                IsHealth = true;//�����ϱ�
            ToGetWink();
            ToMixWink();
            ToPourWink();
            SignalDetect();
        }
        /// <summary>
        /// �Ӿƹ���
        /// </summary>
        public void ToGetWink()
        {
            if (!GVL_MorkMW.AllowLocalSimOrder)
            {
                if (morkMW.RobotIdle && orderLocInfos.Count > 0 && !morkMW.TaskLock && !morkMW.PourWinkComplete && morkMW.CupSignal && modbus.Connected)
                {
                    DeviceProcessLogShow("������ʼ����");
                    morkMW.TaskLock = true;
                    if (orderLocInfos.TryDequeue(out BPASmartClient.MorkMW.Model.OrderLocInfo res))
                    {
                        morkMW.CurrentSuborderId = res.SuborderId;
                        OrderChange(res.SuborderId, ORDER_STATUS.COOKING);
                        foreach (var item in res.mixWink)
                        {
                            switch (item.Loc)
                            {
                                // case 7: ToMixWink(); break;
                                case 1: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                                case 2: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                                case 3: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                                case 4: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                                case 5: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                                case 6: ToSpecifiedLocTakeWink(item.Loc, item.Qty); break;
                            }
                            switch (item.Loc)
                            {
                                //case 7: while (!morkMW.MixWinkComplte) { Thread.Sleep(5); } break;
                                case 1: while (!morkMW.TakeWinkOneComplete) { Thread.Sleep(5); } break;
                                case 2: while (!morkMW.TakeWinkTwoComplete) { Thread.Sleep(5); } break;
                                case 3: while (!morkMW.TakeWinkThreeComplete) { Thread.Sleep(5); } break;
                                case 4: while (!morkMW.TakeWinkFourComplete) { Thread.Sleep(5); } break;
                                case 5: while (!morkMW.TakeWinkFiveComplete) { Thread.Sleep(5); } break;
                                case 6: while (!morkMW.TakeWinkSixComplete) { Thread.Sleep(5); } break;

                            }


                        }

                        morkMW.AllowMixWink = true;//�Ӿ���ɣ���������
                                                   // morkMW.AllowPourWink = true;//������ɣ���������
                    }
                }
            }
            else
            {
                if (morkMW.RobotIdle && simOrderLocInfos.Count > 0 && !morkMW.TaskLock && !morkMW.PourWinkComplete && morkMW.CupSignal)
                {
                    DeviceProcessLogShow("������ʼ����");
                    morkMW.TaskLock = true;
                    if (simOrderLocInfos.TryDequeue(out SimOrderLocInfo res))
                    {
                        foreach (var item in res.mixWink)
                        {
                            switch (item.Loc)
                            {
                                // case 7: ToMixWink(); break;
                                case 1: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;
                                case 2: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;
                                case 3: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;
                                case 4: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;
                                case 5: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;
                                case 6: ToSpecifiedLocTakeWink(item.Loc, item.Time); break;

                            }
                            switch (item.Loc)
                            {
                                //case 7: while (!morkMW.MixWinkComplte) { Thread.Sleep(5); } break;
                                case 1: while (!morkMW.TakeWinkOneComplete) { Thread.Sleep(5); } break;
                                case 2: while (!morkMW.TakeWinkTwoComplete) { Thread.Sleep(5); } break;
                                case 3: while (!morkMW.TakeWinkThreeComplete) { Thread.Sleep(5); } break;
                                case 4: while (!morkMW.TakeWinkFourComplete) { Thread.Sleep(5); } break;
                                case 5: while (!morkMW.TakeWinkFiveComplete) { Thread.Sleep(5); } break;
                                case 6: while (!morkMW.TakeWinkSixComplete) { Thread.Sleep(5); } break;

                            }


                        }
                        DeviceProcessLogShow($"����λ�ýӾ����");
                        morkMW.AllowMixWink = true;//�Ӿ���ɣ���������
                                                   // morkMW.AllowPourWink = true;//������ɣ���������
                    }
                }

            }
        }
        /// <summary>
        /// ���ƹ���
        /// </summary>
        public void ToMixWink()
        {
            // modbus.WriteSingleRegister(0000, 7);//�����˵���

            if (morkMW.AllowMixWink && modbus.Connected)
            {
                DeviceProcessLogShow("��ʼ����");
                modbus.WriteSingleRegister(0000, 7);//�����˵���
                morkMW.AllowMixWink = false;
            }
        }
        /// <summary>
        /// ȥ��Ӧλ�ýӾ�
        /// </summary>
        /// <param name="loc"></param>
        /// <param name="time"></param>
        public void ToSpecifiedLocTakeWink(int loc, int time)
        {
            //���ͽӾ��ź�
            switch (loc)
            {
                case 1: modbus.WriteSingleRegister(0000, 1); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;
                case 2: modbus.WriteSingleRegister(0000, 2); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;
                case 3: modbus.WriteSingleRegister(0000, 3); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;
                case 4: modbus.WriteSingleRegister(0000, 4); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;
                case 5: modbus.WriteSingleRegister(0000, 5); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;
                case 6: modbus.WriteSingleRegister(0000, 6); DeviceProcessLogShow($"��ʼ�ӡ�{loc}����λ��ԭ��"); break;

            }
            //�ȴ������˵���Ӿ�λ��
            switch (loc)
            {
                case 1: while (!morkMW.ArriveWinkOneLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;
                case 2: while (!morkMW.ArriveWinkTwoLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;
                case 3: while (!morkMW.ArriveWinkThreeLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;
                case 4: while (!morkMW.ArriveWinkFourLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;
                case 5: while (!morkMW.ArriveWinkFiveLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;
                case 6: while (!morkMW.ArriveWinkSixLoc) { Thread.Sleep(5); } DeviceProcessLogShow($"��е�۵��{loc}���ŽӾ�λ��"); break;

            }
            Thread.Sleep(time * 1000);//�ӾƵȴ�ʱ�� 
            //���ͽӾ�����ź�
            switch (loc)
            {
                case 1: modbus.WriteSingleCoil(4596, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;
                case 2: modbus.WriteSingleCoil(4597, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;
                case 3: modbus.WriteSingleCoil(4598, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;
                case 4: modbus.WriteSingleCoil(4599, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;
                case 5: modbus.WriteSingleCoil(4600, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;
                case 6: modbus.WriteSingleCoil(4601, true); DeviceProcessLogShow($"��{loc}����λ�ýӾ����"); break;

            }

        }
        /// <summary>
        /// ���ƹ���
        /// </summary>
        public void ToPourWink()
        {
            //if (morkMW.AllowPourWink && morkMW.CupSignal)
            //{
            //    morkMW.AllowPourWink = false;
            //    modbus.WriteSingleRegister(0000, 8);//����

            //}
            if (morkMW.CupSignal && RTrig.GetInstance("AllowOut").Start(morkMW.MixWinkComplte) && modbus.Connected)
            {
                DeviceProcessLogShow("��ʼ����");
                modbus.WriteSingleRegister(0000, 8);//����

            }

        }
        /// <summary>
        /// �źż��
        /// </summary>
        public void SignalDetect()
        {
            if (RTrig.GetInstance("AllComplete").Start(morkMW.ProcessComplete))
            {
                OrderChange(morkMW.CurrentSuborderId, ORDER_STATUS.COMPLETED_COOK);
                morkMW.PourWinkComplete = true;
                DeviceProcessLogShow("����������ɣ���ȡ�ߵ��þƱ�");
            }
            if (morkMW.PourWinkComplete)
            {
                if (TTrig.GetInstance("PoutWinkCom").Start(morkMW.CupSignal))
                {
                    OrderChange(morkMW.CurrentSuborderId, ORDER_STATUS.COMPLETED_TAKE);
                    DeviceProcessLogShow("�ͻ�ȡ�ߵ��þƱ�,����ÿվƱ����Դ��´ζ�������");
                }
                if (RTrig.GetInstance("PoutWinkCom").Start(morkMW.CupSignal))
                {
                    DeviceProcessLogShow("�վƱ���λ������ִ����һ����");
                    morkMW.PourWinkComplete = false;
                    morkMW.TaskLock = false;
                    Thread.Sleep(2000);
                }
            }
        }


        /// <summary>
        /// �������ջ�����״̬
        /// </summary>
        public override void ReadData()
        {
            //GetStatus("M230.0", new Action<object>((obj) =>
            //{

            //}));
            if (modbus.Connected)
            {
                morkMW.ArriveWinkOneLoc = modbus.ReadCoils(4616);
                morkMW.ArriveWinkTwoLoc = modbus.ReadCoils(4617);
                morkMW.ArriveWinkThreeLoc = modbus.ReadCoils(4618);
                morkMW.ArriveWinkFourLoc = modbus.ReadCoils(4619);
                morkMW.ArriveWinkFiveLoc = modbus.ReadCoils(4620);
                morkMW.ArriveWinkSixLoc = modbus.ReadCoils(4621);

                morkMW.RobotIdle = modbus.ReadCoils(4201);


                morkMW.CupSignal = modbus.ReadInputs(0);


                morkMW.TakeWinkOneComplete = modbus.ReadCoils(4606);
                morkMW.TakeWinkTwoComplete = modbus.ReadCoils(4607);
                morkMW.TakeWinkThreeComplete = modbus.ReadCoils(4608);
                morkMW.TakeWinkFourComplete = modbus.ReadCoils(4609);
                morkMW.TakeWinkFiveComplete = modbus.ReadCoils(4610);
                morkMW.TakeWinkSixComplete = modbus.ReadCoils(4611);
                morkMW.MixWinkComplte = modbus.ReadCoils(4612);
                morkMW.ProcessComplete = modbus.ReadCoils(4613);


            }
            else
            {
                modbus.ModbusTcpConnect("192.168.0.100", 8001);
            }
        }

        public void VariableMonitor()
        {
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkOneLoc").CurrentValue = morkMW.ArriveWinkOneLoc;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkTwoLoc").CurrentValue = morkMW.ArriveWinkTwoLoc;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkThreeLoc").CurrentValue = morkMW.ArriveWinkThreeLoc;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkFourLoc").CurrentValue = morkMW.ArriveWinkFourLoc;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkFiveLoc").CurrentValue = morkMW.ArriveWinkFiveLoc;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ArriveWinkSixLoc").CurrentValue = morkMW.ArriveWinkSixLoc;

            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "RobotIdle").CurrentValue = morkMW.RobotIdle;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "CupSignal").CurrentValue = morkMW.CupSignal;

            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkOneComplete").CurrentValue = morkMW.TakeWinkOneComplete;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkTwoComplete").CurrentValue = morkMW.TakeWinkTwoComplete;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkThreeComplete").CurrentValue = morkMW.TakeWinkThreeComplete;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkFourComplete").CurrentValue = morkMW.TakeWinkFourComplete;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkFiveComplete").CurrentValue = morkMW.TakeWinkFiveComplete;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "TakeWinkSixComplete").CurrentValue = morkMW.TakeWinkSixComplete;

            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "MixWinkComplte").CurrentValue = morkMW.MixWinkComplte;
            GVL_MorkMW.varibleInfos.FirstOrDefault(p => p.VaribleName == "ProcessComplete").CurrentValue = morkMW.ProcessComplete;

        }

        public override void ResetProgram()
        {
            morkMW = null;
            morkMW = new GVL_MorkMW();
        }


        public override void SimOrder()
        {
            EventBus.GetInstance.Subscribe<MorkMWSimOrder>(0, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {

                if (@event != null && @event is MorkMWSimOrder order)
                {
                    if (order.mixWink.Count > 0)
                    {

                        string guid = Guid.NewGuid().ToString();
                        simOrderLocInfos.Enqueue(new SimOrderLocInfo { mixWink = order.mixWink, SuborderId = guid });
                        DeviceProcessLogShow("�յ�ģ�ⶩ��");
                    }
                }

            });
        }

        public override void Stop()
        {

        }
        private void GetStatus(string key, Action<object> action)
        {
            if (peripheralStatus.ContainsKey(key))
            {
                if (peripheralStatus[key] != null)
                {
                    action?.Invoke(peripheralStatus[key]);
                }
            }
        }
        /// <summary>
        /// ���������
        /// </summary>
        /// <param name="address"></param>
        /// <param name="value"></param>
        private void WriteData(string address, object value)
        {
            EventBus.GetInstance.Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });
        }
        /// <summary>
        /// ���ݽ���
        /// </summary>
        public void DataParse()
        {
            EventBus.GetInstance.Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {

                if (@event != null && @event is DoOrderEvent order)
                {
                    morkMW.doOrderEvents.Add(order);
                    if (listMorkMWGoods.Count == 0) return;
                    if (morkMW.historySuborderId.FirstOrDefault(p => p == order.MorkOrder.SuborderId) != null) return;
                    OrderCount++;
                    var res = listMorkMWGoods?.FirstOrDefault(p => p.GoodsKey == order.MorkOrder.GoodsKey);
                    if (res != null)
                    {
                        string guid = Guid.NewGuid().ToString();
                        orderLocInfos.Enqueue(new BPASmartClient.MorkMW.Model.OrderLocInfo { mixWink = res.MorkMWBoms, SuborderId = order.MorkOrder.SuborderId });
                        morkMW.historySuborderId.Add(order.MorkOrder.SuborderId);
                        OrderChange(order.MorkOrder.SuborderId, ORDER_STATUS.WAIT);
                        DeviceProcessLogShow($"�յ���{OrderCount}����С���򶩵�����ǰ������{order.MorkOrder.GoodsName}��,�����š�{order.MorkOrder.SuborderId}��");
                    }
                    else
                    {
                        DeviceProcessLogShow($"δ�ҵ�������Ӧ��Ʒ�������š�{order.MorkOrder.SuborderId}��");
                    }
                }

            });
        }
        /// <summary>
        /// ����״̬�ϱ�
        /// </summary>
        /// <param name="subid"></param>
        /// <param name="oRDER_STATUS"></param>
        private void OrderChange(string subid, ORDER_STATUS oRDER_STATUS)
        {
            try
            {
                var res = morkMW.doOrderEvents.FirstOrDefault(p => p.MorkOrder.SuborderId == subid);
                string goodName = string.Empty;
                string SortNum = string.Empty;
                if (res != null)
                {
                    goodName = res.MorkOrder.GoodsName;
                    SortNum = res.MorkOrder.SortNum.ToString();
                }

                EventBus.GetInstance.Publish(new OrderStatusChangedEvent() { SortNum = SortNum, GoodName = goodName, Status = oRDER_STATUS, SubOrderId = subid, deviceClientType = DeviceType });
            }
            catch (Exception)
            {
                DeviceProcessLogShow($"����״̬�ϱ�ʧ�ܣ������š�{morkMW.CurrentSuborderId}��");
                //throw;
            }
        }
        /// <summary>
        /// ���ӿ����ջ�����
        /// </summary>
        /// <param name="ip"></param>
        /// <param name="port"></param>
        public void ConnectKlpRobot(string ip, int port)
        {
            modbus = new ModbusTcp();
            modbus.Show += new Action<string>((s) =>
            {
                if (s != null) DeviceProcessLogShow(s);
            });
            modbus.ShowEx += new Action<string>((s) =>
            {
                if ((s != null)) DeviceProcessLogShow(s);
            });
            modbus.ModbusTcpConnect(ip, port);

        }

        /// <summary>
        /// ����С���򶩵�����
        /// </summary>
        public ConcurrentQueue<BPASmartClient.MorkMW.Model.OrderLocInfo> orderLocInfos = new ConcurrentQueue<BPASmartClient.MorkMW.Model.OrderLocInfo>();

        /// <summary>
        /// ����ģ�ⶩ������
        /// </summary>
        public ConcurrentQueue<SimOrderLocInfo> simOrderLocInfos = new ConcurrentQueue<SimOrderLocInfo>();

        /// <summary>
        /// ���ƻ��䷽����
        /// </summary>
        public List<MORKMWGoods> listMorkMWGoods = new List<MORKMWGoods>();



    }
}