YorkUphysLabV2 2.0.0__tar.gz

yorkuphyslabv2-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Mohammad Kareem
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

yorkuphyslabv2-2.0.0/PKG-INFO

@@ -0,0 +1,43 @@
+Metadata-Version: 2.4
+Name: YorkUphysLabV2
+Version: 2.0.0
+Summary: A Python package to control YU physics labs equipment. V2 updated to work with new versions of setup.
+Author-email: "Bruce Howard (maintainer)" <blhoward@yorku.ca>, "Mohammad Kareem (original author)" <mkareem@yorku.ca>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/brucehoward-physics/YorkUphysLab
+Project-URL: Issues, https://github.com/m-kareem/YorkUphysLab/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: nidaqmx
+Requires-Dist: pyserial
+Requires-Dist: pyvisa-py
+Requires-Dist: numpy
+Dynamic: license-file
+
+# York University physics lab
+
+This package includes the required drivers to control some of the hardwares in physics labs at York University.
+
+## How to install
+
+```pip install --no-cache-dir --upgrade YorkUphysLabV2```
+
+## How to use
+
+See the examples script: YorkUphysLab_example.py
+
+
+## Developed by:
+
+Mohammad Kareem, Ph.D.
+Laboratory Technologist
+Department of Physics & Astronomy
+Faculty of Science | YORK UNIVERSITY
+4700 Keele Street, Toronto, Ontario, Canada M3J 1P3
+
+## Maintained in V2 by:
+
+Bruce Howard, Ph.D.

yorkuphyslabv2-2.0.0/README.md

@@ -0,0 +1,24 @@
+# York University physics lab
+
+This package includes the required drivers to control some of the hardwares in physics labs at York University.
+
+## How to install
+
+```pip install --no-cache-dir --upgrade YorkUphysLabV2```
+
+## How to use
+
+See the examples script: YorkUphysLab_example.py
+
+
+## Developed by:
+
+Mohammad Kareem, Ph.D.
+Laboratory Technologist
+Department of Physics & Astronomy
+Faculty of Science | YORK UNIVERSITY
+4700 Keele Street, Toronto, Ontario, Canada M3J 1P3
+
+## Maintained in V2 by:
+
+Bruce Howard, Ph.D.

yorkuphyslabv2-2.0.0/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
+    '''

yorkuphyslabv2-2.0.0/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()

yorkuphyslabv2-2.0.0/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()