async def main():
"""
Main task of this Client-Subscription example.
"""
client = Client(url='opc.tcp://localhost:4840/freeopcua/server/')
async with client:
idx = await client.get_namespace_index(
uri="http://examples.freeopcua.github.io")
var = await client.nodes.objects.get_child(
[f"{idx}:MyObject", f"{idx}:MyVariable"])
handler = SubscriptionHandler()
# We create a Client Subscription.
subscription = await client.create_subscription(500, handler)
nodes = [
var,
client.get_node(ua.ObjectIds.Server_ServerStatus_CurrentTime),
]
# We subscribe to data changes for two nodes (variables).
await subscription.subscribe_data_change(nodes)
# We let the subscription run for ten seconds
await asyncio.sleep(10)
# We delete the subscription (this un-subscribes from the data changes of the two variables).
# This is optional since closing the connection will also delete all subscriptions.
await subscription.delete()
# After one second we exit the Client context manager - this will close the connection.
await asyncio.sleep(1)
async def test_multiple_clients_with_subscriptions(server):
"""
Tests that multiple clients can subscribe, and when one client disconnects, the other
still maintains it's subscription
"""
class SubscriptionHandler:
def datachange_notification(self, node, val, data):
pass
sub_handler = SubscriptionHandler()
client1 = Client(server.endpoint.geturl())
client2 = Client(server.endpoint.geturl())
o = server.nodes.objects
var = await o.add_variable(3, "some_variable", 1.0)
async with client1:
async with client2:
sub1 = await client1.create_subscription(100, sub_handler)
sub2 = await client2.create_subscription(100, sub_handler)
await sub1.subscribe_data_change(var)
await sub2.subscribe_data_change(var)
assert sub1.subscription_id in server.iserver.subscription_service.subscriptions
assert sub2.subscription_id in server.iserver.subscription_service.subscriptions
# When client2 disconnects, client1 should still keep its subscription.
assert sub1.subscription_id in server.iserver.subscription_service.subscriptions
assert sub2.subscription_id not in server.iserver.subscription_service.subscriptions
assert sub1.subscription_id not in server.iserver.subscription_service.subscriptions
assert sub2.subscription_id not in server.iserver.subscription_service.subscriptions
async def opcua_client():
"""
-handles connect/disconnect/reconnect/subscribe/unsubscribe
-connection-monitoring with cyclic read of the service-level
"""
client = Client(url=server_url)
handler = SubscriptionHandler()
subscription = None
case = 0
subscription_handle_list = []
idx = 0
while 1:
if case == 1:
#connect
print("connecting...")
try:
await client.connect()
await client.load_type_definitions()
idx = await client.get_namespace_index("http://andreas-heine.net/UA")
print("connected!")
case = 2
except:
print("connection error!")
case = 1
await asyncio.sleep(5)
elif case == 2:
#subscribe all nodes and events
print("subscribing nodes and events...")
try:
variable_list = await client.get_node("ns=2;i=6").get_children() # added for performance test with 100 quick and randomly changing variables
subscription = await client.create_subscription(50, handler)
subscription_handle_list = []
if nodes_to_subscribe:
for node in nodes_to_subscribe + variable_list: # added for performance test with 100 quick and randomly changing variables
# for node in nodes_to_subscribe:
handle = await subscription.subscribe_data_change(client.get_node(node))
subscription_handle_list.append(handle)
if events_to_subscribe:
for event in events_to_subscribe:
handle = await subscription.subscribe_events(event[0], event[1])
subscription_handle_list.append(handle)
print("subscribed!")
case = 3
except:
print("subscription error")
case = 4
await asyncio.sleep(0)
elif case == 3:
#running => read cyclic the service level if it fails disconnect and unsubscribe => wait 5s => connect
try:
if users == set():
datachange_notification_queue.clear()
event_notification_queue.clear()
service_level = await client.get_node("ns=0;i=2267").get_value()
if service_level >= 200:
case = 3
else:
case = 4
await asyncio.sleep(5)
async def writeY(data):
client = Client(data['opcUrl'])
client.name = "TOTO"
client.application_uri = "urn:freeopcua:clientasync"
async with client:
struct = client.get_node(
"ns=4;s=|var|CODESYS Control Win V3 x64.Application.GVL.intYPos")
await struct.write_value(data['yPos'], ua.VariantType.Int16)
async def read(data):
client = Client(data['opcUrl'])
client.name = "TOTO"
client.application_uri = "urn:freeopcua:clientasync"
async with client:
struct = client.get_node(
"ns=4;s=|var|CODESYS Control Win V3 x64.Application.GVL.stringStatus"
)
readVal = await struct.read_value()
return readVal
class HelloClient:
def __init__(self, endpoint):
self.client = Client(endpoint)
def __enter__(self):
self.client.connect()
return self.client
def __exit__(self, exc_type, exc_val, exc_tb):
self.client.disconnect()
async def opcua_client():
"""
-handles connect/disconnect/reconnect/subscribe/unsubscribe
-connection-monitoring with cyclic read of the service-level
"""
client = Client(url=server_url)
handler = SubscriptionHandler()
subscription = None
case = 0
subscription_handle_list = []
idx = 0
while 1:
if case == 1:
#connect
print("connecting...")
try:
await client.connect()
print("connected!")
case = 2
except:
print("connection error!")
case = 1
await asyncio.sleep(2)
elif case == 2:
#subscribe all nodes and events
print("subscribing nodes and events...")
try:
subscription = await client.create_subscription(200, handler)
subscription_handle_list = []
if nodes_to_subscribe:
for node in nodes_to_subscribe:
handle = await subscription.subscribe_data_change(
client.get_node(node))
subscription_handle_list.append(handle)
if events_to_subscribe:
for event in events_to_subscribe:
handle = await subscription.subscribe_events(
event[0], event[1])
subscription_handle_list.append(handle)
print("subscribed!")
case = 3
except:
print("subscription error")
case = 4
await asyncio.sleep(0)
elif case == 3:
#running => read cyclic the service level if it fails disconnect and unsubscribe => wait 5s => connect
try:
service_level = await client.get_node("ns=0;i=2267"
).get_value()
if service_level >= 200:
case = 3
else:
case = 4
await asyncio.sleep(2)
async def main():
client = Client("opc.tcp://localhost:53530/OPCUA/SimulationServer/")
client.set_security_string(
"Basic256Sha256,Sign,certificate-example.der,private-key-example.pem")
client.session_timeout = 2000
async with client:
root = client.nodes.root
objects = client.nodes.objects
while True:
print("childs og objects are: ", await objects.get_children())
await asyncio.sleep(1)
async def connectUa(data):
client = Client(data['opcUrl'])
client.name = "TOTO"
client.application_uri = "urn:freeopcua:clientasync"
try:
async with client:
struct = client.get_node(
ua.ObjectIds.Server_ServerStatus_CurrentTime)
time = await struct.read_value()
return time
except:
return 'failed'
async def test_max_connections_1(opc):
opc.server.iserver.isession.__class__.max_connections = 1
port = opc.server.endpoint.port
if port == port_num:
# if client we already have one connection
with pytest.raises(BadMaxConnectionsReached):
async with Client(f'opc.tcp://127.0.0.1:{port}'):
pass
else:
async with Client(f'opc.tcp://127.0.0.1:{port}'):
with pytest.raises(BadMaxConnectionsReached):
async with Client(f'opc.tcp://127.0.0.1:{port}'):
pass
opc.server.iserver.isession.__class__.max_connections = 1000
def __init__(self,
config: HaConfig,
security: Optional[HaSecurityConfig] = None,
loop=None) -> None:
self._config: HaConfig = config
self._keepalive_task: Dict[KeepAlive, asyncio.Task] = {}
self._manager_task: Dict[HaManager, asyncio.Task] = {}
self._reconciliator_task: Dict[Reconciliator, asyncio.Task] = {}
self._gen_sub: Generator[str, None, None] = self.generate_sub_name()
self.loop: asyncio.unix_events._UnixSelectorEventLoop = (
loop or asyncio.get_event_loop())
self._url_to_reset_lock = asyncio.Lock(loop=self.loop)
self._ideal_map_lock: asyncio.Lock = asyncio.Lock(loop=self.loop)
self._client_lock: asyncio.Lock = asyncio.Lock(loop=self.loop)
self.clients: Dict[Client, ServerInfo] = {}
self.active_client: Optional[Client] = None
# full type: Dict[str, SortedDict[str, VirtualSubscription]]
self.ideal_map: Dict[str, SortedDict] = {}
self.sub_names: Set[str] = set()
self.url_to_reset: Set[str] = set()
self.is_running = False
if config.ha_mode != HaMode.WARM:
# TODO
# Check if transparent redundancy support exist for the server (nodeid=2035)
# and prevent using HaClient with such servers.
raise NotImplementedError(
f"{config.ha_mode} not currently supported by HaClient")
for url in self.urls:
c = Client(url,
timeout=self._config.request_timeout,
loop=self.loop)
# timeouts for the session and secure channel are in ms
c.session_timeout = self._config.session_timeout * 1000
c.secure_channel_timeout = self._config.secure_channel_timeout * 1000
c.description = self._config.session_name
server_info = ServerInfo(url)
self.clients[c] = server_info
self.ideal_map[url] = SortedDict()
# security can also be set via the set_security method
self.security_config: HaSecurityConfig = (security if security else
HaSecurityConfig())
self.manager = HaManager(self, self._config.manager_timer)
self.reconciliator = Reconciliator(self._config.reconciliator_timer,
self)
async def opc(request):
"""
Fixture for tests that should run for both `Server` and `Client`
:param request:
:return:
"""
if request.param == 'client':
srv = Server()
await srv.init()
srv.set_endpoint(f'opc.tcp://127.0.0.1:{port_num}')
await add_server_methods(srv)
await srv.start()
# start client
# long timeout since travis (automated testing) can be really slow
clt = Client(f'opc.tcp://[email protected]:{port_num}', timeout=10)
await clt.connect()
yield Opc(clt, srv)
await clt.disconnect()
await srv.stop()
elif request.param == 'server':
# start our own server
srv = Server()
await srv.init()
srv.set_endpoint(f'opc.tcp://127.0.0.1:{port_num1}')
await add_server_methods(srv)
await srv.start()
yield Opc(srv, srv)
# stop the server
await srv.stop()
else:
raise ValueError("invalid internal test config")
async def main():
url = 'opc.tcp://CX-385DB1:4840'
# url = 'opc.tcp://commsvr.com:51234/UA/CAS_UA_Server'
async with Client(url=url) as client:
# Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects
root = client.get_root_node()
root = await root.get_children()
# 'main.xxx' is the node name, 4 is the namespace (ns) , E.G. in uaexpert/objects/plcbeckhoff/MAIN/o_rxd
O_RXD = client.get_node(ua.NodeId('MAIN.O_RXD', 4))
M_RXD = client.get_node(ua.NodeId('MAIN.M_RXD', 4))
M_RIF = client.get_node(ua.NodeId('MAIN.M_RIF', 4))
M_FOOD = client.get_node(ua.NodeId('MAIN.M_FOOD', 4))
out = await O_RXD.get_value()
print('RXD out is {v} '.format(v=out))
dt = 0.2
while True:
await M_RXD.set_attribute(ua.AttributeIds.Value, ua.DataValue(True))
time.sleep(dt)
await M_RXD.set_attribute(ua.AttributeIds.Value, ua.DataValue(False))
time.sleep(dt)
await M_RIF.set_attribute(ua.AttributeIds.Value, ua.DataValue(True))
time.sleep(dt)
await M_RIF.set_attribute(ua.AttributeIds.Value, ua.DataValue(False))
time.sleep(dt)
await M_FOOD.set_attribute(ua.AttributeIds.Value, ua.DataValue(True))
time.sleep(dt)
await M_FOOD.set_attribute(ua.AttributeIds.Value, ua.DataValue(False))
time.sleep(dt)
async def _uageneratestructs():
parser = argparse.ArgumentParser(
description=
"Generate a Python module from the xml structure definition (.bsd), the node argument is typically a children of i=93"
)
add_common_args(parser, require_node=True)
parser.add_argument(
"-o",
"--output",
dest="output_path",
required=True,
type=str,
default=None,
help="The python file to be generated.",
)
args = parse_args(parser, requirenodeid=True)
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
await client.connect()
try:
node = await get_node(client, args)
generators, _ = await client.load_type_definitions([node])
generators[0].save_to_file(args.output_path, True)
finally:
await client.disconnect()
async def admin_client():
# start admin client
# long timeout since travis (automated testing) can be really slow
clt = Client(f'opc.tcp://[email protected]:{port_num}', timeout=10)
await clt.connect()
yield clt
await clt.disconnect()
async def _uals():
parser = argparse.ArgumentParser(description="Browse OPC-UA node and print result")
add_common_args(parser)
parser.add_argument("-l",
dest="long_format",
const=3,
nargs="?",
type=int,
help="use a long listing format")
parser.add_argument("-d",
"--depth",
default=1,
type=int,
help="Browse depth")
args = parse_args(parser)
if args.long_format is None:
args.long_format = 1
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
try:
async with client:
node = await get_node(client, args)
print(f"Browsing node {node} at {args.url}\n")
if args.long_format == 0:
await _lsprint_0(node, args.depth - 1)
elif args.long_format == 1:
await _lsprint_1(node, args.depth - 1)
else:
await _lsprint_long(node, args.depth - 1)
except (OSError, concurrent.futures._base.TimeoutError) as e:
print(e)
sys.exit(1)
sys.exit(0)
async def _uasubscribe():
parser = argparse.ArgumentParser(
description="Subscribe to a node and print results")
add_common_args(parser)
parser.add_argument("-t",
"--eventtype",
dest="eventtype",
default="datachange",
choices=['datachange', 'event'],
help="Event type to subscribe to")
args = parse_args(parser, requirenodeid=False)
if args.eventtype == "datachange":
_require_nodeid(parser, args)
else:
# FIXME: this is broken, someone may have written i=84 on purpose
if args.nodeid == "i=84" and args.path == "":
args.nodeid = "i=2253"
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
await client.connect()
try:
node = await get_node(client, args)
handler = SubHandler()
sub = await client.create_subscription(500, handler)
if args.eventtype == "datachange":
await sub.subscribe_data_change(node)
else:
await sub.subscribe_events(node)
print("Type Ctr-C to exit")
while True:
time.sleep(1)
finally:
await client.disconnect()
async def test_basic256(srv_crypto):
clt = Client(uri_crypto)
await clt.set_security_string(
f"Basic256Sha256,Sign,{EXAMPLE_PATH}certificate-example.der,{EXAMPLE_PATH}private-key-example.pem"
)
async with clt:
assert await clt.get_objects_node().get_children()
async def _uaclient():
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"
)
add_common_args(parser)
parser.add_argument("-c", "--certificate", help="set client certificate")
parser.add_argument("-k", "--private_key", help="set client private key")
args = parse_args(parser)
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
if args.certificate:
await client.load_client_certificate(args.certificate)
if args.private_key:
await client.load_private_key(args.private_key)
try:
async with client:
mynode = await get_node(client, args)
except (OSError, concurrent.futures.TimeoutError) as e:
print(e)
sys.exit(1)
sys.exit(0)
async def test_basic256_encrypt(srv_crypto_all_certs):
clt = Client(uri_crypto)
await clt.set_security_string(
f"Basic256Sha256,SignAndEncrypt,{EXAMPLE_PATH}certificate-example.der,{EXAMPLE_PATH}private-key-example.pem"
)
async with clt:
assert await clt.nodes.objects.get_children()
async def _uals():
parser = argparse.ArgumentParser(
description="Browse OPC-UA node and print result")
add_common_args(parser)
parser.add_argument("-l",
dest="long_format",
const=3,
nargs="?",
type=int,
help="use a long listing format")
parser.add_argument("-d",
"--depth",
default=1,
type=int,
help="Browse depth")
args = parse_args(parser)
if args.long_format is None:
args.long_format = 1
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
await client.connect()
try:
node = await get_node(client, args)
print("Browsing node {0} at {1}\n".format(node, args.url))
if args.long_format == 0:
await _lsprint_0(node, args.depth - 1)
elif args.long_format == 1:
await _lsprint_1(node, args.depth - 1)
else:
_lsprint_long(node, args.depth - 1)
finally:
await client.disconnect()
async def main_mirror_client_2(shared):
#this client runs on an (local) mirror server together with main_mirror_client_1 and is connected to the virtual device server
url = 'opc.tcp://localhost:4841/virtual/server/'
async with Client(url=url) as client:
uri = 'http://examples.freeopcua.github.io'
idx = await client.get_namespace_index(uri)
sensor_value = await client.nodes.root.get_child(
["0:Objects", f"{idx}:Component", f"{idx}:SensorValue"])
command_id = await client.nodes.root.get_child(
["0:Objects", f"{idx}:Component", f"{idx}:CommandID"])
while True:
await asyncio.sleep(update_period_s)
#write sensor value to virtual device
await sensor_value.write_value(shared.sensor_value)
new_sensor_value = await sensor_value.read_value()
print("[Mirror_Client2] Write to virtual ", sensor_value,
new_sensor_value)
#read command id from virtual device
shared.command_id = await command_id.read_value()
print("[Mirror_Client2] Read from virtual ", command_id,
shared.command_id)
async def test_find_servers2(server, discovery_server):
client = Client(discovery_server.endpoint.geturl())
async with client:
servers = await client.find_servers()
new_app_uri1 = 'urn:freeopcua:python:server:test_discovery1'
await server.set_application_uri(new_app_uri1)
await server.register_to_discovery(discovery_server.endpoint.geturl(),
period=0)
new_app_uri2 = 'urn:freeopcua:python:test_discovery2'
await server.set_application_uri(new_app_uri2)
await server.register_to_discovery(discovery_server.endpoint.geturl(),
period=0)
await asyncio.sleep(0.1) # let server register registration
new_servers = await client.find_servers()
assert len(new_servers) - len(servers) == 2
assert new_app_uri1 not in [s.ApplicationUri for s in servers]
assert new_app_uri2 not in [s.ApplicationUri for s in servers]
assert new_app_uri1 in [s.ApplicationUri for s in new_servers]
assert new_app_uri2 in [s.ApplicationUri for s in new_servers]
# now do a query with filer
new_servers = await client.find_servers(
['urn:freeopcua:python:server'])
assert len(new_servers) - len(servers) == 0
assert new_app_uri1 in [s.ApplicationUri for s in new_servers]
assert new_app_uri2 not in [s.ApplicationUri for s in new_servers]
# now do a query with filer
new_servers = await client.find_servers(['urn:freeopcua:python'])
assert len(new_servers) - len(servers) == 2
assert new_app_uri1 in [s.ApplicationUri for s in new_servers]
assert new_app_uri2 in [s.ApplicationUri for s in new_servers]
async def main():
# setup our serverclone_and_subscribe(client_node, server_node, sub_handler)
client = Client(url=PLC_url)
cloud_cert = '/credentials/cloud_cert.der'
cloud_private_key = '/credentials/cloud_private_key.pem'
server_cert = '/credentials/PLC_cert.der'
await client.set_security(SecurityPolicyBasic256Sha256,
certificate=cloud_cert,
private_key=cloud_private_key,
server_certificate=server_cert)
await client.connect()
# client2 = Client(url=PLC_url_2)
#
# await client2.connect()
node_1_client = client.nodes.objects
# node_2_client = client2.nodes.objects
await produce_full_bridge_yaml(
[
# {'nodes': node_2_client, 'name': 'plc_2', 'url': PLC_url_2},
{
'nodes': node_1_client,
'name': 'plc_1',
'url': PLC_url,
'bridge_certificate': cloud_cert,
'bridge_private_key': cloud_private_key,
'server_certificate': server_cert
},
],
'/appdata/test_yaml/test.yaml')
async def main():
# url = 'opc.tcp://192.168.2.64:4840'
url = 'opc.tcp://localhost:4840/freeopcua/server/'
# url = 'opc.tcp://commsvr.com:51234/UA/CAS_UA_Server'
try:
async with Client(url=url) as client:
# Client has a few methods to get proxy to UA nodes that should always be in address space such as Root or Objects
root = client.get_root_node()
_logger.info('Objects node is: %r', root)
# Node objects have methods to read and write node attributes as well as browse or populate address space
_logger.info('Children of root are: %r', await root.get_children())
uri = 'http://examples.freeopcua.github.io'
idx = await client.get_namespace_index(uri)
# get a specific node knowing its node id
# var = client.get_node(ua.NodeId(1002, 2))
# var = client.get_node("ns=3;i=2002")
var = await root.get_child(
["0:Objects", f"{idx}:MyObject", f"{idx}:MyVariable"])
print("My variable", var, await var.get_value())
# print(var)
# var.get_data_value() # get value of node as a DataValue object
# var.get_value() # get value of node as a python builtin
# var.set_value(ua.Variant([23], ua.VariantType.Int64)) #set node value using explicit data type
# var.set_value(3.9) # set node value using implicit data type
# Now getting a variable node using its browse path
except Exception:
_logger.exception('error')
async def _uaread():
parser = argparse.ArgumentParser(
description=
"Read attribute of a node, per default reads value of a node")
add_common_args(parser)
parser.add_argument("-a",
"--attribute",
dest="attribute",
type=int,
default=ua.AttributeIds.Value,
help="Set attribute to read")
parser.add_argument("-t",
"--datatype",
dest="datatype",
default="python",
choices=['python', 'variant', 'datavalue'],
help="Data type to return")
args = parse_args(parser, requirenodeid=True)
client = Client(args.url, timeout=args.timeout)
await client.set_security_string(args.security)
await client.connect()
try:
node = await get_node(client, args)
attr = await node.read_attribute(args.attribute)
if args.datatype == "python":
print(attr.Value.Value)
elif args.datatype == "variant":
print(attr.Value)
else:
print(attr)
finally:
await client.disconnect()
async def run():
url = "opc.tcp://localhost:4840/Larouex-Industrial-Manufacturing/Server"
map_telemetry_file = MapTelemetry(Log)
map_telemetry_file.load_file()
map_telemetry_data = map_telemetry_file.data
config_file = Config(Log)
config_file_data = config_file.data
async with Client(url=url) as client:
idx = await client.get_namespace_index(map_telemetry_data["NameSpace"])
print(idx)
while True:
await asyncio.sleep(config_file_data["ClientFrequencyInSeconds"])
for node in map_telemetry_data["Nodes"]:
print(node["Name"])
for variable in node["Variables"]:
print(variable["DisplayName"])
print(variable["TelemetryName"])
read_node = client.get_node(variable["NodeId"])
val = await read_node.get_value()
print(val)
async def read(url):
print("######################debug: read() started")
async with Client(url=url) as client:
root = client.get_root_node()
program = await root.get_child(['0:Objects', '0:Server', '4:CODESYS Control Win V3 x64', '3:Resources', '4:Application', '3:Programs', '4:PLC_PRG'])
vars = await program.get_children()
var_test = client.get_node("ns=4;s=|var|CODESYS Control Win V3 x64.Application.PLC_PRG.int_var")
print('{}: \t {}' .format("teste", await var_test.get_value()))
##print(var)
##var.get_data_value() # get value of node as a DataValue object
#var.get_value() # get value of node as a python builtin
while True:
for var in vars:
var_output_test= await var.read_value()
print('{}: \t {}' .format((await var.get_display_name())._text, await var.read_value()))
print("test", var_output_test)
await asyncio.sleep(1)
print("-----------------------------------------------------")
#input_var= input()
#print( input_var)
_logger.info('Objects node is: %r', root)
print(program)
_logger.info('Children of root are: %r', await root.get_children())
print(await root.get_children())
async def main():
global _Running
try:
async with Client(url="opc.tcp://192.168.0.102:4840/") as client:
announcement('Connected')
_State = client.get_node("ns=2;i=2")
Vib_Data_List = await client.nodes.root.get_child(
["0:Objects", "2:MyACC", "2:Data_List"])
CT_Threshold = await client.nodes.root.get_child(
["0:Objects", "2:MyACC", "2:CT_Threshold"])
#CT_Data_List =await client.nodes.root.get_child(["0:Objects","2:MyACC","2:CT_Data_List"])
await CT_Threshold.write_value(3200)
# Check data change
handler = SubHandler()
sub = await client.create_subscription(500, handler)
handle = await sub.subscribe_data_change(Vib_Data_List)
while True:
try:
await _State.write_value(3)
await asyncio.sleep(10)
except Exception as e:
print(e)
break
except Exception as e:
print(e)
finally:
if _Running:
announcement('Disconnected')
else:
await _State.set_value(0)
announcement('End')
async def browse_nodes_children(Server_URL, NodeId):
"""Explora los hijos directos del NodeId provisto
Args:
Server_URL (string): Dirección del servidor OPC-UA
NodeId (string): Identificador del nodo de interés
Returns:
list: Nodos hijos
"""
async with Client(url=Server_URL, timeout=60*60) as client:
node = client.get_node(NodeId)
children = await node.get_children()
Nodes = [None]*len(children)
Nodes_Names = [None]*len(children)
Nodes_with_children = [0]*len(children)
if children:
for i, child in enumerate(children):
browse_name = await child.read_display_name()
Nodes[i] = child
Nodes_Names[i] = browse_name.Text
if await child.get_children():
Nodes_with_children[i] = 1
# print(f'{Nodes[i]}\t|\t{Nodes_Names[i]}\t{Nodes_with_children[i]}')
return [Nodes, Nodes_Names, Nodes_with_children]
