C#与欧姆龙NX系列PLC通讯

最新推荐文章于 2024-05-27 15:49:14 发布
最新推荐文章于 2024-05-27 15:49:14 发布
阅读量9.7k 收藏 74
点赞数 10
文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xhyangxianjun/article/details/115273987
版权

  由于项目需要C#跟欧姆龙NX系列PLC通讯，网上百度NX系列的PLC这方面的案例很少，且NXPLC不支持Fins通信，也不支持OPCUA.只能通过Ethernet/IP与其进行通信

采用CX-Compolet控件
 

先上图片：

 

实现核心代码

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using OMRON.Compolet.CIP;
using System.Collections;

namespace Plc
{
    /// <summary>
    /// 欧姆龙CIPCompolet协议
    /// </summary>
    public class OmronCIP
    {
        /// <summary>
        /// 软元件代码
        /// </summary>
        private enum CIPElementCode
        {
            UCMM = 0,
            Class3=1
        };

         /// <summary>
        /// 接收的等待时间
        /// </summary>
        private int m_nWaitingTime;

        /// <summary>
        /// 通信网口
        /// </summary>
        private NXCompolet m_TcpLink;
        /// <summary>
        /// 心跳时间
        /// </summary>
        private int HeartBeatTimer;
        /// <summary>
        /// 本地端口
        /// </summary>
        private int LocalPort;
        /// <summary>
        /// PLC地址
        /// </summary>
        private string PeerAddress;
        /// <summary>
        /// 接收数据超时
        /// </summary>
        private long ReceiveTimeLimit;
        /// <summary>
        /// 第二连接PLC地址
        /// </summary>
        private string RoutePath;
        /// <summary>
        /// 连接类型
        /// </summary>
        private int ConnectionType;


        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="tl">网口</param>
        public OmronCIP(string peerAddress= "192.168.250.1",long receiveTimeLimit=750,int localPort=2, int connectionType =0
            ,int heartBeatTimer=0,string routePath= "2%192.168.250.1")
        {
            //变量初使化赋值
            PeerAddress = peerAddress;
            ReceiveTimeLimit = receiveTimeLimit;
            LocalPort = localPort;
            LocalPort = localPort;
            ConnectionType = connectionType;
            HeartBeatTimer = heartBeatTimer;
            RoutePath = routePath;
            //建立PLC连接变量
            m_TcpLink = new NXCompolet();
            m_TcpLink.ConnectionType = (OMRON.Compolet.CIP.ConnectionType)ConnectionType;
            m_TcpLink.DontFragment = false;
            m_TcpLink.HeartBeatTimer = HeartBeatTimer;
            m_TcpLink.LocalPort = LocalPort;
            m_TcpLink.PeerAddress = PeerAddress;
            m_TcpLink.ReceiveTimeLimit = ReceiveTimeLimit;
            m_TcpLink.RoutePath = RoutePath;
            m_TcpLink.UseRoutePath = false;                       
        }

        public NXCompolet GetTcp
        {
            get
            {
                return m_TcpLink;
            }

        }
        /// <summary>
        /// 设置接收的等待时间
        /// </summary>
        /// <param name="nMs">超时时间，单位:S</param>
        public void SetWaitingTime(int nMs)
        {
            int nCount = nMs;

            if (nCount <= 0)
            {
                m_nWaitingTime = 1;
                ReceiveTimeLimit = 1;
            }        
            else
            {
                m_nWaitingTime = nCount;
                ReceiveTimeLimit = nCount;
            }         
        }
        /// <summary>
        /// 写入位
        /// </summary>
        /// <param name="BinaryValue"></param>
        /// <param name="bVals"></param>
        /// <returns></returns>
        public bool WriteBit(string BinaryValue, bool bVals)
        {
            byte[] val;
            try
            {
                if(bVals)
                {
                    val = StringToByteArray("0100");
                }
                else
                {
                    val = StringToByteArray("0000");
                }
                m_TcpLink.WriteRawData(BinaryValue, val);
                return true;
            }
            catch(Exception ex)
            {
                              
            }
            return false;
        }

        /// <summary>
        /// 写入多个位
        /// </summary>
        /// <param name="valueList"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public bool WriteMultiBit(string[] valueList, bool[] data)
        {
            try
            {
                string[] varlist = valueList;

                if (varlist == null || varlist.Length == 0)
                {
                    return false;
                }
                
                for(int i= 0; i < valueList.Length; i++)
                {
                    byte[] val;
                    try
                    {
                        if (data[i])
                        {
                            val = StringToByteArray("0100");
                        }
                        else
                        {
                            val = StringToByteArray("0000");
                        }
                        m_TcpLink.WriteRawData(valueList[i], val);                       
                    }
                    catch
                    {
                        throw new NotSupportedException();
                    }
                }               
                return true;
            }
            catch (Exception ex)
            {
                            
            }
            finally
            {

            }
            return false;
        }

        public bool WriteWord(string BinaryValue, string bVals)
        {
            try
            {
                string valWrite = BinaryValue;
                if (valWrite.StartsWith("_"))
                {
                    MessageBox.Show("The SystemVariable can not write!");
                    return false;
                }
                object val = RemoveBrackets(bVals);
                if (m_TcpLink.GetVariableInfo(BinaryValue).Type == VariableType.STRUCT)
                {
                    val = ObjectToByteArray(val);
                }
                m_TcpLink.WriteVariable(BinaryValue, val);
                return true;
            }
            catch(Exception ex)
            {
                

            }

            return false;
        }

        public bool WriteString(string BinaryValue, string bVals)
        {
            try
            {
                string valWrite = BinaryValue;
                if (valWrite.StartsWith("_"))
                {
                    MessageBox.Show("The SystemVariable can not write!");
                    return false;
                }
                object val = this.RemoveBrackets(bVals);
                if (m_TcpLink.GetVariableInfo(BinaryValue).Type == VariableType.STRING)
                {
                    //val = this.ObjectToByteArray(val);
                }
                m_TcpLink.WriteVariable(BinaryValue, val);
                return true;
            }
            catch (Exception ex)
            {


            }
            return false;
        }
        /// <summary>
        /// 读取位
        /// </summary>
        /// <param name="BinaryValue"></param>
        /// <returns></returns>
        public bool ReadBit(string BinaryValue)
        {
          
            try
            {
                if (BinaryValue == null)
                {
                    return false;
                }
                object obj = m_TcpLink.ReadRawData(BinaryValue);
                VariableInfo info = m_TcpLink.GetVariableInfo(BinaryValue);
                string val = this.ByteArrayToString(obj as byte[]);
                if( val == "01-00")
                {
                    return true;
                }
                else if(val == "00-00")
                {
                    return false;
                }
                else
                {
                    return false;
                }
            }   
            catch(Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC读取异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            finally
            {
               
            }
            return false;
        }

         /// <summary>
         /// 读取多个位
         /// </summary>
         /// <param name="BinaryMultiValue"></param>
         /// <param name="result"></param>
        public void ReadMultiBit(string BinaryMultiValue,ref string result)
        {
            try
            {
                if (BinaryMultiValue == null)
                {
                    return;
                }
                string[] varlist = BinaryMultiValue.Replace(" ", String.Empty).Split(',');
                Hashtable retVals = m_TcpLink.ReadRawDataMultiple(varlist);
                string multival = string.Empty;
                for (int index = 0; index < varlist.Length; index++)
                {
                    string varName = varlist[index];
                    string val = this.ByteArrayToString(retVals[varName] as byte[]);

                    
                    multival += val + ",";
                }
                multival = multival.TrimEnd(',');
                result = multival;

            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC读取异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            finally
            {

            }
            return;
        }
        /// <summary>
        /// 读取字
        /// </summary>
        /// <param name="BinaryValue"></param>
        /// <returns></returns>
        public bool ReadString(string BinaryValue,ref string result)
        {

            try
            {
                if (BinaryValue == null)
                {
                    return false;
                }
                object obj = m_TcpLink.ReadVariable(BinaryValue);
                if (obj == null)
                {
                    throw new NotSupportedException();
                }
                VariableInfo info = m_TcpLink.GetVariableInfo(BinaryValue);
                string str = GetValueOfVariables(obj);
                result = str;
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC读取异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            finally
            {

            }
            return false;
        }
        /// <summary>
        /// 读取字
        /// </summary>
        /// <param name="BinaryValue"></param>
        /// <returns></returns>
        public short ReadWord(string BinaryValue)
        {

            try
            {
                if (BinaryValue == null)
                {
                    return 0;
                }
                object obj = m_TcpLink.ReadVariable(BinaryValue);
                if (obj == null)
                {
                    throw new NotSupportedException();
                }
                VariableInfo info = m_TcpLink.GetVariableInfo(BinaryValue);
                string str = GetValueOfVariables(obj);
                short res = Convert.ToInt16(str);
                return res;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC读取异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            finally
            {

            }
            return 0;
        }
        /// <summary>
        /// 读取多个字
        /// </summary>
        /// <param name="valueList"></param>
        /// <param name="data"></param>
        /// <returns></returns>
        public bool ReadMultiWord(string[] valueList,ref short[] data)
        {
            try
            {
                string[] varlist = valueList;
                if (varlist == null || varlist.Length == 0)
                {
                    return false;
                }
                short[] res = new short[varlist.Length];
                Hashtable retVals = m_TcpLink.ReadVariableMultiple(varlist);
                string multival = string.Empty;
                if (retVals == null)
                {
                    throw new NotSupportedException();
                }
                for (int index = 0; index < varlist.Length; index++)
                {
                    string varName = varlist[index];
                    object val = retVals[varName];
                    string valStr = this.GetValueOfVariables(val);            
                    multival += valStr + ",";
                    res[index] = Convert.ToInt16(valStr);

                }
                multival = multival.TrimEnd(',');
                return true;
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC读取异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            finally
            {
               
            }
            return false;
        }

 

        /// <summary>
        /// 打开设备
        /// </summary>
        /// <returns></returns>
        public  bool Open()
        {
            try
            {
                m_TcpLink.Active = true;
                if (m_TcpLink.IsConnected)
                {
                    return true;
                }
                else
                {
                    m_TcpLink.Active = false;                    
                    MessageBox.Show("Connection failed !" + System.Environment.NewLine + "Please check PeerAddress.", "PLC异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                m_TcpLink.Active = false;
            }
            return false;
        }
        public bool IsOpen()
        {
            if(m_TcpLink != null)
            {
                return m_TcpLink.IsConnected;
            }
            return false;
        }
        /// <summary>
        /// 关闭设备
        /// </summary>
        public  void Close()
        {
            try
            {
                if (m_TcpLink.IsConnected)
                {
                    m_TcpLink.Active = false;   
                                   
                }
                else
                {
                    m_TcpLink.Active = false;                   
                    MessageBox.Show("Connection failed !" + System.Environment.NewLine + "Please check PeerAddress.", "PLC异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message, "PLC异常", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                m_TcpLink.Active = false;
            }
        }

        #region 常用功能函数
        private void DisplayVariableInfomation(string str, Control con)
        {
            ListView listViewOfVariableNames = con as ListView;
            ListViewItem item = listViewOfVariableNames.Items.Add(str);
            VariableInfo info = m_TcpLink.GetVariableInfo(str);
            if (info.IsArray)
            {
                string text = info.Type.ToString();
                foreach (long num in info.NumberOfElements)
                {
                    text += "[" + num.ToString() + "]";
                }
                item.SubItems.Add(text);
            }
            else
            {
                item.SubItems.Add(info.Type.ToString());
            }
            item.SubItems.Add(string.Empty);
        }

        private bool IsMustElementAccess(VariableInfo info)
        {
            bool toReturn = false;
            if (info.IsArray)
            {
                if (info.Type == VariableType.STRING || info.Type == VariableType.UNION)
                {
                    toReturn = true;
                }
            }

            return toReturn;
        }

        private bool IsMustMemberAccess(VariableInfo info)
        {
            bool toReturn = false;

            if (info.Type == VariableType.UNION)
            {
                toReturn = true;
            }

            return toReturn;
        }

        private String GetAccessablePath(String path)
        {
            String newPath = String.Empty;
            newPath += path;
            VariableInfo info = m_TcpLink.GetVariableInfo(path);
            if (this.IsMustElementAccess(info))
            {
                // get only first element
                for (int i = 0; i < info.Dimension; i++)
                {
                    newPath += "[" + info.StartArrayElements[i].ToString() + "]";
                }
                return this.GetAccessablePath(newPath);
            }
            else if (this.IsMustMemberAccess(info))
            {
                // get only first member
                newPath += "." + info.StructMembers[0].Name;
                return this.GetAccessablePath(newPath);
            }
            else
            {
                return newPath;
            }
        }

        private string GetValueOfVariables(object val)
        {
            string valStr = string.Empty;
            if (val.GetType().IsArray)
            {
                Array valArray = val as Array;
                if (valArray.Rank == 1)
                {
                    valStr += "[";
                    foreach (object a in valArray)
                    {
                        valStr += this.GetValueString(a) + ",";
                    }
                    valStr = valStr.TrimEnd(',');
                    valStr += "]";
                }
                else if (valArray.Rank == 2)
                {
                    for (int i = 0; i <= valArray.GetUpperBound(0); i++)
                    {
                        valStr += "[";
                        for (int j = 0; j <= valArray.GetUpperBound(1); j++)
                        {
                            valStr += this.GetValueString(valArray.GetValue(i, j)) + ",";
                        }
                        valStr = valStr.TrimEnd(',');
                        valStr += "]";
                    }
                }
                else if (valArray.Rank == 3)
                {
                    for (int i = 0; i <= valArray.GetUpperBound(0); i++)
                    {
                        for (int j = 0; j <= valArray.GetUpperBound(1); j++)
                        {
                            valStr += "[";
                            for (int z = 0; z <= valArray.GetUpperBound(2); z++)
                            {
                                valStr += this.GetValueString(valArray.GetValue(i, j, z)) + ",";
                            }
                            valStr = valStr.TrimEnd(',');
                            valStr += "]";
                        }
                    }
                }
            }
            else
            {
                valStr = this.GetValueString(val);
            }
            return valStr;
        }

        private string GetValueString(object val)
        {
            if (val is float || val is double)
            {
                return string.Format("{0:R}", val);
            }
            else
            {
                return val.ToString();
            }
        }

        private object RemoveBrackets(string val)
        {
            object obj = string.Empty;
            if (val.IndexOf("[") >= 0)
            {
                string str = val.Trim('[', ']');
                str = str.Replace("][", ",");
                obj = str.Split(',');
            }
            else
            {
                obj = val;
            }
            return obj;
        }

        private string ByteArrayToString(byte[] ba)
        {
            if (ba.Length == 0)
            {
                return string.Empty;
            }
            else
            {
                return BitConverter.ToString(ba);
            }
        }

        private byte[] StringToByteArray(string hex)
        {
            if (hex == String.Empty)
            {
                return new Byte[0];
            }
            int byteNumber = hex.Length / 2;
            byte[] bytes = new byte[byteNumber];
            for (int i = 0; i < hex.Length; i += 2)
            {
                bytes[i / 2] = Convert.ToByte(hex.Substring(i, 2), 16);
            }
            return bytes;
        }

        private byte[] ObjectToByteArray(object obj)
        {
            if (obj is Array)
            {
                Array arr = obj as Array;
                Byte[] bin = new Byte[arr.Length];
                for (int i = 0; i < bin.Length; i++)
                {
                    bin[i] = Convert.ToByte(arr.GetValue(i));
                }
                return bin;
            }
            else
            {
                return new Byte[1] { Convert.ToByte(obj) };
            }
        }
        #endregion

    }
}

 

杨大军
关注
  • 10
    点赞
  • 踩
  • 74
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
OMRON CX-Compolet帮助文档
08-13
OMRON CX-Compolet帮助文档！！！！！！！！！！！！！！！！
C#基于OPC服务器读写欧姆龙PLC数据实例源码
01-08
【工控老马出品，必属精品，质量保证，亲测能用】 资源名：C#基于OPC服务器读写欧姆龙PLC数据实例源码 资源类型：程序源代码 源码说明： 本资源详细介绍了用C#编写客户端程序连接OPC服务器，从而实现上位机与PLC的数据通讯。 适合人群：新手及有一定经验的开发人员
C#与欧姆龙PLC NX102-9000测试FINS通信，使用TCP连接方式，保证通信数据重要性，实时?
最新发布
VylnHyggo的博客
05-27 505
在使用C#编程语言与欧姆龙PLC NX102-9000进行FINS通信时，我们可以通过调用相关的API来实现各种功能，如实时监测通信是否断线、实时读取寄存器数据以及将本机数据写入到数据寄存器等。通过将上述的通信、读取和写入等功能进行组合，我们可以实现与多台PLC之间的高效数据交互，从而满足工业环境中对数据的实时监测和处理的需求。通过将本机数据写入到D11000至D12000数据寄存器，我们可以将C#程序中的数据传递给PLC，从而实现数据交换的正常进行。这样可以及时发现通信故障，并进行相应的处理。
OMRONPLC通过TCPIP协议通信实例C#源码
01-09
【工控老马出品，必属精品，质量保证，亲测能用】 资源名：OMRONPLC通过TCPIP议通信实例C#源码 资源类型：程序源代码 源码说明： C#写的与OMRON的PLC通过TCP/IP协议通信的实例 适合人群：新手及有一定经验的开发人员
C#与欧姆龙全系列PLC以太网通讯的DLL和源码
01-11
【工控老马出品，必属精品，质量保证，亲测能用】 资源名：C#与欧姆龙全系列PLC以太网通讯的DLL和源码 资源类型：程序源代码 源码说明： 包含了所有dll文件和整套源码，适用欧姆龙全系列的PLC以太网通讯 适合人群：新手及有一定经验的开发人员
C#和欧姆龙PLC通信程序源代码
12-16
【亲测实用】C#和欧姆龙PLC通信程序源代码 文件类型：程序源代码 主要功能： 欧姆龙以太网FINS协议的C#通讯库 带精美UI界面 适合人群：新手及有一定经验的开发人员
OMRON欧姆龙FA通信组件CX-Compolet V2
12-09
CX-Compolet 通过VB或VC#轻松编写程序以及读写 PLC数据。 易于使用，无需任何技术知识 ●提供了有助于您轻松、快速开发PLC通信的软件器件。 ●在不需要考虑网络间差异的情况下读写PLC数据。 ● 支持Microsoft Visual Studio .NET 2008。 ●对于带有EtherNet/IP功能的CJ2，可以通过使用名称（而非地址）来访问PLC中的I/O存储器。 ● 可以进行数组变量访问。 安装时似乎会提示需要finsgateway, 以下是链接 http://download.csdn.net/download/wahaha543/10151934
OMRON Compolet以太网通信
leoly202122的博客
10-17 1717
EtherNet/IP(EtherNet Industry Protocol)是适合工业环境应用的协议体系。它是由两大工业组织ODVA和ControlNet International所推出的最新的成员。它是一种是面向对象的协议。
欧姆龙PLC的CIP协议报文
ylq1045的专栏
04-03 5564
/-------------------------------------------------------CommandSpecificData 指令指定数据 4byte。//-------------------------------------------------------CommandSpecificData 指令指定数据 4byte。0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,//发送方描述默认0 8byte。
OMRON欧姆龙FA通信组件CX-Compolet V2 + finsgateway V2003
12-09
主要3个控件: OMRON SYSMAC C Control OMRON SYSMAC CS1 Control OMRON SYSMAC CV Control vb中使用时在部件中添加一下对应PLC的控件, 相关设置配置好就能直接读写PLC数据了, 非常方便 CX-Compolet 通过VB或VC#轻松编写程序以及读写 PLC数据。 易于使用，无需任何技术知识 ●提供了有助于您轻松、快速开发PLC通信的软件器件。 ●在不需要考虑网络间差异的情况下读写PLC数据。 ● 支持Microsoft Visual Studio .NET 2008。 ●对于带有EtherNet/IP功能的CJ2，可以通过使用名称（而非地址）来访问PLC中的I/O存储器。 ● 可以进行数组变量访问。
C#与欧姆龙PLC实现CIP通讯
花开莫与流年错_的博客
03-05 1386
C#与欧姆龙PLC实现CIP通讯
C#和欧姆龙PLC通信程序 .zip
06-09
C#和欧姆龙PLC通信程序
适合欧姆龙PLC通信组件dll.zip
06-02
最近项目需要用上位机通讯Omron PLC，使用无线网络的Fins协议，经测试通过后代码如下： 使用方法： 1、引用此命名空间； 2、实例化类FinsTcp; 3、调用连接函数conn(); 4、读取写入操作（读位数据，写位数据，读字数据，写字数据 具体代码参考他人吧，要努力小伙子
欧姆龙PLC CIP通信 C#实例源码
01-19
【达摩老生出品，必属精品，亲测校正，质量保证】 资源名：欧姆龙PLC CIP通信 C#实例源码 资源类型：程序源代码 源码说明： 这是一个通过C#网络socket功能，通过CIP协议实现AB，欧姆龙NJ/NX系列PLC简单标签（不包括数组结构体联合体）读写的例子，希望给研究CIP协议通信采集PLC数据的同学一个参考。 适合人群：新手及有一定经验的开发人员
用VB调用COMPOLET的CIP控件和PLC做数据交换.pdf
11-13
OMRON厂家提供的示例，亲测可用，如果需要详细的步骤请联系我的微信，微信和帐户同号，CSDN不常登陆使用，最重要的是免费的哦。不收钱！当初为了学这个还花了500块钱冤枉钱，结果还什么没学到，对方提供的DLL文件根本不可用。
C#实现与欧姆龙PLC以太网通讯源码-Fins UDP
07-16
本项目聚焦于C#语言如何实现与欧姆龙PLC的以太网通信，特别是通过FINS（Factory Integration Network System）协议，这是一项专为欧姆龙设备设计的通讯协议。 FINS协议允许用户通过TCP/IP或UDP/IP在网络中进行设备...
欧姆龙NJNX(标签方式)与西门子PLC通讯
05-09
本案例是欧姆龙的NJ501与西门子的S7-1500的PLC之间以太网跨网段通讯，NJ501采用标签方式通讯。通过IGT-DSER的参数配置软件(下载地址)配置完成的PLC数据交互地址表，包括PLC的IP地址网络端口、寄存器标签地址，以及...
C#通讯欧姆龙NJPLC
acheng
04-02 1800
/PLC的IP地址 plc.UnitAddress = 0;//PLC的单元地址 //读取D寄存器 int[] data = new int[10];//写入D寄存器 int[] newData = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };} } } ``` 以上代码演示了如何使用C#中的OMRON.Compolet.CIPCompolet64库实现对欧姆龙PLC NJ系列的读写操作。
Labview+Hsl通讯（与欧姆龙NX1P2通讯）
weixin_45373784的博客
03-01 2149
通过和欧姆龙客服沟通，NX1P2不支持fins tcp与OPC UA，但是支持FINS-UDP通讯，没办将就用吧。这里PLC IP: 192.168.250.0.1 端口：9600 下面是测试图。PC端的端口随意填就行，不要和PLC端口重复就行。
欧姆龙nx系列plc与上位机通讯c#
06-07
欧姆龙NX系列PLC与上位机通讯主要有两种方式：以太网通讯和串口通讯。以太网通讯方式可以直接通过RJ45接口连接上位机，通讯速度快，且支持远程访问，便于远程监控和管理。同时，该方式支持多协议通讯，可以与多种不同类型的上位机进行通讯，提高了通讯的灵活性和可扩展性。串口通讯方式则常用于PLC与单片机的通讯，通讯速度相对较慢，但支持的协议更多。因此，在选择PLC与上位机通讯方式时，需要根据具体的应用场景选择不同的方式，以达到更好的通讯效果。另外，在配置PLC网络时，需要注意网络拓扑结构、IP地址的设置等问题，以确保通讯的稳定性和安全性。总之，欧姆龙NX系列PLC提供了灵活、可靠的通讯方式，可以满足不同领域和应用的需求。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值