• .NET的PLC帮助类

     TCP和UDP协议：

            TCP（传输控制协议）和UDP（用户数据报协议）是TCP/IP协议簇中的两种核心协议。它们在传输层上提供数据传输服务，但具有不同的特性和功能。

            TCP协议是一种提供可靠、面向连接的字节流服务的传输协议。在数据传输前，发送方和接收方必须先建立TCP连接，然后才能进行数据传输。它通过超时重发、丢弃重复数据、数据检验等功能，确保数据能从一端传输到另一端。

            UDP协议则是一种简单的面向数据报的传输层协议，它提供的是非面向连接、不可靠的数据流传输服务。由于UDP在传输数据报前不需要在客户和服务器之间建立连接，也没有超时重发等机制，因此其传输速度相对较快。但这也意味着它不能提供数据传输的可靠性保障。

            总的来说，TCP和UDP各有其优点和使用场景。TCP主要应用于可靠性要求高的应用，如网页浏览、文件传输等；而UDP则更适合于可靠性要求低、对传输速度和经济性有一定需求的应用，如视频流、游戏等。

    RS-232和RS-475通信接口标准及Modbus协议：

            RS-232是一种常见的串行通信接口标准，由美国电子工业协会（EIA）联合贝尔系统公司、调制解调器厂家及计算机终端生产厂家于1970年共同制定。其全名为“数据终端设备(DTE)和数据通信设备(DCE)之间串行二进制数据交换接口技术标准”。它通常被应用于计算机、调制解调器和各种电子设备之间的通信连接。

            RS-475是一种由美国电子工业协会（EIA）制定的半双工通信接口标准，它通常被应用于电子设备之间的数据传输。它采用平衡驱动和差分接收，因此具有较好的抗干扰能力，同时传输距离较远，可以达到数百米甚至千米级别。与RS-232不同的是，RS-475通常采用9针D型连接器，并且其引脚定义也与RS-232有所不同。RS-475主要用于工业、科学和医疗等领域的设备间通信，但由于其半双工的限制，应用场景不如RS-232和RS-485广泛。

            Modbus是一种串行通信协议，最初由Modicon公司（现在的施耐德电气 Schneider Electric）于1979年开发，用于可编程逻辑控制器（PLC）之间的通信。此协议已经成为工业领域通信协议的业界标准，并且现在是工业电子设备之间常用的连接方式。西门子的S1200和S1500用的就是Modbus协议

            Modbus协议定义了一个控制器能够识别的消息结构，不管它们是经过何种网络进行通信的。它描述了控制器请求访问其他设备的过程，如果回应来自其他设备的请求，以及怎样侦测错误并记录。它制定了消息域格局和内容的公共格式。当在Modbus网络上通信时，此协议决定了每个控制器需要知道它们的设备地址，识别按地址发来的消息，决定要产生何种行动。如果需要回应，控制器将生成反馈信息并用Modbus协议发出。总的来说，Modbus是一种应用于电子控制器之间的通用语言，通过它，不同厂商生产的控制设备可以连成工业网络，进行集中监控。

    一、使用HslCommunication程序集，官网：胡工科技。

    1. using Newtonsoft.Json.Linq;
    2. using System;
    3. using System.Collections.Generic;
    4. using System.Net;
    5. using System.Threading;
    6. using HslCommunication;
    7. using HslCommunication.Profinet.Siemens;
    8. using HslCommunication.Profinet.Omron;
    9. using HslCommunication.Profinet.Keyence;
    10.  
    11. namespace PLC.Class
    12. {
    13.     public class PLCHelper
    14.     {
    15.         #region 连接西门子PLC--SiemensS7Net
    16.         /// <summary>
    17.         /// 连接西门子PLC--SiemensS7Net
    18.         /// </summary>
    19.         /// <param name="siemens"></param>
    20.         /// <param name="ip">IP地址</param>
    21.         /// <param name="port">端口</param>
    22.         /// <returns></returns>
    23.         private bool ConnectSiemens(SiemensS7Net siemens, string ip, int port)
    24.         {
    25.             try
    26.             {
    27.                 IPAddress ipaddress;
    28.                 bool flag = !IPAddress.TryParse(ip, out ipaddress);
    29.                 if (flag)
    30.                 {
    31.                     return false;
    32.                 }
    33.                 else
    34.                 {
    35.                     siemens.IpAddress = ip;
    36.                     siemens.Port = port;
    37.                     OperateResult operateResult = siemens.ConnectServer();
    38.                     bool isSuccess = operateResult.IsSuccess;
    39.                     if (isSuccess)
    40.                     {
    41.                         return true;
    42.                     }
    43.                     else
    44.                     {
    45.                         return false;
    46.                     }
    47.                 }
    48.             }
    49.             catch (Exception)
    50.             {
    51.                 return false;
    52.             }
    53.         }
    54.  
    55.         /// <summary>
    56.         /// 给西门子PLC点位写信号
    57.         /// </summary>
    58.         /// <param name="siemens"></param>
    59.         /// <param name="ip">IP地址</param>
    60.         /// <param name="port">端口</param>
    61.         /// <param name="point">PLC点位</param>
    62.         /// <param name="flag">给点位传入的值</param>
    63.         /// <returns></returns>
    64.         public bool WriteFlagBySiemens(SiemensS7Net siemens, string ip, int port, string point, short flag)
    65.         {
    66.             if (ConnectSiemens(siemens, ip, port))
    67.             {
    68.                 OperateResult result = siemens.Write(point, flag);
    69.                 siemens.ConnectClose();
    70.                 return result.IsSuccess;
    71.             }
    72.             else
    73.             {
    74.                 return false;
    75.             }
    76.         }
    77.  
    78.         /// <summary>
    79.         /// 读取西门子PLC的状态
    80.         /// </summary>
    81.         /// <param name="siemens"></param>
    82.         /// <param name="ip">IP地址</param>
    83.         /// <param name="port">端口</param>
    84.         /// <param name="point">PLC点位</param>
    85.         /// <returns></returns>
    86.         public bool ReadBoolBySiemens(SiemensS7Net siemens, string ip, int port, string point)
    87.         {
    88.             if (ConnectSiemens(siemens, ip, port))
    89.             {
    90.                 OperateResult<bool> value = siemens.ReadBool(point);
    91.                 siemens.ConnectClose();
    92.                 return value.Content;
    93.             }
    94.             else
    95.             {
    96.                 return false;
    97.             }
    98.         }
    99.  
    100.         /// <summary>
    101.         /// 读取西门子PLC的值
    102.         /// </summary>
    103.         /// <param name="siemens"></param>
    104.         /// <param name="ip">IP地址</param>
    105.         /// <param name="port">端口</param>
    106.         /// <param name="point">PLC点位</param>
    107.         /// <param name="length">读取长度</param>
    108.         /// <returns></returns>
    109.         public string ReadStringBySiemens(SiemensS7Net siemens, string ip, int port, string point, ushort length)
    110.         {
    111.             if (ConnectSiemens(siemens, ip, port))
    112.             {
    113.                 OperateResult<string> result = new OperateResult<string>();
    114.                 result = siemens.ReadString(point, length);
    115.                 string source = string.Empty;
    116.  
    117.                 if (!string.IsNullOrEmpty(result.Content))
    118.                 {
    119.                     source = result.Content;
    120.                 }
    121.                 else
    122.                 {
    123.                     for (int i = 0; i < 3; i++)
    124.                     {
    125.                         Thread.Sleep(10);
    126.                         result = siemens.ReadString(point, length);
    127.                         if (!string.IsNullOrEmpty(result.Content))
    128.                         {
    129.                             source = result.Content;
    130.                             break;
    131.                         }
    132.                     }
    133.                     if (string.IsNullOrEmpty(result.Content))
    134.                     {
    135.                         return "未读取到PLC信息";
    136.                     }
    137.                 }
    138.                 siemens.ConnectClose();
    139.                 return source;
    140.             }
    141.             else
    142.             {
    143.                 return "false";
    144.             }
    145.         }
    146.  
    147.         /// <summary>
    148.         /// 清空西门子PLC点位中的值
    149.         /// </summary>
    150.         /// <param name="siemens"></param>
    151.         /// <param name="ip"></param>
    152.         /// <param name="port"></param>
    153.         /// <param name="point"></param>
    154.         /// <param name="length">写入的长度</param>
    155.         /// <returns></returns>
    156.         public bool ClearPlcPocketBySiemens(SiemensS7Net siemens, string ip, int port, string point, int length, string flag = " ")
    157.         {
    158.             if (ConnectSiemens(siemens, ip, port))
    159.             {
    160.                 OperateResult result = siemens.Write(point, flag, length);
    161.                 siemens.ConnectClose();
    162.                 return result.IsSuccess;
    163.             }
    164.             else
    165.             {
    166.                 return false;
    167.             }
    168.         }
    169.         #endregion
    170.  
    171.         #region 连接欧姆龙PLC--OmronFinsNet
    172.         /// <summary>
    173.         /// 连接欧姆龙PLC--OmronFinsNet
    174.         /// </summary>
    175.         /// <param name="omron"></param>
    176.         /// <param name="ip"></param>
    177.         /// <param name="port"></param>
    178.         /// <returns></returns>
    179.         private bool ConnectOmron(OmronFinsNet omron, string ip, int port)
    180.         {
    181.             //OmronFinsUdp
    182.             try
    183.             {
    184.                 IPAddress ipaddress;
    185.                 bool flag = !IPAddress.TryParse(ip, out ipaddress);
    186.                 if (flag)
    187.                 {
    188.                     return false;
    189.                 }
    190.                 else
    191.                 {
    192.                     omron.IpAddress = ip;
    193.                     omron.Port = port;
    194.                     omron.SA1 = 239;
    195.                     //if (ip240.Contains(ip))
    196.                     //{
    197.                     //    omron.SA1 = 240;
    198.                     //}
    199.                     //else
    200.                     //{
    201.                     //    omron.SA1 = 239;
    202.                     //}
    203.                     //omron.DA1 = 24;
    204.                     OperateResult operateResult = omron.ConnectServer();
    205.                     if (!operateResult.IsSuccess)
    206.                     {
    207.                         for (int i = 0;i < 3;i++)
    208.                         {
    209.                             operateResult = omron.ConnectServer();
    210.                             if (operateResult.IsSuccess)
    211.                             {
    212.                                 break;
    213.                                 //return true;
    214.                             }
    215.                         }
    216.                         //SA1使用239连接不上，则采取240连接
    217.                         if (!operateResult.IsSuccess)
    218.                         {
    219.                             omron.SA1 = 240;
    220.                             for (int i = 0; i < 3; i++)
    221.                             {
    222.                                 operateResult = omron.ConnectServer();
    223.                                 if (operateResult.IsSuccess)
    224.                                 {
    225.                                     break;
    226.                                     //return true;
    227.                                 }
    228.                             }
    229.                         }
    230.                         //if (!isSuccess)
    231.                         //{
    232.                         //    return false;
    233.                         //}
    234.                     }
    235.                     return operateResult.IsSuccess;
    236.                 }
    237.             }
    238.             catch (Exception ex)
    239.             {
    240.                 LogHelper.WriteErrLog(ex.ToString());
    241.                 return false;
    242.             }
    243.         }
    244.  
    245.         /// <summary>
    246.         /// 给欧姆龙PLC点位写信号
    247.         /// </summary>
    248.         /// <param name="siemens"></param>
    249.         /// <param name="ip">IP地址</param>
    250.         /// <param name="port">端口</param>
    251.         /// <param name="point">PLC点位</param>
    252.         /// <param name="flag">给点位传入的值</param>
    253.         /// <returns></returns>
    254.         public bool WriteShortByOmron(OmronFinsNet omron, string ip, int port, string point, short flag)
    255.         {
    256.             //if (ConnectOmron(omron, ip, port))
    257.             //{
    258.             OperateResult result = omron.Write(point, flag);
    259.             if (!result.IsSuccess)
    260.             {
    261.                 for (int i = 0;i < 3;i++)
    262.                 {
    263.                     result = omron.Write(point,flag);
    264.                     if (result.IsSuccess)
    265.                     {
    266.                         break;
    267.                         //return true;
    268.                     }
    269.                 }
    270.                 //if (!result.IsSuccess)
    271.                 //{
    272.                 //    return false;
    273.                 //}
    274.             }
    275.             //omron.ConnectClose();
    276.             return result.IsSuccess;
    277.             //}
    278.             //else
    279.             //{
    280.             //    return false;
    281.             //}
    282.         }
    283.  
    284.         //写入float值
    285.         public bool WriteFloatByOmron(OmronFinsNet omron, string ip, int port, string point, float flag)
    286.         {
    287.             //if (ConnectOmron(omron, ip, port))
    288.             //{
    289.             OperateResult result = omron.Write(point, flag);
    290.             if (!result.IsSuccess)
    291.             {
    292.                 for (int i = 0; i < 3; i++)
    293.                 {
    294.                     result = omron.Write(point, flag);
    295.                     if (result.IsSuccess)
    296.                     {
    297.                         break;
    298.                         //return true;
    299.                     }
    300.                 }
    301.                 //if (!result.IsSuccess)
    302.                 //{
    303.                 //    return false;
    304.                 //}
    305.             }
    306.             //omron.ConnectClose();
    307.             return result.IsSuccess;
    308.             //}
    309.             //else
    310.             //{
    311.             //    return false;
    312.             //}
    313.         }
    314.  
    315.         public string WritePointByOmron(OmronFinsNet omron, string ip, int port, List<string> pointlst, List<string> dataTypelst, List<string> valuelst,string type,List<string> filedlst)
    316.         {
    317.             //int sucNum = 0;
    318.             string errorFileds = "";
    319.             try
    320.             {
    321.                 if (type == "EDIT")
    322.                 {
    323.                     //return 0;
    324.                     return "";
    325.                 }
    326.                 //调用时以下6个点位不写入
    327.                 List<string> addNotWritePoint = new List<string>() { "D200", "D202", "D210", "D212", "D0", "D469" };
    328.                 if (ConnectOmron(omron, ip, port))
    329.                 {
    330.                     for (int i = 0; i < pointlst.Count; i++)
    331.                     {
    332.                         if (addNotWritePoint.Contains(pointlst[i]))
    333.                         {
    334.                             continue;
    335.                         }
    336.  
    337.                         if (dataTypelst[i] == "FLOAT" && !string.IsNullOrEmpty(valuelst[i]))
    338.                         {
    339.                             float flag = Convert.ToSingle(valuelst[i]);
    340.                             bool result = WriteFloatByOmron(omron, ip, port, pointlst[i], flag);
    341.                             if (result)
    342.                             {
    343.                                 //sucNum++;
    344.                             }
    345.                             else
    346.                             {
    347.                                 if (errorFileds.Length > 0)
    348.                                 {
    349.                                     errorFileds += ",";
    350.                                 }
    351.                                 errorFileds += filedlst[i];
    352.                                 LogHelper.WriteErrLog($"IP:{ip},端口:{port},点位:{pointlst[i]},值:{valuelst[i]}写入失败！");
    353.                             }
    354.                         }
    355.                         else if (dataTypelst[i] == "SHORT" && !string.IsNullOrEmpty(valuelst[i]))
    356.                         {
    357.                             short flag = Convert.ToInt16(valuelst[i]);
    358.                             bool result = WriteShortByOmron(omron, ip, port, pointlst[i], flag);
    359.                             if (result)
    360.                             {
    361.                                 //sucNum++;
    362.                             }
    363.                             else
    364.                             {
    365.                                 if (errorFileds.Length > 0)
    366.                                 {
    367.                                     errorFileds += ",";
    368.                                 }
    369.                                 errorFileds += filedlst[i];
    370.                                 LogHelper.WriteErrLog($"IP:{ip},端口:{port},点位:{pointlst[i]},值:{valuelst[i]}写入失败！");
    371.                             }
    372.                         }
    373.                     }
    374.                     //return sucNum;
    375.                 }
    376.                 //else
    377.                 //{
    378.                 //    return sucNum;
    379.                 //}
    380.             }
    381.             catch (Exception ex)
    382.             {
    383.                 LogHelper.WriteErrLog(ex.ToString());
    384.             }
    385.             finally
    386.             {
    387.                 omron.ConnectClose();
    388.             }
    389.             //return sucNum;
    390.             return errorFileds;
    391.         }
    392.  
    393.         /// <summary>
    394.         /// 读取欧姆龙PLC的状态
    395.         /// </summary>
    396.         /// <param name="siemens"></param>
    397.         /// <param name="ip">IP地址</param>
    398.         /// <param name="port">端口</param>
    399.         /// <param name="point">PLC点位</param>
    400.         /// <returns></returns>
    401.         public bool ReadBoolByOmron1(OmronFinsNet omron, string ip, int port, string point)
    402.         {
    403.             if (ConnectOmron(omron, ip, port))
    404.             {
    405.                 OperateResult<bool> value = omron.ReadBool(point);
    406.                 omron.ConnectClose();
    407.                 return value.Content;
    408.             }
    409.             else
    410.             {
    411.                 return false;
    412.             }
    413.         }
    414.  
    415.         //读取float型数据
    416.         public float ReadFloatByOmron(OmronFinsNet omron, string ip, int port, string point)
    417.         {
    418.             //if (ConnectOmron(omron, ip, port))
    419.             //{
    420.             OperateResult<float> value = omron.ReadFloat(point);
    421.             if (!value.IsSuccess)
    422.             {
    423.                 for (int i = 0;i < 3;i++)
    424.                 {
    425.                     value = omron.ReadFloat(point);
    426.                     if (value.IsSuccess)
    427.                     {
    428.                         break;
    429.                         //return value.Content;
    430.                     }
    431.                 }
    432.                 //if (!value.IsSuccess)
    433.                 //{
    434.                 //    return 0;
    435.                 //}
    436.             }
    437.             //omron.ConnectClose();
    438.             if (value.IsSuccess)
    439.             {
    440.                 return value.Content;
    441.             }
    442.             else
    443.             {
    444.                 return 0;
    445.             }
    446.             //}
    447.             //else
    448.             //{
    449.             //    return 0;
    450.             //}
    451.         }
    452.  
    453.         //读取short型数据
    454.         public short ReadShortByOmron(OmronFinsNet omron, string ip, int port, string point)
    455.         {
    456.             //if (ConnectOmron(omron, ip, port))
    457.             //{
    458.             OperateResult<short> value = omron.ReadInt16(point);
    459.             if (!value.IsSuccess)
    460.             {
    461.                 for (int i = 0; i < 3; i++)
    462.                 {
    463.                     value = omron.ReadInt16(point);
    464.                     if (value.IsSuccess)
    465.                     {
    466.                         break;
    467.                         //return value.Content;
    468.                     }
    469.                 }
    470.                 //if (!value.IsSuccess)
    471.                 //{
    472.                 //    return 0;
    473.                 //}
    474.             }
    475.             //omron.ConnectClose();
    476.             if (value.IsSuccess)
    477.             {
    478.                 return value.Content;
    479.             }
    480.             else
    481.             {
    482.                 return 0;
    483.             }
    484.             //}
    485.             //else
    486.             //{
    487.             //    return 0;
    488.             //}
    489.         }
    490.  
    491.         //读取Bool类型数据
    492.         public bool ReadBoolByOmron(OmronFinsNet omron, string ip, int port, string point)
    493.         {
    494.             OperateResult<bool> value = omron.ReadBool(point);
    495.             if (!value.IsSuccess)
    496.             {
    497.                 for (int i = 0; i < 3; i++)
    498.                 {
    499.                     value = omron.ReadBool(point);
    500.                     if (value.IsSuccess)
    501.                     {
    502.                         break;
    503.                     }
    504.                 }
    505.             }
    506.             if (value.IsSuccess)
    507.             {
    508.                 return value.Content;
    509.             }
    510.             else
    511.             {
    512.                 return false;
    513.             }
    514.         }
    515.  
    516.         public string ReadPointByOmron(OmronFinsNet omron, string ip, int port, List<string> filedlst, List<string> pointlst, List<string> datatypelst)
    517.         {
    518.             string result = "0";
    519.             JObject jObj = new JObject();
    520.  
    521.             try
    522.             {
    523.                 if (ConnectOmron(omron, ip, port))
    524.                 {
    525.                     for (int i = 0; i < pointlst.Count; i++)
    526.                     {
    527.                         if (datatypelst[i] == "FLOAT")
    528.                         {
    529.                             result = ReadFloatByOmron(omron, ip, port, pointlst[i]).ToString();
    530.                         }
    531.                         else if (datatypelst[i] == "SHORT")
    532.                         {
    533.                             result = ReadShortByOmron(omron, ip, port, pointlst[i]).ToString();
    534.                         }
    535.                         else if (datatypelst[i] == "BOOL" && pointlst[i] == "H10")
    536.                         {
    537.                             //涂布单双面3个点位细分—00：单面，01：双面，01；02：连续
    538.                             bool res = false;
    539.                             List<string> H10s = new List<string>() { "H10.00", "H10.01", "H10.02" };
    540.                             foreach (string h10 in H10s)
    541.                             {
    542.                                 res = ReadBoolByOmron(omron, ip, port, h10);
    543.                                 if (res)
    544.                                 {
    545.                                     result = h10.Substring(h10.Length - 1,1);
    546.                                     break;
    547.                                 }
    548.                             }
    549.                         }
    550.  
    551.                         jObj.Add(new JProperty(filedlst[i], result));
    552.                     }
    553.                 }
    554.             }
    555.             catch (Exception ex)
    556.             {
    557.                 LogHelper.WriteErrLog(ex.ToString());
    558.             }
    559.             finally
    560.             {
    561.                 omron.ConnectClose();
    562.             }
    563.             
    564.             return jObj.ToString();
    565.         }
    566.  
    567.         /// <summary>
    568.         /// 读取欧姆龙PLC的值
    569.         /// </summary>
    570.         /// <param name="siemens"></param>
    571.         /// <param name="ip">IP地址</param>
    572.         /// <param name="port">端口</param>
    573.         /// <param name="point">PLC点位</param>
    574.         /// <param name="length">读取长度</param>
    575.         /// <returns></returns>
    576.         public string ReadStringByOmron(OmronFinsNet omron, string ip, int port, string point, ushort length)
    577.         {
    578.             if (ConnectOmron(omron, ip, port))
    579.             {
    580.                 OperateResult<string> result = new OperateResult<string>();
    581.                 result = omron.ReadString(point, length);
    582.                 string source = string.Empty;
    583.  
    584.                 if (!string.IsNullOrEmpty(result.Content))
    585.                 {
    586.                     source = result.Content;
    587.                 }
    588.                 else
    589.                 {
    590.                     for (int i = 0; i < 3; i++)
    591.                     {
    592.                         Thread.Sleep(10);
    593.                         result = omron.ReadString(point, length);
    594.                         if (!string.IsNullOrEmpty(result.Content))
    595.                         {
    596.                             source = result.Content;
    597.                             break;
    598.                         }
    599.                     }
    600.                     if (string.IsNullOrEmpty(result.Content))
    601.                     {
    602.                         return "未读取到PLC信息";
    603.                     }
    604.                 }
    605.                 omron.ConnectClose();
    606.                 return source;
    607.             }
    608.             else
    609.             {
    610.                 return "false";
    611.             }
    612.         }
    613.  
    614.         /// <summary>
    615.         /// 清空欧姆龙PLC点位中的值
    616.         /// </summary>
    617.         /// <param name="siemens"></param>
    618.         /// <param name="ip"></param>
    619.         /// <param name="port"></param>
    620.         /// <param name="point"></param>
    621.         /// <param name="length">写入的长度</param>
    622.         /// <returns></returns>
    623.         public bool ClearPlcPocketByOmron(OmronFinsNet omron, string ip, int port, string point, int length, string flag = " ")
    624.         {
    625.             if (ConnectOmron(omron, ip, port))
    626.             {
    627.                 OperateResult result = omron.Write(point, flag, length);
    628.                 omron.ConnectClose();
    629.                 return result.IsSuccess;
    630.             }
    631.             else
    632.             {
    633.                 return false;
    634.             }
    635.         }
    636.         #endregion
    637.  
    638.         #region  连接基恩士PLC--KeyenceMcNet
    639.         /// <summary>
    640.         /// 连接基恩士PLC--KeyenceMcNet
    641.         /// </summary>
    642.         /// <param name="omron"></param>
    643.         /// <param name="ip"></param>
    644.         /// <param name="port"></param>
    645.         /// <returns></returns>
    646.         private bool ConnectKeyence(KeyenceMcNet keyence, string ip, int port)
    647.         {
    648.             try
    649.             {
    650.                 IPAddress ipaddress;
    651.                 bool flag = !IPAddress.TryParse(ip, out ipaddress);
    652.                 if (flag)
    653.                 {
    654.                     return false;
    655.                 }
    656.                 else
    657.                 {
    658.                     keyence.IpAddress = ip;
    659.                     keyence.Port = port;
    660.                     OperateResult operateResult = keyence.ConnectServer();
    661.                     bool isSuccess = operateResult.IsSuccess;
    662.                     if (isSuccess)
    663.                     {
    664.                         return true;
    665.                     }
    666.                     else
    667.                     {
    668.                         return false;
    669.                     }
    670.                 }
    671.             }
    672.             catch (Exception)
    673.             {
    674.                 return false;
    675.             }
    676.         }
    677.  
    678.         /// <summary>
    679.         /// 给基恩士PLC点位写信号
    680.         /// </summary>
    681.         /// <param name="siemens"></param>
    682.         /// <param name="ip">IP地址</param>
    683.         /// <param name="port">端口</param>
    684.         /// <param name="point">PLC点位</param>
    685.         /// <param name="flag">给点位传入的值</param>
    686.         /// <returns></returns>
    687.         public bool WriteFlagByKeyence(KeyenceMcNet keyence, string ip, int port, string point, short flag)
    688.         {
    689.             if (ConnectKeyence(keyence, ip, port))
    690.             {
    691.                 OperateResult result = keyence.Write(point, flag);
    692.                 keyence.ConnectClose();
    693.                 return result.IsSuccess;
    694.             }
    695.             else
    696.             {
    697.                 return false;
    698.             }
    699.         }
    700.  
    701.         /// <summary>
    702.         /// 读取基恩士PLC的状态
    703.         /// </summary>
    704.         /// <param name="siemens"></param>
    705.         /// <param name="ip">IP地址</param>
    706.         /// <param name="port">端口</param>
    707.         /// <param name="point">PLC点位</param>
    708.         /// <returns></returns>
    709.         public bool ReadBoolByKeyence(KeyenceMcNet keyence, string ip, int port, string point)
    710.         {
    711.             if (ConnectKeyence(keyence, ip, port))
    712.             {
    713.                 OperateResult<bool> value = keyence.ReadBool(point);
    714.                 keyence.ConnectClose();
    715.                 return value.Content;
    716.             }
    717.             else
    718.             {
    719.                 return false;
    720.             }
    721.         }
    722.  
    723.         /// <summary>
    724.         /// 读取基恩士PLC的值
    725.         /// </summary>
    726.         /// <param name="siemens"></param>
    727.         /// <param name="ip">IP地址</param>
    728.         /// <param name="port">端口</param>
    729.         /// <param name="point">PLC点位</param>
    730.         /// <param name="length">读取长度</param>
    731.         /// <returns></returns>
    732.         public string ReadStringByKeyence(KeyenceMcNet keyence, string ip, int port, string point, ushort length)
    733.         {
    734.             if (ConnectKeyence(keyence, ip, port))
    735.             {
    736.                 OperateResult<string> result = new OperateResult<string>();
    737.                 result = keyence.ReadString(point, length);
    738.                 string source = string.Empty;
    739.  
    740.                 if (!string.IsNullOrEmpty(result.Content))
    741.                 {
    742.                     source = result.Content;
    743.                 }
    744.                 else
    745.                 {
    746.                     for (int i = 0; i < 3; i++)
    747.                     {
    748.                         Thread.Sleep(10);
    749.                         result = keyence.ReadString(point, length);
    750.                         if (!string.IsNullOrEmpty(result.Content))
    751.                         {
    752.                             source = result.Content;
    753.                             break;
    754.                         }
    755.                     }
    756.                     if (string.IsNullOrEmpty(result.Content))
    757.                     {
    758.                         return "未读取到PLC信息";
    759.                     }
    760.                 }
    761.                 keyence.ConnectClose();
    762.                 return source;
    763.             }
    764.             else
    765.             {
    766.                 return "false";
    767.             }
    768.         }
    769.  
    770.         /// <summary>
    771.         /// 清空基恩士PLC点位中的值
    772.         /// </summary>
    773.         /// <param name="siemens"></param>
    774.         /// <param name="ip"></param>
    775.         /// <param name="port"></param>
    776.         /// <param name="point"></param>
    777.         /// <param name="length">写入的长度</param>
    778.         /// <returns></returns>
    779.         public bool ClearPlcPocketByKeyence(KeyenceMcNet keyence, string ip, int port, string point, int length, string flag = " ")
    780.         {
    781.             if (ConnectKeyence(keyence, ip, port))
    782.             {
    783.                 OperateResult result = keyence.Write(point, flag, length);
    784.                 keyence.ConnectClose();
    785.                 return result.IsSuccess;
    786.             }
    787.             else
    788.             {
    789.                 return false;
    790.             }
    791.         }
    792.         #endregion
    793.     }
    794. }

  • 相关阅读:
    超纯水制备
    【unity实战】unity3D中的PRG库存系统和换装系统（附项目源码）
    [附源码]计算机毕业设计基于JEE平台springboot技术的订餐系统
    PLT hook 方案 PLT hook
    【java苍穹外卖项目实战三】nginx反向代理和负载均衡
    华为云云耀云服务器L实例评测｜华为云云耀云服务器L实例开展性能评测
    时空智友企业信息管理系统任意文件读取漏洞复现
    7、使用Maven：IDEA环境
    非零基础自学Java (老师：韩顺平) 第5章 程序控制结构 5.7 for循环控制
    Pytorch单机多卡分布式训练
  • 原文地址：https://blog.csdn.net/weixin_50478033/article/details/133141855