HKCard/HKControl/Main.cs

using System.Collections.Concurrent;
using System.Diagnostics;
using BPA.Helper;
using S7.Net;

namespace HKControl
{
    public class Main
    {

        private volatile static Main _Instance;
        public static Main GetInstance => _Instance ?? (_Instance = new Main());
        private Main() { }

        ConcurrentDictionary<int, Siemens> SiemensDicitonary = new ConcurrentDictionary<int, Siemens>();
        ConcurrentDictionary<int, DataModel> DataModels = new ConcurrentDictionary<int, DataModel>();
        ConcurrentQueue<int> CarQueue = new ConcurrentQueue<int>();

        public Action[] CompleteNotify { get; set; } = new Action[6];

        /// <summary>
        /// 判断指定出餐窗口是否允许刷卡（1-6）
        /// </summary>
        /// <param name="CarNum"></param>
        /// <returns></returns>
        public bool GetIsSwipe(int CarNum)
        {
            if (!DataModels.ContainsKey(CarNum)) return false;
            switch (CarNum)
            {
                case 1:
                    return DataModels[1].LeftWindowData.IsSwipe;
                case 2:
                    return DataModels[1].RightWindowData.IsSwipe;
                case 3:
                    return DataModels[2].LeftWindowData.IsSwipe;
                case 4:
                    return DataModels[2].RightWindowData.IsSwipe;
                case 5:
                    return DataModels[3].LeftWindowData.IsSwipe;
                case 6:
                    return DataModels[3].LeftWindowData.IsSwipe;
                default:
                    break;
            }
            return false;
        }

        /// <summary>
        /// 获取指定档口是否配餐完成
        /// </summary>
        /// <param name="CarNum"></param>
        /// <returns></returns>
        public bool GetIsComplete(int CarNum)
        {
            if (!DataModels.ContainsKey(CarNum)) return false;
            switch (CarNum)
            {
                case 1:
                    return DataModels[1].LeftWindowData.Complete;
                case 2:
                    return DataModels[1].RightWindowData.Complete;
                case 3:
                    return DataModels[2].LeftWindowData.Complete;
                case 4:
                    return DataModels[2].RightWindowData.Complete;
                case 5:
                    return DataModels[3].LeftWindowData.Complete;
                case 6:
                    return DataModels[3].LeftWindowData.Complete;
                default:
                    break;
            }
            return false;
        }

        /// <summary>
        /// 设置指定窗口开始出餐（1--6）
        /// </summary>
        /// <param name="CarNum"></param>
        public void Start(int CarNum)
        {
            CarQueue.Enqueue(CarNum);
        }

        /// <summary>
        /// 初始化
        /// </summary>
        public void Init()
        {
            DataInit();
            Json<CommunicationPar>.Data.CommunicationModels.ToList()?.ForEach(item =>
            {
                if (!DataModels.ContainsKey(item.DeviceNum)) { DataModels.TryAdd(item.DeviceNum, new DataModel()); };
                if (!SiemensDicitonary.ContainsKey(item.DeviceNum)) { SiemensDicitonary.TryAdd(item.DeviceNum, new Siemens()); }
                ThreadManage.GetInstance().Start(new Action(() =>
                {
                    SiemensDicitonary[item.DeviceNum].ConnectOk = new Action(() =>
                      {
                          HKLog.HKLogImport.WriteInfo($"{item.DeviceNum}:连接成功");
                          ThreadManage.GetInstance().StartLong(new Action(() =>
                          {
                              try
                              {
                                  var res = SiemensDicitonary[item.DeviceNum].Read<byte>("MB7");

                                  DataModels[item.DeviceNum].LeftWindowData.IsSwipe = Get8bitValue(res, 1);
                                  DataModels[item.DeviceNum].LeftWindowData.Complete = Get8bitValue(res, 2);

                                  DataModels[item.DeviceNum].RightWindowData.IsSwipe = Get8bitValue(res, 3);
                                  DataModels[item.DeviceNum].RightWindowData.Complete = Get8bitValue(res, 4);
                              }
                              catch (Exception ex)
                              {
                                  HKLog.HKLogImport.WriteInfo(ex.ToString());
                              }
                              Thread.Sleep(100);
                          }), $"{item.DeviceNum} 号设备监听", true);

                          ThreadManage.GetInstance().StartLong(new Action(() =>
                          {
                              for (int i = 0; i < 6; i++)
                              {
                                  if (RTrig.GetInstance($"窗口{i + 1}").Start(GetIsComplete(i + 1)))
                                  {
                                      CompleteNotify[i]?.Invoke();
                                  }
                              }
                              Thread.Sleep(100);
                          }), "完成通知");

                      });
                    SiemensDicitonary[item.DeviceNum].Connect(CpuType.S7200Smart, item.IpAddress);
                }), $"{item.DeviceNum} 号设备连接初始化");

            });
            StartRun();
        }

        private void StartRun()
        {
            ThreadManage.GetInstance().StartLong(new Action(() =>
            {
                while (CarQueue.Count > 0)
                {
                    if (CarQueue.TryDequeue(out int carNum))
                    {
                        switch (carNum)
                        {
                            case 1:
                                Control(1, "M6.1");
                                break;
                            case 2:
                                Control(1, "M6.0");
                                break;
                            case 3:
                                Control(2, "M6.1");
                                break;
                            case 4:
                                Control(2, "M6.0");
                                break;
                            case 5:
                                Control(3, "M6.1");
                                break;
                            case 6:
                                Control(3, "M6.0");
                                break;

                            default:
                                break;
                        }
                    }
                }
                Thread.Sleep(100);
            }), "开始运行设备");
        }

        private void Control(int num, string add)
        {
            HKLog.HKLogImport.WriteInfo($"{num} 号出餐口控制");
            SiemensDicitonary[num].Write(add, true);
            Thread.Sleep(1000);
            SiemensDicitonary[num].Write(add, false);
        }

        private void DataInit()
        {
            Json<CommunicationPar>.Read();
            if (Json<CommunicationPar>.Data.CommunicationModels.Count < 3)
            {
                Json<CommunicationPar>.Data.CommunicationModels.Clear();

                Json<CommunicationPar>.Data.CommunicationModels.Add(new CommunicationModel()
                {
                    IpAddress = "192.168.0.1",
                    DeviceNum = 3
                });

                Json<CommunicationPar>.Data.CommunicationModels.Add(new CommunicationModel()
                {
                    IpAddress = "192.168.0.2",
                    DeviceNum = 2
                });

                Json<CommunicationPar>.Data.CommunicationModels.Add(new CommunicationModel()
                {
                    IpAddress = "192.168.0.3",
                    DeviceNum = 1
                });

                Json<CommunicationPar>.Save();
            }
        }

        /// <summary>
        /// 获取字节中指定位的值
        /// </summary>
        /// <param name="data">要获取的整数</param>
        /// <param name="offset">偏移量 范围(1-8)</param>
        /// <returns></returns>
        public bool Get8bitValue(byte data, byte offset)
        {
            if (offset > 8 || offset < 1) return false;
            return (data & 1 << offset - 1) == 0 ? false : true;
        }
    }
}