Adding support for direct Ethernet SCPI PSU Agent

requirements.txt

@@ -60,3 +60,17 @@ pyModbusTCP
 
 # testing
 -r requirements/testing.txt
+
+# Contributing
+pre-commit
+
+# Ensure compatability with Setuptools 71
+packaging>=24
+ordered-set>=3.1.1
+more_itertools>=8.8
+jaraco.text>=3.7
+importlib_resources>=5.10.2
+importlib_metadata>=6
+tomli>=2.0.1
+wheel>=0.43.0
+platformdirs>=2.6.2

socs/agents/scpi_psu/agent.py

@@ -5,18 +5,21 @@
 from ocs import ocs_agent, site_config
 from ocs.ocs_twisted import TimeoutLock
 
-from socs.agents.scpi_psu.drivers import PsuInterface
+from socs.agents.scpi_psu.drivers import PsuInterface, ScpiPsuInterface
 
 
 class ScpiPsuAgent:
-    def __init__(self, agent, ip_address, gpib_slot):
+    def __init__(self, agent, ip_address, gpib_slot, **kwargs):
         self.agent = agent
         self.log = agent.log
         self.lock = TimeoutLock()
 
         self.job = None
         self.ip_address = ip_address
         self.gpib_slot = gpib_slot
+        self.port = None
+        if ('port' in kwargs.keys()):
+            self.port = kwargs['port']
         self.monitor = False
 
         self.psu = None
@@ -30,7 +33,7 @@ def __init__(self, agent, ip_address, gpib_slot):
                                  agg_params=agg_params,
                                  buffer_time=0)
 
-    @ocs_agent.param('_')
+    # @ocs_agent.param('_')
     def init(self, session, params=None):
         """init()
 
@@ -41,14 +44,37 @@ def init(self, session, params=None):
             if not acquired:
                 return False, "Could not acquire lock"
 
-            try:
-                self.psu = PsuInterface(self.ip_address, self.gpib_slot)
-                self.idn = self.psu.identify()
-            except socket.timeout as e:
-                self.log.error(f"PSU timed out during connect: {e}")
-                return False, "Timeout"
+            if self.port is None:  # Use the old Prologix-based GPIB code
+                try:
+                    self.psu = PsuInterface(self.ip_address, self.gpib_slot)
+                    self.idn = self.psu.identify()
+                except socket.timeout as e:
+                    self.log.error(f"PSU timed out during connect: {e}")
+                    return False, "Timeout"
+            else:  # Use the new direct ethernet connection code
+                try:
+                    self.psu = ScpiPsuInterface(self.ip_address, self.gpib_slot, port=self.port)
+                    self.idn = self.psu.identify()
+                except socket.timeout as e:
+                    self.log.error(f"PSU timed out during connect: {e}")
+                    return False, "Timeout"
+                except ValueError as e:
+                    if (e.args[0].startswith('Model number')):
+                        self.log.error(f"PSU initialization error: {e}. Suggest appending {e.args[-1]} to the list of known model numbers in scpi_psu/drivers.py")
+                    else:
+                        self.log.error(f"PSU initialization resulted in unknown ValueError: {e}")
+                    return False, "ValueError"
+
             self.log.info("Connected to psu: {}".format(self.idn))
 
+        session.add_message('Initialized PSU.')
+        auto_acquire = params.get('auto_acquire', False)
+
+        if auto_acquire:
+            acq_params = None
+            if self.psu.numChannels == 1:
+                acq_params = {'channels': [1]}
+            self.agent.start('monitor_output', acq_params)
         return True, 'Initialized PSU.'
 
     @ocs_agent.param('wait', type=float, default=1)
@@ -68,6 +94,7 @@ def monitor_output(self, session, params=None):
                 Defaults to False.
 
         """
+        session.set_status('running')
         self.monitor = True
 
         while self.monitor:
@@ -80,8 +107,13 @@ def monitor_output(self, session, params=None):
                     }
 
                     for chan in params['channels']:
-                        data['data']["Voltage_{}".format(chan)] = self.psu.get_volt(chan)
-                        data['data']["Current_{}".format(chan)] = self.psu.get_curr(chan)
+                        if self.psu.get_output(chan):
+                            data['data']["Voltage_{}".format(chan)] = self.psu.get_volt(chan)
+                            data['data']["Current_{}".format(chan)] = self.psu.get_curr(chan)
+                        else:
+                            self.log.warn("Cannot measure output when output is disabled")
+                            self.monitor = False
+                            return False, "Cannot measure output when output is disabled"
 
                     # self.log.info(str(data))
                     # print(data)
@@ -104,6 +136,31 @@ def stop_monitoring(self, session, params=None):
         self.monitor = False
         return True, "Stopping current monitor"
 
+    @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
+    def get_voltage(self, session, params=None):
+        """get_voltage(channel)
+
+        **Task** - Measure and return the voltage of the power supply.
+
+        Parameters:
+            channel (int): Channel number (1, 2, or 3).
+
+        """
+        chan = params['channel']
+        with self.lock.acquire_timeout(1) as acquired:
+            if acquired:
+                data = {
+                    'timestamp': time.time(),
+                    'block_name': 'output',
+                    'data': {}
+                }
+
+                data['data']['Voltage_{}'.format(chan)] = self.psu.get_volt(chan)
+                session.data = data
+            else:
+                return False, "Could not acquire lock"
+        return True, 'Channel {} voltage measured'.format(chan)
+
     @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
     @ocs_agent.param('volts', type=float, check=lambda x: 0 <= x <= 30)
     def set_voltage(self, session, params=None):
@@ -125,6 +182,30 @@ def set_voltage(self, session, params=None):
 
         return True, 'Set channel {} voltage to {}'.format(params['channel'], params['volts'])
 
+    @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
+    def get_current(self, session, params=None):
+        """get_current(channel)
+
+        **Task** - Measure and return the current of the power supply.
+
+        Parameters:
+            channel (int): Channel number (1, 2, or 3).
+
+        """
+        chan = params['channel']
+        with self.lock.acquire_timeout(1) as acquired:
+            if acquired:
+                data = {
+                    'timestamp': time.time(),
+                    'block_name': 'output',
+                    'data': {}
+                }
+                data['data']['Current_{}'.format(chan)] = self.psu.get_curr(chan)
+                session.data = data
+            else:
+                return False, "Could not acquire lock"
+        return True, 'Channel {} current measured'.format(chan)
+
     @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
     @ocs_agent.param('current', type=float)
     def set_current(self, session, params=None):
@@ -145,6 +226,26 @@ def set_current(self, session, params=None):
 
         return True, 'Set channel {} current to {}'.format(params['channel'], params['current'])
 
+    @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
+    def get_output(self, session, params=None):
+        """get_output(channel)
+
+        **Task** - Check if channel ouput is enabled or disabled.
+
+        Parameters:
+            channel (int):
+        """
+        enabled = False
+        with self.lock.acquire_timeout(1) as acquired:
+            if acquired:
+                enabled = self.psu.get_output(params['channel'])
+            else:
+                return False, "Could not acquire lock."
+        if enabled:
+            return True, 'Channel {} output is currently enabled.'.format(params['channel'])
+        else:
+            return True, 'Channel {} output is currently disabled.'.format(params['channel'])
+
     @ocs_agent.param('channel', type=int, choices=[1, 2, 3])
     @ocs_agent.param('state', type=bool)
     def set_output(self, session, params=None):
@@ -178,6 +279,9 @@ def make_parser(parser=None):
     pgroup = parser.add_argument_group('Agent Options')
     pgroup.add_argument('--ip-address')
     pgroup.add_argument('--gpib-slot')
+    pgroup.add_argument('--port')
+    pgroup.add_argument('--mode', type=str, default='acq',
+                        choices=['init', 'acq'])
 
     return parser
 
@@ -188,15 +292,23 @@ def main(args=None):
                                   parser=parser,
                                   args=args)
 
+    init_params = False
+    if args.mode == 'acq':
+        init_params = {'auto_acquire': True}
     agent, runner = ocs_agent.init_site_agent(args)
 
-    p = ScpiPsuAgent(agent, args.ip_address, int(args.gpib_slot))
+    p = ScpiPsuAgent(agent, args.ip_address, int(args.gpib_slot), port=int(args.port))
 
-    agent.register_task('init', p.init)
+    agent.register_task('init', p.init, startup=init_params)
     agent.register_task('set_voltage', p.set_voltage)
     agent.register_task('set_current', p.set_current)
     agent.register_task('set_output', p.set_output)
 
+    # Need tasks for get_voltage, get_current, and get_output
+    agent.register_task('get_voltage', p.get_voltage)
+    agent.register_task('get_current', p.get_current)
+    agent.register_task('get_output', p.get_output)
+
     agent.register_process('monitor_output', p.monitor_output, p.stop_monitoring)
 
     runner.run(agent, auto_reconnect=True)

socs/agents/scpi_psu/drivers.py

@@ -1,6 +1,150 @@
 # Tucker Elleflot
+
+import socket
+import time
+
 from socs.common.prologix_interface import PrologixInterface
 
+# append new model strings as needed
+ONE_CHANNEL_MODELS = ['2280S-60-3', '2280S-32-6']
+THREE_CHANNEL_MODELS = ['2230G-30-1']
+
+
+class ScpiPsuInterface:
+    def __init__(self, ip_address, gpibAddr, port, **kwargs):
+        self.ip_address = ip_address
+        self.gpibAddr = gpibAddr
+        self.port = port
+        self.sock = None
+        self.model = None
+        self.numChannels = 0
+        self.conn_socket()
+        try:
+            self.configure()
+        except ValueError as err:
+            raise ValueError(err)
+        super().__init__(**kwargs)
+
+    def conn_socket(self):
+        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self.sock.connect((self.ip_address, self.port))
+        self.sock.settimeout(5)
+
+    def read(self):
+        return self.sock.recv(128).decode().strip()
+
+    def write(self, msg):
+        message = msg + '\n'
+        self.sock.sendall(message.encode())
+        time.sleep(0.1)  # to prevent flooding the connection
+
+    def identify(self):
+        self.write('*idn?')
+        return self.read()
+
+    def read_model(self):
+        idn_response = self.identify().split(',')[1]
+        if (idn_response.startswith('MODEL')):
+            return idn_response[6:]
+        else:
+            return idn_response
+
+    def configure(self):
+        self.model = self.read_model()
+        if (self.model in ONE_CHANNEL_MODELS):
+            self.numChannels = 1
+        if (self.model in THREE_CHANNEL_MODELS):
+            self.numChannels = 3
+        if (self.numChannels == 0):
+            raise ValueError('Model number not found in known device models', self.model)
+
+    def enable(self, ch):
+        '''
+        Enables output for channel (1,2,3) but does not turn it on.
+        Depending on state of power supply, it might need to be called
+        before the output is set.
+        '''
+        if (self.numChannels != 1):
+            self.set_chan(ch)
+            self.write('OUTP:ENAB ON')
+
+    def disable(self, ch):
+        '''
+        disabled output from a channel (1,2,3). once called, enable must be
+        called to turn on the channel again
+        '''
+        self.write('OUTP:ENAB OFF')
+
+    def set_chan(self, ch):
+        if (self.numChannels != 1):
+            self.write('inst:nsel ' + str(ch))
+
+    def set_output(self, ch, out):
+        '''
+        set status of power supply channel
+        ch - channel (1,2,3) to set status
+        out - ON: True|1|'ON' OFF: False|0|'OFF'
+
+        Calls enable to ensure a channel can be turned on. We might want to
+        make them separate (and let us use disable as a safety feature) but
+        for now I am thinking we just want to thing to turn on when we tell
+        it to turn on.
+        '''
+        self.set_chan(ch)
+        self.enable(ch)
+        if (self.numChannels != 1):
+            if isinstance(out, str):
+                self.write('CHAN:OUTP ' + out)
+            elif out:
+                self.write('CHAN:OUTP ON')
+            else:
+                self.write('CHAN:OUTP OFF')
+        else:
+            if isinstance(out, str):
+                self.write('OUTP ' + out)
+            elif out:
+                self.write('OUTP ON')
+            else:
+                self.write('OUTP OFF')
+
+    def get_output(self, ch):
+        '''
+        check if the output of a channel (1,2,3) is on (True) or off (False)
+        '''
+        self.set_chan(ch)
+        if (self.numChannels != 1):
+            self.write('CHAN:OUTP:STAT?')
+        else:
+            self.write('OUTP:STAT?')
+        out = bool(float(self.read()))
+        return out
+
+    def set_volt(self, ch, volt):
+        self.set_chan(ch)
+        self.write('volt ' + str(volt))
+
+    def set_curr(self, ch, curr):
+        self.set_chan(ch)
+        self.write('curr ' + str(curr))
+
+    def get_volt(self, ch):
+        self.set_chan(ch)
+        if (self.numChannels != 1):
+            self.write('MEAS:VOLT? CH' + str(ch))
+        else:
+            self.write('MEAS:VOLT?')
+        voltage = float(self.read().split(',')[1].strip('V'))
+        return voltage
+
+    def get_curr(self, ch):
+        self.set_chan(ch)
+        if (self.numChannels != 1):
+            self.write('MEAS:CURR? CH' + str(ch))
+        else:
+            self.write('MEAS:CURR?')
+        current = float(self.read().split(',')[0].strip('A'))
+        return current
+
 
 class PsuInterface(PrologixInterface):
     def __init__(self, ip_address, gpibAddr, verbose=False, **kwargs):