Yogesh Rupeliya

Hello there,
I am doing Four point measurements by using SMU 2636A with python. Earlier I was using Python 2.7 and I switched to Python 3.8. With 3.8 I am getting error -350 Queue full error which is showing in SMU's display. I tried to write function in Python for Queue error however still getting same error. Here I am attaching both Python files as a text as well as zip. Could you please help me in this situation?

Python 2.7 original file:

# *-* coding:utf-8 *-*

import visa
import numpy as np
import time
import os
import matplotlib.pyplot as plt

class Keithley2636A(object):
    
    def __init__(self):
        try:
            self.__device = visa.instrument('GPIB0::18')
        except:
            print 'Could not attach to Keithley!'
            
        self.__intTime = 1.0 # standart integration time 20ms = 1 plc
        self.__waitingTime = 0.0 # in ms --> minimum waiting time to measure after setting voltage
        self.__maxPower = 1.0 # in Watt
        self.__average = 1 # number of averages for each data point measurement
        
        self.__send(['reset()'])
        
    def __send(self, cmds):
        '''sends a list of commands to the device'''
        for cmd in cmds:
            self.__device.write(cmd)
        
    def init4pt(self):
        optns = []
        #optns.append('display.screen = display.SMUA')
        #optns.append('smua.source.func = smua.OUTPUT_DCAMPS') #current source
        #optns.append('smua.source.autorangei = smua.AUTORANGE_ON') #current source AutoRange
        #optns.append('display.smua.measure.func =  display.MEASURE_DCVOLTS')
        #optns.append('smua.sense = smua.SENSE_REMOTE') #4 wire measurement
        #optns.append('smua.measure.autorangev = smua.AUTORANGE_ON') #voltage measurement AutoRange
        #optns.append('smua.measure.nplc = %f' % self.__intTime) # integration time in Number of Power Line Cycles (range from 0.001 to 25) 25 MAYBE HAS A BUG
        
        optns.append('display.screen = display.SMUA_SMUB')
        optns.append('smua.source.func = smua.OUTPUT_DCVOLTS') #voltage source
        optns.append('smub.source.func = smub.OUTPUT_DCAMPS') #current source
        optns.append('smua.source.autorangev = smua.AUTORANGE_ON') #voltage source AutoRange
        optns.append('smub.source.autorangei = smua.AUTORANGE_ON') #current source AutoRange
        optns.append('display.smua.measure.func =  display.MEASURE_DCAMPS')
        optns.append('display.smub.measure.func =  display.MEASURE_DCVOLTS')
        optns.append('smua.sense = smub.SENSE_LOCAL') #2 wire measurement
        optns.append('smub.sense = smub.SENSE_LOCAL') #2 wire measurement
        optns.append('smua.measure.autorangei = smua.AUTORANGE_ON') #voltage measurement AutoRange
        optns.append('smub.measure.autorangev = smua.AUTORANGE_ON') #voltage measurement AutoRange
        optns.append('smua.measure.nplc = %f' % self.__intTime) # integration time in Number of Power Line Cycles (range from 0.001 to 25) 25 MAYBE HAS A BUG
        optns.append('smub.measure.nplc = %f' % self.__intTime) # integration time in Number of Power Line Cycles (range from 0.001 to 25) 25 MAYBE HAS A BUG
        self.__send(optns)
    
    def __getVoltageLimit(self, cur):
        '''calculates the voltage limit for current source to avoid too high powers in the DUT'''
        if cur == 0.0:
            #lim = 200.0 #only in interlock mode
            lim = 20.0
        else:
            lim = self.__maxPower / cur
            if np.abs(cur) < 0.1:
                #lim = np.clip(np.abs(lim), 0.02, 200.0) #only in interlock mode
                lim = np.clip(np.abs(lim), 0.02, 20.0)
            else:
                lim = np.clip(np.abs(lim), 0.02, 20.0)
        return lim
        
    def __getCurrentLimit(self, vol):
        '''calculates the current limit for voltage source to avoid too high powers in the DUT'''
        if vol == 0.0:
            lim = 1.5
        else:
            lim = self.__maxPower / vol
            if np.abs(vol) < 20.0:
                lim = np.clip(np.abs(lim), 100e-12, 1.5)
            else:
                lim = np.clip(np.abs(lim), 100e-12, 0.1)
        return lim
    
    def setCurrent(self, cur, cha): #cha = channel A/B
        '''sets the current source value for channel A/B'''
        optns = []
        optns.append('smu%s.source.limitv = %f' % (cha, self.__getVoltageLimit(cur)))
        optns.append('smu%s.source.leveli = %f' % (cha, cur))
        self.__send(optns)
        return True
    
    def setVoltage(self, vol, cha): #cha = channel A/B
        '''sets the voltage source value for channel A/B'''
        optns = []
        optns.append('smu%s.source.limiti = %f' % (cha, self.__getCurrentLimit(vol)))
        optns.append('smu%s.source.levelv = %f' % (cha, vol))
        self.__send(optns)
        return True
    
    def __measureCurrent(self, cha):
        '''measures the current on channel A/B'''
        optns = []
        optns.append('smu%s.measure.count = 1' % cha)
        optns.append('print(smu%s.measure.i())' % cha)
        self.__send(optns)
        return self.__device.read_values()[0]
    
    def getCurrent(self, cha): #cha = channel A/B
        cur = 0.0
        for i in range(self.__average):
            time.sleep(self.__waitingTime/1000.0)
            cur = cur + self.__measureCurrent(cha)
        return cur / self.__average, self.__checkCompliance(cha), True
    
    def __measureVoltage(self, cha):
        optns = []
        optns.append('smu%s.measure.count = 1' % cha)
        optns.append('print(smu%s.measure.v())' % cha)
        self.__send(optns)
        return self.__device.read_values()[0]
    
    def getVoltage(self, cha): #cha = channel A/B
        vol = 0.0
        for i in range(self.__average):
            time.sleep(self.__waitingTime/1000.0)
            vol = vol + self.__measureVoltage(cha)
        return vol / self.__average, self.__checkCompliance(cha), True

    def __measureCurVol(self, cha):
        optns = []
        optns.append('smu%s.measure.count = 1' % cha)
        optns.append('print(smu%s.measure.iv())' % cha)
        self.__send(optns)
        return self.__device.read_values()[0:2]

    def getCurVol(self, cha):
        res = self.__measureCurVol(cha)
        return res[0], res[1], True
        
    def setMaxPower(self, pwr):
        '''define the maximum power through the device'''
        self.__maxPower = pwr
    
    def setIntegrationTime(self, time):
        '''time in seconds; for 50Hz 1 plc = 20ms --> range time from 20µs to 500ms'''
        self.__intTime = time / 0.02
        
    def setNumberOfAverages(self, n):
        '''defines over how many measurements per point should be averaged'''
        self.__average = n
        
    def outputOn(self, cha): # cha = channel A/B
        '''turns the output on'''
        self.__send(['smu%s.source.output = smu%s.OUTPUT_ON' % (cha, cha)])
        
    def outputOff(self, cha): # cha = channel A/B
        '''turns the output off'''
        self.__send(['smu%s.source.output = smu%s.OUTPUT_OFF' % (cha, cha)])
        
    def __checkCompliance(self, cha):
        '''checks wheter the source is in compliance or not'''
        self.__send(['print(smu%s.source.compliance)' % cha])
        tmp = self.__device.read()
        if tmp == 'false':
            return False
        else:
            return True
        
def test():
    tst = Keithley2636A()
    fileName = raw_input('file name: ')
    fl = os.listdir('./')
    n = 0
    Ival = []
    Vval = []
    while '%02.i_%s.dat' % (n, fileName) in fl:
        n = n+1
    f = open('%02.i_%s.dat' % (n, fileName), mode='w')
    f.write('V_setpoint/V\tI_measured/A\tV_measured/V\n')
    tst.init4pt()
    minI = input('Minimum Voltage in V: ')
    maxI = input('Maximum Voltage in V: ')
    stepI = input('Voltage steps in V: ')
    tst.outputOn('a')
    tst.setCurrent(0.0, 'b')
    tst.outputOn('b')
    print 'V_setpoint/V\tI_measured/A\tV_measured/V'
    r1 = np.arange(0.0, maxI, stepI)
    r2 = np.arange(maxI, minI, -stepI)
    r3 = np.arange(minI, 0.0+stepI, stepI)
    vLoop = np.append(r1, r2)
    vLoop = np.append(vLoop, r3)
    for v in vLoop:
        tst.setVoltage(v, 'a')
        time.sleep(1.0)
        resCur = tst.getCurrent('a')
        resVolt = tst.getVoltage('b')
        print '%g\t%g\t%g' % (v, resCur[0], resVolt[0])
        f.write('%g\t%g\t%g\n' % (v, resCur[0], resVolt[0]))
        Ival.append(resCur[0])
        Vval.append(resVolt[0])
    print 'end'
    tst.outputOff('a')
    tst.outputOff('b')
    f.close()
    plt.plot(Vval, Ival, 'ro')
    plt.show()
    
if __name__ == '__main__':
    test()



--------------------------------------------------------------------------------------------
Python 3.8 Transferred file :

import pyvisa
import time
import numpy as np
import os
import matplotlib.pyplot as plt
from queue import Queue

class Keithley2636A:
    def __init__(self, visa_address):
        self.rm = pyvisa.ResourceManager()
        self.instrument = self.rm.open_resource(visa_address)
        self.queue = Queue(maxsize=100)  # Set a larger value for the queue size
        
    def setup_measurement(self):
        # Configure the instrument for the 4-point probe measurement
        self.instrument.write("reset()")
        self.instrument.write("display.screen = pyvisa.constants.SMUA_SMUB")
        self.instrument.write("smua.source.func = smua.OUTPUT_DCVOLTS")
        self.instrument.write("smub.source.func = smub.OUTPUT_DCAMPS")
        self.instrument.write("smua.source.autorangev = smua.AUTORANGE_ON")
        self.instrument.write("smub.source.autorangei = smua.AUTORANGE_ON")
        self.instrument.write('display.smua.measure.func =  display.MEASURE_DCAMPS')
        self.instrument.write('display.smub.measure.func =  display.MEASURE_DCVOLTS')
        self.instrument.write("smua.sense = smua.SENSE_REMOTE")
        self.instrument.write("smub.sense = smub.SENSE_REMOTE")
        self.instrument.write('smua.sense = smub.SENSE_LOCAL')  # 2 wire measurement
        self.instrument.write('smub.sense = smub.SENSE_LOCAL')  # 2 wire measurement
        self.instrument.write('smua.measure.autorangei = smua.AUTORANGE_ON')  # voltage measurement AutoRange
        self.instrument.write('smub.measure.autorangev = smua.AUTORANGE_ON')  # voltage measurement AutoRange
        self.instrument.write("smua.source.output = smua.OUTPUT_OFF")
        self.instrument.write("smub.source.output = smub.OUTPUT_OFF")
        self.instrument.write("smua.measure.nplc = 1")  # Set NPLC value as needed
        self.instrument.write("smub.measure.nplc = 1")  # Set NPLC value as needed


    def __getVoltageLimit(self, cur):
        '''calculates the voltage limit for current source to avoid too high powers in the DUT'''
        if cur == 0.0:
            #lim = 200.0 #only in interlock mode
            lim = 20.0
        else:
            lim = 1.0 / cur
            if np.abs(cur) < 0.1:
                #lim = np.clip(np.abs(lim), 0.02, 200.0) #only in interlock mode
                lim = np.clip(np.abs(lim), 0.02, 20.0)
            else:
                lim = np.clip(np.abs(lim), 0.02, 20.0)
        return lim
    
    def __getCurrentLimit(self, vol):
        '''calculates the current limit for voltage source to avoid too high powers in the DUT'''
        if vol == 0.0:
            lim = 1.5
        else:
            lim = 1.0 / vol
            if np.abs(vol) < 20.0:
                lim = np.clip(np.abs(lim), 100e-12, 1.5)
            else:
                lim = np.clip(np.abs(lim), 100e-12, 0.1)
        return lim
    
    def set_voltage(self, voltage, cha):
        #self.instrument.write(f"smua.source.levelv = {voltage}")
        self.instrument.write('smu%s.source.limiti = %f' % (cha, self.__getCurrentLimit(voltage)))
        self.instrument.write('smu%s.source.levelv = %f' % (cha, voltage))
        time.sleep(0.1)
        # Put the measured value into the queue
        self.queue.put({'voltage': voltage, 'current': self.measure_current(cha), 'voltage_measurement': self.measure_voltage(cha)})
    
    def set_current(self, current, cha):
        #self.instrument.write(f"smub.source.leveli = {current}")
        self.instrument.write('smu%s.source.limitv = %f' % (cha, self.__getVoltageLimit(current)))
        self.instrument.write('smu%s.source.leveli = %f' % (cha, current))
        time.sleep(0.1)
    
    def turn_on_channels(self):
        self.instrument.write("smua.source.output = smua.OUTPUT_ON")
        self.instrument.write("smub.source.output = smub.OUTPUT_ON")
    
    def turn_off_channels(self):
        self.instrument.write("smua.source.output = smua.OUTPUT_OFF")
        self.set_current(0.0, 'B')
        self.instrument.write("smub.source.output = smub.OUTPUT_OFF")
        self.queue.queue.clear()  # Clear the queue when turning off channels
    
    def measure_current(self, cha):
        return float(self.instrument.query(f'print(smub.measure.i())'))
    
    def measure_voltage(self, cha):
        return float(self.instrument.query(f'print(smub.measure.v())'))
    
    def close(self):
        self.instrument.close()
        self.rm.close()

if __name__ == "__main__":
    # Configure the GPIB address for your Keithley 2636A
    visa_address = "GPIB0::18::INSTR"  # Adjust this address as needed

    keithley = Keithley2636A(visa_address)

    try:
        keithley.setup_measurement()
        measurement_name = input("Enter the measurement name:")

        minI = float(input('Minimum Voltage in V: '))
        maxI = float(input('Maximum Voltage in V: '))
        stepI = float(input('Voltage steps in V: '))
        cha = 'A'  # Define cha before using it
        
        r1 = np.arange(0.0, maxI, stepI)
        r2 = np.arange(maxI, minI, -stepI)
        r3 = np.arange(minI, 0.0 + stepI, stepI)
        vLoop = np.append(r1, r2)
        vLoop = np.append(vLoop, r3)
        voltage_list = np.arange(minI, maxI, stepI)  # Set your desired voltage range

        current_list = []
        v_list = []

        keithley.turn_on_channels()
        print(f"Step Voltage/V \t Measured Current/A \t  Measured Voltage/V")

        for voltage in vLoop:
            keithley.set_voltage(voltage, cha)
            time.sleep(1.0)
            # Add the measured values to the queue
            keithley.queue.put({'voltage': voltage, 'current': keithley.measure_current(cha), 'voltage_measurement': keithley.measure_voltage(cha)})
            current_list.append(keithley.queue.get()['current'])
            v_list.append(keithley.queue.get()['voltage_measurement'])
            current = keithley.measure_current(cha)
            current_list.append(current)
            v = keithley.measure_voltage(cha)
            v_list.append(v)

            print(f"{round(voltage, 1)} V  {current} A \t  {v} V")
    
        keithley.turn_off_channels()
    finally:
        keithley.close()

Thank you in advance.