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()
