|
1
|
|
|
import logging |
|
2
|
|
|
import sys |
|
3
|
|
|
import argparse |
|
4
|
|
|
from datetime import datetime |
|
5
|
|
|
from enum import Enum |
|
6
|
|
|
import math |
|
7
|
|
|
import time |
|
8
|
|
|
|
|
9
|
|
|
try: |
|
10
|
|
|
from IPython import embed |
|
11
|
|
|
except ImportError: |
|
12
|
|
|
import code |
|
13
|
|
|
|
|
14
|
|
|
def embed(): |
|
15
|
|
|
code.interact(local=dict(globals(), **locals())) |
|
16
|
|
|
|
|
17
|
|
|
from opcua import ua |
|
18
|
|
|
from opcua import Client |
|
19
|
|
|
from opcua import Server |
|
20
|
|
|
from opcua import Node |
|
21
|
|
|
from opcua import uamethod |
|
22
|
|
|
from opcua import security_policies |
|
23
|
|
|
|
|
24
|
|
|
|
|
25
|
|
|
def add_minimum_args(parser): |
|
26
|
|
|
parser.add_argument("-u", |
|
27
|
|
|
"--url", |
|
28
|
|
|
help="URL of OPC UA server (for example: opc.tcp://example.org:4840)", |
|
29
|
|
|
default='opc.tcp://localhost:4841', |
|
30
|
|
|
metavar="URL") |
|
31
|
|
|
parser.add_argument("-v", |
|
32
|
|
|
"--verbose", |
|
33
|
|
|
dest="loglevel", |
|
34
|
|
|
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], |
|
35
|
|
|
default='WARNING', |
|
36
|
|
|
help="Set log level") |
|
37
|
|
|
parser.add_argument("--timeout", |
|
38
|
|
|
dest="timeout", |
|
39
|
|
|
type=int, |
|
40
|
|
|
default=1, |
|
41
|
|
|
help="Set socket timeout (NOT the diverse UA timeouts)") |
|
42
|
|
|
|
|
43
|
|
|
|
|
44
|
|
|
def add_common_args(parser, default_node='i=84'): |
|
45
|
|
|
add_minimum_args(parser) |
|
46
|
|
|
parser.add_argument("-n", |
|
47
|
|
|
"--nodeid", |
|
48
|
|
|
help="Fully-qualified node ID (for example: i=85). Default: root node", |
|
49
|
|
|
default=default_node, |
|
50
|
|
|
metavar="NODE") |
|
51
|
|
|
parser.add_argument("-p", |
|
52
|
|
|
"--path", |
|
53
|
|
|
help="Comma separated browse path to the node starting at NODE (for example: 3:Mybject,3:MyVariable)", |
|
54
|
|
|
default='', |
|
55
|
|
|
metavar="BROWSEPATH") |
|
56
|
|
|
parser.add_argument("-i", |
|
57
|
|
|
"--namespace", |
|
58
|
|
|
help="Default namespace", |
|
59
|
|
|
type=int, |
|
60
|
|
|
default=0, |
|
61
|
|
|
metavar="NAMESPACE") |
|
62
|
|
|
parser.add_argument("--security", |
|
63
|
|
|
help="Security settings, for example: Basic256,SignAndEncrypt,cert.der,pk.pem[,server_cert.der]. Default: None", |
|
64
|
|
|
default='') |
|
65
|
|
|
|
|
66
|
|
|
|
|
67
|
|
|
def _require_nodeid(parser, args): |
|
68
|
|
|
# check that a nodeid has been given explicitly, a bit hackish... |
|
69
|
|
|
if args.nodeid == "i=84" and args.path == "": |
|
70
|
|
|
parser.print_usage() |
|
71
|
|
|
print("{}: error: A NodeId or BrowsePath is required".format(parser.prog)) |
|
72
|
|
|
sys.exit(1) |
|
73
|
|
|
|
|
74
|
|
|
|
|
75
|
|
|
def parse_args(parser, requirenodeid=False): |
|
76
|
|
|
args = parser.parse_args() |
|
77
|
|
|
logging.basicConfig(format="%(levelname)s: %(message)s", level=getattr(logging, args.loglevel)) |
|
78
|
|
|
if args.url and '://' not in args.url: |
|
79
|
|
|
logging.info("Adding default scheme %s to URL %s", ua.OPC_TCP_SCHEME, args.url) |
|
80
|
|
|
args.url = ua.OPC_TCP_SCHEME + '://' + args.url |
|
81
|
|
|
if requirenodeid: |
|
82
|
|
|
_require_nodeid(parser, args) |
|
83
|
|
|
return args |
|
84
|
|
|
|
|
85
|
|
|
|
|
86
|
|
|
def get_node(client, args): |
|
87
|
|
|
node = client.get_node(args.nodeid) |
|
88
|
|
|
if args.path: |
|
89
|
|
|
node = node.get_child(args.path.split(",")) |
|
90
|
|
|
return node |
|
91
|
|
|
|
|
92
|
|
|
|
|
93
|
|
|
def uaread(): |
|
94
|
|
|
parser = argparse.ArgumentParser(description="Read attribute of a node, per default reads value of a node") |
|
95
|
|
|
add_common_args(parser) |
|
96
|
|
|
parser.add_argument("-a", |
|
97
|
|
|
"--attribute", |
|
98
|
|
|
dest="attribute", |
|
99
|
|
|
type=int, |
|
100
|
|
|
default=ua.AttributeIds.Value, |
|
101
|
|
|
help="Set attribute to read") |
|
102
|
|
|
parser.add_argument("-t", |
|
103
|
|
|
"--datatype", |
|
104
|
|
|
dest="datatype", |
|
105
|
|
|
default="python", |
|
106
|
|
|
choices=['python', 'variant', 'datavalue'], |
|
107
|
|
|
help="Data type to return") |
|
108
|
|
|
|
|
109
|
|
|
args = parse_args(parser, requirenodeid=True) |
|
110
|
|
|
|
|
111
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
112
|
|
|
client.set_security_string(args.security) |
|
113
|
|
|
client.connect() |
|
114
|
|
|
try: |
|
115
|
|
|
node = get_node(client, args) |
|
116
|
|
|
attr = node.get_attribute(args.attribute) |
|
117
|
|
|
if args.datatype == "python": |
|
118
|
|
|
print(attr.Value.Value) |
|
119
|
|
|
elif args.datatype == "variant": |
|
120
|
|
|
print(attr.Value) |
|
121
|
|
|
else: |
|
122
|
|
|
print(attr) |
|
123
|
|
|
finally: |
|
124
|
|
|
client.disconnect() |
|
125
|
|
|
sys.exit(0) |
|
126
|
|
|
print(args) |
|
127
|
|
|
|
|
128
|
|
|
|
|
129
|
|
|
def _args_to_array(val, array): |
|
130
|
|
|
if array == "guess": |
|
131
|
|
|
if "," in val: |
|
132
|
|
|
array = "true" |
|
133
|
|
|
if array == "true": |
|
134
|
|
|
val = val.split(",") |
|
135
|
|
|
return val |
|
136
|
|
|
|
|
137
|
|
|
|
|
138
|
|
|
def _arg_to_bool(val): |
|
139
|
|
|
if val in ("true", "True"): |
|
140
|
|
|
return True |
|
141
|
|
|
else: |
|
142
|
|
|
return False |
|
143
|
|
|
|
|
144
|
|
|
|
|
145
|
|
|
def _arg_to_variant(val, array, ptype, varianttype=None): |
|
146
|
|
|
val = _args_to_array(val, array) |
|
147
|
|
|
if isinstance(val, list): |
|
148
|
|
|
val = [ptype(i) for i in val] |
|
149
|
|
|
else: |
|
150
|
|
|
val = ptype(val) |
|
151
|
|
|
if varianttype: |
|
152
|
|
|
return ua.Variant(val, varianttype) |
|
153
|
|
|
else: |
|
154
|
|
|
return ua.Variant(val) |
|
155
|
|
|
|
|
156
|
|
|
|
|
157
|
|
|
def _val_to_variant(val, args): |
|
158
|
|
|
array = args.array |
|
159
|
|
|
if args.datatype == "guess": |
|
160
|
|
|
if val in ("true", "True", "false", "False"): |
|
161
|
|
|
return _arg_to_variant(val, array, _arg_to_bool) |
|
162
|
|
|
# FIXME: guess bool value |
|
163
|
|
|
try: |
|
164
|
|
|
return _arg_to_variant(val, array, int) |
|
165
|
|
|
except ValueError: |
|
166
|
|
|
try: |
|
167
|
|
|
return _arg_to_variant(val, array, float) |
|
168
|
|
|
except ValueError: |
|
169
|
|
|
return _arg_to_variant(val, array, str) |
|
170
|
|
|
elif args.datatype == "bool": |
|
171
|
|
|
if val in ("1", "True", "true"): |
|
172
|
|
|
return ua.Variant(True, ua.VariantType.Boolean) |
|
173
|
|
|
else: |
|
174
|
|
|
return ua.Variant(False, ua.VariantType.Boolean) |
|
175
|
|
|
elif args.datatype == "sbyte": |
|
176
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.SByte) |
|
177
|
|
|
elif args.datatype == "byte": |
|
178
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.Byte) |
|
179
|
|
|
#elif args.datatype == "uint8": |
|
180
|
|
|
#return _arg_to_variant(val, array, int, ua.VariantType.Byte) |
|
181
|
|
|
elif args.datatype == "uint16": |
|
182
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.UInt16) |
|
183
|
|
|
elif args.datatype == "uint32": |
|
184
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.UInt32) |
|
185
|
|
|
elif args.datatype == "uint64": |
|
186
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.UInt64) |
|
187
|
|
|
#elif args.datatype == "int8": |
|
188
|
|
|
#return ua.Variant(int(val), ua.VariantType.Int8) |
|
189
|
|
|
elif args.datatype == "int16": |
|
190
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.Int16) |
|
191
|
|
|
elif args.datatype == "int32": |
|
192
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.Int32) |
|
193
|
|
|
elif args.datatype == "int64": |
|
194
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.Int64) |
|
195
|
|
|
elif args.datatype == "float": |
|
196
|
|
|
return _arg_to_variant(val, array, float, ua.VariantType.Float) |
|
197
|
|
|
elif args.datatype == "double": |
|
198
|
|
|
return _arg_to_variant(val, array, float, ua.VariantType.Double) |
|
199
|
|
|
elif args.datatype == "string": |
|
200
|
|
|
return _arg_to_variant(val, array, str, ua.VariantType.String) |
|
201
|
|
|
elif args.datatype == "datetime": |
|
202
|
|
|
raise NotImplementedError |
|
203
|
|
|
elif args.datatype == "Guid": |
|
204
|
|
|
return _arg_to_variant(val, array, bytes, ua.VariantType.Guid) |
|
205
|
|
|
elif args.datatype == "ByteString": |
|
206
|
|
|
return _arg_to_variant(val, array, bytes, ua.VariantType.ByteString) |
|
207
|
|
|
elif args.datatype == "xml": |
|
208
|
|
|
return _arg_to_variant(val, array, str, ua.VariantType.XmlElement) |
|
209
|
|
|
elif args.datatype == "nodeid": |
|
210
|
|
|
return _arg_to_variant(val, array, ua.NodeId.from_string, ua.VariantType.NodeId) |
|
211
|
|
|
elif args.datatype == "expandednodeid": |
|
212
|
|
|
return _arg_to_variant(val, array, ua.ExpandedNodeId.from_string, ua.VariantType.ExpandedNodeId) |
|
213
|
|
|
elif args.datatype == "statuscode": |
|
214
|
|
|
return _arg_to_variant(val, array, int, ua.VariantType.StatusCode) |
|
215
|
|
|
elif args.datatype in ("qualifiedname", "browsename"): |
|
216
|
|
|
return _arg_to_variant(val, array, ua.QualifiedName.from_string, ua.VariantType.QualifiedName) |
|
217
|
|
|
elif args.datatype == "LocalizedText": |
|
218
|
|
|
return _arg_to_variant(val, array, ua.LocalizedText, ua.VariantType.LocalizedText) |
|
219
|
|
|
|
|
220
|
|
|
|
|
221
|
|
|
def uawrite(): |
|
222
|
|
|
parser = argparse.ArgumentParser(description="Write attribute of a node, per default write value of node") |
|
223
|
|
|
add_common_args(parser) |
|
224
|
|
|
parser.add_argument("-a", |
|
225
|
|
|
"--attribute", |
|
226
|
|
|
dest="attribute", |
|
227
|
|
|
type=int, |
|
228
|
|
|
default=ua.AttributeIds.Value, |
|
229
|
|
|
help="Set attribute to read") |
|
230
|
|
|
parser.add_argument("-l", |
|
231
|
|
|
"--list", |
|
232
|
|
|
"--array", |
|
233
|
|
|
dest="array", |
|
234
|
|
|
default="guess", |
|
235
|
|
|
choices=["guess", "true", "false"], |
|
236
|
|
|
help="Value is an array") |
|
237
|
|
|
parser.add_argument("-t", |
|
238
|
|
|
"--datatype", |
|
239
|
|
|
dest="datatype", |
|
240
|
|
|
default="guess", |
|
241
|
|
|
choices=["guess", 'byte', 'sbyte', 'nodeid', 'expandednodeid', 'qualifiedname', 'browsename', 'string', 'float', 'double', 'int16', 'int32', "int64", 'uint16', 'uint32', 'uint64', "bool", "string", 'datetime', 'bytestring', 'xmlelement', 'statuscode', 'localizedtext'], |
|
242
|
|
|
help="Data type to return") |
|
243
|
|
|
parser.add_argument("value", |
|
244
|
|
|
help="Value to be written", |
|
245
|
|
|
metavar="VALUE") |
|
246
|
|
|
args = parse_args(parser, requirenodeid=True) |
|
247
|
|
|
|
|
248
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
249
|
|
|
client.set_security_string(args.security) |
|
250
|
|
|
client.connect() |
|
251
|
|
|
try: |
|
252
|
|
|
node = get_node(client, args) |
|
253
|
|
|
val = _val_to_variant(args.value, args) |
|
254
|
|
|
node.set_attribute(args.attribute, ua.DataValue(val)) |
|
255
|
|
|
finally: |
|
256
|
|
|
client.disconnect() |
|
257
|
|
|
sys.exit(0) |
|
258
|
|
|
print(args) |
|
259
|
|
|
|
|
260
|
|
|
|
|
261
|
|
|
def uals(): |
|
262
|
|
|
parser = argparse.ArgumentParser(description="Browse OPC-UA node and print result") |
|
263
|
|
|
add_common_args(parser) |
|
264
|
|
|
parser.add_argument("-l", |
|
265
|
|
|
dest="long_format", |
|
266
|
|
|
const=3, |
|
267
|
|
|
nargs="?", |
|
268
|
|
|
type=int, |
|
269
|
|
|
help="use a long listing format") |
|
270
|
|
|
parser.add_argument("-d", |
|
271
|
|
|
"--depth", |
|
272
|
|
|
default=1, |
|
273
|
|
|
type=int, |
|
274
|
|
|
help="Browse depth") |
|
275
|
|
|
|
|
276
|
|
|
args = parse_args(parser) |
|
277
|
|
|
if args.long_format is None: |
|
278
|
|
|
args.long_format = 1 |
|
279
|
|
|
|
|
280
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
281
|
|
|
client.set_security_string(args.security) |
|
282
|
|
|
client.connect() |
|
283
|
|
|
try: |
|
284
|
|
|
node = get_node(client, args) |
|
285
|
|
|
print("Browsing node {} at {}\n".format(node, args.url)) |
|
286
|
|
|
if args.long_format == 0: |
|
287
|
|
|
_lsprint_0(node, args.depth - 1) |
|
288
|
|
|
elif args.long_format == 1: |
|
289
|
|
|
_lsprint_1(node, args.depth - 1) |
|
290
|
|
|
else: |
|
291
|
|
|
_lsprint_long(node, args.depth - 1) |
|
292
|
|
|
finally: |
|
293
|
|
|
client.disconnect() |
|
294
|
|
|
sys.exit(0) |
|
295
|
|
|
print(args) |
|
296
|
|
|
|
|
297
|
|
|
|
|
298
|
|
|
def _lsprint_0(node, depth, indent=""): |
|
299
|
|
|
if not indent: |
|
300
|
|
|
print("{:30} {:25}".format("DisplayName", "NodeId")) |
|
301
|
|
|
print("") |
|
302
|
|
|
for desc in node.get_children_descriptions(): |
|
303
|
|
|
print("{}{:30} {:25}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string())) |
|
304
|
|
|
if depth: |
|
305
|
|
|
_lsprint_0(Node(node.server, desc.NodeId), depth - 1, indent + " ") |
|
306
|
|
|
|
|
307
|
|
|
|
|
308
|
|
|
def _lsprint_1(node, depth, indent=""): |
|
309
|
|
|
if not indent: |
|
310
|
|
|
print("{:30} {:25} {:25} {:25}".format("DisplayName", "NodeId", "BrowseName", "Value")) |
|
311
|
|
|
print("") |
|
312
|
|
|
|
|
313
|
|
|
for desc in node.get_children_descriptions(): |
|
314
|
|
|
if desc.NodeClass == ua.NodeClass.Variable: |
|
315
|
|
|
val = Node(node.server, desc.NodeId).get_value() |
|
316
|
|
|
print("{}{:30} {!s:25} {!s:25}, {!s:3}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string(), desc.BrowseName.to_string(), val)) |
|
317
|
|
|
else: |
|
318
|
|
|
print("{}{:30} {!s:25} {!s:25}".format(indent, desc.DisplayName.to_string(), desc.NodeId.to_string(), desc.BrowseName.to_string())) |
|
319
|
|
|
if depth: |
|
320
|
|
|
_lsprint_1(Node(node.server, desc.NodeId), depth - 1, indent + " ") |
|
321
|
|
|
|
|
322
|
|
|
|
|
323
|
|
|
def _lsprint_long(pnode, depth, indent=""): |
|
324
|
|
|
if not indent: |
|
325
|
|
|
print("{:30} {:25} {:25} {:10} {:30} {:25}".format("DisplayName", "NodeId", "BrowseName", "DataType", "Timestamp", "Value")) |
|
326
|
|
|
print("") |
|
327
|
|
|
for node in pnode.get_children(): |
|
328
|
|
|
attrs = node.get_attributes([ua.AttributeIds.DisplayName, |
|
329
|
|
|
ua.AttributeIds.BrowseName, |
|
330
|
|
|
ua.AttributeIds.NodeClass, |
|
331
|
|
|
ua.AttributeIds.WriteMask, |
|
332
|
|
|
ua.AttributeIds.UserWriteMask, |
|
333
|
|
|
ua.AttributeIds.DataType, |
|
334
|
|
|
ua.AttributeIds.Value]) |
|
335
|
|
|
name, bname, nclass, mask, umask, dtype, val = [attr.Value.Value for attr in attrs] |
|
336
|
|
|
update = attrs[-1].ServerTimestamp |
|
337
|
|
|
if nclass == ua.NodeClass.Variable: |
|
338
|
|
|
print("{}{:30} {:25} {:25} {:10} {!s:30} {!s:25}".format(indent, name.to_string(), node.nodeid.to_string(), bname.to_string(), dtype.to_string(), update, val)) |
|
339
|
|
|
else: |
|
340
|
|
|
print("{}{:30} {:25} {:25}".format(indent, name.to_string(), bname.to_string(), node.nodeid.to_string())) |
|
341
|
|
|
if depth: |
|
342
|
|
|
_lsprint_long(node, depth - 1, indent + " ") |
|
343
|
|
|
|
|
344
|
|
|
|
|
345
|
|
|
class SubHandler(object): |
|
346
|
|
|
|
|
347
|
|
|
def datachange_notification(self, node, val, data): |
|
348
|
|
|
print("New data change event", node, val, data) |
|
349
|
|
|
|
|
350
|
|
|
def event_notification(self, event): |
|
351
|
|
|
print("New event", event) |
|
352
|
|
|
|
|
353
|
|
|
|
|
354
|
|
|
def uasubscribe(): |
|
355
|
|
|
parser = argparse.ArgumentParser(description="Subscribe to a node and print results") |
|
356
|
|
|
add_common_args(parser) |
|
357
|
|
|
parser.add_argument("-t", |
|
358
|
|
|
"--eventtype", |
|
359
|
|
|
dest="eventtype", |
|
360
|
|
|
default="datachange", |
|
361
|
|
|
choices=['datachange', 'event'], |
|
362
|
|
|
help="Event type to subscribe to") |
|
363
|
|
|
|
|
364
|
|
|
args = parse_args(parser, requirenodeid=False) |
|
365
|
|
|
if args.eventtype == "datachange": |
|
366
|
|
|
_require_nodeid(parser, args) |
|
367
|
|
|
else: |
|
368
|
|
|
# FIXME: this is broken, someone may have written i=84 on purpose |
|
369
|
|
|
if args.nodeid == "i=84" and args.path == "": |
|
370
|
|
|
args.nodeid = "i=2253" |
|
371
|
|
|
|
|
372
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
373
|
|
|
client.set_security_string(args.security) |
|
374
|
|
|
client.connect() |
|
375
|
|
|
try: |
|
376
|
|
|
node = get_node(client, args) |
|
377
|
|
|
handler = SubHandler() |
|
378
|
|
|
sub = client.create_subscription(500, handler) |
|
379
|
|
|
if args.eventtype == "datachange": |
|
380
|
|
|
sub.subscribe_data_change(node) |
|
381
|
|
|
else: |
|
382
|
|
|
sub.subscribe_events(node) |
|
383
|
|
|
embed() |
|
384
|
|
|
finally: |
|
385
|
|
|
client.disconnect() |
|
386
|
|
|
sys.exit(0) |
|
387
|
|
|
print(args) |
|
388
|
|
|
|
|
389
|
|
|
|
|
390
|
|
|
# converts numeric value to its enum name. |
|
391
|
|
|
def enum_to_string(klass, value): |
|
392
|
|
|
if isinstance(value, Enum): |
|
393
|
|
|
return value.name |
|
394
|
|
|
# if value is not a subtype of Enum, try to find a constant |
|
395
|
|
|
# with this value in this class |
|
396
|
|
|
for k, v in vars(klass).items(): |
|
397
|
|
|
if not k.startswith('__') and v == value: |
|
398
|
|
|
return k |
|
399
|
|
|
return 'Unknown {} ({})'.format(klass.__name__, value) |
|
400
|
|
|
|
|
401
|
|
|
|
|
402
|
|
|
def application_to_strings(app): |
|
403
|
|
|
result = [] |
|
404
|
|
|
result.append(('Application URI', app.ApplicationUri)) |
|
405
|
|
|
optionals = [ |
|
406
|
|
|
('Product URI', app.ProductUri), |
|
407
|
|
|
('Application Name', app.ApplicationName.to_string()), |
|
408
|
|
|
('Application Type', enum_to_string(ua.ApplicationType, app.ApplicationType)), |
|
409
|
|
|
('Gateway Server URI', app.GatewayServerUri), |
|
410
|
|
|
('Discovery Profile URI', app.DiscoveryProfileUri), |
|
411
|
|
|
] |
|
412
|
|
|
for (n, v) in optionals: |
|
413
|
|
|
if v: |
|
414
|
|
|
result.append((n, v)) |
|
415
|
|
|
for url in app.DiscoveryUrls: |
|
416
|
|
|
result.append(('Discovery URL', url)) |
|
417
|
|
|
return result # ['{}: {}'.format(n, v) for (n, v) in result] |
|
418
|
|
|
|
|
419
|
|
|
|
|
420
|
|
|
def endpoint_to_strings(ep): |
|
421
|
|
|
result = [('Endpoint URL', ep.EndpointUrl)] |
|
422
|
|
|
result += application_to_strings(ep.Server) |
|
423
|
|
|
result += [ |
|
424
|
|
|
('Server Certificate', len(ep.ServerCertificate)), |
|
425
|
|
|
('Security Mode', enum_to_string(ua.MessageSecurityMode, ep.SecurityMode)), |
|
426
|
|
|
('Security Policy URI', ep.SecurityPolicyUri)] |
|
427
|
|
|
for tok in ep.UserIdentityTokens: |
|
428
|
|
|
result += [ |
|
429
|
|
|
('User policy', tok.PolicyId), |
|
430
|
|
|
(' Token type', enum_to_string(ua.UserTokenType, tok.TokenType))] |
|
431
|
|
|
if tok.IssuedTokenType or tok.IssuerEndpointUrl: |
|
432
|
|
|
result += [ |
|
433
|
|
|
(' Issued Token type', tok.IssuedTokenType), |
|
434
|
|
|
(' Issuer Endpoint URL', tok.IssuerEndpointUrl)] |
|
435
|
|
|
if tok.SecurityPolicyUri: |
|
436
|
|
|
result.append((' Security Policy URI', tok.SecurityPolicyUri)) |
|
437
|
|
|
result += [ |
|
438
|
|
|
('Transport Profile URI', ep.TransportProfileUri), |
|
439
|
|
|
('Security Level', ep.SecurityLevel)] |
|
440
|
|
|
return result |
|
441
|
|
|
|
|
442
|
|
|
|
|
443
|
|
|
def uaclient(): |
|
444
|
|
|
parser = argparse.ArgumentParser(description="Connect to server and start python shell. root and objects nodes are available. Node specificed in command line is available as mynode variable") |
|
445
|
|
|
add_common_args(parser) |
|
446
|
|
|
parser.add_argument("-c", |
|
447
|
|
|
"--certificate", |
|
448
|
|
|
help="set client certificate") |
|
449
|
|
|
parser.add_argument("-k", |
|
450
|
|
|
"--private_key", |
|
451
|
|
|
help="set client private key") |
|
452
|
|
|
args = parse_args(parser) |
|
453
|
|
|
|
|
454
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
455
|
|
|
client.set_security_string(args.security) |
|
456
|
|
|
client.connect() |
|
457
|
|
|
if args.certificate: |
|
458
|
|
|
client.load_client_certificate(args.certificate) |
|
459
|
|
|
if args.private_key: |
|
460
|
|
|
client.load_private_key(args.private_key) |
|
461
|
|
|
try: |
|
462
|
|
|
root = client.get_root_node() |
|
463
|
|
|
objects = client.get_objects_node() |
|
464
|
|
|
mynode = get_node(client, args) |
|
465
|
|
|
embed() |
|
466
|
|
|
finally: |
|
467
|
|
|
client.disconnect() |
|
468
|
|
|
sys.exit(0) |
|
469
|
|
|
|
|
470
|
|
|
|
|
471
|
|
|
def uaserver(): |
|
472
|
|
|
parser = argparse.ArgumentParser(description="Run an example OPC-UA server. By importing xml definition and using uawrite command line, it is even possible to expose real data using this server") |
|
473
|
|
|
# we setup a server, this is a bit different from other tool so we do not reuse common arguments |
|
474
|
|
|
parser.add_argument("-u", |
|
475
|
|
|
"--url", |
|
476
|
|
|
help="URL of OPC UA server, default is opc.tcp://0.0.0.0:4841", |
|
477
|
|
|
default='opc.tcp://0.0.0.0:4841', |
|
478
|
|
|
metavar="URL") |
|
479
|
|
|
parser.add_argument("-v", |
|
480
|
|
|
"--verbose", |
|
481
|
|
|
dest="loglevel", |
|
482
|
|
|
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'], |
|
483
|
|
|
default='WARNING', |
|
484
|
|
|
help="Set log level") |
|
485
|
|
|
parser.add_argument("-x", |
|
486
|
|
|
"--xml", |
|
487
|
|
|
metavar="XML_FILE", |
|
488
|
|
|
help="Populate address space with nodes defined in XML") |
|
489
|
|
|
parser.add_argument("-p", |
|
490
|
|
|
"--populate", |
|
491
|
|
|
action="store_false", |
|
492
|
|
|
help="Populate address space with some sample nodes") |
|
493
|
|
|
parser.add_argument("-c", |
|
494
|
|
|
"--disable-clock", |
|
495
|
|
|
action="store_true", |
|
496
|
|
|
help="Disable clock, to avoid seeing many write if debugging an application") |
|
497
|
|
|
parser.add_argument("-s", |
|
498
|
|
|
"--shell", |
|
499
|
|
|
action="store_true", |
|
500
|
|
|
help="Start python shell instead of randomly changing node values") |
|
501
|
|
|
args = parser.parse_args() |
|
502
|
|
|
logging.basicConfig(format="%(levelname)s: %(message)s", level=getattr(logging, args.loglevel)) |
|
503
|
|
|
|
|
504
|
|
|
server = Server() |
|
505
|
|
|
server.set_endpoint(args.url) |
|
506
|
|
|
server.disable_clock(args.disable_clock) |
|
507
|
|
|
server.set_server_name("FreeOpcUa Example Server") |
|
508
|
|
|
if args.xml: |
|
509
|
|
|
server.import_xml(args.xml) |
|
510
|
|
|
if args.populate: |
|
511
|
|
|
@uamethod |
|
512
|
|
|
def multiply(parent, x, y): |
|
513
|
|
|
print("multiply method call with parameters: ", x, y) |
|
514
|
|
|
return x * y |
|
515
|
|
|
|
|
516
|
|
|
uri = "http://examples.freeopcua.github.io" |
|
517
|
|
|
idx = server.register_namespace(uri) |
|
518
|
|
|
objects = server.get_objects_node() |
|
519
|
|
|
myobj = objects.add_object(idx, "MyObject") |
|
520
|
|
|
mywritablevar = myobj.add_variable(idx, "MyWritableVariable", 6.7) |
|
521
|
|
|
mywritablevar.set_writable() # Set MyVariable to be writable by clients |
|
522
|
|
|
myvar = myobj.add_variable(idx, "MyVariable", 6.7) |
|
523
|
|
|
myarrayvar = myobj.add_variable(idx, "MyVarArray", [6.7, 7.9]) |
|
524
|
|
|
myprop = myobj.add_property(idx, "MyProperty", "I am a property") |
|
525
|
|
|
mymethod = myobj.add_method(idx, "MyMethod", multiply, [ua.VariantType.Double, ua.VariantType.Int64], [ua.VariantType.Double]) |
|
526
|
|
|
|
|
527
|
|
|
server.start() |
|
528
|
|
|
try: |
|
529
|
|
|
if args.shell: |
|
530
|
|
|
embed() |
|
531
|
|
|
else: |
|
532
|
|
|
count = 0 |
|
533
|
|
|
while True: |
|
534
|
|
|
time.sleep(1) |
|
535
|
|
|
myvar.set_value(math.sin(count / 10)) |
|
536
|
|
|
myarrayvar.set_value([math.sin(count / 10), math.sin(count / 100)]) |
|
537
|
|
|
count += 1 |
|
538
|
|
|
finally: |
|
539
|
|
|
server.stop() |
|
540
|
|
|
sys.exit(0) |
|
541
|
|
|
|
|
542
|
|
|
|
|
543
|
|
|
def uadiscover(): |
|
544
|
|
|
parser = argparse.ArgumentParser(description="Performs OPC UA discovery and prints information on servers and endpoints.") |
|
545
|
|
|
add_minimum_args(parser) |
|
546
|
|
|
parser.add_argument("-n", |
|
547
|
|
|
"--network", |
|
548
|
|
|
action="store_true", |
|
549
|
|
|
help="Also send a FindServersOnNetwork request to server") |
|
550
|
|
|
#parser.add_argument("-s", |
|
551
|
|
|
#"--servers", |
|
552
|
|
|
#action="store_false", |
|
553
|
|
|
#help="send a FindServers request to server") |
|
554
|
|
|
#parser.add_argument("-e", |
|
555
|
|
|
#"--endpoints", |
|
556
|
|
|
#action="store_false", |
|
557
|
|
|
#help="send a GetEndpoints request to server") |
|
558
|
|
|
args = parse_args(parser) |
|
559
|
|
|
|
|
560
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
561
|
|
|
|
|
562
|
|
|
if args.network: |
|
563
|
|
|
print("Performing discovery at {}\n".format(args.url)) |
|
564
|
|
|
for i, server in enumerate(client.connect_and_find_servers_on_network(), start=1): |
|
565
|
|
|
print('Server {}:'.format(i)) |
|
566
|
|
|
#for (n, v) in application_to_strings(server): |
|
567
|
|
|
#print(' {}: {}'.format(n, v)) |
|
568
|
|
|
print('') |
|
569
|
|
|
|
|
570
|
|
|
print("Performing discovery at {}\n".format(args.url)) |
|
571
|
|
|
for i, server in enumerate(client.connect_and_find_servers(), start=1): |
|
572
|
|
|
print('Server {}:'.format(i)) |
|
573
|
|
|
for (n, v) in application_to_strings(server): |
|
574
|
|
|
print(' {}: {}'.format(n, v)) |
|
575
|
|
|
print('') |
|
576
|
|
|
|
|
577
|
|
|
for i, ep in enumerate(client.connect_and_get_server_endpoints(), start=1): |
|
578
|
|
|
print('Endpoint {}:'.format(i)) |
|
579
|
|
|
for (n, v) in endpoint_to_strings(ep): |
|
580
|
|
|
print(' {}: {}'.format(n, v)) |
|
581
|
|
|
print('') |
|
582
|
|
|
|
|
583
|
|
|
sys.exit(0) |
|
584
|
|
|
|
|
585
|
|
|
|
|
586
|
|
|
def print_history(o): |
|
587
|
|
|
if isinstance(o, ua.HistoryData): |
|
588
|
|
|
print("{:30} {:10} {}".format('Source timestamp', 'Status', 'Value')) |
|
589
|
|
|
for d in o.DataValues: |
|
590
|
|
|
print("{:30} {:10} {}".format(str(d.SourceTimestamp), d.StatusCode.name, d.Value)) |
|
591
|
|
|
|
|
592
|
|
|
|
|
593
|
|
|
def str_to_datetime(s): |
|
594
|
|
|
if not s: |
|
595
|
|
|
return datetime.utcnow() |
|
596
|
|
|
# try different datetime formats |
|
597
|
|
|
for fmt in ["%Y-%m-%d", "%Y-%m-%d %H:%M", "%Y-%m-%d %H:%M:%S"]: |
|
598
|
|
|
try: |
|
599
|
|
|
return datetime.strptime(s, fmt) |
|
600
|
|
|
except ValueError: |
|
601
|
|
|
pass |
|
602
|
|
|
|
|
603
|
|
|
|
|
604
|
|
|
def uahistoryread(): |
|
605
|
|
|
parser = argparse.ArgumentParser(description="Read history of a node") |
|
606
|
|
|
add_common_args(parser) |
|
607
|
|
|
parser.add_argument("--starttime", |
|
608
|
|
|
default="", |
|
609
|
|
|
help="Start time, formatted as YYYY-MM-DD [HH:MM[:SS]]. Default: current time") |
|
610
|
|
|
parser.add_argument("--endtime", |
|
611
|
|
|
default="", |
|
612
|
|
|
help="End time, formatted as YYYY-MM-DD [HH:MM[:SS]]. Default: current time") |
|
613
|
|
|
|
|
614
|
|
|
args = parse_args(parser, requirenodeid=True) |
|
615
|
|
|
|
|
616
|
|
|
client = Client(args.url, timeout=args.timeout) |
|
617
|
|
|
client.set_security_string(args.security) |
|
618
|
|
|
client.connect() |
|
619
|
|
|
try: |
|
620
|
|
|
node = get_node(client, args) |
|
621
|
|
|
starttime = str_to_datetime(args.starttime) |
|
622
|
|
|
endtime = str_to_datetime(args.endtime) |
|
623
|
|
|
print("Reading raw history of node {} at {}; start at {}, end at {}\n".format(node, args.url, starttime, endtime)) |
|
624
|
|
|
print_history(node.read_raw_history(starttime, endtime)) |
|
625
|
|
|
finally: |
|
626
|
|
|
client.disconnect() |
|
627
|
|
|
sys.exit(0) |
|
628
|
|
|
|
FreeOpcUa /
python-opcua
