forked from zietzm/Helmholtz_Test_Bench
1386 lines
76 KiB
Python
1386 lines
76 KiB
Python
# This file contains classes to build all elements of the graphical user interface.
|
|
# These classes also contain the methods that are executed when UI elements are activated.
|
|
|
|
# ToDo: optimize layout for smaller screen (like on IRS clean room PC)
|
|
# import packages for user interface:
|
|
import queue
|
|
from queue import Queue, Empty
|
|
from tkinter import *
|
|
from tkinter import ttk
|
|
from tkinter import messagebox
|
|
from tkinter import filedialog
|
|
from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
|
|
|
|
# import general packages:
|
|
import numpy as np
|
|
import os
|
|
from os.path import exists
|
|
import threading
|
|
from datetime import datetime
|
|
|
|
# import other project files:
|
|
import src.globals as g
|
|
import src.csv_threading as csv
|
|
import src.config_handling as config
|
|
import src.csv_logging as log
|
|
from src.calibration import AmbientFieldCalibration
|
|
from src.exceptions import DeviceAccessError
|
|
from src.utility import ui_print
|
|
import src.helmholtz_cage_device as helmholtz_cage_device
|
|
|
|
# define font styles:
|
|
HEADER_FONT = ("Arial", 13, "bold")
|
|
SUB_HEADER_FONT = ("Arial", 9, "bold")
|
|
BIG_BUTTON_FONT = ("Arial", 11, "bold")
|
|
SMALL_BUTTON_FONT = ("Arial", 9)
|
|
|
|
|
|
class HelmholtzGUI(Tk):
|
|
# main application window, almost everything else here is called from this class
|
|
# Inherited base class: Tk(), main application window class
|
|
def __init__(self):
|
|
Tk.__init__(self)
|
|
|
|
Tk.wm_title(self, "Helmholtz Cage Control") # set title of the window
|
|
try:
|
|
Tk.wm_iconbitmap(self, "Helmholtz.ico") # set application icon
|
|
except TclError:
|
|
pass
|
|
|
|
self.Menu = TopMenu(self) # display dropdown menu bar at the top (see TopMenu class for details)
|
|
|
|
main_area = Frame(self, padx=10, pady=10) # create main area Frame where controls of each mode are displayed
|
|
main_area.pack(side="top", fill="both", expand=True) # pack main area at the top of the window
|
|
|
|
main_area.grid_rowconfigure(0, weight=1) # configure rows and columns of the Tkinter grid to expand with window
|
|
main_area.grid_columnconfigure(0, weight=1)
|
|
|
|
# initialize the GUI pages for the different modes and setup switching between them
|
|
# see https://pythonprogramming.net/change-show-new-frame-tkinter/ for explanation
|
|
# switching between pages is done with show_frame() method
|
|
|
|
self.pages = {} # dictionary for storing all pages (different modes, displayed in main area)
|
|
for P in [ManualMode,
|
|
HardwareConfiguration,
|
|
CalibrateAmbientField,
|
|
ExecuteCSVMode,
|
|
ConfigureLogging]: # do this for every mode page
|
|
page = P(main_area, self) # initialize the page with the main_area frame as the parent
|
|
self.pages[P] = page # add the page to the dictionary
|
|
page.grid(row=0, column=0, sticky="nsew") # place all pages in the same place in the GUI
|
|
|
|
# setup status display and output console
|
|
status_frame = Frame(self) # create frame to house them
|
|
status_frame.pack(side="bottom", fill="x", expand=False) # place at bottom of main window, expand to full width
|
|
status_frame.grid_columnconfigure(1, weight=1) # make column 1, (output console), expand to fill full width
|
|
|
|
# initialize and place status display:
|
|
self.StatusDisplay = StatusDisplay(status_frame, self)
|
|
self.StatusDisplay.grid(row=0, column=0, sticky="nesw")
|
|
|
|
# initialize and place output console:
|
|
self.OutputConsole = OutputConsole(status_frame)
|
|
self.OutputConsole.grid(row=0, column=1, sticky="nesw")
|
|
|
|
self.show_frame(ManualMode) # show manual mode to start with
|
|
|
|
def show_frame(self, key): # method to switch between pages in the main area
|
|
frame = self.pages[key] # get correct page from the dictionary
|
|
frame.page_switch() # update displays in this page with window-specific update function
|
|
frame.tkraise() # bring this frame to the front
|
|
|
|
|
|
class TopMenu:
|
|
# the menu bar at the top of the window
|
|
def __init__(self, window):
|
|
self.window = window
|
|
menu = Menu(window) # initialize Menu object
|
|
window.config(menu=menu) # put menu at the top of the window
|
|
|
|
mode_selector = Menu(menu) # create a submenu object
|
|
menu.add_cascade(label="Menu", menu=mode_selector) # add a dropdown with the submenu object
|
|
# create the different options in the dropdown:
|
|
mode_selector.add_command(label="Static Manual Input", command=self.manual_mode)
|
|
mode_selector.add_command(label="Execute CSV Sequence", command=self.execute_csv_mode)
|
|
mode_selector.add_command(label="Calibrate Ambient Field", command=self.calibrate_ambient)
|
|
mode_selector.add_separator()
|
|
mode_selector.add_command(label="Configure Data Logging", command=self.logging)
|
|
mode_selector.add_command(label="Settings...", command=self.configuration)
|
|
|
|
def manual_mode(self): # switch to the manual mode page
|
|
self.window.show_frame(ManualMode)
|
|
|
|
def configuration(self): # switch to the settings page
|
|
self.window.show_frame(HardwareConfiguration)
|
|
|
|
def calibrate_ambient(self):
|
|
self.window.show_frame(CalibrateAmbientField)
|
|
|
|
def execute_csv_mode(self): # switch to the CSV execution page
|
|
self.window.show_frame(ExecuteCSVMode)
|
|
|
|
def logging(self): # switch to the logging settings page
|
|
self.window.show_frame(ConfigureLogging)
|
|
|
|
|
|
class ManualMode(Frame):
|
|
# Mode for manually setting currents and fields on the test bench.
|
|
# Inherits the Frame object from Tkinter and is placed in the mainArea of the application window.
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent) # initialize the frame object
|
|
|
|
self.controller = controller # object on which mainloop() is running, usually main window
|
|
|
|
self.grid_rowconfigure(ALL, weight=1) # configure rows and columns of the Tkinter grid to expand with window
|
|
self.grid_columnconfigure(ALL, weight=1)
|
|
|
|
row_counter = 0 # keep track of which row in the main grid we are in
|
|
|
|
# setup title text
|
|
header = Label(self, text="Manual Input Mode", font=HEADER_FONT, pady=3)
|
|
header.grid(row=row_counter, column=0)
|
|
|
|
row_counter += 1
|
|
|
|
# Setup Dropdown Menu for input mode
|
|
dropdown_frame = Frame(self) # create frame to house dropdown
|
|
dropdown_frame.grid_rowconfigure(ALL, weight=1)
|
|
dropdown_frame.grid_columnconfigure(ALL, weight=1)
|
|
dropdown_frame.grid(row=row_counter, column=0) # place frame on the page
|
|
|
|
self.input_mode = StringVar() # variable that is changed by the dropdown selection
|
|
# make dictionary with information on all modes.
|
|
# content: [function to call on button press, unit text to be displayed, function to call on dropdown change]
|
|
self.modes = {"Magnetic Field": [self.execute_field, "\u03BCT", self.switch_to_field_mode],
|
|
"Current": [self.execute_current, "A", self.switch_to_current_mode]}
|
|
self.unit = StringVar() # variable to store the unit of the current mode, used to update a label with the unit
|
|
default_mode = list(self.modes.keys())[0] # setup which mode to show at the beginning
|
|
|
|
# create the dropdown. parameters: (frame to place it in, variable changed, starting selection, all options)
|
|
input_mode_selector = ttk.OptionMenu(dropdown_frame, self.input_mode, default_mode, *self.modes.keys())
|
|
|
|
input_mode_selector.grid(row=0, column=1, sticky=W) # place dropdown on the grid
|
|
dropdown_frame.grid_columnconfigure(1, minsize=115) # set size of column with dropdown to keep it from moving
|
|
# Add a description before the dropdown:
|
|
selector_label = Label(dropdown_frame, text="Select Input Mode:", padx=10, pady=10)
|
|
selector_label.grid(row=0, column=0)
|
|
|
|
row_counter = row_counter + 1
|
|
|
|
# Setup Entry fields for field/current values
|
|
# create and configure frame to house fields:
|
|
self.entries_frame = Frame(self)
|
|
self.entries_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.entries_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.entries_frame.grid_columnconfigure(2, weight=1, minsize=20) # set column width so it doesn't move around
|
|
self.entries_frame.grid_columnconfigure(3, weight=1, minsize=110)
|
|
self.entries_frame.grid(row=row_counter, column=0)
|
|
|
|
entry_texts = ["X-Axis:", "Y-Axis:", "Z-Axis:"] # row labels
|
|
self.entry_vars = [DoubleVar() for _ in range(3)] # variables that are changed by entries into the fields
|
|
self.max_value_vars = [StringVar() for _ in range(3)] # variables for labels showing the min/max values
|
|
|
|
# Build up the entry field table:
|
|
row = 0
|
|
for text in entry_texts: # go through x,y,z axis rows
|
|
field = ttk.Entry(self.entries_frame, textvariable=self.entry_vars[row]) # create entry field
|
|
self.entry_vars[row].set(0) # set its value to 0 to start
|
|
field.grid(row=row, column=1, sticky=W)
|
|
axis_label = Label(self.entries_frame, text=text, padx=5, pady=10) # create label showing the axis
|
|
axis_label.grid(row=row, column=0, sticky=W)
|
|
unit_label = Label(self.entries_frame, textvariable=self.unit) # create updatable label showing the unit
|
|
unit_label.grid(row=row, column=2, sticky=W)
|
|
# create updatable label showing the min/max achievable values:
|
|
max_value_label = Label(self.entries_frame, textvariable=self.max_value_vars[row])
|
|
max_value_label.grid(row=row, column=3, sticky=W)
|
|
row = row + 1
|
|
|
|
row_counter += 1
|
|
|
|
# setup checkbox for compensating ambient field
|
|
checkbox_frame = Frame(self, padx=20) # create frame to house it
|
|
checkbox_frame.grid(row=row_counter, column=0, sticky=W)
|
|
|
|
self.compensate = BooleanVar(value=True) # create variable to be changed by the checkbox
|
|
# create checkbox:
|
|
self.compensate_checkbox = Checkbutton(checkbox_frame, text="Compensate ambient field",
|
|
variable=self.compensate, onvalue=True, offvalue=False)
|
|
self.compensate_checkbox.pack(side="left")
|
|
|
|
row_counter += 1
|
|
|
|
# Setup buttons
|
|
self.buttons_frame = Frame(self)
|
|
self.buttons_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.buttons_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.buttons_frame.grid(row=row_counter, column=0)
|
|
|
|
Label(self.buttons_frame, text="").grid(row=0, column=0) # add spacer
|
|
|
|
# add button for executing the current entries
|
|
execute_button = Button(self.buttons_frame, text="Execute", command=self.execute,
|
|
pady=5, padx=5, font=BIG_BUTTON_FONT)
|
|
execute_button.grid(row=row_counter, column=0, padx=5)
|
|
|
|
# add button for quick power_down
|
|
power_down_button = Button(self.buttons_frame, text="Power Down All", command=self.power_down,
|
|
pady=5, padx=5, font=BIG_BUTTON_FONT)
|
|
power_down_button.grid(row=row_counter, column=1, padx=5)
|
|
|
|
# add button for reinitialization of devices
|
|
reinit_button = Button(self.buttons_frame, text="Reinitialize", command=self.reinitialize,
|
|
pady=5, padx=5, font=BIG_BUTTON_FONT)
|
|
reinit_button.grid(row=row_counter, column=2, padx=5)
|
|
|
|
row_counter = row_counter + 1
|
|
|
|
Label(self, text="", pady=10).grid(row=row_counter, column=0) # add spacer
|
|
|
|
self.input_mode.trace_add('write', self.change_mode_callback) # call mode change function on dropdown change
|
|
self.input_mode.set(default_mode) # call up default mode at the start
|
|
self.compensate.trace_add('write', self.change_mode_callback) # call mode change function on checkbox change
|
|
|
|
def page_switch(self): # function that is called when switching to this page in the UI
|
|
self.modes[self.input_mode.get()][2]() # update max values and units, e.g. calls update_max_fields function
|
|
|
|
# noinspection PyUnusedLocal
|
|
# not sure what the parameters are for, but it doesn't work without them
|
|
def change_mode_callback(self, var, index, mode): # called whenever input mode dropdown or checkbox is changed
|
|
self.unit.set(self.modes[self.input_mode.get()][1]) # change unit text
|
|
self.modes[self.input_mode.get()][2]() # update max values, e.g. calls update_max_fields function
|
|
|
|
def switch_to_field_mode(self): # called when switching to magnetic field entry mode
|
|
self.compensate_checkbox.config(state=NORMAL) # enable the compensate ambient field checkbox
|
|
|
|
# update the labels showing the min/max achievable values
|
|
compensate = self.compensate.get() # read out if compensate field checkbox is checked (True or False)
|
|
for i, var in enumerate(self.max_value_vars): # go through the max value labels for each axis
|
|
if not compensate: # ambient field should not be compensated
|
|
field = g.CAGE_DEVICE.axes[i].max_field * 1e6 # get max values from the axis object
|
|
elif compensate: # ambient field should be compensated
|
|
field = g.CAGE_DEVICE.axes[i].max_comp_field * 1e6
|
|
else: # this really should never happen
|
|
field = [0, 0]
|
|
ui_print("Unexpected value encountered: compensate =", compensate)
|
|
messagebox.showerror("Unexpected Value!", ("Unexpected value encountered: compensate =", compensate))
|
|
var.set("(%0.1f to %0.1f \u03BCT)" % (field[0], field[1])) # update the label text with the new values
|
|
|
|
def switch_to_current_mode(self): # called when switching to the input current mode
|
|
self.compensate_checkbox.config(state=DISABLED) # disable the compensate ambient field checkbox
|
|
|
|
# update the labels showing the min/max achievable values
|
|
for i, var in enumerate(self.max_value_vars): # go through the max value labels for each axis
|
|
# update the label
|
|
var.set("(%0.2f to %0.2f A)" % (-g.CAGE_DEVICE.axes[i].max_amps, g.CAGE_DEVICE.axes[i].max_amps))
|
|
|
|
def reinitialize(self): # called on "Reinitialize!" button press
|
|
# reinitialize all PSUs and the Arduino
|
|
g.CAGE_DEVICE.reconnect_hardware()
|
|
|
|
# log change to the log file if user has selected event logging in the Configure Logging window
|
|
logger = self.controller.pages[ConfigureLogging] # get object of logging configurator
|
|
if logger.event_logging: # data should be logged when test bench is commanded
|
|
logger.log_datapoint() # log data
|
|
|
|
def power_down(self): # called on "power down" button press
|
|
g.CAGE_DEVICE.shutdown() # power down outputs on all PSUs and the Arduino
|
|
|
|
# log change to the log file if user has selected event logging in the Configure Logging window
|
|
logger = self.controller.pages[ConfigureLogging] # get object of logging configurator
|
|
if logger.event_logging: # data should be logged when test bench is commanded
|
|
logger.log_datapoint() # log data
|
|
|
|
def execute(self): # called on "Execute!" button press
|
|
# reads values from the entry fields and commands the test bench accordingly
|
|
|
|
vector = np.array([0, 0, 0], dtype=float) # initialize vector to later send to test bench
|
|
i = 0
|
|
try: # try to read values from the entry fields
|
|
for var in self.entry_vars:
|
|
vector[i] = var.get() # write read out value to correct position in the vector
|
|
i += 1
|
|
except TclError as e: # user did not enter correct format somewhere
|
|
messagebox.showwarning("Invalid Entry", "Invalid entry:\n%s" % e) # show warning message
|
|
else: # no issues while reading entries (user entered correct format)
|
|
function_to_call = self.modes[self.input_mode.get()][0] # get function of appropriate mode
|
|
function_to_call(vector) # call function (self.execute_field() or self.execute_current())
|
|
|
|
# log change to the log file if user has selected event logging in the Configure Logging window
|
|
logger = self.controller.pages[ConfigureLogging] # get object of logging configurator
|
|
if logger.event_logging: # data should be logged when test bench is commanded
|
|
logger.log_datapoint() # log data
|
|
|
|
def execute_field(self, vector): # convert magnetic field vector and send to test bench
|
|
ui_print("\nField executing:", vector, "\u03BCT")
|
|
# Acquire a proxy to the helmholtz cage:
|
|
# This can fail if already in use
|
|
try:
|
|
with g.CAGE_DEVICE as cage_dev:
|
|
compensate = self.compensate.get() # read out if compensate ambient field checkbox is ticked
|
|
if compensate: # ambient field should be compensated
|
|
cage_dev.set_field_compensated(vector * 1e-6) # convert to Tesla and send to test bench
|
|
pass
|
|
elif not compensate: # ambient field should not be compensated
|
|
cage_dev.set_field_raw(vector * 1e-6) # convert to Tesla and send to test bench
|
|
pass
|
|
else: # this really should never happen
|
|
ui_print("Unexpected value encountered: compensate =", compensate)
|
|
messagebox.showerror("Unexpected Value!", ("Unexpected value encountered: compensate =", compensate))
|
|
except helmholtz_cage_device.DeviceBusy:
|
|
ui_print("Error: Could not acquire control. Is the HW already in use?")
|
|
|
|
@staticmethod
|
|
def execute_current(vector): # send current vector to the test bench
|
|
ui_print("\nCurrent executing:", vector, "A")
|
|
with g.CAGE_DEVICE as cage_dev:
|
|
# This can fail if already in use
|
|
if cage_dev is None:
|
|
ui_print("Error: Could not acquire control. Is the HW already in use?")
|
|
return
|
|
|
|
cage_dev.set_signed_currents(vector) # command test bench
|
|
|
|
|
|
class ExecuteCSVMode(Frame):
|
|
# Mode for executing magnetic field sequences from csv files.
|
|
# Inherits the Frame object from Tkinter and is placed in the mainArea of the application window.
|
|
# Multithreading is used to execute the sequence without crashing the UI
|
|
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent)
|
|
self.parent = parent # parent UI object, e.g. the mainArea frame
|
|
self.controller = controller # object on which mainloop() is running, usually main window
|
|
|
|
# Functional init:
|
|
self.csv_thread = None # the thread object for executing a csv sequence
|
|
self.sequence_array = None # array containing the values from the csv file
|
|
|
|
# Build UI:
|
|
self.grid_rowconfigure(ALL, weight=1) # configure rows and columns of the Tkinter grid to expand with window
|
|
self.grid_columnconfigure(ALL, weight=1)
|
|
|
|
row_counter = 0 # keep track of which grid row we are in
|
|
|
|
self.row_elements = [] # make list of elements in rows to later calculate height available for plot
|
|
|
|
# setup headline
|
|
header = Label(self, text="Execute CSV Mode", font=HEADER_FONT, pady=3)
|
|
header.grid(row=row_counter, column=0, padx=100, sticky=W)
|
|
self.row_elements.append(header) # add to list of row elements
|
|
|
|
row_counter += 1
|
|
|
|
# Setup buttons
|
|
# Setup frame to house buttons:
|
|
self.top_buttons_frame = Frame(self)
|
|
self.top_buttons_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.top_buttons_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.top_buttons_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
self.row_elements.append(self.top_buttons_frame) # add frame to list of row elements
|
|
|
|
# Create and place buttons:
|
|
# add button for selecting a csv file to execute:
|
|
self.select_file_button = Button(self.top_buttons_frame, text="Select csv file...", command=self.load_csv,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
self.select_file_button.grid(row=0, column=0, padx=5)
|
|
# add button to start running the sequence from the file:
|
|
self.execute_button = Button(self.top_buttons_frame, text="Run Sequence", command=self.run_sequence,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT, state="disabled")
|
|
self.execute_button.grid(row=0, column=1, padx=5)
|
|
# add button to stop/interrupt the sequence:
|
|
self.stop_button = Button(self.top_buttons_frame, text="Stop Run", command=self.stop_run,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT, state="disabled")
|
|
self.stop_button.grid(row=0, column=2, padx=5)
|
|
# add button to reinitialize devices (e.g. after reconnecting a device)
|
|
self.reinit_button = Button(self.top_buttons_frame, text="Reinitialize Devices", command=self.reinitialize,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
self.reinit_button.grid(row=0, column=3, padx=5)
|
|
|
|
row_counter += 1
|
|
|
|
# setup checkboxes to disable checks if devices are connected (enables testing with some devices missing)
|
|
# setup frame to house checkboxes:
|
|
self.checkbox_frame = Frame(self)
|
|
self.checkbox_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.checkbox_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.checkbox_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
self.row_elements.append(self.checkbox_frame) # add frame to list of row elements
|
|
|
|
# setup label to explain checkbox function:
|
|
checkbox_label = Label(self.checkbox_frame, text="Disable device connection checks:")
|
|
checkbox_label.grid(row=0, column=0, sticky=W, padx=3)
|
|
|
|
# create variables for the checkboxes:
|
|
self.xy_override = BooleanVar(value=False) # True to disable connection check for XY PSU
|
|
self.z_override = BooleanVar(value=False) # True to disable connection check for Z PSU
|
|
self.arduino_override = BooleanVar(value=False) # True to disable connection check for arduino
|
|
# create checkboxes:
|
|
xy_checkbox = Checkbutton(self.checkbox_frame, text="XY PSU",
|
|
variable=self.xy_override, onvalue=True, offvalue=False)
|
|
xy_checkbox.grid(row=0, column=1, padx=3)
|
|
z_checkbox = Checkbutton(self.checkbox_frame, text="Z PSU",
|
|
variable=self.z_override, onvalue=True, offvalue=False)
|
|
z_checkbox.grid(row=0, column=2, padx=3)
|
|
arduino_checkbox = Checkbutton(self.checkbox_frame, text="Arduino",
|
|
variable=self.arduino_override, onvalue=True, offvalue=False)
|
|
arduino_checkbox.grid(row=0, column=3, padx=3)
|
|
|
|
row_counter += 1
|
|
|
|
# make frame for plot of csv values (plot is generated and placed in display_plot() method)
|
|
self.plotFrame = Frame(self)
|
|
self.plotFrame.grid_rowconfigure(0, weight=1)
|
|
self.plotFrame.grid_columnconfigure(0, weight=1)
|
|
self.plotFrame.grid(row=row_counter, column=0, sticky="nsw", padx=10, pady=10)
|
|
|
|
def page_switch(self): # function that is called when switching to this window
|
|
# every class in the UI needs this, even if it doesn't do anything
|
|
pass
|
|
|
|
def load_csv(self): # load in csv file to be executed
|
|
directory = os.path.abspath(os.getcwd()) # get project directory
|
|
# open file selection dialogue and store path of selected file
|
|
filename = filedialog.askopenfilename(initialdir=directory, title="Select CSV File",
|
|
filetypes=(("Comma Separated Values", "*.csv*"), ("All Files", "*.*")))
|
|
if exists(filename): # does the file exist?
|
|
ui_print("File selected:", filename)
|
|
try: # try to read data to an array
|
|
self.sequence_array = csv.read_csv_to_array(filename) # read array from csv
|
|
except BaseException as e: # something went wrong, probably wrong format in csv
|
|
# display error messages:
|
|
ui_print("Error while opening file:", e)
|
|
messagebox.showerror("Error!", "Error while opening file: \n%s" % e)
|
|
|
|
try: # try to check the values and display the plot
|
|
csv.check_array_ok(self.sequence_array) # check for values exceeding limits
|
|
self.display_plot() # plot data and display
|
|
except BaseException as e: # something went wrong, probably wrong format in csv
|
|
# display error messages:
|
|
ui_print("Error while processing data from file:", e)
|
|
messagebox.showerror("Error!", "Error while processing data from file: \n%s" % e)
|
|
else: # nothing went wrong
|
|
self.execute_button["state"] = "normal" # activate run button --> enable execution
|
|
elif filename == '': # this happens when file selection window is closed without selecting a file
|
|
ui_print("No file selected, could not load.")
|
|
else: # file does not exist
|
|
# display error messages:
|
|
ui_print("Selected file", filename, "does not exist, could not load.")
|
|
messagebox.showerror("File not found", "Selected file %s does not exist, could not load." % filename)
|
|
|
|
def run_sequence(self): # called on run button press, starts thread for executing the sequence
|
|
# (de)activate buttons as needed:
|
|
self.select_file_button["state"] = "disabled"
|
|
self.execute_button["state"] = "disabled"
|
|
self.stop_button["state"] = "normal"
|
|
self.reinit_button["state"] = "disabled"
|
|
|
|
# setup thread for running the sequence
|
|
# More info: https://www.tutorialspoint.com/python/python_multithreading.htm
|
|
g.threadLock = threading.Lock() # create thread locking object, used to ensure all devices switch at once later
|
|
# create thread object:
|
|
|
|
self.csv_thread = csv.ExecCSVThread(self.sequence_array, self, self.controller, logging_enabled)
|
|
self.csv_thread.start() # start thread
|
|
|
|
def stop_run(self): # called on stop button press, interrupts sequence execution
|
|
self.csv_thread.stop() # call stop method of thread object, this will cause the csv loop to end
|
|
# (de)activate buttons as needed:
|
|
self.select_file_button["state"] = "normal"
|
|
self.execute_button["state"] = "normal"
|
|
self.stop_button["state"] = "disabled"
|
|
self.reinit_button["state"] = "normal"
|
|
|
|
# log change to the log file if user has selected event logging in the Configure Logging window
|
|
logger = self.controller.pages[ConfigureLogging] # get object of logging configurator
|
|
if logger.event_logging: # data should be logged when test bench is commanded
|
|
logger.log_datapoint() # log data
|
|
|
|
def reinitialize(self): # called on "Reinitialize devices" button press
|
|
func.setup_all() # reinitialize all PSUs and the Arduino
|
|
|
|
# log change to the log file if user has selected event logging in the Configure Logging window
|
|
logger = self.controller.pages[ConfigureLogging] # get object of logging configurator
|
|
if logger.event_logging: # data should be logged when test bench is commanded
|
|
logger.log_datapoint() # log data
|
|
|
|
def display_plot(self): # generate and display a plot of the data loaded from a csv file
|
|
# calculate available height for plot (in pixels):
|
|
height_others = 0 # initialize variable to calculate height of other widgets
|
|
for element in self.row_elements: # go through all rows in the widget except the plot frame
|
|
height_others += element.winfo_height() # add up heights
|
|
# calculate available plot height:
|
|
height = self.parent.winfo_height() - height_others - 50 # height of parent frame - other widgets - margin
|
|
|
|
width = min(self.parent.winfo_width() - 100, 1100) # set width to available space but max. 1100
|
|
|
|
figure = csv.plot_field_sequence(self.sequence_array, width, height) # create figure to be displayed
|
|
plotCanvas = FigureCanvasTkAgg(figure, self.plotFrame) # create canvas to draw figure on
|
|
plotCanvas.draw() # equivalent to matplotlib.show()
|
|
plotCanvas.get_tk_widget().grid(row=0, column=0, sticky="nesw") # place canvas in the UI
|
|
|
|
|
|
class CalibrateAmbientField(Frame):
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent)
|
|
self.parent = parent
|
|
self.controller = controller
|
|
|
|
# To center window
|
|
# self.columnconfigure(0, weight=1)
|
|
self.rowconfigure(0, weight=1)
|
|
self.left_column = Frame(self)
|
|
self.left_column.grid(row=0, column=0, sticky="nsew")
|
|
self.right_column = Frame(self)
|
|
self.right_column.grid(row=0, column=1, sticky="nsew")
|
|
self.left_column.rowconfigure(3, weight=1)
|
|
|
|
# Thread variables
|
|
self.calibration_ambient_thread = None
|
|
self.calibration_coil_constants_thread = None
|
|
self.view_mpi_queue = Queue() # Receives status information from calibration procedure threads.
|
|
|
|
# UI variables
|
|
self.connected_state_var = StringVar(value="Not connected")
|
|
self.field_value_vars = [StringVar(value="No data"),
|
|
StringVar(value="No data"),
|
|
StringVar(value="No data")]
|
|
self.calibration_procedure_progress_var = IntVar(value=0)
|
|
self.ambient_field_result_vars = [StringVar(), StringVar(), StringVar()]
|
|
self.ambient_field_ut_result_vars = [StringVar(), StringVar(), StringVar()]
|
|
self.ambient_field_residual_vars = [StringVar(), StringVar(), StringVar()]
|
|
|
|
row_counter = 0
|
|
|
|
# Create headline
|
|
header = Label(self.left_column, text="Ambient Field Calibration", font=HEADER_FONT)
|
|
header.grid(row=row_counter, column=0, columnspan=2, padx=100, pady=20, sticky="nw")
|
|
row_counter += 1
|
|
|
|
# Magnetometer connected indicator
|
|
connected_status_frame = Frame(self.left_column)
|
|
connected_status_frame.grid(row=row_counter, column=0, sticky="nw")
|
|
connected_label = Label(connected_status_frame, text="Magnetometer state:", font=SUB_HEADER_FONT)
|
|
connected_label.grid(row=0, column=0, padx=10, pady=20, sticky="nw")
|
|
self.connected_state_label = Label(connected_status_frame, textvariable=self.connected_state_var, fg="red")
|
|
self.connected_state_label.grid(row=0, column=1, padx=10, pady=20, sticky="nw")
|
|
row_counter += 1
|
|
|
|
# Magnetometer field data grid
|
|
field_data_frame = Frame(self.left_column)
|
|
field_data_frame.grid(row=row_counter, column=0, sticky="nw")
|
|
field_data_label = Label(field_data_frame, text="Field data:", font=SUB_HEADER_FONT)
|
|
field_data_label.grid(row=0, column=0, padx=10, pady=3, sticky="nw")
|
|
axis_labels = ['X:', 'Y:', 'Z:']
|
|
for i in range(3):
|
|
field_data_axis_label = Label(field_data_frame, text=axis_labels[i])
|
|
field_data_axis_label.grid(row=i, column=1, padx=10, pady=3)
|
|
|
|
field_data_axis_data = Label(field_data_frame, textvariable=self.field_value_vars[i])
|
|
field_data_axis_data.grid(row=i, column=2, padx=(20, 0), pady=3)
|
|
|
|
field_data_axis_units = Label(field_data_frame, text="\u03BCT")
|
|
field_data_axis_units.grid(row=i, column=3, padx=5, pady=3)
|
|
row_counter += 1
|
|
|
|
# Calibration start buttons
|
|
start_button_frame = Frame(self.left_column)
|
|
start_button_frame.grid(row=row_counter, column=0, sticky="sw")
|
|
self.start_ambient_calibration_button = Button(start_button_frame, text="Calibrate Ambient Field",
|
|
command=self.calibration_procedure_ambient,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
self.start_ambient_calibration_button.grid(row=0, column=0, padx=10, pady=(30, 10))
|
|
self.start_k_calibration_button = Button(start_button_frame, text="Calibrate Coil Constants",
|
|
command=self.calibration_procedure_coil_constants,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
self.start_k_calibration_button.grid(row=0, column=1, padx=10, pady=(30, 10))
|
|
row_counter += 1
|
|
|
|
# Calibration progress bar
|
|
progress_bar_frame = Frame(self.left_column)
|
|
progress_bar_frame.grid(row=row_counter, column=0, sticky="swe")
|
|
calibration_procedure_progress_label = Label(progress_bar_frame, text="Progress:")
|
|
calibration_procedure_progress_label.grid(row=0, column=0, padx=10, pady=10)
|
|
calibration_procedure_progress = ttk.Progressbar(progress_bar_frame,
|
|
length=240,
|
|
variable=self.calibration_procedure_progress_var)
|
|
calibration_procedure_progress.grid(row=0, column=1, padx=10, pady=10, sticky="we")
|
|
row_counter += 1
|
|
|
|
# Ambient field calibration results
|
|
row_counter = 0
|
|
ambient_field_results_frame = LabelFrame(self.right_column, text="Ambient Field Results")
|
|
ambient_field_results_frame.grid(row=row_counter, column=1, padx=(100, 0), pady=20, sticky="nw")
|
|
for i, label in enumerate(['X', 'Y', 'Z']):
|
|
axis_label = Label(ambient_field_results_frame, text=label)
|
|
axis_label.grid(row=0, column=i+1, padx=5, pady=5, sticky="nw")
|
|
# Ambient field value (A)
|
|
ambient_field_results_label = Label(ambient_field_results_frame, text="Ambient Field:")
|
|
ambient_field_results_label.grid(row=1, column=0, padx=5, pady=5, sticky="nw")
|
|
for i in range(3):
|
|
axis_data = Entry(ambient_field_results_frame,
|
|
textvariable=self.ambient_field_result_vars[i],
|
|
width=15,
|
|
state='readonly')
|
|
axis_data.grid(row=1, column=i+1, padx=5, pady=5, sticky="nw")
|
|
ambient_field_results_unit = Label(ambient_field_results_frame, text="A")
|
|
ambient_field_results_unit.grid(row=1, column=4, padx=5, pady=5, sticky="nw")
|
|
# Ambient field value (microtesla)
|
|
ambient_field_results_ut_label = Label(ambient_field_results_frame, text="Ambient Field:")
|
|
ambient_field_results_ut_label.grid(row=2, column=0, padx=5, pady=5, sticky="nw")
|
|
for i in range(3):
|
|
axis_data = Entry(ambient_field_results_frame,
|
|
textvariable=self.ambient_field_ut_result_vars[i],
|
|
width=15,
|
|
state='readonly')
|
|
axis_data.grid(row=2, column=i + 1, padx=5, pady=5, sticky="nw")
|
|
ambient_field_results_ut_unit = Label(ambient_field_results_frame, text="\u03BCT")
|
|
ambient_field_results_ut_unit.grid(row=2, column=4, padx=5, pady=5, sticky="nw")
|
|
# Residuals
|
|
ambient_field_residual_label = Label(ambient_field_results_frame, text="Residual Field:")
|
|
ambient_field_residual_label.grid(row=3, column=0, padx=5, pady=5, sticky="nw")
|
|
for i in range(3):
|
|
axis_data = Entry(ambient_field_results_frame,
|
|
textvariable=self.ambient_field_residual_vars[i],
|
|
width=15,
|
|
state='readonly')
|
|
axis_data.grid(row=3, column=i+1, padx=5, pady=5, sticky="nw")
|
|
ambient_field_residual_unit = Label(ambient_field_results_frame, text="\u03BCT")
|
|
ambient_field_residual_unit.grid(row=3, column=4, padx=5, pady=5, sticky="nw")
|
|
|
|
# This starts an endless polling loop
|
|
self.update_view()
|
|
|
|
def page_switch(self):
|
|
# every class in the UI needs this, even if it doesn't do anything
|
|
pass
|
|
|
|
def update_view(self):
|
|
# Get new connected status
|
|
if g.MAGNETOMETER.connected:
|
|
self.connected_state_var.set("connected")
|
|
self.connected_state_label.configure(fg="green")
|
|
else:
|
|
self.connected_state_var.set("Not connected")
|
|
self.connected_state_label.configure(fg="red")
|
|
|
|
# Get new field data
|
|
new_field = g.MAGNETOMETER.field
|
|
for i in range(3):
|
|
# Display in uT
|
|
self.field_value_vars[i].set("{:.3f}".format(new_field[i] * 1e6))
|
|
|
|
# Get mpi messages from calibration procedures
|
|
try:
|
|
while True:
|
|
msg = self.view_mpi_queue.get(block=False)
|
|
cmd = msg['cmd']
|
|
arg = msg['arg']
|
|
if cmd == 'finished':
|
|
self.reactivate_buttons()
|
|
elif cmd == 'failed':
|
|
messagebox.showerror("Calibration error", "Error occured during calibration:\n{}".format(arg))
|
|
self.reactivate_buttons()
|
|
elif cmd == 'progress':
|
|
self.calibration_procedure_progress_var.set(min(int(arg*100), 100))
|
|
elif cmd == 'ambient_data':
|
|
self.update_ambient_calibration_results(arg)
|
|
else:
|
|
ui_print("Error: Unexpected mpi command '{}' in CalibrationTool".format(cmd))
|
|
except queue.Empty:
|
|
pass
|
|
|
|
self.controller.after(500, self.update_view)
|
|
|
|
def reactivate_buttons(self):
|
|
self.start_ambient_calibration_button.configure(text="Calibrate Ambient Field", state=NORMAL)
|
|
self.start_k_calibration_button.configure(text="Calibrate Coil Constants", state=NORMAL)
|
|
self.calibration_procedure_progress_var.set(0)
|
|
|
|
def deactivate_buttons(self):
|
|
self.start_ambient_calibration_button.configure(state=DISABLED)
|
|
self.start_k_calibration_button.configure(state=DISABLED)
|
|
|
|
def update_ambient_calibration_results(self, results):
|
|
for i in range(3):
|
|
self.ambient_field_result_vars[i].set("{:.3f}".format(results['ambient'][i]))
|
|
self.ambient_field_ut_result_vars[i].set("{:.3f}".format(results['ambient_ut'][i]))
|
|
self.ambient_field_residual_vars[i].set("{:.3f}".format(results['residual'][i] * 1e6))
|
|
|
|
def calibration_procedure_ambient(self):
|
|
try:
|
|
self.calibration_ambient_thread = AmbientFieldCalibration(self.view_mpi_queue)
|
|
self.calibration_ambient_thread.start()
|
|
self.start_ambient_calibration_button.configure(text="Running")
|
|
self.deactivate_buttons()
|
|
except DeviceAccessError as e:
|
|
print("Error starting calibration procedure: {}".format(e))
|
|
|
|
def calibration_procedure_coil_constants(self):
|
|
try:
|
|
self.calibration_coil_constants_thread = AmbientFieldCalibration(self.view_mpi_queue)
|
|
self.calibration_coil_constants_thread.start()
|
|
self.start_k_calibration_button.configure(text="Running")
|
|
self.deactivate_buttons()
|
|
except DeviceAccessError as e:
|
|
print("Error starting calibration procedure: {}".format(e))
|
|
|
|
|
|
class HardwareConfiguration(Frame):
|
|
"""Settings window to set program constants"""
|
|
|
|
# noinspection PyUnusedLocal
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent)
|
|
|
|
self.grid_rowconfigure(ALL, weight=1)
|
|
self.grid_columnconfigure(ALL, weight=1)
|
|
|
|
row_counter = 0
|
|
|
|
# create headline:
|
|
header = Label(self, text="Configuration Window", font=HEADER_FONT, pady=3)
|
|
header.grid(row=row_counter, column=0, padx=100, sticky=W)
|
|
|
|
row_counter += 1
|
|
|
|
# Setup buttons to select config file
|
|
# Setup frame to house buttons:
|
|
self.file_select_frame = Frame(self)
|
|
self.file_select_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.file_select_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.file_select_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
# Create and place buttons
|
|
# button to load a config file:
|
|
load_file_button = Button(self.file_select_frame, text="Load config file...", command=self.load_config,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
load_file_button.grid(row=0, column=0, padx=5)
|
|
# button to save the current settings to the currently selected file
|
|
save_button = Button(self.file_select_frame, text="Save current config", command=self.save_config,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
save_button.grid(row=0, column=1, padx=5)
|
|
# button to save current settings to a file selected by the user
|
|
save_as_button = Button(self.file_select_frame, text="Save current config as...", command=self.save_config_as,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
save_as_button.grid(row=0, column=2, padx=5)
|
|
|
|
row_counter += 1
|
|
|
|
# Setup entry fields for the PSU serial ports:
|
|
# setup frame:
|
|
port_frame = Frame(self)
|
|
port_frame.grid_rowconfigure(ALL, weight=1)
|
|
port_frame.grid_columnconfigure(ALL, weight=1)
|
|
port_frame.grid(row=row_counter, column=0, sticky=W)
|
|
|
|
# text for the description labels:
|
|
entry_texts = ["XY PSU Serial Port:", "Z PSU Serial Port:"]
|
|
# create variables to store the port names and set to current names
|
|
self.XY_port = StringVar(value=g.CAGE_DEVICE.com_port_psu1)
|
|
self.Z_port = StringVar(value=g.CAGE_DEVICE.com_port_psu2)
|
|
port_vars = [self.XY_port, self.Z_port] # list to store both port variables
|
|
row = 0
|
|
for text in entry_texts: # do this for both ports
|
|
field = Entry(port_frame, textvariable=port_vars[row]) # create entry field
|
|
field.grid(row=row, column=1, sticky=W)
|
|
axis_label = Label(port_frame, text=text, padx=5, pady=10) # create description label
|
|
axis_label.grid(row=row, column=0, sticky=W)
|
|
info_label = Label(port_frame, text="e.g. COM10") # add label with example of right format
|
|
info_label.grid(row=row, column=2, sticky=W)
|
|
row += 1
|
|
|
|
row_counter += 1
|
|
|
|
# Label(self, text="", pady=0).grid(row=row_counter, column=0) # add spacer
|
|
row_counter += 1
|
|
|
|
# setup main entry field for operational constants
|
|
# setup frame:
|
|
value_frame = Frame(self)
|
|
value_frame.grid_rowconfigure(ALL, weight=1)
|
|
value_frame.grid_columnconfigure(ALL, weight=1)
|
|
value_frame.grid(row=row_counter, column=0)
|
|
|
|
# Setup dictionary to generate entry table from
|
|
# {Key: [[x-value,y-value,z-value], unit, description, config file key, unit conversion factor]}
|
|
self.entries = {
|
|
"Coil Constants:": [[DoubleVar() for _ in range(3)], "\u03BCT/A", "Field generated per applied current",
|
|
"coil_const", 1e6],
|
|
"Ambient Field:": [[DoubleVar() for _ in range(3)], "\u03BCT",
|
|
"Field to be compensated", "ambient_field", 1e6],
|
|
"Resistances:": [[DoubleVar() for _ in range(3)], "\u03A9",
|
|
"Resistance of coils + equipment", "resistance", 1],
|
|
"Max. Current:": [[DoubleVar() for _ in range(3)], "A", "Max. allowed current", "max_amps", 1],
|
|
"Max. Voltage:": [[DoubleVar() for _ in range(3)], "V",
|
|
"Max. allowed voltage, must not exceed 16V!", "max_volts", 1],
|
|
"Arduino Pins:": [[IntVar() for _ in range(3)], "-", "Should be 15, 16, 17", "relay_pin", 1]
|
|
}
|
|
|
|
self.fields = {} # setup dictionary with all entry fields
|
|
|
|
# Fill in header (axis names):
|
|
col = 1
|
|
for text in g.AXIS_NAMES:
|
|
label = Label(value_frame, text=text, font=SUB_HEADER_FONT)
|
|
label.grid(row=0, column=col, sticky="ew")
|
|
col += 1
|
|
# generate table with entries, unit labels and descriptions:
|
|
row = 1
|
|
for key in self.entries.keys(): # go through the different values to be set
|
|
self.fields[key] = [] # initialize empty list for fields in the entry field dictionary
|
|
for axis in range(3): # go through all three axes
|
|
field = Entry(value_frame, textvariable=self.entries[key][0][axis], width=10) # setup entry field
|
|
field.grid(row=row, column=axis + 1, sticky=W, padx=2)
|
|
self.fields[key].append(field) # safe access to field to entry field dictionary
|
|
axis_label = Label(value_frame, text=key, padx=5, pady=5) # add label with variable name
|
|
axis_label.grid(row=row, column=0, sticky=W)
|
|
unit_label = Label(value_frame, text=self.entries[key][1]) # add label with unit
|
|
unit_label.grid(row=row, column=4, sticky=W)
|
|
description_label = Label(value_frame, text=self.entries[key][2]) # add label with description
|
|
description_label.grid(row=row, column=5, sticky=W)
|
|
row = row + 1
|
|
|
|
row_counter += 1
|
|
|
|
self.update_fields() # set current values from config file
|
|
|
|
# Label(self, text="", pady=3).grid(row=row_counter, column=0) # add spacer
|
|
row_counter += 1
|
|
|
|
# Setup buttons to implement and restore defaults
|
|
# Setup frame to house buttons:
|
|
self.buttons_frame = Frame(self)
|
|
self.buttons_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.buttons_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.buttons_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
# Create and place buttons
|
|
# button to read the values from all fields, update the config and reinitialize the test bench
|
|
implement_button = Button(self.buttons_frame, text="Update and Reinitialize", command=self.implement,
|
|
pady=5, padx=5, font=BIG_BUTTON_FONT)
|
|
implement_button.grid(row=0, column=0, padx=5)
|
|
# button to restore default settings
|
|
restore_button = Button(self.buttons_frame, text="Restore Defaults", command=self.restore_defaults,
|
|
pady=5, padx=5, font=BIG_BUTTON_FONT)
|
|
restore_button.grid(row=0, column=1, padx=5)
|
|
|
|
row_counter += 1
|
|
# Label(self, text="", pady=3).grid(row=row_counter, column=0) # add spacer
|
|
|
|
def page_switch(self): # function that is called when switching to this window
|
|
self.update_fields() # update values in the entry fields from config
|
|
|
|
def restore_defaults(self): # restore default settings
|
|
config.reset_config_to_default() # overwrite config file with default
|
|
ui_print("\nReinitializing devices...")
|
|
g.CAGE_DEVICE.reconnect_hardware() # setup everything with the defaults
|
|
self.update_fields() # update fields in config window
|
|
|
|
def update_fields(self): # set current values for all entry variables from config file
|
|
# set values for PSU serial ports:
|
|
self.XY_port.set(g.CAGE_DEVICE.com_port_psu1)
|
|
self.Z_port.set(g.CAGE_DEVICE.com_port_psu2)
|
|
|
|
for key in self.entries.keys(): # go through the main value table
|
|
for i in range(3): # go through all three axes
|
|
# get value from config file:
|
|
value = config.read_from_config(g.AXIS_NAMES[i], self.entries[key][3], config.CONFIG_OBJECT)
|
|
self.entries[key][0][i].set(value) # set initial value on the entry field variable
|
|
type_value = self.entries[key][0][i].get() # get value with correct type by reading out field variable
|
|
factor = self.entries[key][4] # get unit conversion factor
|
|
self.entries[key][0][i].set(round(type_value * factor, 3)) # set value with correct unit conversion
|
|
|
|
# check if value is within safe limits:
|
|
value_check = helmholtz_cage_device.value_in_limits(g.AXIS_NAMES[i], self.entries[key][3], value)
|
|
if value_check == 'OK': # value is acceptable
|
|
self.fields[key][i].config(background="White") # set colour of this entry to white
|
|
else: # value exceeds limits
|
|
self.fields[key][i].config(background="Red") # set colour of this entry to red to show problem
|
|
|
|
def write_values(self): # update config object with user inputs into entry fields and reinitialize devices
|
|
|
|
# set serial ports for PSUs:
|
|
config.edit_config("Supplies", "xy_port", self.XY_port.get())
|
|
config.edit_config("Supplies", "z_port", self.Z_port.get())
|
|
|
|
# set numeric values for all axes
|
|
for key in self.entries.keys(): # go through rows of entry table
|
|
for i in [0, 1, 2]: # go through columns of entry table (axes)
|
|
try:
|
|
value = self.entries[key][0][i].get() # get value from field
|
|
except TclError as e: # wrong format entered, e.g. text in number fields
|
|
ui_print("Invalid entry for %s %s %s" % (g.AXIS_NAMES[i], key, e)) # print error message
|
|
# field will go back to the last valid value
|
|
|
|
else: # format is ok
|
|
factor = self.entries[key][4] # get unit conversion factor
|
|
if factor not in [0, 1]: # prevent div/0 and conversion of int variables to float
|
|
value = value / factor # do unit conversion
|
|
|
|
# Check if value is within safe limits
|
|
config_key = self.entries[key][3] # get handle by which value is indexed in config file
|
|
value_ok = helmholtz_cage_device.value_in_limits(g.AXIS_NAMES[i], config_key, value) # perform value check
|
|
|
|
if value_ok == 'OK': # value is within safe limits
|
|
config.edit_config(g.AXIS_NAMES[i], config_key, value) # write new value to config file
|
|
else: # value is not within limits
|
|
unit = self.entries[key][1] # get unit string for error messages
|
|
axis = g.AXIS_NAMES[i] # get axis name for error messages
|
|
|
|
if value_ok == 'HIGH': # value is too high
|
|
max_value = g.default_arrays[config_key][1][i] # get max value
|
|
# assemble error message:
|
|
message = "Attempted to set too high value for {s} {k}\n" \
|
|
"{v} {unit}, max. {mv} {unit} allowed.\n" \
|
|
"Excessive values may damage equipment!\n" \
|
|
"Do you really want to use this value?" \
|
|
.format(s=axis, k=key, v=value * factor, mv=round(max_value * factor, 1), unit=unit)
|
|
elif value_ok == 'LOW': # value is too low
|
|
min_value = g.default_arrays[config_key][2][i] # get min value
|
|
# assemble error message:
|
|
message = "Attempted to set too low value for {s} {k}\n" \
|
|
"{v} {unit}, min. {mv} {unit} allowed.\n" \
|
|
"Excessive values may damage equipment!\n" \
|
|
"Do you really want to use this value?" \
|
|
.format(s=axis, k=key, v=value * factor, mv=round(min_value * factor, 1), unit=unit)
|
|
else: # this should be impossible
|
|
message = "Unknown case for value limits check, this should not happen."
|
|
|
|
# display pop-up message to ask user if he really wants the value
|
|
answer = messagebox.askquestion("Value out of bounds", message)
|
|
# answer becomes 'yes' or 'no' depending on user choice
|
|
if answer == 'yes': # user really wants the value
|
|
# call function to write new value to config file with override=True
|
|
config.edit_config(g.AXIS_NAMES[i], config_key, value, True)
|
|
# if user chooses 'no' nothing happens, old value is kept
|
|
|
|
def implement(self): # "Update and Reinitialize" button, update config with new values and reinitialize devices
|
|
self.write_values() # write current values from entry fields to config object
|
|
ui_print("\nReinitializing devices...")
|
|
g.CAGE_DEVICE.reconnect_hardware() # reinitialize devices and program with new values
|
|
self.update_fields() # update entry fields to show new values
|
|
|
|
def load_config(self): # load configuration from some config file
|
|
directory = os.path.dirname(os.path.abspath(config.CONFIG_FILE)) # get directory of current config file
|
|
# open file selection dialogue at current path and save path of selected file
|
|
filename = filedialog.askopenfilename(initialdir=directory, title="Select Config File",
|
|
filetypes=(("Config File", "*.ini*"), ("All Files", "*.*")))
|
|
if exists(filename): # does the file exist?
|
|
config.CONFIG_FILE = filename # set global config file to the new file
|
|
config.CONFIG_OBJECT = config.get_config_from_file(filename) # load from config file to config object
|
|
config.check_config(config.CONFIG_OBJECT) # check and display warnings if values are out of bounds
|
|
|
|
ui_print("\nReinitializing devices...")
|
|
g.CAGE_DEVICE.reconnect_hardware() # reinitialize devices and program with new values
|
|
self.update_fields() # update entry fields to show new values
|
|
elif filename == '': # this happens when file selection window is closed without selecting a file
|
|
ui_print("No file selected, could not load config.")
|
|
else: # file does not exist
|
|
ui_print("Selected file", filename, "does not exist, could not load config.")
|
|
|
|
def save_config_as(self): # save current configuration to a new config file
|
|
directory = os.path.dirname(os.path.abspath(config.CONFIG_FILE)) # get directory of current config file
|
|
# open file selection dialogue and save path of selected file
|
|
filename = filedialog.asksaveasfilename(initialdir=directory, title="Save config to file",
|
|
filetypes=([("Config File", "*.ini*")]),
|
|
defaultextension=[("Config File", "*.ini*")])
|
|
|
|
if filename == '': # this happens when file selection window is closed without selecting a file
|
|
ui_print("No file selected, could not save config.")
|
|
else: # a file name was entered
|
|
config.CONFIG_FILE = filename # set global config file to the new file
|
|
self.write_values() # write current entry field values to the config object
|
|
config.write_config_to_file(config.CONFIG_OBJECT) # write contents of config object to file
|
|
ui_print("\nReinitializing devices...")
|
|
g.CAGE_DEVICE.reconnect_hardware() # reinitialize devices and program with new values
|
|
self.update_fields() # update entry fields to show values as they are in the config
|
|
|
|
def save_config(self): # same as save_config_as() but with the current config file
|
|
self.write_values() # write current entry field values to the config object
|
|
config.write_config_to_file(config.CONFIG_OBJECT) # write contents of config object to file
|
|
ui_print("\nReinitializing devices...")
|
|
g.CAGE_DEVICE.reconnect_hardware() # reinitialize devices and program with new values
|
|
self.update_fields() # update entry fields to show values as they are in the config
|
|
|
|
|
|
class ConfigureLogging(Frame):
|
|
# generate window to configure data logging to csv
|
|
# ToDo: support logging of axis-independent info like Arduino status
|
|
# ToDo (optional): Add option to select which axes to log data from
|
|
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent)
|
|
self.parent = parent # parent object, here tha mainArea frame
|
|
self.controller = controller # object on which mainloop() is running, usually main window
|
|
|
|
self.log_file = None # string containing path of log file
|
|
self.regular_logging = False # True if data should be logged regularly
|
|
self.event_logging = False # True if data should be logged every time a command is sent to the test bench
|
|
# log_datapoint() has to be called wherever a command is sent to the test bench and data should be logged
|
|
# it does not happen automatically whenever something is sent to the test bench
|
|
# It is done mainly in the functions for UI buttons, but rather inconsistently ToDo(optional): make consistent
|
|
|
|
self.grid_rowconfigure(ALL, weight=1)
|
|
self.grid_columnconfigure(ALL, weight=1)
|
|
|
|
row_counter = 0
|
|
|
|
# setup headline
|
|
header = Label(self, text="Configure Data Logging", font=HEADER_FONT, pady=3)
|
|
header.grid(row=row_counter, column=0, padx=100, sticky=W)
|
|
|
|
row_counter += 1
|
|
|
|
# Create and place buttons
|
|
# Setup frame to house buttons:
|
|
self.top_buttons_frame = Frame(self)
|
|
self.top_buttons_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.top_buttons_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.top_buttons_frame.grid(row=row_counter, column=0, sticky=W, padx=20, pady=5)
|
|
|
|
# button to start data logging
|
|
self.start_logging_button = Button(self.top_buttons_frame, text="Start Logging", command=self.start_logging,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT)
|
|
self.start_logging_button.grid(row=0, column=0, padx=5)
|
|
# button to stop data logging
|
|
self.stop_logging_button = Button(self.top_buttons_frame, text="Stop Logging", command=self.stop_logging,
|
|
pady=5, padx=5, font=SMALL_BUTTON_FONT, state="disabled")
|
|
self.stop_logging_button.grid(row=0, column=1, padx=5)
|
|
# button to write log data to a file
|
|
self.write_to_file_button = Button(self.top_buttons_frame, text="Write data to file", font=SMALL_BUTTON_FONT,
|
|
command=self.write_to_file, pady=5, padx=5, state="disabled")
|
|
self.write_to_file_button.grid(row=0, column=2, padx=5)
|
|
# button to clear all logged data
|
|
self.clear_data_button = Button(self.top_buttons_frame, text="Clear logged data", font=SMALL_BUTTON_FONT,
|
|
command=self.clear_data, pady=5, padx=5, state="disabled")
|
|
self.clear_data_button.grid(row=0, column=3, padx=5)
|
|
|
|
row_counter += 1
|
|
|
|
# Create label showing how many datapoints have been logged
|
|
# setup frame:
|
|
self.log_label_frame = Frame(self)
|
|
self.log_label_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.log_label_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.log_label_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
self.logged_datapoints = IntVar() # create variable to display number of logged datapoints
|
|
# Add description label:
|
|
datapoints_description = Label(self.log_label_frame, text="Datapoints logged:")
|
|
datapoints_description.grid(row=0, column=0, sticky=W)
|
|
# Add updatable label to show how much data has been logged
|
|
datapoints_label = Label(self.log_label_frame, textvariable=self.logged_datapoints)
|
|
datapoints_label.grid(row=0, column=1, sticky=W)
|
|
|
|
row_counter += 1
|
|
|
|
# create checkboxes and entries to set when and how often data should be logged
|
|
# setup frame:
|
|
self.settings_frame = Frame(self)
|
|
self.settings_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.settings_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.settings_frame.grid(row=row_counter, column=0, sticky=W, padx=20)
|
|
|
|
# create checkbox variable for logging in regular time intervals
|
|
self.regular_logging_var = BooleanVar(value=True)
|
|
# create checkbox variable for logging whenever test bench is commanded
|
|
self.event_logging_var = BooleanVar(value=True)
|
|
self.log_interval = DoubleVar(value=1) # create variable for logging interval entry field
|
|
|
|
# create checkboxes for regular and event logging:
|
|
self.regular_logging_checkbox = Checkbutton(self.settings_frame, text="Log in regular intervals",
|
|
variable=self.regular_logging_var, onvalue=True, offvalue=False)
|
|
self.event_logging_checkbox = Checkbutton(self.settings_frame, text="Log whenever test bench is commanded",
|
|
variable=self.event_logging_var, onvalue=True, offvalue=False)
|
|
self.regular_logging_checkbox.grid(row=0, column=0, sticky=W)
|
|
self.event_logging_checkbox.grid(row=1, column=0, sticky=W, columnspan=3)
|
|
|
|
# Set up entry field for setting logging interval
|
|
# Add description label for logging interval entry:
|
|
interval_label = Label(self.settings_frame, text=" Interval (s):")
|
|
interval_label.grid(row=0, column=1, sticky=W)
|
|
# Add entry field to set interval
|
|
self.interval_entry = Entry(self.settings_frame, textvariable=self.log_interval)
|
|
self.interval_entry.grid(row=0, column=2, sticky=W)
|
|
|
|
row_counter += 1
|
|
|
|
# Create checkboxes to select what data to log
|
|
# setup frame:
|
|
self.checkbox_frame = Frame(self)
|
|
self.checkbox_frame.grid_rowconfigure(ALL, weight=1)
|
|
self.checkbox_frame.grid_columnconfigure(ALL, weight=1)
|
|
self.checkbox_frame.grid(row=row_counter, column=0, sticky=W, padx=10, pady=10)
|
|
|
|
self.checkbox_vars = {} # dictionary containing the bool variables changed by the checkboxes
|
|
self.checkboxes = [] # list containing all the checkbox objects, used to lock/unlock all of them
|
|
self.active_keys = [] # list with all keys of the currently ticked checkboxes
|
|
|
|
# add general description headline:
|
|
checkbox_label = Label(self.checkbox_frame, text="Select which data to log:")
|
|
checkbox_label.grid(row=0, column=0, columnspan=2)
|
|
# generate and place all checkboxes:
|
|
row = 1
|
|
for key in log.axis_data_dict.keys(): # go through all loggable values
|
|
self.checkbox_vars[key] = BooleanVar(value=True) # create variable for checkbox and put it in dictionary
|
|
checkbox = Checkbutton(self.checkbox_frame, text=key, # generate checkbox
|
|
variable=self.checkbox_vars[key], onvalue=True, offvalue=False)
|
|
checkbox.grid(row=row, column=0, sticky=W) # place checkbox in UI
|
|
self.checkboxes.append(checkbox) # add created checkbox to list of all checkboxes
|
|
row += 1
|
|
|
|
# self.controller.bind('<Escape>', self.escape_press) ToDo: implement escape button press event to power down
|
|
|
|
def page_switch(self): # function that is called when switching to this window
|
|
# every class in the UI needs this, even if it doesn't do anything
|
|
pass
|
|
|
|
# def escape_press(self, event): ToDo: implement escape button press event to power down
|
|
# stop_logging()
|
|
|
|
def start_logging(self): # start logging data (called by button)
|
|
ui_print("Started data logging.")
|
|
self.update_choices() # update list with ticked checkboxes
|
|
self.regular_logging = self.regular_logging_var.get() # check if regular logging checkbox is ticked
|
|
self.event_logging = self.event_logging_var.get() # check if event logging checkbox is ticked
|
|
self.update_datapoint_count() # start regular update of label showing how many datapoints have been collected
|
|
|
|
if self.logged_datapoints.get() == 0: # no data has been logged so far
|
|
# (if condition is here to keep timestamps consistent when repeatedly starting/stopping)
|
|
log.zero_time = datetime.now() # set reference time for timestamps in log
|
|
|
|
# get settings for regular logging:
|
|
error = False # initialize variable to store if an error occurred
|
|
if self.regular_logging: # regular logging checkbox is ticked
|
|
try: # try to get log interval from entry field
|
|
interval_ms = int(self.log_interval.get() * 1000) # get value and convert to ms
|
|
except TclError as e: # invalid entry for log interval
|
|
# show error pop-up:
|
|
messagebox.showwarning("Wrong entry format!", "Invalid entry for log interval:\n%s" % e)
|
|
self.event_logging = False # don't start event logging if there is a problem
|
|
error = True # save that an error was encountered
|
|
else: # no problems while reading out the log interval
|
|
self.periodic_log(interval_ms) # start periodic logging
|
|
|
|
if (self.regular_logging or self.event_logging) and not error: # logging is active and no error during setup
|
|
# lock/unlock buttons and checkboxes:
|
|
self.stop_logging_button["state"] = "normal"
|
|
self.start_logging_button["state"] = "disabled"
|
|
self.write_to_file_button["state"] = "disabled"
|
|
self.clear_data_button["state"] = "normal"
|
|
self.lock_checkboxes()
|
|
|
|
def stop_logging(self): # stop the data logging, called by "Stop Logging" button
|
|
ui_print("Stopped data logging. Remember to save data to file!")
|
|
self.regular_logging = False # tell everything its time to stop periodic logging
|
|
self.event_logging = False # tell everything its time to stop logging on test bench commands
|
|
self.write_to_file_button["state"] = "normal" # enable write to file button
|
|
self.stop_logging_button["state"] = "disabled" # disable stop logging button
|
|
self.start_logging_button["state"] = "normal" # enable start logging button
|
|
self.unlock_checkboxes() # enable checkboxes
|
|
|
|
def write_to_file(self): # lets user select a file and writes logged data to it
|
|
filepath = log.select_file() # select a file to write to
|
|
if filepath is None: # no valid file was selected
|
|
# ask user if he wants to try again:
|
|
try_again = messagebox.askquestion("No file selected", "No valid file was selected. Try again?")
|
|
if try_again == 'yes': # user wants to try again
|
|
self.write_to_file() # call same function again so user can retry
|
|
else: # a valid filename was selected
|
|
log.write_to_file(log.log_data, filepath) # write logged data to the file
|
|
|
|
def clear_data(self): # called on button press, asks user if he want to save logged data and then deletes it
|
|
if log.unsaved_data: # there is logged data that has not been written to a file yet
|
|
# open pop-up to ask user if he wants to save the data or cancel clearing it:
|
|
save_log = messagebox.askyesnocancel("Save log data?", "There seems to be unsaved logging data. "
|
|
"Do you wish to write it to a file before deleting?")
|
|
if save_log: # user has chosen yes
|
|
self.write_to_file() # run write to file function to save data
|
|
if save_log is not None: # user has chosen yes or no (not cancel)
|
|
log.clear_logged_data() # delete the logged data
|
|
log.unsaved_data = False # tell everything that there is no unsaved data remaining
|
|
self.logged_datapoints.set(len(log.log_data)) # update the label showing how much data has been logged
|
|
ui_print("Log data cleared.")
|
|
else: # user has chosen to cancel
|
|
ui_print("Log data not cleared.")
|
|
else: # there is no unsaved data
|
|
log.clear_logged_data() # delete the logged data
|
|
self.logged_datapoints.set(len(log.log_data)) # update the label showing how much data has been logged
|
|
ui_print("Log data cleared.")
|
|
|
|
def update_choices(self): # updates the list storing which checkboxes are currently ticked
|
|
# (this is passed to logging functions and determines which data is logged)
|
|
|
|
self.active_keys = [] # initialize the list
|
|
for key in self.checkbox_vars.keys(): # go through all checkboxes
|
|
if self.checkbox_vars[key].get(): # box is ticked
|
|
self.active_keys.append(key) # add corresponding item to the list
|
|
|
|
def lock_checkboxes(self): # lock all checkboxes, so they can not be modified while logging
|
|
# lock all checkboxes:
|
|
for checkbox in [*self.checkboxes, self.event_logging_checkbox, self.regular_logging_checkbox]:
|
|
checkbox.config(state=DISABLED)
|
|
self.interval_entry.config(state=DISABLED) # lock logging interval entry field
|
|
|
|
def unlock_checkboxes(self): # opposite of lock checkboxes
|
|
for checkbox in [*self.checkboxes, self.event_logging_checkbox, self.regular_logging_checkbox]:
|
|
checkbox.config(state=NORMAL)
|
|
self.interval_entry.config(state=NORMAL)
|
|
|
|
def periodic_log(self, interval): # logs data in regular intervals (ms)
|
|
if self.regular_logging: # logging in intervals is still active
|
|
self.log_datapoint() # add a datapoint to the log data frame
|
|
self.controller.after(interval, lambda: self.periodic_log(interval)) # call same function again after time
|
|
|
|
def log_datapoint(self): # log a single datapoint based on which checkboxes are ticked
|
|
try:
|
|
log.log_datapoint(self.active_keys) # add datapoint with active checkboxes to log data frame
|
|
except Exception as e: # some error occurred
|
|
messagebox.showerror("Error!", "Error while logging data: \n%s" % e)
|
|
|
|
def update_datapoint_count(self): # update label with how many datapoints have been logged
|
|
if self.regular_logging or self.event_logging: # logging is still active
|
|
self.logged_datapoints.set(len(log.log_data)) # update label with number of rows in log_data
|
|
self.controller.after(1000, self.update_datapoint_count) # call function again after 1 second
|
|
|
|
|
|
class StatusDisplay(Frame):
|
|
# status display to show information on test bench status in real time
|
|
|
|
# noinspection PyUnusedLocal
|
|
def __init__(self, parent, controller):
|
|
Frame.__init__(self, parent, relief=SUNKEN, bd=1)
|
|
self.controller = controller
|
|
|
|
# Queue to store status updates which arrive from another thread by callback
|
|
self.update_label_queue = Queue()
|
|
|
|
# configure Tkinter grid
|
|
self.grid_rowconfigure(ALL, weight=1)
|
|
self.grid_columnconfigure(ALL, weight=1)
|
|
|
|
rowCounter = 0 # keep track of which row we are at in the grid layout
|
|
x_pad = 10 # centrally set padding
|
|
|
|
# create column headers (X-Axis etc.)
|
|
col = 0
|
|
for header in ["", "X-Axis", "Y-Axis", "Z-Axis"]: # define Column headers
|
|
# create label:
|
|
headLabel = Label(self, text=header, font=SUB_HEADER_FONT, borderwidth=1,
|
|
relief="flat", anchor="w", padx=x_pad)
|
|
headLabel.grid(row=rowCounter, column=col, sticky="ew")
|
|
col = col + 1 # move to next column
|
|
|
|
rowCounter += 1 # increase row counter to place future stuff below header
|
|
|
|
# define content of row entries:
|
|
# ToDo (optional): Use the central dictionary, currently defined in csv_logging.py
|
|
TextLabels = ["PSU Serial Port:", "PSU Channel:", "PSU Status:", "Arduino Status:", "", "Output:",
|
|
"Remote Control:",
|
|
"Voltage Setpoint:", "Actual Voltage:", "Current Setpoint:", "Actual Current:", "",
|
|
"Target Field:", "Trgt. Field Raw:", "Target Current:", "Inverted:"]
|
|
self.rowNo = len(TextLabels) # get number of label rows
|
|
|
|
self.columnNo = 4 # number of label columns
|
|
# prepare list of lists to contain all labels for row entries in all columns:
|
|
self.Labels = [[] for _ in range(self.columnNo)]
|
|
|
|
# create dictionary to associate (changing) label variables with their labels:
|
|
self.label_dict = {} # initialize dictionary
|
|
for name in TextLabels: # go through all rows
|
|
self.label_dict[name] = [StringVar() for _ in range(self.columnNo - 1)] # create variables for labels
|
|
# add static labels for row titles:
|
|
self.Labels[0].append(Label(self, text=name, borderwidth=1, relief="flat", anchor="w", padx=x_pad))
|
|
for col in range(self.columnNo - 1): # go through columns
|
|
# add changeable labels for values:
|
|
self.Labels[col + 1].append(Label(self, textvariable=self.label_dict[name][col],
|
|
borderwidth=1, relief="flat", anchor="w", padx=x_pad))
|
|
|
|
# place all labels in grid layout
|
|
col = 0
|
|
for LabelCol in self.Labels: # go through table columns
|
|
for row in range(self.rowNo): # go through table rows
|
|
LabelCol[row].grid(row=row + rowCounter, column=col, sticky="nsew") # place label
|
|
col += 1
|
|
|
|
# Register callback to populate new data:
|
|
g.CAGE_DEVICE.subscribe_status_updates(self.enqueue_new_status)
|
|
# Starts polling loop for status display
|
|
self.update_label_poll_method()
|
|
|
|
def update_labels(self, status): # update all values in the status display
|
|
for i in range(3): # go through all three axes
|
|
# update all label variables with the new values:
|
|
axis = status['axes'][i]
|
|
if axis['connected']:
|
|
# Deal with variables that are dependent on the current hardware state
|
|
active = "True" if axis['active'] else "False"
|
|
remote_active = "True" if axis['active'] else "False"
|
|
voltage_setpoint = "%0.3f V" % axis['voltage_setpoint']
|
|
voltage = "%0.3f V" % axis['voltage']
|
|
current_setpoint = "%0.3f A" % axis['current_setpoint']
|
|
current = "%0.3f A" % axis['current']
|
|
polarity = axis['polarity']
|
|
else:
|
|
active = "N/A"
|
|
remote_active = "N/A"
|
|
voltage_setpoint = "N/A"
|
|
voltage = "N/A"
|
|
current_setpoint = "N/A"
|
|
current = "N/A"
|
|
polarity = "N/A"
|
|
psu_connected = "Connected" if axis['connected'] else "Not Connected"
|
|
arduino_connected = "Connected" if status['arduino_connected'] else "Not Connected"
|
|
|
|
# ToDo (optional): Use the central dictionary currently defined in csv_logging.py for this
|
|
self.label_dict["PSU Serial Port:"][i].set(axis['port'])
|
|
self.label_dict["PSU Channel:"][i].set(axis['channel'])
|
|
self.label_dict["PSU Status:"][i].set(psu_connected)
|
|
self.label_dict["Arduino Status:"][i].set(arduino_connected) # ToDo (optional): make this multicolumn
|
|
self.label_dict["Output:"][i].set(active)
|
|
self.label_dict["Remote Control:"][i].set(remote_active)
|
|
self.label_dict["Voltage Setpoint:"][i].set(voltage_setpoint)
|
|
self.label_dict["Actual Voltage:"][i].set(voltage)
|
|
self.label_dict["Current Setpoint:"][i].set(current_setpoint)
|
|
self.label_dict["Actual Current:"][i].set(current)
|
|
self.label_dict["Target Field:"][i].set("%0.3f \u03BCT" % (axis['target_field'] * 1e6))
|
|
self.label_dict["Trgt. Field Raw:"][i].set("%0.3f \u03BCT" % (axis['target_field_raw'] * 1e6))
|
|
self.label_dict["Target Current:"][i].set("%0.3f A" % axis['target_current'])
|
|
self.label_dict["Inverted:"][i].set(polarity)
|
|
|
|
def enqueue_new_status(self, status):
|
|
"""Runs in caller thread and places status onto queue to display when polled in update_label_poll_method"""
|
|
self.update_label_queue.put(status)
|
|
|
|
def update_label_poll_method(self):
|
|
"""Infinite loop to poll for status updates to display"""
|
|
try:
|
|
new_status = self.update_label_queue.get(block=False) # Blocks until new data is available.
|
|
self.update_labels(new_status)
|
|
except Empty:
|
|
pass
|
|
self.controller.after(200, self.update_label_poll_method)
|
|
|
|
|
|
class OutputConsole(Frame):
|
|
# console to print information to user in, similar to standard python output
|
|
|
|
def __init__(self, parent):
|
|
Frame.__init__(self, parent, relief=SUNKEN, bd=1)
|
|
|
|
# configure Tkinter grid:
|
|
self.grid_rowconfigure(ALL, weight=1)
|
|
self.grid_columnconfigure(0, weight=1, minsize=60) # console needs to have a minimum width
|
|
|
|
scrollbar = Scrollbar(self) # setup scrollbar
|
|
self.console = Text(self) # setup main console widget
|
|
self.console.bind("<Key>", lambda e: "break") # prevent user from writing into the console
|
|
|
|
scrollbar.grid(row=0, column=1, sticky="ns") # place the scrollbar and stretch vertically
|
|
self.console.grid(row=0, column=0, sticky="nesw") # place the output console
|
|
# link scrollbar to the console
|
|
scrollbar.config(command=self.console.yview)
|
|
self.console.config(yscrollcommand=scrollbar.set)
|