Merge branch 'wip' of gitlab.psi.ch-samenv:samenv/frappy into wip

cfg/stick/uniax.cfg

@@ -0,0 +1,9 @@
+[NODE]
+id = uniax stick
+class = protocol.router.Router
+description = router forwarding to linse-uniax apu
+node = linse-uniax:5000
+
+#[INTERFACE]
+#uri=tcp://5002
+

cfg/trinamic.cfg

@@ -18,7 +18,7 @@ io = drv_io
 standby_current=0.1
 maxcurrent=1.4
 acceleration=150.
-movelimit=360
+move_limit=360
 speed=40
 encoder_tolerance=3.6
 free_wheeling=0.1

cfg/uniax.cfg

@@ -10,6 +10,7 @@ description = force control
 class = secop_psi.uniax.Uniax
 motor = drv
 transducer = transducer
+force_offset = 15
 
 #[drv_io]
 #description = 
@@ -23,10 +24,10 @@ class = secop_psi.trinamic.Motor
 # io = drv_io
 uri = tcp://192.168.127.254:3002
 standby_current=0.1
-maxcurrent=0.2
+maxcurrent=0.3
 acceleration=150.
 move_limit=5
-safe_current=0.2
+safe_current=0.3
 speed=40
 encoder_tolerance=3.6
 free_wheeling=0.1
@@ -39,6 +40,7 @@ class = secop_psi.dpm.DPM3
 uri = tcp://192.168.127.254:3001
 digits = 2
 scale_factor = 0.0156
+offset = 15
 
 [res]
 description = temperature on uniax stick

secop/io.py

@@ -47,7 +47,7 @@ class SilentError(CommunicationFailedError):
 
 class HasIO(Module):
     """Mixin for modules using a communicator"""
-    io = Attached()
+    io = Attached(mandatory=False)
     uri = Property('uri for automatic creation of the attached communication module',
                    StringType(), default='')
 

secop_psi/FG_Lecroy_3000.py

@@ -18,83 +18,86 @@
 # Module authors:
 #   Daniel Margineda <daniel.margineda@psi.ch>
 # *****************************************************************************
-"""WAVE FUNCTION LECROY  XX: SIGNAL GENERATOR"""
+"""WAVE FUNCTION LECROY  XX: SIGNAL GENERATOR
+
+modifications not tested!
+"""
 
 from secop.core import Readable, Parameter, FloatRange, \
-    IntRange, BoolType, EnumType, Module, Property
+    IntRange, BoolType, EnumType, Module, Property, HasIO
 
 
-class Channel(Module):
+class Channel(HasIO, Module):
     channel = Property('choose channel to manipulate', IntRange(1, 2))
     freq = Parameter('frequency', FloatRange(1e-6, 20e6, unit='Hz'),
-                     poll=True, initwrite=True, default=1000)
+                     initwrite=True, default=1000)
     amp = Parameter('exc_volt_int', FloatRange(0.00, 5, unit='Vrms'),
-                    poll=True, readonly=False, initwrite=True, default=0.1)
+                    readonly=False, initwrite=True, default=0.1)
     offset = Parameter('offset_volt_int', FloatRange(0.0, 10, unit='V'),
-                       poll=True, readonly=False, initwrite=True, default=0.0)
+                       readonly=False, initwrite=True, default=0.0)
     wave = Parameter('type of wavefunction',
                      EnumType('WaveFunction', SINE=1, SQUARE=2, RAMP=3, PULSE=4, NOISE=5, ARB=6, DC=7),
-                     poll=True, readonly=False, default='SINE')
+                     readonly=False, default='SINE')
     phase = Parameter('signal phase', FloatRange(0, 360, unit='deg'),
-                      poll=True, readonly=False, initwrite=True, default=0)
+                      readonly=False, initwrite=True, default=0)
     enabled = Parameter('enable output channel', datatype=EnumType('OnOff', OFF=0, ON=1),
                         readonly=False, default='OFF')
     symm = Parameter('wavefunction symmetry', FloatRange(0, 100, unit=''),
-                     poll=True, readonly=False, default=0)
+                     readonly=False, default=0)
 
     def read_value(self):
-        return self.sendRecv('C%d:BSWV FRQ?' % self.channel)
+        return self.communicate('C%d:BSWV FRQ?' % self.channel)
 
     def write_target(self, value):
-        self.sendRecv('C%d:BSWV FRQ, %gHz' % (self.channel, value))
+        self.communicate('C%d:BSWV FRQ, %gHz' % (self.channel, value))
         return value
 
     # signal wavefunction parameter
     def read_wave(self):
-        return self.sendRecv('C%d:BSWV WVTP?' % self.channel)
+        return self.communicate('C%d:BSWV WVTP?' % self.channel)
 
     def write_wave(self, value):  # string value
-        self.sendRecv('C%d:BSWV WVTP, %s' % (self.channel, value.name))
+        self.communicate('C%d:BSWV WVTP, %s' % (self.channel, value.name))
         return value
 
     # signal amplitude parameter
     def read_amp(self):
-        return self.sendRecv('C%d:BSWV AMP?' % self.channel)
+        return self.communicate('C%d:BSWV AMP?' % self.channel)
 
     def write_amp(self, value):
-        self.sendRecv('C%d:BSWV AMP, %g' % (self.channel, value))
+        self.communicate('C%d:BSWV AMP, %g' % (self.channel, value))
         return value
 
     # offset value parameter
     def read_offset(self):
-        return self.sendRecv('C%d:BSWV OFST?' % self.channel)
+        return self.communicate('C%d:BSWV OFST?' % self.channel)
 
     def write_offset(self, value):
-        self.sendRecv('C%d:BSWV OFST %g' % (self.channel, value))
+        self.communicate('C%d:BSWV OFST %g' % (self.channel, value))
         return value
 
     # channel symmetry
     def read_symm(self):
-        return self.sendRecv('C%d:BSWV SYM?' % self.channel)
+        return self.communicate('C%d:BSWV SYM?' % self.channel)
 
     def write_symm(self, value):
-        self.sendRecv('C%d:BSWV SYM %g' % (self.channel, value))
+        self.communicate('C%d:BSWV SYM %g' % (self.channel, value))
         return value
 
     # wave phase parameter
     def read_phase(self):
-        return self.sendRecv('C%d:BSWV PHSE?' % self.channel)
+        return self.communicate('C%d:BSWV PHSE?' % self.channel)
 
     def write_phase(self, value):
-        self.sendRecv('C%d:BSWV PHSE %g' % (self.channel, value))
+        self.communicate('C%d:BSWV PHSE %g' % (self.channel, value))
         return value
 
     # dis/enable output channel
     def read_enabled(self):
-        return self.sendRecv('C%d: OUTP?' % self.channel)
+        return self.communicate('C%d: OUTP?' % self.channel)
 
     def write_enabled(self, value):
-        self.sendRecv('C%d: OUTP %s' % (self.channel, value.name))
+        self.communicate('C%d: OUTP %s' % (self.channel, value.name))
         return value
 
 

secop_psi/SR_7270.py

@@ -21,7 +21,7 @@
 """Signal Recovery SR7270: lockin amplifier for AC susceptibility"""
 
 from secop.core import Readable, Parameter, Command, FloatRange, TupleOf, \
-    HasIodev, StringIO, Attached, IntRange, BoolType, EnumType
+    HasIO, StringIO, Attached, IntRange, BoolType, EnumType
 
 
 class SR7270(StringIO):
@@ -33,7 +33,7 @@ class SR7270(StringIO):
         return reply + ';%d;%d' % tuple(status)
 
 
-class XY(HasIodev, Readable):
+class XY(HasIO, Readable):
     x = Attached()
     y = Attached()
     freq_arg = Attached()
@@ -46,29 +46,29 @@ class XY(HasIodev, Readable):
     value = Parameter('X, Y', datatype=TupleOf(FloatRange(unit='V'), FloatRange(unit='V')))
     freq = Parameter('exc_freq_int',
                      FloatRange(0.001, 250e3, unit='Hz'),
-                     poll=True, readonly=False, initwrite=True, default=1000)
+                     readonly=False, initwrite=True, default=1000)
     amp = Parameter('exc_volt_int',
                     FloatRange(0.00, 5, unit='Vrms'),
-                    poll=True, readonly=False, initwrite=True, default=0.1)
+                    readonly=False, initwrite=True, default=0.1)
-    range = Parameter('sensitivity value', FloatRange(0.00, 1, unit='V'), poll=True, default=1)
+    range = Parameter('sensitivity value', FloatRange(0.00, 1, unit='V'), default=1)
-    irange = Parameter('sensitivity index', IntRange(0, 27), poll=True, readonly=False, default=25)
+    irange = Parameter('sensitivity index', IntRange(0, 27), readonly=False, default=25)
     autorange = Parameter('autorange_on', EnumType('autorange', off=0, soft=1, hard=2),
                           readonly=False, default=0, initwrite=True)
-    tc = Parameter('time constant value', FloatRange(10e-6, 100, unit='s'), poll=True, default=0.1)
+    tc = Parameter('time constant value', FloatRange(10e-6, 100, unit='s'), default=0.1)
-    itc = Parameter('time constant index', IntRange(0, 30), poll=True, readonly=False, initwrite=True, default=14)
+    itc = Parameter('time constant index', IntRange(0, 30), readonly=False, initwrite=True, default=14)
     nm = Parameter('noise mode', BoolType(), readonly=False, default=0)
     phase = Parameter('Reference phase control', FloatRange(-360, 360, unit='deg'),
-                      poll=True, readonly=False, initwrite=True, default=0)
+                      readonly=False, initwrite=True, default=0)
     vmode = Parameter('Voltage input configuration', IntRange(0, 3), readonly=False, default=3),
     # dac = Parameter('output DAC channel value', datatype=TupleOf(IntRange(1, 4), FloatRange(0.0, 5000, unit='mV')),
-    #                 poll=True, readonly=False, initwrite=True, default=(3,0))
+    #                 readonly=False, initwrite=True, default=(3,0))
     dac = Parameter('output DAC channel value', FloatRange(-10000, 10000, unit='mV'),
-                    poll=True, readonly=False, initwrite=True, default=0)
+                    readonly=False, initwrite=True, default=0)
 
-    iodevClass = SR7270
+    ioClass = SR7270
 
     def comm(self, command):
-        reply, status, overload = self.sendRecv(command).split(';')
+        reply, status, overload = self.communicate(command).split(';')
         if overload != '0':
             self.status = self.Status.WARN, 'overload %s' % overload
         else:
@@ -200,10 +200,10 @@ class XY(HasIodev, Readable):
 
 
 class Comp(Readable):
-    pollerClass = None
+    enablePoll = False
     value = Parameter(datatype=FloatRange(unit='V'))
 
 
 class arg(Readable):
-    pollerClass = None
+    enablePoll = False
     value = Parameter(datatype=FloatRange(unit=''))

secop_psi/cryotel.py

@@ -22,7 +22,7 @@
 
 """driver for cryotel stirling cryocooler"""
 
-from secop.core import Command, EnumType, FloatRange, HasIodev, Parameter, Drivable, StringIO, StringType
+from secop.core import Command, EnumType, FloatRange, HasIO, Parameter, Drivable, StringIO, StringType
 from secop.errors import CommunicationFailedError, HardwareError
 
 
@@ -48,27 +48,27 @@ class CryotelIO(StringIO):
         return reply
 
 
-class Cryo(HasIodev, Drivable):
+class Cryo(HasIO, Drivable):
     value = Parameter('current temperature', FloatRange(unit='deg'))
     target = Parameter('target temperature', FloatRange(unit='deg'), readonly=False)
-    mode = Parameter('control mode', EnumType('mode', off=0, power=1, temperature=2), readonly=False, poll=True)
+    mode = Parameter('control mode', EnumType('mode', off=0, power=1, temperature=2), readonly=False)
-    power = Parameter('power', FloatRange(unit='W'), poll=True)
+    power = Parameter('power', FloatRange(unit='W'))
     setpower = Parameter('requested power', FloatRange(unit='W'), default=0)
     cool_power = Parameter('power for cooling', FloatRange(unit='W'), default=240, readonly=False)
     hold_power = Parameter('power for holding T', FloatRange(unit='W'), default=120, readonly=False)
     cool_threshold = Parameter('switch to cool_power once above this value', FloatRange(unit='K'), default=100, readonly=False)
     hold_threshold = Parameter('switch to hold_power once below this value', FloatRange(unit='K'), default=95, readonly=False)
 
-    iodevClass = CryotelIO
+    ioClass = CryotelIO
     cnt_inside = 0
 
     def get(self, cmd):
-        return float(self._iodev.communicate(cmd))
+        return float(self.communicate(cmd))
 
     def set(self, cmd, value, check=False):
         setcmd = '%s=%.2f' % (cmd, value)
-        self._iodev.communicate(setcmd)
+        self.communicate(setcmd)
-        reply = float(self._iodev.communicate(cmd))
+        reply = float(self.communicate(cmd))
         if check:
             if value != reply:
                 raise HardwareError('illegal reply from %s: %g' % (cmd, reply))

secop_psi/dpm.py

@@ -21,10 +21,8 @@
 # *****************************************************************************
 """transducer DPM3 read out"""
 
-import time
-
 from secop.core import Readable, Parameter, FloatRange, StringIO,\
-     HasIodev, IntRange, Done
+     HasIO, IntRange, Done
 
 
 class DPM3IO(StringIO):
@@ -47,22 +45,22 @@ def float2hex(value, digits):
     return '%06X' % intvalue
 
 
-class DPM3(HasIodev, Readable):
+class DPM3(HasIO, Readable):
     OFFSET = 0x8f
     SCALE = 0x8c
 
     MAGNITUDE = {'1':  1, '2':  10, '3':  100, '4':  1e3, '5':  1e4, '6':  1e5,
                  '9': -1, 'A': -10, 'B': -100, 'C': -1e3, 'D': -1e4, 'E': -1e5}
 
-    iodevClass = DPM3IO
+    ioClass = DPM3IO
 
     value = Parameter(datatype=FloatRange(unit='N'))
     digits = Parameter('number of digits for value', IntRange(0, 5), initwrite=True, readonly=False)
     # Note: we have to treat the units properly.
     # We got an output of 150 for 10N. The maximal force we want to deal with is 100N,
     #   thus a maximal output of 1500. 10=150/f
-    offset = Parameter('', FloatRange(-1e5, 1e5), readonly=False, poll=True)
+    offset = Parameter('', FloatRange(-1e5, 1e5), readonly=False)
-    scale_factor = Parameter('', FloatRange(-1e5, 1e5, unit='input_units/N'), readonly=False, poll=True)
+    scale_factor = Parameter('', FloatRange(-1e5, 1e5, unit='input_units/N'), readonly=False)
 
     def query(self, adr, value=None):
         if value is not None:
@@ -87,7 +85,7 @@ class DPM3(HasIodev, Readable):
         else:
             cmd = ""
         cmd = cmd + '*1G3%02X' % adr
-        hexvalue = self._iodev.communicate(cmd)
+        hexvalue = self.communicate(cmd)
         if adr == self.SCALE:
             mag = self.MAGNITUDE[hexvalue[0:1]]
             value = int(hexvalue[1:], 16)
@@ -97,7 +95,7 @@ class DPM3(HasIodev, Readable):
 
     def write_digits(self, value):
         # value defines the number of digits
-        back_value = self._iodev.communicate('*1F135%02X\r*1G135' % (value + 1))
+        back_value = self.communicate('*1F135%02X\r*1G135' % (value + 1))
         self.digits = int(back_value, 16) - 1
         # recalculate proper scale and offset
         self.write_scale_factor(self.scale_factor)
@@ -105,11 +103,11 @@ class DPM3(HasIodev, Readable):
         return Done
 
     def read_digits(self):
-        back_value = self._iodev.communicate('*1G135')
+        back_value = self.communicate('*1G135')
         return int(back_value,16) - 1
 
     def read_value(self):
-        return float(self._iodev.communicate('*1B1'))
+        return float(self.communicate('*1B1'))
 
     def read_offset(self):
         reply = self.query(self.OFFSET)

secop_psi/ls340res.py

@@ -24,7 +24,7 @@ import time
 
 from secop.datatypes import StringType, FloatRange
 from secop.modules import Parameter, Property, Readable
-from secop.io import HasIodev, StringIO
+from secop.io import HasIO, StringIO
 
 
 class LscIO(StringIO):
@@ -33,13 +33,13 @@ class LscIO(StringIO):
     wait_before = 0.05
 
 
-class ResChannel(HasIodev, Readable):
+class ResChannel(HasIO, Readable):
     """temperature channel on Lakeshore 340"""
 
-    iodevClass = LscIO
+    ioClass = LscIO
 
     value = Parameter(datatype=FloatRange(unit='Ohm'))
     channel = Property('the channel A,B,C or D', StringType())
 
     def read_value(self):
-        return self._iodev.communicate('SRDG?%s' % self.channel)
+        return float(self.communicate('SRDG?%s' % self.channel))

secop_psi/ppmsf.py

@@ -1,61 +0,0 @@
-#!/usr/bin/env python
-#  -*- coding: utf-8 -*-
-# *****************************************************************************
-# 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>
-# *****************************************************************************
-"""PPMS mf proxy"""
-
-import secop_psi.ppms
-from secop.core import Drivable, Enum, EnumType, FloatRange, Override, Parameter
-from secop.datatypes import StatusType
-from secop.proxy import proxy_class
-
-
-class Field(proxy_class(secop_psi.ppms.Field)):
-    """magnetic field"""
-
-    # pylint: disable=invalid-name
-    Status = Enum(Drivable.Status,
-        PREPARED = 150,
-        PREPARING = 340,
-        RAMPING = 370,
-        FINALIZING = 390,
-    )
-    # pylint: disable=invalid-name
-    PersistentMode = Enum('PersistentMode', persistent=0, driven=1)
-    ApproachMode = Enum('ApproachMode', linear=0, no_overshoot=1, oscillate=2)
-
-    remoteParameters = {
-        'value':
-            Override(datatype=FloatRange(-1, 1, unit='T'), poll=True),
-        'status':
-            Override(datatype=StatusType(Status), poll=True),
-        'target':
-            Override(datatype=FloatRange(-15, 15, unit='T'), poll=True),
-        'ramp':
-            Parameter('ramping speed', readonly=False,
-                      datatype=FloatRange(0.064, 1.19, unit='T/min'), poll=True),
-        'approachmode':
-            Parameter('how to approach target', readonly=False,
-                      datatype=EnumType(ApproachMode), poll=True),
-        'persistentmode':
-            Parameter('what to do after changing field', readonly=False,
-                      datatype=EnumType(PersistentMode), poll=True),
-        'pollinterval':
-            Override(visibility=3),
-    }

secop_psi/senis.py

@@ -32,20 +32,20 @@ from secop.core import Attached, BoolType, FloatRange, IntRange, \
 
 
 class Temperature(Readable):
-    pollerClass = None
+    enablePoll = False
 
     value = Parameter(datatype=FloatRange(unit='degC'))
 
 
 class Bcomp(Readable):
-    pollerClass = None
+    enablePoll = False
 
     value = Parameter(datatype=FloatRange(unit='T'))
     range = Parameter('working range', FloatRange(unit='T'), default=0)
 
 
 class Raw(Readable):
-    pollerClass = None
+    enablePoll = False
 
     value = Parameter(datatype=FloatRange())
 
@@ -62,7 +62,7 @@ class TeslameterBase(Readable):
     y = Attached()
     z = Attached()
 
-    value = Parameter('B vector', poll=True,
+    value = Parameter('B vector',
                      datatype=TupleOf(FloatRange(unit='T'), FloatRange(unit='T'), FloatRange(unit='T')))
     usb = Parameter('usb device', StringType(), readonly=False)
     enabled = Parameter('enable data acq', datatype=BoolType(), readonly=False, default=True)
@@ -152,7 +152,7 @@ class Teslameter3MH6(TeslameterBase):
 
     range = Parameter('range or 0 for autorange', FloatRange(0, 20, unit='T'), readonly=False, default=0)
     rate = Parameter('sampling rate', datatype=FloatRange(10, 15000, unit='Hz'),
-                     readonly=False, poll=True)
+                     readonly=False)
     avtime = Parameter('data acquisition time', FloatRange(), default=0)
 
     SAMPLING_RATES = {0xe0: 15000, 0xd0: 7500, 0xc0: 3750, 0xb0: 2000, 0xa1: 1000,

secop_psi/testtemp.py

@@ -22,17 +22,17 @@
 
 from secop.datatypes import FloatRange, IntRange, StringType
 from secop.modules import Drivable, Parameter, Readable
-from secop.io import HasIodev
+from secop.io import HasIO
 
 Status = Drivable.Status
 
 
-class TempLoop(HasIodev, Drivable):
+class TempLoop(HasIO, Drivable):
     """temperature channel on Lakeshore 336"""
 
-    value = Parameter(datatype=FloatRange(unit='K'), default=0, poll=True)
+    value = Parameter(datatype=FloatRange(unit='K'), default=0)
     status = Parameter(poll=False)
-    target = Parameter(datatype=FloatRange(1.0, 402.0, unit='K'), default=1.3, poll=True)
+    target = Parameter(datatype=FloatRange(1.0, 402.0, unit='K'), default=1.3)
     tolerance = Parameter('the tolerance', FloatRange(-400, 400), default=1, readonly=False)
     pollinterval = Parameter(visibility=3)
     channel = Parameter('the Lakeshore channel', datatype=StringType(), export=False)

secop_psi/uniax.py

@@ -32,7 +32,7 @@ class Uniax(PersistentMixin, Drivable):
     value = Parameter(unit='N')
     motor = Attached()
     transducer = Attached()
-    limit = Parameter('abs limit of force', FloatRange(0, 150, unit='N'), readonly=False, default=150)
+    limit = Parameter('abs limit of force', FloatRange(0, 190, unit='N'), readonly=False, default=150)
     tolerance = Parameter('force tolerance', FloatRange(0, 10, unit='N'), readonly=False, default=0.1)
     slope = PersistentParam('spring constant', FloatRange(unit='deg/N'), readonly=False,
                             default=0.5, persistent='auto')
@@ -41,7 +41,7 @@ class Uniax(PersistentMixin, Drivable):
     current_step = Parameter('', FloatRange(unit='deg'), default=0)
     force_offset = PersistentParam('transducer offset', FloatRange(unit='N'), readonly=False, default=0,
                                    initwrite=True, persistent='auto')
-    hysteresis = PersistentParam('force hysteresis', FloatRange(0, 150, unit='N'), readonly=False, default=5,
+    hysteresis = PersistentParam('force hysteresis', FloatRange(0, 190, unit='N'), readonly=False, default=5,
                                  persistent='auto')
     adjusting = Parameter('', BoolType(), readonly=False, default=False, initwrite=True)
     adjusting_current = PersistentParam('current when adjusting force', FloatRange(0, 2.8, unit='A'), readonly=False,
@@ -71,19 +71,20 @@ class Uniax(PersistentMixin, Drivable):
     _find_target = 0
 
     def earlyInit(self):
+        super().earlyInit()
         self._zero_pos_tol = {}
         self._action = self.idle
 
     def drive_relative(self, step, ntry=3):
         """drive relative, try 3 times"""
-        mot = self._motor
+        mot = self.motor
         mot.read_value()  # make sure motor value is fresh
         if self.adjusting and abs(step) > self.safe_step:
             step = math.copysign(self.safe_step, step)
         self.current_step = step
         for _ in range(ntry):
             try:
-                self._mot_target = self._motor.write_target(mot.value + step)
+                self._mot_target = self.motor.write_target(mot.value + step)
                 self._cnt_wrerr = max(0, self._cnt_wrerr - 1)
                 return True
             except Exception as e:
@@ -92,7 +93,7 @@ class Uniax(PersistentMixin, Drivable):
                 if self._cnt_wrerr > 5:
                     raise
                 self.log.warning('motor reset')
-                self._motor.reset()
+                self.motor.reset()
         return False
 
     def reset_filter(self, now=0.0):
@@ -100,7 +101,7 @@ class Uniax(PersistentMixin, Drivable):
         self._filter_start = now or time.time()
 
     def motor_busy(self):
-        mot = self._motor
+        mot = self.motor
         if mot.isBusy():
             if mot.target != self._mot_target:
                 self.action = self.idle
@@ -162,12 +163,12 @@ class Uniax(PersistentMixin, Drivable):
         if force * sign > self.hysteresis or force * sign > target * sign:
             if self.motor_busy():
                 self.log.info('motor stopped - substantial force detected: %g', force)
-                self._motor.stop()
+                self.motor.stop()
             elif self.init_action():
                 self.next_action(self.adjust)
                 return
             if abs(force) > self.hysteresis:
-                self.set_zero_pos(force, self._motor.read_value())
+                self.set_zero_pos(force, self.motor.read_value())
             self.next_action(self.adjust)
             return
         if force * sign < -self.hysteresis:
@@ -176,7 +177,7 @@ class Uniax(PersistentMixin, Drivable):
             return
         if self.motor_busy():
             if sign * self._find_target < 0:  # target sign changed
-                self._motor.stop()
+                self.motor.stop()
                 self.next_action(self.find)  # restart find
                 return
         else:
@@ -184,26 +185,26 @@ class Uniax(PersistentMixin, Drivable):
             zero_pos = self.zero_pos(target)
             side_name = 'positive' if target > 0 else 'negative'
             if not self.init_action():
-                if abs(self._motor.target - self._motor.value) > self._motor.tolerance:
+                if abs(self.motor.target - self.motor.value) > self.motor.tolerance:
                     # no success on last find try, try short and strong step
                     self.write_adjusting(True)
-                    self.log.info('one step to %g', self._motor.value + self.safe_step)
+                    self.log.info('one step to %g', self.motor.value + self.safe_step)
                     self.drive_relative(sign * self.safe_step)
                     return
             if zero_pos is not None:
                 self.status = 'BUSY', 'change to %s side' % side_name
-                zero_pos += sign * (self.hysteresis * self.slope - self._motor.tolerance)
+                zero_pos += sign * (self.hysteresis * self.slope - self.motor.tolerance)
-                if (self._motor.value - zero_pos) * sign < -self._motor.tolerance:
+                if (self.motor.value - zero_pos) * sign < -self.motor.tolerance:
                     self.write_adjusting(False)
                     self.log.info('change side to %g', zero_pos)
-                    self.drive_relative(zero_pos - self._motor.value)
+                    self.drive_relative(zero_pos - self.motor.value)
                     return
                 # we are already at or beyond zero_pos
                 self.next_action(self.adjust)
                 return
             self.write_adjusting(False)
             self.status = 'BUSY', 'find %s side' % side_name
-            self.log.info('one turn to %g', self._motor.value + sign * 360)
+            self.log.info('one turn to %g', self.motor.value + sign * 360)
             self.drive_relative(sign * 360)
 
     def free(self, force, target):
@@ -293,7 +294,7 @@ class Uniax(PersistentMixin, Drivable):
 
     def read_value(self):
         try:
-            force = self._transducer.read_value()
+            force = self.transducer.read_value()
             self._cnt_rderr = max(0, self._cnt_rderr - 1)
         except Exception as e:
             self._cnt_rderr += 1
@@ -323,7 +324,7 @@ class Uniax(PersistentMixin, Drivable):
             self.log.error(self.status[1])
             return Done
         if self.zero_pos(force) is None and abs(force) > self.hysteresis and self._filtered:
-            self.set_zero_pos(force, self._motor.read_value())
+            self.set_zero_pos(force, self.motor.read_value())
         self._action(self.value, self.target)
         return Done
 
@@ -351,18 +352,18 @@ class Uniax(PersistentMixin, Drivable):
     @Command()
     def stop(self):
         self._action = self.idle
-        if self._motor.isBusy():
+        if self.motor.isBusy():
             self.log.info('stop motor')
-            self._motor.stop()
+            self.motor.stop()
         self.next_action(self.idle)
 
     def write_force_offset(self, value):
         self.force_offset = value
-        self._transducer.write_offset(value)
+        self.transducer.write_offset(value)
         return Done
 
     def write_adjusting(self, value):
-        mot = self._motor
+        mot = self.motor
         if value:
             mot_current = self.adjusting_current
             mot.write_move_limit(self.safe_step)