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)