diff --git a/frappy_psi/electromagnet.py b/frappy_psi/electromagnet.py
index b0c8981f..dee41370 100644
--- a/frappy_psi/electromagnet.py
+++ b/frappy_psi/electromagnet.py
@@ -86,7 +86,7 @@ class IO(BytesIO):
             pos, unit = self.get_string(pos, reply)
             pos, description = self.get_string(pos, reply)
             pos, reference = self.get_string(pos, reply)
-            self.log.info('pos %d', pos-16+2)
+            self.log.debug('pos %d', pos-16+2)
             if typ == 1:
                 # value = struct.unpack('>H', reply[pos:pos+2])[0]
                 value = None
@@ -116,7 +116,7 @@ class IO(BytesIO):
                 'byte_start': pos - length
             }
             result[name, description] = res
-            self.log.info(result)
+            self.log.debug(result)
         return result
 
 
@@ -143,8 +143,8 @@ class Magnet(HasIO, Drivable):
     main_switch = Parameter('main switch', datatype=BoolType(), readonly=False)
     emergency_stop = Parameter('state of emergency stop button', datatype=BoolType())
     collective_fault = Parameter('collecitve fault flag', datatype=BoolType())
-    sample_1_ready = Parameter('sample holder 1 in position', datatype=BoolType())
-    sample_2_ready = Parameter('sample holder 2 in position', datatype=BoolType())
+    holder_1_inserted = Parameter('sample holder 1 is inserted', datatype=BoolType())
+    holder_2_inserted = Parameter('sample holder 2 is inserted', datatype=BoolType())
     motor_stop = Parameter('sample holder motor stop flag', datatype=BoolType())
     current_timeout = Parameter('magnet current timeout flag', datatype=BoolType())
     polarity = Parameter('positive polarity', datatype=BoolType())
@@ -195,10 +195,10 @@ class Magnet(HasIO, Drivable):
     def read_main_switch(self):
         return self.extract_data(('main_switch', 'on'))
 
-    def read_sample_1_ready(self):
+    def read_holder_1_inserted(self):
         return self.extract_data(('sample_holder', 'Type1_in_position'))
 
-    def read_sample_2_ready(self):
+    def read_holder_2_inserted(self):
         return self.extract_data(('sample_holder', 'Type2_in_position'))
 
     def read_motor_stop(self):
@@ -228,39 +228,47 @@ class Magnet(HasIO, Drivable):
 
     def stop(self):
         """stop ramp"""
-        self._write_data(('setpoint', 'Magnetcurrent'), self.read_value())
+        val = self.read_value()
+        self._write_data(('setpoint', 'Magnetcurrent'), val)
+        self.target = val
 
     def doPoll(self):
         self._data = self.io.get_data()
         super().doPoll()
 
 
-class SamplePosition(Drivable):
+class SampleHolder(Drivable):
 
     motor = Attached()
 
-    target = Parameter('target sample position', datatype=IntRange(0,9), readonly=False)                              # TODO: set range
-    value = Parameter('sample position', datatype=IntRange(0,9))                                                      # TODO: set range
-    pos_offset = Parameter('position of first sample holder in motor units', datatype=FloatRange(), default=10.0, readonly=False)     # TODO: set default
-    pos_diff = Parameter('distance between two sample positions in motor units', datatype=FloatRange(), default=20.0, readonly=False) # TODO: set default
-    tolerance = Parameter('position tolerance', datatype=FloatRange(), default=0.1)                                   # TODO: set tolerance
-    _pos = None
+    target = Parameter('target sample holder position', datatype=IntRange(0,6), readonly=False)
+    value = Parameter('sample holder position', datatype=IntRange(0,6))
+    pos_offset = Parameter('position of first sample holder [mm]', datatype=FloatRange(unit='mm'), default=43)
+    pos_diff = Parameter('distance between two sample positions [mm]', datatype=FloatRange(unit='mm'), default=50)
+    tolerance = Parameter('position tolerance', datatype=FloatRange(unit='mm'), default=1)
+    _pos = None     # position of sample holder in units of target (where 1 unit is eq. to pos_diff)
 
     def read_value(self):
         if not self.motor.isBusy():
             val = self.motor.read_value()
-            self._pos = (val - self.pos_offset) / self.pos_diff    # convert motor units to sample position
+            self._pos = (val - self.pos_offset) / self.pos_diff    # convert mm to sample position
             return round(self._pos)
         return self.value
 
     def write_target(self, target):
         val = self.pos_offset + target * self.pos_diff
         reply = self.motor.write_target(val)
-        return reply
+        return target
 
     def read_status(self):
         if self.motor.isBusy():
             return BUSY, 'motor is running'
-        if abs(self._pos - self.value) > self.tolerance: 
+        if abs(self._pos - self.value) > (self.tolerance / self.pos_diff): 
             return ERROR, 'intermediate position'
         return IDLE, ''
+
+    def stop(self):
+        val = self.motor.read_value()
+        self.motor.write_target(val)
+        self._pos = (val - self.pos_offset) / self.pos_diff
+        self.read_status()