diff --git a/secop_psi/uniax.py b/secop_psi/uniax.py
index bd97ab7..cc3ff5c 100644
--- a/secop_psi/uniax.py
+++ b/secop_psi/uniax.py
@@ -76,14 +76,14 @@ class Uniax(PersistentMixin, Drivable):
 
     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 +92,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 +100,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 +162,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 +176,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 +184,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)
-                if (self._motor.value - zero_pos) * sign < -self._motor.tolerance:
+                zero_pos += sign * (self.hysteresis * self.slope - 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 +293,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 +323,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 +351,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)