diff --git a/secop_psi/magfield.py b/secop_psi/magfield.py
index cdf04c7..5e55270 100644
--- a/secop_psi/magfield.py
+++ b/secop_psi/magfield.py
@@ -84,7 +84,7 @@ class Magfield(HasLimits, Drivable):
     _state = None
     _init = True
     _super_sw_check = False
-    _target_changed = False
+    _last_target = None
     switch_time = None
 
     def doPoll(self):
@@ -114,7 +114,6 @@ class Magfield(HasLimits, Drivable):
 
     def write_target(self, target):
         self.check_limits(target)
-        self._target_changed = target != self.target
         self.target = target
         if not self._state.is_active:
             # as long as the state machine is still running, it takes care of changing targets
@@ -147,7 +146,8 @@ class Magfield(HasLimits, Drivable):
     def start_field_change(self, state):
         self.setFastPoll(True, 1.0)
         self.status = Status.PREPARING, 'changed target field'
-        if abs(self.target - self.persistent_field) <= self.tolerance:  # short cut
+        if (self.target == self._last_target and
+                abs(self.target - self.persistent_field) <= self.tolerance):  # short cut
             return self.check_switch_off
         return self.start_ramp_to_field
 
@@ -160,7 +160,8 @@ class Magfield(HasLimits, Drivable):
 
     def ramp_to_field(self, state):
         """ramping, wait for current at persistent field"""
-        if abs(self.target - self.persistent_field) <= self.tolerance:  # short cut
+        if (self.target == self._last_target and
+                abs(self.target - self.persistent_field) <= self.tolerance):  # short cut
             return self.check_switch_off
         if abs(self.current - self.persistent_field) > self.tolerance:
             if state.init:
@@ -186,11 +187,11 @@ class Magfield(HasLimits, Drivable):
 
     def start_switch_on(self, state):
         """switch heater on"""
-        self._super_sw_check = False
         if self.switch_heater != 0:
             self.status = Status.PREPARING, 'wait for heater on'
         else:
             self.status = Status.PREPARING, 'turn switch heater on'
+        self._super_sw_check = False
         self.write_switch_heater(True)
         if not self._super_sw_check:
             raise ProgrammingError('missing super call in write_switch_heater')
@@ -198,11 +199,12 @@ class Magfield(HasLimits, Drivable):
 
     def switch_on(self, state):
         """wait for switch heater open"""
-        if abs(self.target - self.persistent_field) <= self.tolerance:  # short cut
+        if (self.target == self._last_target and
+                abs(self.target - self.persistent_field) <= self.tolerance):  # short cut
             return self.check_switch_off
         if state.now - self.switch_time < self.wait_switch_on:
             return Retry()
-        self._target_changed = False
+        self._last_target = self.target
         return self.start_ramp_to_target
 
     def start_ramp_to_target(self, state):
@@ -214,8 +216,8 @@ class Magfield(HasLimits, Drivable):
 
     def ramp_to_target(self, state):
         """ramp field to target"""
-        if self._target_changed:
-            self._target_changed = False
+        if self.target != self._last_target:  # target was changed
+            self._last_target = self.target
             return self.start_ramp_to_target
         self.persistent_field = self.value
         # Remarks: assume there is a ramp limiting feature
@@ -228,8 +230,8 @@ class Magfield(HasLimits, Drivable):
 
     def stabilize_field(self, state):
         """stabilize field"""
-        if self._target_changed:
-            self._target_changed = False
+        if self.target != self._last_target:  # target was changed
+            self._last_target = self.target
             return self.start_ramp_to_target
         self.persistent_field = self.value
         if state.now - state.stabilize_start < self.wait_stable_field:
@@ -250,16 +252,15 @@ class Magfield(HasLimits, Drivable):
             self.status = Status.FINALIZING, 'turn switch heater off'
         else:
             self.status = Status.FINALIZING, 'wait for heater off'
-        self._super_sw_check = False
         self.write_switch_heater(False)
-        if not self._super_sw_check:
-            raise ProgrammingError('missing super call in write_switch_heater')
+        # no check for super call needed here (would have been detected in start_switch_on)
         return self.switch_off
 
     def switch_off(self, state):
         """wait for switch heater closed"""
-        if self._target_changed or self.mode == Mode.DRIVEN:
+        if self.target != self._last_target or self.mode == Mode.DRIVEN:
             # target or mode has changed -> redo
+            self._last_target = None
             return self.start_switch_on
         self.persistent_field = self.value
         if state.now - self.switch_time < self.wait_switch_off:
@@ -269,15 +270,16 @@ class Magfield(HasLimits, Drivable):
     def start_ramp_to_zero(self, state):
         """start ramping current to target
 
-        initiate ramp to zero (with corresponding ramp rate
+        initiate ramp to zero (with corresponding ramp rate)
         should return ramp_to_zero
         """
         raise NotImplementedError
 
     def ramp_to_zero(self, state):
         """ramp field to zero"""
-        if self._target_changed or self.mode == Mode.DRIVEN:
+        if self.target != self._last_target or self.mode == Mode.DRIVEN:
             # target or mode has changed -> redo
+            self._last_target = None
             return self.start_field_change
         if abs(self.current) > self.tolerance:
             if state.init: