YorkUphysLabV2 2.0.0__py3-none-any.whl

YorkUphysLab/Actuator/Actuator.py

@@ -0,0 +1,133 @@
+import nidaqmx
+from YorkUphysLab.GwINSTEK import GPD3303D as PSU
+import time
+
+
+class Actuator:
+    def __init__(self, _DAQ_mame, _psu, emul=False, _max_time= 12) -> None:
+        self.sdaq = _DAQ_mame
+        self.psu = _psu
+        self.max_time = _max_time
+        self.max_pos = 100 # mm
+        self.actuator_on = False
+        self.emul = emul
+        self.current_pos = 0
+        if self.emul:
+            self.emul_str = "[Emulation mode]:"
+        else:
+            self.emul_str = ""
+
+    
+    def set_position(self, pos):
+        if not self.actuator_on:
+            print(f'{self.emul_str} Actuator is switched OFF. Switch it ON first!')
+            return None
+        
+        # when PSU connection is closed by another device:
+        if not self.psu.is_connected():
+            print("PSU Connection is not established. Switching off other devise sharing same PSU might have caused this. Switch on this decive and try again.")
+            return None
+        
+        
+        if 0 <= pos <= self.max_pos:
+            Vctrl = -0.00004*pos*pos + 0.0528*pos + 0.1
+        else:
+            print(f'{self.emul_str} position ({pos} mm) out of range. use 0-{self.max_pos} mm')
+            return None
+
+        #if self.actuator_on:
+        self.current_pos = self.get_position()
+        required_time = abs(pos - self.current_pos)*self.max_time/self.max_pos + 1
+            
+        if not self.emul:
+            with nidaqmx.Task() as task:
+                task.ao_channels.add_ao_voltage_chan(f'{self.sdaq}/ao0','mychannel',0,5)
+                task.write(Vctrl)
+                task.stop()
+        
+        time.sleep(required_time)
+        print(f'{self.emul_str} position set to {pos} mm')
+        self.current_pos = pos    
+
+    def get_position(self):
+        if not self.actuator_on:
+            print(f'{self.emul_str} Actuator is switched OFF! Switch it ON first!')
+            return None
+        
+        # when PSU connection is closed by another device:
+        if not self.psu.is_connected():
+            print("PSU Connection is not established. Switching off other devise sharing same PSU might have caused this. Switch on this decive and try again.")
+            return None
+        
+        #if self.actuator_on:
+        if not self.emul:
+            with nidaqmx.Task() as task:
+                task.ai_channels.add_ai_voltage_chan(f'{self.sdaq}/ai0')
+                Vadc = task.read()
+            pos = 55.33223 - 31.31889*Vadc + 0.5730428*Vadc*Vadc
+        else:
+            pos = self.current_pos
+        
+        return round(pos,1)
+
+    def switch_on(self):
+        try:
+            if not self.psu.is_connected():
+                self.psu.connect()
+
+            if self.psu.is_connected():
+                self.psu.set_voltage(1, 12)
+                self.psu.set_current(1, 0.5)
+                self.psu.enable_output()
+                self.actuator_on = True
+                message = f'{self.emul_str} Actuator switched ON.'
+            else:
+                message = f'{self.emul_str} PSU Connection is not established.'
+
+        except Exception as e:
+            message = f'{self.emul_str} An error occurred: {str(e)}'
+        
+        print(message)
+        
+        return self.actuator_on
+    
+    def switch_off(self):
+        self.psu.disable_output()
+        #self.psu.close_connection()
+        print(f'{self.emul_str} Actuator switched OFF.')
+        self.actuator_on = False
+        return True
+#==============================================================================    
+
+# how to use this class
+if __name__ == "__main__":
+    
+    DAQ_mame = 'SDAQ-25'
+    # create power-supply and actuator objects
+    psu = PSU.GPD3303D(emul=False)
+    actuator = Actuator(DAQ_mame, psu, emul=False)
+    
+    #psu.connect()
+    actuator.switch_on()
+    actuator.set_position(100)
+    print(f'position moved to = {actuator.get_position()} mm')
+        
+    time.sleep(2)
+    
+    #actuator.switch_off()
+
+    '''
+        SenorDAQ terminals:
+        1:  p0.0
+        2:  p0.1
+        3:  p0.2
+        4:  p0.3
+        5:  GND
+        6:  +5V
+        7:  PFIO
+        8:  GND
+        9:  AO0  ----> 
+        10: GND
+        11: AI0  ----> 
+        12: AI1
+    '''

YorkUphysLab/GwINSTEK/AFG2000.py

@@ -0,0 +1,164 @@
+import serial
+import time
+import serial.tools.list_ports
+import logging
+
+#----------------------------------------------
+logging.getLogger().setLevel(logging.INFO)
+
+class AFG2000:
+    
+    def __init__(self, emul=False, keyword='AFG', baudrate=9600, timeout=1, port=None) -> None:
+        self.port = port
+        self.keyword = keyword
+        self.timeout = timeout
+        self.baudrate = baudrate
+        self.inst = None
+    #---------------------------------------------------
+    
+    def connect(self):
+        if self.inst is not None and self.inst.is_open:
+            logging.info('AFG Connection is already established.')
+            return True
+        if self.port:
+            self.inst = serial.Serial(self.port, self.baudrate, timeout=self.timeout)
+        else:
+            self.inst = self.port_search(self.keyword)
+
+        if self.inst is not None:
+            logging.info(f'Connected to {self.get_idn()}')
+            return True
+        else:
+            logging.error('AFG Connection failed.')
+            return False
+    #---------------------------------------------------
+
+    def port_search(self, keyword):
+        logging.info('Searching for the device...')
+        ports = serial.tools.list_ports.comports()
+        for port, desc, hwid in sorted(ports):
+            ser = serial.Serial(port, self.baudrate, timeout=self.timeout)
+            ser.write(b'*IDN?\r\n')
+            idn = ser.readline().strip().decode('ascii')
+            
+            if keyword in idn:
+                logging.info(f'"{keyword}" found in: {port}')
+                return ser
+            else:
+                ser.close()
+            
+        logging.info(f'"{keyword}" is not found on any port')
+        return None
+    #---------------------------------------------------
+
+    def close(self):
+        if self.inst is not None and self.inst.is_open:
+            self.inst.close()
+            logging.info('AFG Connection closed.')
+        else:
+            logging.info('No active AFG connection to close.')
+    #---------------------------------------------------
+    
+    def is_connected(self):
+        if self.inst is None:
+            return False
+        return self.inst.is_open
+    #---------------------------------------------------
+    
+    def send_cmd(self, cmd):
+        if self.is_connected():
+            self.inst.write(cmd.encode('ascii') + b'\r\n')
+            resp = self.inst.readline().strip().decode('ascii')
+            return resp
+        else:
+            logging.info('AFG Connection is not established.')
+            return None
+    #---------------------------------------------------
+            
+    def get_idn(self):
+        return self.send_cmd('*IDN?')
+    #---------------------------------------------------
+    
+    def set_frequency(self, freq):
+        """
+        Sets the frequency of the AFG2000 function generator.
+
+        Parameters:
+        freq (float): The desired frequency in Hz.
+
+        Returns:
+        bool: True if the frequency is set successfully, False otherwise.
+        """
+        if self.is_connected():
+            self.send_cmd(f'SOUR1:FREQ {freq}')
+            return True
+        else:
+            logging.info('AFG2000 function generator is not connected!')
+            return False
+    	#---------------------------------------------------
+	
+    def set_waveform(self, waveform='SIN'):
+        if self.is_connected():
+            if waveform in ['SIN', 'SQU', 'RAMP', 'NOIS', 'ARB']:
+                self.send_cmd(f'SOUR1:FUNC {waveform}')
+                return True
+            else:
+                logging.error(f'Invalid waveform: {waveform}. Valid waveforms are "SIN", "SQU", "RAMP", "NOIS", and "ARB".')
+                return None
+        else:
+            logging.info('AFG2000 function generator is not connected!')
+            return False
+	#---------------------------------------------------
+        
+    def set_amplitude(self, amplitude, unit='VPP'):
+        if self.is_connected():
+            if unit in ['VPP', 'VRMS', 'DBM']:
+                self.send_cmd(f'SOUR1:VOLT:UNIT {unit}')
+            else:
+                logging.error(f'Invalid unit: {unit}. Valid units are "VPP", "VRMS", and "DBM".')
+                return None
+            self.send_cmd(f'SOUR1:AMPL {amplitude}')
+            return True
+        else:
+            logging.info('AFG2000 function generator is not connected!')
+            return False
+    #---------------------------------------------------
+        
+    def set_DCoffset(self, offset):
+        if self.is_connected():
+            self.send_cmd(f'SOUR1:DCO {offset}')
+            return True
+        else:
+            logging.info('AFG2000 function generator is not connected!')
+            return False
+    #---------------------------------------------------
+        
+    def set_output(self, state):
+        if self.is_connected():
+            if state in ['ON', 'OFF']:
+                self.send_cmd(f'OUTP {state}')
+                return True
+            else:
+                logging.error(f'Invalid output state: {state}. Valid states are "ON" and "OFF".')
+                return None
+        else:
+            logging.info('AFG2000 function generator is not connected!')
+            return False
+#==============================================================================    
+
+# how to use this class
+if __name__ == '__main__':
+    afg = AFG2000()
+    afg.connect()
+    afg.set_waveform('SIN')
+    afg.set_frequency('70')
+    afg.set_amplitude('0.2', 'VPP')
+    afg.set_DCoffset('0.0')
+    afg.set_output('ON')
+    time.sleep(10)
+
+    afg.set_amplitude('0.35')
+    afg.set_frequency('90')
+    time.sleep(10)
+    afg.set_output('OFF')
+    afg.close()

YorkUphysLab/GwINSTEK/GPD3303D.py

@@ -0,0 +1,218 @@
+import serial
+import time
+import serial.tools.list_ports
+
+class GPD3303D:
+    """
+    Represents the GPD3303D Programmable Power Supply Unit (PSU).
+
+    Args:
+        emul (bool): Whether to enable emulation mode. Default is False.
+        keyword (str): The keyword to search for in the device identification string. Default is 'GPD'.
+        baudrate (int): The baud rate for serial communication. Default is 9600.
+        timeout (float): The timeout duration for serial communication in seconds. Default is 1.
+        port (str): The specific port to connect to. If not provided, the port will be searched automatically.
+
+    Attributes:
+        port (str): The port used for communication.
+        keyword (str): The keyword used for device identification.
+        timeout (float): The timeout duration for serial communication.
+        baudrate (int): The baud rate for serial communication.
+        inst (serial.Serial or str): The serial connection instance or a string indicating emulation mode.
+        emul (bool): Whether emulation mode is enabled.
+        inst_is_open (bool): Whether the serial connection is open.
+        voltage (dict): A dictionary to store the voltage values for each channel.
+        current (dict): A dictionary to store the current values for each channel.
+        emul_str (str): A string indicating the emulation mode.
+
+    Methods:
+        connect(): Establishes a connection to the PSU.
+        port_search(keyword): Searches for the PSU on available ports.
+        send_cmd(cmd): Sends a command to the PSU and returns the response.
+        get_idn(): Retrieves the identification string of the PSU.
+        set_voltage(channel, voltage): Sets the voltage for a specific channel.
+        set_current(channel, current): Sets the current for a specific channel.
+        enable_output(): Enables the output of the PSU.
+        disable_output(): Disables the output of the PSU.
+        enable_beep(): Enables the beep sound of the PSU.
+        disable_beep(): Disables the beep sound of the PSU.
+        get_voltage(channel): Retrieves the voltage value for a specific channel.
+        get_current(channel): Retrieves the current value for a specific channel.
+        close_connection(): Closes the connection to the PSU.
+        is_connected(): Checks if the connection to the PSU is established.
+    """
+    def __init__(self, emul=False, keyword='GPD', baudrate=9600, timeout=1, port=None) -> None:
+        self.port = port
+        self.keyword = keyword
+        self.timeout = timeout
+        self.baudrate = baudrate
+        self.inst = None
+        self.emul = emul
+        self.inst_is_open = False
+        self.voltage ={}
+        self.current ={}
+        if self.emul:
+            self.emul_str = "[Emulation mode]:"
+        else:
+            self.emul_str = ""
+
+    def connect(self):
+        if not self.emul:
+            if self.port:
+                self.inst = serial.Serial(self.port, self.baudrate, timeout=self.timeout)
+            else:
+                self.inst = self.port_search(self.keyword)
+
+            if self.inst is not None:
+                print(f'Connected to {self.get_idn()}')
+                return True
+            else:
+                print('PSU Connection failed.')
+                return False
+        else:
+            print(f'{self.emul_str} Connected to GPD3303D PSU.')
+            self.inst = 'emulated psu'
+            self.inst_is_open = True
+            return True
+
+
+    def port_search(self, keyword):
+        print('Searching for the device...')
+        ports = serial.tools.list_ports.comports()
+        for port, desc, hwid in sorted(ports):
+            ser = serial.Serial(port, self.baudrate, timeout=self.timeout)
+            ser.write(b'*IDN?\r\n')
+            idn = ser.readline().strip().decode('ascii')
+            
+            if keyword in idn:
+                print(f'"{keyword}" found in: {port}')
+                return ser
+            else:
+                ser.close()
+            
+        print(f'"{keyword}" is not found on any port')
+        return None
+
+    
+    def send_cmd(self, cmd):
+        if self.is_connected():
+            self.inst.write(cmd.encode('ascii') + b'\r\n')
+            resp = self.inst.readline().strip().decode('ascii')
+            return resp
+        else:
+            print('PSU Connection is not established.')
+            return None
+
+    
+    def get_idn(self):
+        if self.emul:
+            return 'Emulated GPD3303D PSU'
+        else:
+            return self.send_cmd('*IDN?')
+    
+    def set_voltage(self, channel, voltage):
+        if not self.emul:
+            cmd = f'VSET{channel}:{voltage:.1f}'
+            return self.send_cmd(cmd)
+        else:
+            self.voltage[channel] = voltage
+            return True
+    
+    def set_current(self, channel, current):
+        if not self.emul:
+            cmd = f'ISET{channel}:{current:.2f}'
+            return self.send_cmd(cmd)
+        else:
+            self.current[channel] = current
+            return True
+    
+    def enable_output(self):
+        if not self.emul: return self.send_cmd('OUT1')
+        else:
+            print(f'{self.emul_str} PSU output enabled.')
+            return True
+
+    
+    def disable_output(self):
+        if not self.emul: return self.send_cmd('OUT0')
+        else:
+            print(f'{self.emul_str} PSU output disabled.')
+            return True
+    
+    def enable_beep(self):
+        if not self.emul: return self.send_cmd('BEEP1')
+
+    def disable_beep(self):
+        if not self.emul: return self.send_cmd('BEEP0')
+    
+    def get_voltage(self, channel):
+        if not self.emul:
+            response = self.send_cmd(f'VOUT{channel}?')
+            if response is not None:
+                voltage_str, unit_str = response.strip().split("V")
+                return float(voltage_str)
+        else:
+            return float(self.voltage[channel])
+
+    
+    def get_current(self, channel):
+        if not self.emul:
+            response = self.send_cmd(f'IOUT{channel}?')
+            if response is not None:
+                current_str, unit_str = response.strip().split("A")
+                return float(current_str)
+        else:
+            return float(self.current[channel])
+    
+    def close_connection(self):
+        if not self.emul:
+            if self.inst is not None and self.inst.is_open:
+                self.inst.close()
+                print('PSU Connection closed.')
+            else:
+                print('No active PSU connection to close.')
+        else:
+            if self.inst is not None and self.inst_is_open:
+                self.inst_is_open = False
+                print(f'{self.emul_str} PSU Connection closed.')
+            else:
+                print(f'{self.emul_str} No active PSU connection to close.')
+    
+    def is_connected(self):
+        if self.inst is None:
+            return False
+        if not self.emul: return self.inst.is_open
+        else: return self.inst_is_open
+#==============================================================================    
+
+# how to use this class
+if __name__ == '__main__':
+    # create a power-supply object
+    psu = GPD3303D(emul=True)
+    #psu = GPD3303D(port='COM8')
+
+    # connect to the device
+    psu.connect()
+
+    # Set the output voltage and current for channel 1
+    psu.set_voltage(1, 12)
+    psu.set_current(1, 0.01)
+
+    # Set the output voltage and current for channel 2
+    psu.set_voltage(2, 4.7)
+    psu.set_current(2, 0.05)
+    
+    # Enable the output
+    psu.enable_output()
+
+    time.sleep(2)
+    #print(f'voltage - CH1: {psu.get_voltage(1)} V')
+    #print(f'current - CH1: {psu.get_current(1)} A')
+    print(f'voltage - CH2: {psu.get_voltage(2)} V')
+    #print(f'current - CH2: {psu.get_current(2)} A')
+    
+    # Disable the output
+    psu.disable_output()
+
+    # close the connection
+    psu.close_connection()

YorkUphysLab/HVcontrol/HV_control.py

@@ -0,0 +1,133 @@
+import YorkUphysLab.GwINSTEK.GPD3303D as PSU
+import time
+
+
+class HV_control:
+    def __init__(self, _psu, emul=False) -> None:
+        self.psu = _psu
+        self.HV_on = False
+        self.emul = emul
+        if self.emul:
+            self.emul_str = "[Emulation mode]:"
+        else:
+            self.emul_str = ""
+
+    def switch_on(self):
+        try:
+            if not self.psu.is_connected():
+                self.psu.connect()
+
+            if self.psu.is_connected():
+                self.psu.set_voltage(1, 12)
+                self.psu.set_current(1, 0.5)
+                self.psu.set_voltage(2, 1)
+                self.psu.set_current(2, 0.01)
+                self.psu.enable_output()
+                self.HV_on = True
+                message = f'{self.emul_str} HV switched ON.'
+            else:
+                message = f'{self.emul_str} PSU Connection is not established.'
+                
+        except Exception as e:
+            message = f'{self.emul_str} An error occurred: {str(e)}'
+        
+        print(message)
+        return self.HV_on
+    
+    def switch_off(self):
+        self.psu.disable_output()
+        #self.psu.close_connection()
+        print(f'{self.emul_str} HV switched OFF.')
+        self.HV_on = False
+        return True
+    
+    def set_hv(self, voltage):
+        if not self.HV_on:
+            print(f'{self.emul_str} HV is switched OFF! Switch it ON first!')
+            return None
+        
+        # when PSU connection is closed by another device:
+        if not self.psu.is_connected():
+            print("PSU Connection is not established. Switching off other devise sharing same PSU might have caused this. Switch on this decive and try again.")
+            return None
+        
+        if 0 <= voltage <= 3:
+            # Vctrl equation is a linear fit of the data below
+            Vctrl = 1.6489*voltage + 0.0595
+            Vctrl = 5 if Vctrl >= 5 else round(Vctrl, 1)
+
+            #if self.HV_on:
+            self.psu.set_voltage(2, Vctrl)
+            print(f'{self.emul_str} HV voltage set to {voltage} kV')
+            return True
+            
+        else:
+            print(f'{self.emul_str} Requested High voltage out of range. Use 0 -3 kV')
+            return None
+    
+    def get_hv(self):
+        
+        if not self.HV_on:
+            print(f'{self.emul_str} HV is switched OFF! Switch it ON first!')
+            return None
+        
+        # when PSU connection is closed by another device:
+        if not self.psu.is_connected():
+            print("PSU Connection is not established. Switching off other devise sharing same PSU might have caused this. Switch on this decive and try again.")
+            return None
+        
+        # the output must be enabled to read the voltage
+        actual_voltage = self.psu.get_voltage(2)
+        #print(f'{self.emul_str} actual_voltage = {actual_voltage} V')
+        actual_HV = (actual_voltage - 0.0595)/1.6489
+        return round(actual_HV, 2)
+        
+#==============================================================================    
+
+# how to use this class
+if __name__ == "__main__":
+        
+    try:
+        #psu = PSU.GPD3303D(port='COM8')
+        psu = PSU.GPD3303D(emul=True)
+    except:
+        print('No PSU found, or device is not connected')
+        exit()
+    
+    psu.connect()
+
+    if psu.is_connected():
+        HV = HV_control(psu, emul=True)
+        
+        HV.switch_on()
+        HV.set_hv(1.5)
+        time.sleep(2)
+        actual_HV = HV.get_hv()
+        print(f'Actual HV = {actual_HV} kV')
+        psu.disable_output()
+        psu.close_connection()
+    
+    else:
+        print('PSU not connected')
+
+
+'''
+# high voltage callibration
+Vctrl	V kV(cur)
+0.1,	0.025127956
+0.2,	0.085740858
+0.3,	0.146705996
+0.4,	0.207464024
+0.5,	0.26828344
+0.6,	0.328773566
+0.7,	0.389337894
+0.8,	0.449891494
+1.3,	0.753993044
+1.8,	1.053181468
+2.3,	1.354698166
+2.8,	1.654354748
+3.3,	1.955916146
+3.8,	2.276596628
+4.3,	2.578250108
+4.8,	2.875189526
+'''