break
#Calculate the new write values from the step being taken
WF6H_Write_Value = WF6H_Start + (Delta_6/read_steps)*i
WF7H_Write_Value = WF7H_Start - (Delta_7/read_steps)*i
#Append the new write value to the Window Frame lists
WF6H_list.append(WF6H_Write_Value)
WF7H_list.append(WF7H_Write_Value)
#Update a temporary value to be used when walking the loop back
WF6H_max = WF6H_Write_Value
WF7H_max = WF7H_Write_Value
#Write to the PLC
M.Write(Client, WF6H_Tag, WF6H_Write_Value)
M.Write(Client, WF7H_Tag, WF7H_Write_Value)
#Taking the value of the current collected and averaging, the list is temporary because it is updated each run
collection = (M.Read(Client, Target_Tag, Average = True, count = 20,sleep_time = .010) + M.Read(Client, Target_Tag_2, Average = True, count = 20,sleep_time = .010))
collected_list_H.append(collection) #Storing the values in the collection list
i_max = i #storing the maximum i value to be used to walk the loop back
#This is to start the walk backward from the max horizontal value reached
# where we are checking to see that we
# 1: haven't fallen below our threshold colletion and
# 2: Haven't reached our maximum walking value
# When either of these conditions are satisfied, we start our walk in the other direction
if abs(collection) < abs(Start_Current) * Threshold_Percent/100 or i == read_steps:
for index in range(Num_sawtooths_1): #First loop with V0_1 and V0_2
#Taking the plateau data
runtime = time.time()
if index:
while time.time() - runtime < sleep_time:
Full_Data_Set.append(M.Gather(Client, Tag_List))
#Start setting the sleep time if on the first pass in this loop
if not index:
start_time = time.time()
#Ramp one way in V0 while collecting data
for value in V0_List_1:
M.Write(Client, Tags.V0_SP, value)
Full_Data_Set.append(M.Gather(Client, Tag_List))
#Finish setting the sleep time to what it took to ramp one way
if not index:
sleep_time = (time.time() - start_time) / 3
print(sleep_time * 3)
#Taking the trough data
runtime = time.time()
while time.time() - runtime < sleep_time:
Full_Data_Set.append(M.Gather(Client, Tag_List))
#Reverse! Reverse!
for value in V0_List_1[::-1]:
M.Write(Client, Tags.V0_SP, value)
Full_Data_Set.append(M.Gather(Client, Tag_List))
#Comparing the current value to the last write value, if it is different, this updates the break loop for both Horizontal and Vertical
if abs(temp_check_12 - WF12H_Write_Value) >= 0.001: #WF12H Check
H_Broken = True #Update the value of our loop breaker if there was human intervention so that further loops and this one don't run
V_Broken = True
print("Loop Broken")
break
if abs(temp_check_13 - WF13H_Write_Value) >= 0.001: #WF13H Check
H_Broken = True
V_Broken = True
print("Loop Broken")
break
WF12H_Write_Value = WF12H_Start + (Delta_12/Read_Steps)*Right_Steps #Calculate the written value for each window frame
WF13H_Write_Value = WF13H_Start - (Delta_13/Read_Steps)*Right_Steps
M.Write(Client, WF12H_Tag, WF12H_Write_Value) #Write the calculated value to each window frame
M.Write(Client, WF13H_Tag, WF13H_Write_Value)
RFBM_Collection = M.Read(Client, Target_Tag, Average = True, count = count, sleep_time = sleep) #Read the Target tag count times and average
Full_Data_Set.append([M.Read(Client, WF12H_Tag), M.Read(Client, WF13H_Tag), M.Read(Client, WF12V_Tag), M.Read(Client, WF13V_Tag), RFBM_Collection]) #Append all data to the current list
if dBm_to_Watts(RFBM_Collection)/dBm_to_Watts(Start_Power) < Threshold_Percent*0.01: #Check to see that we are above our Threshold
break
#############################
### Back to Center
#############################
#This function will walk us back to the start positions without taking data
M.Ramp_Two(Client, WF12H_Tag, WF13H_Tag, Magnet_1_Stop = WF12H_Start, Magnet_2_Stop = WF13H_Start, Resolution = Right_Steps)
IP = '192.168.1.2'
Client = M.Make_Client(IP)
WFH_Start = M.Read(Client, WFH_Tag)
WFV_Start = M.Read(Client, WFV_Tag)
######
#Walking us to our starting point
######
for i in range(1, Grid_Resolution + 1):
WFH_Write_Value = WFH_Start - i/2 * (Horizontal_Delta/Grid_Resolution)
WFV_Write_Value = WFV_Start + i/2 * (Vertical_Delta/Grid_Resolution)
M.Write(Client, WFH_Tag, WFH_Write_Value)
M.Write(Client, WFV_Tag, WFV_Write_Value)
WFH_Corner = M.Read(Client, WFH_Tag)
WFV_Corner = M.Read(Client, WFV_Tag)
#Total_Data = M.Rapid_T_Scan(Client, WFH_Tag, WFV_Tag, Read_Tag, Horizontal_Delta, Vertical_Delta, Resolution)
for i in range(Grid_Resolution_Vertical):
WFV_Write_Value = WFV_Corner - i * (Vertical_Delta/Grid_Resolution_Vertical)
M.write(Client,WFV_Tag,WFV_Write_Value)
if i == 0:
Step_size = 30 #(Hz) Change in frequency with each regulation step Pulse_Step_Size = 20 #(Hz) Change in frequency with each regulation step when pulsing Max_Threshold = 100000000 #(Hz) Total amount of frequency change before automatically tripping off program ## 1e8 is effectively deactivating this interlock Walk_Threshold = 0.5 #(mV) Deviation from 0 the error signal needs to be before CW regulation kicks in Pulse_Walk_Threshold = 0.5 #(mV) Deviation from 0 the error signal needs before pulsing regulation kicks in Wait_after_step = 0.0400 #Seconds, the time waited after a step is taken, necessary to allow oscope measurements to change Wait_between_reads = 0.0100 #Seconds, currently not used, supplemented by GUI time between reads Interlock_Threshold_mv = 40 #mv, this is the amount of deviation before regulation trips off Loops_Debounce = 1 Trip_Debounce = 6 Long = False #The form that our measurement is output from the o-scope, depending on the way it is set up this can be in either a short or long form ## additional tweak in testing 200417 Error_signal_offset = 0 # (mV) want to pulse off zero M.Write(Client, Regulation_Entry_Tag, Error_signal_offset) reset_on_start = False #This tag is in case we want to reset the entire oscilloscope on startup GPIB.measurement_setup(OS,IF_Channel, measurement = Measurement) #Setting up the required measurement for regulation # These reset the oscilloscope on startup, only the one above is needed. #GPIB.channel_settings_check(OS, IF_Channel) #Setting up the vertical and horizontal settings for the error signal #GPIB.trigger_settings_set(OS, Trigger_Channel, Trigger_Level) #Sets up the vertical settings for trigger channel and trigger parameters #GPIB.vertical_marker_pulsing(OS, IF_Channel) #Sets up vertical cursor bars to read edge of pulse Ups = 0 #number of steps taken up before taking one down Downs = 0 #visa versa i = 0 #total number of iterative loops gone through, only present to show differences in command line readouts ups_debounce_counter = 0 downs_debounce_counter = 0
#Comparing the current value to the last write value, if it is different, this updates the break loop for both Horizontal and Vertical
if abs(temp_check_6 - WF6H_Write_Value) >= 0.001: #WF6H Check
H_Broken = True
V_Broken = True
print("Loop Broken")
break
if abs(temp_check_7 - WF7H_Write_Value) >= 0.001: #WF7H Check
H_Broken = True
V_Broken = True
print("Loop Broken")
break
WF6H_Write_Value = WF6H_Start + (Delta_6/Read_Steps)*Right_Steps #Calculated value to walk 6 to the right
WF7H_Write_Value = WF7H_Start - (Delta_7/Read_Steps)*Right_Steps #Calculated value to walk 7 to the left
M.Write(Client, WF6H_Tag, WF6H_Write_Value) #Writing to 6h
M.Write(Client, WF7H_Tag, WF7H_Write_Value) #Writing to 7h
Target_1_Collection = M.Read(Client, Target_Tag, Average = True, count = count, sleep_time = sleep) #Averaging the collection at these points for each dump
Target_2_Collection = M.Read(Client, Target_Tag_2, Average = True, count = count, sleep_time = sleep)
Full_Data_Set.append([M.Read(Client, WF6H_Tag), M.Read(Client, WF7H_Tag), M.Read(Client, WF6V_Tag), M.Read(Client, WF7V_Tag), Target_1_Collection, Target_2_Collection, M.Read(Client, EC_Tag)]) #Adding all the data from this point to the array
if abs(Target_1_Collection + Target_2_Collection) < abs(Threshold_Percent*Start_Current*.01): #Checking our threshold
break
#############################
### Back to Center
#############################
print("Moving to center")
import Master as M
import time
import Tag_Database as Tags
import matplotlib.pyplot as plt
Client = M.Make_Client('10.50.0.10')
times = list()
for _ in range(1000):
start_time = time.time()
Tag1 = M.Read(Client, Tags.WF1H)
M.Write(Client, Tags.WF1H, 0)
times.append(1000 * (time.time() - start_time))
plt.hist(times)
plt.xlabel('time (ms)')
plt.ylabel('counts')
plt.show()
def Toggle(Client, Tag_Number):
M.Write(Client, Tag_Number, (M.Read(Client, Tag_Number) == False))
return
def Writes(Client, Tags, Values):
for Tag, Value in Tags, Values:
M.Write(Client, Tag, Value)
append_to_file(filename,
"{:.1f} ms".format(1000 * (time.time() - start_time)))
except:
print("Write to Excel failed")
filename = '{}/Amp_data_{}.csv'.format(
datadir,
datetime.today().strftime('%y%m%d_%H%M'))
# M.Write_Multiple(Client, Tag_List[0], Values) #Writing all of the values to the PLC
# Writes(Client, [],[])
try:
for Value_Index, Mod in zip(LOI, Modbus):
print(Mod, Values[Value_Index - 1])
M.Write(Client, Mod, Values[Value_Index - 1])
pass
except:
print("Write to PLC failed...")
print("Waiting...")
time.sleep(Sleep_Check_Time / 10)
try: #Try again with fresh connection
#M.Make_Client(PLC_IP)
#M.Write_Multiple(Client, Tag_List[0], Values)
pass
except:
print("Write to PLC failed after {:.2f} second wait".format(
Sleep_Check_Time / 10))
#Taking the plateau data
runtime = time.time()
if index:
while time.time() - runtime < sleep_time:
Full_Data_Set.append(M.Gather(Client, Tag_List, \
initial_values = [\
time.time(), \
value]))
#Start setting the sleep time if on the first pass in this loop
start_time = time.time()
#Ramp one way in V0 while collecting data
for value in V0_List_1:
M.Write(Client, Tags.V0_SP, value)
Full_Data_Set.append(M.Gather(Client, Tag_List, \
initial_values = [\
time.time(), \
value]))
#Finish setting the sleep time to what it took to ramp one way
print(time.time() - start_time)
#Taking the trough data
runtime = time.time()
while time.time() - runtime < sleep_time:
Full_Data_Set.append(M.Gather(Client, Tag_List, \
initial_values = [\
time.time(), \
value]))
