BPASmartClient/BPASmartClient.MorkMW/Control_MorkMW.cs

using BPA.Helper;
using BPA.Message.Enum;
using BPA.Models;
using BPASmartClient.Device;
using BPASmartClient.EventBus;
using BPASmartClient.Modbus;
using BPASmartClient.Model;
using BPASmartClient.Model.PLC;
using BPASmartClient.Model.����;
using BPASmartClient.Model.���ƻ�;
using BPASmartClient.MorkMW.Model;
using Newtonsoft.Json;
using Org.BouncyCastle.Bcpg.OpenPgp;
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http.Json;
using System.Threading;
using System.Windows.Documents;
using static BPASmartClient.EventBus.EventBus;

namespace BPASmartClient.MorkMW
{
    public class Control_MorkMW : BaseDevice
    {
        ModbusTcp modbus;
        public override DeviceClientType DeviceType => DeviceClientType.MORKMW;
        GVL_MorkMW morkMW = new GVL_MorkMW();
        public override void DoMain()
        {

            ConnectKlpRobot("192.168.0.100", 8001);
            ServerInit();
            DataParse();

        }
      
        private void ServerInit()
        {
            //�䷽������Ϣ
            EventBus.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()
        {
            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)
                {
                    DeviceProcessLogShow("������ʼ����");
                    morkMW.TaskLock = true;
                    if (orderLocInfos.TryDequeue(out OrderLocInfo res))
                    {
                        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 && orderLocInfos.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)
            {
                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))
            {
                DeviceProcessLogShow("��ʼ����");
                modbus.WriteSingleRegister(0000, 8);//����

            }

        }
        /// <summary>
        /// �źż��
        /// </summary>
        public void SignalDetect()
        {
            if (RTrig.GetInstance("AllComplete").Start(morkMW.ProcessComplete))
            {
                morkMW.PourWinkComplete = true;
                DeviceProcessLogShow("����������ɣ���ȡ�ߵ��þƱ�");
            }
            if (morkMW.PourWinkComplete)
            {
                if (TTrig.GetInstance("PoutWinkCom").Start(morkMW.CupSignal))
                {
                    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 override void ResetProgram()
        {
            morkMW = null;
            morkMW = new GVL_MorkMW();
        }


        public override void SimOrder()
        {
            EventBus.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.EventBus.GetInstance().Publish(new WriteModel() { DeviceId = DeviceId, Address = address, Value = value });
        }
        /// <summary>
        /// ���ݽ���
        /// </summary>
        public void DataParse()
        {
            EventBus.EventBus.GetInstance().Subscribe<DoOrderEvent>(DeviceId, delegate (IEvent @event, EventCallBackHandle callBackHandle)
            {

                if (@event != null && @event is DoOrderEvent order)
                {
                   var res= listMorkMWGoods.FirstOrDefault(p => p.GoodsKey == order.MorkOrder.GoodsKey);
                    if (res != null)
                    {
                        string guid = Guid.NewGuid().ToString();
                        orderLocInfos.Enqueue(new OrderLocInfo { mixWink = res.MorkMWBoms, SuborderId = order.MorkOrder.SuborderId });
                        DeviceProcessLogShow($"�յ�С���򶩵��������š�{order.MorkOrder.SuborderId}��");

                    }
                }

            });
        }
     
        /// <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<OrderLocInfo> orderLocInfos = new ConcurrentQueue<OrderLocInfo>();

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

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

    }
}