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.
668 Commits
6 Branches
2.9 GiB
 
 
 
Tree: 7bcea5e53e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7bcea5e53e'
${ noResults }
BPASmartClient/BPASmart.Server/CommunicationServer.cs

378 lines
21 KiB
Raw Blame History 

  1. using BPASmart.Model;

  2. using BPA.Helper;

  3. using BPA.Communication;

  4. using Microsoft.EntityFrameworkCore.Metadata.Conventions;

  5. using Communication;

  6. using System.Collections.Concurrent;

  7. using Newtonsoft.Json;

  8. 

  9. namespace BPASmart.Server

  10. {

  11.     internal class CommunicationServer : IServer

  12.     {

  13.         ConcurrentDictionary<string, ICommunication> CommunicationDevices = new ConcurrentDictionary<string, ICommunication>();

  14. 

  15.         public void Init()

  16.         {

  17.             BPASmartClient.Message.MessageLog.GetInstance.ShowDebugLog("通讯模块初始化");

  18.             RedisHelper.GetInstance.ConnectAsync();

  19.             MqttInit();

  20.             Json<CommunicationPar>.Data.CommunicationDevices.ToList()?.ForEach(item =>

  21.             {

  22. 

  23.                 ThreadManage.GetInstance().Start(new Action(() =>

  24.                 {

  25.                     switch (item.CommDevice)

  26.                     {

  27.                         case BPASmart.Model.ModbusRtu _modbusRtu:

  28.                             break;

  29.                         case BPASmart.Model.ModbusTcp _modbusTcp:

  30.                             BPA.Communication.ModbusTcp modbusTcpMaster = new BPA.Communication.ModbusTcp();

  31.                             modbusTcpMaster.ConnectOk = new Action(() =>

  32.                             {

  33.                                 if (!CommunicationDevices.ContainsKey(item.DeviceName))

  34.                                     CommunicationDevices.TryAdd(item.DeviceName, modbusTcpMaster);

  35.                                 ThreadManage.GetInstance().StartLong(new Action(() =>

  36.                                 {

  37.                                     item.VarTableModels.GetReadDataModels().ToList()?.ForEach(temp =>

  38.                                   {

  39.                                       //switch (temp.Key)

  40.                                       //{

  41.                                       //    case EDataType.Bool:

  42.                                       //        temp.Value?.ForEach(value =>

  43.                                       //        {

  44.                                       //            //var res = modbusTcpMaster.ReadBool(value.StartAddress.ToString(), value.Length);

  45.                                       //            var res = modbusTcpMaster.Read<bool[]>(value.StartAddress.ToString(), value.Length);

  46.                                       //            SetValue(res.Content, item.DeviceName, value, 1);

  47.                                       //        });

  48.                                       //        break;

  49.                                       //    case EDataType.Byte:

  50.                                       //        break;

  51.                                       //    case EDataType.Int:

  52.                                       //        break;

  53.                                       //    case EDataType.Word:

  54.                                       //        temp.Value?.ForEach(value =>

  55.                                       //        {

  56.                                       //            //var res = modbusTcpMaster.ReadUshort(value.StartAddress.ToString(), value.Length);

  57.                                       //            var res = modbusTcpMaster.Read<ushort[]>(value.StartAddress.ToString(), value.Length);

  58.                                       //            SetValue(res.Content, item.DeviceName, value, 1);

  59.                                       //        });

  60.                                       //        break;

  61.                                       //    case EDataType.Dint:

  62.                                       //        break;

  63.                                       //    case EDataType.Dword:

  64.                                       //        temp.Value?.ForEach(value =>

  65.                                       //        {

  66.                                       //            //var res = modbusTcpMaster.ReadUint(value.StartAddress.ToString(), value.Length);

  67.                                       //            var res = modbusTcpMaster.Read<uint[]>(value.StartAddress.ToString(), value.Length);

  68.                                       //            SetValue(res.Content, item.DeviceName, value, 2);

  69.                                       //        });

  70.                                       //        break;

  71.                                       //    case EDataType.Float:

  72.                                       //        temp.Value?.ForEach(value =>

  73.                                       //        {

  74.                                       //            //var res = modbusTcpMaster.ReadFloat(value.StartAddress.ToString(), value.Length);

  75.                                       //            var res = modbusTcpMaster.Read<float[]>(value.StartAddress.ToString(), value.Length);

  76.                                       //            SetValue(res.Content, item.DeviceName, value, 2);

  77.                                       //        });

  78.                                       //        break;

  79.                                       //    default:

  80.                                       //        break;

  81.                                       //}

  82. 

  83.                                       Array ResultArray = null;

  84.                                       temp.Value?.ForEach(value =>

  85.                                       {

  86.                                           switch (temp.Key)

  87.                                           {

  88.                                               case EDataType.Bool:

  89.                                                   ResultArray = modbusTcpMaster.Read<bool[]>(value.StartAddress.ToString(), value.Length)?.Content;

  90.                                                   break;

  91.                                               case EDataType.Byte:

  92.                                                   break;

  93.                                               case EDataType.Int:

  94.                                                   ResultArray = modbusTcpMaster.Read<short[]>(value.StartAddress.ToString(), value.Length)?.Content;

  95.                                                   break;

  96.                                               case EDataType.Word:

  97.                                                   ResultArray = modbusTcpMaster.Read<ushort[]>(value.StartAddress.ToString(), value.Length)?.Content;

  98.                                                   break;

  99.                                               case EDataType.Dint:

  100.                                                   ResultArray = modbusTcpMaster.Read<int[]>(value.StartAddress.ToString(), value.Length)?.Content;

  101.                                                   break;

  102.                                               case EDataType.Dword:

  103.                                                   ResultArray = modbusTcpMaster.Read<uint[]>(value.StartAddress.ToString(), value.Length)?.Content;

  104.                                                   break;

  105.                                               case EDataType.Float:

  106.                                                   ResultArray = modbusTcpMaster.Read<float[]>(value.StartAddress.ToString(), value.Length)?.Content;

  107.                                                   break;

  108.                                               default:

  109.                                                   break;

  110.                                           }

  111.                                           SetValue(ResultArray, item.DeviceName, value, temp.Key);

  112.                                       });

  113.                                   });

  114. 

  115.                                     Thread.Sleep(100);

  116.                                 }), $"{item.DeviceName} 设备数据采集");

  117.                                 var DeviceModel = item;

  118.                             });

  119.                             modbusTcpMaster.IsReconnect = true;

  120.                             modbusTcpMaster.ModbusTcpConnect(_modbusTcp.IP, _modbusTcp.PortNum);

  121.                             break;

  122.                         case BPASmart.Model.Siemens _siemens:

  123.                             break;

  124.                         default:

  125.                             break;

  126.                     }

  127.                 }), $"{item.DeviceName} 初始化连接");

  128.             });

  129.         }

  130. 

  131.         ConcurrentQueue<string> msg = new ConcurrentQueue<string>();

  132.         private void MqttInit()

  133.         {

  134.             MqttHelper mqttHelper = new MqttHelper();

  135.             mqttHelper.Connect("admin", "fengyoufu067101!@#", "124.222.238.75", 61613, $"分布式上位机:{DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss")}");

  136.             mqttHelper.ConnectOk = new Action(() =>

  137.               {

  138.                   mqttHelper.Subscrib("DistributedHostComputer/Control");

  139.                   ThreadManage.GetInstance().StartLong(new Action(() =>

  140.                   {

  141.                       while (msg.Count > 0)

  142.                       {

  143.                           DeviceControl();

  144.                       }

  145.                       Thread.Sleep(100);

  146.                   }), "MQTT 消息监听");

  147.               });

  148.             mqttHelper.MessageRecive = new Action<string>((s) =>

  149.             {

  150.                 msg.Enqueue(s);

  151.             });

  152.         }

  153. 

  154.         private void DeviceControl()

  155.         {

  156.             if (msg.TryDequeue(out string s))

  157.             {

  158.                 var res = JsonConvert.DeserializeObject<PublishInfo>(s);

  159.                 if (res != null)

  160.                 {

  161.                     res.PublishModels.ForEach(item =>

  162.                     {

  163.                         if (CommunicationDevices.ContainsKey(item.DeviceName))

  164.                         {

  165.                             string address = string.Empty;

  166.                             if (item.RealAddress != null && item.RealAddress.Length > 0) address = item.DeviceName;

  167.                             else

  168.                             {

  169.                                 var res = Json<CommunicationPar>.Data.CommunicationDevices.FirstOrDefault(p => p.DeviceName == item.DeviceName);

  170.                                 var res2 = res?.VarTableModels.FirstOrDefault(p => p.VarName?.Length > 0 && p.VarName == item.VarName);

  171.                                 address = res2?.RealAddress;

  172.                             }

  173.                             if (item.Value != null && item.Value.Length > 0)

  174.                             {

  175.                                 switch (item.DataType)

  176.                                 {

  177.                                     case EDataType.Bool:

  178.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToBoolean(item.Value));

  179.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToBoolean(item.Value));

  180.                                         break;

  181.                                     case EDataType.Byte:

  182.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToByte(item.Value));

  183.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToByte(item.Value));

  184.                                         break;

  185.                                     case EDataType.Int:

  186.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToInt16(item.Value));

  187.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToInt16(item.Value));

  188.                                         break;

  189.                                     case EDataType.Word:

  190.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToUInt16(item.Value));

  191.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToUInt16(item.Value));

  192.                                         break;

  193.                                     case EDataType.Dint:

  194.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToInt32(item.Value));

  195.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToInt32(item.Value));

  196.                                         break;

  197.                                     case EDataType.Dword:

  198.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToUInt32(item.Value));

  199.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToUInt32(item.Value));

  200.                                         break;

  201.                                     case EDataType.Float:

  202.                                         //CommunicationDevices[item.DeviceName].Write(address, Convert.ToSingle(item.Value));

  203.                                         CommunicationDevices[item.DeviceName].Write(address, Convert.ToSingle(item.Value));

  204.                                         break;

  205.                                     default:

  206.                                         break;

  207.                                 }

  208.                             }

  209. 

  210.                         }

  211.                     });

  212.                 }

  213.             }

  214.         }

  215. 

  216.         //private void SetValue<TArray>(TArray[] arrays, string DeviceName, ReadDataModel readDataModel, ushort by)

  217.         //{

  218.         //    if (arrays != null)

  219.         //    {

  220.         //        int index = Array.FindIndex(Json<CommunicationPar>.Data.CommunicationDevices.ToArray(), p => p.DeviceName == DeviceName);//获取设备所在集合位置

  221.         //        if (index >= 0 && index < Json<CommunicationPar>.Data.CommunicationDevices.Count)

  222.         //        {

  223.         //            var tempArray = Json<CommunicationPar>.Data.CommunicationDevices.ElementAt(index).VarTableModels.ToArray();

  224.         //            for (int i = 0; i < arrays.Length; i++)

  225.         //            {

  226.         //                int varIndex = Array.FindIndex(tempArray, p => p.RealAddress == (readDataModel.StartAddress + (i * by)).ToString());

  227.         //                if (varIndex >= 0 && varIndex < tempArray.Length)

  228.         //                {

  229.         //                    Json<CommunicationPar>.Data.CommunicationDevices.ElementAt(index).VarTableModels.ElementAt(varIndex).CurrentValue = arrays[i].ToString();

  230.         //                }

  231.         //            }

  232.         //            var Devicename = Json<CommunicationPar>.Data.CommunicationDevices[index].DeviceName;

  233.         //            List<ReeisDataModel> reeisDataModels = new List<ReeisDataModel>();

  234.         //            Json<CommunicationPar>.Data.CommunicationDevices[index].VarTableModels.ToList().ForEach(tempVar =>

  235.         //            {

  236.         //                if (tempVar.VarName.Length > 0)

  237.         //                {

  238.         //                    reeisDataModels.Add(new ReeisDataModel()

  239.         //                    {

  240.         //                        VarName = tempVar.VarName,

  241.         //                        VarVaule = tempVar.CurrentValue,

  242.         //                        DataType = (EDataType)Enum.Parse(typeof(EDataType), tempVar.DataType)

  243.         //                    });

  244.         //                }

  245.         //            });

  246.         //            RedisHelper.GetInstance.SetValue($"{Devicename}", reeisDataModels);

  247.         //        }

  248.         //    }

  249.         //}

  250. 

  251.         //private ushort GetBySize(EDataType eDataType)

  252.         //{

  253.         //    switch (eDataType)

  254.         //    {

  255.         //        case EDataType.Bool:

  256.         //        case EDataType.Byte:

  257.         //        case EDataType.Int:

  258.         //        case EDataType.Word:

  259.         //            return 1;

  260.         //        case EDataType.Dint:

  261.         //        case EDataType.Dword:

  262.         //        case EDataType.Float:

  263.         //            return 2;

  264.         //        case EDataType.Double:

  265.         //            break;

  266.         //        case EDataType.String:

  267.         //            break;

  268.         //        default:

  269.         //            break;

  270.         //    }

  271.         //    return 1;

  272.         //}

  273. 

  274.         private void SetValue(Array arrays, string DeviceName, ReadDataModel readDataModel, EDataType eDataType)

  275.         {

  276.             if (arrays != null)

  277.             {

  278.                 ushort by = eDataType.GetEDataSize();

  279.                 int index = Array.FindIndex(Json<CommunicationPar>.Data.CommunicationDevices.ToArray(), p => p.DeviceName == DeviceName);//获取设备所在集合位置

  280.                 if (index >= 0 && index < Json<CommunicationPar>.Data.CommunicationDevices.Count)

  281.                 {

  282.                     var tempArray = Json<CommunicationPar>.Data.CommunicationDevices.ElementAt(index).VarTableModels.ToArray();

  283.                     for (int i = 0; i < arrays.Length; i++)

  284.                     {

  285.                         int varIndex = Array.FindIndex(tempArray, p => p.RealAddress == (readDataModel.StartAddress + (i * by)).ToString());

  286.                         if (varIndex >= 0 && varIndex < tempArray.Length)

  287.                         {

  288.                             Json<CommunicationPar>.Data.CommunicationDevices.ElementAt(index).VarTableModels.ElementAt(varIndex).CurrentValue = arrays.GetValue(i)?.ToString();

  289.                         }

  290.                     }

  291.                     var Devicename = Json<CommunicationPar>.Data.CommunicationDevices[index].DeviceName;

  292.                     List<ReeisDataModel> reeisDataModels = new List<ReeisDataModel>();

  293.                     Json<CommunicationPar>.Data.CommunicationDevices[index].VarTableModels.ToList().ForEach(tempVar =>

  294.                     {

  295.                         if (tempVar.VarName.Length > 0)

  296.                         {

  297.                             reeisDataModels.Add(new ReeisDataModel()

  298.                             {

  299.                                 VarName = tempVar.VarName,

  300.                                 VarVaule = tempVar.CurrentValue,

  301.                                 DataType = (EDataType)Enum.Parse(typeof(EDataType), tempVar.DataType)

  302.                             });

  303.                         }

  304.                     });

  305.                     RedisHelper.GetInstance.SetValue($"{Devicename}", reeisDataModels);

  306.                 }

  307.             }

  308.         }

  309. 

  310. 

  311. 

  312.         //private Dictionary<EDataType, List<ReadDataModel>> GetReadDataModels(CommunicationModel communicationModel)

  313.         //{

  314.         //    Dictionary<EDataType, List<ReadDataModel>> readDataModels = new Dictionary<EDataType, List<ReadDataModel>>();

  315.         //    communicationModel.VarTableModels.GroupBy(p => p.DataType)?.ToList()?.ForEach(tempVar =>

  316.         //    {

  317.         //        if (tempVar.Key != null && tempVar.Key.Length > 0)

  318.         //        {

  319.         //            //int address = tempVar.Min(p => p.RealAddress);

  320.         //            EDataType dataType = (EDataType)Enum.Parse(typeof(EDataType), tempVar.Key);

  321.         //            switch (dataType)

  322.         //            {

  323.         //                case EDataType.Bool:

  324.         //                case EDataType.Byte:

  325.         //                case EDataType.Int:

  326.         //                case EDataType.Word:

  327.         //                    if (!readDataModels.ContainsKey(dataType)) readDataModels.TryAdd(dataType, GetDataGroup(tempVar));

  328.         //                    break;

  329.         //                case EDataType.Dint:

  330.         //                case EDataType.Dword:

  331.         //                case EDataType.Float:

  332.         //                    if (!readDataModels.ContainsKey(dataType)) readDataModels.TryAdd(dataType, GetDataGroup(tempVar, 2));

  333.         //                    break;

  334.         //                default:

  335.         //                    break;

  336.         //            }

  337.         //        }

  338.         //    });

  339.         //    return readDataModels;

  340.         //}

  341. 

  342.         //private List<ReadDataModel> GetDataGroup(IGrouping<string, VariableInfo> variableInfos, int by = 1)

  343.         //{

  344.         //    List<ReadDataModel> ReturnValue = new List<ReadDataModel>();

  345.         //    var res = variableInfos?.OrderBy(p => p.RealAddress).ToList();

  346.         //    List<int> RealAddresss = new List<int>();

  347.         //    variableInfos.ToList()?.ForEach(item => { if (int.TryParse(item.RealAddress, out int add)) RealAddresss.Add(add); });

  348.         //    int count = 0;

  349.         //    if (res != null)

  350.         //    {

  351.         //        //int address = variableInfos.Min(p => p.RealAddress);

  352.         //        int address = RealAddresss.Min();

  353.         //        int startAddress = address;

  354.         //        for (int i = 0; i < res.Count; i++)

  355.         //        {

  356.         //            if (int.TryParse(res.ElementAt(i).RealAddress, out int TempAddress))

  357.         //            {

  358.         //                if (TempAddress == address)

  359.         //                {

  360.         //                    count++;

  361.         //                    address += by;

  362.         //                }

  363.         //                else

  364.         //                {

  365.         //                    ReturnValue.Add(new ReadDataModel() { StartAddress = (ushort)startAddress, Length = (ushort)count });

  366.         //                    count = 1;

  367.         //                    address = TempAddress + by;

  368.         //                    startAddress = TempAddress;

  369.         //                }

  370.         //            }

  371. 

  372.         //        }

  373.         //        ReturnValue.Add(new ReadDataModel() { StartAddress = (ushort)startAddress, Length = (ushort)count });

  374.         //    }

  375.         //    return ReturnValue;

  376.         //}

  377.     }

  378. }