keithley 2401 generate pulse voltage with python GIPB

Question

I am using keithley 2401, and trying to write a python code to generate pulse voltage, I understand there will be some delay around 10ms which is acceptable. I also have a GUI for input, for example I have two voltage list, on state 100,99 volt, and off state voltage 1,2 (or all zero if needed), and there are also two time list coresponding to on state and off state voltage like on state duration 4,5; and off state duration 1,2. Here I want to go 100 volt first (or 1volt) and stay at 100 volt for 4 second, then change to 1 volt and stay for 1 second, then change to 99 volt and stay for 5 second and so on. This is what the four list means. And I know there are two commands: "Trigger Delay – which affects the ‘Off’ portion of the pulse & Source Delay – which affects the ‘On’ portion of the pulse." But I do not understant why for my code, it only go to the first voltage voltage but do not go the second one. Or I can iterate all the value but do not stay there for the duration set by the input. Could somebody help me the check the code? Thanks a lot! I think the problem comes from generate_pulse_sequence or/and apply_pulse

import sys 
from PyQt5 import QtWidgets, QtGui
from PyQt5.QtWidgets import QApplication, QWidget, QLabel, QLineEdit, QPushButton, QVBoxLayout
import pyvisa as visa
import time
import threading
import numpy as np
    
    class VoltagePulseGenerator(QWidget):
        def __init__(self):
            super().__init__()
    
            # Initialize variables
            self.inst = None
            self.voltage_sequence_input = None
            self.duration_sequence_input = None
            self.current_label = None
    
            # Set up GUI
            self.init_ui()
    
            # Start a thread for continuous current reading
            self.is_running = False
            self.current_thread = None
    
        def init_ui(self):
            # Widgets
            self.voltage_sequence_on_label = QLabel('On voltage Sequence(V,comma seperated):')
            self.voltage_sequence_on_input = QLineEdit()
            self.voltage_sequence_off_label = QLabel('Off voltage Sequence:')
            self.voltage_sequence_off_input = QLineEdit()
    
            self.duration_sequence_on_label = QLabel('On duration Sequence (seconds,comma seperated):')
            self.duration_sequence_on_input = QLineEdit()
            self.duration_sequence_off_label = QLabel('off duration Sequence:')
            self.duration_sequence_off_input = QLineEdit()
            
            self.generate_button = QPushButton('Generate Pulse Sequence')
            self.current_label = QLabel('Current Value: N/A')
            self.compliance_label = QLabel('Enter Compliance (mA):')
            self.compliance_input = QLineEdit()
            
            # Layout
            layout = QVBoxLayout()
            layout.addWidget(self.voltage_sequence_on_label)
            layout.addWidget(self.voltage_sequence_on_input)
            layout.addWidget(self.voltage_sequence_off_label)
            layout.addWidget(self.voltage_sequence_off_input)
            
            layout.addWidget(self.duration_sequence_on_label)
            layout.addWidget(self.duration_sequence_on_input)
            layout.addWidget(self.duration_sequence_off_label)
            layout.addWidget(self.duration_sequence_off_input)
            
            layout.addWidget(self.compliance_label)
            layout.addWidget(self.compliance_input)
            
            layout.addWidget(self.generate_button)
            layout.addWidget(self.current_label)
            
            # Connect button click event
            self.generate_button.clicked.connect(self.generate_pulse_sequence)
    
            # Set layout
            self.setLayout(layout)
    
            # Set window properties
            self.setWindowTitle('Voltage Pulse Generator')
            self.setGeometry(300, 300, 400, 200)
    
        def generate_pulse_sequence(self):
            # Open the instrument connection if not already open
            if self.inst is None:
                self.inst = visa.ResourceManager().open_resource('GPIB0::1::INSTR') 
                self.inst.read_termination = '\n'
                self.inst.write_termination = '\n'
                
                compliance_limit = float(self.compliance_input.text())
                self.inst.write(':SENS:CURR:PROT ' + str(compliance_limit) + 'E-3')
        
            # Get voltage and duration sequences from the input
            voltage_sequence_on = [float(v) for v in self.voltage_sequence_on_input.text().split(',')]
            duration_sequence_on = [float(d) for d in self.duration_sequence_on_input.text().split(',')]
            voltage_sequence_off = [float(v) for v in self.voltage_sequence_off_input.text().split(',')]
            duration_sequence_off = [float(d) for d in self.duration_sequence_off_input.text().split(',')]
        
            # Merge the sequences
            combined_voltage_sequence = []
            combined_duration_sequence = []
            delay_type_sequence = []  # New sequence for delay types
        
            for v_on, d_on, v_off, d_off in zip(voltage_sequence_on, duration_sequence_on, voltage_sequence_off, duration_sequence_off):
                combined_voltage_sequence.extend([v_on, v_off])
                combined_duration_sequence.extend([d_on, d_off])
        
                # Assign delay types based on the sequence
                self.apply_pulse(v_on, d_on, delay_type='SOUR:DEL')
    
                # Apply the pulse with the second voltage and use TRIG:DEL for off state duration
                self.apply_pulse(v_off, d_off, delay_type='TRIG:DEL')
        
            # Apply pulse sequence
            for voltage, duration, delay_type in zip(combined_voltage_sequence, combined_duration_sequence, delay_type_sequence):
                # Apply the pulse with the specified voltage and delay type
                self.apply_pulse(voltage, duration, delay_type=delay_type_sequence)
    
        def apply_pulse(self, voltage, duration, delay_type):
            # Turn on the output
            self.inst.write(':OUTP ON')
        
            # Set the voltage
            self.inst.write(f':SOUR:VOLT {voltage}')
        
            # Set the delay type
            delay_command = f':{delay_type} {duration}'
            self.inst.write(delay_command)
        
            # # Wait for the specified duration
            time.sleep(duration)
        
            # # Turn off the output
            # self.inst.write(':OUTP OFF')
        
            # Read and display the current value
            current_value = self.read_current()
            self.current_label.setText(f'Current Value: {current_value} mA')
    
        def read_current(self):
            while self.is_running:
                # Query the current value
                values_measurement = self.inst.query_ascii_values('READ?', container=np.array)[1]
                current_value = values_measurement * 1000  # Convert to mA
                self.current_label.setText(f'Current Value: {current_value} mA')
                time.sleep(1)
                
        def close_instrument(self):
            if self.inst is not None:
                self.inst.write(':SOUR:VOLT 0')
                self.inst.close()
    
    if __name__ == '__main__':
        app = QApplication(sys.argv)
        voltage_pulse_generator = VoltagePulseGenerator()
        voltage_pulse_generator.show()
    
        # Start a thread for continuous current reading
        voltage_pulse_generator.is_running = True
        voltage_pulse_generator.current_thread = threading.Thread(target=voltage_pulse_generator.read_current)
        voltage_pulse_generator.current_thread.start()
    
        sys.exit(app.exec_())

The threading is also troubling, sometimes it block me from connecting to keithley so I comment the related codes.