• PLC连接库MCProtocolLibrary

    1. using System.Net.Sockets;
    2. using System.Net;
    3. using System.Text;
    4. using System.Xml.Linq;
    5. using System;
    6. using System.Collections.Generic;
    7. using System.IO;
    8. using System.Linq;
    9. using System.Threading;
    10. using System.Threading.Tasks;
    11. using System.Data.Common;
    12. using System.Data.SqlClient;
    13. using System.Data;
    14.  
    15. namespace MCProtocolLibrary
    16. {
    17.     public class ConnectPLC
    18.     {
    19.         private string connection_String;
    20.         private string nameFuntion;
    21.  
    22.         public string Connection_String { get => connection_String; set => connection_String = value; }
    23.         public string NameFuntion { get => nameFuntion; set => nameFuntion = value; }
    24.  
    25.         //public string TableSaveData { get => tableSaveData; set => tableSaveData = value; }
    26.  
    27.         public ConnectPLC(string inputconnectionstring, string inputNameMachine)
    28.         {
    29.             connection_String = inputconnectionstring;
    30.             nameFuntion = inputNameMachine;
    31.  
    32.         }
    33.         public static byte[] Converttextdevicetohexdevice(string namedevice)
    34.         {
    35.             byte[] bytereturn = null;
    36.             byte[] X = { 0x9C };
    37.             byte[] Y = { 0x9D };
    38.             byte[] M = { 0x90 };
    39.             byte[] L = { 0x92 };
    40.             byte[] B = { 0xA0 };
    41.             byte[] D = { 0xA8 };
    42.             byte[] W = { 0xB4 };
    43.             byte[] ZR = { 0xB0 };
    44.  
    45.             Dictionary<string, byte[]> data = new Dictionary<string, byte[]>();
    46.             data.Add("X", X);
    47.             data.Add("Y", Y);
    48.             data.Add("M", M);
    49.             data.Add("L", L);
    50.             data.Add("B", B);
    51.             data.Add("D", D);
    52.             data.Add("W", W);
    53.             data.Add("ZR", ZR);
    54.  
    55.             foreach (var item in data)
    56.             {
    57.                 if (namedevice == item.Key)
    58.                 {
    59.                     bytereturn = item.Value;
    60.                 }
    61.             }
    62.             return bytereturn;
    63.         }
    64.         public TemplateData GetTemplateDatas()
    65.         {
    66.             TemplateData Data = new TemplateData();
    67.             // GetConfig
    68.             using (SqlConnection conn = new SqlConnection(Connection_String))
    69.             {
    70.                 conn.Open();
    71.                 SqlCommand cmd = new SqlCommand($"Select * from ConfigConnectToServerNew Where NameFunction = '{nameFuntion}'", conn);
    72.                 SqlDataAdapter adap = new SqlDataAdapter(cmd);
    73.                 DataTable dt = new DataTable();
    74.                 adap.Fill(dt);
    75.                 if (dt.Rows.Count > 0)
    76.                 {
    77.                     Data.NameFunction = (string)dt.Rows[0]["NameFunction"];
    78.                     Data.IpAddressServer = (string)dt.Rows[0]["IpAddressServer"];
    79.                     Data.PortServer = (int)dt.Rows[0]["PortServer"];
    80.                     Data.TypeTriger = (string)dt.Rows[0]["TypeTriger"];
    81.                     Data.DeviceTriger = (int)dt.Rows[0]["DeviceTriger"];
    82.                     Data.TypeCompleted = (string)dt.Rows[0]["TypeCompleted"];
    83.                     Data.DeviceCompleted = (int)dt.Rows[0]["DeviceCompleted"];
    84.                     for (int i = 7; i < dt.Columns.Count; i += 4)
    85.                     {
    86.                         if (dt.Rows[0][i].ToString() != "" && dt.Rows[0][i + 1].ToString() != "0" && dt.Rows[0][i + 2].ToString() != "0" && dt.Rows[0][i + 3].ToString() != "")
    87.                             Data.Listdataread.Add(new TemplateDataRead()
    88.                             {
    89.                                 TypeData = (string)dt.Rows[0][i],
    90.                                 DeviceData = (int)dt.Rows[0][i + 1],
    91.                                 LengthData = (int)dt.Rows[0][i + 2],
    92.                                 DataType = (string)dt.Rows[0][i + 3]
    93.                             });
    94.                     }
    95.                 }
    96.                 conn.Close();
    97.             };
    98.             return Data;
    99.         }
    100.         public async Task<string> TempleReadDataPLCASCII(TemplateData DataTemplete, string NameMachine, int Timeout)
    101.         {
    102.             try
    103.             {
    104.                 using (TcpClient client = new TcpClient())
    105.                 {
    106.                     //CMD Get Data Result
    107.                     byte[] FinalCmdGetData = new byte[21];
    108.                     byte[] PathCmdGetData = { 0x50, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x01, 0x04, 0x00, 0x00 };
    109.  
    110.                     //CMD Check Exist Data
    111.                     byte[] FinalCmdCheckExistData = new byte[21];
    112.                     byte[] PathCmdCheckExistData = { 0x50, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x01, 0x04, 0x01, 0x00 };
    113.                     byte[] DeviceCheckExistData = BitConverter.GetBytes(DataTemplete.DeviceTriger);
    114.                     byte[] TypeDeviceCheckExistData = Converttextdevicetohexdevice(DataTemplete.TypeTriger);
    115.                     byte[] NumberofDeviceCheckExistData = BitConverter.GetBytes(1);
    116.                     Buffer.BlockCopy(PathCmdCheckExistData, 0, FinalCmdCheckExistData, 0, PathCmdCheckExistData.Length);
    117.                     Buffer.BlockCopy(DeviceCheckExistData, 0, FinalCmdCheckExistData, PathCmdCheckExistData.Length, 3);
    118.                     Buffer.BlockCopy(TypeDeviceCheckExistData, 0, FinalCmdCheckExistData, PathCmdCheckExistData.Length + 3, 1);
    119.                     Buffer.BlockCopy(NumberofDeviceCheckExistData, 0, FinalCmdCheckExistData, PathCmdCheckExistData.Length + 4, 2);
    120.  
    121.                     //CMD Clear Data
    122.                     byte[] On = { 0x10 };
    123.                     byte[] FinalCmdClearData = new byte[22];
    124.                     byte[] PathCmdClearData = { 0x50, 0x00, 0x00, 0xff, 0xff, 0x03, 0x00, 0x0D, 0x00, 0x00, 0x00, 0x01, 0x14, 0x01, 0x00 };
    125.                     byte[] DeviceClearData = BitConverter.GetBytes(DataTemplete.DeviceCompleted);
    126.                     byte[] TypeDeviceClearData = Converttextdevicetohexdevice(DataTemplete.TypeCompleted);
    127.                     byte[] NumberofDeviceClear = { 0x01, 0x00 };
    128.                     Buffer.BlockCopy(PathCmdClearData, 0, FinalCmdClearData, 0, PathCmdClearData.Length);
    129.                     Buffer.BlockCopy(DeviceClearData, 0, FinalCmdClearData, PathCmdClearData.Length, 3);
    130.                     Buffer.BlockCopy(TypeDeviceClearData, 0, FinalCmdClearData, PathCmdClearData.Length + 3, 1);
    131.                     Buffer.BlockCopy(NumberofDeviceClear, 0, FinalCmdClearData, PathCmdClearData.Length + 4, 2);
    132.                     Buffer.BlockCopy(On, 0, FinalCmdClearData, PathCmdClearData.Length + 6, 1);
    133.                     // cancell
    134.                     CancellationTokenSource writeCancellationToken = new CancellationTokenSource();
    135.                     CancellationTokenSource readCancellationToken = new CancellationTokenSource();
    136.                     List<string> listdataread = new List<string>();
    137.                     int checkexist = 0;
    138.                     byte[] DataCheckExist = new byte[100];
    139.                     byte[] BuffData = new byte[100];
    140.                     byte[] DataClear = new byte[100];
    141.                     int savedata = 0;
    142.                     //OpenConnect
    143.                     CancellationTokenSource connectCancellationToken = new CancellationTokenSource();
    144.                     Task connectTask = client.ConnectAsync(IPAddress.Parse(DataTemplete.IpAddressServer), DataTemplete.PortServer);
    145.                     if (await Task.WhenAny(connectTask, Task.Delay(Timeout, connectCancellationToken.Token)) != connectTask)
    146.                     {
    147.                         connectCancellationToken.Cancel();
    148.                         throw new TimeoutException("Error timed out Open Connection .");
    149.                     }
    150.                     await connectTask;
    151.                     NetworkStream stream = client.GetStream();
    152.                     //Check Exist Data
    153.                     //
    154.                     Task writeTask = stream.WriteAsync(FinalCmdCheckExistData, 0, FinalCmdCheckExistData.Length, writeCancellationToken.Token);
    155.                     if (await Task.WhenAny(writeTask, Task.Delay(Timeout, writeCancellationToken.Token)) != writeTask)
    156.                     {
    157.                         writeCancellationToken.Cancel();
    158.                         throw new TimeoutException("Error Trigger Exist Send timed out.");
    159.                     }
    160.                     await writeTask;
    161.                     Task<int> readTask = stream.ReadAsync(DataCheckExist, 0, DataCheckExist.Length, readCancellationToken.Token);
    162.                     if (await Task.WhenAny(readTask, Task.Delay(Timeout, readCancellationToken.Token)) != readTask)
    163.                     {
    164.                         readCancellationToken.Cancel();
    165.                         throw new TimeoutException("Error Trigger Exist Receive timed out.");
    166.                     }
    167.                     int bytesRead = await readTask;
    168.                     if (DataCheckExist[9] == 0 && DataCheckExist[10] == 0)
    169.                     {
    170.                         checkexist = BitConverter.ToInt32(DataCheckExist, 11);
    171.                     }
    172.                     if (checkexist != 0)
    173.                     {
    174.                         listdataread.Clear();
    175.                         foreach (TemplateDataRead item in DataTemplete.Listdataread)
    176.                         {
    177.                             Array.Clear(BuffData, 0, BuffData.Length);
    178.                             
    179.                             byte[] DeviceStoreResult = BitConverter.GetBytes(item.DeviceData);
    180.                             byte[] TypeDeviceStoreResult = Converttextdevicetohexdevice(item.TypeData);
    181.                             byte[] LengthDeviceStoreResult = BitConverter.GetBytes(item.LengthData);
    182.                             Buffer.BlockCopy(PathCmdGetData, 0, FinalCmdGetData, 0, PathCmdGetData.Length);
    183.                             Buffer.BlockCopy(DeviceStoreResult, 0, FinalCmdGetData, PathCmdGetData.Length, 3);
    184.                             Buffer.BlockCopy(TypeDeviceStoreResult, 0, FinalCmdGetData, PathCmdGetData.Length + 3, 1);
    185.                             Buffer.BlockCopy(LengthDeviceStoreResult, 0, FinalCmdGetData, PathCmdGetData.Length + 4, 2);
    186.  
    187.                             Task writeTaskCabi = stream.WriteAsync(FinalCmdGetData, 0, FinalCmdGetData.Length, writeCancellationToken.Token);
    188.                             if (await Task.WhenAny(writeTask, Task.Delay(Timeout, writeCancellationToken.Token)) != writeTask)
    189.                             {
    190.                                 writeCancellationToken.Cancel();
    191.                                 throw new TimeoutException("Error Data Cabi Send timed out.");
    192.                             }
    193.                             await writeTaskCabi;
    194.                             Task<int> readTaskCabi = stream.ReadAsync(BuffData, 0, BuffData.Length, readCancellationToken.Token);
    195.                             if (await Task.WhenAny(readTask, Task.Delay(Timeout, readCancellationToken.Token)) != readTask)
    196.                             {
    197.                                 readCancellationToken.Cancel();
    198.                                 throw new TimeoutException("Error Data Cabi Receive timed out.");
    199.                             }
    200.                             int bytesReadCabi = await readTaskCabi;
    201.                             if (BuffData[9] == 0 && BuffData[10] == 0)
    202.                             {
    203.                                 if (item.DataType == "Float")
    204.                                 {
    205.                                     byte[] buff1 = new byte[] { BuffData[11], BuffData[12], BuffData[13], BuffData[14]};
    206.                                     float fl = BitConverter.ToSingle(buff1, 0);
    207.                                     listdataread.Add(fl.ToString());
    208.                                 }
    209.                                 else if (item.DataType == "DEC")
    210.                                 {
    211.                                     byte[] buff1 = new byte[] { BuffData[11], BuffData[12], BuffData[13], BuffData[14] };
    212.                                     int Dec = BitConverter.ToInt32(buff1,0);
    213.                                     listdataread.Add(Dec.ToString());
    214.                                 }
    215.                                 else
    216.                                 {
    217.                                     string datastr = Encoding.ASCII.GetString(BuffData, 11, findnull(BuffData)).Trim('\0').Trim('\r').Trim('\n');
    218.                                     listdataread.Add(datastr);
    219.                                 }
    220.                             }
    221.                         }
    222.                         if (listdataread.Count > 0)
    223.                         {
    224.                             int countdata = listdataread.Count;
    225.                             if (countdata < 20)
    226.                             {
    227.                                 for (int i = countdata; i < 20; i++)
    228.                                 {
    229.                                     listdataread.Add("");
    230.                                 }
    231.                             }
    232.                             // lưu dữ liệu
    233.                             using (SqlConnection conn = new SqlConnection(Connection_String))
    234.                             {
    235.                                 conn.Open();
    236.                                 string query = "";
    237.                                 //if (listdataread[0].Length >= 19 && listdataread[0].Contains("NR"))
    238.                                 //{
    239.                                 //    query = $"Insert into {DataTemplete.NameFunction} (Data1, Data2, Data3, Data4, Data5,Data6,Data7,Data8, Data9, Data10, Data11, Data12,Data13,Data14,Data15, Data16, Data17, Data18, Data19,Data20, TimeUpdate) Values('{listdataread[0].Substring(0, 12)}','{listdataread[1]}','{listdataread[2]}','{listdataread[3]}','{listdataread[4]}','{listdataread[5]}','{listdataread[6]}','{listdataread[7]}','{listdataread[8]}','{listdataread[9]}','{listdataread[10]}','{listdataread[11]}','{listdataread[12]}','{listdataread[13]}','{listdataread[14]}','{listdataread[15]}','{listdataread[16]}','{listdataread[17]}','{listdataread[18]}','{listdataread[19]}','{DateTime.Now}') ";
    240.                                 //}
    241.                                 //else
    242.                                 //{
    243.                                     query = $"Insert into {DataTemplete.NameFunction} (Data1, Data2, Data3, Data4, Data5,Data6,Data7,Data8, Data9, Data10, Data11, Data12,Data13,Data14,Data15, Data16, Data17, Data18, Data19,Data20, TimeUpdate) Values('{listdataread[0]}','{listdataread[1]}','{listdataread[2]}','{listdataread[3]}','{listdataread[4]}','{listdataread[5]}','{listdataread[6]}','{listdataread[7]}','{listdataread[8]}','{listdataread[9]}','{listdataread[10]}','{listdataread[11]}','{listdataread[12]}','{listdataread[13]}','{listdataread[14]}','{listdataread[15]}','{listdataread[16]}','{listdataread[17]}','{listdataread[18]}','{listdataread[19]}','{DateTime.Now}') ";
    244.  
    245.                                 //}
    246.                                 SqlCommand cmd = new SqlCommand(query, conn);
    247.                                 savedata = cmd.ExecuteNonQuery();
    248.                                 conn.Close();
    249.                             };
    250.                             // Xóa dữ liệu PLC
    251.                             if (savedata > 0)
    252.                             {
    253.                                 Task writeTaskClear = stream.WriteAsync(FinalCmdClearData, 0, FinalCmdClearData.Length, writeCancellationToken.Token);
    254.                                 if (await Task.WhenAny(writeTask, Task.Delay(Timeout, writeCancellationToken.Token)) != writeTask)
    255.                                 {
    256.                                     writeCancellationToken.Cancel();
    257.                                     throw new TimeoutException("Error Confirm Completed Send timed out.");
    258.                                 }
    259.                                 await writeTaskClear;
    260.                                 Task<int> readTaskClear = stream.ReadAsync(DataClear, 0, DataClear.Length, readCancellationToken.Token);
    261.                                 if (await Task.WhenAny(readTask, Task.Delay(Timeout, readCancellationToken.Token)) != readTask)
    262.                                 {
    263.                                     readCancellationToken.Cancel();
    264.                                     throw new TimeoutException("Error Confirm Completed Receive timed out.");
    265.                                 }
    266.                                 int bytesReadClear = await readTaskClear;
    267.                             }
    268.                         }
    269.                     }
    270.  
    271.                     client.Close();
    272.                 }
    273.             }
    274.             catch (Exception ex)
    275.             {
    276.                 return DateTime.Now.ToString() + "," + NameMachine + "," + ex.Message;
    277.             }
    278.             return "Finish";
    279.  
    280.         }
    281.         public int findnull(byte[] input)
    282.         {
    283.             int index = 0;
    284.             for (int i = 11; i < input.Length; i++)
    285.             {
    286.                 
    287.                 if (input[i] < 33 || input[i] > 126 )
    288.                 {
    289.                     return index;
    290.                 }
    291.                 index++;
    292.             }
    293.             return 80;
    294.         }
    295.     }
    296. }

  • 相关阅读:
    电脑是怎样上网的 (二) 从网线到网络设备
    【Linux学习笔记】代码编辑工具vim
    GitHub验证的2FA
    【数据分享】厦门市共享单车数据
    操作DAC模块
    Selenium自动访问Firefox和Chrome并实现搜索截图
    Python大作业——爬虫+可视化+数据分析+数据库（可视化篇）
    只许州官放火不许百姓点灯--CSDN博客停更并陆续删除通知
    Python语言程序设计 习题3
    Flink实时数仓之用户埋点系统（一）
  • 原文地址：https://blog.csdn.net/xdpcxq1029/article/details/134475657