# -*- coding: utf-8 -*- """ Created on 29.10.2024, 09:00 hrs LC Controller measurement script @author: Serdar, adjusted by Lukas and Ryan """ ############################################ # Packages from Ryan import re import math import threading import pyvisa import time # from pyvisa import ResourceManager, constants # NOTE: KLCCommandLib64.py must be in the same folder as this script! try: from KLCCommandLib64 import * except OSError as ex: print("Warning:",ex) # Maximum output voltage V_MAX = 25 # corresponds to the max RMS voltage of 25 V of KLC101 device # NOTE: AC output of KLC101 is a square wave, RMS = Amplitude ############################################ # import AMC # TODO: removed, this package only relevant for the positioner in the 1000 cryostat import csv import time import clr import sys import os, glob, string import spe2py as spe import spe_loader as sl import pandas as pd import time from System.IO import * from System import String import numpy as np import matplotlib.pyplot as plt import datetime from typing import Union # NOTE: this is possibly not needed, remove later #First choose your controller IP_AMC300 = "192.168.1.1" IP_AMC100 = "192.168.71.100" # IP = "192.168.1.1" IP = IP_AMC100 # Import System.IO for saving and opening files from System.IO import * from System.Threading import AutoResetEvent # Import C compatible List and String from System import String from System.Collections.Generic import List # Add needed dll references sys.path.append(os.environ['LIGHTFIELD_ROOT']) sys.path.append(os.environ['LIGHTFIELD_ROOT']+"\\AddInViews") sys.path.append(r'C:\Program Files\Princeton Instruments\LightField\AddInViews') #I added them by hand -serdar sys.path.append(r'C:\Program Files\Princeton Instruments\LightField') #this one also clr.AddReference('PrincetonInstruments.LightFieldViewV5') clr.AddReference('PrincetonInstruments.LightField.AutomationV5') clr.AddReference('PrincetonInstruments.LightFieldAddInSupportServices') os.environ['LIGHTFIELD_ROOT'] = r'C:\Program Files\Princeton Instruments\LightField' # PI imports from PrincetonInstruments.LightField.Automation import Automation from PrincetonInstruments.LightField.AddIns import ExperimentSettings from PrincetonInstruments.LightField.AddIns import CameraSettings #from PrincetonInstruments.LightField.AddIns import DeviceType from PrincetonInstruments.LightField.AddIns import SpectrometerSettings from PrincetonInstruments.LightField.AddIns import RegionOfInterest ######################################################################################################### code begins from here ############################################# def set_custom_ROI(): # Get device full dimensions dimensions = experiment.FullSensorRegion() regions = [] # Add two ROI to regions regions.append( RegionOfInterest( int(dimensions.X), int(dimensions.Y), int(dimensions.Width), int(dimensions.Height//4), # Use // for integer division int(dimensions.XBinning), int(dimensions.Height//4))) # Set both ROI experiment.SetCustomRegions(regions) def experiment_completed(sender, event_args): #callback function which is hooked to event completed, this is the listener print("... Acquisition Complete!") acquireCompleted.Set() #set the event. This puts the autoresetevent false.(look at .NET library for furher info) def InitializerFilenameParams(): experiment.SetValue(ExperimentSettings.FileNameGenerationAttachIncrement, False) experiment.SetValue(ExperimentSettings.FileNameGenerationIncrementNumber, 1.0) experiment.SetValue(ExperimentSettings.FileNameGenerationIncrementMinimumDigits, 2.0) experiment.SetValue(ExperimentSettings.FileNameGenerationAttachDate, False) experiment.SetValue(ExperimentSettings.FileNameGenerationAttachTime, False) def AcquireAndLock(name): print("Acquiring...", end = "") # name += 'Exp{0:06.2f}ms.CWL{1:07.2f}nm'.format(\ # experiment.GetValue(CameraSettings.ShutterTimingExposureTime)\ # ,experiment.GetValue(SpectrometerSettings.GratingCenterWavelength)) experiment.SetValue(ExperimentSettings.FileNameGenerationBaseFileName, name) #this creates .spe file with the name experiment.Acquire() # this is an ashynrchronus func. acquireCompleted.WaitOne() def calculate_distance(x1, y1, x2, y2): return np.sqrt((x2 - x1)**2 + (y2 - y1)**2) def generate_scan_positions(center, range_val, resolution): positive_range = np.arange(center, center + range_val + resolution, resolution) return positive_range def save_as_csv(filename, position_x, position_y): file_existance = os.path.isfile(filename) with open(filename, 'a', newline = '') as csvfile: writer = csv.writer(csvfile) if not file_existance: writer.writerow(['x_coordinates','y_coordinates']) writer.writerow([position_x, position_y]) ################################################################# RYAN'S FUNCTIONS HERE ########################################################################################## # NOTE: leave this function here, could be useful for future uses def polar_to_cartesian(radius, start_angle, end_angle, step_size, clockwise=True): # TODO: DOCS """Creates a list of discrete cartesian coordinates (x,y), given the radius, start- and end angles, the angle step size, and the direction of rotation. Function then returns a list of two lists: list of angles and list of cartesian coordinates (x,y coordinates in a tuple). Args: radius (_type_): _description_ start_angle (_type_): _description_ end_angle (_type_): _description_ step_size (_type_): _description_ clockwise (bool, optional): _description_. Defaults to True. Returns: _type_: _description_ """ """""" # Initialize lists to hold angles and (x, y) pairs angles = [] coordinates = [] # Normalize angles to the range [0, 360) start_angle = start_angle % 360 end_angle = end_angle % 360 if clockwise: # Clockwise rotation current_angle = start_angle while True: # Append the current angle to the angles list angles.append(current_angle % 360) # Convert the current angle to radians current_angle_rad = math.radians(current_angle % 360) # Convert polar to Cartesian coordinates x = radius * math.cos(current_angle_rad) y = radius * math.sin(current_angle_rad) # Append the (x, y) pair to the list coordinates.append((x, y)) # Check if we've reached the end_angle (handling wrap-around) (current_angle - step_size) % 360 == end_angle or if current_angle % 360 == end_angle: break # Decrement the current angle by the step size current_angle -= step_size if current_angle < 0: current_angle += 360 else: # Counterclockwise rotation current_angle = start_angle while True: # Append the current angle to the angles list angles.append(current_angle % 360) # Convert the current angle to radians current_angle_rad = math.radians(current_angle % 360) # Convert polar to Cartesian coordinates x = radius * math.cos(current_angle_rad) y = radius * math.sin(current_angle_rad) # Append the (x, y) pair to the list coordinates.append((x, y)) # Check if we've reached the end_angle (handling wrap-around) (current_angle + step_size) % 360 == end_angle or if current_angle % 360 == end_angle: break # Increment the current angle by the step size current_angle += step_size if current_angle >= 360: current_angle -= 360 return [angles, coordinates] ################################################################# DASHA'S CODE HERE ############################################################################################## # NOTE: all voltage values are the RMS values, and have the unit V def LCR_scan_func(handle:int, init_voltage:float, final_voltage:float, res:float, base_file_name='', folder_name='', reversescan_bool=False, zerowhenfin_bool=True, loopscan_bool=False)->None: """This code is implemented to rotate the Liquid Crystal Retarder, using Thorlabs' KLC101 K-Cube control box. For each voltage (^= angle in the Liquid Crystal Retarder), a measurement of the spectrum via the LightField spectrometer is made. Data Args: handle (int): the handle of the KLC101 device init_voltage (float): starting voltage (V) final_voltage (float): end voltage (V) res (float): voltage step size (V) base_file_name (str, optional): Name of measurement file. Defaults to ''. folder_name (str, optional): Name of folder, where the measurements are saved to. Defaults to ''. reversescan_bool (bool, optional): Toggles to perform measurements in the reverse direction. Defaults to False. zerowhenfin_bool (bool, optional): Turns off the output of the control box, at the end of the measurement series. Defaults to True. loopscan_bool (bool, optional): Toggles the option to perform the following scan: starting voltage -> final voltage -> starting voltage. Defaults to False. """ def pyramid_list(lst) -> Union[list, np.ndarray]: """reverses the list and removes the first element of reversed list. Then, this is appended to the end of the original list and returned as the 'pyramid' list. Args: lst (list or np.ndarray): Raises: TypeError: if the input object isn't a list or np.ndarray Returns: Union[list, np.ndarray]: the pyramid list """ '''''' if isinstance(lst, list): return lst + lst[-2::-1] elif isinstance(lst, np.ndarray): return np.append(lst, lst[-2::-1]) else: raise TypeError('Please input a list!') # defines the folder, in which the data from the spectrometer is temporarily stored in temp_folder_path = "C:/Users/localadmin/Desktop/Users/Dasha/LCR_temp_dump_folder" if base_file_name =='': base_file_name = datetime.datetime.now().strftime('%Y_%m_%d_%H.%M') start_time = time.time() # start of the scan function # Check if the given start and/or end voltages are within the accepted limits if (init_voltage >= V_MAX): raise ValueError('Maximum device voltage exceeded! Please input a smaller initial voltage!') elif (end_voltage >= V_MAX): raise ValueError('Maximum device voltage exceeded! Please input a smaller final voltage!') elif (res >= V_MAX): raise ValueError('Entered step size exceeds 25 V! Please choose a smaller step size!') # creates list of voltage values to measure at, with given resolution, in V voltage_lst = np.arange(init_voltage, final_voltage + res, res) # if reverse scan, flips the direction of the scan if reversescan_bool: voltage_lst = voltage_lst[::-1] # creates the pyramid list of B vals if one were to perform a hysteresis measurement if loopscan_bool: voltage_lst = pyramid_list(voltage_lst) total_points = len(voltage_lst) middle_index_voltage_lst = total_points // 2 intensity_data = [] # To store data from each scan cwd = os.getcwd() # save original directory # helper function for the scanning loop def helper_scan_func(idx, voltage_val, instr=handle, sleep=0.5): # TODO: idx argument possibly redundant for Dasha's code # TODO: docstring # => enable V1 preset => set voltage for V1 preset klcSetChannelEnable(instr, 1) # initialise actual_voltage_val variable actual_voltage_val = [0] klcGetVoltage1(instr, actual_voltage_val) print(f'Actual output voltage: {actual_voltage_val[0]} V,', f'Target output voltage: {voltage_val} V') klcSetVoltage1(instr, voltage_val) while abs(actual_voltage_val[0] - voltage_val) > 0.0011: # check if target voltage is reached, if not, wait time.sleep(sleep) # little break klcGetVoltage1(instr, actual_voltage_val) # update the actual voltage print(f'Actual output voltage: {actual_voltage_val[0]} V,', f'Target output voltage: {voltage_val} V') #scanning loop for i, voltageval in enumerate(voltage_lst): if not loopscan_bool: helper_scan_func(i, voltageval) else: if i <= middle_index_voltage_lst: helper_scan_func(i, voltageval) else: helper_scan_func(i, voltageval) time.sleep(5) # we acquire with the LF acquire_name_spe = f'{base_file_name}_{voltageval}V' AcquireAndLock(acquire_name_spe) #this creates a .spe file with the scan name. # read the .spe file and get the data as loaded_files cwd = os.getcwd() # save original directory os.chdir(temp_folder_path) #change directory loaded_files = sl.load_from_files([acquire_name_spe + '.spe']) # get the .spe file as a variable os.chdir(cwd) # go back to original directory # Delete the created .spe file from acquiring after getting necessary info spe_file_path = os.path.join(temp_folder_path, acquire_name_spe + '.spe') os.remove(spe_file_path) points_left = total_points - i - 1 print('Points left in the scan: ', points_left) #append the intensity data as it is (so after every #of_wl_points, the spectrum of the next point begins) intensity_data.append(loaded_files.data[0][0][0]) #prints total time the mapping lasted end_time = time.time() elapsed_time = (end_time - start_time) / 60 print('Scan time: ', elapsed_time, 'minutes') if zerowhenfin_bool: klcSetVoltage1(handle, 0) # sets V1 channel voltage to 0 V klcSetChannelEnable(handle, 0) # disables channel output #save intensity & WL data as .txt os.chdir('C:/Users/localadmin/Desktop/Users/Dasha/241112_LCR_code_test') # creates new folder for MAP data if folder_name == '': folder_name = f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}" else: folder_name = f"{datetime.datetime.now().strftime('%Y_%m_%d_%H.%M')}_" + folder_name os.mkdir(folder_name) # Here the things will be saved in a new folder under user Lukas ! # IMPORTANT last / has to be there, otherwise data cannot be saved and will be lost!!!!!!!!!!!!!!!! os.chdir('C:/Users/localadmin/Desktop/Users/Dasha/241112_LCR_code_test'+ folder_name) intensity_data = np.array(intensity_data) np.savetxt(base_file_name + '.txt', intensity_data) wl = np.array(loaded_files.wavelength) np.savetxt("Wavelength.txt", wl) # TODO: save the list of voltages to a separate .csv or .txt data in the same folder directory. # PERFORM TEST TO SEE IF THIS WORKS!!! np.savetxt("Voltage.txt", voltage_lst) ################################################################# END OF FUNCTION DEFS ########################################################################################### # ENTER START AND END VOLTAGES, AS WELL AS VOLTAGE STEP SIZE HERE start_voltage = 0 end_voltage = 0.5 voltage_stepsize = 0.25 # ENTER FILE NAME HERE (experiment settings + voltage range, stepsize, actual time) #Here you can specify the filename of the map e.g. put experiment type, exposure time, used filters, etc.... experiment_settings = 'Test settings' #The program adds the range of the scan as well as the resolution and the date and time of the measurement experiment_name = experiment_settings + f"{start_voltage}V_to_{end_voltage}V_{voltage_stepsize}V_{datetime.datetime.now().strftime('%Y_%m_%d_%H%M')}" # ENTER FOLDER NAME HERE, TO WHICH THE EXP. DATA IS TO BE STORED IN # NOTE: This folder name is in the path 'C:/Users/localadmin/Desktop/Users/Dasha/' # suited for Dasha's uses experiment_folder_name = 'Test_folder' try: # initialise KLC connection # Find devices devs = klcListDevices() print("Found devices:",devs,"\n") if(len(devs)<=0): print('There is no device connected') sys.exit() klc = devs[0] # devs is a list of 2-element lists, in which the serial-nr. and device name are contained serialnumber = klc[0] # Connect device KLC_handle = klcOpen(serialnumber, 115200, 3) # serial-nr., baud rate and timeout(in s) if(KLC_handle<0): print("open ", serialnumber, " failed") sys.exit() if(klcIsOpen(serialnumber) == 0): print("klcIsOpen failed") klcClose(KLC_handle) sys.exit() print("Connected to serial number ", serialnumber) # Enable global output # TODO: idk why disable output then only enable, maybe remove later on klcSetEnable(KLC_handle,1) # 1 enable, 2 disable print("Enable output\n") if(klcSetEnable(KLC_handle, 1)<0): # 1 enable, 2 disable print("klcSetEnable failed") en=[0] if(klcGetEnable(KLC_handle, en)<0): # check if the set enable fucntion was called successfully print("klcGetEnable failed") auto = Automation(True, List[String]()) experiment = auto.LightFieldApplication.Experiment acquireCompleted = AutoResetEvent(False) experiment.Load("Alison_08.07.24") # NOTE: this should be the experiment.ExperimentCompleted += experiment_completed # we are hooking a listener. # experiment.SetValue(SpectrometerSettings.GratingSelected, '[750nm,1200][0][0]') # InitializerFilenameParams() # TODO: find out what these two lines of code do, leave commented as of (31.10.2024) LCR_scan_func(handle=KLC_handle, init_voltage=start_voltage, final_voltage=end_voltage, res=voltage_stepsize, base_file_name=experiment_name, folder_name=experiment_folder_name, reversescan_bool=False, zerowhenfin_bool=True, loopscan_bool=False) except Exception() as e: print(e) finally: #close connection to device klcClose(KLC_handle) print("Connection closed")