diff --git a/secop_psi/uniax.py b/secop_psi/uniax.py
index fa819f2..095c1d2 100644
--- a/secop_psi/uniax.py
+++ b/secop_psi/uniax.py
@@ -150,7 +150,7 @@ class Uniax(PersistentMixin, Drivable):
         setattr(self, name, pos)
         return pos
 
-    def do_find(self, state):
+    def find(self, state):
         """find active (engaged) range"""
         if state.init:
             state.prev_direction = 0  # find not yet started
@@ -160,13 +160,13 @@ class Uniax(PersistentMixin, Drivable):
                 self.log.info('motor stopped - substantial force detected: %g', self.value)
                 self.motor.stop()
             elif state.prev_direction == 0:
-                return self.do_adjust
+                return self.adjust
             if abs(self.value) > self.hysteresis:
                 self.set_zero_pos(self.value, self.motor.read_value())
-            return self.do_adjust
+            return self.adjust
         if self.value * direction < -self.hysteresis:
             state.force_before_free = self.value
-            return self.do_free
+            return self.free
         if self.motor_busy():
             if direction == -state.prev_direction:  # target direction changed
                 self.motor.stop()
@@ -192,7 +192,7 @@ class Uniax(PersistentMixin, Drivable):
                 self.drive_relative(zero_pos - self.motor.value)
                 return Retry()
             # we are already at or beyond zero_pos
-            return self.do_adjust
+            return self.adjust
         self.write_adjusting(False)
         self.status = 'BUSY', 'find %s side' % side_name
         self.log.info('one turn to %g', self.motor.value + direction * 360)
@@ -215,7 +215,7 @@ class Uniax(PersistentMixin, Drivable):
         self.motor.stop()
         self.write_adjusting(False)
 
-    def do_free(self, state):
+    def free(self, state):
         """free from high force at other end"""
         if state.init:
             state.free_way = None
@@ -227,7 +227,7 @@ class Uniax(PersistentMixin, Drivable):
             self.log.error(self.status[1])
             return None
         if abs(self.value) < self.hysteresis:
-            return self.do_find
+            return self.find
         if state.free_way is None:
             state.free_way = 0
             self.log.info('free from high force %g', self.value)
@@ -242,15 +242,15 @@ class Uniax(PersistentMixin, Drivable):
         self.drive_relative(direction * self.safe_step)
         return Retry()
 
-    def do_within_tolerance(self, state):
+    def within_tolerance(self, state):
         """within tolerance"""
         if self.motor_busy():
             return Retry()
         if abs(self.target - self.value) > self.tolerance:
-            return self.do_adjust
+            return self.adjust
         self.status = 'IDLE', 'within tolerance'
 
-    def do_adjust(self, state):
+    def adjust(self, state):
         """adjust force"""
         if state.init:
             state.prev_force = None
@@ -259,7 +259,7 @@ class Uniax(PersistentMixin, Drivable):
         if abs(self.target - self.value) < self.tolerance:
             self._in_cnt += 1
             if self._in_cnt >= 3:
-                return self.do_within_tolerance
+                return self.within_tolerance
         else:
             self._in_cnt = 0
         if state.prev_force is None:
@@ -279,7 +279,7 @@ class Uniax(PersistentMixin, Drivable):
                     if motor_dif > self.motor_play:
                         self.log.warning('adjusting failed - try to find zero pos')
                         self.set_zero_pos(self.target, None)
-                        return self.do_find
+                        return self.find
                 elif motor_dif > self.motor_max_play:
                     raise Error('force seems not to change substantially')
         force_step = (self.target - self.value) * self.pid_i
@@ -326,16 +326,16 @@ class Uniax(PersistentMixin, Drivable):
         if abs(target - self.value) <= self.tolerance:
             if not self.isBusy():
                 self.status = 'IDLE', 'already at target'
-            self._state.start(self.do_within_tolerance)
+            self._state.start(self.within_tolerance)
             return target
         self.log.info('new target %g', target)
         self._cnt_rderr = 0
         self._cnt_wrerr = 0
         self.status = 'BUSY', 'changed target'
         if self.value * math.copysign(1, target) > self.hysteresis:
-            self._state.start(self.do_adjust)
+            self._state.start(self.adjust)
         else:
-            self._state.start(self.do_find)
+            self._state.start(self.find)
         return target
 
     @Command()