def setUpClass(cls):
# start our own server
cls.srv_crypto = Server()
cls.uri_crypto = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num1)
cls.srv_crypto.set_endpoint(cls.uri_crypto)
# load server certificate and private key. This enables endpoints
# with signing and encryption.
cls.srv_crypto.load_certificate("../examples/certificate-example.der")
cls.srv_crypto.load_private_key("../examples/private-key-example.pem")
cls.srv_crypto.start()
# start a server without crypto
cls.srv_no_crypto = Server()
cls.uri_no_crypto = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num2)
cls.srv_no_crypto.set_endpoint(cls.uri_no_crypto)
cls.srv_no_crypto.start()
# start server with long key
cls.srv_crypto2 = Server()
cls.uri_crypto2 = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num3)
cls.srv_crypto2.set_endpoint(cls.uri_crypto2)
cls.srv_crypto2.load_certificate("../examples/certificate-3072-example.der")
cls.srv_crypto2.load_private_key("../examples/private-key-3072-example.pem")
cls.srv_crypto2.start()
cls.srv_crypto_no_anoymous = Server()
cls.uri_crypto_no_anoymous = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num4)
cls.srv_crypto_no_anoymous.set_endpoint(cls.uri_crypto_no_anoymous)
cls.srv_crypto_no_anoymous.load_certificate("examples/certificate-3072-example.der")
cls.srv_crypto_no_anoymous.load_private_key("examples/private-key-3072-example.pem")
cls.srv_crypto_no_anoymous.set_security_IDs(["Username", "Basic256Sha256"])
cls.srv_crypto_no_anoymous.start()
def setUpClass(self):
self.srv = Server()
self.srv.set_endpoint('opc.tcp://localhost:%d' % port_num)
add_server_methods(self.srv)
self.srv.start()
self.opc = self.srv
self.discovery = Server()
self.discovery.set_application_uri("urn:freeopcua:python:discovery")
self.discovery.set_endpoint('opc.tcp://localhost:%d' % port_discovery)
self.discovery.start()
def setUpClass(cls):
cls.srv = Server()
cls.srv.set_endpoint('opc.tcp://127.0.0.1:{0:d}'.format(port_num))
add_server_methods(cls.srv)
cls.srv.start()
cls.opc = cls.srv
cls.discovery = Server()
cls.discovery.set_application_uri("urn:freeopcua:python:discovery")
cls.discovery.set_endpoint('opc.tcp://127.0.0.1:{0:d}'.format(port_discovery))
cls.discovery.start()
def test_port_in_use(self):
server1 = Server()
server1.set_endpoint('opc.tcp://localhost:{0:d}'.format(port_num + 1))
server1.start()
server2 = Server()
server2.set_endpoint('opc.tcp://localhost:{0:d}'.format(port_num + 1))
try:
server2.start()
except Exception:
pass
server1.stop()
server2.stop()
def createOPCUA():
global server
server = Server()
url = "opc.tcp://10.148.6.70:4840"
server.set_endpoint(url)
name = "MOTOR_SIMULATION"
addspace = server.register_namespace(name)
node = server.get_objects_node()
Param = node.add_object(addspace, "Parameters")
Temp = Param.add_variable(addspace, "Temperature", 0)
Vibr = Param.add_variable(addspace, "Vibration", 0)
Curr = Param.add_variable(addspace, "Current", 0)
Rpm = Param.add_variable(addspace, "Rate Per Minute", 0)
Temp.set_writable()
Vibr.set_writable()
Curr.set_writable()
Rpm.set_writable()
server.start()
print("Server started at {}".format(url))
return [Temp, Vibr, Curr, Rpm]
def start_server_and_client(cls):
cls.srv = Server()
cls.srv.set_endpoint('opc.tcp://localhost:%d' % port_num1)
cls.srv.start()
cls.clt = Client('opc.tcp://localhost:%d' % port_num1)
cls.clt.connect()
def __init__(self, logger):
self.isinit = False
self.logger = logger
# setup our server
self.server = Server()
self.server.set_endpoint('opc.tcp://localhost:4840/')
self.server.allow_remote_admin(True)
# setup our own namespace, not really necessary but should as spec
uri = "http://yourorganisation.org/DCSControllerDesign/"
self.idx = self.server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
self.objects = self.server.get_objects_node()
# populating our address space; in most real use cases this should be
# imported from UA spec XML.
self.logger.notice('Import UA spec from xml ...')
self.server.import_xml('dcscontrollerdesign.xml')
self.dctni = ua.NodeId.from_string(f'ns={self.idx};i=1003')
self.logger.info(f'{self.dctni}')
self.logger.success('Done')
def __init__(self):
self.server = None
self.uri = ""
self.idx = 0
self.scan_thread = None
self.scan_enable = False
self.devices = []
# setup our server
self.server = Server()
self.server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = self.server.register_namespace(uri)
# import address space which has a device object
self.server.import_xml("device.xml")
# get Objects node
objects = self.server.get_objects_node()
# get the device object type so we can find all the devices in the address space
hw_type = self.server.nodes.base_object_type.get_child("2:Device")
device_nodes = find_o_types(objects, hw_type)
# instantiate a device python object and make it an attribute of the server class
# FIXME do your own organization, most likely an object oriented model
for device_node in device_nodes:
device = Device(self.server, device_node)
setattr(self, device.b_name, device)
# keep track of the device because so that we can update it cyclically using the driver
self.devices.append(device)
def __init__(self, endpoint, name):
# Logging configuration
self.logger = logging.getLogger('MyDeviceServer')
self.logger.setLevel(logging.INFO)
# Setup server
self.server = Server()
self.server.import_xml("MyDevice.xml")
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
self.objects_node = self.server.get_objects_node()
self.my_device_node = self.objects_node.get_child("0:MyDevice")
self.my_device_toggle_b = self.my_device_node.get_child("0:ToggleB")
self.my_device_toggle_c = self.my_device_node.get_child("0:ToggleC")
self.my_device_toggle_d = self.my_device_node.get_child("0:ToggleD")
self.server.link_method(self.my_device_toggle_b, self.toggle_b)
self.server.link_method(self.my_device_toggle_c, self.toggle_c)
self.server.link_method(self.my_device_toggle_d, self.toggle_d)
self.my_variable_a = self.my_device_node.get_child("0:VariableA")
self.my_variable_b = self.my_device_node.get_child("0:VariableB")
self.my_variable_c = self.my_device_node.get_child("0:VariableC")
self.my_variable_d = self.my_device_node.get_child("0:VariableD")
self.my_variable_e = self.my_device_node.get_child("0:VariableE")
def __init__(self, port=Opcx.DEFAULT_PORT, name='OpcxServer'):
from opcua import Server
server = Server()
server.set_server_name(name)
server.set_endpoint("opc.tcp://0.0.0.0:%d/freeopcua/server/" % port)
self.objix = server.register_namespace(Opcx.DEFAULT_URI)
self.server = server
def start_server(url):
server = Server()
server.set_endpoint(url)
name = "OPC UA Simulation Server"
addspace = server.register_namespace(name)
node = server.get_objects_node()
lvl = node.add_object(addspace, "Level Sensors")
lvl1 = lvl.add_variable(addspace, "LVL1", 5)
lvl2 = lvl.add_variable(addspace, "LVL2", 6)
lvl3 = lvl.add_variable(addspace, "LVL3", 7)
lvl4 = lvl.add_variable(addspace, "LVL4", 8)
lvl5 = lvl.add_variable(addspace, "LVL5", 9)
lvl6 = lvl.add_variable(addspace, "LVL6", 10)
flow = node.add_object(addspace, "Flow Sensors")
flow1 = flow.add_variable(addspace, "FLOW1", 1)
flow2 = flow.add_variable(addspace, "FLOW2", 2)
flow3 = flow.add_variable(addspace, "FLOW3", 3)
flow4 = flow.add_variable(addspace, "FLOW4", 4)
pump = node.add_object(addspace, "Pump Actuators")
pump1 = pump.add_variable(addspace, "PUMP1", 0.1)
pump2 = pump.add_variable(addspace, "PUMP2", 0.2)
pump3 = pump.add_variable(addspace, "PUMP3", 0.3)
pump4 = pump.add_variable(addspace, "PUMP4", 0.4)
pump5 = pump.add_variable(addspace, "PUMP5", 0.5)
pump6 = pump.add_variable(addspace, "PUMP6", 0.6)
server.start()
return server
def __init__(self):
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# 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 nodes
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
myvar1 = myobj.add_variable(idx, "MyVariable1", 1)
myvar2 = myobj.add_variable(idx, "MyVariable2", 2)
myvar3 = myobj.add_variable(idx, "MyVariable3", 3)
myvar4 = myobj.add_variable(idx, "MyVariable4", 4)
myvar5 = myobj.add_variable(idx, "MyVariable5", 5)
myvar1.set_writable() # Set MyVariable to be writable by clients
myvar2.set_writable() # Set MyVariable to be writable by clients
myvar3.set_writable() # Set MyVariable to be writable by clients
myvar4.set_writable() # Set MyVariable to be writable by clients
myvar5.set_writable() # Set MyVariable to be writable by clients
self.server = server
def __init__(
self,
endpoint: str = "opc.tcp://0.0.0.0:4840/intry4.0/server/",
server_name: str = "InTry 4.0 - OPC UA Server",
security_policy: List[ua.SecurityPolicyType] = None,
ns_uri: str = "urn:intry:opcua:server",
object_name: str = "variables",
last_row_file: str = "/var/intry-opcua-server/last_row.log",
certificate: str = "/var/intry-opcua-server/cert.der",
private_key: str = "/var/intry-opcua-server/key.pem",
min_time: int = 30,
logger=None,
):
if security_policy is None:
_security_policy = [
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_Sign,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
]
self._server = Server()
self.endpoint = endpoint
self._server.set_endpoint(self.endpoint)
self._server.set_security_policy(_security_policy)
self._server.load_certificate(certificate)
self._server.load_private_key(private_key)
self._ns_index = self._server.register_namespace(ns_uri)
self._object = self._server.nodes.objects.add_object(
self._ns_index, object_name
)
self._last_row_file = last_row_file
self._logger = logger or logging.getLogger(__name__)
self.last_row = {}
self._stop = False
self.min_time = min_time
def main():
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
server_namespace = "http://examples.freeopcua.github.io"
address_space = server.register_namespace(server_namespace)
# get Objects node, this is where we should put our custom stuff
objects_node = server.get_objects_node()
# Add the ocp objects (vars, features,...)
# cresting the first object
my_first_object = objects_node.add_object(address_space, "MyFirstObject")
##creating an array
my_array = ChargeControllerObject.add_variable(address_space, "MyArray",
[6.7, 7.9])
# the variable could be hard typed
my_hardtyped_array = ChargeControllerObject.add_variable(
address_space, "MyHardtypedArray", ua.Variant([],
ua.VariantType.Float))
# starting!
server.start()
print("Server starting ...")
while True:
time.sleep(1)
## update array variables
burst = [random.random() for _ in range(1024)]
my_array.set_value(burst)
my_hardtyped_array.set_value(burst)
def run_opcua_server():
"""
Creates the OPC/UA server and starts it.
"""
# setup our server
server = Server()
server.set_endpoint("opc.tcp://localhost:26543/example/server")
# setup our own namespace, not really necessary but should as spec
uri = "https://github.com/nathanagood/aws-greengrass-samples"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
# starting!
server.start()
try:
count = 0
while True:
time.sleep(5)
count += 1
logger.debug('Setting value: %s', count)
myvar.set_value(count)
finally:
#close connection, remove subcsriptions, etc
server.stop()
async def task(loop):
# setup our server
server = Server()
await server.init()
server.set_endpoint('opc.tcp://0.0.0.0:4840/freeopcua/server/') #4840
# setup our own namespace, not really necessary but should as spec
uri = 'http://examples.freeopcua.github.io'
idx = await server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
await objects.add_method(ua.NodeId("ServerMethod", 2),
ua.QualifiedName('ServerMethod', 2), func,
[ua.VariantType.Int64], [ua.VariantType.Int64])
# populating our address space
myobj = await 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
# starting!
async with server:
count = 0
while True:
await asyncio.sleep(1)
count += 0.1
await myvar.set_value(count)
def __init__(self, endpoint, name, model_filepath):
self.server = Server()
# This need to be imported at the start or else it will overwrite the data
self.server.import_xml(model_filepath)
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
objects = self.server.get_objects_node()
freeopcua_namespace = self.server.get_namespace_index(
"urn:freeopcua:python:server")
hellower = objects.get_child("0:Hellower")
hellower_say_hello = hellower.get_child("0:SayHello")
hellower_exe_calculate = hellower.get_child("0:Calculator")
self.server.link_method(hellower_say_hello, say_hello_xml)
self.server.link_method(hellower_exe_calculate, exe_calculator)
hellower.add_method(freeopcua_namespace, "SayHello2", say_hello,
[ua.VariantType.Boolean], [ua.VariantType.String])
hellower.add_method(freeopcua_namespace, "SayHelloArray",
say_hello_array, [ua.VariantType.Boolean],
[ua.VariantType.String])
def check_or_create_server(self):
if not hasattr(self, "test_server"):
self.test_server = Server()
self.__server_thread = Thread(target=self.__server_run,
name="Test OPC UA server",
args=(self.test_server, ))
self.assertTrue(self.test_server is not None)
def setUpClass(self):
# start our own server
self.srv_crypto = Server()
self.uri_crypto = 'opc.tcp://localhost:%d' % port_num1
self.srv_crypto.set_endpoint(self.uri_crypto)
# load server certificate and private key. This enables endpoints
# with signing and encryption.
self.srv_crypto.load_certificate("examples/certificate-example.der")
self.srv_crypto.load_private_key("examples/private-key-example.pem")
self.srv_crypto.start()
# start a server without crypto
self.srv_no_crypto = Server()
self.uri_no_crypto = 'opc.tcp://localhost:%d' % port_num2
self.srv_no_crypto.set_endpoint(self.uri_no_crypto)
self.srv_no_crypto.start()
def setUpClass(cls):
# start our own server
cls.srv_crypto = Server()
cls.uri_crypto = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num1)
cls.srv_crypto.set_endpoint(cls.uri_crypto)
# load server certificate and private key. This enables endpoints
# with signing and encryption.
cls.srv_crypto.load_certificate("examples/certificate-example.der")
cls.srv_crypto.load_private_key("examples/private-key-example.pem")
cls.srv_crypto.start()
# start a server without crypto
cls.srv_no_crypto = Server()
cls.uri_no_crypto = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num2)
cls.srv_no_crypto.set_endpoint(cls.uri_no_crypto)
cls.srv_no_crypto.start()
def start_server_and_client(cls):
cls.srv = Server()
cls.srv.set_endpoint('opc.tcp://127.0.0.1:{0:d}'.format(port_num1))
cls.srv.start()
cls.clt = Client('opc.tcp://127.0.0.1:{0:d}'.format(port_num1))
cls.clt.connect()
def setUp(self):
self.server = Server()
url = "opc.tcp://localhost:48400/freeopcua/server/"
self.server.set_endpoint(url)
self.server.start()
self.client = Window()
self.client.ui.addrComboBox.setCurrentText(url)
self.client.connect()
def __init__(self,
eflex_type=EFLEXAgentType.CONSUMER,
port=4840,
name="EFLEX Agent"):
self.eflex_type = eflex_type
self.name = name
self.port = port
self.server = Server()
self.configure_server(self.server)
def __init__(self):
self.server = Server()
# setup our server
self.server.set_endpoint(os.environ.get("SERVER_ENDPOINT"))
# setup our own namespace, not really necessary but should as spec
uri = os.environ.get("NAMESPACE")
self.idx = self.server.register_namespace(uri)
def generate_server():
"""
GERANDO SERVIDOR - NOME, URL E IP
"""
server = Server()
server.set_endpoint(URL)
addspace = server.register_namespace(SERVER_NAME)
return server, addspace
def server_opc():
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/vm_opc")
server.set_server_name("Servidor notificaciones vm")
# setup our own namespace, not really necessary but should as spec
uri = "notif VM"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# populating our address space
myobj = objects.add_object(idx, "notif_vm")
event_id = myobj.add_variable(idx, "ID evento", float(0))
# new_st.set_writable()
tss = myobj.add_variable(idx, "Timestamp", datetime.datetime.now())
# new_st.set_writable()
progresiva = myobj.add_variable(idx, "Progresiva", float(-1))
estado_alarma = myobj.add_variable(idx, "Estado alarma", 'inicio')
criticidad = myobj.add_variable(idx, "Criticidad", float(-1))
ack_bit = myobj.add_variable(idx, "ACK bit", False)
ack_bit.set_writable()
alarma_activa = myobj.add_variable(idx, "Alarma presente", False)
# starting!
tags = {
'id': event_id,
'tss': tss,
'prog': progresiva,
'st': estado_alarma,
'crit': criticidad,
'ack': ack_bit,
'active': alarma_activa
}
server.start()
try:
while True:
if np.random.uniform() >= 0.5:
tags['id'].set_value(float(np.random.randint(500)))
tags['tss'].set_value(datetime.datetime.now())
tags['st'].set_value(choice(['inicio', 'cambio', 'fin']))
else:
print 'Bit ACK: ', tags['ack'].get_value(
), datetime.datetime.now()
time.sleep(3)
finally:
#close connection, remove subcsriptions, etc
server.stop()
def setUpClass(self):
self.srv = Server()
self.srv_url = 'opc.tcp://localhost:%d' % port_num
self.srv.set_endpoint(self.srv_url)
objects = self.srv.get_objects_node()
obj = objects.add_object(4, "directory")
var = obj.add_variable(4, "variable", 1.999)
var2 = obj.add_variable(4, "variable2", 1.777)
var2.set_writable()
self.srv.start()
def __init__(self):
self.server = Server()
self.server.set_endpoint('opc.tcp://0.0.0.0:51210/UA/SampleServer')
self.server.set_server_name('Custom structure demo server')
# idx name will be used later for creating the xml used in data type dictionary
self._idx_name = 'http://examples.freeopcua.github.io'
self.idx = self.server.register_namespace(self._idx_name)
self.dict_builder = DataTypeDictionaryBuilder(self.server, self.idx, self._idx_name, 'MyDictionary')
def runTest(self):
tmpfile = NamedTemporaryFile()
path = tmpfile.name
tmpfile.close()
#create cache file
server = Server(cacheFile = path)
#modify cache content
id = ua.NodeId(ua.ObjectIds.Server_ServerStatus_SecondsTillShutdown)
s = shelve.open(path, "w", writeback = True)
s[id.to_string()].attributes[ua.AttributeIds.Value].value = ua.DataValue(123)
s.close()
#ensure that we are actually loading from the cache
server = Server(cacheFile = path)
self.assertEqual(server.get_node(id).get_value(), 123)
os.remove(path)
def setUpClass(cls):
cls.srv = Server()
cls.srv_url = 'opc.tcp://127.0.0.1:{0:d}'.format(port_num)
cls.srv.set_endpoint(cls.srv_url)
objects = cls.srv.get_objects_node()
obj = objects.add_object(4, "directory")
var = obj.add_variable(4, "variable", 1.999)
var2 = obj.add_variable(4, "variable2", 1.777)
var2.set_writable()
cls.srv.start()
