Java实现OPC通信
utgard库已经过时，原作者早已删除库，建议使用OPC UA
有问题可以私信和评论，看到会回复。
录屏简单说了一下文章内容，视频地址：https://www.bilibili.com/video/BV13V411f7Ch/
1.PLC和OPC
使用的PLC：西门子的S7-300，具体型号如下图
使用的OPC server软件：
- 项目使用KEPServer V6（427M，中文）：百度网盘 ，密码: ykj2
- KEPServer的123网盘分享：https://www.123pan.com/s/Lwn8Vv-4qnx 提取码：pTA9
- 模拟仿真用的 MatrikonOPCSimulation（50M），百度网盘，密码: mcur
- OPC Simulation Server的123网盘分享：https://www.123pan.com/s/Lwn8Vv-1qnx 提取码：xzBf
2.连接测试
什么是OPC
OPC是工业控制和生产自动化领域中使用的硬件和软件的接口标准，以便有效地在应用和过程控制设备之间读写数据。O代表OLE(对象链接和嵌入)，P (process过程)，C (control控制)。
OPC服务器包括3类对象(Object)：服务器对象(Server)、项对象(Item)和组对象(Group)。
OPC标准采用C/S模式，OPC服务器负责向OPC客户端不断的提供数据。
OPC server软件使用
- MatrikonOPC： 使用Matrikon OPC Server Simulation
- KEPServer V6： 使用KEPServerEX 6
Server和Client
要实现的是Client（Java）和Client（PLC）之间的通信
中间借助OPCServer，Server上设定好地址变量，不同的Client读写这些变量值实现通信。
示意图如下
配置Server和Client
OPC和DCOM配置：通信不成功都是配置的问题。。。
配置OPCserver
一般一个电脑（win10）同时安装Server（比如KEPServer）和Client(Java编写的)，就配置这个电脑就行
如果是在两个电脑上，那就都需要配置。
3.通信实现
Utgard
Github上的
- 最全面的测试（Utgard和JeasyOPC测试）：OPC_Client
- Utgard测试
博客参考
- 最重要参考：Java OPC client开发踩坑记
- Github上的：资料下载
- Java语言开发OPC之Utgard的数据访问方式
- Utgard访问OPC server
4.实现过程
1.补充学习了一下OPC的概念：
2.使用MatrikonOPC，了解OPCserver是怎么用的
- OPC测试常用的OPCClient和OPCServer软件推荐
- 我的目的就是写一个类似的Java版的Client来连接OPC Server： 使用Matrikon OPC Server Simulation
3.关于OPC UA
- 支持的OPC UA的西门子PLC至少是s7-1500（2021年10月27日 14:58:00 现在不能确定，看到一个回答，s7-300如果有网口就能和OPCUA通信）
- 我的s7-300是没法用的，所以就不需要搜集OPC UA的资料了
- 更正（2021年9月16日11:13:32）：最近看OPC UA的资料，发现使用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.关于订阅方式数据采集
参考：https://www.hifreud.com/2014/12/27/opc-3-main-feature-in-opc/#订阅方式数据采集
并不需要OPC应用程序向OPC服务器要求，就可以自动接到从OPC服务器送来的变化通知的订阅方式数据采集（Subscription）。服务器按一定的更新周期（UpdateRate）更新OPC服务器的数据缓冲器的数值时，如果发现数值有变化时，就会以数据变化事件（DataChange）通知OPC应用程序。
因为没有使用这种订阅方式，所以当时没试过，后来尝试使用Async20Access，会报错。参考上面文章，说是：还必须设置身份标识，，我没试成功。
10.问题：
- 在虚拟机里用localhost一直报错，要写固定IP才行
- 配置里的IP是安装OPCServer软件的电脑的IP，如果使用无线连接，请查看无线的IP地址
- 能不能循环对一个组(group)监控？好像不可以，官方Demo里有两种数据读取方式：1.循环监控item；2.item添加到group,只读取一次
- 如果Java写的client和安装OPCServer软件是两台电脑：那两个电脑都要配置相同DCOM，包括账号密码都要一样
- win10家庭版是否可以？可以，有些麻烦，主要是用户管理部分配置，有人已经验证过可以，我就不试了。建议虚拟机装win10专业版，参考
- 关于组态王，作为OPCSerever，我怎么尝试都没连接上，，有人能连上，我就不试了。
- 关于异步：我使用的同步读取数据，，异步读取没试过，别问我异步的问题。
- group是客户端维护还是服务端维护：服务端可以建自己的分组，但是客户端看到的还是一个个单独的item，group是客户端自己的分组。我是这样理解的。
- 客户端能不能读到服务端的所有item列表：当然可以，请参考
关于KEPServer的注册表ID
11.maven依赖
<!--utgard -->
<dependency>
<groupId>org.openscada.external</groupId>
<artifactId>org.openscada.external.jcifs</artifactId>
<version>1.2.25</version>
<exclusions>
<exclusion>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
</exclusion>
</exclusions>
</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>
<exclusions>
<exclusion>
<groupId>org.bouncycastle</groupId>
<artifactId>bcprov-jdk15on</artifactId>
</exclusion>
</exclusions>
</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>
</dependency>
<dependency>
<groupId>ch.qos.logback</groupId>
<artifactId>logback-classic</artifactId>
</dependency>
5.代码
下载代码：
💧 https://github.com/ioufev/opcda-utgard-demo
- 百度网盘 ，密码: 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("localhost"); // 本机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 = "通道 1.设备 1.标记 1"; // 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 = "通道 1.设备 1.标记 1"; // 项的名字按实际，没有实际PLC，用的模拟器：simulator
// final String itemId = "u.u.u";
// 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);
数据类型
读取和写入数值需要按数据类型来操作
这是常用的数据类型
| 值（十进制） | 数据类型 | 描述 |
|---|---|---|
| 0 | VT_EMPTY | 默认/空（无） |
| 2 | VT_I2 | 2字节有符号整数 |
| 3 | VT_I4 | 4字节有符号整数 |
| 4 | VT_R4 | 4字节实数 |
| 5 | VT_R8 | 8字节实数 |
| 6 | VT_C | currency |
| 7 | VT_DATE | 日期 |
| 8 | VT_BSTR | 文本 |
| 10 | VT_ERROR | 错误代码 |
| 11 | VT_BOOL | 布尔值（TRUE = -1，FALSE = 0） |
| 16 | VT_I1 | 1个字节有符号字符 |
| 17 | VT_UI1 | 1个字节无符号字符 |
| 18 | VT_UI2 | 2字节无符号整数 |
| 19 | VT_UI4 | 4字节无符号整数 |
| +8192 | VT_ARRAY | 值数组（即8200 =文本值数组） |
UtgardTutorial1 增加了类型
package com.ioufev;
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.*;
import java.util.concurrent.Executors;
public class UtgardTutorial1 {
public static void main(String[] args) throws Exception {
// 连接信息
final ConnectionInformation ci = new ConnectionInformation();
ci.setHost("localhost"); // 本机IP
ci.setDomain(""); // 域，为空就行
ci.setUser("OPCUser"); // 本机上自己建好的用户名
ci.setPassword("123456"); // 密码
// 使用MatrikonOPC Server的配置
// ci.setClsid("F8582CF2-88FB-11D0-B850-00C0F0104305"); // MatrikonOPC的注册表ID，可以在“组件服务”里看到
// final String itemId = "组 1.标记 1"; // MatrikonOPC Server上配置的项的名字按实际
// 使用KEPServer的配置
ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729"); // KEPServer的注册表ID，可以在“组件服务”里看到，上面有图片说明
final String itemId = "通道 1.设备 1.标记 1"; // KEPServer上配置的项的名字，没有实际PLC，用的模拟器：simulator
// final String itemId = "通道 1.设备 1.标记 2";
// final String itemId = "通道 1.设备 1.标记 3";
// final String itemId = "通道 1.设备 1.标记 4";
// final String itemId = "通道 1.设备 1.标记 5";
// final String itemId = "通道 1.设备 1.标记 6";
// final String itemId = "通道 1.设备 1.标记 7";
// final String itemId = "通道 1.设备 1.标记 8";
// final String itemId = "通道 1.设备 1.标记 9";
// final String itemId = "通道 1.设备 1.标记 10";
// final String itemId = "通道 1.设备 1.标记 11";
// final String itemId = "通道 1.设备 1.标记 12";
// final String itemId = "通道 1.设备 1.标记 13";
// final String itemId = "通道 1.设备 1.标记 14";
// final String itemId = "通道 1.设备 1.标记 15";
// 启动服务
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 state) {
try {
int type = state.getValue().getType(); // 类型实际是数字，用常量定义的
switch(type){
case JIVariant.VT_I2: // 整形占2个字节，即 short 类型
System.out.println("监控项的数据类型是：-----short 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsShort());
break;
case JIVariant.VT_I4: // 整形占4个字节，即 int 类型，KEPServerEX 上的类型是 Long
System.out.println("监控项的数据类型是：-----int 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsInt());
break;
case JIVariant.VT_I8: // 整形占8个字节，即 long 类型，KEPServerEX 上的类型是 LLong
System.out.println("监控项的数据类型是：-----long 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsLong());
break;
case JIVariant.VT_R4: // 浮点数占4个字节，即 float 类型
System.out.println("监控项的数据类型是：-----float 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsFloat());
break;
case JIVariant.VT_R8: // 浮点数占8个字节，即 double 类型
System.out.println("监控项的数据类型是：-----double 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsDouble());
break;
case JIVariant.VT_BSTR: // 字符串
System.out.println("监控项的数据类型是：-----字符串 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsString());
break;
case JIVariant.VT_UI2: // 无符号占2个字节，即 word 类型，字
System.out.println("监控项的数据类型是：-----无符号占2个字节的 word 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsUnsigned().getValue());
break;
case JIVariant.VT_UI4: // 无符号占4个字节，即 Dword 类型，双字
System.out.println("监控项的数据类型是：-----无符号占4个字节 Dword 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsUnsigned().getValue());
break;
case JIVariant.VT_DATE: // 日期 类型
System.out.println("监控项的数据类型是：-----日期 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsDate());
break;
case JIVariant.VT_BOOL: // 布尔类型
System.out.println("监控项的数据类型是：-----int 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsBoolean());
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I2: // short 数组 类型
System.out.println("监控项的数据类型是：-----short 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Short[] arrayInstanceShort = (Short[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Short value : arrayInstanceShort) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_R4: // float 数组 类型
System.out.println("监控项的数据类型是：-----float 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Float[] arrayInstanceFloat = (Float[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Float value : arrayInstanceFloat) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_BSTR: // 字符串 数组 类型
System.out.println("监控项的数据类型是：-----字符串 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
String[] arrayInstanceString = (String[]) state.getValue().getObjectAsArray().getArrayInstance();
for (String value : arrayInstanceString) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I8: // long 数组 类型
System.out.println("监控项的数据类型是：-----long 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Long[] arrayInstanceLong = (Long[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Long value : arrayInstanceLong) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I4: // int 数组 类型
System.out.println("监控项的数据类型是：-----int 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Integer[] arrayInstanceInteger = (Integer[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Integer value : arrayInstanceInteger) {
System.out.println("<<<-----" + value);
}
break;
default:
System.out.println("监控项的数据类型是：-----" + type + " 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObject());
break;
}
System.out.println("监控项的时间戳是：-----" + state.getTimestamp().getTime());
System.out.println("监控项的详细信息是：-----" + state);
} catch (JIException e) {
e.printStackTrace();
}
}
});
// 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())));
}
}
}
UtgardTutorial2 增加了类型
package com.ioufev;
import java.util.Date;
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.JIArray;
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("localhost"); // 电脑IP
ci.setDomain(""); // 域，为空就行
ci.setUser("OPCUser"); // 用户名，配置DCOM时配置的
ci.setPassword("123456"); // 密码
// 使用MatrikonOPC Server的配置
// ci.setClsid("F8582CF2-88FB-11D0-B850-00C0F0104305"); // MatrikonOPC的注册表ID，可以在“组件服务”里看到
// final String itemId = "组 1.标记 1"; // 项的名字按实际
// 使用KEPServer的配置
ci.setClsid("7BC0CC8E-482C-47CA-ABDC-0FE7F9C6E729"); // KEPServer的注册表ID，可以在“组件服务”里看到
final String itemId = "通道 1.设备 1.标记 1"; // 项的名字按实际，没有实际PLC，用的模拟器：simulator
// final String itemId = "通道 1.设备 1.标记 2";
// 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, (item, state) -> {
// also dump value，转存值
try {
int type = state.getValue().getType(); // 类型实际是数字，用常量定义的
switch(type){
case JIVariant.VT_I2: // 整形占2个字节，即 short 类型
System.out.println("监控项的数据类型是：-----short 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsShort());
break;
case JIVariant.VT_I4: // 整形占4个字节，即 int 类型，KEPServerEX 上的类型是 Long
System.out.println("监控项的数据类型是：-----int 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsInt());
break;
case JIVariant.VT_I8: // 整形占8个字节，即 long 类型，KEPServerEX 上的类型是 LLong
System.out.println("监控项的数据类型是：-----long 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsLong());
break;
case JIVariant.VT_R4: // 浮点数占4个字节，即 float 类型
System.out.println("监控项的数据类型是：-----float 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsFloat());
break;
case JIVariant.VT_R8: // 浮点数占8个字节，即 double 类型
System.out.println("监控项的数据类型是：-----double 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsDouble());
break;
case JIVariant.VT_BSTR: // 字符串
System.out.println("监控项的数据类型是：-----字符串 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsString());
break;
case JIVariant.VT_UI2: // 无符号占2个字节，即 word 类型，字
System.out.println("监控项的数据类型是：-----无符号占2个字节的 word 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsUnsigned().getValue());
break;
case JIVariant.VT_UI4: // 无符号占4个字节，即 Dword 类型，双字
System.out.println("监控项的数据类型是：-----无符号占4个字节 Dword 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsUnsigned().getValue());
break;
case JIVariant.VT_DATE: // 日期 类型
System.out.println("监控项的数据类型是：-----日期 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsDate());
break;
case JIVariant.VT_BOOL: // 布尔类型
System.out.println("监控项的数据类型是：-----int 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsBoolean());
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I2: // short 数组 类型
System.out.println("监控项的数据类型是：-----short 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Short[] arrayInstanceShort = (Short[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Short value : arrayInstanceShort) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_R4: // float 数组 类型
System.out.println("监控项的数据类型是：-----float 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Float[] arrayInstanceFloat = (Float[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Float value : arrayInstanceFloat) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_BSTR: // 字符串 数组 类型
System.out.println("监控项的数据类型是：-----字符串 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
String[] arrayInstanceString = (String[]) state.getValue().getObjectAsArray().getArrayInstance();
for (String value : arrayInstanceString) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I8: // long 数组 类型
System.out.println("监控项的数据类型是：-----long 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Long[] arrayInstanceLong = (Long[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Long value : arrayInstanceLong) {
System.out.println("<<<-----" + value);
}
break;
case JIVariant.VT_ARRAY | JIVariant.VT_I4: // int 数组 类型
System.out.println("监控项的数据类型是：-----int 数组 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObjectAsArray().toString());
Integer[] arrayInstanceInteger = (Integer[]) state.getValue().getObjectAsArray().getArrayInstance();
for (Integer value : arrayInstanceInteger) {
System.out.println("<<<-----" + value);
}
break;
default:
System.out.println("监控项的数据类型是：-----" + type + " 类型");
System.out.println("监控项的值是：-----" + state.getValue().getObject());
break;
}
System.out.println("监控项的时间戳是：-----" + state.getTimestamp().getTime());
System.out.println("监控项的详细信息是：-----" + state);
} 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() {
try {
final JIVariant value = new JIVariant("24"); // 写入24
System.out.println(">>> " + "写入值： " + "24");
item.write(value);
// final JIVariant value = new JIVariant("24"); // 写入24
// System.out.println(">>> " + "写入值： " + "24");
// int errorCode = item.write(value);
// System.out.println("var---" + errorCode);
// 写入3位Long类型的数组，，KEPServerEX 上的类型是 LLong
// Long[] array = {(long) 1,(long) 2,(long) 3};
// final JIVariant value = new JIVariant(new JIArray(array));
// System.out.println(">>> " + "写入值： long 数组" + "{1,2,3}");
// item.write(value);
// 写入3位 int 类型的数组，，KEPServerEX 上的类型是 Long
// Integer[] array = {4, 5, 6};
// final JIVariant value = new JIVariant(new JIArray(array));
// System.out.println(">>> " + "写入值： int 数组" + "{1,2,3}");
// item.write(value);
// 写入时间类型
// final JIVariant value = new JIVariant(new Date()); // 写入日期
// System.out.println(">>> " + "写入值： " + "当前日期");
// item.write(value);
} catch (JIException e) {
e.printStackTrace();
}
}
}, 5, 3, TimeUnit.SECONDS); // 启动后5秒第一次执行代码，以后每3秒执行一次代码
// wait a little bit ，延时20秒
Thread.sleep(10 * 1000);
writeThread.shutdownNow(); // 关掉一直写入的线程
// stop reading，停止循环读取数值
access.unbind();
} catch (final JIException e) {
System.out.println(String.format("%08X: %s", e.getErrorCode(), server.getErrorMessage(e.getErrorCode())));
}
}
}
6.补充
🩸 用 utgard 进行 opc 通讯报 Message not found for errorCode: 0x80010111
测试 utgard 时，操作系统请使用 win10 1909 及以前的版本。
测试可以通信
- win10专业版 1903
- win10专业版 1909
- win11专业版 21H2
测试不可以通信
- win10专业版 21H2
偶然看到一个说是 j-interop 的问题
然后我去验证，不可行。
j-interop 是很久之前的，很久没更新了。
搜了一下原因
是因为微软为了修补 DCOM 的安全漏洞，发了更新补丁。2021年6月8日，微软发布了针对DCOM的Windows安全更新KB5004442（CVE-2021-26414）——强制更改了Windows操作系统DCOM安全机制。该更新要求DCOM应用程序提供“数据包完整性”身份验证级别，否则可能会出现无法兼容的问题。
分布式组件对象模型（DCOM）远程协议是一种使用远程过程调用（RPC）公开应用程序对象的协议，它支持远程过程调用，并且可用于网络设备的软件组件之间的通信。
会受影响操作系统版本
可用性
这些错误事件仅适用于 Windows 版本的子集;请参阅下表。
| Windows 版本 | 可在这些日期或之后使用 |
|---|---|
| Windows Server 2022 | 2021 年 9 月 27 日KB5005619 |
| Windows 10版本 2004、Windows 10、版本 20H2、Windows 10、版本 21H1 | 2021 年 9 月 1 日KB5005101 |
| Windows 10 版本 1909 | 2021 年 8 月 26 日KB5005103 |
| Windows Server 2019、Windows 10 版本 1809 | 2021 年 8 月 26 日KB5005102 |
| Windows Server 2016、Windows 10 版本 1607 | 2021 年 9 月 14 日KB5005573 |
| Windows Server 2012 R2 和 Windows 8.1 | 2021 年 10 月 12 日KB5006714 |
| Windows 11版本 22H2 | 2022 年 9 月 30 日KB5017389 |
