MA6: fix bad sea config

Change-Id: Ib6bf2234633cc760fc771a3f5c0beb4cb63a0f6d

bin/frappy-cli

@@ -24,12 +24,14 @@
 
 import sys
 import argparse
+import socket
 from pathlib import Path
 
 # Add import path for inplace usage
 sys.path.insert(0, str(Path(__file__).absolute().parents[1]))
 
 from frappy.client.interactive import init, run, clientenv, interact
+from frappy.protocol.discovery import scan
 
 
 def parseArgv(argv):
@@ -37,6 +39,9 @@ def parseArgv(argv):
     parser.add_argument('-i', '--include',
                         help='file to execute after connecting to the clients', metavar='file',
                         type=Path, action='append', default=[])
+    parser.add_argument('-s', '--scan',
+                        help='hosts to scan for (-s subnet for all nodes in subnet)',
+                        action='append', default=[])
     parser.add_argument('-o', '--only-execute',
                         help='Do not go into interactive mode after executing files. \
                         Has no effect without --include.', action='store_true')
@@ -46,9 +51,38 @@ def parseArgv(argv):
     return parser.parse_args(argv)
 
 
+def own_ip():
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.settimeout(0)
+    try:
+        # doesn't even have to be reachable
+        s.connect(('10.254.254.254', 1))
+        return s.getsockname()[0]
+    except Exception:
+        return '127.0.0.1'
+    finally:
+        s.close()
+
+
 args = parseArgv(sys.argv[1:])
 
-success = init(*args.node)
+nodes = args.node
+hosts = args.scan
+if not nodes and not hosts:
+    hosts = ['localhost']
+if hosts:
+    answers = []
+    for host in hosts:
+        ans = scan()
+        if host == 'subnet':  # all in subnet
+            answers.extend(ans)
+        else:  # filter by ip
+            ip = socket.gethostbyname(host)
+            if ip == '127.0.0.1':
+                ip = own_ip()
+            answers.extend(a for a in ans if a.address == ip)
+    nodes.extend(f'{h.hostname}:{h.port}' for h in answers)
+success = init(*nodes)
 
 run_error = ''
 file_success = False

bin/frappy-scan

@@ -23,54 +23,17 @@
 """SEC node autodiscovery tool."""
 
 import argparse
-import json
-import os
-import select
-import socket
 import sys
-from collections import namedtuple
-from time import time as currenttime
-
-UDP_PORT = 10767
-
-Answer = namedtuple('Answer',
-                    'address, port, equipment_id, firmware, description')
-
-
-def decode(msg, addr):
-    msg = msg.decode('utf-8')
-    try:
-        data = json.loads(msg)
-    except Exception:
-        return None
-    if not isinstance(data, dict):
-        return None
-    if data.get('SECoP') != 'node':
-        return None
-    try:
-        eq_id = data['equipment_id']
-        fw = data['firmware']
-        desc = data['description']
-        port = data['port']
-    except KeyError:
-        return None
-    addr, _scanport = addr
-    return Answer(addr, port, eq_id, fw, desc)
+from frappy.protocol.discovery import scan, listen
 
 
 def print_answer(answer, *, short=False):
-    try:
-        hostname = socket.gethostbyaddr(answer.address)[0]
-        address = hostname
-        numeric = f' ({answer.address})'
-    except Exception:
-        address = answer.address       
-        numeric = ''
     if short:
         # NOTE: keep this easily parseable!
-        print(f'{answer.equipment_id} {address}:{answer.port}')
+        print(f'{answer.equipment_id} {answer.hostname}:{answer.port}')
         return
-    print(f'Found {answer.equipment_id} at {address}{numeric}:')
+    numeric = f' ({answer.address})' if answer.address == answer.hostname else ''
+    print(f'Found {answer.equipment_id} at {answer.hostname}{numeric}:')
     print(f'  Port: {answer.port}')
     print(f'  Firmware: {answer.firmware}')
     desc = answer.description.replace('\n', '\n    ')
@@ -78,51 +41,6 @@ def print_answer(answer, *, short=False):
     print('-' * 80)
 
 
-def scan(max_wait=1.0):
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
-    # send a general broadcast
-    try:
-        s.sendto(json.dumps(dict(SECoP='discover')).encode('utf-8'),
-                 ('255.255.255.255', UDP_PORT))
-    except OSError as e:
-        print('could not send the broadcast:', e)
-        # we still keep listening for self-announcements
-    start = currenttime()
-    seen = set()
-    while currenttime() < start + max_wait:
-        res = select.select([s], [], [], 0.1)
-        if res[0]:
-            try:
-                msg, addr = s.recvfrom(1024)
-            except socket.error:  # pragma: no cover
-                continue
-            answer = decode(msg, addr)
-            if answer is None:
-                continue
-            if (answer.address, answer.equipment_id, answer.port) in seen:
-                continue
-            seen.add((answer.address, answer.equipment_id, answer.port))
-            yield answer
-
-
-def listen(*, short=False):
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    if os.name == 'nt':
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
-    else:
-        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
-    s.bind(('0.0.0.0', UDP_PORT))
-    while True:
-        try:
-            msg, addr = s.recvfrom(1024)
-        except KeyboardInterrupt:
-            break
-        answer = decode(msg, addr)
-        if answer:
-            print_answer(answer, short=short)
-
-
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument('-l', '--listen', action='store_true',
@@ -136,4 +54,5 @@ if __name__ == '__main__':
     for answer in scan():
         print_answer(answer, short=short)
     if args.listen:
-        listen(short=short)
+        for answer in listen():
+            print_answer(short=short)

cfg/dil5_cfg.py

@@ -11,13 +11,13 @@ lsc_uri = '192.168.1.2:7777'
 #lsc_uri='serial:///dev/ttyACM1?baudrate=57600+parity=odd+bytesize=7+stopbits=1',
 
 
-Node('dil5.psi.ch',
-     'dil5 with state machine for condensing and removing',
+Node('dil5_logo.psi.ch',
+     'dil5 logo test',
      interface='tcp://5000',
      secondary = ['ws://8010']
 )
 
-Mod('io',
+Mod('logo',
     'frappy_psi.logo.IO',
     '',
     ip_address = "192.168.0.3",
@@ -26,155 +26,101 @@ Mod('io',
 )
 
 Mod('V1',
-    'frappy_psi.logo.Valve',
+    'frappy_psi.logo.DigitalActuator',
     'Valves',
-    io = 'io',
-    vm_address_input ="V1025.0",
-    vm_address_output ="V1064.3"
+    io = 'logo',
+    feedback_addr ="V1025.0",
+    output_addr ="V1064.3"
 )
 
 Mod('V2',
-    'frappy_psi.logo.Valve',
-    'Valves',
-    io = 'io',
-    vm_address_input ="V1024.2",
-    vm_address_output ="V1064.0",
+    'frappy_psi.logo.DigitalActuator',
+    'dil bypass',
+    io = 'logo',
+    feedback_addr ="V1024.2",
+    output_addr ="V1064.0",
 )
 
 Mod('V4',
-    'frappy_psi.logo.Valve',
-    'Valves',
-    io = 'io',
-    vm_address_input ="V1024.5",
-    vm_address_output ="V1064.7",
+    'frappy_psi.logo.DigitalActuator',
+    'compressor to dump',
+    io = 'logo',
+    # feedback_addr ="V1024.5",  # not verified
+    output_addr ="V1064.7",
+    target_addr ="V404.1",
 )
 
 Mod('V5',
-    'frappy_psi.logo.Valve',
-    'Valves',
-    io = 'io',
-    vm_address_input ="V1024.4",
-    vm_address_output ="V1064.2"
+    'frappy_psi.logo.DigitalActuator',
+    'compressor input',
+    io = 'logo',
+    feedback_addr ="V1024.4",
+    output_addr ="V1064.2",
 )
 
 Mod('V9',
-    'frappy_psi.logo.Valve',
-    'Valves',
-    io = 'io',
-    vm_address_input ="V1024.3",
-    vm_address_output ="V404.1",
+    'frappy_psi.logo.DelayedActuator',
+    'dump output',
+    io = 'logo',
+    delay_addr = 'VW24',
+    feedback_addr ="V1024.3",
+    output_addr ="V1064.5",
+    target_addr ="V404.3",
 )
 
-Mod('pump',
-    'frappy_psi.logo.FluidMachines',
-    'Pump',
-    io = 'io',
-    vm_address_output ="V414.1"
+Mod('forepump',
+    'frappy_psi.logo.DigitalActuator',
+    'forepump',
+    io = 'logo',
+    output_addr ="V1064.6",
+    target_addr ="V404.4",
 )
 
 Mod('compressor',
-    'frappy_psi.logo.FluidMachines',
-    'Compressor',
-    io = 'io',
-    vm_address_output ="V400.1"
+    'frappy_psi.logo.DigitalActuator',
+    '',
+    io = 'logo',
+    output_addr ="V1064.4",
+    target_addr ="V404.2",
 )
 
 Mod('p2',
-    'frappy_psi.logo.Pressure',
-    'Pressure in mBar',
-    io = 'io',
-    vm_address ="VW0",
+    'frappy_psi.logo.Value',
+    'pressure after compressor',
+    io = 'logo',
+    addr ="VW0",
+    value = Param(unit='mbar'),
 )
 
 Mod('p1',
-    'frappy_psi.logo.Pressure',
-    'Pressure in mBar',
-    io = 'io',
-    vm_address ="VW2",
+    'frappy_psi.logo.Value',
+    'dump pressure',
+    io = 'logo',
+    addr ="VW28",
+    value = Param(unit='mbar'),
 )
 
 Mod('p5',
-    'frappy_psi.logo.Pressure',
-    'Pressure in mBar',
-    io = 'io',
-    vm_address ="VW4",
+    'frappy_psi.logo.Value',
+    'pressure after forepump',
+    io = 'logo',
+    addr ="VW4",
+    value = Param(unit='mbar'),
 )
 
-Mod('Druckluft',
-    'frappy_psi.logo.Airpressure',
+Mod('airpressure',
+    'frappy_psi.logo.DigitalValue',
     'Airpressure state',
-    io = 'io',
-    vm_address ="VW6",
+    io = 'logo',
+    addr ="V1024.7",
 )
 
-
-
-Mod('SF1',
-    'frappy_psi.logo.safetyfeatureState',
-    'Safety Feature',
-    io = 'io',
-    vm_address ="V410.1",
-)
-
-Mod('SF2',
-    'frappy_psi.logo.safetyfeatureState',
-    'Safety Feature',
-    io = 'io',
-    vm_address ="V406.1",
-)
-
-Mod('SF3',
-    'frappy_psi.logo.safetyfeatureState',
-    'Safety Feature',
-    io = 'io',
-    vm_address ="V408.1",
-)
-
-Mod('SF4',
-    'frappy_psi.logo.safetyfeatureState',
-    'Safety Feature',
-    io = 'io',
-    vm_address ="V412.1",
-)
-
-Mod('p2max',
-    'frappy_psi.logo.safetyfeatureParam',
-    'Safety Feature Param',
-    io = 'io',
-    target = 2000,
-    vm_address ="VW8",
-)
-
-Mod('pcond',
-    'frappy_psi.logo.safetyfeatureParam',
-    'Safety Feature Param',
-    io = 'io',
-    target = 1800,
-    vm_address ="VW10",
-)
-
-Mod('p5min',
-    'frappy_psi.logo.safetyfeatureParam',
-    'Safety Feature Param',
-    io = 'io',
-    target = 0,
-    vm_address ="VW12",
-)
-
-Mod('p5max',
-    'frappy_psi.logo.safetyfeatureParam',
-    'Safety Feature Param',
-    io = 'io',
-    target = 900,
-    vm_address ="VW14",
-)
-
-
 Mod('io_ls273',
     'frappy_psi.ls372.StringIO',
     'io for Ls372',
     uri=lsc_uri,
     )
+
 Mod('sw',
     'frappy_psi.ls372.Switcher',
     'channel switcher',
@@ -361,41 +307,31 @@ Mod('T_cond',
     io='itc',
 )
 
-Mod('stateMachine',
-    'frappy_psi.dilution_statemachine.DIL5',
-    'Statemachine',
-    
+Mod('safety',
+    'frappy_psi.dilution.Interlock',
+    'interlock mechanism',
+    io='logo',
+    dil='dil',
+)
+
+Mod('dil',
+    'frappy_psi.dilution.DIL5',
+    'dilution state machine and parameters',
+
     condenseline_pressure = "p2",
     condense_valve = "V9",
     dump_valve = "V4",
-    circulate_pump = "pump",
+    forepump = "forepump",
     compressor = "compressor",
 
     turbopump = "turbopump",
     condenseline_valve = "V1",
     circuitshort_valve = "V2",
-    still_pressure = "p3",
+    still_pressure = "p4",
+    still_pressure_turbo = "p3",
     #ls372 = "res1",
-    V5 = "V5",
-    p1 = "p1",
-    
-    MV10 = 'MV10',
-    MV13 ='MV13',
-    MV8 = 'MV8',
-    MVB = 'MVB',
-    MV2 = 'MV2',
-
-    MV1 = 'MV1',
-    MV3a = 'MV3a',
-    MV3b = 'MV3b',
-    GV1 = 'GV1',
-    MV14 = 'MV14',
-    MV12 = 'MV12',
-    MV11 = 'MV11',
-    MV9 = 'MV9',
-    GV2 = 'GV2',
-    condensing_p_low  = 150,
-    condensing_p_high = 250
+    dump_pressure = "p1",
+    condensing_p_low  = 1200,
+    condensing_p_high = 1500,
 )
 
-

cfg/main/jtccr_cfg.py

@@ -14,7 +14,7 @@ Mod('tt',
     io='sea_main',
     meaning=['temperature_regulation', 27],
     sea_object='tt',
-    rel_paths=['tt', 'set'],
+    rel_paths=['main', '.', 'set'],
     value=Param(unit='K'),
 )
 

cfg/main/ori4_cfg.py

@@ -9,12 +9,21 @@ Mod('sea_main',
     service='main',
 )
 
+#Mod('tt',
+#    'frappy_psi.sea.SeaDrivable', '',
+#    io='sea_main',
+#    meaning=['temperature_regulation', 27],
+#    sea_object='tt',
+#    rel_paths=['tm', '.', 'set', 'dblctrl'],
+#)
+
 Mod('tt',
-    'frappy_psi.sea.SeaDrivable', '',
+    'frappy_psi.sea.LscDrivable', '',
     io='sea_main',
     meaning=['temperature_regulation', 27],
     sea_object='tt',
-    rel_paths=['.', 'tm', 'set', 'dblctrl'],
+    sensor_path='tm',
+    set_path='set',
 )
 
 Mod('cc',

cfg/sea/ma6.config.json

@@ -1,50 +1,50 @@
 {"tt": {"base": "/tt", "params": [
 {"path": "", "type": "float", "readonly": false, "cmd": "run tt", "description": "tt", "kids": 18},
 {"path": "send", "type": "text", "readonly": false, "cmd": "tt send", "visibility": 3},
-{"path": "status", "type": "text", "readonly": false, "cmd": "run tt", "visibility": 3},
+{"path": "status", "type": "text", "visibility": 3},
 {"path": "is_running", "type": "int", "readonly": false, "cmd": "tt is_running", "visibility": 3},
 {"path": "mainloop", "type": "text", "readonly": false, "cmd": "tt mainloop", "visibility": 3},
-{"path": "target", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "running", "type": "int", "readonly": false, "cmd": "run tt"},
+{"path": "target", "type": "float"},
+{"path": "running", "type": "int"},
 {"path": "tolerance", "type": "float", "readonly": false, "cmd": "tt tolerance"},
 {"path": "maxwait", "type": "float", "readonly": false, "cmd": "tt maxwait"},
 {"path": "settle", "type": "float", "readonly": false, "cmd": "tt settle"},
 {"path": "log", "type": "text", "readonly": false, "cmd": "tt log", "visibility": 3, "kids": 4},
-{"path": "log/mean", "type": "float", "readonly": false, "cmd": "run tt", "visibility": 3},
-{"path": "log/m2", "type": "float", "readonly": false, "cmd": "run tt", "visibility": 3},
-{"path": "log/stddev", "type": "float", "readonly": false, "cmd": "run tt", "visibility": 3},
-{"path": "log/n", "type": "float", "readonly": false, "cmd": "run tt", "visibility": 3},
+{"path": "log/mean", "type": "float", "visibility": 3},
+{"path": "log/m2", "type": "float", "visibility": 3},
+{"path": "log/stddev", "type": "float", "visibility": 3},
+{"path": "log/n", "type": "float", "visibility": 3},
 {"path": "dblctrl", "type": "bool", "readonly": false, "cmd": "tt dblctrl", "kids": 9},
 {"path": "dblctrl/tshift", "type": "float", "readonly": false, "cmd": "tt dblctrl/tshift"},
 {"path": "dblctrl/mode", "type": "enum", "enum": {"disabled": -1, "inactive": 0, "stable": 1, "up": 2, "down": 3}, "readonly": false, "cmd": "tt dblctrl/mode"},
-{"path": "dblctrl/shift_up", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "dblctrl/shift_lo", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "dblctrl/t_min", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "dblctrl/t_max", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "dblctrl/shift_up", "type": "float"},
+{"path": "dblctrl/shift_lo", "type": "float"},
+{"path": "dblctrl/t_min", "type": "float"},
+{"path": "dblctrl/t_max", "type": "float"},
 {"path": "dblctrl/int2", "type": "float", "readonly": false, "cmd": "tt dblctrl/int2"},
 {"path": "dblctrl/prop_up", "type": "float", "readonly": false, "cmd": "tt dblctrl/prop_up"},
 {"path": "dblctrl/prop_lo", "type": "float", "readonly": false, "cmd": "tt dblctrl/prop_lo"},
-{"path": "tm", "type": "float", "readonly": false, "cmd": "run tt", "kids": 4},
+{"path": "tm", "type": "float", "kids": 4},
 {"path": "tm/curve", "type": "text", "readonly": false, "cmd": "tt tm/curve", "kids": 1},
 {"path": "tm/curve/points", "type": "floatvarar", "readonly": false, "cmd": "tt tm/curve/points", "visibility": 3},
 {"path": "tm/alarm", "type": "float", "readonly": false, "cmd": "tt tm/alarm"},
-{"path": "tm/stddev", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "tm/raw", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "ts", "type": "float", "readonly": false, "cmd": "run tt", "kids": 4},
+{"path": "tm/stddev", "type": "float"},
+{"path": "tm/raw", "type": "float"},
+{"path": "ts", "type": "float", "kids": 4},
 {"path": "ts/curve", "type": "text", "readonly": false, "cmd": "tt ts/curve", "kids": 1},
 {"path": "ts/curve/points", "type": "floatvarar", "readonly": false, "cmd": "tt ts/curve/points", "visibility": 3},
 {"path": "ts/alarm", "type": "float", "readonly": false, "cmd": "tt ts/alarm"},
-{"path": "ts/stddev", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "ts/raw", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "ts_2", "type": "float", "readonly": false, "cmd": "run tt", "kids": 4},
-{"path": "ts_2/curve", "type": "text", "readonly": false, "cmd": "tt ts_2/curve", "kids": 1},
+{"path": "ts/stddev", "type": "float"},
+{"path": "ts/raw", "type": "float"},
+{"path": "ts_2", "type": "float", "visibility": 3, "kids": 4},
+{"path": "ts_2/curve", "type": "text", "readonly": false, "cmd": "tt ts_2/curve", "visibility": 3, "kids": 1},
 {"path": "ts_2/curve/points", "type": "floatvarar", "readonly": false, "cmd": "tt ts_2/curve/points", "visibility": 3},
-{"path": "ts_2/alarm", "type": "float", "readonly": false, "cmd": "tt ts_2/alarm"},
-{"path": "ts_2/stddev", "type": "float", "readonly": false, "cmd": "run tt"},
-{"path": "ts_2/raw", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "ts_2/alarm", "type": "float", "readonly": false, "cmd": "tt ts_2/alarm", "visibility": 3},
+{"path": "ts_2/stddev", "type": "float", "visibility": 3},
+{"path": "ts_2/raw", "type": "float", "visibility": 3},
 {"path": "set", "type": "float", "readonly": false, "cmd": "tt set", "kids": 18},
 {"path": "set/mode", "type": "enum", "enum": {"disabled": -1, "off": 0, "controlling": 1, "manual": 2}, "readonly": false, "cmd": "tt set/mode"},
-{"path": "set/reg", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "set/reg", "type": "float"},
 {"path": "set/ramp", "type": "float", "readonly": false, "cmd": "tt set/ramp", "description": "maximum ramp in K/min (0: ramp off)"},
 {"path": "set/wramp", "type": "float", "readonly": false, "cmd": "tt set/wramp"},
 {"path": "set/smooth", "type": "float", "readonly": false, "cmd": "tt set/smooth", "description": "smooth time (minutes)"},
@@ -53,17 +53,17 @@
 {"path": "set/resist", "type": "float", "readonly": false, "cmd": "tt set/resist"},
 {"path": "set/maxheater", "type": "text", "readonly": false, "cmd": "tt set/maxheater", "description": "maximum heater limit, units should be given without space: W, mW, A, mA"},
 {"path": "set/linearpower", "type": "float", "readonly": false, "cmd": "tt set/linearpower", "description": "when not 0, it is the maximum effective power, and the power is linear to the heater output"},
-{"path": "set/maxpowerlim", "type": "float", "readonly": false, "cmd": "run tt", "description": "the maximum power limit (before any booster or converter)"},
+{"path": "set/maxpowerlim", "type": "float", "description": "the maximum power limit (before any booster or converter)"},
 {"path": "set/maxpower", "type": "float", "readonly": false, "cmd": "tt set/maxpower", "description": "maximum power [W]"},
-{"path": "set/maxcurrent", "type": "float", "readonly": false, "cmd": "run tt", "description": "the maximum current before any booster or converter"},
+{"path": "set/maxcurrent", "type": "float", "description": "the maximum current before any booster or converter"},
 {"path": "set/manualpower", "type": "float", "readonly": false, "cmd": "tt set/manualpower"},
-{"path": "set/power", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "set/power", "type": "float"},
 {"path": "set/prop", "type": "float", "readonly": false, "cmd": "tt set/prop", "description": "bigger means more gain"},
 {"path": "set/integ", "type": "float", "readonly": false, "cmd": "tt set/integ", "description": "bigger means faster"},
 {"path": "set/deriv", "type": "float", "readonly": false, "cmd": "tt set/deriv"},
 {"path": "setsamp", "type": "float", "readonly": false, "cmd": "tt setsamp", "kids": 18},
 {"path": "setsamp/mode", "type": "enum", "enum": {"disabled": -1, "off": 0, "controlling": 1, "manual": 2}, "readonly": false, "cmd": "tt setsamp/mode"},
-{"path": "setsamp/reg", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "setsamp/reg", "type": "float"},
 {"path": "setsamp/ramp", "type": "float", "readonly": false, "cmd": "tt setsamp/ramp", "description": "maximum ramp in K/min (0: ramp off)"},
 {"path": "setsamp/wramp", "type": "float", "readonly": false, "cmd": "tt setsamp/wramp"},
 {"path": "setsamp/smooth", "type": "float", "readonly": false, "cmd": "tt setsamp/smooth", "description": "smooth time (minutes)"},
@@ -72,16 +72,16 @@
 {"path": "setsamp/resist", "type": "float", "readonly": false, "cmd": "tt setsamp/resist"},
 {"path": "setsamp/maxheater", "type": "text", "readonly": false, "cmd": "tt setsamp/maxheater", "description": "maximum heater limit, units should be given without space: W, mW, A, mA"},
 {"path": "setsamp/linearpower", "type": "float", "readonly": false, "cmd": "tt setsamp/linearpower", "description": "when not 0, it is the maximum effective power, and the power is linear to the heater output"},
-{"path": "setsamp/maxpowerlim", "type": "float", "readonly": false, "cmd": "run tt", "description": "the maximum power limit (before any booster or converter)"},
+{"path": "setsamp/maxpowerlim", "type": "float", "description": "the maximum power limit (before any booster or converter)"},
 {"path": "setsamp/maxpower", "type": "float", "readonly": false, "cmd": "tt setsamp/maxpower", "description": "maximum power [W]"},
-{"path": "setsamp/maxcurrent", "type": "float", "readonly": false, "cmd": "run tt", "description": "the maximum current before any booster or converter"},
+{"path": "setsamp/maxcurrent", "type": "float", "description": "the maximum current before any booster or converter"},
 {"path": "setsamp/manualpower", "type": "float", "readonly": false, "cmd": "tt setsamp/manualpower"},
-{"path": "setsamp/power", "type": "float", "readonly": false, "cmd": "run tt"},
+{"path": "setsamp/power", "type": "float"},
 {"path": "setsamp/prop", "type": "float", "readonly": false, "cmd": "tt setsamp/prop", "description": "bigger means more gain"},
 {"path": "setsamp/integ", "type": "float", "readonly": false, "cmd": "tt setsamp/integ", "description": "bigger means faster"},
 {"path": "setsamp/deriv", "type": "float", "readonly": false, "cmd": "tt setsamp/deriv"},
 {"path": "display", "type": "text", "readonly": false, "cmd": "tt display"},
-{"path": "remote", "type": "bool", "readonly": false, "cmd": "run tt"}]},
+{"path": "remote", "type": "bool"}]},
 
 "cc": {"base": "/cc", "params": [
 {"path": "", "type": "bool", "kids": 96},
@@ -108,7 +108,7 @@
 {"path": "mcr", "type": "float"},
 {"path": "mot", "type": "float"},
 {"path": "mw", "type": "float", "readonly": false, "cmd": "cc mw", "description": "correction pulse after automatic open"},
-{"path": "hav", "type": "enum",  "type": "enum", "enum": {"none": 0, "int": 1, "ext": 2}, "readonly": false, "cmd": "cc hav"},
+{"path": "hav", "type": "enum", "enum": {"none": 0, "int": 1, "ext": 2}, "readonly": false, "cmd": "cc hav"},
 {"path": "h", "type": "float"},
 {"path": "hr", "type": "float"},
 {"path": "hc", "type": "float"},
@@ -132,26 +132,26 @@
 {"path": "hms", "type": "float"},
 {"path": "hit", "type": "float", "readonly": false, "cmd": "cc hit"},
 {"path": "hft", "type": "int", "readonly": false, "cmd": "cc hft"},
-{"path": "hea", "type": "enum", "enum": {"0": 0, "1": 1, "6": 2}, "readonly": false, "cmd": "cc hea"},
-{"path": "hch", "type": "int", "readonly": false, "cmd": "cc hch", "visibility": 3},
-{"path": "hwr0", "type": "float", "readonly": false, "cmd": "cc hwr0", "visibility": 3},
-{"path": "hem0", "type": "float", "readonly": false, "cmd": "cc hem0", "description": "sensor length in mm from top to empty pos.", "visibility": 3},
-{"path": "hfu0", "type": "float", "readonly": false, "cmd": "cc hfu0", "description": "sensor length in mm from top to full pos.", "visibility": 3},
-{"path": "hd0", "type": "float", "readonly": false, "cmd": "cc hd0", "description": "external sensor drive current (mA)", "visibility": 3},
-{"path": "h0", "type": "float", "visibility": 3},
-{"path": "hs0", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
-{"path": "h1", "type": "float", "visibility": 3},
-{"path": "hs1", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
-{"path": "h2", "type": "float", "visibility": 3},
-{"path": "hs2", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
-{"path": "h3", "type": "float", "visibility": 3},
-{"path": "hs3", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
-{"path": "h4", "type": "float", "visibility": 3},
-{"path": "hs4", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
-{"path": "h5", "type": "float", "visibility": 3},
-{"path": "hs5", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}, "visibility": 3},
+{"path": "hea", "type": "enum", "enum": {"0": 0, "1": 1, "6": 6}, "readonly": false, "cmd": "cc hea"},
+{"path": "hch", "type": "int", "readonly": false, "cmd": "cc hch"},
+{"path": "hwr0", "type": "float", "readonly": false, "cmd": "cc hwr0"},
+{"path": "hem0", "type": "float", "readonly": false, "cmd": "cc hem0", "description": "sensor length in mm from top to empty pos."},
+{"path": "hfu0", "type": "float", "readonly": false, "cmd": "cc hfu0", "description": "sensor length in mm from top to full pos."},
+{"path": "hd0", "type": "float", "readonly": false, "cmd": "cc hd0", "description": "external sensor drive current (mA)"},
+{"path": "h0", "type": "float"},
+{"path": "hs0", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
+{"path": "h1", "type": "float"},
+{"path": "hs1", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
+{"path": "h2", "type": "float"},
+{"path": "hs2", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
+{"path": "h3", "type": "float"},
+{"path": "hs3", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
+{"path": "h4", "type": "float"},
+{"path": "hs4", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
+{"path": "h5", "type": "float"},
+{"path": "hs5", "type": "enum", "enum": {"sens_ok": 0, "sens_warm": 1, "no_sens": 2, "timeout": 3, "not_yet_read": 4, "disabled": 5}},
 {"path": "hfb", "type": "float"},
-{"path": "nav", "type": "enum",  "type": "enum", "enum": {"none": 0, "int": 1, "ext": 2}, "readonly": false, "cmd": "cc nav"},
+{"path": "nav", "type": "bool", "readonly": false, "cmd": "cc nav"},
 {"path": "nu", "type": "float"},
 {"path": "nl", "type": "float"},
 {"path": "nth", "type": "float", "readonly": false, "cmd": "cc nth"},
@@ -183,15 +183,16 @@
 {"path": "bdl", "type": "float", "readonly": false, "cmd": "cc bdl"}]},
 
 "nv": {"base": "/nv", "params": [
-{"path": "", "type": "enum", "enum": {"fixed": 0, "controlled": 1, "automatic": 2, "close": 3, "open": 4}, "readonly": false, "cmd": "nv", "kids": 11},
+{"path": "", "type": "enum", "enum": {"fixed": 0, "controlled": 1, "automatic": 2, "close": 3, "open": 4}, "readonly": false, "cmd": "nv", "kids": 12},
 {"path": "send", "type": "text", "readonly": false, "cmd": "nv send", "visibility": 3},
 {"path": "status", "type": "text", "visibility": 3},
 {"path": "motstat", "type": "enum", "enum": {"idle": 0, "opening": 1, "closing": 2, "opened": 3, "closed": 4, "no_motor": 5}},
 {"path": "flow", "type": "float"},
 {"path": "set", "type": "float", "readonly": false, "cmd": "nv set"},
 {"path": "flowmax", "type": "float", "readonly": false, "cmd": "nv flowmax"},
-{"path": "flowp", "type": "float"},
+{"path": "flowp", "type": "float", "description": "flow calculated from pressure before pump"},
 {"path": "span", "type": "float"},
+{"path": "use_pressure", "type": "bool", "readonly": false, "cmd": "nv use_pressure", "description": "use pressure instead of flow meter for control"},
 {"path": "ctrl", "type": "none", "kids": 13},
 {"path": "ctrl/regtext", "type": "text"},
 {"path": "ctrl/prop_o", "type": "float", "readonly": false, "cmd": "nv ctrl/prop_o", "description": "prop [sec/mbar] when opening. above 4 mbar a 10 times lower value is used"},
@@ -235,15 +236,34 @@
 {"path": "calib/ln_per_min_per_mbar", "type": "float", "readonly": false, "cmd": "nv calib/ln_per_min_per_mbar"},
 {"path": "calib/mbar_offset", "type": "float", "readonly": false, "cmd": "nv calib/mbar_offset"}]},
 
+"hefill": {"base": "/hefill", "params": [
+{"path": "", "type": "enum", "enum": {"watching": 0, "filling": 1, "inactive": 2, "manualfill": 3}, "readonly": false, "cmd": "hefill", "kids": 16},
+{"path": "send", "type": "text", "readonly": false, "cmd": "hefill send", "visibility": 3},
+{"path": "status", "type": "text", "visibility": 3},
+{"path": "state", "type": "text"},
+{"path": "readpath", "type": "text", "readonly": false, "cmd": "hefill readpath", "visibility": 3},
+{"path": "lowlevel", "type": "float", "readonly": false, "cmd": "hefill lowlevel"},
+{"path": "highlevel", "type": "float", "readonly": false, "cmd": "hefill highlevel"},
+{"path": "smooth", "type": "float"},
+{"path": "minfillminutes", "type": "float", "readonly": false, "cmd": "hefill minfillminutes"},
+{"path": "maxfillminutes", "type": "float", "readonly": false, "cmd": "hefill maxfillminutes"},
+{"path": "minholdhours", "type": "float", "readonly": false, "cmd": "hefill minholdhours"},
+{"path": "maxholdhours", "type": "float", "readonly": false, "cmd": "hefill maxholdhours"},
+{"path": "tolerance", "type": "float", "readonly": false, "cmd": "hefill tolerance"},
+{"path": "badreadingminutes", "type": "float", "readonly": false, "cmd": "hefill badreadingminutes"},
+{"path": "tubecoolingminutes", "type": "float", "readonly": false, "cmd": "hefill tubecoolingminutes"},
+{"path": "vessellimit", "type": "float", "readonly": false, "cmd": "hefill vessellimit"},
+{"path": "vext", "type": "float"}]},
+
 "hepump": {"base": "/hepump", "params": [
 {"path": "", "type": "enum", "enum": {"neodry": 8, "xds35_auto": 0, "xds35_manual": 1, "sv65": 2, "other": 3, "no": -1}, "readonly": false, "cmd": "hepump", "description": "xds35: scroll pump, sv65: leybold", "kids": 10},
 {"path": "send", "type": "text", "readonly": false, "cmd": "hepump send", "visibility": 3},
 {"path": "status", "type": "text", "visibility": 3},
 {"path": "running", "type": "bool", "readonly": false, "cmd": "hepump running"},
-{"path": "eco", "type": "bool", "readonly": false, "cmd": "hepump eco"},
-{"path": "auto", "type": "bool", "readonly": false, "cmd": "hepump auto"},
+{"path": "eco", "type": "bool", "readonly": false, "cmd": "hepump eco", "visibility": 3},
+{"path": "auto", "type": "bool", "readonly": false, "cmd": "hepump auto", "visibility": 3},
 {"path": "valve", "type": "enum", "enum": {"closed": 0, "closing": 1, "opening": 2, "opened": 3, "undefined": 4}, "readonly": false, "cmd": "hepump valve"},
-{"path": "eco_t_lim", "type": "float", "readonly": false, "cmd": "hepump eco_t_lim", "description": "switch off eco mode when T_set < eco_t_lim and T < eco_t_lim * 2"},
+{"path": "eco_t_lim", "type": "float", "readonly": false, "cmd": "hepump eco_t_lim", "description": "switch off eco mode when T_set < eco_t_lim and T < eco_t_lim * 2", "visibility": 3},
 {"path": "calib", "type": "float", "readonly": false, "cmd": "hepump calib", "visibility": 3},
 {"path": "health", "type": "float"}]},
 
@@ -291,11 +311,11 @@
 {"path": "save", "type": "bool", "readonly": false, "cmd": "nvflow save", "description": "unchecked: current calib is not saved. set checked: save calib"}]},
 
 "ln2fill": {"base": "/ln2fill", "params": [
-{"path": "", "type": "enum", "enum": {"watching": 0, "fill": 1, "inactive": 2}, "readonly": false, "cmd": "ln2fill", "kids": 14},
+{"path": "", "type": "enum", "enum": {"watching": 0, "filling": 1, "inactive": 2, "manualfill": 3}, "readonly": false, "cmd": "ln2fill", "kids": 14},
 {"path": "send", "type": "text", "readonly": false, "cmd": "ln2fill send", "visibility": 3},
 {"path": "status", "type": "text", "visibility": 3},
 {"path": "state", "type": "text"},
-{"path": "readlevel", "type": "text", "readonly": false, "cmd": "ln2fill readlevel", "visibility": 3},
+{"path": "readpath", "type": "text", "readonly": false, "cmd": "ln2fill readpath", "visibility": 3},
 {"path": "lowlevel", "type": "float", "readonly": false, "cmd": "ln2fill lowlevel"},
 {"path": "highlevel", "type": "float", "readonly": false, "cmd": "ln2fill highlevel"},
 {"path": "smooth", "type": "float"},
@@ -307,52 +327,33 @@
 {"path": "badreadingminutes", "type": "float", "readonly": false, "cmd": "ln2fill badreadingminutes"},
 {"path": "tubecoolingminutes", "type": "float", "readonly": false, "cmd": "ln2fill tubecoolingminutes"}]},
 
-"hefill": {"base": "/hefill", "params": [
-{"path": "", "type": "enum", "enum": {"watching": 0, "fill": 1, "inactive": 2}, "readonly": false, "cmd": "hefill", "kids": 16},
-{"path": "send", "type": "text", "readonly": false, "cmd": "hefill send", "visibility": 3},
-{"path": "status", "type": "text", "visibility": 3},
-{"path": "state", "type": "text"},
-{"path": "readlevel", "type": "text", "readonly": false, "cmd": "hefill readlevel", "visibility": 3},
-{"path": "lowlevel", "type": "float", "readonly": false, "cmd": "hefill lowlevel"},
-{"path": "highlevel", "type": "float", "readonly": false, "cmd": "hefill highlevel"},
-{"path": "smooth", "type": "float"},
-{"path": "minfillminutes", "type": "float", "readonly": false, "cmd": "hefill minfillminutes"},
-{"path": "maxfillminutes", "type": "float", "readonly": false, "cmd": "hefill maxfillminutes"},
-{"path": "minholdhours", "type": "float", "readonly": false, "cmd": "hefill minholdhours"},
-{"path": "maxholdhours", "type": "float", "readonly": false, "cmd": "hefill maxholdhours"},
-{"path": "tolerance", "type": "float", "readonly": false, "cmd": "hefill tolerance"},
-{"path": "badreadingminutes", "type": "float", "readonly": false, "cmd": "hefill badreadingminutes"},
-{"path": "tubecoolingminutes", "type": "float", "readonly": false, "cmd": "hefill tubecoolingminutes"},
-{"path": "vessellimit", "type": "float", "readonly": false, "cmd": "hefill vessellimit"},
-{"path": "vext", "type": "float"}]},
-
 "mf": {"base": "/mf", "params": [
 {"path": "", "type": "float", "readonly": false, "cmd": "run mf", "kids": 26},
 {"path": "persmode", "type": "int", "readonly": false, "cmd": "mf persmode"},
-{"path": "perswitch", "type": "int", "readonly": false, "cmd": "run mf"},
+{"path": "perswitch", "type": "int"},
 {"path": "nowait", "type": "int", "readonly": false, "cmd": "mf nowait"},
-{"path": "maxlimit", "type": "float", "readonly": false, "cmd": "run mf", "visibility": 3},
+{"path": "maxlimit", "type": "float", "visibility": 3},
 {"path": "limit", "type": "float", "readonly": false, "cmd": "mf limit"},
 {"path": "ramp", "type": "float", "readonly": false, "cmd": "mf ramp"},
 {"path": "perscurrent", "type": "float", "readonly": false, "cmd": "mf perscurrent"},
 {"path": "perslimit", "type": "float", "readonly": false, "cmd": "mf perslimit"},
 {"path": "perswait", "type": "int", "readonly": false, "cmd": "mf perswait"},
 {"path": "persdelay", "type": "int", "readonly": false, "cmd": "mf persdelay"},
-{"path": "current", "type": "float", "readonly": false, "cmd": "run mf"},
-{"path": "measured", "type": "float", "readonly": false, "cmd": "run mf"},
-{"path": "voltage", "type": "float", "readonly": false, "cmd": "run mf"},
-{"path": "lastfield", "type": "float", "readonly": false, "cmd": "run mf", "visibility": 3},
-{"path": "ampRamp", "type": "float", "readonly": false, "cmd": "run mf", "visibility": 3},
-{"path": "inductance", "type": "float", "readonly": false, "cmd": "run mf", "visibility": 3},
+{"path": "current", "type": "float"},
+{"path": "measured", "type": "float"},
+{"path": "voltage", "type": "float"},
+{"path": "lastfield", "type": "float", "visibility": 3},
+{"path": "ampRamp", "type": "float", "visibility": 3},
+{"path": "inductance", "type": "float", "visibility": 3},
 {"path": "trainedTo", "type": "float", "readonly": false, "cmd": "mf trainedTo"},
-{"path": "trainMode", "type": "int", "readonly": false, "cmd": "run mf"},
+{"path": "trainMode", "type": "int"},
 {"path": "external", "type": "int", "readonly": false, "cmd": "mf external"},
 {"path": "startScript", "type": "text", "readonly": false, "cmd": "mf startScript", "visibility": 3},
-{"path": "is_running", "type": "int", "readonly": false, "cmd": "run mf", "visibility": 3},
+{"path": "is_running", "type": "int", "readonly": false, "cmd": "mf is_running", "visibility": 3},
 {"path": "verbose", "type": "int", "readonly": false, "cmd": "mf verbose", "visibility": 3},
-{"path": "driver", "type": "text", "readonly": false, "cmd": "run mf", "visibility": 3},
-{"path": "creationCmd", "type": "text", "readonly": false, "cmd": "run mf", "visibility": 3},
-{"path": "targetValue", "type": "float", "readonly": false, "cmd": "run mf"},
+{"path": "driver", "type": "text", "visibility": 3},
+{"path": "creationCmd", "type": "text", "visibility": 3},
+{"path": "targetValue", "type": "float"},
 {"path": "status", "type": "text", "readonly": false, "cmd": "mf status", "visibility": 3}]},
 
 "lev": {"base": "/lev", "params": [
@@ -362,7 +363,22 @@
 {"path": "mode", "type": "enum", "enum": {"slow": 0, "fast (switches to slow automatically after filling)": 1}, "readonly": false, "cmd": "lev mode"},
 {"path": "n2", "type": "float"}]},
 
-"prep0": {"base": "/prep0", "params": [
-{"path": "", "type": "text", "readonly": false, "cmd": "prep0", "kids": 2},
-{"path": "send", "type": "text", "readonly": false, "cmd": "prep0 send", "visibility": 3},
-{"path": "status", "type": "text", "visibility": 3}]}}
+"table": {"base": "/table", "params": [
+{"path": "", "type": "none", "kids": 17},
+{"path": "send", "type": "text", "readonly": false, "cmd": "table send", "visibility": 3},
+{"path": "status", "type": "text", "visibility": 3},
+{"path": "fix_tt_set_prop", "type": "bool", "readonly": false, "cmd": "table fix_tt_set_prop"},
+{"path": "val_tt_set_prop", "type": "float"},
+{"path": "tbl_tt_set_prop", "type": "text", "readonly": false, "cmd": "table tbl_tt_set_prop", "description": "enter value pair separated with colon T1:par1 T2:par2 ..."},
+{"path": "fix_tt_set_integ", "type": "bool", "readonly": false, "cmd": "table fix_tt_set_integ"},
+{"path": "val_tt_set_integ", "type": "float"},
+{"path": "tbl_tt_set_integ", "type": "text", "readonly": false, "cmd": "table tbl_tt_set_integ", "description": "enter value pair separated with colon T1:par1 T2:par2 ..."},
+{"path": "fix_tt_dblctrl_int2", "type": "bool", "readonly": false, "cmd": "table fix_tt_dblctrl_int2"},
+{"path": "val_tt_dblctrl_int2", "type": "float"},
+{"path": "tbl_tt_dblctrl_int2", "type": "text", "readonly": false, "cmd": "table tbl_tt_dblctrl_int2", "description": "enter value pair separated with colon T1:par1 T2:par2 ..."},
+{"path": "fix_tt_dblctrl_prop_up", "type": "bool", "readonly": false, "cmd": "table fix_tt_dblctrl_prop_up"},
+{"path": "val_tt_dblctrl_prop_up", "type": "float"},
+{"path": "tbl_tt_dblctrl_prop_up", "type": "text", "readonly": false, "cmd": "table tbl_tt_dblctrl_prop_up", "description": "enter value pair separated with colon T1:par1 T2:par2 ..."},
+{"path": "fix_tt_dblctrl_prop_lo", "type": "bool", "readonly": false, "cmd": "table fix_tt_dblctrl_prop_lo"},
+{"path": "val_tt_dblctrl_prop_lo", "type": "float"},
+{"path": "tbl_tt_dblctrl_prop_lo", "type": "text", "readonly": false, "cmd": "table tbl_tt_dblctrl_prop_lo", "description": "enter value pair separated with colon T1:par1 T2:par2 ..."}]}}

frappy/addrparam.py

@@ -0,0 +1,75 @@
+# *****************************************************************************
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Module authors:
+#   Markus Zolliker <markus.zolliker@psi.ch>
+#
+# *****************************************************************************
+
+from frappy.core import Parameter, Property
+from frappy.datatypes import ValueType
+
+
+class AddrParam(Parameter):
+    """parameter with an address field
+
+    instead of implementing read_<param> and write_<param>, just implement
+    addressed_read and addressed_write.
+    """
+    addr = Property('address', ValueType())
+
+
+class AddrMixin:
+    """mixin for addressed parameters
+
+    in case a read_<param> and/or write_<param> are not implemented,
+    they are created with a call to addressed_read and/or addressed_write
+    """
+    def __init_subclass__(cls):
+        for aname, aobj in list(cls.__dict__.items()):
+            if isinstance(aobj, AddrParam):
+                methodname = f'read_{aname}'
+
+                if not hasattr(cls, methodname):
+                    def rfunc(self, pname=aname):
+                        return self.addressed_read(self.accessibles[pname])
+
+                    setattr(cls, methodname, rfunc)
+
+                if not aobj.readonly:
+                    methodname = f'write_{aname}'
+                    if not hasattr(cls, methodname):
+                        def wfunc(self, value, pname=aname):
+                            return self.addressed_write(self.accessibles[pname], value)
+
+                        setattr(cls, methodname, wfunc)
+        super().__init_subclass__()
+
+    def addressed_read(self, pobj):
+        """addressed read
+
+        :param pobj: the AddrParam
+        :return: the value read
+        """
+        return getattr(self, pobj.name)
+
+    def addressed_write(self, pobj, value):
+        """addressed write
+
+        :param pobj: the AddrParam
+        :param value: the value to be written
+        :return: the value written or None
+        """

frappy/params.py

@@ -233,13 +233,13 @@ class Parameter(Accessible):
         try:
             return instance.parameters[self.name].value
         except KeyError:
-            raise ProgrammingError(f'optional parameter {self.name} it is not implemented') from None
+            raise ProgrammingError(f'optional parameter {self.name} is not implemented') from None
 
     def __set__(self, obj, value):
         try:
             obj.announceUpdate(self.name, value)
         except KeyError:
-            raise ProgrammingError(f'optional parameter {self.name} it is not implemented') from None
+            raise ProgrammingError(f'optional parameter {self.name} is not implemented') from None
 
     def __set_name__(self, owner, name):
         self.name = name

frappy/playground.py

@@ -94,6 +94,7 @@ logger = MainLogger()
 
 class Playground(Server):
     def __init__(self, **kwds):  # pylint: disable=super-init-not-called
+        self.name = 'playground'
         for modname, cfg in kwds.items():
             cfg.setdefault('description', modname)
         self.log = logger.log

frappy/protocol/discovery.py

@@ -23,6 +23,9 @@
 import os
 import json
 import socket
+import select
+from time import monotonic
+from collections import namedtuple
 
 from frappy.lib import closeSocket
 from frappy.protocol.interface.tcp import format_address
@@ -32,6 +35,79 @@ UDP_PORT = 10767
 MAX_MESSAGE_LEN = 508
 
 
+Answer = namedtuple('Answer',
+                    'address, hostname, port, equipment_id, firmware, description')
+
+
+def decode(msg, addr):
+    msg = msg.decode('utf-8')
+    try:
+        data = json.loads(msg)
+    except Exception:
+        return None
+    if not isinstance(data, dict):
+        return None
+    if data.get('SECoP') != 'node':
+        return None
+    try:
+        eq_id = data['equipment_id']
+        fw = data['firmware']
+        desc = data['description']
+        port = data['port']
+    except KeyError:
+        return None
+    try:
+        hostname = socket.gethostbyaddr(addr[0])[0]
+    except Exception:
+        hostname = addr[0]
+    return Answer(addr[0], hostname, port, eq_id, fw, desc)
+
+
+def scan(max_wait=1.0):
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
+    # send a general broadcast
+    try:
+        s.sendto(json.dumps(dict(SECoP='discover')).encode('utf-8'),
+                 ('255.255.255.255', UDP_PORT))
+    except OSError as e:
+        print('could not send the broadcast:', e)
+        # we still keep listening for self-announcements
+    seen = set()
+    start = monotonic()
+    while monotonic() < start + max_wait:
+        res = select.select([s], [], [], 0.1)
+        if res[0]:
+            try:
+                msg, addr = s.recvfrom(1024)
+            except socket.error:  # pragma: no cover
+                continue
+            answer = decode(msg, addr)
+            if answer is None:
+                continue
+            if (answer.address, answer.equipment_id, answer.port) in seen:
+                continue
+            seen.add((answer.address, answer.equipment_id, answer.port))
+            yield answer
+
+
+def listen():
+    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    if os.name == 'nt':
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    else:
+        s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
+    s.bind(('0.0.0.0', UDP_PORT))
+    while True:
+        try:
+            msg, addr = s.recvfrom(1024)
+        except KeyboardInterrupt:
+            break
+        answer = decode(msg, addr)
+        if answer:
+            yield answer
+
+
 class UDPListener:
     def __init__(self, equipment_id, description, ifaces, logger, *,
                  startup_broadcast=True):

frappy_psi/dilution.py

@@ -0,0 +1,451 @@
+# *****************************************************************************
+#
+# This program is free software; you can redistribute it and/or modify it under
+# the terms of the GNU General Public License as published by the Free Software
+# Foundation; either version 2 of the License, or (at your option) any later
+# version.
+#
+# This program is distributed in the hope that it will be useful, but WITHOUT
+# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
+# details.
+#
+# You should have received a copy of the GNU General Public License along with
+# this program; if not, write to the Free Software Foundation, Inc.,
+# 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+#
+# Module authors:
+#  Andrea Plank <andrea.plank@psi.ch>
+#
+# *****************************************************************************
+
+import time
+from frappy.core import Readable, Drivable, Parameter, Attached, FloatRange, \
+    Command, IDLE, BUSY, WARN, ERROR, Property
+from frappy.datatypes import EnumType, IntRange, BoolType, StructOf, StringType
+from frappy.states import Retry, Finish, status_code, HasStates
+from frappy.lib.enum import Enum
+from frappy.errors import ImpossibleError, HardwareError
+from frappy.addrparam import AddrParam, AddrMixin
+from frappy.lib import formatStatusBits
+from frappy.persistent import PersistentMixin, PersistentParam
+from frappy_psi.logo import LogoMixin, DigitalActuator
+
+T = Enum(  # target states
+         off = 0,
+         sorbpumped = 2,
+         condense = 5,
+         remove = 7,
+         remove_and_sorbpump = 9,
+         remove_and_condense = 10,
+         manual = 11,
+         test = 12,
+         )
+
+V = Enum(T,  # value status inherits from target status
+         sorbpumping=1,
+         condensing=4,
+         circulating=6,
+         removing=8,
+         )
+
+
+class Dilution(HasStates, Drivable):
+    condenseline_pressure = Attached()
+    condense_valve = Attached()
+    dump_valve = Attached()
+
+    forepump = Attached()
+    compressor = Attached(mandatory=False)
+    turbopump = Attached(mandatory=False)
+    condenseline_valve = Attached()
+    circuitshort_valve = Attached()
+    still_pressure = Attached()
+    still_pressure_turbo = Attached(mandatory=False)
+
+    value = Parameter('current state', EnumType(T), default=0)
+    target = Parameter('target state', EnumType(T), default=0)
+
+    sorbpumped = Parameter('sorb pump done', BoolType(), default=False)
+    dump_pressure = Attached()
+
+    #ls372 = Attached()
+
+    condensing_p_low = Parameter('Lower limit for condenseline pressure',
+                                 FloatRange(unit='mbar'), readonly=False, default=1200)
+    condensing_p_high = Parameter('Higher limit for condenseline pressure',
+                                  FloatRange(unit='mbar'), readonly=False, default=1500)
+    dump_target = Parameter('low dump pressure limit indicating end of condensation phase',
+                            FloatRange(unit='mbar * min'), readonly=False, default=100)
+    pulse_factor = Parameter('factor for calculating V9 pulse length',
+                             FloatRange(unit='mbar'), readonly=False, default=20)
+    end_condense_pressure = Parameter('low condense pressure indicating end of condensation phase',
+                                      FloatRange(unit='mbar'), readonly=False, default=500)
+    turbo_condense_pressure = Parameter('low condense pressure before turbo start',
+                                        FloatRange(unit='mbar'), readonly=False, default=900)
+    safe_turbo_pressure = Parameter('low still pressure before turbo start',
+                                     FloatRange(unit='mbar'), readonly=False, default=10)
+    turbo_off_speed = Parameter('speed to wait for after switching turbo off',
+                                FloatRange(unit='Hz'), readonly=False, default=200)
+    end_remove_turbo_pressure = Parameter('pressure reached before end of remove (before turbo)',
+                                          FloatRange(unit='mbar'), readonly=False, default=1e-4)
+    end_remove_pressure = Parameter('pressure reached before end of remove (before fore pump)',
+                                         FloatRange(unit='mbar'), readonly=False, default=0.02)
+    st = StringType()
+    valve_set = StructOf(close=st, open=st, check_open=st, check_closed=st)
+    condense_valves = Parameter('valve to act when condensing', valve_set)
+    valves_after_remove = Parameter('valve to act after remove', valve_set)
+    check_after_remove = Parameter('check for manual valves after remove', valve_set)
+    _start_time = 0
+    init = True
+    _warn_manual_work = None
+
+    def write_target(self, target):
+        """
+        if (target == Targetstates.SORBPUMP):
+            if self.value == target:
+                return self.target
+            self.start_machine(self.sorbpump)
+            self.value = Targetstates.SORBPUMP
+            return self.value
+        """
+        self.log.info('start %s', target.name)
+        if self.value == target:
+            return target  # not sure if this is correct. may be a step wants to be repeated?
+
+        try:
+            self.start_machine(getattr(self, target.name, None))
+        except Exception as e:
+            self.log.exception('error')
+        self.log.info('started %s', target.name)
+
+        return target
+
+    """
+    @status_code(BUSY, 'sorbpump state')
+    def sorbpump(self, state):
+        #Heizt Tsorb auf und wartet ab.
+        if self.init:
+            self.ls372.write_target(40) #Setze Tsorb auf 40K
+            self.start_time = self.now
+            self.init = false
+            return Retry
+        
+        if self.now - self.start_time < 2400:  # 40 Minuten warten
+            return Retry
+                    
+        self.ls372.write_target(0)
+        
+        if self.ls372.read_value() > 10:  # Warten bis Tsorb unter 10K
+            return Retry
+        
+        return self.condense
+    """
+
+    @status_code(BUSY, 'start test')
+    def test(self, state):
+        """Nur zum testen, ob UI funktioniert"""
+        self.init = False
+        if state.init:
+            state._start = state.now
+        return self.wait_test
+
+    @status_code(BUSY)
+    def wait_test(self, state):
+        if state.now < state.start + 20:
+            return Retry
+        return self.final_status(IDLE, 'end test')
+
+    @status_code(BUSY)
+    def condense(self, state):
+        """Führt das Kondensationsverfahren durch."""
+        if state.init:
+            # self.value = V.condensing
+            pumpstate = self.forepump.read_value()
+            if self.turbopump:
+                self.turbopump.write_target(0)
+            self.handle_valves(**self.condense_valves)
+            self._start_time = state.now
+            if not pumpstate:  # wait longer for starting fore pump
+                self._start_time += 10
+            return Retry
+        if self.wait_valves():
+            return Retry
+        self.check_valve_result()
+        return self.condensing
+
+    @status_code(BUSY)
+    def condensing(self, state):
+        pdump = self.dump_pressure.value  # or self.dump_pressure.read_value() ?
+        pcond = self.condenseline_pressure.read_value()
+        v9 = self.condense_valve.read_value()
+        if v9:
+            if pcond > self.condensing_p_high:
+                self.log.info('shut V9')
+                self.condense_valve.write_target(0)
+        elif pcond < self.condensing_p_low and state.now > self._start_time + 5:
+            pulse_time = 60 * self.pulse_factor / pdump
+            if pulse_time > 59:
+                self.log.info('open V9')
+                self.condense_value.write_target(1)
+            else:
+                self.log.info('V9 pulse %r', pulse_time)
+                self._start_time = state.now
+                self.condense_valve.pulse(pulse_time)
+
+        if pdump > self.dump_target:
+            return Retry
+    
+        self.condense_valve.write_target(1)
+        
+        if self.turbopump is not None:
+            return self.condense_wait_before_turbo_start
+                
+        return self.wait_for_condense_line_pressure
+
+    @status_code(BUSY, 'condense (wait before starting turbo)')
+    def condense_wait_before_turbo_start(self, state):
+        if (self.condenseline_pressure.read_value() > self.turbo_condense_pressure
+                and self.still_pressure.read_value() > self.safe_turbo_pressure):
+            return Retry
+        self.turbopump.write_target(1)
+        return self.wait_for_condense_line_pressure
+
+    @status_code(BUSY)
+    def wait_for_condense_line_pressure(self, state):
+        if self.condenseline_pressure.read_value() > self.end_condense_pressure:
+            return Retry
+        self.condense_valve.write_target(0)
+        return self.circulate
+
+    @status_code(BUSY)
+    def circulate(self, state):
+        """Zirkuliert die Mischung."""
+        if state.init:
+            self.handle_valves(**self.condense_valves)
+        if self.wait_valves():
+            return Retry
+        self.check_valve_result()
+        self.value = V.circulating
+        return Finish
+
+    @status_code(BUSY, 'remove (wait for turbo shut down)')
+    def remove(self, state):
+        """Entfernt die Mischung."""
+            
+        if state.init:
+            self.handle_valves(**self.remove_valves)
+            if self.turbopump is not None:
+                self._start_time = state.now
+                self.turbopump.write_target(0)
+            return Retry
+
+        if self.turbopump is not None: 
+            # if (state.now - self._start_time < self.turbo_off_delay or
+            if self.turbopump.read_speed() > self.turbo_off_speed:
+                return Retry
+
+        self.circuitshort_valve.write_target(1)
+            
+        if self.turbopump is not None: 
+            return self.remove_wait_for_still_pressure
+           
+        return self.remove_endsequence
+    
+    @status_code(BUSY, 'remove (wait for still pressure low)')
+    def remove_wait_for_still_pressure(self, state):
+        if self.still_pressure.read_value() > self.safe_turbo_pressure:
+            return Retry
+        self.turbopump.write_target(1)
+        return self.remove_endsequence
+    
+    @status_code(BUSY)
+    def remove_endsequence(self, state):
+        if (self.still_pressure_turbo and
+                self.still_pressure_turbo.read_value() > self.end_remove_turbo_pressure):
+            return Retry
+        if self.still_pressure.read_value() > self.end_remove_pressure:
+            return Retry
+        self.circuitshort_valve.write_target(0)
+        self.dump_valve.write_target(0)
+
+        if self.compressor is not None:
+            self.compressor.write_target(0)
+        return self.close_valves_after_remove
+
+    @status_code(BUSY)
+    def close_valves_after_remove(self, state):
+        if state.init:
+            self.handle_valves(**self.valves_after_remove)
+        self.turbopump.write_target(0)
+        if self.wait_valves():
+            return Retry
+        self.check_valve_result()
+        self._warn_manual_work = True
+        return self.final_status(WARN, 'please check manual valves')
+
+    def read_status(self):
+        status = super().read_status()
+        if status[0] < ERROR and self._warn_manual_work:
+            try:
+                self.handle_valves(**self.check_after_remove)
+                self._warn_manual_work = False
+            except ImpossibleError:
+                return WARN, f'please close manual valves {",".join(self._valves_failed[False])}'
+        return status
+
+    def handle_valves(self, check_closed=(), check_open=(), close=(), open=()):
+        """check ot set given valves
+
+        raises ImpossibleError, when checks fails
+        """
+        self._valves_to_wait_for = {}
+        self._valves_failed = {True: [], False: []}
+        for flag, valves in enumerate([check_closed, check_open]):
+            for vname in valves.split():
+                if self.secNode.modules[vname].read_value() != flag:
+                    self._valves_failed[flag].append(vname)
+        for flag, valves in enumerate([close, open]):
+            for vname in valves.split():
+                valve = self.secNode.modules[vname]
+                valve.write_target(flag)
+                if valve.isBusy():
+                    self._valves_to_wait_for[vname] = (valve, flag)
+                elif valve.read_value() != flag:
+                    self._valves_failed[flag].append(vname)
+
+    def wait_valves(self):
+        busy = False
+        for vname, (valve, flag) in dict(self._valves_to_wait_for.items()):
+            statuscode = valve.read_status()[0]
+            if statuscode == BUSY:
+                busy = True
+                continue
+            if valve.read_value() == flag and statuscode == IDLE:
+                self._valves_to_wait_for.pop(vname)
+            else:
+                self._valves_failed[flag].append(vname)
+        return busy
+
+    def check_valve_result(self):
+        result = []
+        for flag, valves in self._valves_failed.items():
+            if valves:
+                result.append(f"{','.join(valves)} not {'open' if flag else 'closed'}")
+                if result:
+                    raise ImpossibleError(f"failed: {', '.join(result)}")
+
+
+class DIL5(Dilution):
+    condense_valves = {
+        'close': 'V2 V4 V9',
+        'check_closed': 'MV10 MV13 MV8 MVB MV2',
+        'check_open': 'MV1 MV3a MV3b GV1 MV9 MV11 MV12 MV14',
+        'open': 'V1 V5 compressor forepump',
+    }
+    remove_valves = {
+        'close': 'V1 V2 V9',
+        'check_closed': 'MV10 MV13 MV8 MVB MV2',
+        'check_open': 'MV1 MV3a MV3b GV1 MV9 MV11 MV12 MV14',
+        'open': 'V4 V5 compressor forepump',
+    }
+    valves_after_remove = {
+        'close': 'V1 V2 V4 V5 V9',
+        'check_closed': 'MV10 MV13 MV8 MVB MV2',
+        'open': '',
+        'check_open': '',
+    }
+    check_after_remove = {
+        'close': '',
+        'check_closed': 'MV1 MV9 MV10 MV11 MV12',
+        'open': '',
+        'check_open': '',
+    }
+
+
+class Interlock(LogoMixin, AddrMixin, Readable):
+    dil = Attached()
+    value = AddrParam('interlock state (bitmap)',
+                      IntRange(0, 31), addr='V414', readonly=False)
+    p5lim = AddrParam('safety limit on p5 to protect forepump',
+                      FloatRange(), value=1300, addr='VW16 VW18', readonly=False)
+    p2lim = AddrParam('safety limit on p2 to protect compressor',
+                      FloatRange(), value=4000, addr='VW8 VW10', readonly=False)
+    p1lim = AddrParam('safety limit to protect dump',
+                      FloatRange(), value=1300, addr='VW12 VW14', readonly=False)
+    p2max = AddrParam('limit pn p2 for mechanism to put mix to dump',
+                      FloatRange(), value=3000, addr='VW20 VW22', readonly=False)
+    conditions = { # starting with bit 1
+        'off (p5>p5lim)': {'forepump': False},
+        'off (p2>p2lim)': {'compressor': False},
+        'off (p1>p2lim)': {'forepump': False, 'compressor': False},
+        'open (p2>p2max)': {'V4': True}}
+
+    reset_param = Property('addr for reset', StringType(), default='V418.1')
+    _mismatch = None
+    _prefix = ''
+    _actuators = None
+
+    def initModule(self):
+        super().initModule()
+        self._actuators = {}
+        for actions in self.conditions.values():
+            for modname in actions:
+                if modname not in self._actuators:
+                    self._actuators[modname] = self.secNode.modules[modname]
+
+    def doPoll(self):
+        self.read_status()  # this includes read_value
+
+    def initialReads(self):
+        super().initialReads()
+        self.reset()
+
+    @Command
+    def reset(self):
+        """reset the interlock"""
+        self._prefix = ''
+        self.set_vm_value(self.reset_param, 1)
+        for actuator in self._actuators.values():
+            actuator.reset_fault()
+        if self.read_value() != 0:
+            raise HardwareError('can not clear status byte')
+        self.set_vm_value(self.reset_param, 0)
+        self.read_status()  # update status (this may trigger ERROR again)
+
+    def read_status(self):
+        if self._mismatch is None:  # init
+            self._mismatch = set()
+        bits = self.read_value()
+        if bits:
+            self.dil.stop()
+            keys = formatStatusBits(bits, self.conditions, 1)
+            statustext = []
+            for key in keys:
+                actions = self.conditions[key]
+                statustext.append(f"{' and '.join(actions)} {key}")
+                for module, value in actions.items():
+                    modobj = self._actuators[module]
+                    if modobj.target != value:
+                        self._prefix = 'switched '
+                        modobj.set_fault(value, f'switched {key}')
+            return ERROR, f"{self._prefix}{', '.join(statustext)}"
+        if self._mismatch:
+            return ERROR, f"mismatch on values for {', '.join(self._mismatch)}"
+        return IDLE, ''
+
+    def addressed_read(self, pobj):
+        values = [self.get_vm_value(a) for a in pobj.addr.split()]
+        if any(v != values[0] for v in values):
+            self._mismatch.add(pobj.name)
+            self.read_status()
+        else:
+            self._mismatch.discard(pobj.name)
+        return values[0]
+
+    def addressed_write(self, pobj, value):
+        for addr in pobj.addr.split():
+            self.set_vm_value(addr, value)
+        self.read_status()
+
+

frappy_psi/dilution_statemachine.py

@@ -1,320 +0,0 @@
-# *****************************************************************************
-#
-# This program is free software; you can redistribute it and/or modify it under
-# the terms of the GNU General Public License as published by the Free Software
-# Foundation; either version 2 of the License, or (at your option) any later
-# version.
-#
-# This program is distributed in the hope that it will be useful, but WITHOUT
-# ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-# FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more
-# details.
-#
-# You should have received a copy of the GNU General Public License along with
-# this program; if not, write to the Free Software Foundation, Inc.,
-# 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-#
-# Module authors:
-#  Andrea Plank <andrea.plank@psi.ch>
-#
-# *****************************************************************************
-
-from frappy.core import Drivable, Parameter, EnumType, Attached, FloatRange, \
-    Command, IDLE, BUSY, WARN, ERROR, Property
-from frappy.datatypes import StatusType, EnumType, ArrayOf, BoolType, IntRange
-from frappy.states import StateMachine, Retry, Finish, status_code, HasStates
-from frappy.lib.enum import Enum
-from frappy.errors import ImpossibleError
-import time
-Targetstates = Enum(
-    SORBPUMP = 0,
-    CONDENSE = 1,
-    CIRCULATE = 2,
-    REMOVE = 3,
-    MANUAL = 4,
-    TEST = 5,
-    STOP = 6,
-)
-
-class Dilution(HasStates, Drivable):
-    
-    condenseline_pressure = Attached()
-    condense_valve = Attached()
-    dump_valve = Attached()
-
-    circulate_pump = Attached()
-    compressor = Attached(mandatory=False)
-    turbopump = Attached(mandatory=False)
-    condenseline_valve = Attached()
-    circuitshort_valve = Attached()
-    still_pressure = Attached()
-    #ls372 = Attached()
-    V5 = Attached()  #Name noch ändern!!!
-    p1 = Attached()  #Name noch ändern!!!
-    
-    condensing_p_low  = Property('Lower limit for condenseline pressure', IntRange())
-    
-    condensing_p_high = Property('Higher limit for condenseline pressure', IntRange())
-    
-    target = Parameter('target state', EnumType(Targetstates))
-    
-    value =  Parameter('current state', EnumType(Targetstates))
-   
-    init = True
-    
-      
-    
-    def write_target(self, target):
-       """
-       if (target == Targetstates.SORBPUMP):
-           if self.value == target:
-               return self.target
-           self.start_machine(self.sorbpump) 
-           self.value = Targetstates.SORBPUMP
-           return self.value
-       """
-       if (target == Targetstates.TEST): 
-           self.value = Targetstates.TEST
-           self.init = True
-           self.start_machine(self.test)
-           
-       if (target == Targetstates.REMOVE): 
-           if self.value == target:
-               return target
-           if self.value != Teststates.CIRCULATE: 
-               self.final_status(WARN, "state before is not circulate")
-               return self.value
-           self.value = Targetstates.REMOVE
-           self.init = True
-           self.start_machine(self.remove)
-          
-       elif (target == Targetstates.CIRCULATE): 
-           if self.value == target:
-               return target
-           self.value = Targetstates.CIRCULATE
-           self.init = True
-           self.start_machine(self.circulate)
-       
-       elif (target == Targetstates.CONDENSE): 
-            if self.value == target:
-                return target
-            self.value = Targetstates.CONDENSE
-            self.init = True
-            self.start_machine(self.condense)
-
-       elif(target == Targetstates.MANUAL):
-           self.value = Targetstates.MANUAL
-           self.stop_machine()
-       
-       elif (target == Targetstates.STOP):
-           self.value = Targetstates.STOP
-           self.stop_machine()
-       return self.value
-
-    """
-    @status_code(BUSY, 'sorbpump state')
-    def sorbpump(self, state):
-        #Heizt Tsorb auf und wartet ab.
-        if self.init:
-            self.ls372.write_target(40) #Setze Tsorb auf 40K
-            self.start_time = self.now
-            self.init = false
-            return Retry
-        
-        if self.now - self.start_time < 2400:  # 40 Minuten warten
-            return Retry
-                    
-        self.ls372.write_target(0)
-        
-        if self.ls372.read_value() > 10:  # Warten bis Tsorb unter 10K
-            return Retry
-        
-        return self.condense
-    """
-
-    @status_code(BUSY, 'test  mode')
-    def test(self, state):
-        "Nur zum testen, ob UI funktioniert"
-        self.init = False
-        self.condense_valve.write_target(1)
-        time.sleep(1)
-        self.condense_valve.write_target(0)
-        self.dump_valve.write_target(1)
-        time.sleep(1)
-        self.dump_valve.write_target(0)
-        self.compressor.write_target(1)
-        return True
-
-    @status_code(BUSY)
-    def wait_for_condense_line_pressure(self, state):
-        if (self.condenseline_pressure.read_value > 500):
-            return Retry
-        self.condense_valve.write_target(0)   
-        return self.circulate
-        
-    def initialize_condense_valves(self, state):
-        raise NotImplementedError
-
-    @status_code(BUSY)
-    def condense(self, state):
-        """Führt das Kondensationsverfahren durch."""
-        if state.init:
-            self.initialize_condense_valves()
-            self.circuitshort_valve.write_target(0)
-            self.dump_valve.write_target(0)
-            self.condense_valve.write_target(0)
-            
-            self.condenseline_valve.write_target(1)
-            self.V5.write_target(1)
-            
-            if (self.compressor is not  None):
-                self.compressor.write_target(1)
-            
-            self.circulate_pump.write_target(1)
-            return Retry
-
-        if self.condenseline_pressure.read_value() < self.condensing_p_low:
-            self.condense_valve.write_target(1)
-        elif (self.condenseline_pressure.read_value() > self.condensing_p_high):  
-            self.condense_valve.write_target(0)
-            
-        if (self.p1.read_value() > 20):
-            return Retry
-    
-        self.condense_valve.write_target(1)
-        
-        if (self.turbopump is not None):
-            return self.condense_wait_before_turbo_start
-                
-        return self.wait_for_condense_line_pressure
-
-    @status_code(BUSY, 'condense (wait before starting turbo)')
-    def condense_wait_before_turbo_start(self, state):
-        if (self.condenseline_pressure.read_value() > 900 and self.still_pressure.read_value() > 10):
-            return Retry
-        else:
-            self.turbopump.write_target(1)
-            return self.wait_for_condense_line_pressure
-    
-    def initialize_circulation_valves(self, state):
-        raise NotImplementedError
-
-    @status_code(BUSY)
-    def circulate(self, state):
-        """Zirkuliert die Mischung."""
-        if state.init:
-           self.initialize_circulation_valves()
-        return Retry
-
-    @status_code(BUSY, 'remove (wait for turbo shut down)')
-    def remove(self, state):
-        """Entfernt die Mischung."""
-            
-        if state.init:
-            self.condenseline_valve.write_target(0)
-            self.dump_valve.write_target(1)
-            self.start_time = self.now
-            return Retry
-
-        if self.turbopump is not None: 
-            self.turbopump.write_target(0)
-                
-            if (self.now - self.start_time < 300 or self.turbopump.read_speed() > 60):
-                return Retry
-                
-        self.circuitshort_valve.write_target(1)
-            
-        if self.turbopump is not None: 
-            return self.remove_wait_for_still_pressure
-           
-        return remove_endsequence
-    
-    @status_code(BUSY, 'remove (wait for still pressure low)')
-    def remove_wait_for_still_pressure(self, state):
-        if self.still_pressure.read_value() > 20:
-            return Retry
-        self.turbopump.write_target(1)
-        return self.remove_endsequence
-    
-    @status_code(BUSY)
-    def remove_endsequence(self, state):
-        if self.still_pressure.read_value() > 1e-4:
-            return Retry
-        self.circuitshort_valve.write_target(0)
-        self.dump_valve.write_target(0)
-
-        if self.compressor is not None:
-            self.compressor.write_target(0)
-        self.remove_check_manual_valves()
-        self.remove_close_valves()
-        self.circulate_pump.write_target(0)
-        return Finish
-
-    def remove_check_manual_valves(self):
-        raise NotImplementedError
-
-    def remove_close_valves(self):
-        raise NotImplementedError
-
-
-class DIL5(Dilution):
-
-    MV10 = Attached()
-    MV13 = Attached()
-    MV8 = Attached()
-    MVB = Attached()
-    MV2 = Attached()
-    MV1 = Attached()
-    MV3a = Attached()
-    MV3b = Attached()
-    GV1 = Attached()
-    MV14 = Attached()
-    MV12 = Attached()
-    MV11 = Attached()
-    MV9 = Attached()
-    GV2 = Attached()    
-    
-    def earlyInit(self):
-        self.circulate_closed_valves = [self.condense_valve, self.dump_valve, self.circuitshort_valve, self.MV10, self.MV13, self.MV8, self.MVB, self.MV2]
-        self.circulate_open_valves = [self.MV11, self.circulate_pump, self.GV2, self.V5, self.compressor, self.condenseline_valve, self.MV1, self.MV3a, self.MV3b, self.GV1, self.MV9, self.MV14]
-        self.condense_closed_valves = [self.MV10, self.MV13, self.MV8, self.MVB, self.MV2]
-        self.condense_open_valves = [self.MV1, self.MV3a, self.MV3b, self.GV1, self.MV9, self.MV14, self.MV12, self.MV11]
-        self.remove_check_closed_valves = [self.MV11, self.MV9, self.MV12, self.MV1]
-        self.remove_closed_valves = [self.condenseline_valve, self.circuitshort_valve, self.V5, self.condense_valve, self.dump_valve]
-        super().earlyInit()
-        
-    def initialize_condense_valves(self):
-        #Anfangszustand der Ventile überprüfen
-        for valve in self.condense_open_valves:
-            if valve.read_value() == 0:
-                self.stop_machine()
-                raise ImpossibleError(f'valve {valve.name} must be open')
-        
-        for valve in self.condense_closed_valves:
-            if valve.read_value == 1:
-                self.stop_machine()
-                return  ImpossibleError(f'valve {valve.name} must be closed') 
-            
-    def initialize_circulation_valves(self):
-        #Anfangszustand der Ventile überprüfen
-        self.value = Targetstates.CIRCULATE
-        for valve in self.circulate_closed_valves:
-            if (valve.read_value() == 1):
-                self.stop_machine()
-                raise ImpossibleError(f'valve {valve.name} must be open')
-    
-        for valve in self.circulate_open_valves:
-            if (valve.read_value() == 0):
-                valve.write_target(1)     
-                self.stop_machine()
-                raise ImpossibleError(f'valve {valve.name} must be open')
-
-    def remove_check_manual_valves(self):
-        for valve in self.remove_check_closed_valves:
-            if (valve.read_value() == 1):
-                self.final_status(WARN, "manual valve {valve.name} must be closed")
-
-    def remove_close_valves(self):
-        for valve in self.remove_closed_valves:
-            valve.write_target(0)
-    

frappy_psi/logo.py

@@ -17,17 +17,17 @@
 # 
 #
 # *****************************************************************************
+import sys
+from time import monotonic
 from ast import literal_eval
 import snap7
-from frappy.core import Readable, Parameter, FloatRange, HasIO, StringIO, Property, StringType,IDLE, BUSY, WARN, ERROR,Writable,  Drivable, BoolType, IntRange, Communicator
-from frappy.errors import CommunicationFailedError
+from frappy.core import Attached, Command, Readable, Parameter, FloatRange, HasIO, Property, StringType, \
+    IDLE, BUSY, WARN, ERROR, Writable, Drivable, BoolType, IntRange, Communicator, StatusType
+from frappy.errors import CommunicationFailedError, ConfigError
 from threading import RLock
-import sys
-import time
+
 
 class IO(Communicator):
-
-    
     tcap_client = Property('tcap_client', IntRange())
     tsap_server = Property('tcap_server', IntRange())
     ip_address = Property('numeric ip address', StringType())
@@ -37,30 +37,28 @@ class IO(Communicator):
     def initModule(self):
         self._lock = RLock()
         super().initModule()
+
     def _init(self):
-        if not self._plc:
-            if time.time() < self._last_try + 10:
-                raise CommunicationFailedError('logo PLC not reachable')
-            self._plc = snap7.logo.Logo()
-            prev_stderr = sys.stdout
-            sys.stderr = open('/dev/null', 'w')  # suppress output of snap7
-            try:
-                self._plc.connect(self.ip_address, self.tcap_client, self.tsap_server)
-                if self._plc.get_connected():
-                    return
-            except Exception:
-                pass
-            finally:
-                sys.stderr = prev_stderr
-            self._plc = None
-            self._last_try = time.time()
-            raise CommunicationFailedError('logo PLC not reachable')  
-    
-    
-    
+        if monotonic() < self._last_try + 10:
+            raise CommunicationFailedError('logo PLC not reachable')
+        self._plc = snap7.logo.Logo()
+        sys.stderr = open('/dev/null', 'w')  # suppress output of snap7
+        try:
+            self._plc.connect(self.ip_address, self.tcap_client, self.tsap_server)
+            if self._plc.get_connected():
+                return
+        except Exception:
+            pass
+        finally:
+            sys.stderr = sys.stdout
+        self._plc = None
+        self._last_try = monotonic()
+        raise CommunicationFailedError('logo PLC not reachable')
+
     def communicate(self, cmd):
         with self._lock:
-            self._init()
+            if not self._plc:
+                self._init()
             cmd = cmd.split(maxsplit=1)
             if len(cmd) == 2:
                 self.comLog('> %s %s', cmd[0], cmd[1])
@@ -76,59 +74,207 @@ class IO(Communicator):
                     self.comLog('? %r', e)
                     self.log.exception('error in plc read')
                 self._plc = None
-                raise    
-    
-    
-    
-class Snap7Mixin(HasIO):
+                raise
+
+
+class LogoMixin(HasIO):
     ioclass = IO
-    
+
     def get_vm_value(self, vm_address):
         return literal_eval(self.io.communicate(vm_address))
 
-    
     def set_vm_value(self, vm_address, value):
-        return literal_eval(self.io.communicate(f'{vm_address} {value}'))
+        return literal_eval(self.io.communicate(f'{vm_address} {round(value)}'))
+
+
+class DigitalActuator(LogoMixin, Writable):
+    """output with or without feedback"""
+    output_addr = Property('VM address output', datatype=StringType(), default='')
+    target_addr = Property('VM address target', datatype=StringType(), default='')
+    feedback_addr = Property('VM address feedback', datatype=StringType(), default='')
+    target = Parameter('target', datatype=BoolType())
+    value = Parameter('feedback or output', datatype=BoolType())
+    _input = 'output'
+    _value_addr = None
+    _target_addr = None
+    _fault = None
+
+    def doPoll(self):
+        self.read_status()  # this calls also read_value
+
+    def checkProperties(self):
+        super().checkProperties()
+        if self.feedback_addr:
+            self._input = 'feedback'
+            self._value_addr = self.feedback_addr
+        else:
+            self._input = 'output'
+            self._value_addr = self.output_addr
+        self._target_addr = self.target_addr or self.output_addr
+        if self._target_addr and self._value_addr:
+            self._check_feedback = self.feedback_addr and self.output_addr
+            return
+        raise ConfigError('need either output_addr or both feedback_addr and target_addr')
+
+    def initialReads(self):
+        super().initialReads()
+        self.target = self.read_value()
+
+    def set_fault(self, value, statustext):
+        """on a fault condition, set target to value
+
+        and status to statustext
+        """
+        self.write_target(value)
+        self._fault = statustext
+        self.read_status()
+
+    def reset_fault(self):
+        """reset fault condition"""
+        self._fault = None
+        self.read_status()
 
-class Pressure(Snap7Mixin, Readable):
-    vm_address = Property('VM address', datatype= StringType())
-    value = Parameter('pressure', datatype = FloatRange(unit = 'mbar'))
-    
-    #pollinterval = 0.5
-    
     def read_value(self):
-        return self.get_vm_value(self.vm_address)
-    
+        return self.get_vm_value(self._value_addr)
+
+    def write_target(self, target):
+        self._fault = None
+        self.set_vm_value(self._target_addr, target)
+        value = self.read_value()
+        if value != target and self.feedback_addr:
+            # retry only if we have a feedback and the feedback did not change yet
+            for i in range(20):
+                if self.read_value() == target:
+                    self.log.debug('tried %d times', i)
+                    break
+                self.set_vm_value(self._target_addr, target)
+
+    def read_status(self):
+        if self._fault:
+            return ERROR, self._fault
+        value = self.read_value()
+        if value != self.target:
+            return ERROR, 'value and target do not match'
+        if self._check_feedback:
+            if value != self.get_vm_value(self._check_feedback):
+                return ERROR, f'feedback does not match output'
+        if self.feedback_addr:
+            return IDLE, 'feedback confirmed'
+        return IDLE, ''
+
+
+class DelayedActuator(DigitalActuator, Drivable):
+    delay_addr = Property('address of delay value', StringType())
+    _pulse_start = 0
+    _pulse_end = 0
+    _fault = None
+
+    def read_status(self):
+        if self._fault:
+            return ERROR, self._fault
+        value = self.read_value()
+        fberror = None
+        if self._pulse_start:
+            now = monotonic()
+            if now < self._pulse_start + 1:
+                value = 1
+            elif now < self._pulse_end - 1:
+                if not value:
+                    self._pulse_start = 0
+                    return WARN, f'{self._input} is not on during pulse - due to interlock?'
+            if value:
+                if now < self._pulse_end + 1:
+                    return BUSY, 'pulsing'
+                self.log.warn('pulse timeout')
+                self.set_vm_value(self._target_addr, 0)
+            self._pulse_start = 0
+            self.set_vm_value(self.delay_addr, 0)
+        elif self._check_feedback and value != self.get_vm_value(self._check_feedback):
+            fberror = ERROR, f'feedback does not match output'
+        if value != self.target:
+            return ERROR, 'value does not match target'
+        self.setFastPoll(False)
+        if fberror:
+            return fberror
+        if self.feedback_addr:
+            return IDLE, 'feedback confirmed'
+        return IDLE, ''
+
+    def write_target(self, value):
+        self._pulse_start = 0
+        if not value:
+            self.set_vm_value(self.delay_addr, 0)
+        return super().write_target(value)
+
+    @Command(argument=FloatRange(0))
+    def pulse(self, delay):
+        """open for delay seconds"""
+        self.set_vm_value(self.delay_addr, delay)
+        self.set_vm_value(self._target_addr, 1)
+        self.set_vm_value(self._target_addr, 0)
+        self.setFastPoll(True, 0.5)
+        self.status = BUSY, 'pulsing'
+        now = monotonic()
+        self._pulse_start = now
+        self._pulse_end = now + delay
+
+
+class Value(LogoMixin, Readable):
+    addr = Property('VM address', datatype=StringType())
+
+    def read_value(self):
+        return self.get_vm_value(self.addr)
+
     def read_status(self):
         return IDLE, ''
 
 
-class Airpressure(Snap7Mixin, Readable):
-    vm_address = Property('VM address', datatype= StringType())
-    value = Parameter('airpressure state', datatype = BoolType())
-    
-    #pollinterval = 0.5
-    
+class DigitalValue(Value):
+    value = Parameter('airpressure state', datatype=BoolType())
+
+
+# TODO: the following classes are too specific, they have to be moved
+
+class Pressure(LogoMixin, Drivable):
+    vm_address = Property('VM address', datatype=StringType())
+    value = Parameter('pressure', datatype=FloatRange(unit='mbar'))
+
+    # pollinterval = 0.5
+
+    def read_value(self):
+        return self.get_vm_value(self.vm_address)
+
+    def read_status(self):
+        return IDLE, ''
+
+
+class Airpressure(LogoMixin, Readable):
+    vm_address = Property('VM address', datatype=StringType())
+    value = Parameter('airpressure state', datatype=BoolType())
+
+    # pollinterval = 0.5
+
     def read_value(self):
         if (self.get_vm_value(self.vm_address) > 500):
             return 1
         else:
             return 0
-    
-    def read_status(self):
-        return IDLE, ''    
-    
-class Valve(Snap7Mixin, Drivable):
-    vm_address_input = Property('VM address input', datatype= StringType())
-    vm_address_output = Property('VM address output', datatype= StringType())
 
-    target = Parameter('Valve target', datatype = BoolType())
-    value = Parameter('Value state', datatype = BoolType())  
+    def read_status(self):
+        return IDLE, ''
+
+
+class Valve(LogoMixin, Drivable):
+    vm_address_input = Property('VM address input', datatype=StringType())
+    vm_address_output = Property('VM address output', datatype=StringType())
+
+    target = Parameter('Valve target', datatype=BoolType())
+    value = Parameter('Value state', datatype=BoolType())
     _remaining_tries = None
-    
+
     def read_value(self):
         return self.get_vm_value(self.vm_address_input)
-    
+
     def write_target(self, target):
         self.set_vm_value(self.vm_address_output, target)
         self._remaining_tries = 5
@@ -142,127 +288,126 @@ class Valve(Snap7Mixin, Drivable):
         if value != self.target:
             if self._remaining_tries is None:
                 self.target = self.read_value()
-                return IDLE,''
+                return IDLE, ''
             self._remaining_tries -= 1
             if self._remaining_tries < 0:
                 self.setFastPoll(False)
                 return ERROR, 'too many tries to switch'
-            self.set_vm_value(self.vm_address_output, self.target) 
+            self.set_vm_value(self.vm_address_output, self.target)
             return BUSY, 'switching (try again)'
         self.setFastPoll(False)
         return IDLE, ''
-    
-class FluidMachines(Snap7Mixin, Drivable):
-    vm_address_output = Property('VM address output', datatype= StringType())
 
-    target = Parameter('Valve target', datatype = BoolType())
-    value = Parameter('Value state', datatype = BoolType())    
-    
+
+class FluidMachines(LogoMixin, Drivable):
+    vm_address_output = Property('VM address output', datatype=StringType())
+
+    target = Parameter('Valve target', datatype=BoolType())
+    value = Parameter('Valve state', datatype=BoolType())
+
     def read_value(self):
         return self.get_vm_value(self.vm_address_output)
-    
+
     def write_target(self, target):
         return self.set_vm_value(self.vm_address_output, target)
-    
-    def read_status(self):
-        return IDLE, ''  
-    
-class TempSensor(Snap7Mixin, Readable):
-    vm_address = Property('VM address', datatype= StringType())
-    value = Parameter('resistance', datatype = FloatRange(unit = 'Ohm'))
-    
-    
-    def read_value(self):
-        return self.get_vm_value(self.vm_address)
-    
+
     def read_status(self):
         return IDLE, ''
 
-class HeaterParam(Snap7Mixin, Writable):
-    vm_address = Property('VM address output', datatype= StringType())
-    
-    target = Parameter('Heater target', datatype = IntRange())
-    
-    value = Parameter('Heater Param', datatype = IntRange())  
-    
+
+class TempSensor(LogoMixin, Readable):
+    vm_address = Property('VM address', datatype=StringType())
+    value = Parameter('resistance', datatype=FloatRange(unit='Ohm'))
+
     def read_value(self):
         return self.get_vm_value(self.vm_address)
-    
+
+    def read_status(self):
+        return IDLE, ''
+
+
+class HeaterParam(LogoMixin, Writable):
+    vm_address = Property('VM address output', datatype=StringType())
+
+    target = Parameter('Heater target', datatype=IntRange())
+
+    value = Parameter('Heater Param', datatype=IntRange())
+
+    def read_value(self):
+        return self.get_vm_value(self.vm_address)
+
     def write_target(self, target):
         return self.set_vm_value(self.vm_address, target)
-    
+
     def read_status(self):
-        return IDLE, ''      
-    
+        return IDLE, ''
 
-class controlHeater(Snap7Mixin, Writable):
-    
-    vm_address = Property('VM address on switch', datatype= StringType()) 
 
-    target = Parameter('Heater state', datatype = BoolType())
-    
-    value = Parameter('Heater state', datatype = BoolType())
-    
+class controlHeater(LogoMixin, Writable):
+    vm_address = Property('VM address on switch', datatype=StringType())
+
+    target = Parameter('Heater state', datatype=BoolType())
+
+    value = Parameter('Heater state', datatype=BoolType())
+
     def read_value(self):
         return self.get_vm_value(self.vm_address_on)
-    
+
     def write_target(self, target):
         if (target):
             return self.set_vm_value(self.vm_address, True)
         else:
             return self.set_vm_value(self.vm_address, False)
-    
+
     def read_status(self):
-        return IDLE, ''   
- 
-    
-class safetyfeatureState(Snap7Mixin, Readable):
-    
-    vm_address = Property('VM address state', datatype= StringType()) 
-    
-    value = Parameter('safety Feature state', datatype = BoolType())
-    
-    def read_value(self):
-        return self.get_vm_value(self.vm_address)
-    
-    def read_status(self):
-       return IDLE, '' 
+        return IDLE, ''
 
 
-class safetyfeatureParam(Snap7Mixin, Writable):
-    vm_address = Property('VM address output', datatype= StringType())
-    
-    target = Parameter('safety Feature target', datatype = IntRange())
-    
-    value = Parameter('safety Feature Param', datatype = IntRange())  
-    
+
+
+class safetyfeatureState(LogoMixin, Readable):
+    vm_address = Property('VM address state', datatype=StringType())
+
+    value = Parameter('safety Feature state', datatype=BoolType())
+
     def read_value(self):
         return self.get_vm_value(self.vm_address)
-    
+
+    def read_status(self):
+        return IDLE, ''
+
+
+class safetyfeatureParam(LogoMixin, Writable):
+    vm_address = Property('VM address output', datatype=StringType())
+
+    target = Parameter('safety Feature target', datatype=IntRange())
+
+    value = Parameter('safety Feature Param', datatype=IntRange())
+
+    def read_value(self):
+        return self.get_vm_value(self.vm_address)
+
     def write_target(self, target):
         return self.set_vm_value(self.vm_address, target)
-    
+
     def read_status(self):
-        return IDLE, ''    
+        return IDLE, ''
 
 
-class comparatorgekoppeltParam(Snap7Mixin, Writable):
-    vm_address_1 = Property('VM address output', datatype= StringType())
-    vm_address_2 = Property('VM address output', datatype= StringType())
-    
-    target = Parameter('safety Feature target', datatype = IntRange())
-    value = Parameter('safety Feature Param', datatype = IntRange())  
-    
+class comparatorgekoppeltParam(LogoMixin, Writable):
+    vm_address_1 = Property('VM address output', datatype=StringType())
+    vm_address_2 = Property('VM address output', datatype=StringType())
+
+    target = Parameter('safety Feature target', datatype=IntRange())
+    value = Parameter('safety Feature Param', datatype=IntRange())
+
     def read_value(self):
         return self.get_vm_value(self.vm_address_1)
-    
+
     def write_target(self, target):
         self.set_vm_value(self.vm_address_1, target)
         return self.set_vm_value(self.vm_address_2, target)
-    
-    def read_status(self):
-        return IDLE, ''    
- 
-    
 
-    
+    def read_status(self):
+        return IDLE, ''
+

frappy_psi/manual_valves.py

@@ -19,20 +19,14 @@
 #
 # *****************************************************************************
 
-from frappy.core import Readable, Parameter, FloatRange, BoolType, StringIO, HasIO, \
-    Property, StringType, Writable, IntRange, IDLE, BUSY, ERROR
-from frappy.errors import CommunicationFailedError
+from frappy.core import Parameter, BoolType, Writable
+from frappy.persistent import PersistentMixin, PersistentParam
 
-class ManualValve(Writable):
-    target = Parameter('Valve target', datatype = BoolType())
-    value = Parameter('Valve state', datatype = BoolType()) 
-    
-    def read_value(self):
-        return self.value
+
+class ManualValve(PersistentMixin, Writable):
+    target = PersistentParam('Valve target', datatype=BoolType(), persistent='auto')
+    value = Parameter('Valve state', datatype=BoolType())
     
     def write_target(self, target):
         self.value = target
         return self.value
-    
-    def read_status(self):
-        return IDLE, ''  

frappy_psi/pfeiffer_new.py

@@ -129,7 +129,7 @@ class PfeifferMixin(HasIO):
 
 
 class RPT200(PfeifferMixin, Readable):   
-    value = Parameter('Pressure', FloatRange(unit='hPa'))
+    value = Parameter('Pressure', FloatRange(unit='mbar'))
 
     def read_value(self):
         return self.data_request_u_expo_new(740)
@@ -143,11 +143,11 @@ class RPT200(PfeifferMixin, Readable):
 
 
 class TCP400(PfeifferMixin, Drivable, Readable):
-    speed= Parameter('Rotational speed', FloatRange(unit = 'Hz'), readonly = False)
+    speed= Parameter('Rotational speed', FloatRange(unit='Hz'), readonly = False)
     target= Parameter('Pumping station', BoolType())
-    current= Parameter('Current consumption', FloatRange(unit = '%'))
+    current= Parameter('Current consumption', FloatRange(unit='%'))
     value = Parameter('Turbopump state', BoolType())    
-    temp = Parameter('temp', FloatRange(unit = 'C'))
+    temp = Parameter('temp', FloatRange(unit='C'))
 
     def read_temp (self):
         return self.data_request_u_int(326)

frappy_psi/sea.py

@@ -213,7 +213,10 @@ class SeaClient(ProxyClient, Module):
             if not self._connected.is_set():
                 if self._connect_thread is None:
                     # let doPoll do the reconnect
-                    self.pollInfo.trigger(True)
+                    if self.pollInfo:  # is None in playground
+                        self.pollInfo.trigger(True)
+                    else:
+                        self.log.info('sea_main.doPoll() will connect')
                 raise ConnectionClosed('disconnected - reconnect is tried later')
             return self.raw_request(command, quiet)
 
@@ -557,10 +560,12 @@ class SeaModule(Module):
                 else:
                     cls.paramFilter(result, paramdesc)
             cfgdict.pop('rel_paths', None)
-            params = sum(result.values(), [])
+            params = []
+            for key, plist in result.items():
+                params.extend(plist)
             if is_running:  # take this at end
                 params.append(is_running)
-
+            # this needs some care in the configuration: the main value must be the first!
             main_value = params[0]
             if issubclass(cls, Readable):
                 if 'key' in main_value:
@@ -675,7 +680,7 @@ class SeaModule(Module):
             if key != 'status' and key is not None:
                 attributes['read_' + key] = rfunc
 
-            if not readonly:
+            if not readonly and key:
 
                 def wfunc(self, value, datatype=datatype, command=paramdesc['cmd']):
                     value = datatype.export_value(value)
@@ -711,9 +716,15 @@ class SeaModule(Module):
     @classmethod
     def paramFilter(cls, result, paramdesc):
         sub = paramdesc['path'].split('/', 1)
-        sublist = result.get(sub[0])
+        sublist = result.get(sub[0] or '.')
         if sublist is None:
-            return False
+            sublist = result.get('.')
+            if sublist is None:
+                return False
+            if len(sub) > 1 or 'kids' in paramdesc:
+                # avoid params from  subtrees
+                return False
+            # this is a top paramerter without kids
         sublist.append(paramdesc)
         return True