From 0046d5b0bac949a831dfc2719b72aa28471bf8b5 Mon Sep 17 00:00:00 2001
From: unknown <asoalexandros@gmail.com>
Date: Mon, 25 Nov 2024 11:06:08 +0100
Subject: [PATCH] clear memristor software versions

---
 .../default-37a8.jupyterlab-workspace         |   1 +
 .../help.py                                   |   0
 .../memristor.py                              |   0
 .../memristor_buttons.ipynb                   |   0
 .../memristor (Version 1.0)/old/default.ini   |  11 +
 .../old/memristor_version1.py                 | 337 ++++++++
 .../old/memristor_version2.py                 | 349 +++++++++
 .../old/old_functions.py                      |  86 ++
 .../tests/how_buttons_look.ipynb              | 740 ++++++++++++++++++
 .../tests/memristor.ipynb                     | 475 +++++++++++
 .../tests/sampling_check.ipynb                | 154 ++++
 .../tests/test_check_dir.ipynb                | 223 ++++++
 .../tests/test_tkinter.ipynb                  |  91 +++
 .../working version/Version1/help.py          | 259 ++++++
 .../working version/Version1/memristor.py     | 357 +++++++++
 .../working version/Version2/help-Copy1.py    | 289 +++++++
 .../Version2/memristor-Copy1.py               | 466 +++++++++++
 hp4155/memristor (Version 2.0)/help.py        | 359 +++++++++
 hp4155/memristor (Version 2.0)/memristor.py   | 543 +++++++++++++
 .../memristor_buttons.ipynb                   | 114 +++
 .../help.py                                   |   0
 .../help_pulse.py                             |   0
 .../memristor.py                              |   0
 .../memristor_buttons.ipynb                   |   0
 .../help_new.py                               |   0
 .../interface.py                              |   0
 .../old/constant_pulse_test.ipynb             |  95 +++
 .../old/help.py                               | 246 ++++++
 .../old/sweep_pulse_test.ipynb                |  96 +++
 .../pulse evaluations/Drain_constant.py       | 168 ++++
 .../pulse evaluations/Drain_sweep.py          |  97 +++
 .../pulse evaluations/Drain_sweep_new.py      | 155 ++++
 .../pulse evaluations/constant_pulse.ipynb    | 225 ++++++
 .../pulse evaluations/measurement.py          |  77 ++
 .../pulse evaluations/mesa_constant.py        | 189 +++++
 .../pulse evaluations/mesa_plots.py           |  28 +
 .../pulse evaluations/mesa_sweep.py           | 178 +++++
 .../pulse evaluations/sweep_pulse.ipynb       | 220 ++++++
 .../pulse evaluations/time_evaluation.py      |  87 ++
 .../pulse.py                                  |   0
 .../pulse_interface.ipynb                     |   0
 41 files changed, 6715 insertions(+)
 create mode 100644 hp4155/memristor (Version 1.0)/.jupyter/desktop-workspaces/default-37a8.jupyterlab-workspace
 rename hp4155/{memristor_test_version => memristor (Version 1.0)}/help.py (100%)
 rename hp4155/{memristor_test_version => memristor (Version 1.0)}/memristor.py (100%)
 rename hp4155/{memristor_test_version => memristor (Version 1.0)}/memristor_buttons.ipynb (100%)
 create mode 100644 hp4155/memristor (Version 1.0)/old/default.ini
 create mode 100644 hp4155/memristor (Version 1.0)/old/memristor_version1.py
 create mode 100644 hp4155/memristor (Version 1.0)/old/memristor_version2.py
 create mode 100644 hp4155/memristor (Version 1.0)/old/old_functions.py
 create mode 100644 hp4155/memristor (Version 1.0)/tests/how_buttons_look.ipynb
 create mode 100644 hp4155/memristor (Version 1.0)/tests/memristor.ipynb
 create mode 100644 hp4155/memristor (Version 1.0)/tests/sampling_check.ipynb
 create mode 100644 hp4155/memristor (Version 1.0)/tests/test_check_dir.ipynb
 create mode 100644 hp4155/memristor (Version 1.0)/tests/test_tkinter.ipynb
 create mode 100644 hp4155/memristor (Version 1.0)/working version/Version1/help.py
 create mode 100644 hp4155/memristor (Version 1.0)/working version/Version1/memristor.py
 create mode 100644 hp4155/memristor (Version 1.0)/working version/Version2/help-Copy1.py
 create mode 100644 hp4155/memristor (Version 1.0)/working version/Version2/memristor-Copy1.py
 create mode 100644 hp4155/memristor (Version 2.0)/help.py
 create mode 100644 hp4155/memristor (Version 2.0)/memristor.py
 create mode 100644 hp4155/memristor (Version 2.0)/memristor_buttons.ipynb
 rename hp4155/{memristor_final => memristor (Version 3.0)}/help.py (100%)
 rename hp4155/{memristor_final => memristor (Version 3.0)}/help_pulse.py (100%)
 rename hp4155/{memristor_final => memristor (Version 3.0)}/memristor.py (100%)
 rename hp4155/{memristor_final => memristor (Version 3.0)}/memristor_buttons.ipynb (100%)
 rename hp4155/{memristor_pulsed => memristor pulsed (Version 1.0)}/help_new.py (100%)
 rename hp4155/{memristor_pulsed => memristor pulsed (Version 1.0)}/interface.py (100%)
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/old/constant_pulse_test.ipynb
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/old/help.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/old/sweep_pulse_test.ipynb
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_constant.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep_new.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/constant_pulse.ipynb
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/measurement.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_constant.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_plots.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_sweep.py
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/sweep_pulse.ipynb
 create mode 100644 hp4155/memristor pulsed (Version 1.0)/pulse evaluations/time_evaluation.py
 rename hp4155/{memristor_pulsed => memristor pulsed (Version 1.0)}/pulse.py (100%)
 rename hp4155/{memristor_pulsed => memristor pulsed (Version 1.0)}/pulse_interface.ipynb (100%)

diff --git a/hp4155/memristor (Version 1.0)/.jupyter/desktop-workspaces/default-37a8.jupyterlab-workspace b/hp4155/memristor (Version 1.0)/.jupyter/desktop-workspaces/default-37a8.jupyterlab-workspace
new file mode 100644
index 0000000..bcdb4aa
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/.jupyter/desktop-workspaces/default-37a8.jupyterlab-workspace	
@@ -0,0 +1 @@
+{"data":{"layout-restorer:data":{"main":{"dock":{"type":"tab-area","currentIndex":0,"widgets":["notebook:memristor_buttons.ipynb"]},"current":"notebook:memristor_buttons.ipynb"},"down":{"size":0,"widgets":[]},"left":{"collapsed":false,"visible":true,"current":"filebrowser","widgets":["filebrowser","running-sessions","@jupyterlab/toc:plugin","extensionmanager.main-view"],"widgetStates":{"jp-running-sessions":{"sizes":[0.16666666666666666,0.16666666666666666,0.16666666666666666,0.16666666666666666,0.16666666666666666,0.16666666666666666],"expansionStates":[false,false,false,false,false,false]},"extensionmanager.main-view":{"sizes":[0.3333333333333333,0.3333333333333333,0.3333333333333333],"expansionStates":[false,false,false]}}},"right":{"collapsed":true,"visible":true,"widgets":["jp-property-inspector","debugger-sidebar"],"widgetStates":{"jp-debugger-sidebar":{"sizes":[0.2,0.2,0.2,0.2,0.2],"expansionStates":[false,false,false,false,false]}}},"relativeSizes":[0.21617900172117036,0.7838209982788296,0],"top":{"simpleVisibility":true}},"notebook:memristor_buttons.ipynb":{"data":{"path":"memristor_buttons.ipynb","factory":"Notebook"}},"docmanager:recents":{"opened":[{"path":"","contentType":"directory","root":"~/labcode/hp4155/memristor"},{"path":"memristor_buttons.ipynb","contentType":"notebook","factory":"Notebook","root":"~/labcode/hp4155/memristor"}],"closed":[]}},"metadata":{"id":"default"}}
\ No newline at end of file
diff --git a/hp4155/memristor_test_version/help.py b/hp4155/memristor (Version 1.0)/help.py
similarity index 100%
rename from hp4155/memristor_test_version/help.py
rename to hp4155/memristor (Version 1.0)/help.py
diff --git a/hp4155/memristor_test_version/memristor.py b/hp4155/memristor (Version 1.0)/memristor.py
similarity index 100%
rename from hp4155/memristor_test_version/memristor.py
rename to hp4155/memristor (Version 1.0)/memristor.py
diff --git a/hp4155/memristor_test_version/memristor_buttons.ipynb b/hp4155/memristor (Version 1.0)/memristor_buttons.ipynb
similarity index 100%
rename from hp4155/memristor_test_version/memristor_buttons.ipynb
rename to hp4155/memristor (Version 1.0)/memristor_buttons.ipynb
diff --git a/hp4155/memristor (Version 1.0)/old/default.ini b/hp4155/memristor (Version 1.0)/old/default.ini
new file mode 100644
index 0000000..810acdb
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/old/default.ini	
@@ -0,0 +1,11 @@
+[Memristor]
+step = 0.02
+integration_time=MED
+
+[SET]
+voltage=4
+comp=1E-3
+
+[RESET]
+voltage=-2
+comp=20E-3
\ No newline at end of file
diff --git a/hp4155/memristor (Version 1.0)/old/memristor_version1.py b/hp4155/memristor (Version 1.0)/old/memristor_version1.py
new file mode 100644
index 0000000..089153a
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/old/memristor_version1.py	
@@ -0,0 +1,337 @@
+import sys
+sys.path.append(r"C:\Users\user\labcode\hp4155")
+
+import module
+import matplotlib.pyplot as plt
+import numpy as np
+from IPython.display import display, clear_output
+import pandas as pd
+from datetime import datetime
+import configparser
+from ipyfilechooser import FileChooser
+import ipywidgets as widgets
+import time
+import os
+
+
+def memristor():
+    #parameters set by the user
+    Vset=1
+    CC_vset=10**(-3)
+    Vreset=-1
+    CC_vreset=10**(-3)
+    step = 0.02
+    integration_time='MED'
+    
+    #additional variables
+    counter=0
+    V12=V34=I12=I34=None
+    file_path =os.getcwd()
+    file = None
+
+    #default ini file
+    ini_file_path=os.getcwd()
+    ini_file_name=r"default.ini"
+    ini_file=os.path.join(ini_file_path,ini_file_name)
+
+    #filechooser 
+    fc = FileChooser(select_desc='load .ini')
+    fc.default_path = r"\\FILESERVER\public"
+    fc.filter_pattern = '*.ini'
+    display(fc)
+    #pathchooser 
+    pc = FileChooser(select_desc="save path")
+    pc.default_path = r"\\FILESERVER\public"
+    pc.show_only_dirs = True
+    display(pc)
+    print()
+    
+    # the three naming fields
+
+    sample_series= widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'sample series:',
+        style = {'description_width': 'initial'}
+    )
+    field = widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'Field:',
+        style = {'description_width': 'initial'},
+    )
+
+    DUT = widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'DUT:',
+        style = {'description_width': 'initial'},
+    )
+    
+    all_text_boxes = widgets.VBox([sample_series,field,DUT])
+    display(all_text_boxes)
+    print()
+
+    #connecting to the device
+    device = module.HP4155a('GPIB0::17::INSTR')
+    device.reset()
+
+##################################################################################################################################################################
+    #setup the device
+    def disable():
+        nonlocal device
+        #smu1 and smu3 are disabled
+        device.smu_disable_sweep(1)
+        device.smu_disable_sweep(3)
+
+        #disable vmus and vsus
+        device.disable_vsu(1)
+        device.disable_vsu(2)
+        device.disable_vmu(1)
+        device.disable_vmu(2)
+
+    #define each different measurement as a function
+
+    #first sweep from start to stop and stop to start
+    def sweep(start,stop,step,comp,integration):
+        nonlocal device
+        device.reset()
+        disable()
+        
+        device.measurement_mode('SWE')
+        #smu2 is constant and common
+        device.smu_mode_meas(2,'COMM')
+        device.smu_function_sweep(2,'CONS')
+
+        #smu4 is VAR1 and V
+        device.smu_mode_meas(4,'V')
+        device.smu_function_sweep(4,'VAR1')
+
+        device.integration_time(integration)
+
+        #define double sweep
+        device.var1_mode('DOUB')
+        
+        #start stop step and comp
+        device.start_value_sweep(start)
+        #time.sleep(5)
+        device.step_sweep(step)
+        #time.sleep(5)
+        device.stop_value_sweep(stop)
+        #time.sleep(5)
+        device.comp('VAR1',comp)
+
+        #display variables
+        device.display_variable('X','V4')
+        device.display_variable('Y1','I4')
+
+        #execute measurement
+        device.single_measurement()
+        while device.operation_completed()==False:
+            pass
+        
+        device.autoscaling()
+
+        #return values
+        V=device.return_data('V4')
+        I=device.return_data('I4')
+
+        #convert the list to np.array to return the absolute values for the logarithmic scale
+        V = np.array(V)
+        I = np.array(I)
+
+        #return all values to the function
+        return V, I
+
+    #plot sweep results
+    def plot_sweep(x,y,title):
+        #plot results
+        plt.figure().clear()
+        fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+        fig.suptitle(title)
+        ax1.set_title('Linear I')
+        ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+        ax2.set_title('Logarithmic I')
+        ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+        ax2.set_yscale('log')
+
+        ax1.plot(x,y)
+        ax2.plot(x,np.absolute(y))
+        plt.tight_layout()
+        plt.show()
+
+    def initialize_file():
+        nonlocal DUT,file_path,file
+        if pc.selected!=None:
+            file_path = pc.selected
+        print(f"save results in:{file_path}")
+        file_name = DUT.value+"_Memristor.txt"
+        file = os.path.join(file_path,file_name)
+        
+        #check if file name exists 
+        i=1
+        while os.path.exists(file):
+            file_name = DUT.value+"_Memristor_"+str(i)+".txt"
+            file= os.path.join(file_path,file_name)
+            i=i+1
+        return file
+
+    def create_data_frame(x,y):
+        header = ['V','ABSV(V)',"I(A)",'ABSI(A)']
+        data = {header[0]:x,header[1]:np.absolute(x),header[2]:y,header[3]:np.absolute(y)}
+        df = pd.DataFrame(data)
+        print(df)
+        return df
+
+    def decode_ini(process):
+        nonlocal ini_file
+        
+        if fc.selected!=None:
+            ini_file= fc.selected
+        config = configparser.ConfigParser()
+        config.read(ini_file)
+        
+        #read the values
+        integration_time = config.get('Memristor','integration_time')
+        if integration_time!='SHOR' and integration_time!='MED' and integration_time!='LONG':
+            raise Exception('Integration time can be SHOR(short),MED(medium) or LONG(long)')
+       
+
+        comp=config.getfloat(process,'comp')
+        if abs(comp)>1:
+            raise Exception("current compliance can be from -1A to 1A")
+        
+        if process == 'SET':
+            voltage = config.getfloat(process,'voltage')
+            if voltage<=0 or voltage>200:
+                raise Exception('set voltage can be from 0V to 200V')
+
+        else:
+            voltage = config.getfloat(process,'voltage')
+            if voltage>=0 or voltage<-200:
+                raise Exception('set voltage can be from -200V to 0V')
+        
+        step=config.getfloat('Memristor','step')
+        step = abs(step)
+        if step>abs(voltage) or step ==0:
+            raise Exception('invalid step')
+
+        return voltage,comp,integration_time,step
+                        
+##############################################################################################################################################################        
+    #sampling follows in a bit...
+
+    #create buttons as it shown in the how_buttons_look 
+    set=widgets.Button(description='SET')
+    reset=widgets.Button(description='RESET')
+    sampling=widgets.Checkbox(description='sampling check')
+    full=widgets.Checkbox(description='full sweep')
+
+    #align a button with a checkbox horizontaly
+    line1 = widgets.HBox([set,sampling])
+    line2 = widgets.HBox([reset,full])
+
+    #pack them into a single vertical box
+    all = widgets.VBox([line1,line2])
+    output = widgets.Output()
+
+    #dispaly them all
+    display(all,output)
+
+    #handling events for the buttons:
+
+    widgets_list=[sampling,full,DUT,sample_series,field]
+
+    def disable_widgets():#only for not buttons
+        nonlocal widgets_list
+        for widget in widgets_list:
+            widget.disabled=True 
+
+    def on_set_button_clicked(b):
+        nonlocal Vset,CC_vset,step,integration_time,device,counter,full,V12,I12,V34,I34,file,DUT,sample_series,field,file_path,ini_file,widgets_list,set,reset
+        with output:
+            clear_output()
+            
+            #decode ini file
+            Vset,CC_vset,integration_time,step=decode_ini('SET')
+            
+            #disable the buttons set and reset
+            set.disabled = True
+            reset.disabled = True
+            
+            if counter == 0:
+                disable_widgets()
+                file = initialize_file()
+            counter=counter+1
+
+            #execute measurement,plot results and create dataframe
+            V12,I12=sweep(0,Vset,step,CC_vset,integration_time)
+            plot_sweep(V12,I12,'SET')
+            df=create_data_frame(V12,I12)
+            
+            #save results
+            with open(file, 'a', encoding='utf-8-sig') as f:    
+                title = f"SET Memristor:"+"\n"+f"sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n"+f"Set Voltage={Vset}V"+"\n"+f"current compliance={CC_vset}A"+"\n"
+
+                f.write(title)
+                f.write(df.to_string(index=False))
+                f.write("\n")
+                #f.close() outside the with block the file is closed
+
+            #plot all results if checkbox is clicked
+            if counter==2 and full.value == True:
+                time.sleep(3)
+                clear_output()
+                V = np.concatenate((V12,V34))
+                I = np.concatenate((I12,I34))
+                plot_sweep(V,I,'SET+RESET')
+
+            if counter == 1:
+                reset.disabled = False
+
+    def on_reset_button_clicked(b):
+        nonlocal Vreset,CC_vreset,step,integration_time,device,counter,full,V12,I12,V34,I34,file,DUT,sample_series,field,file_path,widgets_list,set,reset
+        with output:
+            clear_output()
+
+            #decode ini
+            Vreset,CC_vreset,integration_time,step=decode_ini('RESET')
+
+            #disable the buttons set and reset
+            set.disabled = True
+            reset.disabled = True
+            
+            if counter == 0:
+                disable_widgets()
+                file=initialize_file()
+                
+            counter=counter+1
+            
+            #execute measurement and plot results and create dataframe
+            V34,I34=sweep(0,Vreset,step,CC_vreset,integration_time)
+            plot_sweep(V34,I34,'RESET')
+            df = create_data_frame(V34,I34)
+
+            #save results
+            with open(file, 'a', encoding='utf-8-sig') as f:
+                title = f"RESET Memristor:"+"\n"+f"sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n"+f"Reset Voltage={Vreset}V"+"\n"+f"current compliance={CC_vreset}A"+"\n"
+
+                f.write(title)
+                f.write(df.to_string(index=False))
+                f.write("\n")
+                #f.close() outside the with block the file is closed 
+
+            #plot all results if checkbox is clicked
+            if counter==2 and full.value == True:
+                time.sleep(3)
+                clear_output()
+                V = np.concatenate((V12,V34))
+                I = np.concatenate((I12,I34))
+                plot_sweep(V,I,'SET+RESET')
+            
+            if counter == 1:
+                set.disabled = False             
+
+    #link buttons with functions
+    set.on_click(on_set_button_clicked)
+    reset.on_click(on_reset_button_clicked)
\ No newline at end of file
diff --git a/hp4155/memristor (Version 1.0)/old/memristor_version2.py b/hp4155/memristor (Version 1.0)/old/memristor_version2.py
new file mode 100644
index 0000000..73c20ff
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/old/memristor_version2.py	
@@ -0,0 +1,349 @@
+### this is the new memrstor measurement (set and reset as many times as the user wants and full sweeps with a button)
+from help import *
+import ipywidgets as widgets
+from keyboard import add_hotkey,remove_hotkey
+
+def memristor():
+    #parameters set by the user
+    Vset=1
+    CC_vset=10**(-3)
+    Vreset=-1
+    CC_vreset=10**(-3)
+    step = 0.02
+    integration_time='MED'
+    
+    #additional variables
+    first = True #first measurement
+    file_path =os.getcwd()
+    file = None
+
+    #default ini file
+    ini_file_path=os.getcwd()
+    ini_file_name=r"default.ini"
+    ini_file=os.path.join(ini_file_path,ini_file_name)
+
+    #filechooser 
+    fc = FileChooser(select_desc='load .ini')
+    fc.default_path = r"\\FILESERVER\public"
+    fc.filter_pattern = '*.ini'
+    display(fc)
+    #pathchooser 
+    pc = FileChooser(select_desc="save path")
+    pc.default_path = r"\\FILESERVER\public"
+    pc.show_only_dirs = True
+    display(pc)
+    print()
+    
+    # the three naming fields
+
+    sample_series= widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'sample series:',
+        style = {'description_width': 'initial'}
+    )
+    field = widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'Field:',
+        style = {'description_width': 'initial'},
+    )
+
+    DUT = widgets.Text(
+        value= '',
+        placeholder ='Enter text here:',
+        description = 'DUT:',
+        style = {'description_width': 'initial'},
+    )
+    
+    all_text_boxes = widgets.VBox([sample_series,field,DUT])
+    display(all_text_boxes)
+    print()
+
+    # THE BUTTONS 
+    #create buttons as it shown in the how_buttons_look 
+    set=widgets.Button(description='SET')
+    reset=widgets.Button(description='RESET')
+    sampling=widgets.Checkbox(description='sampling check')
+    full=widgets.Button(description='full sweep')
+    number = widgets.BoundedIntText(value=1,min=1,max=sys.maxsize,step=1,description='full sweeps:',disabled=False) #number of measuremts for the full sweep
+
+    #align a button with a checkbox or integer bounded texts horizontaly
+    line1 = widgets.HBox([set,sampling])
+    line3 = widgets.HBox([full,number])
+
+    #pack them into a single vertical box
+    all = widgets.VBox([line1,reset,line3])
+    output = widgets.Output()
+
+    #dispaly them all
+    display(all,output)
+
+    #connect to the device 
+    device = module.HP4155a('GPIB0::17::INSTR')
+    device.reset()
+
+    #disable all irrelevant units for the measurement
+    #smu1 and smu3 are disabled
+    device.smu_disable_sweep(1)
+    device.smu_disable_sweep(3)
+
+    #disable vmus and vsus
+    device.disable_vsu(1)
+    device.disable_vsu(2)
+    device.disable_vmu(1)
+    device.disable_vmu(2)
+
+    """ the above is what happens when the programm starts all the rest have to be written into button trigger functions"""
+    
+    def on_set_button_clicked(b):
+        nonlocal Vset,CC_vset,step,integration_time,device,first,DUT,sample_series,field,file_path,ini_file,file
+        with output:
+            #disable buttons
+            set.disabled = True
+            reset.disabled=True
+            full.disabled =True
+            number.disabled =True
+
+            clear_output()
+
+            #during first button press
+            if first == True:
+                sample_series.disabled = True
+                field.disabled = True
+                DUT.disabled = True
+                sampling.disabled = True
+                
+                #get ini file,and path from filechooser and open a new file 
+                if fc.selected!=None:
+                    ini_file = fc.selected
+                print(f"read parameters from ini:{ini_file}")
+                if pc.selected!=None:
+                    file_path = pc.selected
+                print(f"save results in:{file_path}")
+                file = initialize_file(sample_series,field,DUT,file_path)
+                first = False
+            
+            try:
+                #decode ini file
+                Vset,CC_vset,integration_time,step=decode_ini('SET',ini_file)
+
+                #execute measurement,plot results and save them
+                V12,I12 = sweep(0,Vset,step,CC_vset,integration_time,device)
+                plot_sweep(V12,I12,'SET')
+                df = create_data_frame(V12,I12)
+                title = f"SET Memristor:"+"\n\n"+f"Set Voltage={Vset}V"+"\n"+f"current compliance={CC_vset}A"+"\n"
+                write_to_file(file,title,df)
+                
+                #enable buttons
+                set.disabled = False
+                reset.disabled=False
+                full.disabled =False
+                number.disabled=False
+
+            
+            except Exception as e:
+                print(e)
+                print('please ensure that all parameters are correct')
+                set.disabled = False
+                reset.disabled=False
+                full.disabled =False
+                number.disabled=False
+
+
+    def on_reset_button_clicked(b):
+        nonlocal Vreset,CC_vreset,step,integration_time,device,first,DUT,sample_series,field,file_path,ini_file,file
+        with output:
+            set.disabled = True
+            reset.disabled=True
+            full.disabled =True
+            number.disabled=True
+
+            clear_output()
+
+            #during first button press
+            if first == True: 
+                #disable checkboxes, text fields etc.
+                sample_series.disabled = True
+                field.disabled = True
+                DUT.disabled = True
+                sampling.disabled = True
+
+                #get ini file,and path from filechooser and open a new file 
+                if fc.selected!=None:
+                    ini_file = fc.selected
+                print(f"read parameters from ini:{ini_file}")
+                if pc.selected!=None:
+                    file_path = pc.selected
+                print(f"save results in:{file_path}")
+                file = initialize_file(sample_series,field,DUT,file_path)
+                first = False #set first to false irrelvant if it is in the if statement or not
+            
+            try:
+                #decode ini file
+                Vreset,CC_vreset,integration_time,step=decode_ini('RESET',ini_file)
+
+                #execute measurement,plot results and save them
+                V34,I34 = sweep(0,Vreset,step,CC_vreset,integration_time,device)
+                plot_sweep(V34,I34,'RESET')
+                df = create_data_frame(V34,I34)
+                title =f"RESET Memristor:"+"\n\n"+f"Reset Voltage={Vreset}V"+"\n"+f"current compliance={CC_vreset}A"+"\n"
+                write_to_file(file,title,df)
+            
+                #enable buttons 
+                set.disabled = False
+                reset.disabled=False
+                full.disabled =False
+                number.disabled=False
+            
+            except Exception as e:
+                print(e)
+                print('please ensure that all parameters are correct')
+                set.disabled = False
+                reset.disabled=False
+                full.disabled =False
+                number.disabled=False
+    
+    def on_full_button_clicked(b):
+        nonlocal Vset,CC_vset,step,integration_time,device,first,DUT,sample_series,field,file_path,ini_file,file,Vreset,CC_vreset,number
+        with output:
+            
+            #disable buttons
+            set.disabled = True
+            reset.disabled=True
+            full.disabled =True
+            number.disabled=True
+            clear_output()
+
+            #during first button press
+            if first == True: 
+                #disable checkboxes, text fields etc.
+                sample_series.disabled = True
+                field.disabled = True
+                DUT.disabled = True
+                sampling.disabled = True
+
+                #get ini file,and path from filechooser and open a new file 
+                if fc.selected!=None:
+                    ini_file = fc.selected
+                print(f"read parameters from ini:{ini_file}")
+                if pc.selected!=None:
+                    file_path = pc.selected
+                print(f"save results in:{file_path}")
+                file = initialize_file(sample_series,field,DUT,file_path)
+                first = False
+
+            try:
+                #decode ini
+                Vreset,CC_vreset,integration_time,step=decode_ini('RESET',ini_file)
+                Vset,CC_vset,integration_time,step=decode_ini('SET',ini_file)
+
+
+                with open(file,'a') as f:
+                    f.write(f"{number.value} full sweeps with parameters:")
+                    f.write("\n")
+                    f.write(f"Set Voltage = {Vset}V")
+                    f.write("\n")
+                    f.write(f"Current compliance set = {CC_vset}")
+                    f.write("\n")
+                    f.write(f"Reset Voltage = {Vreset}V")
+                    f.write("\n")
+                    f.write(f"Current compliance reset = {CC_vreset}")
+                    f.write("\n\n")
+                
+                
+                    plt.figure().clear()
+                    fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+                    fig.suptitle('FULL SWEEP')
+                    ax1.set_title('Linear I')
+                    ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                    ax2.set_title('Logarithmic I')
+                    ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                    ax2.set_yscale('log')
+
+                    stop = False
+
+                    def break_loop():
+                        nonlocal stop
+                        stop = True
+                        
+                    add_hotkey("esc",break_loop)
+                    #execute number of measurements
+                    for i in range(number.value):
+                        V12,I12 = sweep(0,Vset,step,CC_vset,integration_time,device) #set
+                        V34,I34 = sweep(0,Vreset,step,CC_vreset,integration_time,device) #reset
+
+                        #butterfly curve
+                        V=np.concatenate((V12,V34))
+                        I=np.concatenate((I12,I34))
+
+                        #create data frame and save to file
+                        df = create_data_frame(V,I)
+                        f.write(f"{i+1} Iteration")
+                        f.write("\n")
+                        f.write(df.to_string())
+                        f.write("\n\n")
+
+                        #plot results
+                        ax1.plot(V,I)
+                        ax2.plot(V,np.absolute(I))
+                        fig.tight_layout()
+
+                        #update plot 
+                        clear_output(wait = True)
+                        display(fig)
+                        print(df)
+
+                        #check for loop termination
+                        if stop == True:
+                            print("endurance stopped after esc!")
+                            f.write("endurance stopped!\n\n")
+                            break
+                    else:
+                        print("endurance completed!")
+                        f.write("endurance completed!\n\n")
+                        
+
+                    remove_hotkey('esc')
+                    stop = False
+                    
+                    set.disabled = False
+                    reset.disabled=False
+                    full.disabled =False
+                    number.disabled=False
+            
+            except Exception as e:
+                print(e)
+                print('please ensure that all parameters are correct')
+                set.disabled = False
+                reset.disabled=False
+                full.disabled =False
+                number.disabled=False
+    
+    #link buttons with functions
+    set.on_click(on_set_button_clicked)
+    reset.on_click(on_reset_button_clicked)
+    full.on_click(on_full_button_clicked)
+
+                    
+            
+                
+                
+                
+                
+                
+                
+                
+                
+
+            
+    
+            
+                    
+        
+
+    
+
+    
+    
+    
\ No newline at end of file
diff --git a/hp4155/memristor (Version 1.0)/old/old_functions.py b/hp4155/memristor (Version 1.0)/old/old_functions.py
new file mode 100644
index 0000000..b3cb17f
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/old/old_functions.py	
@@ -0,0 +1,86 @@
+"""These are old help functions and their dependances"""
+
+from ipyfilechooser import FileChooser
+import configparser
+
+
+def decode_ini(process,ini_file):     
+    #if fc.selected!=None:
+        #ini_file= fc.selected
+    config = configparser.ConfigParser()
+    config.read(ini_file)
+        
+    #read the values
+    integration_time = config.get('Memristor','integration_time')
+    if integration_time!='SHOR' and integration_time!='MED' and integration_time!='LONG':
+        raise Exception('Integration time can be SHOR(short),MED(medium) or LONG(long)')
+       
+    comp=config.getfloat(process,'comp')
+    if abs(comp)>1:
+        raise Exception("current compliance can be from -1A to 1A")
+        
+    if process == 'SET':
+        voltage = config.getfloat(process,'voltage')
+        if voltage<=0 or voltage>200:
+            raise Exception('set voltage can be from 0V to 200V')
+
+    else:
+        voltage = config.getfloat(process,'voltage')
+        if voltage>=0 or voltage<-200:
+            raise Exception('set voltage can be from -200V to 0V')
+    #here an elif for the full sweep or in a full sweep function
+        
+    step=config.getfloat('Memristor','step')
+    step = abs(step)
+    if step>abs(voltage) or step ==0:
+        raise Exception('invalid step')
+
+    return voltage,comp,integration_time,step
+
+
+def initialize_file(sample_series,field,DUT,file_path):
+    #if pc.selected!=None:
+        #file_path = pc.selected
+    #print(f"save results in:{file_path}")
+    file_name = DUT.value+"_Memristor.txt"
+    file = os.path.join(file_path,file_name)
+        
+    #check if file name exists 
+    i=1
+    while os.path.exists(file):
+        file_name = DUT.value+"_Memristor_"+str(i)+".txt"
+        file= os.path.join(file_path,file_name)
+        i=i+1
+    
+    #write sample series
+    with open(file,'a') as f:
+        title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n\n"
+        f.write(title)
+    return file
+
+#works
+def initialize_tkinter(sample_series,field,DUT):
+    #open dialog and hide the main window
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile = f'{sample_series.value}_{field.value}_{DUT.value}.txt')
+
+    #check if the file path is correct(.txt)
+    while file_path.endswith(".txt") == False:
+        #open again filedialog with error message box
+        tk.messagebox.showerror(message='invalid filename!')
+        file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile = f'{sample_series.value}_{field.value}_{DUT.value}.txt')
+
+    #the first time open the file in write mode!(replaces the old file)
+    #write sample series
+    with open(file_path,'w') as f:
+        title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n\n"
+        f.write(title)
+
+    root.destroy()
+    #return the file path
+    return file_path
diff --git a/hp4155/memristor (Version 1.0)/tests/how_buttons_look.ipynb b/hp4155/memristor (Version 1.0)/tests/how_buttons_look.ipynb
new file mode 100644
index 0000000..38c7af4
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/tests/how_buttons_look.ipynb	
@@ -0,0 +1,740 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "6d955a9f-629b-4bf5-be97-b4ae534824a0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import ipywidgets as widgets\n",
+    "from ipyfilechooser import FileChooser\n",
+    "import sys"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b0ed6115-9df5-4ff7-b4dc-146c83fe50c5",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "reset=widgets.Button(description='RESET')\n",
+    "set=widgets.Button(description='SET')\n",
+    "sampling=widgets.Checkbox(description='sampling check')\n",
+    "full=widgets.Checkbox(description='full sweep')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "ed90b452-1aa0-4b8d-892c-87f161d9c81f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "line1=widgets.HBox([set,sampling])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "256f987e-04fd-4089-8e4f-c86ae9360c98",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "line2=widgets.HBox([reset,full])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "720bf813-db95-46c6-a426-4b04d0e87677",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all = widgets.VBox([line1,line2])\n",
+    "output = widgets.Output()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "ac715ba2-fac6-421d-901d-de7ee250bc89",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "498a303de00d4818ac680f2e38389695",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Button(description='SET', style=ButtonStyle()), Checkbox(value=False, descriptio…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "bc164da1b02c4f2a92760b9eb2a80e37",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(all,output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "fd0ccb93-6b61-4e49-9952-f6bb6dd3c471",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sampling.value\n",
+    "sampling.disabled=True"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "a7fa339d-8d0f-4d4c-800a-5d8d52ff11d5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "sampling.value"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f10795c4-76b1-40a4-a28d-b6b354d1afe3",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# the three naming fields\n",
+    "\n",
+    "sample_series= widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'sample series:',\n",
+    "    style = {'description_width': 'initial'}\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "0e6e7449-275f-43fc-bd8e-048c72033713",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9d3f34e078ec45d19c078d7a27d02514",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Text(value='', description='sample series:', placeholder='Enter text here:', style=TextStyle(description_width…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(sample_series)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "df28834c-de9e-4072-a18b-6b1fdf246b01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sample_series.disabled = False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "26a809a8-5f8e-4a4f-a390-9a119978a223",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "field = widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'Field:',\n",
+    "    style = {'description_width': 'initial'},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9e41b95e-3961-44e8-b80e-707a71c98ffd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "05128f937400431cb70fa88e54ac603d",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Text(value='', description='Field:', placeholder='Enter text here:', style=TextStyle(description_width='initia…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(field)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "f1284c6d-a847-4104-8208-a2f785c4fb3d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "DUT = widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'DUT:',\n",
+    "    style = {'description_width': 'initial'},\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "71204ea2-3b7b-4a69-9639-1ace2fb7b9ec",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "e1d55202858343119ec5c8031eec5f8a",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Text(value='', description='DUT:', placeholder='Enter text here:', style=TextStyle(description_width='initial'…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(DUT)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "dc107383-f558-4cea-95cb-7b4aa0ff2cef",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_text_boxes = widgets.VBox([sample_series,field,DUT])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "d9e2b71f-68c4-4228-a6ec-12439e57938c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "10dddd491221439d80aefe1bc6008af9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='', description='sample series:', placeholder='Enter text here:', style=TextStyle(de…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "display(all_text_boxes)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "342522c9-0d49-421f-bd36-bd6143de783c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "all_text_boxes.disabled= False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "f76363a2-f9e4-4cf3-81cb-9b2d12c6ce28",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c4ef63ca15c64e8fb4d02266224b16bb",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FileChooser(path='\\\\FILESERVER\\public', filename='', title='', show_hidden=False, select_desc='save results', …"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "pc = FileChooser(select_desc=\"save results\")\n",
+    "pc.default_path = r\"\\\\FILESERVER\\public\"\n",
+    "pc.show_only_dirs = True\n",
+    "display(pc)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "bd697c90-2c85-4f88-993f-02767474f004",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c9b9a0e5d65241f682cec0b9a42c6807",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FileChooser(path='\\\\FILESERVER\\public', filename='', title='', show_hidden=False, select_desc='load .ini', cha…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "d4b2ed2d10c042bc95a92f7e493c8e27",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "FileChooser(path='\\\\FILESERVER\\public', filename='', title='', show_hidden=False, select_desc='save path', cha…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "f79913da61ce4ca59a26b162e26fc661",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='', description='sample series:', placeholder='Enter text here:', style=TextStyle(de…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "c221f4c1a88d4c8d8e42a7656d7d6e12",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Button(description='SET', style=ButtonStyle()), Checkbox(value=False, descriptio…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "2641f6368b5f493ea711a23ad9735eb9",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#final version of buttons\n",
+    "#filechooser \n",
+    "fc = FileChooser(select_desc='load .ini')\n",
+    "fc.default_path = r\"\\\\FILESERVER\\public\"\n",
+    "fc.filter_pattern = '*.ini'\n",
+    "display(fc)\n",
+    "#pathchooser \n",
+    "pc = FileChooser(select_desc=\"save path\")\n",
+    "pc.default_path = r\"\\\\FILESERVER\\public\"\n",
+    "pc.show_only_dirs = True\n",
+    "display(pc)\n",
+    "print()\n",
+    "\n",
+    "    \n",
+    "# the three naming fields\n",
+    "\n",
+    "sample_series= widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'sample series:',\n",
+    "    style = {'description_width': 'initial'}\n",
+    ")\n",
+    "field = widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'Field:',\n",
+    "    style = {'description_width': 'initial'},\n",
+    ")\n",
+    "\n",
+    "DUT = widgets.Text(\n",
+    "    value= '',\n",
+    "    placeholder ='Enter text here:',\n",
+    "    description = 'DUT:',\n",
+    "    style = {'description_width': 'initial'},\n",
+    ")\n",
+    "\n",
+    "all_text_boxes = widgets.VBox([sample_series,field,DUT])\n",
+    "display(all_text_boxes)\n",
+    "print()\n",
+    "\n",
+    "#create buttons as it shown in the how_buttons_look \n",
+    "set=widgets.Button(description='SET')\n",
+    "reset=widgets.Button(description='RESET')\n",
+    "sampling=widgets.Checkbox(description='sampling check')\n",
+    "full=widgets.Checkbox(description='full sweep')\n",
+    "\n",
+    "#align a button with a checkbox horizontaly\n",
+    "line1 = widgets.HBox([set,sampling])\n",
+    "line2 = widgets.HBox([reset,full])\n",
+    "\n",
+    "#pack them into a single vertical box\n",
+    "all = widgets.VBox([line1,line2])\n",
+    "output = widgets.Output()\n",
+    "\n",
+    "#dispaly them all\n",
+    "display(all,output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "4ee60013-352b-4d32-b137-2a0fa0b9953e",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "259be64afd1244e0ae569c15ce5d7ff6",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(Text(value='', description='sample series:', placeholder='Enter text here:', style=TextStyle(de…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "94152fdea86a4711b2f460e5e164c4d4",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Button(description='SET', style=ButtonStyle()), Checkbox(value=False, descriptio…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "9847e6a3f82a4ff586b2c6079561fe58",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sample_series= widgets.Text(\n",
+    "        value= '',\n",
+    "        placeholder ='Enter text here:',\n",
+    "        description = 'sample series:',\n",
+    "        style = {'description_width': 'initial'}\n",
+    "    )\n",
+    "field = widgets.Text(\n",
+    "        value= '',\n",
+    "        placeholder ='Enter text here:',\n",
+    "        description = 'Field:',\n",
+    "        style = {'description_width': 'initial'},\n",
+    "    )\n",
+    "\n",
+    "DUT = widgets.Text(\n",
+    "        value= '',\n",
+    "        placeholder ='Enter text here:',\n",
+    "        description = 'DUT:',\n",
+    "        style = {'description_width': 'initial'},\n",
+    "    )\n",
+    "    \n",
+    "all_text_boxes = widgets.VBox([sample_series,field,DUT])\n",
+    "display(all_text_boxes)\n",
+    "print()\n",
+    "\n",
+    "# THE BUTTONS \n",
+    "#create buttons as it shown in the how_buttons_look \n",
+    "set=widgets.Button(description='SET')\n",
+    "reset=widgets.Button(description='RESET')\n",
+    "sampling=widgets.Checkbox(description='sampling check')\n",
+    "full=widgets.Button(description='full sweep')\n",
+    "number = widgets.BoundedIntText(value=1,min=1,max=sys.maxsize,step=1,description='full sweeps:',disabled=False) #number of measuremts for the full sweep\n",
+    "\n",
+    "#align a button with a checkbox or integer bounded texts horizontaly\n",
+    "line1 = widgets.HBox([set,sampling])\n",
+    "line3 = widgets.HBox([full,number])\n",
+    "\n",
+    "#pack them into a single vertical box\n",
+    "all = widgets.VBox([line1,reset,line3])\n",
+    "output = widgets.Output()\n",
+    "\n",
+    "#dispaly them all\n",
+    "display(all,output)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "4df29b64-60b0-482b-b64f-4041afee042f",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n",
+      "<class 'int'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "number.disabled = True\n",
+    "print(number.value)\n",
+    "print(type(number.value))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "2063a5db-1b3e-4563-9031-3e8866a1293f",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "pc= None\n",
+    "def create():\n",
+    "    \n",
+    "\n",
+    "def druck():\n",
+    "    print(pc.selected)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "410ac261-0419-4422-9930-a4daf24bdb41",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "None\n"
+     ]
+    }
+   ],
+   "source": [
+    "druck()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "047ae36a-204c-4b4b-be15-343d1b3c9f46",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np \n",
+    "\n",
+    "x1 = np.array([0,1,3])\n",
+    "x2 = np.array([0,1,2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8d280dcc-fcf8-4afa-b405-aefed48422f4",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0 1 3]\n",
+      "[0 1 2]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x1)\n",
+    "print(x2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "91ebd23b-0cfd-4cc1-b800-47d6ab89f857",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\user\\AppData\\Local\\Temp\\ipykernel_2700\\2797304533.py:1: RuntimeWarning: invalid value encountered in divide\n",
+      "  x3 = np.divide(x1,x2)\n"
+     ]
+    }
+   ],
+   "source": [
+    "x3 = np.divide(x1,x2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "09b1b543-aba6-4514-ad89-43c54b62a602",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[nan 1.  1.5]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(x3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "5d01fa30-0c1d-4e89-9fb5-74e9e3af6511",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor (Version 1.0)/tests/memristor.ipynb b/hp4155/memristor (Version 1.0)/tests/memristor.ipynb
new file mode 100644
index 0000000..f37c997
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/tests/memristor.ipynb	
@@ -0,0 +1,475 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8803a478-f755-4fb2-8fdd-9c7363b5fc2c",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys\n",
+    "sys.path.append(r\"C:\\Users\\user\\labcode\\hp4155\")\n",
+    "\n",
+    "import module\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from IPython.display import display, clear_output\n",
+    "\n",
+    "\n",
+    "# In this measurement SMU2 and SMU4 are used which are closer to the user\n",
+    "#smu4 is the voltage source and smu2 is ground\n",
+    "#how to use current complnance??\n",
+    "\n",
+    "#parameters set by the user\n",
+    "Vset=1\n",
+    "CC_vset=10**(-3)\n",
+    "Vreset=-1\n",
+    "CC_vreset=10**(-3)\n",
+    "step = 0.02\n",
+    "voltage=[]\n",
+    "current=[]\n",
+    "abs_current=[]\n",
+    "abs_voltage=[]\n",
+    "\n",
+    "#connect to the device\n",
+    "device = module.HP4155a('GPIB0::17::INSTR')\n",
+    "device.reset()\n",
+    "\n",
+    "\n",
+    "#setup device\n",
+    "#smu1 and smu3 are disabled\n",
+    "device.smu_disable_sweep(1)\n",
+    "device.smu_disable_sweep(3)\n",
+    "\n",
+    "#disable vmus and vsus\n",
+    "device.disable_vsu(1)\n",
+    "device.disable_vsu(2)\n",
+    "device.disable_vmu(1)\n",
+    "device.disable_vmu(2)\n",
+    "\n",
+    "\n",
+    "#smu2 is constant and common\n",
+    "device.smu_mode_meas(2,'COMM')\n",
+    "device.smu_function_sweep(2,'CONS')\n",
+    "\n",
+    "#smu4 is VAR1 and V\n",
+    "device.smu_mode_meas(4,'V')\n",
+    "device.smu_function_sweep(4,'VAR1')\n",
+    "\n",
+    "device.integration_time('MED')\n",
+    "\n",
+    "#user functions\n",
+    "device.user_function('ABSV','V','ABS(V4)')\n",
+    "device.user_function('ABSI','A','ABS(I4)')\n",
+    "\n",
+    "#display variables\n",
+    "device.display_variable('X','V4')\n",
+    "device.display_variable('Y1','I4')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "6a55c180-30ff-4d37-b06e-c306a75b00d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0, 0.02, 0.04, 0.06, 0.08, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2, 0.22, 0.24, 0.26, 0.28, 0.3, 0.32, 0.34, 0.36, 0.38, 0.4, 0.42, 0.44, 0.46, 0.48, 0.5, 0.52, 0.54, 0.56, 0.58, 0.6, 0.62, 0.64, 0.66, 0.68, 0.7, 0.72, 0.74, 0.76, 0.78, 0.8, 0.82, 0.84, 0.86, 0.88, 0.9, 0.92, 0.94, 0.96, 0.98, 1.0]\n",
+      "51\n",
+      "[3.1e-13, 3.7e-13, -4e-13, -4.9e-13, 5e-14, -4.6e-13, 3e-13, 2.5e-13, 3.2e-13, 4.7e-13, 1.7e-13, -2.6e-13, 2e-14, 6e-14, 2e-13, 2.2e-13, 6e-13, -2.1e-13, 2e-13, 1.5e-13, 2.9e-13, 9e-14, 5e-14, 4e-13, -2.1e-13, 1.1e-13, 6.3e-13, 1e-14, 2.6e-13, 2.3e-13, -3.5e-13, 1.3e-13, 1.3e-13, 2.53e-12, -8.4e-13, -1.02e-11, -1.284e-11, -1.333e-11, -9.35e-12, -3.58e-12, 3.25e-12, 2.79e-12, 8.5e-13, 1.41e-12, 1.42e-12, 1.18e-12, 9.8e-13, 9e-13, 9.7e-13, 1.16e-12, 6.1e-13]\n",
+      "51\n",
+      "[0.0, 0.02, 0.04, 0.06, 0.08, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2, 0.22, 0.24, 0.26, 0.28, 0.3, 0.32, 0.34, 0.36, 0.38, 0.4, 0.42, 0.44, 0.46, 0.48, 0.5, 0.52, 0.54, 0.56, 0.58, 0.6, 0.62, 0.64, 0.66, 0.68, 0.7, 0.72, 0.74, 0.76, 0.78, 0.8, 0.82, 0.84, 0.86, 0.88, 0.9, 0.92, 0.94, 0.96, 0.98, 1.0]\n",
+      "51\n",
+      "[3.1e-13, 3.7e-13, 4e-13, 4.9e-13, 5e-14, 4.6e-13, 3e-13, 2.5e-13, 3.2e-13, 4.7e-13, 1.7e-13, 2.6e-13, 2e-14, 6e-14, 2e-13, 2.2e-13, 6e-13, 2.1e-13, 2e-13, 1.5e-13, 2.9e-13, 9e-14, 5e-14, 4e-13, 2.1e-13, 1.1e-13, 6.3e-13, 1e-14, 2.6e-13, 2.3e-13, 3.5e-13, 1.3e-13, 1.3e-13, 2.53e-12, 8.4e-13, 1.02e-11, 1.284e-11, 1.333e-11, 9.35e-12, 3.58e-12, 3.25e-12, 2.79e-12, 8.5e-13, 1.41e-12, 1.42e-12, 1.18e-12, 9.8e-13, 9e-13, 9.7e-13, 1.16e-12, 6.1e-13]\n",
+      "51\n",
+      "[1.0, 0.98, 0.96, 0.94, 0.92, 0.9, 0.88, 0.86, 0.84, 0.82, 0.8, 0.78, 0.76, 0.74, 0.72, 0.7, 0.68, 0.66, 0.64, 0.62, 0.6, 0.58, 0.56, 0.54, 0.52, 0.5, 0.48, 0.46, 0.44, 0.42, 0.4, 0.38, 0.36, 0.34, 0.32, 0.3, 0.28, 0.26, 0.24, 0.22, 0.2, 0.18, 0.16, 0.14, 0.12, 0.1, 0.08, 0.06, 0.04, 0.02, 0.0]\n",
+      "51\n",
+      "[3.3e-13, 3.2e-13, 0.0, 7.6e-13, 3.3e-13, 3.8e-13, 4.4e-13, 2.5e-13, -9e-14, 3e-13, 0.0, -4e-14, 3.4e-13, -6e-14, 7e-14, 3.6e-13, 7e-14, -9e-14, 2.8e-13, 3.7e-13, -1e-14, -6e-14, 7.2e-13, -7.5e-13, -1.03e-12, -8.5e-13, -1.47e-12, 8.3e-13, -2e-13, 8.3e-13, 1.41e-12, 6.5e-13, 4.6e-13, 4.3e-13, 4e-13, 3.3e-13, 5.4e-13, 4.9e-13, 1.7e-13, 3.9e-13, 4.8e-13, -1.2e-13, 6e-13, 3e-13, 2.3e-13, 2.7e-13, 4.9e-13, 2.5e-13, 2.7e-13, 2e-14, 4.8e-13]\n",
+      "51\n",
+      "[1.0, 0.98, 0.96, 0.94, 0.92, 0.9, 0.88, 0.86, 0.84, 0.82, 0.8, 0.78, 0.76, 0.74, 0.72, 0.7, 0.68, 0.66, 0.64, 0.62, 0.6, 0.58, 0.56, 0.54, 0.52, 0.5, 0.48, 0.46, 0.44, 0.42, 0.4, 0.38, 0.36, 0.34, 0.32, 0.3, 0.28, 0.26, 0.24, 0.22, 0.2, 0.18, 0.16, 0.14, 0.12, 0.1, 0.08, 0.06, 0.04, 0.02, 0.0]\n",
+      "51\n",
+      "[3.3e-13, 3.2e-13, 0.0, 7.6e-13, 3.3e-13, 3.8e-13, 4.4e-13, 2.5e-13, 9e-14, 3e-13, 0.0, 4e-14, 3.4e-13, 6e-14, 7e-14, 3.6e-13, 7e-14, 9e-14, 2.8e-13, 3.7e-13, 1e-14, 6e-14, 7.2e-13, 7.5e-13, 1.03e-12, 8.5e-13, 1.47e-12, 8.3e-13, 2e-13, 8.3e-13, 1.41e-12, 6.5e-13, 4.6e-13, 4.3e-13, 4e-13, 3.3e-13, 5.4e-13, 4.9e-13, 1.7e-13, 3.9e-13, 4.8e-13, 1.2e-13, 6e-13, 3e-13, 2.3e-13, 2.7e-13, 4.9e-13, 2.5e-13, 2.7e-13, 2e-14, 4.8e-13]\n",
+      "51\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#set measurement\n",
+    "#define start-step-stop and current compliance\n",
+    "device.start_value_sweep(0)\n",
+    "device.step_sweep(step)\n",
+    "device.stop_value_sweep(Vset)\n",
+    "device.comp('VAR1',CC_vset)\n",
+    "\n",
+    "#start measurement (step 1)\n",
+    "device.single_measurement()\n",
+    "while device.operation_completed()==False:\n",
+    "    pass\n",
+    "\n",
+    "device.autoscaling()\n",
+    "\n",
+    "V=device.return_data('V4')\n",
+    "I=device.return_data('I4')\n",
+    "ABSV=device.return_data('ABSV')\n",
+    "ABSI=device.return_data('ABSI')\n",
+    "\n",
+    "#test\n",
+    "print(V)\n",
+    "print(len(V))\n",
+    "print(I)\n",
+    "print(len(I))\n",
+    "print(ABSV)\n",
+    "print(len(ABSV))\n",
+    "print(ABSI)\n",
+    "print(len(ABSI))\n",
+    "\n",
+    "voltage.append(V)\n",
+    "current.append(I)\n",
+    "abs_current.append(ABSI)\n",
+    "abs_voltage.append(ABSV)\n",
+    "\n",
+    "#step 2 from vset to 0\n",
+    "device.start_value_sweep(Vset)\n",
+    "device.step_sweep(step)\n",
+    "device.stop_value_sweep(0)\n",
+    "device.comp('VAR1',CC_vset)\n",
+    "\n",
+    "#start measurement (step 1)\n",
+    "device.single_measurement()\n",
+    "while device.operation_completed()==False:\n",
+    "    pass\n",
+    "\n",
+    "device.autoscaling()\n",
+    "\n",
+    "V=device.return_data('V4')\n",
+    "I=device.return_data('I4')\n",
+    "ABSV=device.return_data('ABSV')\n",
+    "ABSI=device.return_data('ABSI')\n",
+    "\n",
+    "#test\n",
+    "print(V)\n",
+    "print(len(V))\n",
+    "print(I)\n",
+    "print(len(I))\n",
+    "print(ABSV)\n",
+    "print(len(ABSV))\n",
+    "print(ABSI)\n",
+    "print(len(ABSI))\n",
+    "\n",
+    "voltage.append(V)\n",
+    "current.append(I)\n",
+    "abs_current.append(ABSI)\n",
+    "abs_voltage.append(ABSV)\n",
+    "\n",
+    "#plot results\n",
+    "plt.figure().clear()\n",
+    "fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis \n",
+    "fig.suptitle('SET')\n",
+    "ax1.set_title('Linear I')\n",
+    "ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_title('Logarithmic I')\n",
+    "ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_yscale('log')\n",
+    "\n",
+    "ax1.plot(voltage[0],current[0],color='tab:red',label='HRS')\n",
+    "ax1.plot(voltage[1],current[1],color='tab:green',label='LRS')\n",
+    "ax2.plot(voltage[0],abs_current[0],color='tab:red',label='HRS')\n",
+    "ax2.plot(voltage[1],abs_current[1],color='tab:green',label='LRS')\n",
+    "\n",
+    "ax1.legend(loc='best')\n",
+    "ax2.legend(loc=\"best\")\n",
+    "fig.tight_layout()\n",
+    "display(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "d2f989ad-6751-4a37-b253-426f06c35213",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[0.0, -0.02, -0.04, -0.06, -0.08, -0.1, -0.12, -0.14, -0.16, -0.18, -0.2, -0.22, -0.24, -0.26, -0.28, -0.3, -0.32, -0.34, -0.36, -0.38, -0.4, -0.42, -0.44, -0.46, -0.48, -0.5, -0.52, -0.54, -0.56, -0.58, -0.6, -0.62, -0.64, -0.66, -0.68, -0.7, -0.72, -0.74, -0.76, -0.78, -0.8, -0.82, -0.84, -0.86, -0.88, -0.9, -0.92, -0.94, -0.96, -0.98, -1.0]\n",
+      "51\n",
+      "[-4e-14, 9e-14, 1.6e-13, 1.2e-13, 2.6e-13, 5e-14, -6e-14, 1.9e-13, -1.6e-13, 3e-13, 2e-14, 3e-14, 2.9e-13, -1e-13, 3.5e-13, -3e-14, 1e-14, 1.8e-13, 1.2e-13, 1.1e-13, 1.1e-13, 7e-14, 3e-14, 2e-14, 3.2e-13, -1.1e-13, 2.7e-13, 1.4e-13, -1e-14, 1.3e-13, 1.1e-13, 1.5e-13, 1.2e-13, 1.9e-13, 4e-14, 9e-14, 1e-13, -1.7e-13, 3e-14, 1.3e-13, 4.5e-13, -3.4e-13, 1.73e-12, 3.32e-12, 3.06e-12, 3.41e-12, 3.45e-12, 3.52e-12, 3.33e-12, 2.04e-12, 1.14e-12]\n",
+      "51\n",
+      "[0.0, 0.02, 0.04, 0.06, 0.08, 0.1, 0.12, 0.14, 0.16, 0.18, 0.2, 0.22, 0.24, 0.26, 0.28, 0.3, 0.32, 0.34, 0.36, 0.38, 0.4, 0.42, 0.44, 0.46, 0.48, 0.5, 0.52, 0.54, 0.56, 0.58, 0.6, 0.62, 0.64, 0.66, 0.68, 0.7, 0.72, 0.74, 0.76, 0.78, 0.8, 0.82, 0.84, 0.86, 0.88, 0.9, 0.92, 0.94, 0.96, 0.98, 1.0]\n",
+      "51\n",
+      "[4e-14, 9e-14, 1.6e-13, 1.2e-13, 2.6e-13, 5e-14, 6e-14, 1.9e-13, 1.6e-13, 3e-13, 2e-14, 3e-14, 2.9e-13, 1e-13, 3.5e-13, 3e-14, 1e-14, 1.8e-13, 1.2e-13, 1.1e-13, 1.1e-13, 7e-14, 3e-14, 2e-14, 3.2e-13, 1.1e-13, 2.7e-13, 1.4e-13, 1e-14, 1.3e-13, 1.1e-13, 1.5e-13, 1.2e-13, 1.9e-13, 4e-14, 9e-14, 1e-13, 1.7e-13, 3e-14, 1.3e-13, 4.5e-13, 3.4e-13, 1.73e-12, 3.32e-12, 3.06e-12, 3.41e-12, 3.45e-12, 3.52e-12, 3.33e-12, 2.04e-12, 1.14e-12]\n",
+      "51\n",
+      "[-1.0, -0.98, -0.96, -0.94, -0.92, -0.9, -0.88, -0.86, -0.84, -0.82, -0.8, -0.78, -0.76, -0.74, -0.72, -0.7, -0.68, -0.66, -0.64, -0.62, -0.6, -0.58, -0.56, -0.54, -0.52, -0.5, -0.48, -0.46, -0.44, -0.42, -0.4, -0.38, -0.36, -0.34, -0.32, -0.3, -0.28, -0.26, -0.24, -0.22, -0.2, -0.18, -0.16, -0.14, -0.12, -0.1, -0.08, -0.06, -0.04, -0.02, 0.0]\n",
+      "51\n",
+      "[-9e-14, 3.6e-13, -4e-14, -2.08e-12, -7.3e-13, -1.9e-13, 2.3e-12, 7.66e-12, 5.36e-12, 1.051e-11, -4.3e-13, 1.59e-12, 1.3e-12, -1.2e-13, -1.3e-13, -4.9e-13, 1.05e-12, -2.08e-12, 4.4e-13, 4.1e-13, -8.7e-13, 1.1e-12, 5e-14, 1.2e-13, -5.8e-13, 2.2e-13, 4.1e-13, 3e-13, -1.39e-12, -5e-13, 3e-14, 4.6e-13, -2.18e-12, 1.3e-13, 4e-13, 3.1e-13, -1.51e-12, 1.1e-13, 7.2e-13, -1.47e-12, 2.6e-13, 9e-14, -1.4e-13, 2.1e-13, -3.2e-13, 3.8e-13, -1.1e-13, -7.8e-13, -3.7e-13, -8e-14, -4e-14]\n",
+      "51\n",
+      "[1.0, 0.98, 0.96, 0.94, 0.92, 0.9, 0.88, 0.86, 0.84, 0.82, 0.8, 0.78, 0.76, 0.74, 0.72, 0.7, 0.68, 0.66, 0.64, 0.62, 0.6, 0.58, 0.56, 0.54, 0.52, 0.5, 0.48, 0.46, 0.44, 0.42, 0.4, 0.38, 0.36, 0.34, 0.32, 0.3, 0.28, 0.26, 0.24, 0.22, 0.2, 0.18, 0.16, 0.14, 0.12, 0.1, 0.08, 0.06, 0.04, 0.02, 0.0]\n",
+      "51\n",
+      "[9e-14, 3.6e-13, 4e-14, 2.08e-12, 7.3e-13, 1.9e-13, 2.3e-12, 7.66e-12, 5.36e-12, 1.051e-11, 4.3e-13, 1.59e-12, 1.3e-12, 1.2e-13, 1.3e-13, 4.9e-13, 1.05e-12, 2.08e-12, 4.4e-13, 4.1e-13, 8.7e-13, 1.1e-12, 5e-14, 1.2e-13, 5.8e-13, 2.2e-13, 4.1e-13, 3e-13, 1.39e-12, 5e-13, 3e-14, 4.6e-13, 2.18e-12, 1.3e-13, 4e-13, 3.1e-13, 1.51e-12, 1.1e-13, 7.2e-13, 1.47e-12, 2.6e-13, 9e-14, 1.4e-13, 2.1e-13, 3.2e-13, 3.8e-13, 1.1e-13, 7.8e-13, 3.7e-13, 8e-14, 4e-14]\n",
+      "51\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#step 3 from 0 to vreset\n",
+    "#define start-step-stop and current compliance\n",
+    "device.start_value_sweep(0)\n",
+    "device.step_sweep(step)\n",
+    "device.stop_value_sweep(Vreset)\n",
+    "device.comp('VAR1',CC_vreset)\n",
+    "\n",
+    "#start measurement (step 1)\n",
+    "device.single_measurement()\n",
+    "while device.operation_completed()==False:\n",
+    "    pass\n",
+    "\n",
+    "device.autoscaling()\n",
+    "\n",
+    "V=device.return_data('V4')\n",
+    "I=device.return_data('I4')\n",
+    "ABSV=device.return_data('ABSV')\n",
+    "ABSI=device.return_data('ABSI')\n",
+    "\n",
+    "#test\n",
+    "print(V)\n",
+    "print(len(V))\n",
+    "print(I)\n",
+    "print(len(I))\n",
+    "print(ABSV)\n",
+    "print(len(ABSV))\n",
+    "print(ABSI)\n",
+    "print(len(ABSI))\n",
+    "\n",
+    "voltage.append(V)\n",
+    "current.append(I)\n",
+    "abs_current.append(ABSI)\n",
+    "abs_voltage.append(ABSV)\n",
+    "\n",
+    "#step 4 from vreset to 0\n",
+    "device.start_value_sweep(Vreset)\n",
+    "device.step_sweep(step)\n",
+    "device.stop_value_sweep(0)\n",
+    "device.comp('VAR1',CC_vreset)\n",
+    "\n",
+    "device.single_measurement()\n",
+    "while device.operation_completed()==False:\n",
+    "    pass\n",
+    "\n",
+    "device.autoscaling()\n",
+    "\n",
+    "V=device.return_data('V4')\n",
+    "I=device.return_data('I4')\n",
+    "ABSV=device.return_data('ABSV')\n",
+    "ABSI=device.return_data('ABSI')\n",
+    "\n",
+    "#test\n",
+    "print(V)\n",
+    "print(len(V))\n",
+    "print(I)\n",
+    "print(len(I))\n",
+    "print(ABSV)\n",
+    "print(len(ABSV))\n",
+    "print(ABSI)\n",
+    "print(len(ABSI))\n",
+    "\n",
+    "voltage.append(V)\n",
+    "current.append(I)\n",
+    "abs_current.append(ABSI)\n",
+    "abs_voltage.append(ABSV)\n",
+    "\n",
+    "#plot results\n",
+    "plt.figure().clear()\n",
+    "fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis \n",
+    "fig.suptitle('RESET')\n",
+    "ax1.set_title('Linear I')\n",
+    "ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_title('Logarithmic I')\n",
+    "ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_yscale('log')\n",
+    "\n",
+    "ax1.plot(voltage[3],current[3],color='tab:red',label='HRS')\n",
+    "ax1.plot(voltage[2],current[2],color='tab:green',label='LRS')\n",
+    "ax2.plot(voltage[3],abs_current[3],color='tab:red',label='HRS')\n",
+    "ax2.plot(voltage[2],abs_current[2],color='tab:green',label='LRS')\n",
+    "\n",
+    "ax1.legend(loc='best')\n",
+    "ax2.legend(loc=\"best\")\n",
+    "fig.tight_layout()\n",
+    "display(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "85212c25-5337-4b37-bab7-9a4e96d79b95",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 640x480 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "#plot all results\n",
+    "\n",
+    "plt.figure().clear()\n",
+    "fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis \n",
+    "fig.suptitle('SET-RESET')\n",
+    "ax1.set_title('Linear I')\n",
+    "ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_title('Logarithmic I')\n",
+    "ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')\n",
+    "ax2.set_yscale('log')\n",
+    "\n",
+    "ax1.plot(voltage[3],current[3],color='tab:red')\n",
+    "ax1.plot(voltage[2],current[2],color='tab:green')\n",
+    "ax2.plot(voltage[3],abs_current[3],color='tab:red')\n",
+    "ax2.plot(voltage[2],abs_current[2],color='tab:green')\n",
+    "ax1.plot(voltage[0],current[0],color='tab:red',label='HRS')\n",
+    "ax1.plot(voltage[1],current[1],color='tab:green',label='LRS')\n",
+    "ax2.plot(voltage[0],abs_current[0],color='tab:red',label='HRS')\n",
+    "ax2.plot(voltage[1],abs_current[1],color='tab:green',label='LRS')\n",
+    "\n",
+    "ax1.legend(loc='best')\n",
+    "ax2.legend(loc=\"best\")\n",
+    "fig.tight_layout()\n",
+    "display(fig)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "10e582bf-fe8b-46fd-bd72-6c8174ac4c6e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+0,\"No error\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(device.error())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "86d9d2db-41c7-40c4-8e6f-d1dc601016a0",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor (Version 1.0)/tests/sampling_check.ipynb b/hp4155/memristor (Version 1.0)/tests/sampling_check.ipynb
new file mode 100644
index 0000000..63d14da
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/tests/sampling_check.ipynb	
@@ -0,0 +1,154 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "13f0597a-f7c3-4539-8f52-da86b9ba5112",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from help import *"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "1405aabf-8b1c-4415-b2aa-598d0ca53946",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device = module.HP4155a('GPIB0::17::INSTR')\n",
+    "device.reset()\n",
+    "#smu1 and smu3 are disabled\n",
+    "device.smu_disable_sweep(1)\n",
+    "device.smu_disable_sweep(3)\n",
+    "\n",
+    "#disable vmus and vsus\n",
+    "device.disable_vsu(1)\n",
+    "device.disable_vsu(2)\n",
+    "device.disable_vmu(1)\n",
+    "device.disable_vmu(2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "a4e130de-95f2-4b56-acbc-b1d69a9bfb28",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "device.user_function('R','OHM','V2/I2')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "5c30b5e6-266a-485f-96d7-b81681243cd9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "t,r=retention(0.1,10,180,device)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "d6dcbb7c-64a6-443e-ad9a-a10047fd6bdb",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "fig, ax = plt.subplots() \n",
+    "fig.suptitle('Resistance')\n",
+    "ax.set(xlabel='time(s)',ylabel='Resistance(Ohm)')\n",
+    "ax.set_yscale('log')\n",
+    "ax.set_xscale('linear')\n",
+    "plt.plot(t,r)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "2331b94d-e1fd-4669-9cd3-ca466ba876eb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "18\n",
+      "[  0.  20.  30.  40.  50.  60.  70.  80.  90. 100. 110. 120. 130. 140.\n",
+      " 150. 160. 170. 180.]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(t))\n",
+    "print(t)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "3475bd6b-0e84-4780-8ae0-533aef03b1d7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "18\n",
+      "[ 3.344482e+10  2.272727e+11  3.039514e+10 -7.936508e+10  4.545455e+10\n",
+      "  7.462687e+10 -1.562500e+11 -1.052632e+11  3.773585e+10  6.329114e+10\n",
+      " -1.428571e+12 -2.222222e+11 -5.076142e+10  5.128205e+10 -1.000000e+12\n",
+      "  2.777778e+11  3.875969e+10  6.622517e+10]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(len(r))\n",
+    "print(r)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "463a9b14-5b0f-444e-8a2b-a9c3e67d6cf5",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor (Version 1.0)/tests/test_check_dir.ipynb b/hp4155/memristor (Version 1.0)/tests/test_check_dir.ipynb
new file mode 100644
index 0000000..d1e608f
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/tests/test_check_dir.ipynb	
@@ -0,0 +1,223 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d352c77f-f3b8-4ef7-9ffa-314487cf3c61",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tkinter as tk\n",
+    "from tkinter import filedialog\n",
+    "import tkinter.messagebox\n",
+    "import os"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "8aa89cff-50fd-4001-860a-6174c5bcef14",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#choose folder test\n",
+    "\n",
+    "def check_writable(folder):\n",
+    "    filename = \"test.txt\"\n",
+    "    file = os.path.join(folder,filename)\n",
+    "    try:\n",
+    "        with open(file,'a'):\n",
+    "            writable = True\n",
+    "    except:\n",
+    "        writable = False\n",
+    "    \n",
+    "    return writable  \n",
+    "    \n",
+    "def choose_folder():\n",
+    "    \n",
+    "    root = tk.Tk()\n",
+    "    root.withdraw()\n",
+    "    root.lift() #show window above all other applications\n",
+    "\n",
+    "    root.attributes(\"-topmost\", True)#window stays above all other applications\n",
+    "\n",
+    "    \n",
+    "    #choose nonemty folder\n",
+    "    folder = tk.filedialog.askdirectory()\n",
+    "    \n",
+    "    while folder == '':\n",
+    "        folder = tk.filedialog.askdirectory()\n",
+    "\n",
+    "    #check if writable in a while loop\n",
+    "    writable=check_writable(folder)\n",
+    "    print(writable)\n",
+    "    while writable == False:\n",
+    "        #choose a correct folder\n",
+    "        folder = tk.filedialog.askdirectory()\n",
+    "    \n",
+    "        while folder == '':\n",
+    "            folder = tk.filedialog.askdirectory()\n",
+    "        \n",
+    "        #check writable if not repeat\n",
+    "        writable=check_writable(folder)\n",
+    "        print(writable)\n",
+    "        \n",
+    "    \n",
+    "\n",
+    "    root.destroy()\n",
+    "    return folder"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "c657efc0-4f27-4293-b3cb-9aedb36b221d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "False\n",
+      "False\n",
+      "True\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "'//fileserver.cst.rwth-aachen.de/public/Datentransfer/Asonitis, Alexandros'"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "choose_folder()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "64d203ba-94b6-416d-b039-8813323056d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\alex\\Desktop\\labcode\\hp4155\\memristor\\tests\\tempfile.txt\n",
+      "<class 'str'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "temp_file= os.path.join(os.getcwd(),'tempfile.txt')\n",
+    "print(temp_file)\n",
+    "print(type(temp_file))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "4adcc5ec-164c-4b1c-8c5b-c428f1427c32",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "C:\\Users\\alex\\Desktop\\labcode\\hp4155\\memristor\\tests\\end.txt\n"
+     ]
+    }
+   ],
+   "source": [
+    "file=os.path.join(os.getcwd(),'end.txt')\n",
+    "print(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d9e3ceb5-0865-4a69-8a15-d847fc611de4",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "False"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "os.path.exists(file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "00510796-ecd2-4d94-9fe3-af5f82d99a35",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "end.txt\n"
+     ]
+    }
+   ],
+   "source": [
+    "filename= os.path.basename(file)\n",
+    "print(filename)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "be2428c2-d18c-48b9-89ea-d098c83acd67",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#test upload\n",
+    "with (open(r\"C:\\Users\\alex\\Desktop\\_Memristor.txt\",'r') as source,open(r\"text.txt\",'a') as target):\n",
+    "    target.write(source.read())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d9755730-1730-4c87-9c8d-ff709c99705d",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor (Version 1.0)/tests/test_tkinter.ipynb b/hp4155/memristor (Version 1.0)/tests/test_tkinter.ipynb
new file mode 100644
index 0000000..e2652a4
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/tests/test_tkinter.ipynb	
@@ -0,0 +1,91 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "28f8535b-e458-4c47-81c0-e7aa84e8133e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import tkinter as tk\n",
+    "import tkinter.filedialog"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "388e7750-f089-4b3d-86fd-90109f23e811",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "//FILESERVER/public/Datentransfer/Asonitis, Alexandros\n"
+     ]
+    }
+   ],
+   "source": [
+    "root = tk.Tk()\n",
+    "root.withdraw()\n",
+    "root.lift() #show window above all other applications\n",
+    "\n",
+    "root.attributes(\"-topmost\", True)#window stays above all other applications\n",
+    "ok=tk.filedialog.askdirectory()\n",
+    "print(ok)\n",
+    "while ok == '':\n",
+    "    ok=tk.filedialog.askdirectory()\n",
+    "    print(ok)\n",
+    "\n",
+    "root.destroy()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "de224e51-3021-4a2d-89ff-2bc81e273f49",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'str'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(type(ok))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4095b557-098c-46cc-acd1-e28b66f62381",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor (Version 1.0)/working version/Version1/help.py b/hp4155/memristor (Version 1.0)/working version/Version1/help.py
new file mode 100644
index 0000000..509c761
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/working version/Version1/help.py	
@@ -0,0 +1,259 @@
+"""
+This is a python file containing all the important functions for memristor measurement
+
+Available Functions
+
+measurements in the HP4155a
+plot results
+create data frame 
+ini file decoder
+enabing and disabling widgets for jupyter(lists)
+"""
+
+import sys
+sys.path.insert(0, '..') #append parent directory
+
+import module
+import matplotlib.pyplot as plt
+
+import tkinter as tk
+from tkinter import filedialog
+import tkinter.messagebox
+
+import numpy as np
+from IPython.display import display, clear_output
+import pandas as pd
+from datetime import datetime
+import ipywidgets as widgets
+import time
+import os
+
+
+#double sweep from start to stop and then from start to stop
+def sweep(start,stop,step,comp,integration,device):
+    device.measurement_mode('SWE')
+
+    #changed smu2 is source and 4 is ground
+    #smu2 is constant and common
+    device.smu_mode_meas(4,'COMM')
+    device.smu_function_sweep(4,'CONS')
+
+    #smu4 is VAR1 and V
+    device.smu_mode_meas(2,'V')
+    device.smu_function_sweep(2,'VAR1')
+
+    device.integration_time(integration)
+
+    #define double sweep
+    device.var1_mode('DOUB')
+        
+    #start stop step and comp
+    device.start_value_sweep(start)
+    #time.sleep(5)
+    device.stop_value_sweep(stop)
+    #time.sleep(5)
+    device.step_sweep(step)
+    #time.sleep(5)
+    device.comp('VAR1',comp)
+
+    #display variables
+    device.display_variable('X','V2')
+    device.display_variable('Y1','I2')
+
+    #execute measurement
+    device.single_measurement()
+    while device.operation_completed()==False:
+        pass
+        
+    device.autoscaling()
+
+    #return values
+    V=device.return_data('V2')
+    I=device.return_data('I2')
+
+    #convert the list to np.array to return the absolute values for the logarithmic scale
+    V = np.array(V)
+    I = np.array(I)
+
+    #return all values to the function
+    return V, I
+
+#sampling check
+def sampling_check(voltage,device):
+    
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.number_of_points(5)
+    device.integration_time('MED')
+    device.initial_interval(2e-3)
+    device.filter_status('OFF')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        pass
+    
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        R_mean = np.average(R)
+        return R_mean
+    except:
+        return 0
+
+#new (retention)
+def retention(voltage,period,duration,device):
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.initial_interval(period)
+
+    device.total_sampling_time(duration)
+
+    if int(duration/period)<=10001:
+        device.number_of_points(int(duration/period))
+    else:
+        device.number_of_points('MAX')
+    device.integration_time('MED')
+    device.filter_status('OFF')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        pass
+
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        return TIME,R
+    except:
+        return 0,0
+    
+
+#plot sweep results
+def plot_sweep(x,y,title):
+    #plot results
+    plt.figure().clear()
+    fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+    fig.suptitle(title)
+    ax1.set_title('Linear I')
+    ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_title('Logarithmic I')
+    ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_yscale('log')
+
+    ax1.plot(x,y)
+    ax2.plot(x,np.absolute(y))
+    plt.tight_layout()
+    plt.show()
+
+def create_data_frame(x,y):
+    header = ['V(V)','ABSV(V)',"I(A)",'ABSI(A)',"R(Ohm)"]
+    data = {header[0]:x,header[1]:np.absolute(x),header[2]:y,header[3]:np.absolute(y),header[4]:np.divide(x,y)}
+    df = pd.DataFrame(data)
+    #print(df)
+    return df
+
+
+#write results to file
+def write_to_file(file,title,df):
+    with open(file,'a') as f:
+        f.write(title)
+        f.write("\n")
+        f.write(df.to_string())
+        f.write("\n\n")
+
+#### new functions ##############
+def change_state(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = not widget.disabled
+
+
+#works
+def initialize_tkinter(sample_series,field,DUT):
+    #open dialog and hide the main window
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile = f'{DUT.value}_Memristor.txt')
+
+    #check if the file path is correct(.txt)
+    while file_path.endswith(".txt") == False:
+        #open again filedialog with error message box
+        tk.messagebox.showerror(message='invalid filename!')
+        file_path = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile = f'{DUT.value}_Memristor.txt')
+
+    #the first time open the file in write mode!(replaces the old file)
+    #write sample series
+    with open(file_path,'w') as f:
+        title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n\n"
+        f.write(title)
+
+    root.destroy()
+    #return the file path
+    return file_path
+
+#a check values function
+def check_values(step,set_voltage,reset_voltage):
+    valid = True
+
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    if step > abs(set_voltage) or step > abs(reset_voltage):#invalid parameter setting 
+        valid = False
+        tkinter.messagebox.showerror(message="Invalid parameter setting(step>voltage)")
+
+    #now if the set-reset voltages have the same polarity show a warning
+    elif set_voltage*reset_voltage>0:
+        valid = tk.messagebox.askokcancel(message="Set-Reset voltages have the same polarity. Continue?")
+
+    else:
+        pass
+        
+    root.destroy()
+    return valid
+        
+
+def information_box(information):
+    #open dialog and hide the main window
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    #display meaagebox
+    tkinter.messagebox.showinfo(message=information)
+    root.destroy()
+    
+    
\ No newline at end of file
diff --git a/hp4155/memristor (Version 1.0)/working version/Version1/memristor.py b/hp4155/memristor (Version 1.0)/working version/Version1/memristor.py
new file mode 100644
index 0000000..99eeb86
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/working version/Version1/memristor.py	
@@ -0,0 +1,357 @@
+### this is the new memrstor measurement (set and reset as many times as the user wants and full sweeps with a button)
+from help import *
+import ipywidgets as widgets
+from keyboard import add_hotkey,remove_hotkey
+
+
+#additional variables
+first = True #first measurement
+file_path = None
+first_sampling = True #indicates first sampling for set and reset buttons because we cannot add two at each button
+
+# the three naming fields
+
+sample_series= widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'sample series:',
+    style = {'description_width': 'initial'}
+    )
+
+field = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'Field:',
+    style = {'description_width': 'initial'},
+    )
+
+DUT = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'DUT:',
+    style = {'description_width': 'initial'},
+    )
+    
+all_text_boxes = widgets.VBox([sample_series,field,DUT])
+display(all_text_boxes)
+print()
+
+
+#first series of parameters
+step = widgets.BoundedFloatText(
+    value=0.01,
+    min=0,
+    max=200,
+    step=0.01,
+    description='Step(V):',
+)
+
+integration_time=widgets.Dropdown(
+    options=['SHORt', 'MEDium', 'LONG'],
+    value='MEDium',
+    description='Integration:',
+    #style = {'description_width': 'initial'},
+)
+
+sampling=widgets.Checkbox(description='sampling check')
+
+#align the widgets horizontaly
+line0=widgets.HBox([step,integration_time,sampling])
+display(line0)
+print()
+
+
+# THE BUTTONS 
+#create buttons as it shown in the how_buttons_look 
+set=widgets.Button(description='SET')
+reset=widgets.Button(description='RESET')
+full=widgets.Button(description='full sweep')
+number = widgets.BoundedIntText(value=1,min=1,max=sys.maxsize,step=1,description='full sweeps:',disabled=False) #number of measuremts for the full sweep
+
+#parameter boxes
+Vset=widgets.BoundedFloatText(
+    value=1,
+    min=-200,
+    max=200,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-1,
+    max=1,
+    step=0.1,
+    description= 'Comp(A):',
+)
+
+#parameter buttons
+Vreset=widgets.BoundedFloatText(
+    value=-1,
+    min=-200,
+    max=200,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vreset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-1,
+    max=1,
+    step=0.1,
+    description='Comp(A):',
+)
+
+
+#align a button with a checkbox or integer bounded texts horizontaly
+line1 = widgets.HBox([set,Vset,CC_vset])
+line2 = widgets.HBox([reset,Vreset,CC_vreset])
+line3 = widgets.HBox([full,number])
+
+#pack them into a single vertical box
+all = widgets.VBox([line1,line2,line3])
+output = widgets.Output()
+
+#dispaly them all
+display(all,output)
+
+#help lists for changing state of the buttons
+information = [sample_series,field,DUT]
+buttons = [set,reset,full]
+parameters = [Vset,CC_vset,Vreset,CC_vreset,step,integration_time,number,sampling]
+
+
+#connect to the device 
+device = module.HP4155a('GPIB0::17::INSTR')
+device.reset()
+
+#disable all irrelevant units for the measurement
+#smu1 and smu3 are disabled
+device.smu_disable_sweep(1)
+device.smu_disable_sweep(3)
+
+#disable vmus and vsus
+device.disable_vsu(1)
+device.disable_vsu(2)
+device.disable_vmu(1)
+device.disable_vmu(2)
+
+# R user function
+device.user_function('R','OHM','V2/I2')
+
+""" the above is what happens when the programm starts all the rest have to be written into button trigger functions"""
+    
+def on_set_button_clicked(b):
+    global first,file_path,first_sampling
+    with output:
+        #disable buttons
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True:
+            change_state(information)#disable all widgets that are relevant about the information of the sample
+            file_path = initialize_tkinter(sample_series,field,DUT)
+            first = False
+            
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        if valid == True:
+            if sampling.value == True: #do sampling set before set process(100mV)
+                R_mean = sampling_check(0.1,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+               
+            #execute measurement,plot results and save them
+            V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device)
+            plot_sweep(V12,I12,'SET')
+            df = create_data_frame(V12,I12)
+            print(df)
+            title = f"SET Memristor:"+"\n\n"+f"Set Voltage={Vset.value}V"+"\n"+f"current compliance={CC_vset.value}A"+"\n"
+            write_to_file(file_path,title,df)
+
+            if sampling.value == True: #do sampling set after set process(10mV)
+                R_mean = sampling_check(0.01,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+        
+        #show messagebox
+        information_box("Measurement finished!")
+
+        change_state(buttons)
+        change_state(parameters)
+ 
+def on_reset_button_clicked(b):
+    global first,file_path,first_sampling
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            file_path= initialize_tkinter(sample_series,field,DUT)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        if valid == True:
+            
+            if sampling.value == True: #do sampling set before reset process(10mV)
+                R_mean = sampling_check(0.01,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+            
+            #execute measurement,plot results and save them
+            V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device)
+            plot_sweep(V34,I34,'RESET')
+            df = create_data_frame(V34,I34)
+            print(df)
+            title =f"RESET Memristor:"+"\n\n"+f"Reset Voltage={Vreset.value}V"+"\n"+f"current compliance={CC_vreset.value}A"+"\n"
+            write_to_file(file_path,title,df)
+
+            if sampling.value == True: #do sampling set after reset process(100mV)
+                R_mean = sampling_check(0.1,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+        
+        #show messagebox
+        information_box("Measurement finished!")
+
+        change_state(buttons)
+        change_state(parameters)
+
+def on_full_button_clicked(b):
+    global first,file_path
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            file_path= initialize_tkinter(sample_series,field,DUT)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+        if valid == True:
+            with open(file_path,'a') as f:
+                f.write(f"{number.value} full sweeps with parameters:")
+                f.write("\n")
+                f.write(f"Set Voltage = {Vset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance set = {CC_vset.value}A")
+                f.write("\n")
+                f.write(f"Reset Voltage = {Vreset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance reset = {CC_vreset.value}A")
+                f.write("\n\n")
+                
+                
+                plt.figure().clear()
+                fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+                fig.suptitle('FULL SWEEP')
+                ax1.set_title('Linear I')
+                ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_title('Logarithmic I')
+                ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_yscale('log')
+
+                stop = False
+
+                def break_loop():
+                    nonlocal stop
+                    stop = True
+                #help list with the resistances
+                resistances = []    
+                        
+                add_hotkey("esc",break_loop)
+                #execute number of measurements
+                for i in range(number.value):#here it is easier to implement the sampling checks
+                    if sampling.value == True: #before set(100mv)
+                        R_mean = sampling_check(0.1,device)
+                        resistances.append(R_mean)
+                        
+                    V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device) #set
+                    
+                    #after set/before set
+                    if sampling.value == True: #before set(10mv)
+                        R_mean = sampling_check(0.01,device)
+                        resistances.append(R_mean)
+                    
+                    V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device) #reset
+
+                    #no reason to do check at the end because the next loop will do that
+
+                    #butterfly curve
+                    V=np.concatenate((V12,V34))
+                    I=np.concatenate((I12,I34))
+
+                    #create data frame and save to file
+                    df = create_data_frame(V,I)
+                    f.write(f"{i+1} Iteration")
+                    f.write("\n")
+                    f.write(df.to_string())
+                    f.write("\n\n")
+
+                    #plot results
+                    ax1.plot(V,I)
+                    ax2.plot(V,np.absolute(I))
+                    fig.tight_layout()
+
+                    #update plot 
+                    clear_output(wait = True)
+                    #display(fig)
+                    plt.show()
+                    print(df)
+
+                    #check for loop termination
+                    if stop == True:
+                        information_box("Endurance stopped after esc!")
+                        f.write("endurance stopped!\n\n")
+                        break
+                else:
+                    information_box("Endurance completed!")
+                    f.write("endurance completed!\n\n")
+                        
+                remove_hotkey('esc')
+                stop = False
+
+                #plot resistances if sampling value == True or len(resistances) !=0
+                if len(resistances)!=0:
+                    indexes = np.arange(1,len(resistances)+1)
+                    resistances = np.array(resistances)
+                
+                    plt.figure().clear()
+                    fig, ax = plt.subplots()
+                    
+                    fig.suptitle('Resistance')
+                    ax.set(xlabel='Index',ylabel='Resistance(Ohm)')
+                    ax.set_yscale('log')
+                    plt.scatter(indexes,resistances)
+                    plt.show()
+                    print(len(resistances))
+                    print(indexes)
+        change_state(buttons)
+        change_state(parameters)
+
+                                  
+#link buttons with functions
+set.on_click(on_set_button_clicked)
+reset.on_click(on_reset_button_clicked)
+full.on_click(on_full_button_clicked)
+
diff --git a/hp4155/memristor (Version 1.0)/working version/Version2/help-Copy1.py b/hp4155/memristor (Version 1.0)/working version/Version2/help-Copy1.py
new file mode 100644
index 0000000..2f93a2e
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/working version/Version2/help-Copy1.py	
@@ -0,0 +1,289 @@
+"""
+This is a python file containing all the important functions for memristor measurement
+
+Available Functions
+
+measurements in the HP4155a
+plot results
+create data frame 
+ini file decoder
+enabing and disabling widgets for jupyter(lists)
+"""
+
+import sys
+sys.path.insert(0, '..') #append parent directory
+
+import module
+import matplotlib.pyplot as plt
+
+import tkinter as tk
+from tkinter import filedialog
+import tkinter.messagebox
+
+import numpy as np
+from IPython.display import display, clear_output
+import pandas as pd
+from datetime import datetime
+import ipywidgets as widgets
+import time
+import os
+
+
+#double sweep from start to stop and then from start to stop
+def sweep(start,stop,step,comp,integration,device):
+    device.measurement_mode('SWE')
+
+    #changed smu2 is source and 4 is ground
+    #smu2 is constant and common
+    device.smu_mode_meas(4,'COMM')
+    device.smu_function_sweep(4,'CONS')
+
+    #smu4 is VAR1 and V
+    device.smu_mode_meas(2,'V')
+    device.smu_function_sweep(2,'VAR1')
+
+    device.integration_time(integration)
+
+    #define double sweep
+    device.var1_mode('DOUB')
+        
+    #start stop step and comp
+    device.start_value_sweep(start)
+    #time.sleep(5)
+    device.stop_value_sweep(stop)
+    #time.sleep(5)
+    device.step_sweep(step)
+    #time.sleep(5)
+    device.comp('VAR1',comp)
+
+    #display variables
+    device.display_variable('X','V2')
+    device.display_variable('Y1','I2')
+
+    #execute measurement
+    device.single_measurement()
+    while device.operation_completed()==False:
+        pass
+        
+    device.autoscaling()
+
+    #return values
+    V=device.return_data('V2')
+    I=device.return_data('I2')
+
+    #convert the list to np.array to return the absolute values for the logarithmic scale
+    V = np.array(V)
+    I = np.array(I)
+
+    #return all values to the function
+    return V, I
+
+#sampling check
+def sampling_check(voltage,device):
+    
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.number_of_points(5)
+    device.integration_time('MED')
+    device.initial_interval(2e-3)
+    device.filter_status('OFF')
+
+    #remove total sampling time
+    device.auto_sampling_time('ON')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        pass
+    
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        R_mean = np.average(R)
+        return R_mean
+    except:
+        return 0
+
+#new (retention)
+def retention(voltage,period,duration,device):
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.initial_interval(period)
+
+    device.total_sampling_time(duration)
+
+    if int(duration/period)+1<=10001:
+        device.number_of_points(int(duration/period)+1)
+    else:
+        device.number_of_points('MAX')
+    device.integration_time('MED')
+    device.filter_status('OFF')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        pass
+
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        return TIME,R
+    except:
+        return 0,0
+    
+
+#plot sweep results
+def plot_sweep(x,y,title):
+    #plot results
+    plt.figure().clear()
+    fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+    fig.suptitle(title)
+    ax1.set_title('Linear I')
+    ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_title('Logarithmic I')
+    ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_yscale('log')
+
+    ax1.plot(x,y)
+    ax2.plot(x,np.absolute(y))
+    plt.tight_layout()
+    plt.show()
+
+def plot_retention(x,y):
+    fig, ax = plt.subplots() 
+    fig.suptitle('Retention')
+    ax.set(xlabel='time(s)',ylabel='Resistance(Ohm)')
+    ax.set_yscale('log')
+    ax.set_xscale('linear')
+    plt.plot(x,y)
+    plt.show()
+
+def create_data_frame(x,y):
+    header = ['V(V)','ABSV(V)',"I(A)",'ABSI(A)',"R(Ohm)"]
+    data = {header[0]:x,header[1]:np.absolute(x),header[2]:y,header[3]:np.absolute(y),header[4]:np.divide(x,y)}
+    df = pd.DataFrame(data)
+    #print(df)
+    return df
+
+def create_retention_data_frame(x,y):
+    header = ['Time(s)','R(Ohm)']
+    data = {header[0]:x,header[1]:y}
+    df =  pd.DataFrame(data)
+    return df
+
+
+#write results to file
+def write_to_file(file,title,df):
+    with open(file,'a') as f:
+        f.write(title)
+        f.write("\n")
+        f.write(df.to_string())
+        f.write("\n\n")
+
+#### new functions ##############
+def change_state(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = not widget.disabled
+
+def enable_widgets(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = False
+
+#a check values function
+def check_values(step,set_voltage,reset_voltage):
+    valid = True
+
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    if step > abs(set_voltage) or step > abs(reset_voltage) or step==0:#invalid parameter setting 
+        valid = False
+        tkinter.messagebox.showerror(message="Invalid parameter setting!")
+
+    #now if the set-reset voltages have the same polarity show a warning
+    elif set_voltage*reset_voltage>0:
+        valid = tk.messagebox.askokcancel(message="Set-Reset voltages have the same polarity. Continue?")
+
+    else:
+        pass
+        
+    root.destroy()
+    return valid
+        
+
+def information_box(information):
+    #open dialog and hide the main window
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    #display meaagebox
+    tkinter.messagebox.showinfo(message=information)
+    root.destroy()
+
+#choose directory to save measurement results
+def choose_folder():
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    folder = tk.filedialog.askdirectory()
+    while folder == '' :
+        folder = tk.filedialog.askdirectory()
+
+    root.destroy()
+    return folder
+
+#create or append to file a new measurement
+def create_file(sample_series,field,DUT,folder):
+    filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+    file=os.path.join(folder,filename)#the whole file with location
+    date = str(datetime.today().replace(microsecond=0))
+    
+    #check loop (once the return is called the function is over)
+    while True:
+        try:#you cannot write in every directory
+            with open(file,'a') as f:
+                title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n"+f"Date:{date}"+"\n\n"
+                f.write(title)
+            return file
+        except:
+            information_box(f"You cannot write in the directory: {folder}!")
+            #again
+            folder=choose_folder()
+            file=os.path.join(folder,filename)#the whole file with location
+        
+
+    
+    
\ No newline at end of file
diff --git a/hp4155/memristor (Version 1.0)/working version/Version2/memristor-Copy1.py b/hp4155/memristor (Version 1.0)/working version/Version2/memristor-Copy1.py
new file mode 100644
index 0000000..bfae8e3
--- /dev/null
+++ b/hp4155/memristor (Version 1.0)/working version/Version2/memristor-Copy1.py	
@@ -0,0 +1,466 @@
+### this is the new memrstor measurement (set and reset as many times as the user wants and full sweeps with a button)
+from help import *
+import ipywidgets as widgets
+from keyboard import add_hotkey,remove_hotkey
+
+
+#additional variables
+first = True #first measurement
+"""
+This is not anymore the first time you start a measurement but the first time you write a header
+"""
+
+file = None #complete filename with path
+#first_sampling = True #indicates first sampling for set and reset buttons because we cannot add two at each button
+#we dont need this variable anymore
+
+# the three naming fields
+
+sample_series= widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'sample series:',
+    style = {'description_width': 'initial'}
+    )
+
+field = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'Field:',
+    style = {'description_width': 'initial'},
+    )
+
+DUT = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'DUT:',
+    style = {'description_width': 'initial'},
+    )
+
+#start new measurement button(new sample)
+new=widgets.Button(description='next sample')
+
+#choose a new folder button
+new_folder = widgets.Button(description='change folder')
+
+
+horizontal = widgets.HBox([sample_series,new])
+horizontal3= widgets.HBox([DUT,new_folder])
+all_text_boxes = widgets.VBox([horizontal,field,horizontal3])
+
+
+
+#first series of parameters
+step = widgets.BoundedFloatText(
+    value=0.01,
+    min=0,
+    max=200,
+    step=0.01,
+    description='Step(V):',
+)
+
+integration_time=widgets.Dropdown(
+    options=['SHORt', 'MEDium', 'LONG'],
+    value='MEDium',
+    description='Integration:',
+    #style = {'description_width': 'initial'},
+)
+
+sampling=widgets.Checkbox(description='sampling check')
+
+#align the widgets horizontaly
+line0=widgets.HBox([step,integration_time,sampling])
+
+
+
+# THE BUTTONS 
+#create buttons as it shown in the how_buttons_look 
+set=widgets.Button(description='SET')
+reset=widgets.Button(description='RESET')
+full=widgets.Button(description='full sweep')
+number = widgets.BoundedIntText(value=1,min=1,max=sys.maxsize,step=1,description='full sweeps:',disabled=False) #number of measuremts for the full sweep
+retention_button=widgets.Button(description='retention')
+
+
+#parameter boxes
+Vset=widgets.BoundedFloatText(
+    value=1,
+    min=-200,
+    max=200,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-0.1,
+    max=0.1,
+    step=0.01,
+    description= 'Comp(A):',
+)
+
+#parameter buttons
+Vreset=widgets.BoundedFloatText(
+    value=-1,
+    min=-200,
+    max=200,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vreset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-0.1,
+    max=0.1,
+    step=0.01,
+    description='Comp(A):',
+)
+
+Vretention=widgets.BoundedFloatText(
+    value=1,
+    min=-200,
+    max=200,
+    step=1,
+    description='Voltage(V):',
+)
+
+period=widgets.BoundedFloatText(
+    value=1,
+    min=2e-3,
+    max=65.535,
+    step=1,
+    description='Period(s):',
+)
+
+duration=widgets.BoundedFloatText(
+    value=60,
+    min=60e-6,
+    max=1e11,
+    step=1,
+    description='Duration(s):',
+)
+
+#align a button with a checkbox or integer bounded texts horizontaly
+line1 = widgets.HBox([set,Vset,CC_vset])
+line2 = widgets.HBox([reset,Vreset,CC_vreset])
+line3 = widgets.HBox([full,number])
+line4 = widgets.HBox([retention_button,Vretention,period,duration])
+
+#pack them into a single vertical box
+all = widgets.VBox([line1,line2,line3,line4])
+output = widgets.Output()
+
+
+#help lists for changing state of the buttons
+information = [sample_series,field,DUT]
+buttons = [set,reset,full,new,new_folder,retention_button]
+parameters = [Vset,CC_vset,Vreset,CC_vreset,step,integration_time,number,sampling,Vretention,period,duration]
+
+
+#connect to the device 
+device = module.HP4155a('GPIB0::17::INSTR')
+device.reset()
+
+#disable all irrelevant units for the measurement
+#smu1 and smu3 are disabled
+device.smu_disable_sweep(1)
+device.smu_disable_sweep(3)
+
+#disable vmus and vsus
+device.disable_vsu(1)
+device.disable_vsu(2)
+device.disable_vmu(1)
+device.disable_vmu(2)
+
+# R user function
+device.user_function('R','OHM','V2/I2')
+
+#choose folder directory
+folder=choose_folder()
+
+
+#display all at the end
+display(all_text_boxes)
+print()
+display(line0)
+print()
+
+#display the buttons
+display(all,output)
+""" the above is what happens when the programm starts all the rest have to be written into button trigger functions"""
+    
+def on_set_button_clicked(b):
+    global first,folder,file
+    with output:
+        #disable buttons
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True:
+            change_state(information)#disable all widgets that are relevant about the information of the sample
+            file = create_file(sample_series,field,DUT,folder)
+            first = False
+            
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        if valid == True:
+            if sampling.value == True: #do sampling set before set process(100mV)
+                R_mean = sampling_check(0.1,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+               
+            #execute measurement,plot results and save them
+            V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device)
+            plot_sweep(V12,I12,'SET')
+            df = create_data_frame(V12,I12)
+            print(df)
+            title = f"SET Memristor:"+"\n\n"+f"Set Voltage={Vset.value}V"+"\n"+f"current compliance={CC_vset.value}A"+"\n"
+            write_to_file(file,title,df)
+
+            if sampling.value == True: #do sampling set after set process(10mV)
+                R_mean = sampling_check(0.01,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+        
+        #show messagebox
+        information_box("Measurement finished!")
+
+        change_state(buttons)
+        change_state(parameters)
+ 
+def on_reset_button_clicked(b):
+    global first,folder,file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            file = create_file(sample_series,field,DUT,folder)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        if valid == True:
+            
+            if sampling.value == True: #do sampling set before reset process(10mV)
+                R_mean = sampling_check(0.01,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+            
+            #execute measurement,plot results and save them
+            V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device)
+            plot_sweep(V34,I34,'RESET')
+            df = create_data_frame(V34,I34)
+            print(df)
+            title =f"RESET Memristor:"+"\n\n"+f"Reset Voltage={Vreset.value}V"+"\n"+f"current compliance={CC_vreset.value}A"+"\n"
+            write_to_file(file,title,df)
+
+            if sampling.value == True: #do sampling set after reset process(100mV)
+                R_mean = sampling_check(0.1,device)
+                print(f"Average Resistance(Sampling Check):{R_mean} Ohm")
+                first_sampling = False
+        
+        #show messagebox
+        information_box("Measurement finished!")
+
+        change_state(buttons)
+        change_state(parameters)
+
+def on_full_button_clicked(b):
+    global first,folder,file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            file = create_file(sample_series,field,DUT,folder)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+        if valid == True:
+            with open(file,'a') as f:
+                f.write(f"{number.value} full sweeps with parameters:")
+                f.write("\n")
+                f.write(f"Set Voltage = {Vset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance set = {CC_vset.value}A")
+                f.write("\n")
+                f.write(f"Reset Voltage = {Vreset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance reset = {CC_vreset.value}A")
+                f.write("\n\n")
+                
+                
+                plt.figure().clear()
+                fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+                fig.suptitle('FULL SWEEP')
+                ax1.set_title('Linear I')
+                ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_title('Logarithmic I')
+                ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_yscale('log')
+
+                stop = False
+
+                def break_loop():
+                    nonlocal stop
+                    stop = True
+                #help list with the resistances
+                resistances = []    
+                        
+                add_hotkey("esc",break_loop)
+                #execute number of measurements
+                for i in range(number.value):#here it is easier to implement the sampling checks
+                    if sampling.value == True: #before set(100mv)
+                        R_mean = sampling_check(0.1,device)
+                        resistances.append(R_mean)
+                        
+                    V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device) #set
+                    
+                    #after set/before set
+                    if sampling.value == True: #before set(10mv)
+                        R_mean = sampling_check(0.01,device)
+                        resistances.append(R_mean)
+                    
+                    V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device) #reset
+
+                    #no reason to do check at the end because the next loop will do that
+
+                    #butterfly curve
+                    V=np.concatenate((V12,V34))
+                    I=np.concatenate((I12,I34))
+
+                    #create data frame and save to file
+                    df = create_data_frame(V,I)
+                    f.write(f"{i+1} Iteration")
+                    f.write("\n")
+                    f.write(df.to_string())
+                    f.write("\n\n")
+
+                    #plot results
+                    ax1.plot(V,I)
+                    ax2.plot(V,np.absolute(I))
+                    fig.tight_layout()
+
+                    #update plot 
+                    clear_output(wait = True)
+                    #display(fig)
+                    plt.show()
+                    print(df)
+
+                    #check for loop termination
+                    if stop == True:
+                        information_box("Endurance stopped after esc!")
+                        f.write("endurance stopped!\n\n")
+                        break
+                else:
+                    information_box("Endurance completed!")
+                    f.write("endurance completed!\n\n")
+                        
+                remove_hotkey('esc')
+                stop = False
+
+                #plot resistances if sampling value == True or len(resistances) !=0
+                if len(resistances)!=0:
+                    indexes = np.arange(1,len(resistances)+1)
+                    resistances = np.array(resistances)
+                
+                    plt.figure().clear()
+                    fig, ax = plt.subplots()
+                    
+                    fig.suptitle('Resistance')
+                    ax.set(xlabel='Index',ylabel='Resistance(Ohm)')
+                    ax.set_yscale('log')
+                    plt.scatter(indexes,resistances)
+                    plt.show()
+                    print(len(resistances))
+                    print(indexes)
+        change_state(buttons)
+        change_state(parameters)
+
+#move to next sample
+def on_new_sample_button_clicked(b):
+    global first
+    with output:
+        #the if is to ensure that is not pressed many times
+        #just in case the user presses anything
+        change_state(buttons)
+        change_state(parameters)
+        
+        first = True
+        #change_state(information) not anymore creating changing state but enabling the widgets
+        enable_widgets(information)
+        sample_series.value=''
+        field.value=''
+        DUT.value=''
+
+        #enable again
+        change_state(buttons)
+        change_state(parameters)
+
+#new_folder clicked
+def on_new_folder_button_clicked(b):
+    global folder,file,first
+    with output:
+        change_state(buttons) #just to be sure
+        change_state(parameters)
+        
+        folder = choose_folder()#choose new folder
+        #file = create_file(sample_series,field,DUT,folder) #and create the new file (creates multiple headers!!!)
+        first = True #that will write header if the directory is the same as the previous one!
+        change_state(buttons)
+        change_state(parameters)
+
+def on_retention_button_clicked(b):
+    global first,folder,file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            file = create_file(sample_series,field,DUT,folder)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #execute measurement
+        t,R=retention(Vretention.value,period.value,duration.value,device)
+        plot_retention(t,R)
+        df=create_retention_data_frame(t,R)
+        title =f"Retention Memristor:"+"\n\n"+f"Voltage={Vretention.value}V"+"\n"+f"period={period.value}s"+"\n"+f"duration={duration.value}s"+"\n"
+
+        write_to_file(file,title,df)
+        #show messagebox
+        information_box("Measurement finished!")
+
+        change_state(buttons)
+        change_state(parameters)
+            
+#link buttons with functions
+set.on_click(on_set_button_clicked)
+reset.on_click(on_reset_button_clicked)
+full.on_click(on_full_button_clicked)
+new.on_click(on_new_sample_button_clicked)
+new_folder.on_click(on_new_folder_button_clicked)
+retention_button.on_click(on_retention_button_clicked)
diff --git a/hp4155/memristor (Version 2.0)/help.py b/hp4155/memristor (Version 2.0)/help.py
new file mode 100644
index 0000000..c57d751
--- /dev/null
+++ b/hp4155/memristor (Version 2.0)/help.py	
@@ -0,0 +1,359 @@
+"""
+This is a python file containing all the important functions for memristor measurement
+
+Available Functions
+
+measurements in the HP4155a
+plot results
+create data frame 
+ini file decoder
+enabing and disabling widgets for jupyter(lists)
+"""
+
+import sys
+sys.path.insert(0, '..') #append parent directory
+
+import module
+import matplotlib.pyplot as plt
+
+import tkinter as tk
+from tkinter import filedialog
+import tkinter.messagebox
+
+import numpy as np
+from IPython.display import display, clear_output
+import pandas as pd
+from datetime import datetime
+import ipywidgets as widgets
+import time
+import os
+
+
+#double sweep from start to stop and then from start to stop
+def sweep(start,stop,step,comp,integration,device):
+    device.measurement_mode('SWE')
+
+    #changed smu2 is source and 4 is ground
+    #smu2 is constant and common
+    device.smu_mode_meas(4,'COMM')
+    device.smu_function_sweep(4,'CONS')
+
+    #smu4 is VAR1 and V
+    device.smu_mode_meas(2,'V')
+    device.smu_function_sweep(2,'VAR1')
+
+    device.integration_time(integration)
+
+    #define double sweep
+    device.var1_mode('DOUB')
+
+    #start stop step and comp
+    device.start_value_sweep(start)
+    #time.sleep(5)
+    device.stop_value_sweep(stop)
+    #time.sleep(5)
+
+    if start < stop and step < 0 :
+        step = -step
+    elif start > stop and step > 0 :
+        step = -step
+    
+    device.step_sweep(step)
+    #time.sleep(5)
+    device.comp('VAR1',comp)
+
+    #display variables
+    device.display_variable('X','V2')
+    device.display_variable('Y1','I2')
+
+    #execute measurement
+    device.single_measurement()
+    while device.operation_completed()==False:
+        time.sleep(2)
+        
+    device.autoscaling()
+
+    #return values
+    V=device.return_data('V2')
+    I=device.return_data('I2')
+
+    #convert the list to np.array to return the absolute values for the logarithmic scale
+    V = np.array(V)
+    I = np.array(I)
+
+    #return all values to the function
+    return V, I
+
+#sampling check
+def sampling_check(voltage,device):
+    
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.number_of_points(5)
+    device.integration_time('MED')
+    device.initial_interval(2e-3)
+    device.filter_status('OFF')
+
+    #remove total sampling time
+    device.auto_sampling_time('ON')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        time.sleep(2)
+       
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        R_mean = np.average(R)
+        return R_mean
+    except:
+        return 0
+
+#new (retention)
+def retention(voltage,period,duration,device):
+    device.measurement_mode('SAMP')
+    
+    device.smu_mode_meas(2,'V')
+    device.smu_mode_meas(4,'COMM')
+
+    #set voltage and compliance
+    device.constant_smu_sampling(2,voltage)
+    device.constant_smu_comp(2,'MAX')
+
+    device.sampling_mode('LIN')
+    device.initial_interval(period)
+
+    device.total_sampling_time(duration)
+
+    if int(duration/period)+1<=10001:
+        device.number_of_points(int(duration/period)+1)
+    else:
+        device.number_of_points('MAX')
+    device.integration_time('MED')
+    device.filter_status('OFF')
+
+    device.display_variable('X','@TIME')
+    device.display_variable('Y1','R')
+    device.single_measurement()
+    while device.operation_completed() == False:
+        time.sleep(2)
+
+    device.autoscaling()
+    try: 
+        TIME = device.return_data('@TIME')
+        R = device.return_data('R')
+        TIME = np.array(TIME)
+        R = np.array(R)
+        return TIME,R
+    except:
+        return 0,0
+    
+
+#plot sweep results
+def plot_sweep(x,y,title):
+    #plot results
+    plt.figure().clear()
+    fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+    fig.suptitle(title)
+    ax1.set_title('Linear I')
+    ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_title('Logarithmic I')
+    ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+    ax2.set_yscale('log')
+
+    ax1.plot(x,y)
+    ax2.plot(x,np.absolute(y))
+    plt.tight_layout()
+    plt.show()
+
+def plot_retention(x,y):
+    fig, ax = plt.subplots() 
+    fig.suptitle('Retention')
+    ax.set(xlabel='time(s)',ylabel='Resistance(Ohm)')
+    ax.set_yscale('log')
+    ax.set_xscale('linear')
+    plt.plot(x,y)
+    plt.show()
+
+def create_data_frame(x,y):
+    header = ['V(V)','ABSV(V)',"I(A)",'ABSI(A)',"R(Ohm)"]
+    data = {header[0]:x,header[1]:np.absolute(x),header[2]:y,header[3]:np.absolute(y),header[4]:np.divide(x,y)}
+    df = pd.DataFrame(data)
+    #print(df)
+    return df
+
+def create_retention_data_frame(x,y):
+    header = ['Time(s)','R(Ohm)']
+    data = {header[0]:x,header[1]:y}
+    df =  pd.DataFrame(data)
+    return df
+
+
+#write results to file
+def write_to_file(file,title,df):
+    with open(file,'a') as f:
+        f.write(title)
+        f.write("\n")
+        f.write(df.to_string())
+        f.write("\n\n")
+
+#### new functions ##############
+def change_state(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = not widget.disabled
+
+def enable_widgets(widgets_list):
+    for widget in widgets_list:
+        widget.disabled = False
+
+#a check values function
+def check_values(step,set_voltage,reset_voltage):
+    valid = True
+
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    if step > abs(set_voltage) or step > abs(reset_voltage) or step==0:#invalid parameter setting 
+        valid = False
+        tkinter.messagebox.showerror(message="Invalid parameter setting!")
+
+    #now if the set-reset voltages have the same polarity show a warning
+    elif set_voltage*reset_voltage>0:
+        valid = tk.messagebox.askokcancel(message="Set-Reset voltages have the same polarity. Continue?")
+
+    else:
+        pass
+        
+    root.destroy()
+    return valid
+        
+
+def information_box(information):
+    #open dialog and hide the main window
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    #display meaagebox
+    tkinter.messagebox.showinfo(message=information)
+    root.destroy()
+
+#choose directory to save measurement results
+#and check if you have access
+def check_writable(folder):
+    filename = "test.txt"
+    file = os.path.join(folder,filename)
+
+    #protection against removing existing file in python
+    i=1
+    while os.path.exists(file):
+        filename=f"test{i}.txt"
+        file = os.path.join(folder,filename)
+    try:
+        with open(file,'a'):
+            writable = True
+        os.remove(file)
+    except:
+        writable = False
+        information_box(f"{folder} is not writable!")
+    
+    return writable  
+    
+def choose_folder():
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    #choose nonemty folder
+    folder = tk.filedialog.askdirectory()
+    
+    while folder == '':
+        folder = tk.filedialog.askdirectory()
+
+    #check if writable in a while loop
+    writable=check_writable(folder)
+
+    while writable == False:
+        #choose a correct folder
+        folder = tk.filedialog.askdirectory()
+    
+        while folder == '':
+            folder = tk.filedialog.askdirectory()
+        
+        #check writable if not repeat
+        writable=check_writable(folder)
+        
+    root.destroy()
+    return folder
+
+
+
+#create or append to file a new measurement(now locally) we dont need that anymore!!!
+def create_remote_file(sample_series,field,DUT,folder):
+    filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+    file=os.path.join(folder,filename)#the whole file with location
+    date = str(datetime.today().replace(microsecond=0))
+    
+    #check loop (once the return is called the function is over)
+    while True:
+        try:#you cannot write in every directory
+            with open(file,'a') as f:
+                title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n"+f"Date:{date}"+"\n\n"
+                f.write(title)
+            return file
+        except:
+            information_box(f"You cannot write in the directory: {folder}!")
+            #again
+            folder=choose_folder()
+            file=os.path.join(folder,filename)#the whole file with location
+        
+
+#write the header
+def write_header(file,sample_series,field,DUT):
+    date = str(datetime.today().replace(microsecond=0))
+    with open(file,'a') as f: 
+        title = f"Memristor Measurement"+"\n\n"+f"Sample series:{sample_series.value}" +"\n"+f"field:{field.value}"+"\n"+f"DUT:{DUT.value}"+"\n"+f"Date:{date}"+"\n\n"
+        f.write(title)
+
+"""
+New function (UPLOAD RESULTS) 
+IMPORTANT FOR ALL MEASUREMENTS
+THE RESULTS ARE MOVED FROM SOURCE FILE TO TARGET FILE EVEN LOCALLY
+"""
+
+def upload_results(source_file,target_file,target_file_dir):
+    while True:
+        try:
+            with (open(source_file,'r') as source,open(target_file,'a') as target):
+                target.write(source.read())
+            os.remove(source_file)
+            return source_file,target_file,target_file_dir
+        except:
+            information_box(f"{target_file} is no longer accessible. Please change directory")
+            target_file_dir = choose_folder()
+            filename = os.path.basename(target_file)
+            target_file =os.path.join(target_file_dir,filename)
+            #and then try again
+
+        
+            
\ No newline at end of file
diff --git a/hp4155/memristor (Version 2.0)/memristor.py b/hp4155/memristor (Version 2.0)/memristor.py
new file mode 100644
index 0000000..e8b6297
--- /dev/null
+++ b/hp4155/memristor (Version 2.0)/memristor.py	
@@ -0,0 +1,543 @@
+### this is the new memrstor measurement (set and reset as many times as the user wants and full sweeps with a button)
+from help import *
+import ipywidgets as widgets
+from keyboard import add_hotkey,remove_hotkey
+
+
+
+
+
+#additional variables
+first = True #first measurement
+"""
+This is not anymore the first time you start a measurement but the first time you write a header
+"""
+
+file = None #complete filename with path
+#first_sampling = True #indicates first sampling for set and reset buttons because we cannot add two at each button
+#we dont need this variable anymore
+
+
+#create temporary file to store the results localy
+temp_file= os.path.join(os.getcwd(),'tempfile.txt')
+
+# the three naming fields
+
+sample_series= widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'sample series:',
+    style = {'description_width': 'initial'}
+    )
+
+field = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'Field:',
+    style = {'description_width': 'initial'},
+    )
+
+DUT = widgets.Text(
+    value= '',
+    placeholder ='Enter text here:',
+    description = 'DUT:',
+    style = {'description_width': 'initial'},
+    )
+
+#start new measurement button(new sample)
+new=widgets.Button(description='next sample')
+
+#choose a new folder button
+new_folder = widgets.Button(description='change folder')
+
+
+horizontal = widgets.HBox([sample_series,new])
+horizontal3= widgets.HBox([DUT,new_folder])
+all_text_boxes = widgets.VBox([horizontal,field,horizontal3])
+
+
+
+#first series of parameters
+step = widgets.BoundedFloatText(
+    value=0.01,
+    min=0,
+    max=100,
+    step=0.01,
+    description='Step(V):',
+)
+
+integration_time=widgets.Dropdown(
+    options=['SHORt', 'MEDium', 'LONG'],
+    value='MEDium',
+    description='Integration:',
+    #style = {'description_width': 'initial'},
+)
+
+sampling=widgets.Checkbox(description='sampling check')
+
+#align the widgets horizontaly
+line0=widgets.HBox([step,integration_time,sampling])
+
+
+
+# THE BUTTONS 
+#create buttons as it shown in the how_buttons_look 
+set=widgets.Button(description='SET')
+reset=widgets.Button(description='RESET')
+full=widgets.Button(description='full sweep')
+number = widgets.BoundedIntText(value=1,min=1,max=sys.maxsize,step=1,description='full sweeps:',disabled=False) #number of measuremts for the full sweep
+retention_button=widgets.Button(description='retention')
+
+
+#parameter boxes
+Vset=widgets.BoundedFloatText(
+    value=1,
+    min=-100,
+    max=100,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-0.1,
+    max=0.1,
+    step=0.01,
+    description= 'Comp(A):',
+)
+
+#parameter buttons
+Vreset=widgets.BoundedFloatText(
+    value=-1,
+    min=-100,
+    max=100,
+    step=0.1,
+    description='Voltage(V):',
+)
+
+#parameter buttons
+CC_vreset=widgets.BoundedFloatText(
+    value=1e-3,
+    min=-0.1,
+    max=0.1,
+    step=0.01,
+    description='Comp(A):',
+)
+
+Vretention=widgets.BoundedFloatText(
+    value=1,
+    min=-100,
+    max=100,
+    step=1,
+    description='Voltage(V):',
+)
+
+period=widgets.BoundedFloatText(
+    value=1,
+    min=2e-3,
+    max=65.535,
+    step=1,
+    description='Period(s):',
+)
+
+duration=widgets.BoundedFloatText(
+    value=60,
+    min=60e-6,
+    max=1e11,
+    step=1,
+    description='Duration(s):',
+)
+
+#align a button with a checkbox or integer bounded texts horizontaly
+line1 = widgets.HBox([set,Vset,CC_vset])
+line2 = widgets.HBox([reset,Vreset,CC_vreset])
+line3 = widgets.HBox([full,number])
+line4 = widgets.HBox([retention_button,Vretention,period,duration])
+
+#pack them into a single vertical box
+all = widgets.VBox([line1,line2,line3,line4])
+output = widgets.Output()
+
+
+#help lists for changing state of the buttons
+information = [sample_series,field,DUT]
+buttons = [set,reset,full,new,new_folder,retention_button]
+parameters = [Vset,CC_vset,Vreset,CC_vreset,step,integration_time,number,sampling,Vretention,period,duration]
+
+
+#connect to the device 
+device = module.HP4155a('GPIB0::17::INSTR')
+device.reset()
+
+#disable all irrelevant units for the measurement
+#smu1 and smu3 are disabled
+device.smu_disable_sweep(1)
+device.smu_disable_sweep(3)
+
+#disable vmus and vsus
+device.disable_vsu(1)
+device.disable_vsu(2)
+device.disable_vmu(1)
+device.disable_vmu(2)
+
+# R user function
+device.user_function('R','OHM','V2/I2')
+
+#choose folder directory
+folder=choose_folder()
+
+
+#display all at the end
+display(all_text_boxes)
+print()
+display(line0)
+print()
+
+#display the buttons
+display(all,output)
+""" the above is what happens when the programm starts all the rest have to be written into button trigger functions"""
+    
+def on_set_button_clicked(b):
+    global first,folder,file,temp_file
+    with output:
+        #disable buttons
+        change_state(buttons)
+        change_state(parameters)
+
+        #lock the  device
+        device.inst.lock_excl()
+
+        clear_output()
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        #during first button press
+        if first == True and valid == True:
+            change_state(information)#disable all widgets that are relevant about the information of the sample
+            filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+            file = os.path.join(folder,filename)
+            #write header to temp_file
+            write_header(temp_file,sample_series,field,DUT)
+            first = False
+
+        if valid == True:
+            if sampling.value == True: #do sampling set before set process(100mV)
+                R_mean_before = sampling_check(0.1,device)
+                R_mean_before = round(R_mean_before,1)#round 1 decimal point
+                print(f"Average Resistance(Sampling Check):{R_mean_before:e} Ohm")
+                first_sampling = False
+               
+            #execute measurement,plot results and save them
+            V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device)
+            plot_sweep(V12,I12,'SET')
+            df = create_data_frame(V12,I12)
+            print(df)
+            
+
+            if sampling.value == True: #do sampling set after set process(10mV)
+                R_mean_after = sampling_check(0.01,device)
+                R_mean_after = round(R_mean_after,1)
+                print(f"Average Resistance(Sampling Check):{R_mean_after:e} Ohm")
+                first_sampling = False
+
+            title = f"SET Memristor:"+"\n\n"+f"Set Voltage={Vset.value}V"+"\n"+f"current compliance={CC_vset.value}A"+"\n"
+            if sampling.value == True:
+                title = title + f"R(Ohm)  Before/After"+"\n"+f"{R_mean_before}  {R_mean_after}"+"\n"
+            write_to_file(temp_file,title,df)
+
+            #upload results
+            temp_file,file,folder=upload_results(temp_file,file,folder)
+        
+        #show messagebox
+        information_box("Measurement finished!")
+
+        #unlock device
+        device.inst.unlock()
+        
+        change_state(buttons)
+        change_state(parameters)
+ 
+def on_reset_button_clicked(b):
+    global first,folder,file,temp_file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        #lock device
+        device.inst.lock_excl()
+
+        clear_output()
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        #during first button press
+        if first == True and valid == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+            file = os.path.join(folder,filename)
+            #write header to temp_file
+            write_header(temp_file,sample_series,field,DUT)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        if valid == True:
+            if sampling.value == True: #do sampling set before reset process(10mV)
+                R_mean_before = sampling_check(0.01,device)
+                R_mean_before = round(R_mean_before,1)#round 1 decimal point
+                print(f"Average Resistance(Sampling Check):{R_mean_before:e} Ohm")
+                first_sampling = False
+            
+            #execute measurement,plot results and save them
+            V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device)
+            plot_sweep(V34,I34,'RESET')
+            df = create_data_frame(V34,I34)
+            print(df)
+            
+            if sampling.value == True: #do sampling set after reset process(100mV)
+                R_mean_after = sampling_check(0.1,device)
+                R_mean_after = round(R_mean_after,1)
+                print(f"Average Resistance(Sampling Check):{R_mean_after:e} Ohm")
+                first_sampling = False
+            
+            title =f"RESET Memristor:"+"\n\n"+f"Reset Voltage={Vreset.value}V"+"\n"+f"current compliance={CC_vreset.value}A"+"\n"
+            if sampling.value == True:
+                title = title + f"R(Ohm)  Before/After"+"\n"+f"{R_mean_before}  {R_mean_after}"+"\n"
+            write_to_file(temp_file,title,df)
+            
+            #upload results
+            temp_file,file,folder=upload_results(temp_file,file,folder)
+
+        #show messagebox
+        information_box("Measurement finished!")
+
+        #unlock device
+        device.inst.unlock()
+
+        change_state(buttons)
+        change_state(parameters)
+
+def on_full_button_clicked(b):
+    global first,folder,file,temp_file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        # lock device
+        device.inst.lock_excl()
+        
+        clear_output()
+
+        #check values
+        valid = check_values(step.value,Vset.value,Vreset.value)
+
+        #during first button press
+        if first == True and valid == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+            file = os.path.join(folder,filename)
+            #write header to temp_file
+            write_header(temp_file,sample_series,field,DUT)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        
+        if valid == True:
+            with open(temp_file,'a') as f:
+                f.write(f"{number.value} full sweeps with parameters:")
+                f.write("\n")
+                f.write(f"Set Voltage = {Vset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance set = {CC_vset.value}A")
+                f.write("\n")
+                f.write(f"Reset Voltage = {Vreset.value}V")
+                f.write("\n")
+                f.write(f"Current compliance reset = {CC_vreset.value}A")
+                f.write("\n\n")
+                
+                
+                plt.figure().clear()
+                fig, (ax1, ax2) = plt.subplots(2,sharex=True,figsize=(8,6)) #the plots share the same x axis 
+                fig.suptitle('FULL SWEEP')
+                ax1.set_title('Linear I')
+                ax1.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_title('Logarithmic I')
+                ax2.set(xlabel='Voltage(V)',ylabel='Current(A)')
+                ax2.set_yscale('log')
+
+                stop = False
+
+                def break_loop():
+                    nonlocal stop
+                    stop = True
+                #help list with the resistances
+                resistances = []    
+                        
+                add_hotkey("esc",break_loop)
+                #execute number of measurements
+                for i in range(number.value):#here it is easier to implement the sampling checks
+                    if sampling.value == True: #before set(100mv)
+                        R_mean_init = sampling_check(0.1,device)
+                        R_mean_init = round(R_mean_init,1)
+                        resistances.append(R_mean_init)
+                        
+                    V12,I12 = sweep(0,Vset.value,step.value,CC_vset.value,integration_time.value,device) #set
+                    
+                    #after set/before set
+                    if sampling.value == True: #before set(10mv)
+                        R_mean_set = sampling_check(0.01,device)
+                        R_mean_set = round(R_mean_set,1)
+                        resistances.append(R_mean_set)
+                    
+                    V34,I34 = sweep(0,Vreset.value,step.value,CC_vreset.value,integration_time.value,device) #reset
+
+                    #no reason to do check at the end because the next loop will do that(not anymore) more sampling checks
+
+                    #after reset
+                    if sampling.value == True:#-0.1V
+                        R_mean_reset = sampling_check(-0.1,device)
+                        R_mean_reset = round(R_mean_reset,1)
+                        resistances.append(R_mean_reset)
+
+
+                    #butterfly curve
+                    V=np.concatenate((V12,V34))
+                    I=np.concatenate((I12,I34))
+
+                    #create data frame and save to file
+                    df = create_data_frame(V,I)
+                    f.write(f"{i+1} Iteration")
+                    f.write("\n")
+                    if sampling.value == True:
+                        f.write(f"R(Ohm)  INIT/SET/RESET"+"\n"+f"{R_mean_init}  {R_mean_set} {R_mean_reset}"+"\n")
+                    f.write(df.to_string())
+                    f.write("\n\n")
+
+
+                    #plot results
+                    ax1.plot(V,I)
+                    ax2.plot(V,np.absolute(I))
+                    fig.tight_layout()
+
+                    #update plot 
+                    clear_output()
+                    display(fig)
+                    #plt.show()
+                    print(df)
+
+                    #check for loop termination
+                    if stop == True:
+                        information_box("Endurance stopped after esc!")
+                        f.write("endurance stopped!\n\n")
+                        break
+                else:
+                    information_box("Endurance completed!")
+                    f.write("endurance completed!\n\n")
+                        
+                remove_hotkey('esc')
+                stop = False
+
+                #plot resistances if sampling value == True or len(resistances) !=0
+                if len(resistances)!=0:
+                    indexes = np.arange(1,len(resistances)+1)
+                    resistances = np.array(resistances)
+                
+                    plt.figure().clear()
+                    fig, ax = plt.subplots()
+                    
+                    fig.suptitle('Resistance')
+                    ax.set(xlabel='Index',ylabel='Resistance(Ohm)')
+                    ax.set_yscale('log')
+                    plt.scatter(indexes,resistances)
+                    plt.show()
+                    #print(len(resistances))
+                    #print(indexes)
+        
+            #upload results
+            temp_file,file,folder=upload_results(temp_file,file,folder)
+        
+        #unlock the device
+        device.inst.unlock()
+        
+        change_state(buttons)
+        change_state(parameters)
+
+#move to next sample
+def on_new_sample_button_clicked(b):
+    global first
+    with output:
+        #the if is to ensure that is not pressed many times
+        #just in case the user presses anything
+        change_state(buttons)
+        change_state(parameters)
+        
+        first = True
+        #change_state(information) not anymore creating changing state but enabling the widgets
+        enable_widgets(information)
+        #sample_series.value=''
+        #field.value=''
+        DUT.value=''
+
+        #enable again
+        change_state(buttons)
+        change_state(parameters)
+
+#new_folder clicked
+def on_new_folder_button_clicked(b):
+    global folder,file,first
+    with output:
+        change_state(buttons) #just to be sure
+        change_state(parameters)
+        
+        folder = choose_folder()#choose new folder
+        #file = create_file(sample_series,field,DUT,folder) #and create the new file (creates multiple headers!!!)
+        first = True #that will write header if the directory is the same as the previous one!
+        change_state(buttons)
+        change_state(parameters)
+
+def on_retention_button_clicked(b):
+    global first,folder,file,temp_file
+    with output:
+        change_state(buttons)
+        change_state(parameters)
+
+        device.inst.lock_excl()
+        
+        clear_output()
+
+        #during first button press
+        if first == True: 
+            #disable checkboxes, text fields etc.
+            change_state(information)
+            filename=f"{sample_series.value}_{field.value}_{DUT.value}.txt"
+            file = os.path.join(folder,filename)
+            #write header to temp_file
+            write_header(temp_file,sample_series,field,DUT)
+            first = False #set first to false irrelvant if it is in the if statement or not
+
+        #execute measurement
+        t,R=retention(Vretention.value,period.value,duration.value,device)
+        plot_retention(t,R)
+        df=create_retention_data_frame(t,R)
+        title =f"Retention Memristor:"+"\n\n"+f"Voltage={Vretention.value}V"+"\n"+f"period={period.value}s"+"\n"+f"duration={duration.value}s"+"\n"
+
+        write_to_file(temp_file,title,df)
+        #upload results
+        temp_file,file,folder=upload_results(temp_file,file,folder)
+        #show messagebox
+        information_box("Measurement finished!")
+
+        device.inst.unlock()
+    
+        change_state(buttons)
+        change_state(parameters)
+            
+#link buttons with functions
+set.on_click(on_set_button_clicked)
+reset.on_click(on_reset_button_clicked)
+full.on_click(on_full_button_clicked)
+new.on_click(on_new_sample_button_clicked)
+new_folder.on_click(on_new_folder_button_clicked)
+retention_button.on_click(on_retention_button_clicked)
diff --git a/hp4155/memristor (Version 2.0)/memristor_buttons.ipynb b/hp4155/memristor (Version 2.0)/memristor_buttons.ipynb
new file mode 100644
index 0000000..ddfec87
--- /dev/null
+++ b/hp4155/memristor (Version 2.0)/memristor_buttons.ipynb	
@@ -0,0 +1,114 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "df99f5a2-80af-4892-8633-33177239e444",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "867d912290bc4089ab98083476c64723",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Text(value='', description='sample series:', placeholder='Enter text here:', sty…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "93d35a24b3474362912ad3626c5d3065",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "HBox(children=(BoundedFloatText(value=0.01, description='Step(V):', step=0.01), Dropdown(description='Integrat…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "92dbe8ccf22f4fa0b8b3fb00003a4416",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "VBox(children=(HBox(children=(Button(description='SET', style=ButtonStyle()), BoundedFloatText(value=1.0, desc…"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ab54e647d9f74958b4211dd8f95b8041",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Output()"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%run memristor.py"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "076a9132-edc2-4ae5-8a7f-c8a179473952",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor_final/help.py b/hp4155/memristor (Version 3.0)/help.py
similarity index 100%
rename from hp4155/memristor_final/help.py
rename to hp4155/memristor (Version 3.0)/help.py
diff --git a/hp4155/memristor_final/help_pulse.py b/hp4155/memristor (Version 3.0)/help_pulse.py
similarity index 100%
rename from hp4155/memristor_final/help_pulse.py
rename to hp4155/memristor (Version 3.0)/help_pulse.py
diff --git a/hp4155/memristor_final/memristor.py b/hp4155/memristor (Version 3.0)/memristor.py
similarity index 100%
rename from hp4155/memristor_final/memristor.py
rename to hp4155/memristor (Version 3.0)/memristor.py
diff --git a/hp4155/memristor_final/memristor_buttons.ipynb b/hp4155/memristor (Version 3.0)/memristor_buttons.ipynb
similarity index 100%
rename from hp4155/memristor_final/memristor_buttons.ipynb
rename to hp4155/memristor (Version 3.0)/memristor_buttons.ipynb
diff --git a/hp4155/memristor_pulsed/help_new.py b/hp4155/memristor pulsed (Version 1.0)/help_new.py
similarity index 100%
rename from hp4155/memristor_pulsed/help_new.py
rename to hp4155/memristor pulsed (Version 1.0)/help_new.py
diff --git a/hp4155/memristor_pulsed/interface.py b/hp4155/memristor pulsed (Version 1.0)/interface.py
similarity index 100%
rename from hp4155/memristor_pulsed/interface.py
rename to hp4155/memristor pulsed (Version 1.0)/interface.py
diff --git a/hp4155/memristor pulsed (Version 1.0)/old/constant_pulse_test.ipynb b/hp4155/memristor pulsed (Version 1.0)/old/constant_pulse_test.ipynb
new file mode 100644
index 0000000..5c46f3f
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/old/constant_pulse_test.ipynb	
@@ -0,0 +1,95 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from help import *\n",
+    "\n",
+    "#set the values here\n",
+    "const_voltage = 10\n",
+    "comp = 0.1\n",
+    "\n",
+    "#number of pulses \n",
+    "pulses = 100\n",
+    "\n",
+    "# pulse period is in interval 5ms to 1s \n",
+    "pulse_period = 5e-2\n",
+    "\n",
+    "#pulse is in interval 0.5ms to 100ms\n",
+    "pulse_width = 5e-3\n",
+    "\n",
+    "# Restriction: pulse period ≥ pulse width + 4 ms\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "times,values=constant_pulse(const_voltage,comp,pulses,pulse_period,pulse_width)\n",
+    "plot_constant(values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Measurement finished!\n"
+     ]
+    }
+   ],
+   "source": [
+    "create_file(measurement=\"Constant Pulse\",period=pulse_period,width=pulse_width,pulses=pulses,times=times,values=values,comp=comp)\n",
+    "print(\"Measurement finished!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/hp4155/memristor pulsed (Version 1.0)/old/help.py b/hp4155/memristor pulsed (Version 1.0)/old/help.py
new file mode 100644
index 0000000..bd52bc9
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/old/help.py	
@@ -0,0 +1,246 @@
+import sys
+sys.path.insert(0, '..') #append parent directory
+
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+import module
+import time
+import pandas as pd
+import tkinter as tk
+from tkinter import filedialog
+
+def sweep_pulse(start,stop,comp,points,width,period):
+    device = module.HP4155a('GPIB0::17::INSTR')
+    device.reset()
+    device.smu_disable_sweep(1)
+    device.smu_disable_sweep(3)
+
+    #disable vmus and vsus
+    device.disable_vsu(1)
+    device.disable_vsu(2)
+    device.disable_vmu(1)
+    device.disable_vmu(2)
+
+    device.measurement_mode("SWE")
+    device.smu_function_sweep(2,"VAR1")
+    device.smu_mode_meas(4,"COMMON")
+    device.smu_function_sweep(4,"CONS")
+
+    device.smu_mode_meas(2,"VPULSE")
+    device.start_value_sweep(start)
+    device.stop_value_sweep(stop)
+
+    #define the number of steps given specific pulses
+    
+    step = (stop-start)/(points-1)
+    device.step_sweep(step)
+    
+    device.comp("VAR1",comp)
+    
+    device.display_variable("X","V2")
+    device.display_variable("Y1",'I2')
+
+    device.range_mode(4,"AUTO")
+    device.range_mode(2,"AUTO")
+
+    device.pulse_base(0)
+    device.pulse_width(width)
+    device.pulse_period(period)
+    device.integration_time("MED")
+
+    t0 = time.time()
+    device.single_measurement()
+    while device.operation_completed()== False:
+        pass
+    
+    t1 = time.time()
+    # get the execution time
+    elapsed_time = t1 - t0
+    device.autoscaling()
+
+    I_i=device.return_data("I2")
+    V_i=device.return_data("V2")
+    R_i = np.divide(V_i,I_i)
+    
+    
+    expected_time = period*int(points)
+
+    times = (elapsed_time,expected_time)
+    values = (V_i,I_i,R_i)
+
+    del device
+
+    return times,values
+
+def constant_pulse(const,comp,points,period,width):
+    device = module.HP4155a('GPIB0::17::INSTR')
+    device.reset()
+    device.user_function('V','V','V2')
+    device.user_function('I','A','I2')
+
+    #disable vmus and vsus
+    device.disable_vsu(1)
+    device.disable_vsu(2)
+    device.disable_vmu(1)
+    device.disable_vmu(2)
+    device.smu_disable_sweep(1)
+    #device.smu_disable_sweep(3)
+    
+    device.measurement_mode("SWE")
+    device.smu_mode_meas(2,"VPULSE")
+    device.smu_function_sweep(2,'CONS')
+    device.smu_mode_meas(4,"COMM")
+    device.smu_function_sweep(2,"CONS")
+    device.smu_function_sweep(4,'CONS')
+
+    #smu 3 is used to define the number of pulses not contacted
+    device.smu_mode_meas(3,'V')
+    device.smu_function_sweep(3,"VAR1")
+
+    device.start_value_sweep(0)
+    device.stop_value_sweep(10)
+
+    #define the number of steps given specific pulses
+    step = 10/(points-1)
+    device.step_sweep(step)
+    
+    device.comp("VAR1","MAX")
+    device.const_comp(2,comp)
+
+    device.cons_smu_value(2,const)
+    
+    device.display_variable("X","V")
+    device.display_variable("Y1",'I')
+
+    device.range_mode(4,"AUTO")
+    device.range_mode(2,"AUTO")
+    device.range_mode(3,"AUTO")
+
+    device.pulse_base(0)
+    device.pulse_width(width)
+    device.pulse_period(period)
+    device.integration_time("MED")
+
+    t0 = time.time()
+    device.single_measurement()
+    while device.operation_completed()== False:
+        pass
+    
+    t1 = time.time()
+    # get the execution time
+    elapsed_time = t1 - t0
+    device.autoscaling()
+
+    I_i=device.return_data("I")
+    V_i=device.return_data("V")
+    R_i = np.divide(V_i,I_i)
+
+    
+    expected_time = period*int(points)
+
+    times = (elapsed_time,expected_time)
+    values = (V_i,I_i,R_i)
+
+    del device
+
+    return times,values
+
+def create_file(measurement,period,width,pulses,values,times,comp):
+
+    filename = " "
+    
+    root = tk.Tk()
+    root.withdraw()
+    root.lift() #show window above all other applications
+
+    root.attributes("-topmost", True)#window stays above all other applications
+
+    file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =filename)
+
+    #check if the file path is correct(.txt)
+    while file.endswith(".txt") == False:
+        #open again filedialog with error message box
+        tk.messagebox.showerror(message='invalid filename!')
+        file = filedialog.asksaveasfilename(defaultextension=".txt", filetypes=[("Text files","*.txt")],title = "save results path",initialfile =filename)
+    root.destroy()
+
+    with open(file,"w") as f: 
+        f.write(f"{measurement}"+"\n")
+        f.write(f"period(s):{period}"+"\n")
+        f.write(f"width(s):{width}"+"\n")
+        f.write(f"execution time(s):{times[0]}"+"\n")
+        f.write(f"expected time(s):{times[1]}"+"\n")
+        f.write(f"number of pulses:{pulses}"+"\n")
+        f.write(f"current compliance(A):{comp}"+"\n\n")
+
+        zipped = list(zip(values[0],values[1], values[2]))
+        df = pd.DataFrame(zipped, columns=['VPULSE(V)', 'IPULSE(A)', 'RPULSE(Ohm)'])
+
+        f.write("Results Pulse:\n")
+        f.write(df.to_string())
+
+def plot_sweep(values):    
+    fig, ax1 = plt.subplots() 
+    color = 'tab:red'
+
+    ax1.set_xlabel("V(V)")
+    ax1.set_ylabel("I(A)",color=color)
+    ax1.set_yscale('log')
+
+    ax1.plot(values[0],np.abs(values[1]),color=color)
+    ax1.tick_params(axis ='y', labelcolor = color,which = 'both') 
+
+    # Adding Twin Axes 
+    ax2 = ax1.twinx() 
+    color = 'tab:green'
+
+    ax2.set_ylabel("R(Ohm)",color = color)
+    ax2.plot(values[0],np.abs(values[2]),color = color)
+
+    ax2.tick_params(axis ='y', labelcolor = color,which = 'both')
+    ax2.set_yscale('log')
+
+    plt.show()
+
+
+def plot_constant(values):
+    index =[]
+    for i in range(len(values[0])):
+        index.append(i+1)
+    
+    fig, ax1 = plt.subplots() 
+    color = 'tab:red'
+
+    ax1.set_xlabel("Index(Pulse number)")
+    ax1.set_ylabel("I(A)",color=color)
+    ax1.set_yscale('log')
+
+    ax1.plot(index,np.abs(values[1]),color=color,label = "Voltage(V):"+str(min(values[0])))
+    ax1.tick_params(axis ='y', labelcolor = color,which = 'both') 
+
+    # Adding Twin Axes 
+    ax2 = ax1.twinx() 
+    color = 'tab:green'
+
+    ax2.set_ylabel("R(Ohm)",color = color)
+    ax2.plot(index,np.abs(values[2]),color=color,label = "Voltage(V):"+str(min(values[0])))
+    ax2.set_yscale('log')
+
+    ax2.tick_params(axis ='y', labelcolor = color,which = 'both') 
+
+    fig.legend()
+    plt.show()
+
+
+
+
+ 
+
+
+
+
+
+
+
diff --git a/hp4155/memristor pulsed (Version 1.0)/old/sweep_pulse_test.ipynb b/hp4155/memristor pulsed (Version 1.0)/old/sweep_pulse_test.ipynb
new file mode 100644
index 0000000..68eb350
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/old/sweep_pulse_test.ipynb	
@@ -0,0 +1,96 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from help import *\n",
+    "\n",
+    "#set the values here\n",
+    "start_voltage = 0\n",
+    "stop_voltage = 15\n",
+    "comp = 0.1\n",
+    "\n",
+    "#number of pulses \n",
+    "pulses = 100\n",
+    "\n",
+    "# pulse period is in interval 5ms to 1s \n",
+    "pulse_period = 5e-3\n",
+    "\n",
+    "#pulse is in interval 0.5ms to 100ms\n",
+    "pulse_width = 5e-4\n",
+    "\n",
+    "# Restriction: pulse period ≥ pulse width + 4 ms\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "times,values=sweep_pulse(start=start_voltage,stop=stop_voltage,comp=comp,points=pulses,width=pulse_width,period=pulse_period)\n",
+    "plot_sweep(values)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Measurement finished!\n"
+     ]
+    }
+   ],
+   "source": [
+    "create_file(measurement=\"Sweep Pulse\",period=pulse_period,width=pulse_width,pulses=pulses,times=times,values=values,comp=comp)\n",
+    "print(\"Measurement finished!\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 4
+}
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_constant.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_constant.py
new file mode 100644
index 0000000..d01f2e1
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_constant.py	
@@ -0,0 +1,168 @@
+import os
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from measurement import Meas
+from measurement import constant_pulse
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+# get the 10 measurements
+def split_dataframe_index(df):
+    subsets= []
+    for i in range(10):
+        subset = df[df["Index"]==i+1]
+        subsets.append(subset)
+    return subsets   
+
+#get the 3 measureemnts
+def plot_3(periods,df):
+    subsets = []
+    for period in periods:
+        subset = df[df["Period(s)"]==period]
+        subsets.append(subset)
+    return subsets
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\constant pulse high current")
+
+files = os.listdir(os.getcwd())
+
+data = pd.DataFrame() 
+
+for file in files:
+    if file.endswith(".txt"):
+        measurement = constant_pulse(file)
+        dictionary = {"Index":measurement.index,"Period(s)":measurement.period,"Pulses":measurement.pulses,"Ideal(s)":measurement.ideal,"Real(s)":measurement.real,"Delay(s)":measurement.delay,"Relative Error(%)":measurement.relative_error,"Integration":measurement.integration,"file location":measurement.file,"Average Resistance(Ohm)":measurement.results["RPULSE(Ohm)"].mean()}
+        data = data._append(dictionary,ignore_index=True)
+        
+#save the data for later use
+data.to_csv("Results.csv", encoding='utf-8',index=False)
+
+
+#split to short and medium integration time
+med = data[data['Integration']=='MED']
+shor = data[data['Integration']=='SHOR']
+
+
+#get the 10 measuremets
+measurements_med = split_dataframe_index(med)
+measurements_shor = split_dataframe_index(shor)
+
+
+
+for subset in measurements_med:
+    subset.sort_values(by='Pulses',inplace=True)
+for subset in measurements_shor:
+    subset.sort_values(by='Pulses',inplace=True)
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+
+plt.title("Delay of the High Current Pulse constant Measurements")
+plt.xlabel("Number of Pulses")
+plt.ylabel("Delay(s)")
+
+
+plt.legend()
+plt.show()
+
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+plt.title("Relative Error of the High Current Pulse constant Measurements")
+
+plt.xlabel("Number of Pulses")
+plt.ylabel("Relative Error(%)")
+plt.yscale("log")
+
+plt.legend()
+plt.show()
+
+print("Average Delay for medium integration time:",med["Delay(s)"].mean(),"±",med["Delay(s)"].std())
+print("Average Delay for short integration time:",shor["Delay(s)"].mean(),"±",shor["Delay(s)"].std())
+
+data = data.sort_values(by='Period(s)')
+data.boxplot(column=["Delay(s)"],by="Period(s)")
+
+plt.show()
+
+data.boxplot(column=["Relative Error(%)"],by="Period(s)")
+plt.yscale("log")
+plt.show()
+
+
+#plot the results
+
+#first retrieve the periods and sort them
+periods =list(set(data["Period(s)"].to_numpy()))
+periods.sort()
+
+periods_to_plot = [periods[0],periods[4],periods[9]]
+
+plot_med = plot_3(periods_to_plot,med)
+plot_shor = plot_3(periods_to_plot,shor)
+
+fig,axs = plt.subplots(1,3,figsize=(15,9))  
+
+for index,subset in enumerate(plot_med): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace=True)
+    subset.reset_index(drop=True, inplace=True)
+
+    
+    for i in range(3): # 3 number of pulses
+        measurement = subset.iloc[i]
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[index].plot(df["VPULSE(V)"],df['RPULSE(Ohm)'],label = f'pulses(MED):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Medium Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+
+    
+for index,subset in enumerate(plot_shor): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace =True)
+    subset.reset_index(drop=True, inplace=True)
+
+    for i in range(3): #3 different pulses
+        measurement = subset.iloc[i]
+        
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[index].plot(df['VPULSE(V)'],df["RPULSE(Ohm)"],label = f'pulses(SHOR):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Short Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+ 
+fig.suptitle("Measurement Results for High Current Pulse Constant Measurements")
+for i in range(3):
+    axs[i].set_title(f"Period(s):{periods_to_plot[i]}")
+    axs[i].set_xlabel("Voltage(V)")
+    axs[i].set_ylabel("Resistance(Ohm)")
+
+axs[0].legend()
+axs[1].legend()
+axs[2].legend()
+fig.tight_layout()
+plt.show()
+
+med = med.sort_values(by='Period(s)')
+med.boxplot(column=["Average Resistance(Ohm)"],by="Period(s)",label = "MED")
+plt.legend()
+plt.show()
+
+shor = shor.sort_values(by='Period(s)')
+shor.boxplot(column=["Average Resistance(Ohm)"],by="Period(s)",label = "SHOR")
+plt.legend()
+plt.show()
+
+
+
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep.py
new file mode 100644
index 0000000..86568bf
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep.py	
@@ -0,0 +1,97 @@
+import os
+import matplotlib.pyplot as plt
+import pandas as pd
+import numpy as np
+
+from matplotlib.markers import MarkerStyle
+
+from measurement import Meas
+from measurement import list_measurements
+from measurement import *
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\Drain sweep")
+
+files = os.listdir(os.getcwd())
+
+measurements = []
+
+for file in files:
+    measurement = Meas(file)
+    measurement.get_information()
+    measurements.append(measurement)
+
+#split in short and medium integration time
+measurements_shor,measurements_med = split_integration(measurements)
+measurements_med= sort_by_period(measurements_med)
+measurements_shor = sort_by_period(measurements_med)
+
+# convert to the plotting class
+measurements_med = list_measurements(measurements_med)
+measurements_shor = list_measurements(measurements_shor)
+
+measurements_med.retrive_values()
+measurements_shor.retrive_values()
+
+
+fig, (ax1,ax2) = plt.subplots(2 ,layout='constrained')
+
+#colormap
+cmap = plt.get_cmap('jet')
+
+#the plot
+fig.suptitle("High Current Pulse Sweep ")
+ax1.set_xlabel("Pulse Period (s)")
+ax1.set_ylabel("Delay(s)")
+ax1.set_title("Delay")
+
+im=ax1.scatter(measurements_med.periods,measurements_med.delays , c=measurements_med.pulses, cmap=cmap,marker='o',label ='MED')
+
+im =ax1.scatter(measurements_shor.periods,measurements_shor.delays , c=measurements_shor.pulses, cmap=cmap,marker='^',label ='SHOR')
+
+
+ax1.grid(True)
+ax1.legend()
+
+ax2.set_xlabel("Pulse Period (s)")
+ax2.set_ylabel("Relative error (%)")
+ax2.set_title("Relative error")
+
+im = ax2.scatter(measurements_med.periods, measurements_med.relative_errors, c=measurements_med.pulses, cmap=cmap,marker='o',label='MED')
+im=ax2.scatter(measurements_shor.periods, measurements_shor.relative_errors, c=measurements_shor.pulses, cmap=cmap,marker='^',label='SHOR')
+
+
+c_bar = plt.colorbar(im,ax=(ax1,ax2))
+c_bar.set_label("Number of pulses")
+
+ax2.grid(True)
+ax2.legend()
+
+plt.show()
+
+#plot results
+
+#get the nessecary files
+plot_med=measurements_med.get_indexes()
+plot_shor=measurements_shor.get_indexes()
+
+# convert to lists of measurements
+for i in range(len(plot_med)):
+    plot_med[i]= list_measurements(plot_med[i])
+    plot_med[i].retrive_values()
+
+for i in range(len(plot_shor)):
+    plot_shor[i]= list_measurements(plot_shor[i])
+    plot_shor[i].retrive_values()
+
+#create figure
+fig,axs = plt.subplots(3)
+
+for i in range(3):
+    period = max(plot_med[i].periods) #one element
+    for df in plot_med[i].results:
+        axs[i].plot(df["VPULSE(V)"],df['IPULSE(A)'],marker='o')
+    for df in plot_shor[i].results:
+        axs[i].plot(df["VPULSE(V)"],df['IPULSE(A)'],marker='^')
+    axs[i].legend([f"Period(s):{period}"])
+
+print(measurements_med.medium)
\ No newline at end of file
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep_new.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep_new.py
new file mode 100644
index 0000000..5e95f95
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/Drain_sweep_new.py	
@@ -0,0 +1,155 @@
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from measurement import Meas
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+# get the 14 measurements
+def split_dataframe_index(df):
+    subsets= []
+    for i in range(10):
+        subset = df[df["Index"]==i+1]
+        subsets.append(subset)
+    return subsets   
+
+#get the 3 measureemnts
+def plot_3(periods,df):
+    subsets = []
+    for period in periods:
+        subset = df[df["Period(s)"]==period]
+        subsets.append(subset)
+    return subsets
+
+#get measurement results from dataframe
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\Drain sweep")
+
+files = os.listdir(os.getcwd())
+
+data = pd.DataFrame() 
+
+for file in files:
+    if file.endswith(".txt"):
+        measurement = Meas(file)
+        dictionary = {"Index":measurement.index,"Period(s)":measurement.period,"Pulses":measurement.pulses,"Ideal(s)":measurement.ideal,"Real(s)":measurement.real,"Delay(s)":measurement.delay,"Relative Error(%)":measurement.relative_error,"Integration":measurement.integration,"file location":measurement.file}
+        data = data._append(dictionary,ignore_index=True)
+        
+#save the data for later use
+data.to_csv("Results.csv", encoding='utf-8',index=False)
+
+
+#split to short and medium integration time
+med = data[data['Integration']=='MED']
+shor = data[data['Integration']=='SHOR']
+
+
+#get the 10 measuremets
+measurements_med = split_dataframe_index(med)
+measurements_shor = split_dataframe_index(shor)
+
+for subset in measurements_med:
+    subset.sort_values(by='Pulses',inplace=True)
+for subset in measurements_shor:
+    subset.sort_values(by='Pulses',inplace=True)
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+
+plt.title("Delay of the High Current Pulse Sweep Measurements")
+plt.xlabel("Number of Pulses")
+plt.ylabel("Delay(s)")
+
+
+plt.legend()
+plt.show()
+
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+plt.title("Relative Error of the High Current Pulse Sweep Measurements")
+
+plt.xlabel("Number of Pulses")
+plt.ylabel("Relative Error(%)")
+plt.yscale("log")
+
+plt.legend()
+plt.show()
+
+print("Average Delay for medium integration time:",med["Delay(s)"].mean(),"±",med["Delay(s)"].std())
+print("Average Delay for short integration time:",shor["Delay(s)"].mean(),"±",shor["Delay(s)"].std())
+
+data = data.sort_values(by='Period(s)')
+data.boxplot(column=["Delay(s)"],by="Period(s)")
+
+plt.show()
+
+data.boxplot(column=["Relative Error(%)"],by="Period(s)")
+plt.yscale("log")
+plt.show()
+
+
+#plot the results
+
+#first retrieve the periods and sort them
+periods =list(set(data["Period(s)"].to_numpy()))
+periods.sort()
+
+periods_to_plot = [periods[0],periods[4],periods[9]]
+
+plot_med = plot_3(periods_to_plot,med)
+plot_shor = plot_3(periods_to_plot,shor)
+
+fig,axs = plt.subplots(1,3,figsize=(15,9),sharey=True)
+
+for index,subset in enumerate(plot_med): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace=True)
+    subset.reset_index(drop=True, inplace=True)
+
+    
+    for i in range(3): # 3 number of pulses
+        measurement = subset.iloc[i]
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[index].plot(df["VPULSE(V)"],df['RPULSE(Ohm)'],label = f'pulses(MED):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Medium Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+
+    
+for index,subset in enumerate(plot_shor): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace =True)
+    subset.reset_index(drop=True, inplace=True)
+
+    for i in range(3): #3 different pulses
+        measurement = subset.iloc[i]
+        
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[index].plot(df["VPULSE(V)"],df['RPULSE(Ohm)'],label = f'pulses(SHOR):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Short Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+ 
+fig.suptitle("Measurement Results for High Current Pulse Sweep Measurements")
+for i in range(3):
+    axs[i].set_title(f"Period(s):{periods_to_plot[i]}")
+    axs[i].set_xlabel("Voltage(V)")
+    axs[i].set_ylabel("Resistance(Ohm)")
+
+axs[0].legend()
+axs[1].legend()
+axs[2].legend()
+fig.tight_layout()
+plt.show()
+
+
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/constant_pulse.ipynb b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/constant_pulse.ipynb
new file mode 100644
index 0000000..912b78d
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/constant_pulse.ipynb	
@@ -0,0 +1,225 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "8ce721e3-4d69-495c-ba5e-eac30522e3dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import sys \n",
+    "sys.path.insert(0, '..') #append parent directory\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import module\n",
+    "import time\n",
+    "from random import uniform\n",
+    "import pandas as pd\n",
+    "from random import randint\n",
+    "\n",
+    "device = module.HP4155a('GPIB0::17::INSTR')\n",
+    "device.reset()\n",
+    "device.user_function('I','A','I2')\n",
+    "device.user_function('V','V','V2')\n",
+    "device.user_function('R','OHM','V/I')\n",
+    "\n",
+    "#disable vmus and vsus\n",
+    "device.disable_vsu(1)\n",
+    "device.disable_vsu(2)\n",
+    "device.disable_vmu(1)\n",
+    "device.disable_vmu(2)\n",
+    "\n",
+    "def pulse(const,start,stop,points,period,integration,device):\n",
+    "    device.smu_disable_sweep(1)\n",
+    "    #device.smu_disable_sweep(3)\n",
+    "    \n",
+    "    device.measurement_mode(\"SWE\")\n",
+    "    device.smu_mode_meas(2,\"VPULSE\")\n",
+    "    device.smu_function_sweep(2,'CONS')\n",
+    "    device.smu_mode_meas(4,\"COMM\")\n",
+    "    device.smu_function_sweep(2,\"CONS\")\n",
+    "    device.smu_function_sweep(4,'CONS')\n",
+    "\n",
+    "    #smu 3 is used to define the number of pulses not contacted\n",
+    "    device.smu_mode_meas(3,'V')\n",
+    "    device.smu_function_sweep(3,\"VAR1\")\n",
+    "\n",
+    "    device.start_value_sweep(start)\n",
+    "    device.stop_value_sweep(stop)\n",
+    "\n",
+    "    \n",
+    "    #define the number of steps given specific pulses\n",
+    "    step = (stop-start)/(points-1)\n",
+    "    device.step_sweep(step)\n",
+    "    \n",
+    "    device.comp(\"VAR1\",\"MAX\")\n",
+    "    device.const_comp(2,\"MAX\")\n",
+    "\n",
+    "    device.cons_smu_value(2,const)\n",
+    "    \n",
+    "    device.display_variable(\"X\",\"V\")\n",
+    "    device.display_variable(\"Y1\",'I')\n",
+    "\n",
+    "    device.range_mode(4,\"AUTO\")\n",
+    "    device.range_mode(2,\"AUTO\")\n",
+    "    device.range_mode(3,\"AUTO\")\n",
+    "\n",
+    "    device.pulse_width(period/10)\n",
+    "    device.pulse_period(period)\n",
+    "    device.integration_time(integration)\n",
+    "\n",
+    "    t0 = time.time()\n",
+    "    device.single_measurement()\n",
+    "    while device.operation_completed()== False:\n",
+    "        pass\n",
+    "    \n",
+    "    t1 = time.time()\n",
+    "    # get the execution time\n",
+    "    elapsed_time = t1 - t0\n",
+    "    device.autoscaling()\n",
+    "\n",
+    "    I_i=device.return_data(\"I\")\n",
+    "    V_i=device.return_data(\"V\")\n",
+    "    R_i = device.return_data(\"R\")\n",
+    "\n",
+    "    #plt.figure().clear()\n",
+    "    #plt.plot(V_i,I_i,label = f'{points} constant pulses')\n",
+    "    #plt.legend()\n",
+    "    #plt.show()\n",
+    "    \n",
+    "    expected_time = period*int(points)\n",
+    "\n",
+    "    times = (elapsed_time,expected_time)\n",
+    "    values = (V_i,I_i,R_i)\n",
+    "\n",
+    "    return times,values\n",
+    "\n",
+    "def has_duplicates(values):\n",
+    "    if len(values) != len(set(values)):\n",
+    "        return True\n",
+    "    else:\n",
+    "        return False"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "bbb5552d-0368-4a27-9224-b90b7ccb2a2c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Please Give The number of first iteration: 3\n",
+      "Please Give the number of the last iteration 10\n",
+      "Give the name of the measurement: MESA\n",
+      "Give the Constant voltage: 0.001\n",
+      "Give The Start Value: 0\n",
+      "Give The Stop Value: 1\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "programm finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "index_start = int(input(\"Please Give The number of first iteration:\"))\n",
+    "index_stop = int(input(\"Please Give the number of the last iteration\"))\n",
+    "measurement = input(\"Give the name of the measurement:\")\n",
+    "\n",
+    "const=float(input(\"Give the Constant voltage:\"))\n",
+    "\n",
+    "start = float(input(\"Give The Start Value:\"))\n",
+    "stop = float(input(\"Give The Stop Value:\"))\n",
+    "\n",
+    "#set the number of iterations\n",
+    "for i in range(index_start-1,index_stop):\n",
+    "    #for each iteration choose a random period and round it to 3 decimal points\n",
+    "    period = uniform(0.005,1)\n",
+    "    period = round(period,3)\n",
+    "\n",
+    "    #for each period choose 5 random pulse numbers from 2 to 100\n",
+    "    \n",
+    "    pulses = [randint(2, 100) for p in range(5)]\n",
+    "    #avoid duplicates\n",
+    "    while has_duplicates(pulses)== True:\n",
+    "        pulses = [randint(2, 100) for p in range(5)]\n",
+    "\n",
+    "    #iterate over the pulses list\n",
+    "    for j in range(len(pulses)):\n",
+    "        #execute the measuremnt first for short and then medium integration time\n",
+    "        for integration in [\"SHOR\",\"MED\"]:\n",
+    "            filename = r\"\\\\FILESERVER\\public\\Datentransfer\\Asonitis, Alexandros\\memristor test\\pulse_measurements\\constant_pulse_\" + f\"{measurement}_{integration}_{pulses[j]}_{i+1}.txt\"\n",
+    "            times,values = pulse(const,start,stop,pulses[j],period,integration,device)\n",
+    "            with open(filename,\"w\") as f: \n",
+    "                f.write(f\"{measurement}\"+\"\\n\")\n",
+    "                f.write(f\"period(s):{period}\"+\"\\n\")\n",
+    "                f.write(f\"execution time(s):{times[0]}\"+\"\\n\")\n",
+    "                f.write(f\"expected time(s):{times[1]}\"+\"\\n\")\n",
+    "                f.write(f\"number of pulses:{pulses[j]}\"+\"\\n\\n\")\n",
+    "\n",
+    "                zipped = list(zip(values[0],values[1], values[2]))\n",
+    "                df = pd.DataFrame(zipped, columns=['VPULSE(V)', 'IPULSE(A)', 'RPULSE(Ohm)'])\n",
+    "\n",
+    "                f.write(\"Results Pulse:\\n\")\n",
+    "                f.write(df.to_string())\n",
+    "print(\"programm finished\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "5aba9455-5223-4e7e-a96c-d6c7937ff2b6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+0,\"No error\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(device.error())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "cfd2fd82-ad4f-445c-a69e-3653d65eb47e",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/measurement.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/measurement.py
new file mode 100644
index 0000000..6167984
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/measurement.py	
@@ -0,0 +1,77 @@
+import pandas as pd
+
+class Meas():
+    def __init__(self,file:str):
+        self.file = file
+
+        replaced_file =  self.file.replace(".","_")
+        filename = replaced_file.split("_")
+
+        #read the integration time and the number of pulses,index
+        self.integration=filename[2]
+        self.pulses=int(filename[3])
+
+        self.index = int(filename[4])
+
+        #read the period, execution time and expected time
+        with open(self.file,'r') as f:
+            lines = f.readlines()
+                
+            for i in range(1,4):
+                lines[i]= lines[i].replace("\n",":")
+                lines[i] = lines[i].split(":")
+
+                if i == 1:
+                    self.period = float(lines[i][1])
+                    
+                
+                elif i == 2 :
+                    self.real= float(lines[i][1])
+                else: #i==3
+                    self.ideal = float(lines[i][1])
+        
+        # calculate delay and relative error
+        self.delay = self.real-self.ideal
+        self.relative_error = (self.delay / self.ideal) * 100
+
+        #get dataframe 
+        self.results = pd.read_csv(self.file,delim_whitespace=True,skiprows=7)
+
+
+class constant_pulse():
+    def __init__(self,file:str):
+        self.file = file
+
+        replaced_file =  self.file.replace(".","_")
+        filename = replaced_file.split("_")
+
+        #read the integration time and the number of pulses,index
+        self.integration=filename[3]
+        self.pulses=int(filename[4])
+
+        self.index = int(filename[5])
+
+        #read the period, execution time and expected time
+        with open(self.file,'r') as f:
+            lines = f.readlines()
+                
+            for i in range(1,4):
+                lines[i]= lines[i].replace("\n",":")
+                lines[i] = lines[i].split(":")
+
+                if i == 1:
+                    self.period = float(lines[i][1])
+                    
+                
+                elif i == 2 :
+                    self.real= float(lines[i][1])
+                else: #i==3
+                    self.ideal = float(lines[i][1])
+        
+        # calculate delay and relative error
+        self.delay = self.real-self.ideal
+        self.relative_error = (self.delay / self.ideal) * 100
+
+        #get dataframe 
+        self.results = pd.read_csv(self.file,delim_whitespace=True,skiprows=7)
+
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_constant.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_constant.py
new file mode 100644
index 0000000..6db7e16
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_constant.py	
@@ -0,0 +1,189 @@
+import os
+
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from measurement import Meas
+from measurement import constant_pulse
+import warnings
+
+warnings.filterwarnings("ignore")
+
+# get the 10 measurements
+def split_dataframe_index(df):
+    subsets= []
+    for i in range(10):
+        subset = df[df["Index"]==i+1]
+        subsets.append(subset)
+    return subsets   
+
+#get the 3 measureemnts
+def plot_3(periods,df):
+    subsets = []
+    for period in periods:
+        subset = df[df["Period(s)"]==period]
+        subsets.append(subset)
+    return subsets
+
+#get measurement results from dataframe
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\constant pulse low current")
+
+files = os.listdir(os.getcwd())
+
+data = pd.DataFrame() 
+
+for file in files:
+    if file.endswith(".txt"):
+        measurement = constant_pulse(file)
+        I_min=(measurement.results["IPULSE(A)"].abs()).min() 
+        dictionary = {"Index":measurement.index,"Period(s)":measurement.period,"Pulses":measurement.pulses,"Ideal(s)":measurement.ideal,"Real(s)":measurement.real,"Delay(s)":measurement.delay,"Relative Error(%)":measurement.relative_error,"Integration":measurement.integration,"file location":measurement.file,"Min I(A)":I_min,"Mean R(Ohm)":measurement.results["RPULSE(Ohm)"].mean(),"Max R(Ohm)":measurement.results["RPULSE(Ohm)"].max()}
+        data = data._append(dictionary,ignore_index=True)
+
+
+
+#save the data for later use
+data.to_csv("Results.csv", encoding='utf-8',index=False)
+
+
+#split to short and medium integration time
+med = data[data['Integration']=='MED']
+shor = data[data['Integration']=='SHOR']
+
+#remove overflows
+#shor = shor[shor["Max R(Ohm)"]<1e30]
+#med = med[med["Max R(Ohm)"]<1e30]
+
+
+
+#get the 14 measuremets
+measurements_med = split_dataframe_index(med)
+measurements_shor = split_dataframe_index(shor)
+
+
+#plot boxplot delay and relative error for both short and medium integration time in one plot
+
+data = data.sort_values(by='Period(s)')
+data.boxplot(column=["Delay(s)"],by="Period(s)")
+
+plt.show()
+
+data.boxplot(column=["Relative Error(%)"],by="Period(s)")
+plt.yscale("log")
+plt.show()
+
+
+for subset in measurements_med:
+    subset.sort_values(by='Pulses',inplace=True)
+for subset in measurements_shor:
+    subset.sort_values(by='Pulses',inplace=True)
+
+#plot number of pulse vs delay and realtive error
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+
+plt.title("Delay of the Low Current Pulse constant Measurements")
+plt.xlabel("Number of Pulses")
+plt.ylabel("Delay(s)")
+
+
+plt.legend()
+plt.show()
+
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+plt.title("Relative Error of the Low Current Pulse constant Measurements")
+
+plt.xlabel("Number of Pulses")
+plt.ylabel("Relative Error(%)")
+plt.yscale("log")
+
+plt.legend()
+plt.show()
+
+print("Average Delay for medium integration time:",med["Delay(s)"].mean(),"±",med["Delay(s)"].std())
+print("Average Delay for short integration time:",shor["Delay(s)"].mean(),"±",shor["Delay(s)"].std())
+
+#plot 3
+
+#plot the results
+
+#first retrieve the periods and sort them
+periods =list(set(data["Period(s)"].to_numpy()))
+periods.sort()
+
+periods_to_plot = [periods[0],periods[4],periods[9]]
+
+plot_med = plot_3(periods_to_plot,med)
+plot_shor = plot_3(periods_to_plot,shor)
+
+fig,axs = plt.subplots(2,3,figsize=(15,9))
+
+for index,subset in enumerate(plot_med): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace=True)
+    subset.reset_index(drop=True, inplace=True)
+
+    
+    for i in range(3): # 3 number of pulses
+        measurement = subset.iloc[i]
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[0,index].plot(df["VPULSE(V)"],df["IPULSE(A)"],label = f'pulses(MED):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Medium Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+
+    
+for index,subset in enumerate(plot_shor): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace =True)
+    subset.reset_index(drop=True, inplace=True)
+
+    for i in range(3): #3 different pulses
+        measurement = subset.iloc[i]
+        
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[1,index].plot(df["VPULSE(V)"],df['IPULSE(A)'],label = f'pulses(SHOR):{int(measurement["Pulses"])}')
+        print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Short Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+ 
+fig.suptitle("Measurement Results for Low Current Pulse constant Measurements")
+for i in range(2):
+    for j in range(3):
+        axs[i,j].set_title(f"Period(s):{periods_to_plot[j]}")
+        axs[i,j].set_xlabel("Voltage(V)")
+        axs[i,j].set_ylabel("Current(A)")
+
+        axs[i,j].legend()
+fig.tight_layout()
+plt.show()
+
+#plot minimum current
+med = med.sort_values(by='Period(s)')
+med.boxplot(column=["Min I(A)"],by="Period(s)",label='MED')
+plt.yscale('log')
+
+plt.legend()
+plt.show()
+
+shor = shor.sort_values(by='Period(s)')
+shor.boxplot(column=["Min I(A)"],by="Period(s)",label='SHOR')
+plt.yscale('log')
+
+plt.legend()
+plt.show()
+
+
+print("Average Minimum I(A) for medium integration time:",med['Min I(A)'].mean(),"±",med['Min I(A)'].std())
+print("Average Minimum I(A) for short integration time:",shor['Min I(A)'].mean(),"±",shor['Min I(A)'].std())
+
+
+
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_plots.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_plots.py
new file mode 100644
index 0000000..13c7d3b
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_plots.py	
@@ -0,0 +1,28 @@
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from measurement import Meas
+import warnings
+
+warnings.filterwarnings("ignore")
+
+#plot all the measurements
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\MESA")
+
+files = os.listdir(os.getcwd())
+fig= plt.figure(1)
+
+for file in files:
+    if file.endswith(".txt"):
+        meas = Meas(file)
+
+        fig.clear()
+        plt.plot(meas.results["VPULSE(V)"],meas.results["IPULSE(A)"])
+        plt.title(f"Period(s):{meas.period},Pulses:{meas.pulses},IT:{meas.integration}")
+        plt.xlabel("V(V)")
+        plt.ylabel("I(A)")
+        
+        filename = os.path.splitext(os.path.basename(file))[0]
+        plt.savefig(f"{filename}.png")
\ No newline at end of file
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_sweep.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_sweep.py
new file mode 100644
index 0000000..0d1c37f
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/mesa_sweep.py	
@@ -0,0 +1,178 @@
+import os
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+from measurement import Meas
+import warnings
+
+warnings.filterwarnings("ignore")
+
+
+# get the 10 measurements
+def split_dataframe_index(df):
+    subsets= []
+    for i in range(14):
+        subset = df[df["Index"]==i+1]
+        subsets.append(subset)
+    return subsets   
+
+#get the 3 measureemnts
+def plot_3(periods,df):
+    subsets = []
+    for period in periods:
+        subset = df[df["Period(s)"]==period]
+        subsets.append(subset)
+    return subsets
+
+#get measurement results from dataframe
+
+os.chdir(r"\\FILESERVER\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\MESA")
+
+files = os.listdir(os.getcwd())
+
+data = pd.DataFrame() 
+
+for file in files:
+    if file.endswith(".txt"):
+        measurement = Meas(file)
+        I_min=(measurement.results["IPULSE(A)"].abs()).min() 
+        dictionary = {"Index":measurement.index,"Period(s)":measurement.period,"Pulses":measurement.pulses,"Ideal(s)":measurement.ideal,"Real(s)":measurement.real,"Delay(s)":measurement.delay,"Relative Error(%)":measurement.relative_error,"Integration":measurement.integration,"file location":measurement.file,"Min I(A)":I_min}
+        data = data._append(dictionary,ignore_index=True)
+        
+#save the data for later use
+data.to_csv("Results.csv", encoding='utf-8',index=False)
+
+
+#split to short and medium integration time
+med = data[data['Integration']=='MED']
+shor = data[data['Integration']=='SHOR']
+
+
+#get the 14 measuremets
+measurements_med = split_dataframe_index(med)
+measurements_shor = split_dataframe_index(shor)
+
+
+#plot boxplot delay and relative error for both short and medium integration time in one plot
+
+data = data.sort_values(by='Period(s)')
+data.boxplot(column=["Delay(s)"],by="Period(s)")
+
+plt.show()
+
+data.boxplot(column=["Relative Error(%)"],by="Period(s)")
+plt.yscale("log")
+plt.show()
+
+
+for subset in measurements_med:
+    subset.sort_values(by='Pulses',inplace=True)
+for subset in measurements_shor:
+    subset.sort_values(by='Pulses',inplace=True)
+
+#plot number of pulse vs delay and realtive error
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Delay(s)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+
+plt.title("Delay of the Low Current Pulse Sweep Measurements")
+plt.xlabel("Number of Pulses")
+plt.ylabel("Delay(s)")
+
+
+plt.legend()
+plt.show()
+
+
+for subset in measurements_med:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"MED:{round(subset["Period(s)"].mean(),3)}s",marker="o")
+for subset in measurements_shor:
+    plt.plot(subset["Pulses"],subset["Relative Error(%)"],label =f"SHOR:{round(subset["Period(s)"].mean(),3)}s",marker="v")
+
+plt.title("Relative Error of the Low Current Pulse Sweep Measurements")
+
+plt.xlabel("Number of Pulses")
+plt.ylabel("Relative Error(%)")
+plt.yscale("log")
+
+plt.legend()
+plt.show()
+
+print("Average Delay for medium integration time:",med["Delay(s)"].mean(),"±",med["Delay(s)"].std())
+print("Average Delay for short integration time:",shor["Delay(s)"].mean(),"±",shor["Delay(s)"].std())
+
+#plot 3
+
+#plot the results
+
+#first retrieve the periods and sort them
+periods =list(set(data["Period(s)"].to_numpy()))
+periods.sort()
+
+periods_to_plot = [periods[0],periods[7],periods[13]]
+
+plot_med = plot_3(periods_to_plot,med)
+plot_shor = plot_3(periods_to_plot,shor)
+
+fig,axs = plt.subplots(2,3,figsize=(15,9))
+
+for index,subset in enumerate(plot_med): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace=True)
+    subset.reset_index(drop=True, inplace=True)
+
+    
+    for i in range(3): # 3 number of pulses
+        measurement = subset.iloc[i]
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[0,index].plot(df["VPULSE(V)"],df["IPULSE(A)"],label = f'pulses(MED):{int(measurement["Pulses"])}')
+        #print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Medium Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+
+    
+for index,subset in enumerate(plot_shor): #the different periods
+    subset.sort_values(by='Pulses',inplace= True)
+    subset.reset_index(drop=True, inplace=True)
+    subset.drop(index=[1,3],inplace =True)
+    subset.reset_index(drop=True, inplace=True)
+
+    for i in range(3): #3 different pulses
+        measurement = subset.iloc[i]
+        
+        #get the values
+        df = pd.read_csv(str(measurement["file location"]),delim_whitespace=True,skiprows=7)
+        axs[1,index].plot(df["VPULSE(V)"],df['IPULSE(A)'],label = f'pulses(SHOR):{int(measurement["Pulses"])}')
+        #print(f"Average Resistance for {int(measurement["Pulses"])} Pulses and Short Integration Time:{df['RPULSE(Ohm)'].mean()}±{df['RPULSE(Ohm)'].std()}") 
+ 
+fig.suptitle("Measurement Results for Low Current Pulse Sweep Measurements")
+for i in range(2):
+    for j in range(3):
+        axs[i,j].set_title(f"Period(s):{periods_to_plot[j]}")
+        axs[i,j].set_xlabel("Voltage(V)")
+        axs[i,j].set_ylabel("Current(A)")
+
+        axs[i,j].legend()
+fig.tight_layout()
+plt.show()
+
+#plot minimum current
+med = med.sort_values(by='Period(s)')
+med.boxplot(column=["Min I(A)"],by="Period(s)",label='MED')
+plt.yscale('log')
+
+plt.legend()
+plt.show()
+
+shor = shor.sort_values(by='Period(s)')
+shor.boxplot(column=["Min I(A)"],by="Period(s)",label='SHOR')
+plt.yscale('log')
+
+plt.legend()
+plt.show()
+
+
+print("Average Minimum I(A) for medium integration time:",med['Min I(A)'].mean(),"±",med['Min I(A)'].std())
+print("Average Minimum I(A) for short integration time:",shor['Min I(A)'].mean(),"±",shor['Min I(A)'].std())
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/sweep_pulse.ipynb b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/sweep_pulse.ipynb
new file mode 100644
index 0000000..c11f336
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/sweep_pulse.ipynb	
@@ -0,0 +1,220 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d310162d-c528-49ef-babb-47f603fee08b",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "VisaIOError",
+     "evalue": "VI_ERROR_RSRC_LOCKED (-1073807345): Specified type of lock cannot be obtained, or specified operation cannot be performed, because the resource is locked.",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[1;31mVisaIOError\u001b[0m                               Traceback (most recent call last)",
+      "Cell \u001b[1;32mIn[1], line 15\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[38;5;66;03m#connect to the device\u001b[39;00m\n\u001b[0;32m     14\u001b[0m device \u001b[38;5;241m=\u001b[39m module\u001b[38;5;241m.\u001b[39mHP4155a(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mGPIB0::17::INSTR\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m---> 15\u001b[0m \u001b[43mdevice\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mreset\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m     17\u001b[0m \u001b[38;5;66;03m#set the measurement parameters\u001b[39;00m\n\u001b[0;32m     18\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mpulse\u001b[39m(start,stop,points,period,integration,device):\n",
+      "File \u001b[1;32m~\\labcode\\hp4155\\memristor\\..\\module.py:18\u001b[0m, in \u001b[0;36mHP4155a.reset\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m     17\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mreset\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[1;32m---> 18\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43minst\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43m*RST\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyvisa\\resources\\messagebased.py:197\u001b[0m, in \u001b[0;36mMessageBasedResource.write\u001b[1;34m(self, message, termination, encoding)\u001b[0m\n\u001b[0;32m    191\u001b[0m         warnings\u001b[38;5;241m.\u001b[39mwarn(\n\u001b[0;32m    192\u001b[0m             \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mwrite message already ends with \u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtermination characters\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[0;32m    193\u001b[0m             stacklevel\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m2\u001b[39m,\n\u001b[0;32m    194\u001b[0m         )\n\u001b[0;32m    195\u001b[0m     message \u001b[38;5;241m+\u001b[39m\u001b[38;5;241m=\u001b[39m term\n\u001b[1;32m--> 197\u001b[0m count \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite_raw\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mencode\u001b[49m\u001b[43m(\u001b[49m\u001b[43menco\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m    199\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m count\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyvisa\\resources\\messagebased.py:157\u001b[0m, in \u001b[0;36mMessageBasedResource.write_raw\u001b[1;34m(self, message)\u001b[0m\n\u001b[0;32m    143\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mwrite_raw\u001b[39m(\u001b[38;5;28mself\u001b[39m, message: \u001b[38;5;28mbytes\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mint\u001b[39m:\n\u001b[0;32m    144\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"Write a byte message to the device.\u001b[39;00m\n\u001b[0;32m    145\u001b[0m \n\u001b[0;32m    146\u001b[0m \u001b[38;5;124;03m    Parameters\u001b[39;00m\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    155\u001b[0m \n\u001b[0;32m    156\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[1;32m--> 157\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mvisalib\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mwrite\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msession\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmessage\u001b[49m\u001b[43m)\u001b[49m[\u001b[38;5;241m0\u001b[39m]\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyvisa\\ctwrapper\\functions.py:2796\u001b[0m, in \u001b[0;36mwrite\u001b[1;34m(library, session, data)\u001b[0m\n\u001b[0;32m   2794\u001b[0m return_count \u001b[38;5;241m=\u001b[39m ViUInt32()\n\u001b[0;32m   2795\u001b[0m \u001b[38;5;66;03m# [ViSession, ViBuf, ViUInt32, ViPUInt32]\u001b[39;00m\n\u001b[1;32m-> 2796\u001b[0m ret \u001b[38;5;241m=\u001b[39m \u001b[43mlibrary\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mviWrite\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdata\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mlen\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbyref\u001b[49m\u001b[43m(\u001b[49m\u001b[43mreturn_count\u001b[49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m   2797\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m return_count\u001b[38;5;241m.\u001b[39mvalue, ret\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyvisa\\ctwrapper\\highlevel.py:226\u001b[0m, in \u001b[0;36mIVIVisaLibrary._return_handler\u001b[1;34m(self, ret_value, func, arguments)\u001b[0m\n\u001b[0;32m    223\u001b[0m         \u001b[38;5;66;03m# Set session back to a safe value\u001b[39;00m\n\u001b[0;32m    224\u001b[0m         session \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m--> 226\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhandle_return_value\u001b[49m\u001b[43m(\u001b[49m\u001b[43msession\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mret_value\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[1;32m~\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\pyvisa\\highlevel.py:251\u001b[0m, in \u001b[0;36mVisaLibraryBase.handle_return_value\u001b[1;34m(self, session, status_code)\u001b[0m\n\u001b[0;32m    248\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_last_status_in_session[session] \u001b[38;5;241m=\u001b[39m rv\n\u001b[0;32m    250\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m rv \u001b[38;5;241m<\u001b[39m \u001b[38;5;241m0\u001b[39m:\n\u001b[1;32m--> 251\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m errors\u001b[38;5;241m.\u001b[39mVisaIOError(rv)\n\u001b[0;32m    253\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m rv \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39missue_warning_on:\n\u001b[0;32m    254\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m session \u001b[38;5;129;01mand\u001b[39;00m rv \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_ignore_warning_in_session[session]:\n",
+      "\u001b[1;31mVisaIOError\u001b[0m: VI_ERROR_RSRC_LOCKED (-1073807345): Specified type of lock cannot be obtained, or specified operation cannot be performed, because the resource is locked."
+     ]
+    }
+   ],
+   "source": [
+    "import sys \n",
+    "sys.path.insert(0, '..') #append parent directory\n",
+    "\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "\n",
+    "import module\n",
+    "import time\n",
+    "from random import uniform\n",
+    "import pandas as pd\n",
+    "from random import randint\n",
+    "\n",
+    "#connect to the device\n",
+    "device = module.HP4155a('GPIB0::17::INSTR')\n",
+    "device.reset()\n",
+    "\n",
+    "#set the measurement parameters\n",
+    "def pulse(start,stop,points,period,integration,device):\n",
+    "\n",
+    "    device.smu_disable_sweep(1)\n",
+    "    device.smu_disable_sweep(3)\n",
+    "\n",
+    "    #disable vmus and vsus\n",
+    "    device.disable_vsu(1)\n",
+    "    device.disable_vsu(2)\n",
+    "    device.disable_vmu(1)\n",
+    "    device.disable_vmu(2)\n",
+    "\n",
+    "    device.user_function('R','OHM','V2/I2')\n",
+    "    device.measurement_mode(\"SWE\")\n",
+    "    device.smu_function_sweep(2,\"VAR1\")\n",
+    "    device.smu_mode_meas(4,\"COMMON\")\n",
+    "    device.smu_function_sweep(4,\"CONS\")\n",
+    "\n",
+    "    device.smu_mode_meas(2,\"VPULSE\")\n",
+    "    device.start_value_sweep(start)\n",
+    "    device.stop_value_sweep(stop)\n",
+    "\n",
+    "    #define the number of steps given specific pulses\n",
+    "    \n",
+    "    step = (stop-start)/(points-1)\n",
+    "    device.step_sweep(step)\n",
+    "    \n",
+    "    device.comp(\"VAR1\",\"MAX\")\n",
+    "    \n",
+    "    device.display_variable(\"X\",\"V2\")\n",
+    "    device.display_variable(\"Y1\",'I2')\n",
+    "\n",
+    "    device.range_mode(4,\"AUTO\")\n",
+    "    device.range_mode(2,\"AUTO\")\n",
+    "\n",
+    "    device.pulse_width(period/10)\n",
+    "    device.pulse_period(period)\n",
+    "    device.integration_time(integration)\n",
+    "\n",
+    "    t0 = time.time()\n",
+    "    device.single_measurement()\n",
+    "    while device.operation_completed()== False:\n",
+    "        pass\n",
+    "    \n",
+    "    t1 = time.time()\n",
+    "    # get the execution time\n",
+    "    elapsed_time = t1 - t0\n",
+    "    device.autoscaling()\n",
+    "\n",
+    "    I_i=device.return_data(\"I2\")\n",
+    "    V_i=device.return_data(\"V2\")\n",
+    "    R_i = device.return_data(\"R\")\n",
+    "    \n",
+    "    \n",
+    "    expected_time = period*int(points)\n",
+    "\n",
+    "    times = (elapsed_time,expected_time)\n",
+    "    values = (V_i,I_i,R_i)\n",
+    "\n",
+    "    return times,values"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "5173db43-2301-4946-9dbb-9296d61b979f",
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "name": "stdin",
+     "output_type": "stream",
+     "text": [
+      "Please Give The number of first iteration: 1\n",
+      "Please Give the number of the last iteration 10\n",
+      "Give the name of the measurement: DRAIN\n",
+      "Give The Start Value: 0\n",
+      "Give The Stop Value: 15\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "programm finished\n"
+     ]
+    }
+   ],
+   "source": [
+    "index_start = int(input(\"Please Give The number of first iteration:\"))\n",
+    "index_stop = int(input(\"Please Give the number of the last iteration\"))\n",
+    "measurement = input(\"Give the name of the measurement:\")\n",
+    "\n",
+    "start = int(input(\"Give The Start Value:\"))\n",
+    "stop = int(input(\"Give The Stop Value:\"))\n",
+    "\n",
+    "#set the number of iterations\n",
+    "for i in range(index_start-1,index_stop):\n",
+    "    #for each iteration choose a random period and round it to 3 decimal points\n",
+    "    period = uniform(0.005,1)\n",
+    "    period = round(period,3)\n",
+    "\n",
+    "    #for each period choose 5 random pulse numbers from 2 to 100\n",
+    "    pulses = [randint(2, 100) for p in range(5)]\n",
+    "\n",
+    "    #iterate over the pulses list\n",
+    "    for j in range(len(pulses)):\n",
+    "        #execute the measuremnt first for short and then medium integration time\n",
+    "        for integration in [\"SHOR\",\"MED\"]:\n",
+    "            filename = r\"\\\\FILESERVER\\public\\Datentransfer\\Asonitis, Alexandros\\memristor test\\pulse_measurements\\evaluation_\" + f\"{measurement}_{integration}_{pulses[j]}_{i+1}.txt\"\n",
+    "            times,values = pulse(start,stop,pulses[j],period,integration,device)\n",
+    "            with open(filename,\"w\") as f: \n",
+    "                f.write(f\"{measurement}\"+\"\\n\")\n",
+    "                f.write(f\"period(s):{period}\"+\"\\n\")\n",
+    "                f.write(f\"execution time(s):{times[0]}\"+\"\\n\")\n",
+    "                f.write(f\"expected time(s):{times[1]}\"+\"\\n\")\n",
+    "                f.write(f\"number of pulses:{pulses[j]}\"+\"\\n\\n\")\n",
+    "\n",
+    "                zipped = list(zip(values[0],values[1], values[2]))\n",
+    "                df = pd.DataFrame(zipped, columns=['VPULSE(V)', 'IPULSE(A)', 'RPULSE(Ohm)'])\n",
+    "\n",
+    "                f.write(\"Results Pulse:\\n\")\n",
+    "                f.write(df.to_string())\n",
+    "print(\"programm finished\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "6a4234c9-cf9f-42e2-99e8-f7ac9d1d5beb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "+0,\"No error\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(device.error())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "4aab235b-1533-4ae0-b4bb-930e5d3e0116",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.0"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/time_evaluation.py b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/time_evaluation.py
new file mode 100644
index 0000000..8d6e5f3
--- /dev/null
+++ b/hp4155/memristor pulsed (Version 1.0)/pulse evaluations/time_evaluation.py	
@@ -0,0 +1,87 @@
+import os
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+
+os.chdir(r"\\fileserver.cst.rwth-aachen.de\public\Datentransfer\Asonitis, Alexandros\memristor test\pulse_measurements\High current measurements")
+
+
+files = os.listdir(os.getcwd())
+
+periods =[]
+execution_times =[]
+expected_times = []
+
+
+#read all the headers from  the txt files 
+for file in files:
+    if file.endswith(".txt"):
+        with open(file,'r') as f:
+            lines = f.readlines()
+
+            for i in range(1,4):
+                lines[i]= lines[i].replace("\n",":")
+                lines[i] = lines[i].split(":")
+
+                if i == 1:
+                    period = float(lines[i][1])
+                    periods.append(period)
+                
+                elif i == 2 :
+                    execution_time = float(lines[i][1])
+                    execution_times.append(execution_time)
+                else: #i==3
+                    expected_time = float(lines[i][1])
+                    expected_times.append(expected_time)
+
+
+# get the dataframes
+dfs = []
+
+for file in files:
+    df = pd.read_csv(file,delim_whitespace=True,skiprows=6)
+    dfs.append(df)
+
+
+#sort the lists
+sort_indexes = np.argsort(periods)
+expected_times = [expected_times[index] for index in sort_indexes]
+execution_times = [execution_times[index] for index in sort_indexes]
+periods= [periods[index] for index in sort_indexes]
+dfs = [dfs[index] for index in sort_indexes]
+
+#calculate delays
+delays = np.subtract(execution_times,expected_times)
+
+# plots
+
+fig,(ax1,ax2,ax3) = plt.subplots(3,sharex=True)
+fig.suptitle("Duration Evaluation of High Current Pulse Sweep Measurements")
+
+ax1.plot(periods,expected_times,label="Ideal")
+ax1.plot(periods,execution_times,label = "Real")
+ax1.set_ylabel("Duration (s)")
+ax1.legend()
+
+ax2.plot(periods,delays)
+ax2.set_ylabel("Delay (s)")
+
+relative_error = np.divide(delays,expected_times)*100
+ax3.plot(periods,relative_error)
+ax3.set_ylabel("Relative Error (%)")
+ax3.set_xlabel("Period (s)")
+
+plt.show()
+
+fig,(ax1,ax2) = plt.subplots(2,sharex=True)
+
+df = dfs[0]
+ax1.plot(df["V(V)"],df["I(A)"])
+ax2.plot(df["V(V)"],df["R(Ohm)"])
+
+ax1.set_ylabel("I (A)")
+ax2.set_xlabel("V (V)")
+ax2.set_ylabel("R (Ohm)")
+
+fig.suptitle("Results Evaluation of High Current Pulse Sweep Measurements")
+plt.show()
\ No newline at end of file
diff --git a/hp4155/memristor_pulsed/pulse.py b/hp4155/memristor pulsed (Version 1.0)/pulse.py
similarity index 100%
rename from hp4155/memristor_pulsed/pulse.py
rename to hp4155/memristor pulsed (Version 1.0)/pulse.py
diff --git a/hp4155/memristor_pulsed/pulse_interface.ipynb b/hp4155/memristor pulsed (Version 1.0)/pulse_interface.ipynb
similarity index 100%
rename from hp4155/memristor_pulsed/pulse_interface.ipynb
rename to hp4155/memristor pulsed (Version 1.0)/pulse_interface.ipynb
-- 
GitLab