async def add_server_custom_enum_struct(server: Server):
# import some nodes from xml
await server.import_xml(f"{TEST_DIR}enum_struct_test_nodes.xml")
ns = await server.get_namespace_index('http://yourorganisation.org/struct_enum_example/')
uatypes.register_extension_object('ExampleStruct', ua.NodeId(5001, ns), ExampleStruct)
val = ua.ExampleStruct()
val.IntVal1 = 242
val.EnumVal = ua.ExampleEnum.EnumVal2
myvar = server.get_node(ua.NodeId(6009, ns))
await myvar.write_value(val)
async def apply_references(server: Server, node_mapping_list: list,
node_mapping: DownstreamBridgeNodeMapping):
for node_dict in tqdm(node_mapping_list):
references = node_dict['references']
original_node = server.get_node(node_dict['mapped_id'])
for ref in references:
new_target = node_mapping.get_bridge_id(ref['target'])
if new_target is not None:
try:
if ref['refTypeId'] == asyncua.ua.object_ids.ObjectIds.HasTypeDefinition:
continue
await original_node.add_reference(target=new_target,
reftype=ref['refTypeId'],
forward=ref['isForward'])
except:
pass
async def create_srv(port, key, cert):
srv = Server()
srvs.append(srv)
await srv.init()
await srv.set_application_uri("urn:freeopcua:python:discovery")
srv.set_endpoint(f"opc.tcp://127.0.0.1:{port}")
srv.set_security_policy([
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
])
await srv.load_certificate(cert)
await srv.load_private_key(key)
await srv.start()
# default the service level to 255 once started
slevel = srv.get_node(ua.NodeId(ua.ObjectIds.Server_ServiceLevel))
await slevel.write_value(ua.Variant(255, ua.VariantType.Byte))
return srv
async def main():
logging.basicConfig(level=logging.INFO)
server = Server()
await server.init()
# import some nodes from xml
nodes1 = await server.import_xml(
"../schemas/UA-Nodeset-master/DI/Opc.Ua.Di.NodeSet2.xml")
nodes2 = await server.import_xml(
"../schemas/UA-Nodeset-master/Robotics/Opc.Ua.Robotics.NodeSet2.xml")
nodes1 = [server.get_node(node) for node in nodes1]
nodes2 = [server.get_node(node) for node in nodes2]
await server.export_xml(nodes1, "di.xml")
await server.export_xml(nodes2, "rob.xml")
# starting!
async with server:
while True:
await asyncio.sleep(1)
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# Example 1 - create a basic object
#-------------------------------------------------------------------------------
myobj = objects.add_object(idx, "MyObject")
#-------------------------------------------------------------------------------
# Example 2 - create a new object type and a instance of the new object type
#-------------------------------------------------------------------------------
types = server.get_node(ua.ObjectIds.BaseObjectType)
object_type_to_derive_from = server.get_root_node().get_child(
["0:Types", "0:ObjectTypes", "0:BaseObjectType"])
mycustomobj_type = types.add_object_type(idx, "MyCustomObjectType")
mycustomobj_type.add_variable(0, "var_should_be_there_after_instantiate",
1.0) # demonstrates instantiate
myobj = objects.add_object(idx, "MyCustomObjectA", mycustomobj_type.nodeid)
#-------------------------------------------------------------------------------
# Example 3 - import a new object from xml address space and create a instance of the new object type
#-------------------------------------------------------------------------------
# Import customobject type
server.import_xml('customobject.xml')
# get an event generator for the server node which generates BaseEventType
serverevgen = server.get_event_generator()
serverevgen.event.Severity = 111
# Configure server to use sqlite as history database (default is a simple in memory dict)
server.iserver.history_manager.set_storage(HistorySQLite("my_event_history.sql"))
# starting!
server.start()
# enable history for myobj events; must be called after start since it uses subscription
server.iserver.enable_history_event(myobj, period=None)
# enable history for server events; must be called after start since it uses subscription
server_node = server.get_node(ua.ObjectIds.Server)
server.historize_node_event(server_node, period=None)
try:
count = 0
while True:
time.sleep(1)
count += 0.1
# generate events for subscribed clients and history
myevgen.trigger(message="This is MyFirstEvent " + str(count))
myevgen2.trigger(message="This is MySecondEvent " + str(count))
serverevgen.trigger(message="Server Event Message")
# read event history from sql
end_time = datetime.utcnow()
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'
)
