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)
class HelloServer:
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")
self.server.link_method(hellower_say_hello, say_hello_xml)
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 __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
class HelloServer:
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")
self.server.link_method(hellower_say_hello, say_hello_xml)
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 __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
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
class Servidor_OPCUA:
def __init__(self):
self.server = Server()
self.server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/")
self.server.set_server_name("Stack IIoT")
self.namespaces = {}
self.objects = self.server.get_objects_node()
# Para agregar un nuevo namespace
def new_namespace(self, uri, namespace, nombre):
idx = self.server.register_namespace(uri)
print('New namespace: {}'.format(idx))
Namespace = namespace(
self.objects, idx,
self.server) # Se declaran todas las variables del nuevo namespace
self.namespaces[nombre] = Namespace
def start(self):
global alarma, valor_alarma, mensaje_alarma
self.server.start()
for nombre, namespace in self.namespaces.items():
namespace.subscripciones()
# Se incia el loop del servidor
try:
while True:
time.sleep(0.1)
for nombre, namespace in self.namespaces.items():
namespace.monitorea_alarma()
finally:
self.server.stop()
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 __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 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()
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 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 start():
mServer = Server()
mServer.set_endpoint(URL)
mServer.set_security_policy([
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
ua.SecurityPolicyType.Basic256Sha256_Sign
])
address_space = mServer.register_namespace(NAMESPACE_NAME)
root_node = mServer.get_objects_node()
params = root_node.add_object(address_space, "Parameters")
start_time = params.add_variable(address_space, "start_time",
start_timestamp)
data = root_node.add_object(address_space, "data")
pump = data.add_object(address_space, "Pump")
temperature = 20 + random.randint(0, 10)
pump_temp_var = pump.add_variable(address_space, "temperature",
temperature)
pump_temp_vup = VarUpdater(
pump_temp_var) # just a dummy class update a variable
pump_temp_unit = pump.add_variable(address_space, "unit", "°C")
pump_status = pump.add_variable(address_space, "status", False)
pump_status.set_writable()
level = 12
pump_level = pump.add_variable(address_space, "level", level)
pump_level.set_writable()
sleep_period = 0.5
# Start the server
mServer.start()
print("Server started at {}".format(URL))
print("root_node: " + root_node.__str__())
print("params: " + params.__str__())
print("pump: " + pump.__str__())
# print(""+pump)
# enable following if you want to subscribe to nodes on server side
handler = SubHandler()
sub = mServer.create_subscription(500, handler)
handle = sub.subscribe_data_change(pump_level)
# IMPORTANT: This should be started after the mServer.start()
pump_temp_vup.start()
try:
while True:
time.sleep(sleep_period)
finally:
# close connection, remove subscriptions, etc
pump_temp_vup.stop() # should be stopped
mServer.stop()
class TestCmdLines(unittest.TestCase):
'''
Test command lines
'''
@classmethod
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 test_uals(self):
s = subprocess.check_output(
["python", "tools/uals", "--url", self.srv_url])
self.assertIn(b"i=85", s)
self.assertNotIn(b"i=89", s)
self.assertNotIn(b"1.999", s)
s = subprocess.check_output(
["python", "tools/uals", "--url", self.srv_url, "-d", "3"])
self.assertIn(b"1.999", s)
def test_uaread(self):
s = subprocess.check_output([
"python", "tools/uaread", "--url", self.srv_url, "--path",
"0:Objects,4:directory,4:variable"
])
self.assertIn(b"1.999", s)
def test_uawrite(self):
s = subprocess.check_output([
"python", "tools/uawrite", "--url", self.srv_url, "--path",
"0:Objects,4:directory,4:variable2", "1.789"
])
s = subprocess.check_output([
"python", "tools/uaread", "--url", self.srv_url, "--path",
"0:Objects,4:directory,4:variable2"
])
self.assertIn(b"1.789", s)
self.assertNotIn(b"1.999", s)
def test_uadiscover(self):
s = subprocess.check_output(
["python", "tools/uadiscover", "--url", self.srv_url])
self.assertIn(b"opc.tcp://localhost", s)
self.assertIn(b"FreeOpcUa", s)
self.assertIn(b"urn:freeopcua:python:server", s)
@classmethod
def tearDownClass(self):
self.srv.stop()
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 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
my_first_event_generator = server.get_event_generator()
my_first_event_generator.event.Severity = 300
# Creating a custom EVENT
eventType = server.create_custom_event_type(
address_space,
'ThresholdEvent',
ua.ObjectIds.BaseEventType,
[
('value', ua.VariantType.Float),
('alarmEnabled', ua.VariantType.Boolean),
]
)
my_custom_event_generator = server.get_event_generator(eventType, my_first_object)
# starting!
server.start()
print( "Server starting ...")
rndEv = RandomEventsGenerator(my_first_event_generator) # just a stupide class update a variable
rndEv.start()
while True:
time.sleep(1)
sensor_value = random.random()
threshold = 0.9
if sensor_value > threshold:
my_custom_event_generator.event.Message = ua.LocalizedText("Value is graeter than th")
my_custom_event_generator.event.value = ua.Variant(sensor_value, ua.VariantType.Float)
my_custom_event_generator.event.alarmenabled = ua.Variant( outputsEnabled , ua.VariantType.Boolean)
my_custom_event_generator.event.Severity = ua.Variant( 1 , ua.VariantType.Int32)
my_custom_event_generator.trigger()
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")
## Two different methods definitions
# First
method_1_node = my_first_object.add_method(address_space,
"method_1_description",
odd_or_even,
[ua.VariantType.Int32],
[ua.VariantType.Boolean])
# Second
inarg_1 = ua.Argument()
inarg_1.Name = "Argument_1"
inarg_1.DataType = ua.NodeId(ua.ObjectIds.Float32)
inarg_1.ValueRank = -1
inarg_1.ArrayDimensions = []
inarg_1.Description = ua.LocalizedText("Method argument 1 description")
inarg_2 = ua.Argument()
inarg_2.Name = "Argument_2"
inarg_2.DataType = ua.NodeId(ua.ObjectIds.Float32)
inarg_2.ValueRank = -1
inarg_2.ArrayDimensions = []
inarg_2.Description = ua.LocalizedText("Method argument 2 description")
outarg = ua.Argument()
outarg.Name = "Result"
outarg.DataType = ua.NodeId(ua.ObjectIds.Float32)
outarg.ValueRank = -1
outarg.ArrayDimensions = []
outarg.Description = ua.LocalizedText("Output argument description")
method_2_node = my_first_object.add_method(address_space,
"method_2_description",
multiply, [inarg_1, inarg_2],
[outarg])
# starting!
server.start()
print("Server starting ...")
while True:
time.sleep(1)
class OPCUAServer(object):
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 _scan(self):
while self.scan_enable:
# update all device data from devices' configured driver, such as modbus)
for device in self.devices:
device.update()
time.sleep(1)
def scan_on(self):
# Start the thread which handles the cyclic updates of devices
self.scan_thread = threading.Thread(target=self._scan)
# self.scan_thread.setDaemon(True)
self.scan_enable = True
self.scan_thread.start()
def scan_off(self):
# Stop the thread which handles cyclic updates
self.scan_enable = False
self.scan_thread.join()
class MyDeviceServer(object):
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")
@uamethod
def toggle_b(self, parent):
self.logger.info("Call Toggle B method")
self.my_variable_b.set_value(not self.my_variable_b.get_value())
@uamethod
def toggle_c(self, parent):
self.logger.info("Call Toggle C method")
self.my_variable_c.set_value(not self.my_variable_c.get_value())
@uamethod
def toggle_d(self, parent):
self.logger.info("Call Toggle D method")
self.my_variable_d.set_value(not self.my_variable_d.get_value())
def start(self):
self.server.start()
def stop(self):
self.server.stop()
def setVarA(self, intNumber):
self.my_variable_a.set_value(intNumber)
def setVarE(self, intNumber):
self.my_variable_e.set_value(intNumber)
def start(self):
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/thingsroot/server")
server.set_server_name("ThingsRoot Example OpcUA Server")
self.idx = server.register_namespace("http://opcua.thingsroot.com")
self.objects = server.get_objects_node()
self.server = server
self.devices = _dict({})
self.devices_sub_handle = _dict({})
self.device_types = _dict({})
# self.load_redis_db()
server.start()
def create_Server_Basics(name, port):
url = 'opc.tcp://0.0.0.0:' + port
gebName = 'MEMAP_' + name
server = Server()
server.set_endpoint(url)
server.set_server_name('MEMAP Mockup ' + name)
idx = server.register_namespace(gebName)
# Root node
objects = server.get_objects_node()
return (server, url, idx, objects)
class CTSServer:
'''
CTSClient class is the OpcUa client for the CTS OpcUa server.
It also contains various high level function allowing to turn on and off
leds, run scans, display the CTS status, load MC events in the CTS, etc...
Input:
- angle_cts : the configuration of the CTS (0., 120. or 240. degrees )
'''
def __init__(self, angle_cts):
'''
Initialise function for CTSClient
Input:
- angle_cts : the configuration of the CTS
(0., 120. or 240. degrees)
'''
self.server = Server()
self.cts = camtestsetup.CTS('config/cts_config_' +
str(int(angle_cts)) + '.cfg',
'config/camera_config.cfg',
angle=angle_cts,
connected=True)
com.initialise_can(self.cts)
# optional: setup logging
logging.basicConfig(level=logging.WARN)
self.logger = logging.getLogger("opcua.address_space")
self.logger.setLevel(logging.DEBUG)
self.server.set_endpoint(
"opc.tcp://0.0.0.0:4843/cameratestsetup/server/")
self.server.set_server_name("Camera Test Setup OpcUa Server")
# setup our own namespace
#uri = "http://isdc.unige.ch/"
#idx = self.server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
self.objects = self.server.get_objects_node()
## create the ua structure
create_opcua_structure(self.cts, self.objects)
# starting!
ready = True
self.server.start()
def run_OPCUA_server_start():
print("Starting OPC UA SERVER %s:%s" % (OPCUA_HOST, OPCUA_PORT))
# setup our server
server = Server()
server.set_endpoint("opc.tcp://%s:%s/freeopcua/server/" % (OPCUA_HOST, OPCUA_PORT))
# 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
imms = objects.add_object(idx, "IMMS")
imms_date = imms.add_variable(idx, "DATE", 0, varianttype=ua.VariantType.Double)
imms_date.set_writable()
imms_time = imms.add_variable(idx, "TIME", "", varianttype=ua.VariantType.String)
imms_time.set_writable()
imms_ActSimPara1 = imms.add_variable(idx, "ActSimPara1", 0, varianttype=ua.VariantType.Double)
imms_ActSimPara1.set_writable()
imms_ActSimPara2 = imms.add_variable(idx, "ActSimPara2", 0, varianttype=ua.VariantType.Double)
imms_ActSimPara2.set_writable()
imms_ActCntCyc = imms.add_variable(idx, "ActCntCyc", 0, varianttype=ua.VariantType.Double)
imms_ActCntCyc.set_writable()
imms_ActCntPrt = imms.add_variable(idx, "ActCntPrt", 0, varianttype=ua.VariantType.Double)
imms_ActCntPrt.set_writable()
imms_ActStsMach = imms.add_variable(idx, "ActStsMach", "", varianttype=ua.VariantType.String)
imms_ActStsMach.set_writable()
imms_ActTimCyc = imms.add_variable(idx, "ActTimCyc", 5, varianttype=ua.VariantType.Double)
imms_ActTimCyc.set_writable()
imms_SetCntMld = imms.add_variable(idx, "SetCntMld", 0, varianttype=ua.VariantType.Double)
imms_SetCntMld.set_writable()
imms_SetCntPrt = imms.add_variable(idx, "SetCntPrt", 0, varianttype=ua.VariantType.Double)
imms_SetCntPrt.set_writable()
imms_SetTimCyc = imms.add_variable(idx, "SetTimCyc", 0, varianttype=ua.VariantType.Double)
imms_SetTimCyc.set_writable()
# starting!
server.start()
def run_simulation_server(steps):
"""
This support function creates a simple OPC UA server with node listed in the config file
:param steps: Lifecycle of the server
:return:
"""
with open('../src_test/config_test.yaml') as config_file:
cfg = yaml.safe_load(config_file)
# setup the server
server = Server()
server.set_endpoint(cfg['opcua']['url'])
# setup the namespace
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# get objects node
objects = server.get_objects_node()
# server start
server.start()
log_event(cfg, 'OPCUA TEST SERVER', '', 'INFO', 'OPC UA server started')
# populating the address space
myobj = objects.add_object(idx, "TestDataAssembly")
nodes = []
metrics = cfg['metrics']
for metric in metrics:
metric_id = metric['metric_id']
meas = metric['measurement']
tag = metric['tagname']
var = metric['variable']
ns = metric['nodeNamespace']
id = metric['nodeId']
method = metric['method']
time_interval = metric['interval']
node_str = 'ns=' + str(ns) + '; i=' + str(id)
nodes.append(myobj.add_variable(node_str, var, -1))
# update variable
time.sleep(1)
for it in range(steps):
for node in nodes:
node.set_value(node.get_value() + 1)
time.sleep(0.5)
time.sleep(2)
server.stop()
log_event(cfg, 'OPCUA TEST SERVER', '', 'INFO', 'OPC UA server stopped')
def start_opc():
"""
The function initializes an OPC server and creates required tags for WinCC.
Args:
(nil)
Returns:
tags: A list of OPC tags to be sent to WinCC.
server: The initialised server itself is returned. Will be later used
to stop the server.
"""
# creates a 'local' server at port '8020'
server = Server()
server.set_endpoint("opc.tcp://127.0.0.1:8020/")
uri = "gesture_control"
idx = server.register_namespace(uri)
objects = server.get_objects_node()
obj = objects.add_object(idx, "GestureTest")
# fan-1 tags
a_sel = obj.add_variable(idx, "f1_sel", False)
a_cmd = obj.add_variable(idx, "f1_cmd", False)
a_sel.set_writable()
a_cmd.set_writable()
# fan-2 tags
b_sel = obj.add_variable(idx, "f2_sel", False)
b_cmd = obj.add_variable(idx, "f2_cmd", False)
b_sel.set_writable()
b_cmd.set_writable()
# fan-3 tags
c_sel = obj.add_variable(idx, "f3_sel", False)
c_cmd = obj.add_variable(idx, "f3_cmd", False)
c_sel.set_writable()
c_cmd.set_writable()
tags = [a_sel, a_cmd, b_sel, b_cmd, c_sel, c_cmd]
# start server
server.start()
return tags, server
def main():
FORMAT = '%(asctime)-15s - %(message)s'
logging.basicConfig(filename='opcua.log',
level=logging.DEBUG,
format=FORMAT)
# logging.basicConfig(level=logging.DEBUG, format=FORMAT)
# log = LoggerUtility.get_logger("dht11.log")
# log.info("**************************** START ****************************")
# 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
uri = "http://paolopasqua.site"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
d = sOPCUA_DHT(sOPCUA_DHT.DHT11, "test", "D24")
d.register_to_server(idx, objects)
#26 19 13 6
r1 = sOPCUA_Relay(26, "1")
r1.register_to_server(idx, objects)
r2 = sOPCUA_Relay(19, "2")
r2.register_to_server(idx, objects)
r3 = sOPCUA_Relay(13, "3")
r3.register_to_server(idx, objects)
r4 = sOPCUA_Relay(6, "4")
r4.register_to_server(idx, objects)
shutdown = False
try:
server.start()
while not shutdown:
pass
finally:
#close connection, remove subcsriptions, etc
server.stop()
def create_Server_Basics(objectName, ems, port):
url = 'opc.tcp://0.0.0.0:' + port
gebName = objectName + ems
server = Server()
server.set_endpoint(url)
server.set_server_name(objectName + '_OPCUA_Server_' + ems)
idx = server.register_namespace(gebName)
'''
server.set_security_policy([
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt,
ua.SecurityPolicyType.Basic256Sha256_Sign])
'''
# Root node
objects = server.get_objects_node()
return (server, url, idx, objects)
def main():
# create Server object
server = Server()
# define ip address for the server. format: 'opc.tcp://[ip_address]'
url = 'opc.tcp://0.0.0.0:4840/freeopcua/server/'
server.set_endpoint(url)
# define address space
name = 'OPCUA_SIMULATION_SERVER'
addspace = server.register_namespace(name)
# get root node
root_node = server.get_objects_node()
# define node where we wish to run parameters
# assign to address space and name it 'Parameters'
obj = root_node.add_object(addspace, 'Parameters')
# We will use three parameters: temperature, pressure, time
temp_param = obj.add_variable(addspace, 'Temperature', 0)
pres_param = obj.add_variable(addspace, 'Pressure', 0)
time_param = obj.add_variable(addspace, 'Time', 0)
# make variables writable
temp_param.set_writable()
pres_param.set_writable()
time_param.set_writable()
server.start()
print(f'server started at {url}')
try:
count = 0
while True:
time.sleep(1)
count += 0.1
temp_param.set_value(random.random())
pres_param.set_value(random.randint(1, 100))
time_param.set_value(count)
finally:
# close connection, remove subcsriptions, etc
server.stop()
class TestCmdLines(unittest.TestCase):
'''
Test command lines
'''
@classmethod
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 test_uals(self):
s = subprocess.check_output(["python", "tools/uals", "--url", self.srv_url])
self.assertIn(b"i=85", s)
self.assertNotIn(b"i=89", s)
self.assertNotIn(b"1.999", s)
s = subprocess.check_output(["python", "tools/uals", "--url", self.srv_url, "-d", "3"])
self.assertIn(b"1.999", s)
def test_uaread(self):
s = subprocess.check_output(["python", "tools/uaread", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable"])
self.assertIn(b"1.999", s)
def test_uawrite(self):
s = subprocess.check_output(["python", "tools/uawrite", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable2", "1.789"])
s = subprocess.check_output(["python", "tools/uaread", "--url", self.srv_url, "--path", "0:Objects,4:directory,4:variable2"])
self.assertIn(b"1.789", s)
self.assertNotIn(b"1.999", s)
def test_uadiscover(self):
s = subprocess.check_output(["python", "tools/uadiscover", "--url", self.srv_url])
self.assertIn(b"opc.tcp://localhost", s)
self.assertIn(b"FreeOpcUa", s)
self.assertIn(b"urn:freeopcua:python:server", s)
@classmethod
def tearDownClass(self):
self.srv.stop()
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")
# create the fist variable
my_first_variable = my_first_object.add_variable( address_space, "MyFirstVariable", 0.0 )
# create a hardtyped variable
my_hardtyped_variable = my_first_object.add_variable(address_space, "MyHardtypedVariable", 0, ua.VariantType.Float)
# allow the clients to update variable value
my_first_variable.set_writable()
# starting!
server.start()
print( "Server starting ...")
# count the cycles
count = 0
while True:
count = count + 1
time.sleep(1)
# use the counter as a dummy value
value = count
# assign the value to the varibles
my_first_variable.set_value( value )
my_hardtyped_variable.set_value( value )
def mymain():
# 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
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")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
# starting!
server.start()
server.stop()
def mymain():
# 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
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")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
# starting!
server.start()
server.stop()
def start_opcua_server():
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/sirris/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.sirris.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, "AMIF_oven")
myvar = myobj.add_variable(idx, "oven_temperature", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
# q.put(myvar)
# starting!
server.start()
return myvar
class HelloServer:
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()
ESP8266=self.server.get_node("ns=0;i=20005")
print("ESP8266: ")
print(ESP8266)
#death_button=ESP8266.get_children()
watering_status=ESP8266.get_value()
print(watering_status)
switch_method=self.server.get_node("ns=0;i=20006")
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")
self.server.link_method(switch_method, switch_mtd)
# self.server.link_method(hellower_say_hello, say_hello_xml)
# 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 __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
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 a property
my_first_property = my_first_object.add_property(address_space,
"MyFirstProperty",
"Epever")
my_second_property = my_first_object.add_property(address_space,
"MySecondProperty",
"Tracer 2210A MPPT")
# starting!
server.start()
print("Server starting ...")
# count the cycles
count = 0
while True:
count = count + 1
time.sleep(1)
# use the counter as a dummy value
value = count
def setup_server():
'''
To avoid problems with opc toolbox from matlab use one of the following
to indicate the host ip:
- '192.168.0.183' change if needed
- 'pi.local' mdns name
DO NOT USE '0.0.0.0' or localhost!!!
'''
# setup our server
server = Server()
server.set_endpoint("opc.tcp://pi.local:4840/opcua")
# 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, "MyCar")
myvar = myobj.add_variable(idx, "RPM", 0)
myvar.set_writable() # Set MyVariable to be writable by clients
return server, myvar
from opcua import ua, Server
from opcua.server.history_sql import HistorySQLite
if __name__ == "__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
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()
# populating our address space
myobj = objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", ua.Variant(0, ua.VariantType.Double))
myvar.set_writable() # Set MyVariable to be writable by clients
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = server.create_custom_event_type(2, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
# create second event
etype2 = server.create_custom_event_type(2, 'MySecondEvent', ua.ObjectIds.BaseEventType,
[('MyOtherProperty', ua.VariantType.Float)])
class OPCServer(object):
def __init__(self, settings):
super(OPCServer, self).__init__()
server_settings = settings.get("server")
objects = settings.get("objects")
self._endpoint = server_settings["endpoint"]
self._name = server_settings["name"]
self._namespace = server_settings["namespace"]
self._init_server()
for o in objects:
self._add_object(o["name"])
for variable, value in o["ro_variables"].items():
self._add_variable(o["name"], variable, value)
for variable, value in o["rw_variables"].items():
self._add_variable(o["name"], variable, value, True)
def start(self):
if self._server:
self._server.start()
def _init_server(self):
self._server = Server()
self._server.set_endpoint(self._endpoint)
self._server.set_server_name(self._name)
self._index = self._server.register_namespace(self._namespace)
_log.info("Index: %r" % (self._index,))
self._objects_node = self._server.get_objects_node()
_log.info("Node: %r" % (self._objects_node))
self._objects = {}
_log.info("Endpoints: %r" % (self._server.get_endpoints()))
def stop(self):
self._server.stop()
def _add_object(self, object_name):
self._objects[object_name] = { 'object': self._objects_node.add_object(self._index, object_name), 'variables' : {}}
def _add_variable(self, object_name, variable_name, value, writable=False):
obj = self._objects.get(object_name, None)
if obj.get('object', None):
var = self._objects_node.add_variable(self._index, variable_name, str(value))
obj['variables'][variable_name] = var
if writable:
var.set_writable()
return True
return False
def _get_variable(self, object_name, variable_name):
obj = self._objects.get(object_name)
if obj.get('object', None):
var = obj['variables'].get(variable_name, None)
return var
return None
def set_value(self, object_name, variable_name, value):
var = self._get_variable(object_name, variable_name)
if var:
var.set_value(str(value))
return True
return False
def get_value(self, object_name, variable_name):
var = self._get_variable(object_name, variable_name)
if var:
return var.get_value()
return None
def uaserver():
parser = argparse.ArgumentParser(description="Run an example OPC-UA server. By importing xml definition and using uawrite command line, it is even possible to expose real data using this server")
# we setup a server, this is a bit different from other tool so we do not reuse common arguments
parser.add_argument("-u",
"--url",
help="URL of OPC UA server, default is opc.tcp://0.0.0.0:4840",
default='opc.tcp://0.0.0.0:4840',
metavar="URL")
parser.add_argument("-v",
"--verbose",
dest="loglevel",
choices=['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'],
default='WARNING',
help="Set log level")
parser.add_argument("-x",
"--xml",
metavar="XML_FILE",
help="Populate address space with nodes defined in XML")
parser.add_argument("-p",
"--populate",
action="store_true",
help="Populate address space with some sample nodes")
parser.add_argument("-c",
"--disable-clock",
action="store_true",
help="Disable clock, to avoid seeing many write if debugging an application")
parser.add_argument("-s",
"--shell",
action="store_true",
help="Start python shell instead of randomly changing node values")
parser.add_argument("--certificate",
help="set server certificate")
parser.add_argument("--private_key",
help="set server private key")
args = parser.parse_args()
logging.basicConfig(format="%(levelname)s: %(message)s", level=getattr(logging, args.loglevel))
server = Server()
server.set_endpoint(args.url)
if args.certificate:
server.load_certificate(args.certificate)
if args.private_key:
server.load_private_key(args.private_key)
server.disable_clock(args.disable_clock)
server.set_server_name("FreeOpcUa Example Server")
if args.xml:
server.import_xml(args.xml)
if args.populate:
@uamethod
def multiply(parent, x, y):
print("multiply method call with parameters: ", x, y)
return x * y
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
objects = server.get_objects_node()
myobj = objects.add_object(idx, "MyObject")
mywritablevar = myobj.add_variable(idx, "MyWritableVariable", 6.7)
mywritablevar.set_writable() # Set MyVariable to be writable by clients
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myarrayvar = myobj.add_variable(idx, "MyVarArray", [6.7, 7.9])
myprop = myobj.add_property(idx, "MyProperty", "I am a property")
mymethod = myobj.add_method(idx, "MyMethod", multiply, [ua.VariantType.Double, ua.VariantType.Int64], [ua.VariantType.Double])
server.start()
try:
if args.shell:
embed()
elif args.populate:
count = 0
while True:
time.sleep(1)
myvar.set_value(math.sin(count / 10))
myarrayvar.set_value([math.sin(count / 10), math.sin(count / 100)])
count += 1
else:
while True:
time.sleep(1)
finally:
server.stop()
sys.exit(0)
def run(nodejson, endpoint, namespace, description):
# now setup our server
server = Server()
#server.set_endpoint("opc.tcp://localhost:4840/freeopcua/server/")
server.set_endpoint(endpoint)
server.set_server_name(description)
# setup our own namespace
uri = namespace
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
variables = {}
nodeId = 5
def add_variable(f, vals, nodeId):
for x in vals:
k = x if isinstance(x, str) or isinstance(x, unicode) else x.keys()[0]
#v = f.add_variable("ns=6;i=600%d" % nodeId, k, ua.Variant([], ua.VariantType.Float))
v = f.add_variable("ns=6;i=600%d" % nodeId, x, ua.Variant([], ua.VariantType.Float))
# nodeid, browsename, value, [variant type]
#v = f.add_variable("ns=6;s=%s" % x, x, ua.Variant([], ua.VariantType.Float))
v.set_writable()
variables[k] = v
nodeId = nodeId+1
return nodeId
def add_folder(p, pid, val, nodeId):
for n, v in val.items():
mf = p.add_folder("ns=%d;i=%d00%d" % (pid, pid, nodeId), n)
#mf = p.add_folder("ns=%d;s=%s" % (pid, n), n)
if isinstance(v, list) or isinstance(v, tuple):
nodeId = add_variable(mf, v, nodeId+1)
else:
nodeId = add_folder(mf, pid+1, v, nodeId+1)
return nodeId
# populating our address space
add_folder(objects, 5, nodejson, nodeId)
'''
myobj = objects.add_object(idx, "MyObject")
myvar = myobj.add_variable(idx, "MyVariable", 6.7)
myvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
myarrayvar = myobj.add_variable(idx, "myStronglytTypedVariable", ua.Variant([], ua.VariantType.UInt32))
myprop = myobj.add_property(idx, "myproperty", "I am a property")
mymethod = myobj.add_method(idx, "mymethod", func, [ua.VariantType.Int64], [ua.VariantType.Boolean])
inargx = ua.Argument()
inargx.Name = "x"
inargx.DataType = ua.NodeId(ua.ObjectIds.Int64)
inargx.ValueRank = -1
inargx.ArrayDimensions = []
inargx.Description = ua.LocalizedText("First number x")
inargy = ua.Argument()
inargy.Name = "y"
inargy.DataType = ua.NodeId(ua.ObjectIds.Int64)
inargy.ValueRank = -1
inargy.ArrayDimensions = []
inargy.Description = ua.LocalizedText("Second number y")
outarg = ua.Argument()
outarg.Name = "Result"
outarg.DataType = ua.NodeId(ua.ObjectIds.Int64)
outarg.ValueRank = -1
outarg.ArrayDimensions = []
outarg.Description = ua.LocalizedText("Multiplication result")
multiply_node = myobj.add_method(idx, "multiply", multiply, [inargx, inargy], [outarg])
'''
# starting!
server.start()
#print("Available loggers are: ", logging.Logger.manager.loggerDict.keys())
return server, variables
