Java实现OPC通讯

时间 2019-11-08

标签 java 实现 opc 通讯栏目 Java 繁體版

原文原文链接

1.PLC和OPC

使用的PLC：西门子的S7 300，具体型号以下图html

使用的OPC server软件：java

模拟仿真用的 MatrikonOPCSimulation（50M），百度网盘，密码: mcur
项目使用KEPServer V6（450M，中文）：百度网盘，密码: ykj2
Github上的：资料下载

2.链接测试

什么是OPC

OPC是工业控制和生产自动化领域中使用的硬件和软件的接口标准，以便有效地在应用和过程控制设备之间读写数据。O表明OLE(对象连接和嵌入)，P (process过程)，C (control控制)。git

OPC标准采用C/S模式，OPC服务器负责向OPC客户端不断的提供数据。github

OPC服务器包括3类对象(Object)：服务器对象(Server)、组对象(Group)和项对象(Item)。编程

来源：OPC-(二)-什么是OPCsegmentfault

OPC server软件使用

MatrikonOPC：使用Matrikon OPC Server Simulation
KEPServer V6：使用KEPServerEX 6

Server和Client

要实现的是Client（Java）和Client（PLC）之间的通讯数组

中间借助OPCServer，Server上设定好地址变量，不一样的Client读写这些变量值实现通讯。服务器

示意图以下异步

配置Server和Client

OPC和DCOM配置：通讯不成功都是配置的问题。。。maven

配置OPCserver
通常一个电脑（win10）同时安装Server（好比KEPServer）和Client(Java编写的)，就配置这个电脑就行
若是是在两个电脑上，那就都须要配置。

3.通讯实现

图片来源

Utgard

官网：http://openscada.org/projects/utgard/

编程指导

源码：https://github.com/ctron/org.openscada.utgard

Github上的

最全面的测试（Utgard和JeasyOPC测试）：OPC_Client

Utgard测试

博客参考

最重要参考：Java OPC client开发踩坑记

Java语言开发OPC之Utgard的数据访问方式

Utgard访问OPC server

4.实现过程

1.补充学习了一下OPC的概念：

OPC 协议认识

OPC技术学习总结

2.使用MatrikonOPC，了解OPCserver是怎么用的

OPC测试经常使用的OPCClient和OPCServer软件推荐

个人目的就是写一个相似的Java版的Client来链接OPC Server：使用Matrikon OPC Server Simulation

3.关于OPC UA

支持的OPC UA的西门子PLC至少是s7-1500

个人s7-300是无法用的，因此就不须要搜集OPC UA的资料了

4.关于用Java实现

C#和C++都不用配置DCOM，直接调用函数

既然是非要用Java，那就别想太方便，须要配置DCOM。

5.关于Utgard

utgard是一个开源的项目，基于j-interop作的，用于和OPC SERVER通信。

j-interop是纯java封装的用于COM/DCOM通信的开源项目，这样就没必要使用JNI

6.关于JeasyOPC

JeasyOPC源码下载

借助一个dll库来实现的和OPCServer的通讯，可是JCustomOpc.dll，，太老了，并且支持只32位系统

7.最终实现

固然选Utgard

过程就是把须要的jar包找到，

而后复制编程指导里的读写代码，读就是启动线程一直对相应地址变量读取数值，写就是对相应地址变量写入数值

8.测试

参考OPC_Client里的例子

关于配置文件的代码直接复制用了

例子实际也用不到，试了试，，由于实际只须要对地址变量读写数值就能够了

9.问题：

在虚拟机里用localhost一直报错，要写固定IP才行

配置里的IP是安装OPCServer软件的电脑的IP，若是使用无线链接，请查看无线的IP地址

能不能循环对一个组(group)监控？好像不能够，官方Demo里有两种数据读取方式：1.循环监控item；2.item添加到group,只读取一次

若是Java写的client和安装OPCServer软件是两台电脑：那两个电脑都要配置相同DCOM，包括帐号密码都要同样

win10家庭版是否能够？能够，有些麻烦，主要是用户管理部分配置，已经验证过能够，后续补充说明。

关于组态王，做为OPCSerever，怎么尝试都没链接上。

10.maven依赖

<!--utgard -->
        <dependency>
            <groupId>org.openscada.external</groupId>
            <artifactId>org.openscada.external.jcifs</artifactId>
            <version>1.2.25</version>
        </dependency>
        <dependency>
            <groupId>org.openscada.jinterop</groupId>
            <artifactId>org.openscada.jinterop.core</artifactId>
            <version>2.1.8</version>
        </dependency>
        <dependency>
            <groupId>org.openscada.jinterop</groupId>
            <artifactId>org.openscada.jinterop.deps</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.openscada.utgard</groupId>
            <artifactId>org.openscada.opc.dcom</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.openscada.utgard</groupId>
            <artifactId>org.openscada.opc.lib</artifactId>
            <version>1.5.0</version>
        </dependency>
        <dependency>
            <groupId>org.bouncycastle</groupId>
            <artifactId>bcprov-jdk15on</artifactId>
            <version>1.61</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-core</artifactId>
            <version>1.3.0-alpha4</version>
        </dependency>
        <dependency>
            <groupId>ch.qos.logback</groupId>
            <artifactId>logback-classic</artifactId>
            <version>1.3.0-alpha4</version>
            <scope>test</scope>
        </dependency>

5.代码

下载代码：

百度网盘，密码: ermn

蓝奏云

能够参考的代码：OPC-(四)-OPC Client Java调用之Utgard

截图：

说明

对地址变量进行读取数值和写入数值操做，通常分循环和批量两种方式，(同步和异步就不讨论了)：

循环读取：Utgard提供了一个AccessBase类来循环读取数值

循环写入：启动一个线程来循环写入数值

批量读取：经过组(Group)，增长项(Item)到组，而后对Item使用read()

批量写入：经过组(Group)，增长项(Item)到组，而后对Item使用write()

根据实际使用，对例子加了注释，方便理解

读取数值

import java.util.concurrent.Executors;

import org.jinterop.dcom.common.JIException;
import org.jinterop.dcom.core.JIString;
import org.jinterop.dcom.core.JIVariant;
import org.openscada.opc.lib.common.ConnectionInformation;
import org.openscada.opc.lib.da.AccessBase;
import org.openscada.opc.lib.da.DataCallback;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.ItemState;
import org.openscada.opc.lib.da.Server;
import org.openscada.opc.lib.da.SyncAccess;
 
public class UtgardTutorial1 {
 
    public static void main(String[] args) throws Exception {
        // 链接信息
        final ConnectionInformation ci = new ConnectionInformation(); 
        ci.setHost("192.168.0.1");         // 电脑IP
        ci.setDomain("");                  // 域，为空就行
        ci.setUser("OPCUser");             // 电脑上本身建好的用户名
        ci.setPassword("123456");          // 密码
 
        // 使用MatrikonOPC Server的配置
        // ci.setClsid("F8582CF2-88FB-11D0-B850-00C0F0104305"); // MatrikonOPC的注册表ID，能够在“组件服务”里看到
        // final String itemId = "u.u";    // MatrikonOPC Server上配置的项的名字按实际
 
        // 使用KEPServer的配置
        ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729"); // KEPServer的注册表ID，能够在“组件服务”里看到
        final String itemId = "u.u.u";    // KEPServer上配置的项的名字，没有实际PLC，用的模拟器：simulator
        // final String itemId = "通道 1.设备 1.标记 1";
 
        // 启动服务
        final Server server = new Server(ci, Executors.newSingleThreadScheduledExecutor());
 
        try {
            // 链接到服务
            server.connect();
            // add sync access, poll every 500 ms，启动一个同步的access用来读取地址上的值，线程池每500ms读值一次
            // 这个是用来循环读值的，只读一次值不用这样
            final AccessBase access = new SyncAccess(server, 500);
            // 这是个回调函数，就是读到值后执行这个打印，是用匿名类写的，固然也能够写到外面去
            access.addItem(itemId, new DataCallback() {
                @Override
                public void changed(Item item, ItemState itemState) {
                    int type = 0;
                    try {
                        type = itemState.getValue().getType(); // 类型实际是数字，用常量定义的
                    } catch (JIException e) {
                        e.printStackTrace();
                    }
                    System.out.println("监控项的数据类型是：-----" + type);
                    System.out.println("监控项的时间戳是：-----" + itemState.getTimestamp().getTime());
                    System.out.println("监控项的详细信息是：-----" + itemState);
 
                    // 若是读到是short类型的值
                    if (type == JIVariant.VT_I2) {
                        short n = 0;
                        try {
                            n = itemState.getValue().getObjectAsShort();
                        } catch (JIException e) {
                            e.printStackTrace();
                        }
                        System.out.println("-----short类型值： " + n); 
                    }
 
                    // 若是读到是字符串类型的值
                    if(type == JIVariant.VT_BSTR) {  // 字符串的类型是8
                        JIString value = null;
                        try {
                            value = itemState.getValue().getObjectAsString();
                        } catch (JIException e) {
                            e.printStackTrace();
                        } // 按字符串读取
                        String str = value.getString(); // 获得字符串
                        System.out.println("-----String类型值： " + str); 
                    }
                }
            });
            // start reading，开始读值
            access.bind();
            // wait a little bit，有个10秒延时
            Thread.sleep(10 * 1000);
            // stop reading，中止读取
            access.unbind();
        } catch (final JIException e) {
            System.out.println(String.format("%08X: %s", e.getErrorCode(), server.getErrorMessage(e.getErrorCode())));
        }
    }
}

读取数值与写入数值

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
 
import org.jinterop.dcom.common.JIException;
import org.jinterop.dcom.core.JIVariant;
import org.openscada.opc.lib.common.ConnectionInformation;
import org.openscada.opc.lib.da.AccessBase;
import org.openscada.opc.lib.da.DataCallback;
import org.openscada.opc.lib.da.Group;
import org.openscada.opc.lib.da.Item;
import org.openscada.opc.lib.da.ItemState;
import org.openscada.opc.lib.da.Server;
import org.openscada.opc.lib.da.SyncAccess;
 
public class UtgardTutorial2 {
    
    public static void main(String[] args) throws Exception {
 
        // 链接信息 
        final ConnectionInformation ci = new ConnectionInformation();
        
        ci.setHost("192.168.0.1");          // 电脑IP
        ci.setDomain("");                   // 域，为空就行
        ci.setUser("OPCUser");              // 用户名，配置DCOM时配置的
        ci.setPassword("123456");           // 密码
        
        // 使用MatrikonOPC Server的配置
        // ci.setClsid("F8582CF2-88FB-11D0-B850-00C0F0104305"); // MatrikonOPC的注册表ID，能够在“组件服务”里看到
        // final String itemId = "u.u";    // 项的名字按实际
 
        // 使用KEPServer的配置
        ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729"); // KEPServer的注册表ID，能够在“组件服务”里看到
        final String itemId = "u.u.u";    // 项的名字按实际，没有实际PLC，用的模拟器：simulator
        // final String itemId = "通道 1.设备 1.标记 1";
        
        // create a new server，启动服务
        final Server server = new Server(ci, Executors.newSingleThreadScheduledExecutor());
        try {
            // connect to server，链接到服务
            server.connect();
 
            // add sync access, poll every 500 ms，启动一个同步的access用来读取地址上的值，线程池每500ms读值一次
            // 这个是用来循环读值的，只读一次值不用这样
            final AccessBase access = new SyncAccess(server, 500);
            // 这是个回调函数，就是读到值后执行再执行下面的代码，是用匿名类写的，固然也能够写到外面去
            access.addItem(itemId, new DataCallback() {
                @Override
                public void changed(Item item, ItemState state) {
                    // also dump value
                    try {
                        if (state.getValue().getType() == JIVariant.VT_UI4) { // 若是读到的值类型时UnsignedInteger，即无符号整形数值
                            System.out.println("<<< " + state + " / value = " + state.getValue().getObjectAsUnsigned().getValue());
                        } else {
                            System.out.println("<<< " + state + " / value = " + state.getValue().getObject());
                        }
                    } catch (JIException e) {
                        e.printStackTrace();
                    }
                }
            });
 
            // Add a new group，添加一个组，这个用来就读值或者写值一次，而不是循环读取或者写入
            // 组的名字随意，给组起名字是由于，server能够addGroup也能够removeGroup，读一次值，就先添加组，而后移除组，再读一次就再添加而后删除
            final Group group = server.addGroup("test"); 
            // Add a new item to the group，
            // 将一个item加入到组，item名字就是MatrikonOPC Server或者KEPServer上面建的项的名字好比：u.u.TAG1，PLC.S7-300.TAG1
            final Item item = group.addItem(itemId);
 
            // start reading，开始循环读值
            access.bind();
 
            // add a thread for writing a value every 3 seconds
            // 写入一次就是item.write(value)，循环写入就起个线程一直执行item.write(value)
            ScheduledExecutorService writeThread = Executors.newSingleThreadScheduledExecutor();
            writeThread.scheduleWithFixedDelay(new Runnable() {
                @Override
                public void run() {
                    final JIVariant value = new JIVariant("24");  // 写入24
                    try {
                        System.out.println(">>> " + "写入值：  " + "24");
                        item.write(value);
                    } catch (JIException e) {
                        e.printStackTrace();
                    }
                }
            }, 5, 3, TimeUnit.SECONDS); // 启动后5秒第一次执行代码，之后每3秒执行一次代码
 
            // wait a little bit ，延时20秒
            Thread.sleep(20 * 1000);
            writeThread.shutdownNow();  // 关掉一直写入的线程
            // stop reading，中止循环读取数值
            access.unbind();
        } catch (final JIException e) {
            System.out.println(String.format("%08X: %s", e.getErrorCode(), server.getErrorMessage(e.getErrorCode())));
        }
    }
}

数组类型

若是地址变量的数据类型是数组类型呢？

// 读取Float类型的数组
if (type == 8196) { // 8196是打印state.getValue().getType()获得的
    JIArray jarr = state.getValue().getObjectAsArray(); // 按数组读取
    Float[] arr = (Float[]) jarr.getArrayInstance();  // 获得数组
    String value = "";
    for (Float f : arr) {
        value = value + f + ",";
    }
    System.out.println(value.substring(0, value.length() - 1); // 遍历打印数组的值，中间用逗号分隔，去掉最后逗号
}

// 写入3位Long类型的数组
Long[] array = {(long) 1,(long) 2,(long) 3}; 
final JIVariant value = new JIVariant(new JIArray(array));
item.write(value);

读取和写入数值须要按数据类型来操做

这是经常使用的数据类型