151 lines
5.5 KiB
Python
151 lines
5.5 KiB
Python
import logging
|
|
from base import HandlerBase
|
|
from frappy.client import SecopClient
|
|
# from frappy.lib.enum import EnumMember
|
|
# from frappy.datatypes import get_datatype
|
|
|
|
|
|
def convert_par(module, name, par):
|
|
result = dict(type='input', name=module+":"+name, title=name)
|
|
if par.get('readonly', True):
|
|
result['type'] = 'rdonly'
|
|
else:
|
|
result['command'] = 'change %s:%s' % (module, name)
|
|
if par['datainfo']['type'] == 'enum':
|
|
result['enum_names'] = [dict(title=k, value=v) for k, v in par['datainfo']['members'].items()]
|
|
result['type'] = 'enum'
|
|
elif par['datainfo']['type'] == 'bool':
|
|
result['type'] = 'checkbox'
|
|
return result
|
|
|
|
|
|
class SecopInteractor(SecopClient):
|
|
prio_par = ["value", "status", "target"]
|
|
hide_par = ["baseclass", "class", "pollinterval"]
|
|
skip_par = ["status2"]
|
|
|
|
def __init__(self, uri, node_map):
|
|
super().__init__(uri)
|
|
self.module_updates = set()
|
|
self.param_updates = set()
|
|
self.updates = {}
|
|
self.connect()
|
|
self.register_callback(None, updateItem=self.updateItem)
|
|
|
|
def add_main_components(self, components):
|
|
for name, desc in self.modules.items():
|
|
component = dict(type='rdlink', name=f'{name}:value', title=name)
|
|
if 'status' in desc['parameters']:
|
|
component['statusname'] = f'{name}:status'
|
|
components.append(component)
|
|
self.param_updates.add('value')
|
|
self.param_updates.add('status')
|
|
|
|
def get_components(self, path):
|
|
module = self.modules[path]
|
|
self.module_updates.add(path) # TODO: remove others?
|
|
parameters = dict(module["parameters"])
|
|
components = []
|
|
for name in SecopInteractor.skip_par:
|
|
if name in parameters:
|
|
parameters.pop(name)
|
|
for name in SecopInteractor.prio_par:
|
|
if name in parameters:
|
|
components.append(convert_par(path, name, parameters.pop(name)))
|
|
components1 = []
|
|
for name in SecopInteractor.hide_par:
|
|
if name in parameters:
|
|
components1.append(convert_par(path, name, parameters.pop(name)))
|
|
for name, p in parameters.items():
|
|
components.append(convert_par(path, name, parameters[name]))
|
|
components.extend(components1)
|
|
return dict(type='draw', path=path, title=path, components=components)
|
|
|
|
def updateItem(self, module, parameter, entry):
|
|
key = module, parameter
|
|
# print(key, entry)
|
|
if module in self.module_updates or parameter in self.param_updates:
|
|
name = f'{module}:{parameter}'
|
|
if entry.readerror:
|
|
item = {'name': name, 'error': str(entry.readerror)}
|
|
else:
|
|
item = {'name': name, 'value': str(entry), 'formatted': entry.formatted()}
|
|
# print(item)
|
|
self.updates[key] = item
|
|
|
|
def update_main(self):
|
|
cache = self.cache
|
|
for modname in self.modules:
|
|
key = modname, 'value'
|
|
if key in cache:
|
|
self.updateItem(*key, cache[key])
|
|
|
|
def update_params(self, path):
|
|
cache = self.cache
|
|
for param in self.modules[path]['parameters']:
|
|
key = path, param
|
|
if key in cache:
|
|
self.updateItem(*key, cache[key])
|
|
|
|
def handle_command(self, command):
|
|
"""handle command if we can, else return False"""
|
|
if not command.strip():
|
|
return dict(type='accept-command')
|
|
if command.startswith('change '):
|
|
command = command[7:]
|
|
modpar, _, strvalue = command.partition(' ')
|
|
module, _, parameter = modpar.partition(':')
|
|
if not parameter:
|
|
parameter = 'target'
|
|
if module not in self.modules:
|
|
return False
|
|
logging.info('SENDCOMMAND %r', command)
|
|
try:
|
|
self.setParameterFromString(module, parameter, strvalue)
|
|
except Exception as e:
|
|
print(f"{e!r} converting {strvalue} to {self.modules[module]['parameters'][parameter]['datatype']}")
|
|
return True
|
|
|
|
def get_updates(self):
|
|
updates, self.updates = self.updates, {}
|
|
return list(updates.values())
|
|
|
|
def info(self):
|
|
return ["na"]
|
|
|
|
|
|
# class SecopInstrument(HandlerBase):
|
|
#
|
|
# def __init__(self, inst_name, instrument_config):
|
|
# super().__init__()
|
|
# self.instrument_config = instrument_config
|
|
# host_ports = instrument_config['hostport']
|
|
# self.logger_dir = instrument_config.get('logger_dir', '')
|
|
# # test_day = instrument_config.get('test_day', None)
|
|
# # self.test_day = [int(x) for x in test_day.split('-')] if test_day else None
|
|
# self.title = inst_name
|
|
# self.device = ''
|
|
# self.nodes = []
|
|
# self.node_map = {}
|
|
# for host_port in host_ports.split(','):
|
|
# node = SecopClient(host_port)
|
|
# node.connect()
|
|
# self.nodes.append(node)
|
|
# for name, mod in node.modules.items():
|
|
# self.node_map[name] = node
|
|
#
|
|
# def register(self, client):
|
|
# print('OPEN')
|
|
# for node in self.nodes:
|
|
# node.register_callback(None, client.updateItem)
|
|
# return super().register(client)
|
|
#
|
|
# def remove(self, client):
|
|
# print('REMOVE')
|
|
# for node in self.nodes:
|
|
# node.unregister_callback(None, client.updateItem)
|
|
# super().remove(client)
|
|
#
|
|
# def new_client(self):
|
|
# return self.register(SecopClient(self))
|