async def set_event_notifier(self, values):
"""
Set the event notifier attribute.
:param values: an iterable of EventNotifier enum values.
"""
event_notifier_bitfield = ua.EventNotifier.to_bitfield(values)
await self.set_attribute(
ua.AttributeIds.EventNotifier,
ua.DataValue(
ua.Variant(event_notifier_bitfield, ua.VariantType.Byte)))
async def disable_history_data_change(self, node):
"""
Set attribute Historizing of node to False and stop storing data for history
"""
await node.write_attribute(ua.AttributeIds.Historizing,
ua.DataValue(False))
await node.unset_attr_bit(ua.AttributeIds.AccessLevel,
ua.AccessLevel.HistoryRead)
await node.unset_attr_bit(ua.AttributeIds.UserAccessLevel,
ua.AccessLevel.HistoryRead)
await self.history_manager.dehistorize(node)
async def test_value(opc):
o = opc.opc.nodes.objects
var = ua.Variant(1.98, ua.VariantType.Double)
v = await o.add_variable(3, 'VariableValue', var)
assert 1.98 == await v.read_value()
dvar = ua.DataValue(var)
dv = await v.read_data_value()
assert ua.DataValue == type(dv)
assert dvar.Value == dv.Value
assert dvar.Value == var
await opc.opc.delete_nodes([v])
async def Start(self):
if self._config:
async with self._server:
#print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
logging.info("Server Started")
while True:
await asyncio.sleep(self.scan)
for element in self.mynodes:
#updating values
await self._server.write_attribute_value(
element.nodeid, ua.DataValue(sin(time.time())))
logging.warning("The server need to be configure it first")
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 test_server_read_write_attribute_value(server: Server):
node = await server.get_objects_node().add_variable(
0, "0:TestVar", 0, varianttype=ua.VariantType.Int64)
dv = server.read_attribute_value(node.nodeid, attr=ua.AttributeIds.Value)
assert dv.Value.Value == 0
dv = ua.DataValue(
Value=ua.Variant(Value=5, VariantType=ua.VariantType.Int64))
await server.write_attribute_value(node.nodeid,
dv,
attr=ua.AttributeIds.Value)
dv = server.read_attribute_value(node.nodeid, attr=ua.AttributeIds.Value)
assert dv.Value.Value == 5
await server.delete_nodes([node])
def _add_node_attr(self,
item,
nodedata,
name,
vtype=None,
add_timestamps=False):
if item.SpecifiedAttributes & getattr(ua.NodeAttributesMask, name):
dv = ua.DataValue(ua.Variant(getattr(item, name), vtype))
if add_timestamps:
# dv.ServerTimestamp = datetime.utcnow() # Disabled until someone explains us it should be there
dv.SourceTimestamp = datetime.utcnow()
nodedata.attributes[getattr(ua.AttributeIds,
name)] = AttributeValue(dv)
async def set_value(self, value, varianttype=None):
"""
Set value of a node. Only variables(properties) have values.
An exception will be generated for other node types.
value argument is either:
* a python built-in type, converted to opc-ua
optionnaly using the variantype argument.
* a ua.Variant, varianttype is then ignored
* a ua.DataValue, you then have full control over data send to server
WARNING: On server side, ref to object is directly saved in our UA db, if this is a mutable object
and you modfy it afterward, then the object in db will be modified without any
data change event generated
"""
datavalue = None
if isinstance(value, ua.DataValue):
datavalue = value
elif isinstance(value, ua.Variant):
datavalue = ua.DataValue(value)
datavalue.SourceTimestamp = datetime.utcnow()
else:
datavalue = ua.DataValue(ua.Variant(value, varianttype))
datavalue.SourceTimestamp = datetime.utcnow()
await self.set_attribute(ua.AttributeIds.Value, datavalue)
async def test_set_value(opc):
o = opc.opc.get_objects_node()
var = ua.Variant(1.98, ua.VariantType.Double)
dvar = ua.DataValue(var)
v = await o.add_variable(3, 'VariableValue', var)
await v.set_value(var.Value)
v1 = await v.get_value()
assert v1 == var.Value
await v.set_value(var)
v2 = await v.get_value()
assert v2 == var.Value
await v.set_data_value(dvar)
v3 = await v.get_data_value()
assert v3.Value == dvar.Value
async def test_write_value(opc):
o = opc.opc.nodes.objects
var = ua.Variant(1.98, ua.VariantType.Double)
dvar = ua.DataValue(var)
v = await o.add_variable(3, 'VariableValue', var)
await v.write_value(var.Value)
v1 = await v.read_value()
assert v1 == var.Value
await v.write_value(var)
v2 = await v.read_value()
assert v2 == var.Value
await v.write_value(dvar)
v3 = await v.read_data_value()
assert v3.Value == dvar.Value
def _add_node_attr(self,
item,
nodedata,
name,
vtype=None,
add_timestamps=False,
is_array=False):
if item.SpecifiedAttributes & getattr(ua.NodeAttributesMask, name):
dv = ua.DataValue(
ua.Variant(getattr(item, name), vtype, is_array=is_array),
SourceTimestamp=datetime.utcnow() if add_timestamps else None,
)
nodedata.attributes[getattr(ua.AttributeIds,
name)] = AttributeValue(dv)
async def enable_history_data_change(self,
node,
period=timedelta(days=7),
count=0):
"""
Set attribute Historizing of node to True and start storing data for history
"""
await node.write_attribute(ua.AttributeIds.Historizing,
ua.DataValue(True))
await node.set_attr_bit(ua.AttributeIds.AccessLevel,
ua.AccessLevel.HistoryRead)
await node.set_attr_bit(ua.AttributeIds.UserAccessLevel,
ua.AccessLevel.HistoryRead)
await self.history_manager.historize_data_change(node, period, count)
def _add_node_attr(self,
attributes: __TYPE_ATTRIBUTES,
nodedata: NodeData,
name: str,
vtype: ua.VariantType = None,
add_timestamps: bool = False,
is_array: bool = False):
if attributes.SpecifiedAttributes & getattr(ua.NodeAttributesMask,
name):
dv = ua.DataValue(
ua.Variant(getattr(attributes, name), vtype,
is_array=is_array),
SourceTimestamp=datetime.utcnow() if add_timestamps else None,
)
nodedata.attributes[getattr(ua.AttributeIds,
name)] = AttributeValue(dv)
async def _uawrite():
parser = argparse.ArgumentParser(
description="Write attribute of a node, per default write value of 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("-l",
"--list",
"--array",
dest="array",
default="guess",
choices=["guess", "true", "false"],
help="Value is an array")
parser.add_argument("-t",
"--datatype",
dest="datatype",
default="guess",
choices=[
"guess", 'byte', 'sbyte', 'nodeid',
'expandednodeid', 'qualifiedname', 'browsename',
'string', 'float', 'double', 'int16', 'int32',
"int64", 'uint16', 'uint32', 'uint64', "bool",
"string", 'datetime', 'bytestring', 'xmlelement',
'statuscode', 'localizedtext'
],
help="Data type to return")
parser.add_argument("value", help="Value to be written", metavar="VALUE")
args = parse_args(parser, requirenodeid=True)
client = Client(args.url, timeout=args.timeout)
await _configure_client_with_args(client, args)
try:
await client.connect()
node = await get_node(client, args)
val = _val_to_variant(args.value, args)
await node.write_attribute(args.attribute, ua.DataValue(val))
except Exception as e:
print(e)
sys.exit(1)
finally:
await client.disconnect()
sys.exit(0)
async def setup_nodes(self):
"""
Set up some nodes as defined by spec
"""
uries = ['http://opcfoundation.org/UA/']
ns_node = Node(self.isession,
ua.NodeId(ua.ObjectIds.Server_NamespaceArray))
await ns_node.write_value(uries)
params = ua.WriteParameters()
for nodeid in (
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerRead,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadData,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryReadEvents,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerWrite,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateData,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerHistoryUpdateEvents,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerMethodCall,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerBrowse,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerRegisterNodes,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerTranslateBrowsePathsToNodeIds,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxNodesPerNodeManagement,
ua.ObjectIds.
Server_ServerCapabilities_OperationLimits_MaxMonitoredItemsPerCall,
):
attr = ua.WriteValue()
attr.NodeId = ua.NodeId(nodeid)
attr.AttributeId = ua.AttributeIds.Value
attr.Value = ua.DataValue(
ua.Variant(10000, ua.VariantType.UInt32),
StatusCode_=ua.StatusCode(ua.StatusCodes.Good),
ServerTimestamp=datetime.utcnow(),
)
params.NodesToWrite.append(attr)
result = await self.isession.write(params)
result[0].check()
async def main():
url = 'opc.tcp://localhost:4840/freeopcua/server/'
async with Client(url=url) as client:
uri = 'http://examples.freeopcua.github.io'
idx = await client.get_namespace_index(uri)
var = await client.nodes.root.get_child(
["0:Objects", f"{idx}:MyObject", f"{idx}:MyVariable"])
nb = 4000
start = time.time()
attr = ua.WriteValue()
attr.NodeId = var.nodeid
attr.AttributeId = ua.AttributeIds.Value
attr.Value = ua.DataValue(ua.Variant(1.0, ua.VariantType.Float))
params = ua.WriteParameters()
params.NodesToWrite = [attr]
for i in range(nb):
params.NodesToWrite[0].Value.Value.Value = i
result = await client.uaclient.write_value(params)
#result[0].check()
#await var.write_value(i)
print("\n Write frequency: \n", nb / (time.time() - start))
async def write(url):
print("######################debug: write() started")
async with Client(url=url) as client:
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)
while True:
await asyncio.sleep(5)
print("############################### Changing Value! ###########################")
try:
#input_var= input()
#print(input_var)
datavalue = ua.DataValue(ua.Variant(3, ua.VariantType.Int16))
await var_test.write_value(datavalue) # set node value using implicit data type
except:
print("!!!!!!!!!!!!!!!!!!!!!!! ERROR Changing Value! !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!")
async def read_node_history(self, node_id, start, end, nb_values):
table = self._get_table_name(node_id)
start_time, end_time, order, limit = self._get_bounds(start, end, nb_values)
cont = None
results = []
# select values from the database; recreate UA Variant from binary
try:
async with self._db.execute(
f'SELECT * FROM "{table}" WHERE "SourceTimestamp" BETWEEN ? AND ? '
f'ORDER BY "_Id" {order} LIMIT ?', (start_time, end_time, limit,)) as cursor:
async for row in cursor:
# rebuild the data value object
dv = ua.DataValue(variant_from_binary(Buffer(row[6])))
dv.ServerTimestamp = row[1]
dv.SourceTimestamp = row[2]
dv.StatusCode = ua.StatusCode(row[3])
results.append(dv)
except aiosqlite.Error as e:
self.logger.error("Historizing SQL Read Error for %s: %s", node_id, e)
if nb_values:
if len(results) > nb_values:
cont = results[nb_values].SourceTimestamp
results = results[:nb_values]
return results, cont
async def main():
# optional: setup logging
#logger = logging.getLogger("asyncua.address_space")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.internal_server")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.binary_server_asyncio")
# logger.setLevel(logging.DEBUG)
#logger = logging.getLogger("asyncua.uaprocessor")
# logger.setLevel(logging.DEBUG)
# now setup our server
server = Server()
await server.init()
server.disable_clock() #for debuging
#server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/")
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
server.set_server_name("FreeOpcUa Example Server")
# set all possible endpoint policies for clients to connect through
server.set_security_policy([
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
ua.SecurityPolicyType.Basic256Sha256_Sign
])
# setup our own namespace
uri = "http://examples.freeopcua.github.io"
idx = await server.register_namespace(uri)
# create a new node type we can instantiate in our address space
dev = await server.nodes.base_object_type.add_object_type(idx, "MyDevice")
await (await dev.add_variable(idx, "sensor1",
1.0)).set_modelling_rule(True)
await (await dev.add_property(idx, "device_id",
"0340")).set_modelling_rule(True)
ctrl = await dev.add_object(idx, "controller")
await ctrl.set_modelling_rule(True)
await (await ctrl.add_property(idx, "state",
"Idle")).set_modelling_rule(True)
# populating our address space
# First a folder to organise our nodes
myfolder = await server.nodes.objects.add_folder(idx, "myEmptyFolder")
# instanciate one instance of our device
mydevice = await server.nodes.objects.add_object(idx, "Device0001", dev)
mydevice_var = await mydevice.get_child(
[f"{idx}:controller",
f"{idx}:state"]) # get proxy to our device state variable
# create directly some objects and variables
myobj = await server.nodes.objects.add_object(idx, "MyObject")
myvar = await myobj.add_variable(idx, "MyVariable", 6.7)
await myvar.set_writable() # Set MyVariable to be writable by clients
mystringvar = await myobj.add_variable(idx, "MyStringVariable",
"Really nice string")
await mystringvar.set_writable(
) # Set MyVariable to be writable by clients
mydtvar = await myobj.add_variable(idx, "MyDateTimeVar", datetime.utcnow())
await mydtvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = await myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myarrayvar = await myobj.add_variable(
idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32))
myprop = await myobj.add_property(idx, "myproperty", "I am a property")
mymethod = await myobj.add_method(idx, "mymethod", func,
[ua.VariantType.Int64],
[ua.VariantType.Boolean])
multiply_node = await myobj.add_method(
idx, "multiply", multiply,
[ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64])
# import some nodes from xml
await server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = await server.get_event_generator()
myevgen.event.Severity = 300
# starting!
async with server:
print("Available loggers are: ",
logging.Logger.manager.loggerDict.keys())
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
# trigger event, all subscribed clients wil receive it
var = await myarrayvar.read_value(
) # return a ref to value in db server side! not a copy!
var = copy.copy(
var
) # WARNING: we need to copy before writting again otherwise no data change event will be generated
var.append(9.3)
await myarrayvar.write_value(var)
await mydevice_var.write_value("Running")
await myevgen.trigger(message="This is BaseEvent")
await server.write_attribute_value(
myvar.nodeid, ua.DataValue(0.9)
) # Server side write method which is a bit faster than using write_value
while True:
await asyncio.sleep(0.1)
await server.write_attribute_value(myvar.nodeid,
ua.DataValue(sin(time.time())))
try:
while True:
# from an OPC UA client write a value to this node to see it show up in the python object
print('Python mirror of MyClientWrite is: ' + str(my_python_obj.MyClientWrite))
# write a single attr to OPC UA
my_python_obj.MyVariable = 12.3
my_python_obj.MyProperty = 55 # this value will not be visible to clients because write is not called
my_python_obj.write_value('MyVariable')
time.sleep(3)
# write all attr of the object to OPC UA
my_python_obj.MyVariable = 98.1
my_python_obj.MyProperty = 99
my_python_obj.write_value()
time.sleep(3)
# write directly to the OPC UA node of the object
dv = ua.DataValue(ua.Variant(5.5, ua.VariantType.Double))
my_python_obj.nodes['MyVariable'].write_value(dv)
dv = ua.DataValue(ua.Variant(4, ua.VariantType.UInt64))
my_python_obj.nodes['MyVariable'].write_value(dv)
time.sleep(3)
finally:
# close connection, remove subscriptions, etc
server.stop()
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
with server:
print("Available loggers are: ",
logging.Logger.manager.loggerDict.keys())
vup = VarUpdater(mysin) # just a stupide class update a variable
vup.start()
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
# trigger event, all subscribed clients wil receive it
var = myarrayvar.read_value(
) # return a ref to value in db server side! not a copy!
var = copy.copy(
var
) # WARNING: we need to copy before writting again otherwise no data change event will be generated
var.append(9.3)
myarrayvar.write_value(var)
mydevice_var.write_value("Running")
myevgen.trigger(message="This is BaseEvent")
server.write_attribute_value(
myvar.nodeid, ua.DataValue(9.9)
) # Server side write method which is a but faster than using write
embed()
vup.stop()
async def write_value_rank(self, value):
"""
Set attribute ValueRank of node
"""
v = ua.Variant(value, ua.VariantType.Int32)
await self.write_attribute(ua.AttributeIds.ValueRank, ua.DataValue(v))
async def unset_attr_bit(self, attr, bit):
dv = await self.read_attribute(attr)
val = ua.ua_binary.unset_bit(dv.Value.Value, bit)
await self.write_attribute(
attr, ua.DataValue(ua.Variant(val, dv.Value.VariantType)))
async def datachange_notification(self, node, val, data):
if self.orig_data == node:
if not isinstance(val, bool):
logger.error("Node value is not boolean")
return
await self.server.write_attribute_value(self.copy_data.nodeid, ua.DataValue(val))
async def test_xml_string_with_null_description(opc, tmpdir):
o = await opc.opc.nodes.objects.add_variable(2, "xmlstring", "mystring")
await o.write_attribute(ua.AttributeIds.Description, ua.DataValue(None))
o2 = await _test_xml_var_type(opc, tmpdir, o, "string")
assert await o.get_description() == await o2.get_description()
async def set_value_rank(self, value):
"""
Set attribute ArrayDimensions of node
"""
v = ua.Variant(value, ua.VariantType.Int32)
await self.set_attribute(ua.AttributeIds.ValueRank, ua.DataValue(v))
async def main():
_logger = logging.getLogger('Server')
#logger = logging.getLogger("asyncua.address_space")
#logger = logging.getLogger("asyncua.internal_server")
#logger = logging.getLogger("asyncua.binary_server_asyncio")
#logger = logging.getLogger("asyncua.uaprocessor")
server = Server()
await server.init()
server.set_endpoint("opc.tcp://0.0.0.0:16703/")
server.set_server_name("Servidor OPC eMPC MA")
await server.set_application_uri(uri="http://servidor-eMPC-MA.com/test/")
server.set_security_policy([ua.SecurityPolicyType.NoSecurity])
server._permission_ruleset = None
server._policyIDs = ["Anonymous"]
server.certificate = None
uri = "Servidor OPC eMPC MA"
idx = await server.register_namespace(uri)
await server.import_xml("deck_opcua.xml")
_logger.info("Iniciando servidor OPC-UA...")
_logger.info("Escuchando en: opc.tcp://localhost:16703/")
# Crear instancia del controlador
controlador = clase_MPC.Controlador()
# starting!
async with server:
while True:
await asyncio.sleep(0.01)
command_run = await server.get_node("ns=6;s=command_run"
).get_value()
if command_run == 1:
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node read: command_run = {command_run}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Executing...'
)
await controlador.recibir_variables(server)
controlador.actualizar_arrays()
ControlFlag = await server.get_node("ns=4;s=ControlFlag"
).read_value()
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node read: Control_Flag = {ControlFlag}'
)
if ControlFlag:
controlador.ejecutar()
await server.write_attribute_value(
server.get_node("ns=4;s=uq[1]").nodeid,
ua.DataValue(controlador.uq1))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t \
Node written: uq1 = {controlador.uq1:.3f}')
await server.write_attribute_value(
server.get_node("ns=4;s=uFr[1]").nodeid,
ua.DataValue(controlador.uFr1))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t \
Node written: uFr1 = {controlador.uFr1:.3f}'
)
# Falta escribir todas las variables del controlador al servidor
await controlador.escribir_variables(server)
await server.write_attribute_value(
server.get_node("ns=6;s=command_run").nodeid,
ua.DataValue(0))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: command_run = 0'
)
# import some nodes from xml
server.import_xml("custom_nodes.xml")
# creating a default event object
# The event object automatically will have members for all events properties
# you probably want to create a custom event type, see other examples
myevgen = server.get_event_generator()
myevgen.event.Severity = 300
# starting!
with server:
print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
vup = VarUpdater(mysin) # just a stupide class update a variable
vup.start()
# enable following if you want to subscribe to nodes on server side
#handler = SubHandler()
#sub = server.create_subscription(500, handler)
#handle = sub.subscribe_data_change(myvar)
# trigger event, all subscribed clients wil receive it
var = myarrayvar.get_value() # return a ref to value in db server side! not a copy!
var = copy.copy(var) # WARNING: we need to copy before writting again otherwise no data change event will be generated
var.append(9.3)
myarrayvar.set_value(var)
mydevice_var.set_value("Running")
myevgen.trigger(message="This is BaseEvent")
server.set_attribute_value(myvar.nodeid, ua.DataValue(9.9)) # Server side write method which is a but faster than using set_value
embed()
vup.stop()
async def escribir_variables(s, server):
# Los arrays en el espacio de nombres del servidor empiezan en 1, y no en cero como en Python
# MHE
for i in range(s.Nx):
await server.write_attribute_value(
server.get_node(f"ns=4;s=state[{i+1}]").nodeid,
ua.DataValue(s.state[i]))
await server.write_attribute_value(
server.get_node(f"ns=4;s=v_new[{i+1}]").nodeid,
ua.DataValue(s.v_new[i]))
await server.write_attribute_value(
server.get_node(f"ns=4;s=error[{i+1}]").nodeid,
ua.DataValue(s.error[i]))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: state[{i+1}] = {s.state[i]}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: v_new[{i+1}] = {s.v_new[i]}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: error[{i+1}] = {s.error[i]}'
)
for i in range(2):
# Gradientes
await server.write_attribute_value(
server.get_node(f"ns=4;s=grad_m[{i+1}]").nodeid,
ua.DataValue(s.grad_m[i]))
await server.write_attribute_value(
server.get_node(f"ns=4;s=grad_p[{i+1}]").nodeid,
ua.DataValue(s.grad_p[i]))
# MA
await server.write_attribute_value(
server.get_node(f"ns=4;s=Lambda[{i+1}]").nodeid,
ua.DataValue(s.Lambda[i]))
await server.write_attribute_value(
server.get_node(f"ns=4;s=Gamma[{i+1}]").nodeid,
ua.DataValue(s.Gamma[i]))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: grad_m[{i+1}] = {s.grad_m[i]}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: grad_p[{i+1}] = {s.grad_p[i]}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: Lambda[{i+1}] = {s.Lambda[i]}'
)
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: Gamma[{i+1}] = {s.Gamma[i]}'
)
await server.write_attribute_value(
server.get_node(f"ns=4;s=Epsilon").nodeid, ua.DataValue(s.Epsilon))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: Epsilon = {s.Epsilon}'
)
# Para verificar que está calculando el controlador
await server.write_attribute_value(
server.get_node(f"ns=4;s=MPC_T_end").nodeid,
ua.DataValue(s.m_MPC.T[60.0].value + s.m_MPC.error[2].value))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: MPC_T_end = {s.m_MPC.T[60.0].value+s.m_MPC.error[2].value}'
)
await server.write_attribute_value(
server.get_node(f"ns=4;s=MPC_g1").nodeid,
ua.DataValue(value(s.m_MPC.c1)))
_logger.info(
f' [{datetime.now().strftime("%H:%M:%S.%f")[:-3]}]\t Node written: MPC_g1 = {value(s.m_MPC.c1)}'
)
def add_value(history, age):
value = ua.DataValue()
value.SourceTimestamp = datetime.utcnow() - timedelta(hours=age)
return history.save_node_value(NODE_ID, value)
