diff --git a/frappy_psi/cryoltd.py b/frappy_psi/cryoltd.py
index 98bc6f1f..cb7d75f7 100644
--- a/frappy_psi/cryoltd.py
+++ b/frappy_psi/cryoltd.py
@@ -29,7 +29,8 @@ import re
 import time
 from math import copysign
 from frappy.core import HasIO, StringIO, Readable, Drivable, Parameter, Command, \
-    Module, Property, Attached, Enum, IDLE, BUSY, ERROR
+    Module, Property, Attached, Enum, IDLE, BUSY, ERROR, nopoll, PersistentParam, \
+    PersistentMixin
 from frappy.errors import ConfigError, BadValueError, HardwareError
 from frappy.datatypes import FloatRange, StringType, EnumType, StructOf
 from frappy.states import HasStates, status_code, Retry
@@ -41,7 +42,10 @@ VALUE_UNIT = re.compile(r'([-0-9.E]*\d|inf)([A-Za-z/%]*)$')
 
 def as_float(value):
     """converts string (with unit) to float"""
-    return float(VALUE_UNIT.match(value).group(1))
+    try:
+        return float(VALUE_UNIT.match(value).group(1))
+    except Exception:
+        raise ValueError(f'can not convert {value!r} to float with unit')
 
 
 BOOL_MAP = {'TRUE': True, 'FALSE': False}
@@ -113,6 +117,8 @@ class Main(HasIO, Module):
                     # ignore multiline values
                     # if needed, we may collect here and treat with a special key
                 continue
+            if not value:
+                continue  # silently ignore empty values
             obj, pname, cvt = self.params_map.get(key, missing)
             if obj:
                 if not hasattr(obj, pname):
@@ -268,7 +274,7 @@ class BaseMagfield(HasStates, Channel):
     def cvt_error(self, text):
         if text != self._last_error:
             self._last_error = text
-            self.log.error(text)
+            self.log.error(f'{self.channel}_Error: {text}')
             return text
         return self._error_text
 
@@ -287,6 +293,11 @@ class BaseMagfield(HasStates, Channel):
     ramp = Parameter()
     target = Parameter()
 
+    @nopoll
+    def read_setpoint(self):
+        self.main.doPoll()
+        return self.setpoint
+
     def write_ramp(self, ramp):
         if self._rate_units != 'A/s':
             self.sendcmd('Set:<CH>:ChangeRateUnits A/s')
@@ -323,9 +334,18 @@ class BaseMagfield(HasStates, Channel):
         return super().start_field_change
 
     def start_ramp_to_target(self, sm):
-        self.start_sweep(sm.target)
+        try:
+            self.start_sweep(sm.target)
+            self.log.info('start_ramp_to_target: start_sweep done')
+        except Exception as e:
+            self.log.error('start_ramp_to_target: start_sweep failed with %r', e)
+            raise
         return self.ramp_to_target  # -> stabilize_field
 
+    # def start_ramp_to_target(self, sm):
+    #     self.start_sweep(sm.target)
+    #     return self.ramp_to_target  # -> stabilize_field
+
     def stabilize_field(self, sm):
         if self._ready_text == 'FALSE':
             # wait for overshoot/degauss/cycle
@@ -432,7 +452,7 @@ class BaseMagfield(HasStates, Channel):
         self._error_text = ''
 
 
-class MainField(BaseMagfield, magfield.Magfield):
+class MainField(PersistentMixin, BaseMagfield, magfield.Magfield):
     checked_modules = None
 
     def earlyInit(self):
@@ -456,12 +476,13 @@ class MainField(BaseMagfield, magfield.Magfield):
         super().check_limits(value)
         self.check_combined(None, 0, value)
 
-    mode = Parameter(datatype=EnumType(PersistencyMode))
+    mode = PersistentParam(datatype=EnumType(PersistencyMode))
 
     def write_mode(self, mode):
         self.reset_error()
         super().write_mode(mode)  # updates mode
-        return mode
+        self.mode = mode
+        self.saveParameters()
 
     @status_code('PREPARING')
     def start_ramp_to_field(self, sm):
diff --git a/frappy_psi/magfield.py b/frappy_psi/magfield.py
index bb4199b0..e50981eb 100644
--- a/frappy_psi/magfield.py
+++ b/frappy_psi/magfield.py
@@ -112,7 +112,7 @@ class SimpleMagfield(HasStates, Drivable):
         last = self._last_target
         if last is None:
             try:
-                last = self.setpoint  # get read back from HW, if available
+                last = self.read_setpoint()  # get read back from HW, if available
             except Exception:
                 pass
         if last is None or abs(last - self.value) > self.tolerance: