async def main():
# setup our server
server = Server()
await server.init()
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 = await 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 = await objects.add_object(idx, 'MyObject')
myvar = await myobj.add_variable(idx, 'MyVariable', 6.7)
# Set MyVariable to be writable by clients
await myvar.set_writable()
await objects.add_method(ua.NodeId('ServerMethod', 2),
ua.QualifiedName('ServerMethod', 2), func,
[ua.VariantType.Int64], [ua.VariantType.Int64])
_logger.info('Starting server!')
async with server:
count = 0
while True:
await asyncio.sleep(1)
count += 0.1
_logger.info('Set value of %s to %.1f', myvar, count)
await myvar.set_value(count)
async def start_server(loop: asyncio.AbstractEventLoop):
server = Server()
await server.init()
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 = await server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
myobj = await objects.add_object(idx, "MyObject")
# Creating a custom event: Approach 1
# The custom event object automatically will have members from its parent (BaseEventType)
etype = await server.create_custom_event_type(
idx, 'MyFirstEvent', ua.ObjectIds.BaseEventType,
[('MyNumericProperty', ua.VariantType.Float),
('MyStringProperty', ua.VariantType.String)])
myevgen = await server.get_event_generator(etype, myobj)
# Creating a custom event: Approach 2
custom_etype = await server.nodes.base_event_type.add_object_type(
2, 'MySecondEvent')
await custom_etype.add_property(2, 'MyIntProperty',
ua.Variant(0, ua.VariantType.Int32))
await custom_etype.add_property(2, 'MyBoolProperty',
ua.Variant(True, ua.VariantType.Boolean))
mysecondevgen = await server.get_event_generator(custom_etype, myobj)
await server.start()
loop.call_later(2, emmit_event, loop, myevgen, mysecondevgen, 1)
class HelloServer:
def __init__(self, endpoint, name, model_filepath):
self.server = Server()
# This need to be imported at the start or else it will overwrite the data
self.server.import_xml(model_filepath)
self.server.set_endpoint(endpoint)
self.server.set_server_name(name)
objects = self.server.get_objects_node()
freeopcua_namespace = self.server.get_namespace_index(
"urn:freeopcua:python:server")
hellower = objects.get_child("0:Hellower")
hellower_say_hello = hellower.get_child("0:SayHello")
self.server.link_method(hellower_say_hello, say_hello_xml)
hellower.add_method(freeopcua_namespace, "SayHello2", say_hello,
[ua.VariantType.Boolean], [ua.VariantType.String])
hellower.add_method(freeopcua_namespace, "SayHelloArray",
say_hello_array, [ua.VariantType.Boolean],
[ua.VariantType.String])
def __enter__(self):
self.server.start()
return self.server
def __exit__(self, exc_type, exc_val, exc_tb):
self.server.stop()
async def main():
# Certificates folder
certs_folder = os.environ.get('CERTS_FOLDER', os.path.dirname(os.path.realpath(__file__)))
key_pem_path = os.path.join(certs_folder, "key.pem")
cert_der_path = os.path.join(certs_folder, "certificate.der")
server = Server()
await server.init()
await server.set_application_uri("urn:opcua:iom:server")
server.set_endpoint('opc.tcp://0.0.0.0:4840/freeopcua/server/')
server.set_server_name("IoM PLC Server Example")
# Security
await server.load_certificate(cert_der_path)
await server.load_private_key(key_pem_path)
server.set_security_policy([
ua.SecurityPolicyType.NoSecurity,
ua.SecurityPolicyType.Basic256Sha256_SignAndEncrypt])
# setup our own namespace, not really necessary but should as spec
idx = await server.register_namespace("https://tknika.eus/opcua/demo/plc")
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# populating our address space
plc_server = await objects.add_object(idx, 'PLC Server')
bool_data = await plc_server.add_variable(idx, 'BooleanData', True, datatype=ua.NodeId(1, 0))
pos_data = await plc_server.add_variable(idx, 'PositiveTrendData', 0, datatype=ua.NodeId(11, 0))
neg_data = await plc_server.add_variable(idx, 'NegativeTrendData', 0, datatype=ua.NodeId(11, 0))
temp_data = await plc_server.add_variable(idx, 'TemperatureData', 18.5, datatype=ua.NodeId(11, 0))
hum_data = await plc_server.add_variable(idx, 'HumidityData', 60.2, datatype=ua.NodeId(11, 0))
cyc_data = await plc_server.add_variable(idx, 'CyclicData', 0, datatype=ua.NodeId(11, 0))
mirror_orig_data = await plc_server.add_variable(idx, 'MirrorDataOriginal', True, datatype=ua.NodeId(1, 0))
mirror_copy_data = await plc_server.add_variable(idx, 'MirrorDataCopy', True, datatype=ua.NodeId(1, 0))
latitude_data = await plc_server.add_variable(idx, "GPSLatitude", "", datatype=ua.NodeId(12, 0))
longitude_data = await plc_server.add_variable(idx, "GPSLongitude", "", datatype=ua.NodeId(12, 0))
latitude_longitude_data = await plc_server.add_variable(idx, "GPSLatitudeAndLongitude", "", datatype=ua.NodeId(12, 0))
logger.info('Starting OPC UA server!')
bool_task = asyncio.Task(toggle_data(bool_data, refresh=10, init=True))
pos_task = asyncio.Task(periodic_data(pos_data, refresh=5))
neg_task = asyncio.Task(periodic_data(neg_data, refresh=5, increment=-2))
temp_task = asyncio.Task(random_data(temp_data, refresh=10, init=18.5, min=15, max=22))
hum_task = asyncio.Task(random_data(hum_data, refresh=10, init=60.2, min=0, max=100))
cyclic_task = asyncio.Task(cyclic_data(cyc_data, cycle_time=200, step=0.5, init=0, min=-100, max=100))
mirror_handler = MirrorHandler(server, mirror_orig_data, mirror_copy_data)
await mirror_handler.start()
tcx_update_handler = TCXUpdateHandler("circular-urnieta-aia-donosti-urnieta.tcx", latitude_data, longitude_data, latitude_longitude_data)
tcx_task = asyncio.Task(tcx_update_handler.start())
async with server:
await asyncio.gather(bool_task, pos_task, neg_task, temp_task, hum_task, cyclic_task, tcx_task)
async def serve_state(duration=None, frequency=1, debug=False):
server = Server()
await server.init()
server.set_endpoint("opc.tcp://0.0.0.0:4840/pulsedng/")
# setup our own namespace, not really necessary but should as spec
uri = "http://pulsedng.xenon-sc.lngs.infn.it"
nsidx = await server.register_namespace(uri)
# --------------------------------------------------------
# create custom enum data type
# --------------------------------------------------------
enums = await server.get_root_node().get_child(
["0:Types", "0:DataTypes", "0:BaseDataType", "0:Enumeration"])
# 1.
# Create Enum Type
GeneratorState_type = await enums.add_data_type(nsidx, 'GeneratorState')
# Or convert the existing IntEnum GeneratorState
es = await GeneratorState_type.add_property(
0, "EnumStrings", enum_to_stringlist(GeneratorState))
await es.set_value_rank(1)
await es.set_array_dimensions([0])
# --------------------------------------------------------
# create object with enum variable
# --------------------------------------------------------
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# create object
myobj = await objects.add_object(nsidx, 'GeneratorObject')
# add var with as type the custom enumeration
GeneratorState_var = await myobj.add_variable(
nsidx,
'GeneratorState2Var',
GeneratorState.off,
datatype=GeneratorState_type.nodeid)
await GeneratorState_var.set_writable()
await GeneratorState_var.set_value(GeneratorState.idle
) # change value of enumeration
_logger.info('Starting server!')
async with server:
while True:
for state in GeneratorState:
await asyncio.sleep(2)
_logger.info('Set value of %s to %d', GeneratorState_var,
state)
await GeneratorState_var.set_value(state)
async def main():
# setup our server
server = Server()
await server.init()
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 = await server.register_namespace(uri)
# await server.import_xml('device.xml')
# # get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
suobj=await objects.add_object(idx,'ROCKWELLObj')
suvar=[]
device=Rockwell_AB_PLC
device.IP = '192.168.100.200'
device.tag_list = ['Program:MainProgram.run', 'Program:MainProgram.start', 'Program:MainProgram.EMG',
'Local:1:O.Data.0', 'Local:1:O.Data.1', 'Local:1:O.Data.2','Local:1:O.Data.3', 'Local:1:O.Data.4',
'Local:1:O.Data.5','Local:1:O.Data.6', 'Local:1:O.Data.7']
# 初始化 创建 opc ua变量
a=0
for i in device.tag_list:
suvar.append(i)
suvar[a]=await suobj.add_variable(idx,i,0) # fixme 初始化都写0
await suvar[a].set_writable()
a+=1
# await objects.add_method(
# ua.NodeId('ServerMethod', 2), ua.QualifiedName('ServerMethod', 2),
# func, [ua.VariantType.Int64], [ua.VariantType.Int64]
# )
# _logger.info('Starting server!')
async with server:
count = 0
while True:
await asyncio.sleep(1) # 数据更新周期
# print(device.IP,device.tag_list)
aa,bb = rockwellread(device.IP,device.tag_list)
# print(cc.Value)
# print(aa,bb)
# count += 0.1
# _logger.info(aa, bb)
# await myvar.write_value(count)
a=0
for i in bb:
await suvar[a].write_value(i)
a+=1
async def main():
# setup our server
server = Server()
# Configure server to use sqlite as history database (default is a simple memory dict)
server.iserver.history_manager.set_storage(
HistorySQLite("my_datavalue_history.sql"))
# initialize server
await server.init()
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 = await server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
myobj = await objects.add_object(idx, "MyObject")
myvar = await myobj.add_variable(idx, "MyVariable",
ua.Variant(0, ua.VariantType.Double))
await myvar.set_writable() # Set MyVariable to be writable by clients
print(myvar)
# starting!
await server.start()
# enable data change history for this particular node, must be called after start since it uses subscription
await server.historize_node_data_change(myvar, period=None, count=100)
try:
count = 0
while True:
await asyncio.sleep(1)
count += 0.1
await myvar.set_value(math.sin(count))
finally:
# close connection, remove subscriptions, etc
await server.stop()
async def main():
# setup our server
server = Server()
await server.init()
server.set_endpoint('opc.tcp://localhost:4840/sunbeltOPC/server/')
# setup our own namespace, not really necessary but should as spec
uri = 'http://examples.freeopcua.github.io'
idx = await server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# Gather updated values from OpenWeather Map api for mapping.
pressure = 999
temperature = 999
humidity = 999
wind_speed = 999
# populating our address space
root_obj = await objects.add_object(idx, 'Weather Data')
# define variables wanted by the server here.
w_pressure = await root_obj.add_variable(idx, 'Pressure', pressure)
w_temperature = await root_obj.add_variable(idx, 'Temperature',
temperature)
w_humidity = await root_obj.add_variable(idx, 'Humidity', humidity)
w_wind_speed = await root_obj.add_variable(idx, 'Wind Speed', wind_speed)
# define variables that you may want to be writable by niagara here
w_location = await root_obj.add_variable(idx, 'Location',
'Santa Clara, US')
# Set variables from above to be writable by clients
await w_location.set_writable()
_logger.info('Starting server!')
async with server:
while True:
await asyncio.sleep(10)
loc = await w_location.read_value()
weather = update_weather(loc)
await w_pressure.set_value(weather[0])
await w_temperature.set_value(weather[1])
await w_humidity.set_value(weather[2])
await w_wind_speed.set_value(weather[3])
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()
async def init_server():
with open(r'../configuration.yml') as config_file:
config = yaml.load(config_file, Loader=yaml.FullLoader)
server = Server()
await server.init()
server.set_endpoint("opc.tcp://" + config['host'] + ":" +
str(config['port']))
namespace = await server.register_namespace(config['namespace'])
root_node = server.get_objects_node()
objects = await root_node.add_object(namespace, "BaseObjects")
server_rtt = await objects.add_variable(namespace, "server_rtt", None)
data_pool = await objects.add_variable(namespace, "data_pool", None)
await server_rtt.set_writable()
await data_pool.set_writable()
server_tests = Server_tests(server_rtt, data_pool)
server.link_method(root_node, server_tests.random_sort)
random_sort_method = await objects.add_method(
namespace, "random_sort", server_tests.random_sort,
[ua.VariantType.Int64, ua.VariantType.Float, ua.VariantType.Float],
[ua.VariantType.Float])
await server.start()
try:
print("OPC-UA server started")
while True:
await asyncio.sleep(1)
finally:
await server.stop()
import time
from asyncua import ua, Server
if __name__ == "__main__":
# setup our server
server = Server()
server.set_endpoint("opc.tcp://0.0.0.0:4840/freeopcua/server/")
# setup our own namespace, not really necessary but should as spec
uri = "http://examples.freeopcua.github.io"
idx = server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# Example 1 - create a basic object
#-------------------------------------------------------------------------------
myobj = objects.add_object(idx, "MyObject")
#-------------------------------------------------------------------------------
# Example 2 - create a new object type and a instance of the new object type
#-------------------------------------------------------------------------------
types = server.get_node(ua.ObjectIds.BaseObjectType)
object_type_to_derive_from = server.get_root_node().get_child(
["0:Types", "0:ObjectTypes", "0:BaseObjectType"])
mycustomobj_type = types.add_object_type(idx, "MyCustomObjectType")
mycustomobj_type.add_variable(0, "var_should_be_there_after_instantiate",
1.0) # demonstrates instantiate
async def main():
print('starting OPC server ')
opc_server = Server()
await opc_server.init()
opc_url = "opc.tcp://0.0.0.0:4840"
opc_server.set_endpoint(opc_url)
print('starting OPC server ..')
opc_name = "Grove-opcua-server"
addspace = await opc_server.register_namespace(opc_name)
print('starting OPC server ...')
opc_node = opc_server.get_objects_node()
param = await opc_node.add_object(addspace, "Parameters")
opc_time = await param.add_variable(addspace, "Time", 0)
opc_warehouse_state = await param.add_variable(addspace, "Warehouse state",
0)
opc_door_outside = await param.add_variable(addspace, "Outside door", 0)
opc_door_inside = await param.add_variable(addspace, "Inside door", 0)
opc_temperature_d = await param.add_variable(addspace,
"Temperature doorlock", 0.0)
opc_temperature_w = await param.add_variable(addspace,
"Temperature warehouse", 0.0)
await opc_time.set_read_only()
await opc_warehouse_state.set_read_only()
await opc_door_outside.set_read_only()
await opc_door_inside.set_read_only()
await opc_temperature_d.set_read_only()
await opc_temperature_w.set_read_only()
print('starting OPC server .....')
print("OPC UA Server started at {}".format(opc_url))
print("time Doors Warehouse (Celsius)")
# is voor terminal-mode, niet voor windows mode
async with opc_server:
while True:
try:
await asyncio.sleep(2)
time_stamp = datetime.now()
await opc_time.set_value(time_stamp)
await opc_temperature_d.set_value(temperature_doors.temperature
)
await opc_temperature_w.set_value(
temperature_warehouse.temperature)
print('{} {:.1f} {:.1f}'.format(
time_stamp.strftime("%X"), temperature_doors.temperature,
temperature_warehouse.temperature))
await opc_warehouse_state.set_value(warehouse_state)
await opc_door_outside.set_value(door_outside_state)
await opc_door_inside.set_value(door_inside_state)
except KeyboardInterrupt:
warehouse_relay.off()
door_outside_relay.off()
door_inside_relay.off()
warehouse_button.led_off()
door_outside_button.led_off()
door_inside_button.led_off()
await opc_server.stop()
print("exit")
exit(1)
async def main():
# optional: setup logging
logging.basicConfig(level=logging.WARN)
# logger = logging.getLogger("asyncua.address_space")
# logger.setLevel(logging.DEBUG)
# logger = logging.getLogger("asyncua.internal_server")
# logger.setLevel(logging.DEBUG)
# logger = logging.getLogger("asyncua.binary_server_asyncio")
# logger.setLevel(logging.DEBUG)
# logger = logging.getLogger("asyncua.uaprocessor")
# logger.setLevel(logging.DEBUG)
# logger = logging.getLogger("asyncua.subscription_service")
# logger.setLevel(logging.DEBUG)
# now setup our server
server = Server()
await server.init()
# 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 = await server.register_namespace(uri)
# get Objects node, this is where we should put our custom stuff
objects = server.get_objects_node()
# populating our address space
await objects.add_folder(idx, "myEmptyFolder")
myobj = await objects.add_object(idx, "MyObject")
myvar = await myobj.add_variable(idx, "MyVariable", 6.7)
await myvar.set_writable() # Set MyVariable to be writable by clients
myarrayvar = await myobj.add_variable(idx, "myarrayvar", [6.7, 7.9])
await myobj.add_variable(idx, "myStronglytTypedVariable",
ua.Variant([], ua.VariantType.UInt32))
await myobj.add_property(idx, "myproperty", "I am a property")
await 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")
await myobj.add_method(idx, "multiply", multiply, [inargx, inargy],
[outarg])
await myobj.add_method(idx, "multiply_async", multiply_async,
[inargx, inargy], [])
await myobj.add_method(idx, "func_async", func_async,
[ua.VariantType.Int64], [])
async with server:
while True:
await asyncio.sleep(1)
async def main():
# setup our server
server = Server()
endpoint_url = "opc.tcp://0.0.0.0:4840/freeopcua/server/"
if len(sys.argv) > 1:
endpoint_url = sys.argv[1]
print("Use Server Endpoint: " + endpoint_url)
await server.init()
server.set_endpoint(endpoint_url)
# setup our own namespace, not really necessary but should as spec
uri = 'http://examples.codecentric.de'
idx = await server.register_namespace(uri)
# get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
# populating our address space
_logger.info('Starting server!')
belt1 = await objects.add_object(idx, "Convoyer Belt1")
arm = await objects.add_object(idx, "Robot Arm")
pre_stage_temp = 25.0
mid_stage_temp = 65.0
post_stage_temp = 90.0
# motor has a possible degree from 0 to 180
motor_degree = 0
pre_stage = await belt1.add_variable(idx, "PreStage", pre_stage_temp)
mid_stage = await belt1.add_variable(idx, "MidStage", mid_stage_temp)
post_stage = await belt1.add_variable(idx, "PostStage", post_stage_temp)
motor_degree_var = await arm.add_variable(idx, "Motor", motor_degree)
ts = await belt1.add_variable(idx, "TimeStamp", datetime.now().isoformat())
ts_arm = await arm.add_variable(idx, "TimeStamp", datetime.now().isoformat())
async with server:
count = 0
current_pos = 0
positive_direction = True
while True:
await asyncio.sleep(0.1)
count += 1
randomizer = randrange(1, 10)
now = datetime.now().isoformat()
temp = calc_temp(pre_stage_temp, count, randomizer * 200)
temp2 = calc_temp(mid_stage_temp, count, randomizer * 1000)
temp3 = calc_temp(post_stage_temp, count, randomizer * 500)
await pre_stage.set_value(temp)
await mid_stage.set_value(temp2)
await post_stage.set_value(temp3)
await ts.set_value(now)
step_size = 1
# every 500 steps, delay:
if count % (randomizer * 500) == 0:
_logger.info("Delay Robot Arm")
step_size = 0
if positive_direction and current_pos < 180:
current_pos += step_size
elif positive_direction and current_pos >= 180:
positive_direction = False
current_pos -= step_size
elif not positive_direction and 0 < current_pos < 180:
current_pos -= step_size
elif not positive_direction and current_pos <= 0:
positive_direction = True
current_pos += step_size
await ts_arm.set_value(now)
await motor_degree_var.set_value(current_pos)
_logger.debug('Set value of %s to %.1f', temp, count)
_logger.debug('Arm Position of %s to %.1f', str(positive_direction), current_pos)
if count == 10000:
count = 0
async def main():
@uamethod
async def callback(parent, in_extobj):
out_extobj = ua.uaprotocol_auto.AxisInformation(
) # get new instanace of AxisInformation
out_extobj.EngineeringUnits = in_extobj.EngineeringUnits
out_extobj.EURange.Low = in_extobj.EURange.Low
out_extobj.EURange.High = in_extobj.EURange.High
out_extobj.Title = in_extobj.Title
out_extobj.AxisScaleType = in_extobj.AxisScaleType
out_extobj.AxisSteps = in_extobj.AxisSteps
await 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()
await server.init()
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 = await server.register_namespace("http://examples.freeopcua.github.io"
)
await server.load_data_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 = []
outarg_extobj.Description = ua.LocalizedText("Actual AxisInformation")
status = ua.Argument()
status.Name = "Status"
status.DataType = ua.NodeId(12, 0)
status.ValueRank = -1
status.ArrayDimensions = []
status.Description = ua.LocalizedText("MSG")
method_parent = await obj.add_object(idx, "Methods")
method_node = await method_parent.add_method(idx, "SetAxisInformation",
callback, [inarg_extobj],
[outarg_extobj, status])
#add a variable of type AxisInformation
axis_info = await obj.add_variable(
idx,
"AxisInformation",
ua.uaprotocol_auto.AxisInformation(),
varianttype=ua.VariantType.ExtensionObject)
async with server:
while 1:
await asyncio.sleep(0)
async def main():
# setup our server
server = Server()
await server.init()
server.default_timeout = 60
# server.set_endpoint('opc.tcp://0.0.0.0:4840/freeopcua/server/')
server.set_endpoint('opc.tcp://192.168.100.170:4840/')
# setup our own namespace, not really necessary but should as spec
# 设置加密和密钥后 prosys可以连接
await server.load_certificate("certificate-example.der")
await server.load_private_key("private-key-example.pem")
# 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
])
uri = 'http://examples.freeopcua.github.io'
idx = await server.register_namespace(uri)
# await server.import_xml('device.xml')
# # get Objects node, this is where we should put our nodes
objects = server.get_objects_node()
suobj = await objects.add_object(idx, 'ROCKWELLObj')
suvar = []
device = Rockwell_AB_PLC
device.IP = '192.168.100.200'
device.tag_list = [
'Program:MainProgram.run', 'Program:MainProgram.start',
'Program:MainProgram.EMG', 'Local:1:O.Data.0', 'Local:1:O.Data.1',
'Local:1:O.Data.2', 'Local:1:O.Data.3', 'Local:1:O.Data.4',
'Local:1:O.Data.5', 'Local:1:O.Data.6', 'Local:1:O.Data.7',
'Program:MainProgram.EP_Timer.PRE', 'Program:MainProgram.EP_Timer.ACC',
'Program:MainProgram.EP_Timer.EN', 'Program:MainProgram.EP_Timer.TT',
'Program:MainProgram.EP_Timer.DN'
]
# 初始化 创建 opc ua变量
a = 0
for i in device.tag_list:
suvar.append(i)
nodeid = (f'ns={idx};s={i}')
# print(nodeid,type(nodeid))
# i=i.replace(':','-')
# 添加变量，add_variable(NodeId(xxxx), QualifiedName(xxxx), DataValue(xxx))
# 加QualifiedName（）否则直接写字符串":"会分割字符串 报错
suvar[a] = await suobj.add_variable(ua.NodeId(nodeid),
ua.QualifiedName(i), True)
# fixme 初始化需不需要特殊操作？ 暂时都写0 最好和后续变量类型一致
await suvar[a].set_writable()
a += 1
# await objects.add_method(
# ua.NodeId('ServerMethod', 2), ua.QualifiedName('ServerMethod', 2),
# func, [ua.VariantType.Int64], [ua.VariantType.Int64]
# )
# _logger.info('Starting server!')
async with server:
count = 0
while True:
await asyncio.sleep(1) # 数据更新周期
# print(device.IP,device.tag_list)
aa, bb = rockwellread(device.IP, device.tag_list)
# print(cc.Value)
# print(aa,bb)
# count += 0.1
# _logger.info(aa, bb)
# await myvar.write_value(count)
a = 0
for i in bb:
await suvar[a].write_value(i)
a += 1
