Merge pull request #1101 from lnls-sirius/add-psioc-mode-idff

Add IDFFMode do FBP PS IOC

siriuspy/siriuspy/cycle/conn.py

@@ -596,6 +596,7 @@ class PSCyclerFBP(PSCycler):
         'PwrState-Sel', 'PwrState-Sts',
         'OpMode-Sel', 'OpMode-Sts',
         'SOFBMode-Sel', 'SOFBMode-Sts',
+        'IDFFMode-Sel', 'IDFFMode-Sts',
         'CycleType-Sel', 'CycleType-Sts',
         'CycleFreq-SP', 'CycleFreq-RB',
         'CycleAmpl-SP', 'CycleAmpl-RB',
@@ -611,19 +612,36 @@ class PSCyclerFBP(PSCycler):
 
     def set_sofbmode(self, state):
         """Set SOFBMode."""
-        state = _PSConst.OffOn.On if state == 'on' else _PSConst.OffOn.Off
+        state = _PSConst.OffOn.On if state.lower() == 'on' \
+            else _PSConst.OffOn.Off
         return _pv_conn_put(self['SOFBMode-Sel'], state)
 
     def check_sofbmode(self, state, wait=1):
         """Check if SOFBMode."""
-        state = _PSConst.OffOn.On if state == 'on' else _PSConst.OffOn.Off
+        state = _PSConst.OffOn.On if state.lower() == 'on' \
+            else _PSConst.OffOn.Off
         return _pv_timed_get(self['SOFBMode-Sts'], state, wait=wait)
 
+    def set_idffmode(self, state):
+        """Set IDFFMode."""
+        state = _PSConst.OffOn.On if state.lower() == 'on' \
+            else _PSConst.OffOn.Off
+        return _pv_conn_put(self['IDFFMode-Sel'], state)
+
+    def check_idffmode(self, state, wait=1):
+        """Check if IDFFMode."""
+        state = _PSConst.OffOn.On if state.lower() == 'on' \
+            else _PSConst.OffOn.Off
+        return _pv_timed_get(self['IDFFMode-Sts'], state, wait=wait)
+
     def prepare(self, mode):
         """Config power supply to cycling mode."""
         if not self.check_sofbmode('off', wait=1):
             return False
 
+        if not self.check_idffmode('off', wait=1):
+            return False
+
         if not self.check_opmode_slowref(wait=1):
             return False
 

siriuspy/siriuspy/cycle/main.py

@@ -235,6 +235,14 @@ def prepare_ps_sofbmode_size(self):
             prepare_ps_size += 2*len(self.trimnames)
         return prepare_ps_size
 
+    @property
+    def prepare_ps_idffmode_size(self):
+        """Prepare PS IDFFMode task size."""
+        prepare_ps_size = 2*(len(self.psnames)+1)
+        if self._include_sitrims:
+            prepare_ps_size += 2*len(self.trimnames)
+        return prepare_ps_size
+
     @property
     def prepare_ps_opmode_slowref_size(self):
         """Prepare PS OpMode SlowRef task size."""
@@ -313,6 +321,14 @@ def prepare_ps_sofbmode_max_duration(self):
             prepare_ps_max_duration += TIMEOUT_CHECK
         return prepare_ps_max_duration
 
+    @property
+    def prepare_ps_idffmode_max_duration(self):
+        """Prepare PS IDFFMode task maximum duration."""
+        prepare_ps_max_duration = 5 + TIMEOUT_CHECK
+        if self._include_sitrims:
+            prepare_ps_max_duration += TIMEOUT_CHECK
+        return prepare_ps_max_duration
+
     @property
     def prepare_ps_opmode_slowref_max_duration(self):
         """Prepare PS OpMode SlowRef task maximum duration."""
@@ -720,6 +736,60 @@ def check_pwrsupplies_sofbmode(self, psnames, timeout=TIMEOUT_CHECK):
             status &= False
         return status
 
+    def set_pwrsupplies_idffmode(self, psnames):
+        """Set power supplies IDFFMode."""
+        psnames = {
+            p for p in psnames if _PSSearch.conv_psname_2_psmodel(p) == 'FBP'}
+        if not psnames:
+            return
+
+        self._update_log('Turning off power supplies IDFFMode...')
+        for idx, psname in enumerate(psnames):
+            cycler = self._get_cycler(psname)
+            cycler.set_idffmode('off')
+            if idx % 5 == 4 or idx == len(psnames)-1:
+                self._update_log(
+                    'Sent IDFFMode preparation to {0}/{1}'.format(
+                        str(idx+1), str(len(psnames))))
+
+    def check_pwrsupplies_idffmode(self, psnames, timeout=TIMEOUT_CHECK):
+        """Check power supplies IDFFMode."""
+        psnames = {
+            p for p in psnames if _PSSearch.conv_psname_2_psmodel(p) == 'FBP'}
+        if not psnames:
+            return True
+
+        self._update_log('Checking power supplies IDFFMode...')
+        self._checks_result = {psn: False for psn in psnames}
+        msg = 'Successfully checked IDFFMode preparation for {}/' + \
+            str(len(psnames))
+        checked = 0
+        time = _time.time()
+        while _time.time() - time < timeout:
+            for psname in psnames:
+                if self._checks_result[psname]:
+                    continue
+                cycler = self._get_cycler(psname)
+                if cycler.check_idffmode('off', 0.05):
+                    self._checks_result[psname] = True
+                    checked = sum(self._checks_result.values())
+                    if not checked % 5:
+                        self._update_log(msg.format(str(checked)))
+                if _time.time() - time > timeout:
+                    break
+            if all(self._checks_result.values()):
+                break
+            _time.sleep(TIMEOUT_SLEEP)
+        self._update_log(msg.format(str(checked)))
+
+        status = True
+        for psname, sts in self._checks_result.items():
+            if sts:
+                continue
+            self._update_log(psname+' is in IDFFMode.', error=True)
+            status &= False
+        return status
+
     def set_pwrsupplies_slowref(self, psnames):
         """Set power supplies OpMode to SlowRef."""
         psnames = {p for p in psnames if 'LI' not in p}
@@ -867,6 +937,22 @@ def prepare_pwrsupplies_sofbmode(self):
             return
         self._update_log('Power supplies SOFBMode preparation finished!')
 
+    def prepare_pwrsupplies_idffmode(self):
+        """Prepare IDFFMode."""
+        psnames = self.psnames
+        timeout = TIMEOUT_CHECK
+        if self._include_sitrims:
+            self.create_trims_cyclers()
+            psnames.extend(self.trimnames)
+            timeout += TIMEOUT_CHECK
+
+        self.set_pwrsupplies_idffmode(psnames)
+        if not self.check_pwrsupplies_idffmode(psnames, timeout):
+            self._update_log(
+                'There are power supplies in IDFFMode.', error=True)
+            return
+        self._update_log('Power supplies IDFFMode preparation finished!')
+
     def prepare_pwrsupplies_opmode_slowref(self):
         """Prepare OpMode to slowref."""
         psnames = self.psnames

siriuspy/siriuspy/devices/pstesters.py

@@ -330,7 +330,7 @@ class TesterPSFBP(TesterPS):
     """PS FBP Tester."""
 
     PROPERTIES_DEFAULT = TesterPS.PROPERTIES_DEFAULT + \
-        ('SOFBMode-Sel', 'SOFBMode-Sts')
+        ('SOFBMode-Sel', 'SOFBMode-Sts', 'IDFFMode-Sel', 'IDFFMode-Sts')
 
     def set_sofbmode(self, state='on'):
         """Set SOFBMode."""
@@ -348,6 +348,22 @@ def check_sofbmode(self, state='on'):
             state = _PSC.OffOn.Off
         return self['SOFBMode-Sts'] == state
 
+    def set_idffmode(self, state='on'):
+        """Set IDFFMode."""
+        if state == 'on':
+            state = _PSC.OffOn.On
+        else:
+            state = _PSC.OffOn.Off
+        self['IDFFMode-Sel'] = state
+
+    def check_idffmode(self, state='on'):
+        """Check IDFFMode."""
+        if state == 'on':
+            state = _PSC.OffOn.On
+        else:
+            state = _PSC.OffOn.Off
+        return self['IDFFMode-Sts'] == state
+
 
 class TesterPSLinac(_TesterBase):
     """Linac PS tester."""

siriuspy/siriuspy/devices/pwrsupply.py

@@ -44,7 +44,8 @@ class _PSDev(_Device):
         'CycleEnbl-Mon',
     )
     _properties_fbp = _properties_magps + (
-        'SOFBMode-Sel', 'SOFBMode-Sts'
+        'SOFBMode-Sel', 'SOFBMode-Sts',
+        'IDFFMode-Sel', 'IDFFMode-Sts',
         )
     _properties_fc = (
         'AlarmsAmp-Mon', 'OpMode-Sel', 'OpMode-Sts',
@@ -1051,17 +1052,25 @@ def fofbacc_filter_gain(self):
     def fofbacc_filter_gain(self, value):
         self['FOFBAccFilterGain-SP'] = value
 
+
 class PowerSupplyFBP(PowerSupply):
     """FBP Power Supply Device."""
 
     SOFBMODE_SEL = _Const.DsblEnbl
     SOFBMODE_STS = _Const.DsblEnbl
+    IDFFMODE_SEL = _Const.DsblEnbl
+    IDFFMODE_STS = _Const.DsblEnbl
 
     @property
     def sofbmode(self):
         """SOFB mode status."""
         return self['SOFBMode-Sts']
 
+    @property
+    def idffmode(self):
+        """IDFF mode status."""
+        return self['IDFFMode-Sts']
+
     def cmd_sofbmode_enable(self, timeout=_PSDev._default_timeout):
         """Command to enable SOFBMode. Send command and wait."""
         return self._cmd_sofbmode(
@@ -1076,3 +1085,18 @@ def _cmd_sofbmode(self, timeout, state_sel, state_sts):
         self['SOFBMode-Sel'] = state_sel
         return self._wait(
             'SOFBMode-Sts', state_sts, timeout=timeout)
+
+    def cmd_idffmode_enable(self, timeout=_PSDev._default_timeout):
+        """Command to enable IDFFMode. Send command and wait."""
+        return self._cmd_idffmode(
+            timeout, self.IDFFMODE_SEL.Enbl, self.IDFFMODE_STS.Enbl)
+
+    def cmd_idffmode_disable(self, timeout=_PSDev._default_timeout):
+        """Command to disable IDFFMode. Send command and wait."""
+        return self._cmd_idffmode(
+            timeout, self.IDFFMODE_SEL.Dsbl, self.IDFFMODE_STS.Dsbl)
+
+    def _cmd_idffmode(self, timeout, state_sel, state_sts):
+        self['IDFFMode-Sel'] = state_sel
+        return self._wait(
+            'IDFFMode-Sts', state_sts, timeout=timeout)