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 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 Server import time import numpy as np #import requests, json import random #from numpy import genfromtxt # ============================== Building 1 ============================== Geb = "Building1_" server1 = Server() url1 = "opc.tcp://0.0.0.0:4880" server1.set_endpoint(url1) server1.set_server_name("MEMAP fortiss Server 1") name = "MEMAP_Building1" idx = server1.register_namespace(name) # Root node objects = server1.get_objects_node() # ================= Defining the Namespace Building 1 ===================== #General = objects.add_object(idx, "General") #Classification = General.add_folder(idx, "Classification") BuildingClass = General.add_variable(idx, "BuildingClass", 0) ### Demand Demand = objects.add_object(idx, "Demand") Heat = Demand.add_folder(idx, "Heat") #
# logger.setLevel(logging.DEBUG) #logger = logging.getLogger("opcua.binary_server_asyncio") # logger.setLevel(logging.DEBUG) #logger = logging.getLogger("opcua.uaprocessor") # logger.setLevel(logging.DEBUG) # now setup our server server = Server() #server.disable_clock() #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") # setup our own namespace uri = "http://examples.freeopcua.github.io" idx = server.register_namespace(uri) # create a new node type we can instantiate in our address space dev = server.nodes.base_object_type.add_object_type(0, "MyDevice") dev.add_variable(0, "sensor1", 1.0) dev.add_property(0, "device_id", "0340") ctrl = dev.add_object(0, "controller") ctrl.add_property(0, "state", "Idle") # populating our address space # First a folder to organise our nodes myfolder = server.nodes.objects.add_folder(idx, "myEmptyFolder") # instanciate one instance of our device mydevice = server.nodes.objects.add_object(idx, "Device0001", dev) mydevice_var = mydevice.get_child(["0:controller", "0:state"]) # get proxy to our device state variable
class OpcUaConnectorGeneralTest(ConnectorTestBase): def test_number_one(self): self._create_connector("connection_test.json") self.assertTrue(self.connector is not None) self.check_or_create_server() self.connector.open() 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 __server_run(self, test_server): self.test_server = test_server class SubHandler(object): def datachange_notification(self, node, val, data): print("Python: New data change event", node, val) def event_notification(self, event): print("Python: New event", event) @uamethod def multiply(parent, x, y): return x * y self.test_server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") self.test_server.set_server_name("Test Server") self.test_server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, ua.SecurityPolicyType.Basic256Sha256_Sign]) uri = "http://127.0.0.1" idx = self.test_server.register_namespace(uri) device = self.test_server.nodes.objects.add_object(idx, "Device1") name = self.test_server.nodes.objects.add_variable(idx, "serialNumber", "TEST") name.set_writable() temperature_and_humidity = device.add_object(idx, "TemperatureAndHumiditySensor") temperature = temperature_and_humidity.add_variable(idx, "Temperature", 56.7) humidity = temperature_and_humidity.add_variable(idx, "Humidity", 68.7) battery = device.add_object(idx, "Battery") battery_level = battery.add_variable(idx, "batteryLevel", 24) device.add_method(idx, "multiply", multiply, [ua.VariantType.Int64, ua.VariantType.Int64], [ua.VariantType.Int64]) self.test_server.start() try: while self.server_running: sleep(.1) finally: self.test_server.stop() def stop_test_server(self): self.server_running = False def tearDown(self): super().tearDown() self.stop_test_server()
class MyGroveOpcTerminalApp: def __init__(self): self.warehouse_state = False self.door_outside_state = False self.door_inside_state = False self.warehouse_button = GroveLedButton(5) self.door_outside_button = GroveLedButton(18) self.door_inside_button = GroveLedButton(16) self.warehouse_button.on_press = self.on_press_main self.door_outside_button.on_press = self.on_press_door_outside self.door_inside_button.on_press = self.on_press_door_inside self.warehouse_relay = GroveRelay(22) self.door_outside_relay = GroveRelay(26) self.door_inside_relay = GroveRelay(24) self.time_stamp = datetime.now() self.temperature_doors = Factory.getTemper("MCP9808-I2C", 0x18) self.temperature_doors.resolution(Temper.RES_1_16_CELSIUS) self.temperature_warehouse = Factory.getTemper("MCP9808-I2C", 0x19) self.temperature_warehouse.resolution(Temper.RES_1_16_CELSIUS) print('starting OPC server ') self.opc_server = Server(shelffile="/home/pi/grove-opc-server") # shelffile is trick with freeopcua to speedup loading of xml object base self.opc_url = "opc.tcp://0.0.0.0:4840" self.opc_server.set_endpoint(self.opc_url) print('starting OPC server ..') self.opc_name = "Grove-opcua-server" self.addspace = self.opc_server.register_namespace(self.opc_name) print('starting OPC server ...') self.opc_node = self.opc_server.get_objects_node() self.param = self.opc_node.add_object(self.addspace, "Parameters") self.opc_time = self.param.add_variable(self.addspace, "Time", 0) self.opc_trigger = self.param.add_variable(self.addspace, "Trigger", 0) self.opc_warehouse_state = self.param.add_variable( self.addspace, "Warehouse state", 0) self.opc_door_outside = self.param.add_variable( self.addspace, "Outside door", 0) self.opc_door_inside = self.param.add_variable(self.addspace, "Inside door", 0) self.opc_temperature_d = self.param.add_variable( self.addspace, "Temperature doorlock", 0.0) self.opc_temperature_w = self.param.add_variable( self.addspace, "Temperature warehouse", 0.0) self.opc_time.set_read_only() self.opc_trigger.set_read_only() self.opc_warehouse_state.set_read_only() self.opc_door_outside.set_read_only() self.opc_door_inside.set_read_only() self.opc_temperature_d.set_read_only() self.opc_temperature_w.set_read_only() print('starting OPC server .....') self.opc_server.start() print("OPC UA Server started at {}".format(self.opc_url)) print("time Doors Warehouse (Celsius)") def closeapp(self): self.warehouse_relay.off() self.door_outside_relay.off() self.door_inside_relay.off() self.warehouse_button.led_off() self.door_outside_button.led_off() self.door_inside_button.led_off() self.opc_server.stop() print("exit") # self.master.destroy() exit(1) def update_opc(self, trigger): self.time_stamp = datetime.now() self.opc_time.set_value(self.time_stamp) self.opc_temperature_d.set_value(self.temperature_doors.temperature) self.opc_temperature_w.set_value( self.temperature_warehouse.temperature) print('{} {:.1f} {:.1f}'.format( self.time_stamp.strftime("%X"), self.temperature_doors.temperature, self.temperature_warehouse.temperature)) self.opc_trigger.set_value(trigger) self.opc_warehouse_state.set_value(self.warehouse_state) self.opc_door_outside.set_value(self.door_outside_state) self.opc_door_inside.set_value(self.door_inside_state) def on_press_main(self): if self.warehouse_state: self.warehouse_state = False self.door_outside_state = False self.door_inside_state = False self.warehouse_relay.off() self.door_outside_relay.off() self.door_inside_relay.off() self.warehouse_button.led_off() self.door_outside_button.led_off() self.door_inside_button.led_off() else: self.warehouse_state = True self.warehouse_relay.on() self.warehouse_button.led_on() self.update_opc(1) def on_press_door_outside(self): if self.warehouse_state: if self.door_outside_state: self.door_outside_state = False self.door_outside_relay.off() self.door_outside_button.led_off() else: if not self.door_inside_state: self.door_outside_state = True self.door_outside_relay.on() self.door_outside_button.led_on() self.update_opc(2) def on_press_door_inside(self): if self.warehouse_state: if self.door_inside_state: self.door_inside_state = False self.door_inside_relay.off() self.door_inside_button.led_off() else: if not self.door_outside_state: self.door_inside_state = True self.door_inside_relay.on() self.door_inside_button.led_on() self.update_opc(3) # start functie is voor terminal-mode, niet voor windows mode def start(self): """Start event system and own cyclic loop.""" while True: try: # dirty temp (client changes every 5 sec opc_warehouse_state) if self.opc_warehouse_state.get_value(): self.warehouse_button.led_on() else: self.warehouse_button.led_off() time.sleep(5) self.update_opc(0) except KeyboardInterrupt: self.closeapp()
from opcua import ua, Server import asyncio, random, time from datetime import datetime server = Server() server.set_endpoint("opc.tcp://127.0.0.1:4840") server.set_server_name("OPCUA-Test") address_space = server.register_namespace("http://andreas-heine.net/UA") root_node = server.get_root_node() object_node = server.get_objects_node() server_node = server.get_server_node() parameter_obj = object_node.add_object(address_space, "Parameter") random_node = parameter_obj.add_variable(address_space, "random", ua.Variant(0, ua.VariantType.UInt64)) etype = server.create_custom_event_type( address_space, 'MyFirstEvent', ua.ObjectIds.BaseEventType, [('MyNumericProperty', ua.VariantType.Float), ('MyStringProperty', ua.VariantType.String)]) myevgen = server.get_event_generator(etype, parameter_obj) vars_obj = object_node.add_object(address_space, "Vars") var_list = [] for i in range(100): var = vars_obj.add_variable( ua.NodeId.from_string(f'ns={address_space};s=DB_DATA.Test.var{i}'), f'Test.var{i}', 0) var.set_writable(True) var_list.append(var)
def main(): print('Gionji Solar Plant') global relay_box relay_box = rb.RelayBox() relay_box.add_relay('cane', 0, 25) init() # setup our server server = Server() server.set_endpoint(OPC_ENDPOINT) # setup our own namespace, not really necessary but should as spec server_namespace = OPC_NAMESPACE 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() # populating our address space ChargeControllerObject = objects_node.add_object(address_space, "ChargeController") RelayBoxObject = objects_node.add_object(address_space, "RelayBox") opc_variables = dict() panelVoltage = ChargeControllerObject.add_variable(address_space, "panelVoltage", 0.0) panelCurrent = ChargeControllerObject.add_variable(address_space, "panelCurrent", 0.0) batteryVoltage = ChargeControllerObject.add_variable( address_space, "batteryVoltage", 0.0) batteryCurrent = ChargeControllerObject.add_variable( address_space, "batteryCurrent", 0.0) loadVoltage = ChargeControllerObject.add_variable(address_space, "loadVoltage", 0.0) loadCurrent = ChargeControllerObject.add_variable(address_space, "loadCurrent", 0.0) inPower = ChargeControllerObject.add_variable(address_space, "inPower", 0.0) outPower = ChargeControllerObject.add_variable(address_space, "outPower", 0.0) batteryStatus = ChargeControllerObject.add_variable( address_space, "batteryStatus", "") batteryCapacity = ChargeControllerObject.add_variable( address_space, "batteryCapacity", 0.0) batteryTemperature = ChargeControllerObject.add_variable( address_space, "batteryTemperature", 0.0) plug1Current = RelayBoxObject.add_variable(address_space, "plug_1_current", 0.0) plug2Current = RelayBoxObject.add_variable(address_space, "plug_2_current", 0.0) inverterCurrent = RelayBoxObject.add_variable(address_space, "inverter_current", 0.0) irradiation = ChargeControllerObject.add_variable(address_space, "irradiation", 0.0) inverter_control_node = RelayBoxObject.add_method( address_space, "set_plug_state", set_plug_state, [ua.VariantType.Int32, ua.VariantType.Boolean], [ ua.VariantType.Boolean, ua.VariantType.Boolean, ua.VariantType.Boolean, ua.VariantType.Boolean ]) # starting! server.start() print("Server starting ...") # creating my machinery objects chargeController = cc.EpeverChargeController(produce_dummy_data=DUMMY_DATA) while (True): print(relay_box.get_relays()) data = dict() ## Read data from hardware machines try: data = chargeController.readAllData() panelVoltage.set_value(data['panelVoltage']) panelCurrent.set_value(data['panelCurrent']) batteryVoltage.set_value(data['batteryVoltage']) batteryCurrent.set_value(data['batteryCurrent']) loadVoltage.set_value(data['loadVoltage']) loadCurrent.set_value(data['loadCurrent']) inPower.set_value(data['inPower']) outPower.set_value(data['outPower']) # batteryStatus.set_value(data['batteryStatus']) # batteryCapacity.set_value(data['batteryCapacity']) batteryTemperature.set_value(data['batteryTemperature']) except Exception as e: print(e) ## Read Irradiation data try: data['irradiation'] = sensors.getIrradiation() irradiation.set_value(data['irradiation']) except Exception as e: print(e) ## Read currents try: data['plug_1_current'] = currentMonitor.getCurrentPlug1() data['plug_2_current'] = currentMonitor.getCurrentPlug2() data['inverter_current'] = currentMonitor.getCurrentInverter() plug1Current.set_value(data['plug_1_current']) plug2Current.set_value(data['plug_2_current']) inverterCurrent.set_value(data['inverter_current']) except Exception as e: print(e) print(json.dumps(data)) #blinkLed(0.05, 2) time.sleep(DELAY)
led_r.off() led_g.off() led_b.off() server = Server() server.set_endpoint("opc.tcp://0.0.0.0:4840/pi-box") server.set_server_name("OPC-UA Pi Box") # 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 ]) idx = server.register_namespace("opcua-pi-box") # get Objects node, this is where we should put our nodes objects = server.get_objects_node() myobj = objects.add_object(idx, "OPCUA-PI-BOX") ledR = myobj.add_variable(idx, "Led_R", False, ua.VariantType.Boolean) ledR.set_writable() ledG = myobj.add_variable(idx, "Led_G", False, ua.VariantType.Boolean) ledG.set_writable() ledB = myobj.add_variable(idx, "Led_B", False, ua.VariantType.Boolean) ledB.set_writable() switch1 = myobj.add_variable(idx, "Switch_1", 0, ua.VariantType.UInt32) switch2 = myobj.add_variable(idx, "Switch_2", 0, ua.VariantType.UInt32)
def serverLoop(self): self.log.Info(self.opcInfoList) # setup our server server = Server() server.set_endpoint("opc.tcp://" + self.get_local_ip("eth0") + ":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) server.user_manager.set_user_manager(self.user_manager) server.set_security_IDs("Username") # get Objects node, this is where we should put our nodes objects = server.get_objects_node() # populating our address space obj_modbusDevInfoList = objects.add_object(idx, "obj_modbusDevInfoList") obj_opcInfoList = objects.add_object(idx, "obj_opcInfoList") obj_lzbusIpInfoList = objects.add_object(idx, "obj_lzbusIpInfoList") obj_snmpInfoList = objects.add_object(idx, "obj_snmpInfoList") obj_dev1 = objects.add_object(idx, "obj_173_12_10_138") obj_dev2 = objects.add_object(idx, "obj_173_12_10_139") v_modbusDevInfoList = obj_modbusDevInfoList.add_variable( idx, "v_modbusDevInfoList", "") v_opcInfoList = obj_opcInfoList.add_variable(idx, "v_opcInfoList", "") v_lzbusIpInfoList = obj_lzbusIpInfoList.add_variable( idx, "v_lzbusIpInfoList", "") v_snmpInfoList = obj_snmpInfoList.add_variable(idx, "v_snmpInfoList", "") d1_ip = obj_dev1.add_variable(idx, "ID", "173.12.10.138") d1_type = obj_dev1.add_variable(idx, "TYPE", "1") d1_powerstatus = obj_dev1.add_variable(idx, "POWERSTAUS", "on") d1_netstatus = obj_dev1.add_variable(idx, "NETSTATUS", "on") d1_cpu1_per = obj_dev1.add_variable(idx, "CPU1_PER", "70") d1_cpu2_per = obj_dev1.add_variable(idx, "CPU2_PER", "50") d1_cpu3_per = obj_dev1.add_variable(idx, "CPU3_PER", "30") d1_cpu4_per = obj_dev1.add_variable(idx, "CPU4_PER", "10") d1_mem_total = obj_dev1.add_variable(idx, "MEM_TOTAL", "82300000") d1_disk_total = obj_dev1.add_variable(idx, "DISK_TOTAL", "70") d2_type = obj_dev2.add_variable(idx, "TYPE", "1") d2_powerstatus = obj_dev2.add_variable(idx, "POWERSTAUS", "on") d2_netstatus = obj_dev2.add_variable(idx, "NETSTATUS", "on") d2_cpu1_per = obj_dev2.add_variable(idx, "CPU1_PER", "70") d2_cpu2_per = obj_dev2.add_variable(idx, "CPU2_PER", "50") d2_cpu3_per = obj_dev2.add_variable(idx, "CPU3_PER", "30") d2_cpu4_per = obj_dev2.add_variable(idx, "CPU4_PER", "10") d2_mem_total = obj_dev2.add_variable(idx, "MEM_TOTAL", "82300000") d2_disk_total = obj_dev2.add_variable(idx, "DISK_TOTAL", "70") # starting! server.start() while True: dateInfo = datetime.datetime.now().strftime('%Y-%m-%d %H-%M-%S') v_modbusDevInfoList.set_value(json.dumps(self.modbusDevInfoList)) v_opcInfoList.set_value(json.dumps(self.opcInfoList)) v_lzbusIpInfoList.set_value(json.dumps(self.lzbusIpInfoList)) v_snmpInfoList.set_value(json.dumps(self.snmpInfoList)) d1_ip.set_value("173.12.10.138") d1_type.set_value("1") d1_powerstatus.set_value("on") d1_netstatus.set_value("on") d1_cpu1_per.set_value("70") d1_cpu2_per.set_value("50") d1_cpu3_per.set_value("30") d1_cpu4_per.set_value("10") d1_mem_total.set_value("82300000") d1_disk_total.set_value("70") d2_type.set_value("1") d2_powerstatus.set_value("on") d2_netstatus.set_value("on") d2_cpu1_per.set_value("70") d2_cpu2_per.set_value("50") d2_cpu3_per.set_value("30") d2_cpu4_per.set_value("10") d2_mem_total.set_value("82300000") d2_disk_total.set_value("70") time.sleep(60)
class TestClass(object): """This class only exists for testing the mirror classes with less overhead than the whole server containing CANopen communication.""" 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 __enter__(self): return self def __exit__(self, exception_type, exception_value, traceback): self.server.stop() if isinstance(exception_value, KeyboardInterrupt): self.logger.warning('Received Ctrl+C event (KeyboardInterrupt).') return True def start(self): """Create one mirrored DCS Controller and start the OPC server""" self.mDC42 = self.objects.add_object(self.idx, 'DCSController42', self.dctni) # starting! self.server.start() sleep(1) # after the UA server is started initialize the mirrored object self.logger.notice('Initialize mirrored object ...') self.mDC42py = MyDCSController(self, self.mDC42, 42) sleep(10) # Wait until the class is initialized self.logger.success('... Done.') self.isinit = True self.run() def run(self): """Do nothing""" while (True): pass
class ROSServer: def __init__(self): self.namespace_ros = rospy.get_param("/rosopcua/namespace") self.topicsDict = {} self.servicesDict = {} self.actionsDict = {} rospy.init_node("rosopcua") self.server = Server() self.server.set_endpoint("opc.tcp://0.0.0.0:21554/") self.server.set_server_name("ROS ua Server") self.server.start() # setup our own namespaces, this is expected uri_topics = "http://ros.org/topics" # two different namespaces to make getting the correct node easier for get_node (otherwise had object for service and topic with same name uri_services = "http://ros.org/services" uri_actions = "http://ros.org/actions" idx_topics = self.server.register_namespace(uri_topics) idx_services = self.server.register_namespace(uri_services) idx_actions = self.server.register_namespace(uri_actions) # get Objects node, this is where we should put our custom stuff objects = self.server.get_objects_node() # one object per type we are watching topics_object = objects.add_object(idx_topics, "ROS-Topics") services_object = objects.add_object(idx_services, "ROS-Services") actions_object = objects.add_object(idx_actions, "ROS_Actions") while not rospy.is_shutdown(): # ros_topics starts a lot of publisher/subscribers, might slow everything down quite a bit. ros_services.refresh_services(self.namespace_ros, self, self.servicesDict, idx_services, services_object) ros_topics.refresh_topics_and_actions(self.namespace_ros, self, self.topicsDict, self.actionsDict, idx_topics, idx_actions, topics_object, actions_object) # Don't clog cpu time.sleep(60) self.server.stop() quit() def find_service_node_with_same_name(self, name, idx): rospy.logdebug("Reached ServiceCheck for name " + name) for service in self.servicesDict: rospy.logdebug( "Found name: " + str(self.servicesDict[service].parent.nodeid.Identifier)) if self.servicesDict[service].parent.nodeid.Identifier == name: rospy.logdebug("Found match for name: " + name) return self.servicesDict[service].parent return None def find_topics_node_with_same_name(self, name, idx): rospy.logdebug("Reached TopicCheck for name " + name) for topic in self.topicsDict: rospy.logdebug( "Found name: " + str(self.topicsDict[topic].parent.nodeid.Identifier)) if self.topicsDict[topic].parent.nodeid.Identifier == name: rospy.logdebug("Found match for name: " + name) return self.topicsDict[topic].parent return None def find_action_node_with_same_name(self, name, idx): rospy.logdebug("Reached ActionCheck for name " + name) for topic in self.actionsDict: rospy.logdebug( "Found name: " + str(self.actionsDict[topic].parent.nodeid.Identifier)) if self.actionsDict[topic].parent.nodeid.Identifier == name: rospy.logdebug("Found match for name: " + name) return self.actionsDict[topic].parent return None
def __init__(self, name, shared): super().__init__(name, shared) self.logger = logging.getLogger(self.name) self.logger.info("init") self.shared.config.set_hidden_value(self.name, "user") self.shared.config.set_hidden_value(self.name, "password") self.shared.config.set_hidden_value(self.name, "password_hash") def config(key, val): return self.shared.config.config(self.name, key, val) endpoint = config("endpoint", "no_endpoint") certificate = config("certificate", "") private_key = config("private_key", "") uri = config("uri", "http://examples.freeopcua.github.io") root_object_name = config("root_object_name", "TEST") separator = config("separator", ".") namespace = config("namespace", 2) self.oldnew = config("oldnew_comparision", 0) admin_username = config("user", "admin") admin_password = config("password", "admin") admin_password_hash = config("password_hash", "").replace("$$", "$") security_ids = [] anonymous_on = config("anonymous_on", 0) username_on = config("username_on", 1) certificate_on = config("certificate_basic256sha256_on", 0) if anonymous_on: security_ids.append("Anonymous") if username_on: security_ids.append("Username") if certificate_on: security_ids.append("Basic256Sha256") security_policy = [] if config("nosecurity_on", 1): security_policy.append(ua.SecurityPolicyType.NoSecurity) if config("basic128rsa15_sign_on", 0): security_policy.append(ua.SecurityPolicyType.Basic128Rsa15_Sign) if config("basic128rsa15_signandencrypt_on", 0): security_policy.append( ua.SecurityPolicyType.Basic128Rsa15_SignAndEncrypt) if config("basic256_sign_on", 0): security_policy.append(ua.SecurityPolicyType.Basic256_Sign) if config("basic256_signandencrypt_on", 0): security_policy.append( ua.SecurityPolicyType.Basic256_SignAndEncrypt) if config("basic256sha256_sign_on", 1): security_policy.append(ua.SecurityPolicyType.Basic256Sha256_Sign) if config("basic256sha256_signandencrypt_on", 1): security_policy.append( ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt) initial_values_is_quality_good = config( "initial_values_is_quality_good", 0) if anonymous_on: server = Server() else: server = Server(iserver=CustomInternalServer()) server.iserver.set_parent(server) server.set_endpoint(endpoint) server.allow_remote_admin(False) if certificate and private_key: server.load_certificate(str(certificate)) server.load_private_key(str(private_key)) if security_ids: server.set_security_IDs(security_ids) if security_policy: server.set_security_policy(security_policy) def custom_user_manager(isession, userName, password): if userName != admin_username: return False if admin_password_hash: if werkzeug.security.check_password_hash( admin_password_hash, password): return True else: # fallback to plaintext if password == admin_password: return True return False if username_on: server.user_manager.set_user_manager(custom_user_manager) idx = server.register_namespace(uri) objects = server.get_objects_node() root = objects.add_object(idx, root_object_name) self.server = server self.objects = objects self.root = root self.sep = separator self.ns = namespace self.items = [] if initial_values_is_quality_good: self.initial_status_code = ua.StatusCodes.Good else: self.initial_status_code = ua.StatusCodes.BadWaitingForInitialData
out_extobj.AxisSteps = in_extobj.AxisSteps axis_info.set_value(out_extobj) #write values to variable ret = (ua.Variant(out_extobj, ua.VariantType.ExtensionObject), ua.Variant("test", ua.VariantType.String)) return ret server = Server() server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/") server.set_security_policy([ua.SecurityPolicyType.NoSecurity]) obj = server.get_objects_node() idx = server.register_namespace("http://examples.freeopcua.github.io") server.load_type_definitions() inarg_extobj = ua.Argument() inarg_extobj.Name = "In" inarg_extobj.DataType = ua.NodeId(12079, 0) inarg_extobj.ValueRank = -1 inarg_extobj.ArrayDimensions = [] inarg_extobj.Description = ua.LocalizedText("Wanted AxisInformation") outarg_extobj = ua.Argument() outarg_extobj.Name = "Out" outarg_extobj.DataType = ua.NodeId(12079, 0) outarg_extobj.ValueRank = -1 outarg_extobj.ArrayDimensions = []
print("Failed to connect to the OPC Server") print(identifier) else: print("Conected to: ", elevator_opc_info['ep_url']) # Elevator_client.load_type_definitions() disp_c = Elevator_client.get_node("ns=2;i=3") aspd_c = Elevator_client.get_node("ns=2;i=4") lspd_c = Elevator_client.get_node("ns=2;i=5") up_c = Elevator_client.get_node("ns=2;i=7") nx_server = Server() nx_server.set_endpoint(nx_server_info['ep_url']) nx_server.set_server_name(nx_server_info['name']) nidx = nx_server.register_namespace(nx_server_info['uri']) objects = nx_server.get_objects_node() nx = objects.add_object(nidx, 'NX') disp_s = nx.add_variable(nidx, "Displacement", 0.0) disp_s.set_writable() avel_s = nx.add_variable(nidx, "Angular_Velocity", 0.0) avel_s.set_writable() lvel_s = nx.add_variable(nidx, "Linear_Velocity", 0.0) lvel_s.set_writable() up_s = nx.add_variable(nidx, "GoingUp", True) up_s.set_writable() # handler = UpdateNodes()
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
class CustomServer(object): def __init__(self): self.SERVER_ENDPOINT = os.environ.get("SERVER_ENDPOINT") self.NAMESPACE = os.environ.get("NAMESPACE") self.SERVER_NAME = os.environ.get("SERVER_NAME") self.ENABLE_CERTIFICATE = bool( strtobool(os.environ.get("ENABLE_CERTIFICATE"))) # setup our server self.server = Server() self.server.set_endpoint(self.SERVER_ENDPOINT) self.server.set_server_name(self.SERVER_NAME) # set the security endpoints for identification of clients if self.ENABLE_CERTIFICATE: # load server certificate and private key. This enables endpoints with signing and encryption. self.CERTIFICATE_PATH_SERVER_CERT = os.path.dirname( os.getcwd()) + os.environ.get("CERTIFICATE_PATH_SERVER_CERT") self.CERTIFICATE_PATH_SERVER_PRIVATE_KEY = os.path.dirname( os.getcwd()) + os.environ.get( "CERTIFICATE_PATH_SERVER_PRIVATE_KEY") self.server.load_certificate(self.CERTIFICATE_PATH_SERVER_CERT) self.server.load_private_key( self.CERTIFICATE_PATH_SERVER_PRIVATE_KEY) # set all possible endpoint policies for clients to connect through self.server.set_security_policy([ # ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, # ua.SecurityPolicyType.Basic256Sha256_Sign, ]) self.server.set_security_IDs(["Username", "Basic256Sha256"]) else: self.server.set_security_policy([ua.SecurityPolicyType.NoSecurity]) self.server.set_security_IDs(["Anonymous", "Username"]) # set the user_manager function self.server.user_manager.set_user_manager(user_manager) # setup our own namespace, not really necessary but should as spec uri = self.NAMESPACE self.idx = self.server.register_namespace(uri) # get important nodes self.root = self.server.get_root_node() self.obj = self.server.get_objects_node() self.init_methods() def init_methods(self): # method: ADD_OBJECTS_DIR inarg1 = ua.Argument() inarg1.Name = "objects folder" inarg1.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg1.ValueRank = -1 inarg1.ArrayDimensions = [] inarg1.Description = ua.LocalizedText("Name the new objects folder") method_node = self.obj.add_method(self.idx, "ADD_NEW_OBJECTS_FOLDER", self.add_objects_subfolder, [inarg1]) # method: ADD_OPC_TAG inarg1 = ua.Argument() inarg1.Name = "opctag" inarg1.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg1.ValueRank = -1 inarg1.ArrayDimensions = [] inarg1.Description = ua.LocalizedText("Name new OPC variable") inarg2 = ua.Argument() inarg2.Name = "variant_type" inarg2.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg2.ValueRank = -1 inarg2.ArrayDimensions = [] inarg2.Description = ua.LocalizedText("Type of variable") inarg3 = ua.Argument() inarg3.Name = "parent_node" inarg3.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg3.ValueRank = -1 inarg3.ArrayDimensions = [] inarg3.Description = ua.LocalizedText( "Type in the name of the parent node the new variable should assigned to" ) method_node = self.obj.add_method(self.idx, "ADD_OPC_TAG", self.register_opc_tag, [inarg1, inarg2, inarg3]) # method: SET_PV_LIMIT inarg1 = ua.Argument() inarg1.Name = "active_power_setpoint" inarg1.DataType = ua.NodeId(ua.ObjectIds.Int32) # Integer inarg1.ValueRank = -1 inarg1.ArrayDimensions = [] inarg1.Description = ua.LocalizedText( "Type in active power setpoint in percent [0 ... 100]") inarg2 = ua.Argument() inarg2.Name = "parent_node" inarg2.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg2.ValueRank = -1 inarg2.ArrayDimensions = [] inarg2.Description = ua.LocalizedText( "Type in the name of the parent node") method_node = self.obj.add_method(self.idx, "SET_PV_LIMIT", self.set_pv_active_power_setpoint, [inarg1, inarg2]) # method: RUN_ONLINE_GRID_PROTECTION inarg1 = ua.Argument() inarg1.Name = "On/Off" inarg1.DataType = ua.NodeId(ua.ObjectIds.Int32) # Integer inarg1.ValueRank = -1 inarg1.ArrayDimensions = [] inarg1.Description = ua.LocalizedText( "Type in 1 to RUN or 0 to STOP ONLINE_GRID_PROTECTION") inarg2 = ua.Argument() inarg2.Name = "parent_node" inarg2.DataType = ua.NodeId(ua.ObjectIds.String) # String inarg2.ValueRank = -1 inarg2.ArrayDimensions = [] inarg2.Description = ua.LocalizedText( "Type in the name of the parent node") method_node = self.obj.add_method(self.idx, "RUN_ONLINE_GRID_PROTECTION", self.run_online_grid_protection, [inarg1, inarg2]) @uamethod def add_objects_subfolder(self, parent, dir_name): # check if old dir with dir_name exists. if so then delete this dir first try: obj = self.root.get_child( ["0:Objects", ("{}:" + dir_name).format(self.idx)]) self.server.delete_nodes([obj], True) except BadNoMatch: print(DateHelper.get_local_datetime(), "There is no old folder with the name: " + dir_name) folder = self.obj.add_folder(self.idx, dir_name) print(DateHelper.get_local_datetime(), "Add subfolder: " + dir_name) @uamethod def register_opc_tag(self, parent, opctag, variant_type="Float", parent_node=""): # Object "parent_node": try: obj = self.root.get_child( ["0:Objects", ("{}:" + parent_node).format(self.idx)]) except BadNoMatch: print( DateHelper.get_local_datetime(), "register_opc_tag(): OPCUA_server_dir the variables should be assigned to, doesn't exists." ) raise var = ua.Variant(0, strings_to_vartyps(variant_type)) mvar = obj.add_variable(self.idx, opctag.strip(), var) mvar.set_writable() print( DateHelper.get_local_datetime(), "Add variable: " + opctag + " of type " + variant_type + " @node " + parent_node) @uamethod def set_pv_active_power_setpoint(self, parent, setpoint, parent_node=""): try: obj = self.root.get_child( ["0:Objects", ("{}:" + parent_node).format(self.idx)]) except BadNoMatch: print( DateHelper.get_local_datetime(), "set_pv_active_power_setpoint(): assign new value to node failed." ) raise for mvar in obj.get_variables(): if "PV" and "CTRL" in mvar.get_browse_name().Name: variant_type = mvar.get_data_value().Value.VariantType mvar.set_value(clamp(setpoint, 0, 100), variant_type) print( DateHelper.get_local_datetime(), "Set Value of node " + mvar.get_browse_name().Name + " to " + str(clamp(setpoint, 0, 100))) @uamethod def run_online_grid_protection(self, parent, setpoint, parent_node=""): try: obj = self.root.get_child( ["0:Objects", ("{}:" + parent_node).format(self.idx)]) except BadNoMatch: print(DateHelper.get_local_datetime(), "run_online_grid_protection(): Change in On/Off failed.") raise for mvar in obj.get_variables(): if "RUN_ONLINE_GRID_PROTECTION" in mvar.get_browse_name().Name: variant_type = mvar.get_data_value().Value.VariantType mvar.set_value(clamp(setpoint, 0, 1), variant_type) print( DateHelper.get_local_datetime(), "Change status of online grid protection to " + str(clamp(setpoint, 0, 1))) def start(self): self.server.start() print(DateHelper.get_local_datetime(), self.__class__.__name__, " successful started") def stop(self): self.server.stop() print(DateHelper.get_local_datetime(), self.__class__.__name__, " successful stopped")
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 main(): # logging.basicConfig(level=logging.ERROR) # logger=logging.getLogger("opcua.server.internal_subscription") # logger.setLevel(logging.ERROR) read = open('config.txt', 'r') configs = read.readlines() read.close() server = Server() endpoint = configs[0].split('@')[1].rstrip('\n') servername = configs[1].split('@')[1].rstrip('\n') kafkaservers = configs[2].split('@')[1].replace("'", "").replace( "\"", "").rstrip('\n') kafkaserver = kafkaservers[1:-1].split(',') kafkatopic = configs[3].split('@')[1].rstrip('\n') eventname = configs[4].split('@')[1].rstrip('\n') # auto_offset_reset='earlist' consumer = KafkaConsumer(kafkatopic, bootstrap_servers=kafkaserver) server.set_endpoint(endpoint) server.set_server_name(servername) print("Program running......") print("Please do not close this page") # 证书 # server.load_certificate("certificate-example.der") # server.load_private_key("private-key-example.pem") # 安全策略 server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, # ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt, # ua.SecurityPolicyType.Basic256Sha256_Sign ]) uri = "http://taiji.com.cn" idx = server.register_namespace(uri) objs = server.get_objects_node() myobj = objs.add_object(idx, "MyObject") # 节点 taglists = readFile("node.csv") for taglist in taglists: # myobj.add_variable(idx, taglist, 6.7).set_writable() myobj.add_variable(idx, taglist, random.random()).set_writable() # myobj.add_variable(idx, taglist, 6.7) attrs = readFile("ae_attr.csv") custom_etype = server.nodes.base_event_type.add_object_type(idx, eventname) for attr in attrs: custom_etype.add_property(2, attr, ua.Variant("", ua.VariantType.String)) myevent = server.get_event_generator(custom_etype, myobj) server.start() try: rootnode = server.get_root_node().get_child( ["0:Objects", "{}:MyObject".format(idx)]) rootnodes = rootnode.get_variables() nodeAll = {} for i in range(len(rootnodes)): nodeId = rootnodes[i] nodeName = rootnodes[i].get_browse_name().Name nodeAll.update({nodeName: nodeId}) for message in consumer: recv = message.value.decode("utf8") # print("recvevent=",recv) if recv[0] == '{' and recv[-1] == '}': nodeKafka = json.loads(recv) # print("nodeKafka=", nodeKafka) comName = nodeKafka.keys() & nodeAll.keys() for row in comName: rootnode.get_child(["2:{}".format(row) ]).set_value(nodeKafka[row]) else: recv = recv.replace('\n', '').replace('\r', '') datas = recv.split("|")[1:] # print("datas=", datas) if len(datas) == 9: for i in range(len(attrs)): # exec("myevent.event.{}='{}'".format(attrs[i], datas[i].replace('\n', '').replace('\r', ''))) exec("myevent.event.{}='{}'".format( attrs[i], datas[i])) myevent.trigger() else: # continue f = open('ErrorAE.bak', 'a', encoding='utf8') f.write(recv) f.write('\n') f.close # print("mysecondevgen=",mysecondevgen) # print("mysecondevgen=", myevent.event) except Exception as e: print(e) finally: server.stop()
class StationUAServer: def __init__(self, pick_by_light): self._pbl = pick_by_light self._setup_nodes() self._generate_tags() self.ua_server.start() self._generate_subscriptions() Thread(target=self._var_updater, daemon=True).start() def _setup_nodes(self): # Create server instance self.ua_server = Server('./opcua_cache') self.ua_server.set_endpoint('opc.tcp://0.0.0.0:4840/UA/PickByLight') self.ua_server.set_server_name("Pick By Light Server") # idx name will be used later for creating the xml used in data type dictionary # setup our own namespace, not really necessary but should as spec idx_name = 'http://examples.freeopcua.github.io' self.idx = self.ua_server.register_namespace(idx_name) # Set all possible endpoint policies for clients to connect through self.ua_server.set_security_policy([ ua.SecurityPolicyType.NoSecurity, ua.SecurityPolicyType.Basic128Rsa15_SignAndEncrypt, ua.SecurityPolicyType.Basic128Rsa15_Sign, ua.SecurityPolicyType.Basic256_SignAndEncrypt, ua.SecurityPolicyType.Basic256_Sign ]) # get Objects node, this is where we should put our custom stuff objects = self.ua_server.get_objects_node() # Create objects for the pack tags using the above created packMLBasedObjectType self.Status = objects.add_folder('ns=2;s=Status', "Status") self.Command = objects.add_folder('ns=2;s=Command', "Command") self.Command.add_method('ns=2;s=Command.SelectPort', "SelectPort", self._select_method, [ua.VariantType.Int32, ua.VariantType.String], [ua.VariantType.Boolean]) self.Command.add_method('ns=2;s=Command.DeselectPort', "DeselectPort", self._deselect_method, [ua.VariantType.Int32], [ua.VariantType.Boolean]) self.Command.add_method('ns=2;s=Command.DeselectAllPorts', "DeselectAllPorts", self._deselect_all_method, [], [ua.VariantType.Boolean]) root = self.ua_server.get_root_node() DummyFestoObj = root.add_object( "ns=2;s=|var|CECC-LK.Application.Flexstation_globalVariables", "DummyFesto") DummyFestoObj.add_variable( "ns=2;s=|var|CECC-LK.Application.Flexstation_globalVariables.FlexStationStatus", "FlexStationStatus", val=0).set_writable() DummyFestoObj.add_variable( "ns=2;s=|var|CECC-LK.Application.FBs.stpStopper1.stAppControl.uiOpNo", "uiOpNo", val=0).set_writable() DummyFestoObj.add_variable( "ns=2;s=ns=2;s=|var|CECC-LK.Application.AppModul.stRcvData.sOderDes", "sOderDes", val="").set_writable() def _generate_tags(self): # for all ports generate tags for port_number, port in self._pbl.get_ports(): # Make a folder with the port_number as the name b_obj = self.Status.add_object( 'ns=2;s=Status.Port_{}'.format(port_number), "Port_{}".format(port_number)) content = self._pbl.get_content(port_number) b_obj.add_variable( "ns=2;s=Status.Port_{}.Selected".format(port_number), "Selected", bool()) b_obj.add_variable( "ns=2;s=Status.Port_{}.WorkFinished".format(port_number), "WorkFinished", bool()) b_obj.add_variable( "ns=2;s=Status.Port_{}.Instructions".format(port_number), "Instructions", "") b_obj.add_variable( "ns=2;s=Status.Port_{}.Activity".format(port_number), "Activity", bool()) b_obj.add_variable( "ns=2;s=Status.Port_{}.ActivityTimestamp".format(port_number), "ActivityTimestamp", datetime.fromtimestamp(0)) b_obj.add_variable( "ns=2;s=Status.Port_{}.LightState".format(port_number), "LightState", 0) b_obj.add_variable( "ns=2;s=Status.Port_{}.ContentDisplayName".format(port_number), "ContentDisplayName", content['display_name']) b_obj.add_variable( "ns=2;s=Status.Port_{}.ContentName".format(port_number), "ContentName", content['name']) b_obj.add_variable( "ns=2;s=Status.Port_{}.ContentDescription".format(port_number), "ContentDescription", content['description']) b_obj.add_variable( "ns=2;s=Status.Port_{}.ContentImagePath".format(port_number), "ContentImagePath", content['image_path']) ''' create command tags for clients that does not support ua methods. ''' b_obj = self.Command.add_object( 'ns=2;s=Command.Port_{}'.format(port_number), "Port_{}".format(port_number)) b_obj.add_variable( "ns=2;s=Command.Port_{}.Select".format(port_number), "Select", bool()).set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.Deselect".format(port_number), "Deselect", bool()).set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.Instructions".format(port_number), "Instructions", "").set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.ContentDisplayName".format( port_number), "ContentDisplayName", content['display_name']).set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.ContentName".format(port_number), "ContentName", content['name']).set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.ContentDescription".format( port_number), "ContentDescription", content['description']).set_writable() b_obj.add_variable( "ns=2;s=Command.Port_{}.ContentImagePath".format(port_number), "ContentImagePath", content['image_path']).set_writable() ''' Generate some common commands ''' # Make a folder for the commons b_obj = self.Command.add_object('ns=2;s=Command.ByContent', 'ByContent') b_obj.add_variable("ns=2;s=Command.ByContent.Select", "Select", bool()).set_writable() b_obj.add_variable("ns=2;s=Command.ByContent.Deselect", "Deselect", bool()).set_writable() b_obj.add_variable("ns=2;s=Command.ByContent.Name", "Name", "").set_writable() b_obj.add_variable("ns=2;s=Command.ByContent.Instructions", "Instructions", "").set_writable() b_obj.add_variable("ns=2;s=Command.ByContent.Result", "Result", -1).set_writable() def _generate_subscriptions(self): # Create UA subscriber node for the box. Set self as handler. sub = self.ua_server.create_subscription(100, self) # Subscribe to the Select tag and all the content tags for port_number, port in self._pbl.get_ports(): ac = self.ua_server.get_node( "ns=2;s=Command.Port_{}.Select".format(port_number)) sub.subscribe_data_change(ac) ac = self.ua_server.get_node( "ns=2;s=Command.Port_{}.Deselect".format(port_number)) sub.subscribe_data_change(ac) b = self.ua_server.get_node( "ns=2;s=Command.Port_{}.ContentDisplayName".format( port_number)) sub.subscribe_data_change(b) c = self.ua_server.get_node( "ns=2;s=Command.Port_{}.ContentName".format(port_number)) sub.subscribe_data_change(c) d = self.ua_server.get_node( "ns=2;s=Command.Port_{}.ContentDescription".format( port_number)) sub.subscribe_data_change(d) e = self.ua_server.get_node( "ns=2;s=Command.Port_{}.ContentImagePath".format(port_number)) sub.subscribe_data_change(e) a = self.ua_server.get_node("ns=2;s=Command.ByContent.Select") sub.subscribe_data_change(a) a = self.ua_server.get_node("ns=2;s=Command.ByContent.Deselect") sub.subscribe_data_change(a) a = self.ua_server.get_node("ns=2;s=Command.ByContent.Name") sub.subscribe_data_change(a) a = self.ua_server.get_node( "ns=2;s=Command.ByContent.Instructions") sub.subscribe_data_change(a) def _event_notification(self, event): logger.warning( "Python: New event. No function implemented. {}".format(event)) def _select_method(self, parrent, port_number, instructions): r = self._pbl.select_port(port_number.Value, instructions=instructions.Value) return [ua.Variant(value=r, varianttype=ua.VariantType.Boolean)] def _deselect_method(self, parrent, port_number): r = self._pbl.deselect_port(port_number.Value) return [ua.Variant(value=r, varianttype=ua.VariantType.Boolean)] def _deselect_all_method(self, parrent): r = self._pbl.deselect_all() return [ua.Variant(value=r, varianttype=ua.VariantType.Boolean)] def datachange_notification(self, node, val, data): """UA server callback on data change notifications Arguments: node {Node} -- [description] val {[type]} -- [description] data {[type]} -- [description] """ logger.debug("New data change event. node:{}, value:{}".format( node, val)) # Sorry about these lines of code, but I don't see any nicer way of determining the port number than from # the identifier string. Then splitting it up to isolate the port number. # Example "Status.Port_2.Selected" is split into ['Status', 'Port_2', 'Selected'] then 'Port_2' is split into # ['Port', '2'] and then the '2' is turned into an intiger. path_list = str(node.nodeid.Identifier).split(".") # We can safely assume that the last term is the tag that updated. tag = path_list[-1] # Figure out the port number port_number = None if 'Port' in path_list[1]: port_number = int(path_list[1].split("_")[-1]) """ Switch for each possible tag""" # If the command tag "Select" changes go select that port with the instructions saved in the command tag. if tag == 'Select' and port_number: if val == True: node = self.ua_server.get_node( "ns=2;s=Command.Port_{}.Instructions".format(port_number)) instructions = node.get_value() self._pbl.select_port(port_number, instructions=instructions) # Reset the select flag node = self.ua_server.get_node( "ns=2;s=Command.Port_{}.Select".format(port_number)) node.set_value(False) elif tag == 'Deselect' and port_number: if val == True: self._pbl.deselect_port(port_number, work_finished=True) # Reset the select flag node = self.ua_server.get_node( "ns=2;s=Command.Port_{}.Deselect".format(port_number)) node.set_value(False) elif tag == 'ContentDisplayName' and port_number: self._pbl.set_content_key(port_number, 'display_name', str(val)) elif tag == 'ContentName' and port_number: self._pbl.set_content_key(port_number, 'name', str(val)) elif tag == 'ContentDescription' and port_number: self._pbl.set_content_key(port_number, 'description', str(val)) elif tag == 'ContentImagePath' and port_number: self._pbl.set_content_key(port_number, 'image_path', str(val)) elif tag == 'Select' and 'ByContent' in path_list[1]: if val == True: instructions = self.ua_server.get_node( "ns=2;s=Command.ByContent.Instructions").get_value() name = self.ua_server.get_node( "ns=2;s=Command.ByContent.Name").get_value() _, selected_port = self._pbl.select_content( name=name, instructions=instructions) # Reset the select flag node = self.ua_server.get_node( "ns=2;s=Command.ByContent.Select") node.set_value(False) node = self.ua_server.get_node( "ns=2;s=Command.ByContent.Result") node.set_value(selected_port) elif tag == 'Deselect' and 'ByContent' in path_list[1]: if val == True: name = self.ua_server.get_node( "ns=2;s=Command.ByContent.Name").get_value() self._pbl.deselect_content(name=name, work_finished=True) # Reset the select flag node = self.ua_server.get_node( "ns=2;s=Command.ByContent.Deselect") node.set_value(False) def _var_updater(self): while True: sleep(0.1) # for all boxes update tags for port_number, port in self._pbl.get_ports(): # get the object in the packml status object using our unique idx node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.Activity".format(port_number)) node.set_value(port.activity) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.ActivityTimestamp".format( port_number)) node.set_value(port.activity_timestamp) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.LightState".format(port_number)) node.set_value(port.get_light()) state = self._pbl.get_port_state(port_number) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.Selected".format(port_number)) node.set_value(state.selected) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.WorkFinished".format(port_number)) node.set_value(state.work_finished) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.Instructions".format(port_number)) node.set_value(state.select_instructions) content = self._pbl.get_content(port_number) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.ContentDisplayName".format( port_number)) node.set_value(content['display_name']) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.ContentName".format(port_number)) node.set_value(content['name']) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.ContentDescription".format( port_number)) node.set_value(content['description']) node = self.ua_server.get_node( "ns=2;s=Status.Port_{}.ContentImagePath".format( port_number)) node.set_value(content['image_path'])
class MyServer: ''' initialise opcua server object ''' def __init__(self): self.opc_server = UAServer() # OPC UA server instance self.opc_objects_dict = {} self.opc_variables_dict = {} # self.db_server=Server.query.get( server_id ) # self.initialise() self.instantiate_server_vars() def get_db(self, server_id): self.db_server = Server.query.get(server_id) self.instantiate_server_vars() ''' Instantiate all server related variables from the Sqlite DB server to the opcua server instance ''' def initialise(self): self.instantiate_server_vars() def instantiate_server_vars(self): self.opc_server_endpoint = "opc.tcp://" + self.db_server.server_endpoint_url self.opc_server_name = self.db_server.server_name self.opc_server_uri = self.db_server.server_namespace self.ns_idx = self.opc_server.register_namespace(self.opc_server_uri) self.opc_objects = self.opc_server.get_objects_node() self.opc_server.set_endpoint(self.opc_server_endpoint) self.load_server(self.db_server.server_objects) ''' load opc server with objects and variables from the SQlite DB ''' def load_server(self, db_objects, parent_obj=None): for server_obj in db_objects: if (server_obj.id not in self.opc_objects_dict): if parent_obj is None: self.opc_objects_dict[ server_obj.id] = self.opc_objects.add_object( self.ns_idx, server_obj.object_name) else: self.opc_objects_dict[ server_obj.id] = parent_obj.add_object( self.ns_idx, server_obj.object_name) self.load_object_variables( server_obj.object_variables, self.opc_objects_dict[server_obj.id]) if (server_obj.get_child_objects().count() > 0): self.load_server(server_obj.get_child_objects(), self.opc_objects_dict[server_obj.id]) def load_object_variables(self, variables, object_owner): for variable in variables: self.opc_variables_dict[ variable.variable_address] = object_owner.add_variable( self.ns_idx, variable.variable_name, convert_val(variable.variable_value, variable.variable_type)) if variable.variable_writable: self.opc_variables_dict[ variable.variable_address].set_writable() def start_opc_server(self): self.opc_server.start() def stop_opc_server(self): self.opc_server.stop() @classmethod def kill_all_servers(cls): for addr in addrs: pass
def run(self): # data handler will send complete data every time db = dbfn.db("../db.sqlite3") self.global_params = db.getParams() print("**** params:", self.params) print("**** global_params:", self.global_params) fields = [] for s_id in self.global_params["modbus_servers"].split(","): for s in db.getDataFormat(s_id, 0): field_name = self.global_params["field_name"].format(source=s[4], block=s[5], field=s[6] ) fields.append(field_name) db.close() 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() dat = dict() col_names = [] main_obj = objects.add_object(idx, self.global_params["site"]) ems_obj = main_obj.add_object(idx, "EMS") for s in fields: #print("Addding OPCUA Var:", s) col_names.append(s) v = ems_obj.add_variable(idx, s ,0) dat[s] = v # TODO solve this hardcoding dat['timestamp'] = ems_obj.add_variable(idx, 'timestamp' ,'') v = main_obj.add_variable(idx, "JSON" ,"") dat["JSON"] = v server.start() full_data = dict() while not self.exit.is_set(): time.sleep(1) if self.q_opcua.qsize() == 0: time.sleep(.1) continue data = self.q_opcua.get() logging.debug("OPCUA Received : %s",data) #print("OPCUA", len(data)) for c in data: if c in dat: dat[c].set_value(data[c]) else: print("Missing field in OPCUA", c) full_data[c] = data[c] #print("&&&&&&& full_data", full_data) dat["JSON"].set_value(json.dumps(full_data)) logging.info("opcuaServer %d Run loop", self.params["id"]) logging.warning("opcuaServer %d Exit loop", self.params["id"]) server.stop() return
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)
#!/usr/bin/env python3 from opcua import ua, Server if __name__ == "__main__": server = Server() server.set_endpoint("opc.tcp://0.0.0.0:4840/") ns = server.register_namespace("http://gopcua.com/") main = server.nodes.objects.add_object(ua.NodeId("main", ns), "main") roBool = main.add_variable(ua.NodeId("ro_bool", ns), "ro_bool", True, ua.VariantType.Boolean) rwBool = main.add_variable(ua.NodeId("rw_bool", ns), "rw_bool", True, ua.VariantType.Boolean) rwBool.set_writable() roInt32 = main.add_variable(ua.NodeId("ro_int32", ns), "ro_int32", 5, ua.VariantType.Int32) rwInt32 = main.add_variable(ua.NodeId("rw_int32", ns), "rw_int32", 5, ua.VariantType.Int32) rwInt32.set_writable() roArrayInt32 = main.add_variable(ua.NodeId("array_int32", ns), "array_int32", [1, 2, 3], ua.VariantType.Int32) ro2DArrayInt32 = main.add_variable(ua.NodeId("2d_array_int32", ns), "2d_array_int32", [[1], [2], [3]], ua.VariantType.Int32) server.start()
def current_value_logger(): # if LOG_VALUE_ENABLE == True: print(sh.__dict__) print(freq.__dict__) if __name__ == "__main__": """Add tags in opcua and start server""" server = Server() server.set_endpoint(URL) server.set_build_info(product_uri, manufacture_name, product_name, version, build_number, build_date) ns_sh = server.register_namespace("shearer") ns_fr = server.register_namespace("frequency") objects = server.get_objects_node() shearer = objects.add_object(ns_sh, "mb450") frequency = objects.add_object(ns_fr, "mfk400") shearer_data_status = shearer.add_variable(ns_sh, "data_status", 0) shearer_software_version = shearer.add_variable(ns_sh, "software_version", 0.0) shearer_motor_status_m1 = shearer.add_variable(ns_sh, "motor_sensor_status_m1", 0) shearer_motor_status_m2 = shearer.add_variable(ns_sh, "motor_sensor_status_m2", 0) shearer_motor_status_m3 = shearer.add_variable(ns_sh, "motor_sensor_status_m3", 0) shearer_motor_status_m4 = shearer.add_variable(ns_sh,
value = int("".join(str(x) for x in predict_ans)) / 10 value_list.append(value) print(f'cost time {time.time()-start}s') Temp.set_value(value_list) count -= 1 Count.set_value(count) print('set', count) else: time.sleep(0.05) count = Count.get_value() if __name__ == '__main__': if args.show_mode == False: server = Server() server.set_endpoint("opc.tcp://192.168.0.101:4840") #server.set_endpoint("opc.tcp://172.20.10.7:4840") obj = server.get_objects_node() uri = server.register_namespace("ML6A01") Thermo = obj.add_object(uri, "Thermometer") Temp = Thermo.add_variable(uri, "Temperature", ['']) Count = Thermo.add_variable(uri, "Count", count) Count.set_writable() server.start() main() if args.show_mode == False: server.stop() cap.release() cv2.destroyAllWindows()
from time import sleep from datetime import datetime import time import random from opcua import Server import numpy as np server = Server() server.set_endpoint("opc.tcp://127.0.0.1:12345") server.register_namespace("Room1") objects = server.get_objects_node() tempsens = objects.add_object('ns=2;s="TS"', "Temperature Sensor") temp1 = tempsens.add_variable('ns=2;s="TS1_Temperature"', "TS1 Temperature", 20) temp2 = tempsens.add_variable('ns=2;s="TS2_Temperature"', "TS2 Temperature", 20) temp3 = tempsens.add_variable('ns=2;s="TS3_Temperature"', "TS3 Temperature", 20) temp4 = tempsens.add_variable('ns=2;s="TS4_Temperature"', "TS4 Temperature", 20) temp5 = tempsens.add_variable('ns=2;s="TS5_Temperature"', "TS5 Temperature", 20) temp6 = tempsens.add_variable('ns=2;s="TS6_Temperature"', "TS6 Temperature", 20) temp7 = tempsens.add_variable('ns=2;s="TS7_Temperature"', "TS7 Temperature", 20) temp8 = tempsens.add_variable('ns=2;s="TS8_Temperature"', "TS8 Temperature", 20) temp9 = tempsens.add_variable('ns=2;s="TS9_Temperature"', "TS9 Temperature", 20) temp10 = tempsens.add_variable('ns=2;s="TS10_Temperature"', "TS10 Temperature",
#---SERVER INIT---# logger = logging.getLogger("opcua.address_space") logger.setLevel(logging.DEBUG) #---colorama init---# init(autoreset=True) #-------------------# server = Server() url = "opc.tcp://192.168.178.23:4840" server.set_endpoint(url) name = "OPCUA_MACHINE_SIMULATION_SERVER" addspace = server.register_namespace(name) #Addressraum # alle Node-Objekte kommen hier rein machine_node = server.get_objects_node() #-----------------# def getSensors(): print(Fore.GREEN + "\nAktuelle Sensoren: \n", "-Temperatur (°C) \n", "-Druck (bar) \n") #---MASCHINEN PARAMETER / SENSOREN---# # unseren Adressraum füllen Params = machine_node.add_object(addspace, "Parameters")
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)
from opcua import Server import random import time server = Server() # instantiate server class url = 'opc.tcp://127.0.0.1:51213' server.set_endpoint( url) # specify th port the server will use to communicate data # Add a namespace in the server. There are lready namespace in the server, each one with a specific id name_1 = 'room 1' namespace_1 = server.register_namespace( name_1 ) # create a namespace called 'room 1' and return the integer namespace id (in this case = 2) # The server is already populated with various nodes with server information, we need the one that stores objects (T.B.N. namespaces and # nodes are independent, e.g. we can store an object in a namespace and one of its variables in another namespace) objects_node = server.get_objects_node( ) # this is the root node, to which we can add all the nodes (objects we want) # Add temperature sensor object (node) temperature_sensor = objects_node.add_object( f'ns={str(namespace_1)}; s="temperature_sensor"', 'temperature sensor') # in this way we create the # object called 'temperature_sensor' in the namespace 1 (we have to specify the namspace this object belongs to and a string) temperature = temperature_sensor.add_variable( f'ns={str(namespace_1)}; s="temperature"', 'temperature', 0 ) # in this way we create a variable called 'Temperature' in the object (node) 'temperature_sensor' with a default value of 0 # Add light bulb object (node) light_bulb = objects_node.add_object(f'ns={str(namespace_1)}; s="light_bulb"', 'light bulb') light_bulb_state = light_bulb.add_variable( f'ns={str(namespace_1)}; s="light_bulb_state"', 'light bulb state', False) light_bulb_state.set_writable(
############ GET LOCAL MACHINE IP ############### s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM) s.connect(("8.8.8.8", 80)) id = s.getsockname()[0] s.close() ################################################# ########### SET SERVER INSTANCE ################# server = Server() url = "opc.tcp://" + id + ":4840" server.set_endpoint(url) name = "V.A.B. - Server Raspberry PI" addspace = server.register_namespace(name) node = server.get_objects_node() Param = node.add_object(addspace, "Gain parameters") ################################################# ############ FILE READING ####################### fileName_temp = "GainParametersToController.txt" fileName_confirmed = "GainParametersConfirmed.txt" lineHeaders = ["K_phi ", "K_phi_p ", "K_theta ", "K_theta_p "] initialValueGains = [0, 0, 0, 0] if os.path.exists(fileName_confirmed): print("Get initial values from file and create a temp one") file_object_def = open(fileName_confirmed, "r+")
from opcua import Server import time server = Server() server.set_endpoint("opc.tcp://127.0.0.1:9090") addspace = server.register_namespace("SIMULATION_SERVER") node = server.get_objects_node() Param = node.add_object(addspace, "Parameters") val = Param.add_variable(addspace, "Cup Size", 0) val.set_writable() server.start() print("Values being transferred to the internal process as follows:-") while True: Value={"Broken Pots", "Liquid Spills", "Broken Trays"} for x in Value: print('Incoming Waste is: '+ x) # x is a str val.set_value(Value) time.sleep(3)
sys.path.insert(0, "..") import time from opcua import ua, Server if __name__ == "__main__": # setup our server server = Server() server.set_endpoint("opc.tcp://localhost:4841/freeopcua/server/") # setup our own namespace, not really necessary but should as spec uri = "opcv" idx = server.register_namespace(uri) # get Objects node, this is where we should put our nodes objects = server.get_objects_node() # AMK - Here we declare our objects and data! # populating our address space myobj = objects.add_object(idx, "Data") dist = myobj.add_variable(idx, "Xdist", -1) side = myobj.add_variable(idx, "Xdist", -1) # myvar.set_writable() # Set MyVariable to be writable by clients # starting! server.start() try:
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()