def __init__(self, hardware, parameters, parent = None):
QtCore.QThread.__init__(self, parent)
# Other class initializations
self.acquire = IdleActive()
self.frame_number = 0
self.key = -1
self.mutex = QtCore.QMutex()
self.parameters = parameters
self.running = True
self.shutter = False
# Camera initialization
self.camera = False
self.got_camera = False
self.reversed_shutter = False
# Default camera parameters.
cam1_params = self.parameters.addSubSection("camera1")
cam1_params.add("save", params.ParameterSetBoolean("",
"save",
True,
is_mutable = False,
is_saved = False))
cam1_params.add("x_pixels", params.ParameterInt("",
"x_pixels",
1,
is_mutable = False,
is_saved = True))
cam1_params.add("y_pixels", params.ParameterInt("",
"y_pixels",
1,
is_mutable = False,
is_saved = True))
cam1_params.add("flip_horizontal", params.ParameterSetBoolean("Flip image horizontal",
"flip_horizontal",
False))
cam1_params.add("flip_vertical", params.ParameterSetBoolean("Flip image vertical",
"flip_vertical",
False))
cam1_params.add("transpose", params.ParameterSetBoolean("Transpose image",
"transpose",
False))
def __init__(self, hardware, parameters, parent = None):
QtCore.QThread.__init__(self, parent)
# Other class initializations
self.acquire = IdleActive()
self.frame_number = 0
self.key = -1
self.mutex = QtCore.QMutex()
self.parameters = parameters
self.running = True
self.shutter = False
# Camera initialization
self.camera = False
self.got_camera = False
self.reversed_shutter = False
self.parameters.add("camera1.save", params.ParameterSetBoolean("",
"save",
True,
is_mutable = False,
is_saved = False))
self.parameters.add("camera1.x_pixels", params.ParameterInt("",
"x_pixels",
1,
is_mutable = False,
is_saved = True))
self.parameters.add("camera1.y_pixels", params.ParameterInt("",
"y_pixels",
1,
is_mutable = False,
is_saved = True))
def __init__(self, parameters, parent):
QtGui.QDialog.__init__(self, parent)
halModule.HalModule.__init__(self)
if parent:
self.have_parent = True
else:
self.have_parent = False
# General.
self.offset_file = 0
self.parameters = parameters
self.jumpsize = 0.0
self.tcp_message = None
# Qt timer for checking focus lock
self.focus_check_timer = QtCore.QTimer()
self.focus_check_timer.setSingleShot(True)
self.focus_check_timer.timeout.connect(self.tcpPollFocusStatus)
self.num_focus_checks = 0
self.accum_focus_checks = 0
# Focus lock specific parameters.
flock_params = self.parameters.get("focuslock")
flock_params.add("qpd_mode", params.ParameterRangeInt("Current mode",
"qpd_mode",
0, 0, 6,
is_mutable = False,
is_saved = False))
flock_params.add("cal_frames_to_pause", params.ParameterRangeInt("Frames to pause between steps (z-calibration)",
"cal_frames_to_pause", 2, 1, 100))
flock_params.add("cal_deadtime", params.ParameterRangeInt("Frames before to pause at start (z-calibration)",
"cal_deadtime", 20, 1, 100))
flock_params.add("cal_range", params.ParameterRangeFloat("Distance +- z to move in nanometers (z-calibration)",
"cal_range", 600, 100, 5000))
flock_params.add("cal_step_size", params.ParameterRangeFloat("Step size in z in nanometers (z-calibration)",
"cal_step_size", 10, 1, 100))
flock_params.add("olock_bracket_step", params.ParameterRangeFloat("Distance +- z in nanometers (optimal lock)",
"olock_bracket_step", 1000.0, 10.0, 10000.0))
flock_params.add("olock_quality_threshold", params.ParameterRangeFloat("Minimum 'quality' signal (optimal lock)",
"olock_quality_threshold", 0.0, 0.0, 1000.0))
flock_params.add("olock_scan_step", params.ParameterRangeFloat("Step size in z in nanometers (optimal lock)",
"olock_scan_step", 100.0, 10.0, 1000.0))
flock_params.add("olock_scan_hold", params.ParameterRangeInt("Frames to pause between steps (optimal lock)",
"olock_scan_hold", 10, 1, 100))
flock_params.add("zscan_focus_lock", params.ParameterSetBoolean("Lock focus between steps (z-scan)",
"zscan_focus_lock", False))
flock_params.add("zscan_frames_to_pause", params.ParameterRangeInt("Frames to pause between steps (z-scan)",
"zscan_frames_to_pause", 100, 1, 100000))
flock_params.add("zscan_start", params.ParameterRangeFloat("Piezo starting position in micros (z-scan)",
"zscan_start", 50.0, 0.0, 1000.0))
flock_params.add("zscan_step", params.ParameterRangeFloat("Piezo step size in microns (z-scan)",
"zscan_step", 0.1, 0.0, 100.0))
flock_params.add("zscan_stop", params.ParameterRangeFloat("Piezo stopping position (z-scan)",
"zscan_stop", 51.0, 0.0, 1000.0))
def __init__(self, hardware, parameters, parent=None):
miscControl.MiscControl.__init__(self, parameters, parent)
self.em_filter_pos = 0
self.em_filter_wheel = prior.Prior(port=hardware.get("port"),
baudrate=hardware.get("baud_rate"))
# Add parameters.
misc_params = parameters.addSubSection("misc")
misc_params.add(
"em_checked",
params.ParameterSetBoolean(
"Change emission filter position during filming", "em_checked",
False))
misc_params.add(
"em_filter",
params.ParameterRangeInt("Emission filter position", "em_filter",
0, 0, 5))
misc_params.add(
"em_period",
params.ParameterInt("Emission filter update period in frames",
"em_period", 60))
# UI setup
self.ui = miscControlsUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(parameters.get("setup_name") + " Misc Control")
# connect signals
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
# setup (emission) filter wheel
# self.ui.emFilter6Button.hide()
# self.ui.emFilter7Button.hide()
# self.ui.emFilter8Button.hide()
# self.ui.emFilter9Button.hide()
# self.ui.emFilter10Button.hide()
self.em_filters = [[self.ui.emFilter1Button, "Quad"],
[self.ui.emFilter2Button, "750"],
[self.ui.emFilter3Button, "647"],
[self.ui.emFilter4Button, "560"],
[self.ui.emFilter5Button, "488"],
[self.ui.emFilter6Button, "Empty"]]
for [afilter, name] in self.em_filters:
afilter.clicked.connect(self.handleEmFilter)
afilter.setText(name)
if self.em_filter_wheel:
self.em_filters[self.em_filter_wheel.getFilter() - 1][0].click()
self.ui.emCheckBox.setChecked(parameters.get("misc.em_checked"))
self.ui.emSpinBox.setValue(parameters.get("misc.em_period"))
def __init__(self, parameters, joystick, parent = None):
QtCore.QObject.__init__(self, parent)
halModule.HalModule.__init__(self, parent)
self.button_timer = QtCore.QTimer(self)
self.jstick = joystick
self.old_right_joystick = [0, 0]
self.old_left_joystick = [0, 0]
self.to_emit = False
# Add joystick specific parameters.
js_params = parameters.addSubSection("joystick")
js_params.add("joystick_gain_index", params.ParameterInt("",
"joystick_gain_index",
0,
is_mutable = False,
is_saved = False))
js_params.add("multiplier", params.ParameterInt("",
"multiplier",
1,
is_mutable = False,
is_saved = False))
js_params.add("hat_step", params.ParameterRangeFloat("Step size in um for hat button press",
"hat_step",
1.0, 0.0, 10.0))
js_params.add("joystick_gain", [25.0, 250.0, 2500.0])
js_params.add("joystick_multiplier_value", params.ParameterRangeFloat("X button multiplier for joystick and focus lock",
"joystick_multiplier_value",
5.0, 0.0, 50.0))
js_params.add("joystick_mode", params.ParameterSetString("Response mode",
"joystick_mode",
"quadratic",
["linear", "quadratic"]))
js_params.add("joystick_signx", params.ParameterSetFloat("Sign for x motion",
"joystick_signx",
1.0, [-1.0, 1.0]))
js_params.add("joystick_signy", params.ParameterSetFloat("Sign for y motion",
"joystick_signy",
1.0, [-1.0, 1.0]))
js_params.add("lockt_step", params.ParameterRangeFloat("Focus lock step size in um",
"lockt_step",
0.025, 0.0, 1.0))
js_params.add("min_offset", params.ParameterRangeFloat("Minimum joystick offset to be non-zero",
"min_offset",
0.1, 0.0, 1.0))
js_params.add("xy_swap", params.ParameterSetBoolean("Swap x and y axises",
"xy_swap",
False))
self.parameters = js_params
self.jstick.start(self.joystickHandler)
self.button_timer.setInterval(100)
self.button_timer.setSingleShot(True)
self.button_timer.timeout.connect(self.buttonDownHandler)
def __init__(self, hardware, parameters, parent = None):
cameraControl.HWCameraControl.__init__(self, hardware, parameters, parent)
if hardware and hardware.has("pci_card"):
self.initCamera(hardware.get("pci_card"))
else:
self.initCamera()
# Add Andor EMCCD specific parameters.
#
cam_params = parameters.get("camera1")
# FIXME: Need to get this value from the camera.
max_intensity = self.camera.getMaxIntensity()
cam_params.add("max_intensity", params.ParameterInt("",
"max_intensity",
max_intensity,
is_mutable = False,
is_saved = False))
# FIXME: Need to update based on the current EM gain mode.
[gain_low, gain_high] = self.camera.getEMGainRange()
cam_params.add("emccd_gain", params.ParameterRangeInt("EMCCD Gain",
"emccd_gain",
gain_low, gain_low, gain_high))
[x_size, y_size] = self.camera.getCameraSize()
cam_params.add("x_start", params.ParameterRangeInt("AOI X start",
"x_start",
1, 1, x_size))
cam_params.add("x_end", params.ParameterRangeInt("AOI X end",
"x_end",
x_size, 1, x_size))
cam_params.add("y_start", params.ParameterRangeInt("AOI Y start",
"y_start",
1, 1, y_size))
cam_params.add("y_end", params.ParameterRangeInt("AOI Y end",
"y_end",
y_size, 1, y_size))
[x_max_bin, y_max_bin] = self.camera.getMaxBinning()
cam_params.add("x_bin", params.ParameterRangeInt("Binning in X",
"x_bin",
1, 1, x_max_bin))
cam_params.add("y_bin", params.ParameterRangeInt("Binning in Y",
"y_bin",
1, 1, y_max_bin))
# FIXME: Need to check if camera supports frame transfer mode.
cam_params.add("frame_transfer_mode", params.ParameterSetInt("Frame transfer mode (0 = off, 1 = on)",
"frame_transfer_mode",
1, [0, 1]))
[mint, maxt] = self.camera.getTemperatureRange()
cam_params.add("temperature", params.ParameterRangeInt("Temperature",
"temperature",
-70, mint, maxt))
preamp_gains = self.camera.getPreampGains()
cam_params.add("preampgain", params.ParameterSetFloat("Pre-amplifier gain",
"preampgain",
preamp_gains[0], preamp_gains))
# FIXME: Need to update based on the AD channel.
hs_speeds = self.camera.getHSSpeeds()[0]
cam_params.add("hsspeed", params.ParameterSetFloat("Horizontal shift speed",
"hsspeed",
hs_speeds[0], hs_speeds))
vs_speeds = self.camera.getVSSpeeds()
cam_params.add("vsspeed", params.ParameterSetFloat("Vertical shift speed",
"vsspeed",
vs_speeds[-1], vs_speeds))
max_exposure = self.camera.getMaxExposure()
cam_params.add("exposure_time", params.ParameterRangeFloat("Exposure time (seconds)",
"exposure_time",
0.0, 0.0, max_exposure))
cam_params.add("kinetic_cycle_time", params.ParameterRangeFloat("Kinetic cycle time (seconds)",
"kinetic_cycle_time",
0.0, 0.0, 100.0))
ad_channels = range(self.camera.getNumberADChannels())
cam_params.add("adchannel", params.ParameterSetInt("Analog to digital converter channel",
"adchannel",
0, ad_channels))
n_modes = range(self.camera.getNumberEMGainModes())
cam_params.add("emgainmode", params.ParameterSetInt("EMCCD gain mode",
"emgainmode",
0, n_modes))
cam_params.add("baselineclamp", params.ParameterSetBoolean("Baseline clamp",
"baselineclamp",
True))
# FIXME: Need to get amplitudes from the camera.
cam_params.add("vsamplitude", params.ParameterSetInt("Vertical shift amplitude",
"vsamplitude",
0, [0, 1, 2]))
cam_params.add("off_during_filming", params.ParameterSetBoolean("Fan off during filming",
"off_during_filming",
False))
cam_params.add("low_during_filming", params.ParameterSetBoolean("Fan low during filming",
"low_during_filming",
False))
cam_params.add("external_trigger", params.ParameterSetBoolean("Use an external camera trigger",
"external_trigger",
False))
cam_params.add("head_model", params.ParameterString("Camera head model", "head_model", "",
is_mutable = False))
cam_params.add("isolated_cropmode", params.ParameterSetBoolean("Isolated crop mode",
"isolated_cropmode",
False))
def __init__(self, hardware, parameters, parent):
QtGui.QDialog.__init__(self, parent)
halModule.HalModule.__init__(self)
self.channels = False
self.exp_channels = False
self.linear_channels = False
self.file_channels = False
self.parameters = parameters
self.use_was_checked = False
self.which_checked = []
# Add progression parameters.
self.parameters.add(
"progressions.use_progressions",
params.ParameterSetBoolean("",
"use_progressions",
False,
is_mutable=False))
self.parameters.add(
"progressions.pstart_value",
params.ParameterRangeFloat("",
"pstart_value",
0.1,
0.0,
1.0,
is_mutable=False,
is_saved=False))
self.parameters.add(
"progressions.pinc_value",
params.ParameterRangeFloat("",
"pinc_value",
0.01,
0.0,
1.0,
is_mutable=False,
is_saved=False))
self.parameters.add(
"progressions.pfile_name",
params.ParameterStringFilename("Progression file name",
"pfile_name", "", False))
self.parameters.add(
"progressions.pframe_value",
params.ParameterRangeInt("",
"pframe_value",
1000,
100,
100000,
is_mutable=False,
is_saved=False))
if parent:
self.have_parent = 1
else:
self.have_parent = 0
# UI setup
self.ui = progressionUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(
parameters.get("setup_name") + " Progression Control")
self.setWindowIcon(qtAppIcon.QAppIcon())
# connect signals
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
self.ui.progressionsCheckBox.stateChanged.connect(self.handleProgCheck)
self.ui.loadFileButton.clicked.connect(self.newPowerFile)
# set modeless
self.setModal(False)
def __init__(self, parameters, parent):
QtGui.QMainWindow.__init__(self, parent)
halModule.HalModule.__init__(self)
#self.setFocusPolicy(QtCore.Qt.ClickFocus)
self.directory = ""
self.drag_start_x = 0
self.drag_start_y = 0
self.move_timer = QtCore.QTimer()
self.stage_x = 0
self.stage_y = 0
self.stage_z = 0
self.tcp_message = False
self.translator = Translator()
# Add stage parameters.
parameters.add(
"stage.flip_axis",
params.ParameterSetBoolean("Switch X-Y stage axises", "flip_axis",
False))
parameters.add(
"stage.large_step_size",
params.ParameterRangeFloat("Large step size", "large_step_size",
25.0, 1.0, 500.0))
parameters.add(
"stage.small_step_size",
params.ParameterRangeFloat("Small step size", "small_step_size",
5.0, 1.0, 50.0))
parameters.add("stage.stage_speed", self.stage.getSpeed())
self.stage_speed = parameters.get("stage.stage_speed")
parameters.add(
"stage.x_sign",
params.ParameterSetInt("Reverse the sign of the X axis", "x_sign",
1, [-1, 1]))
parameters.add(
"stage.y_sign",
params.ParameterSetInt("Reverse the sign of the Y axis", "y_sign",
1, [-1, 1]))
if parent:
self.have_parent = True
else:
self.have_parent = False
# UI setup
self.ui = stageUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(parameters.get("setup_name") + " Stage Control")
self.setWindowIcon(qtAppIcon.QAppIcon())
# UI motion buttons.
icon_path = "./icons/"
self.motion_buttons = [
MotionButton(self.ui.leftSButton, icon_path + "1leftarrow-128.png",
"small", 1, 0),
MotionButton(self.ui.leftLButton, icon_path + "2leftarrow-128.png",
"large", 1, 0),
MotionButton(self.ui.rightSButton,
icon_path + "1rightarrow-128.png", "small", -1, 0),
MotionButton(self.ui.rightLButton,
icon_path + "2rightarrow-128.png", "large", -1, 0),
MotionButton(self.ui.upSButton, icon_path + "1uparrow-128.png",
"small", 0, 1),
MotionButton(self.ui.upLButton, icon_path + "2uparrow-128.png",
"large", 0, 1),
MotionButton(self.ui.downSButton,
icon_path + "1downarrow1-128.png", "small", 0, -1),
MotionButton(self.ui.downLButton, icon_path + "2dowarrow-128.png",
"large", 0, -1)
]
for button in self.motion_buttons:
button.buttonClicked.connect(self.moveRelative)
# Configure timer.
self.move_timer.setSingleShot(True)
self.move_timer.timeout.connect(self.handleMoveTimer)
# Connect signals.
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
self.ui.addButton.clicked.connect(self.handleAdd)
self.ui.clearButton.clicked.connect(self.handleClear)
self.ui.goButton.clicked.connect(self.handleGo)
self.ui.homeButton.clicked.connect(self.handleHome)
self.ui.loadButton.clicked.connect(self.handleLoad)
self.ui.saveButton.clicked.connect(self.handleSave)
self.ui.saveComboBox.activated.connect(self.handleSaveIndexChange)
self.ui.zeroButton.clicked.connect(self.zero)
# set modeless
self.setModal(False)
# open connection to the stage
if not (self.stage.getStatus()):
print "Failed to connect to the microscope stage. Perhaps it is turned off?"
self.stage.shutDown()
self.stage = False
else:
self.stage.updatePosition.connect(self.handleUpdatePosition)
self.stage.setVelocity(self.stage_speed, self.stage_speed)
def __init__(self, parameters, hardware_config):
# Create serial control thread
try:
self.serial_thread = W1SerialThread(
hardware_config.get("com_port"),
baudrate=115200,
timeout=0.01,
verbose=hardware_config.get("verbose", False))
except:
print "Could not create serial port for spinning disk. Is it connected properly?"
raise W1Exception("W1 Spinning Disk Initialization Error \n" +
" Could not properly initialize com_port: " +
str(hardware_config.get("com_port")))
# Connect error signal from serial control thread
self.serial_thread.error.connect(self.handleSerialThreadError)
# Start thread
self.serial_thread.start(QtCore.QThread.NormalPriority)
# Create a local copy of the current W1 configuration
self.params = params.StormXMLObject(
[]) # Create empty parameters object
# Record internal verbosity (debug purposes only)
self.verbose = hardware_config.get("verbose")
# Create dictionaries for the configuration of the filter wheels and two dichroic mirror sets
self.filter_wheel_1_config = {}
values = hardware_config.get("filter_wheel_1")
filter_names = values.split(",")
for pos, filter_name in enumerate(filter_names):
self.filter_wheel_1_config[filter_name] = pos + 1
self.filter_wheel_2_config = {}
values = hardware_config.get("filter_wheel_2")
filter_names = values.split(",")
for pos, filter_name in enumerate(filter_names):
self.filter_wheel_2_config[filter_name] = pos + 1
self.dichroic_mirror_config = {}
values = hardware_config.get("dichroic_mirror")
dichroic_names = values.split(",")
for pos, dichroic_name in enumerate(dichroic_names):
self.dichroic_mirror_config[dichroic_name] = pos + 1
self.camera_dichroic_config = {}
values = hardware_config.get("camera_dichroic")
camera_dichroic_names = values.split(",")
for pos, camera_dichroic in enumerate(camera_dichroic_names):
self.camera_dichroic_config[camera_dichroic] = pos + 1
# Define error codes
self.error_codes = {
"30005": "Command name error",
"30006": "Command argument number error",
"30007": "Command argument value error",
"30141": "Command argument value error",
"30012": "Interlock alarm is on",
"30133": "Interlock alarm is on",
"30014": "Electricity alarm is on",
"30015": "Shutter alarm is on",
"30016": "Actuator alarm is on",
"30017": "Disk alarm is on",
"30018": "Data error alarm is on",
"30019": "Other alarm is on",
"30021": "Designated system is not defined",
"30022": "Designated system does not exist",
"30023": "Designated system is not detected",
"30031": "Waiting for initialization to complete",
"30032": "Under maintenance mode",
"30201": "External SYNC signal is under use",
"30204": "Disk rotation stopped",
"30301": "Shutter error",
"30302": "Shutter unopenable error",
"1": "Unknown serial communication error"
}
# Initialize spinning disk parameters
# Add spinning disk sub section
sd_params = parameters.addSubSection("spinning_disk")
# Add basic parameters
sd_params.add(
"bright_field_bypass",
params.ParameterSetBoolean(
"Bypass spinning disk for brightfield mode?",
"bright_field_bypass", False))
sd_params.add(
"spin_disk",
params.ParameterSetBoolean("Spin the disk?", "spin_disk", True))
# Disk properties
sd_params.add(
"disk",
params.ParameterSetString(
"Disk pinhole size", "disk", "50-micron pinholes",
["50-micron pinholes", "25-micron pinholes"]))
max_speed = self.getMaxSpeed()
sd_params.add(
"disk_speed",
params.ParameterRangeInt("Disk speed (RPM)", "disk_speed",
max_speed, 1, max_speed))
# Dichroic mirror position
values = sorted(self.dichroic_mirror_config.keys())
sd_params.add(
"dichroic_mirror",
params.ParameterSetString("Dichroic mirror position",
"dichroic_mirror", values[0], values))
# Filter wheel positions
values = sorted(self.filter_wheel_1_config.keys())
sd_params.add(
"filter_wheel_pos1",
params.ParameterSetString("Camera 1 Filter Wheel Position (1-10)",
"filter_wheel_pos1", values[0], values))
values = sorted(self.filter_wheel_2_config.keys())
sd_params.add(
"filter_wheel_pos2",
params.ParameterSetString("Camera 2 Filter Wheel Position (1-10)",
"filter_wheel_pos2", values[0], values))
# Camera dichroic positions
values = sorted(self.camera_dichroic_config.keys())
sd_params.add(
"camera_dichroic_mirror",
params.ParameterSetString("Camera dichroic mirror position (1-3)",
"camera_dichroic_mirror", values[0],
values))
# Aperature settings
sd_params.add(
"aperture",
params.ParameterRangeInt("Aperture value (1-10; small to large)",
"aperture", 10, 1, 10))
def __init__(self, hardware, parameters, parent = None):
cameraControl.HWCameraControl.__init__(self, hardware, parameters, parent)
andor.loadSDK3DLL("C:/Program Files/Andor SOLIS/")
if hardware:
self.camera = andor.SDK3Camera(hardware.get("camera_id", 0))
else:
self.camera = andor.SDK3Camera()
self.camera.setProperty("CycleMode", "enum", "Continuous")
self.parameters = params.StormXMLObject([]) # Create empty parameters object
# Add Andor SDK3 specific parameters.
#
cam_params = parameters.get("camera1")
max_intensity = 2**16
cam_params.add("max_intensity", params.ParameterInt("",
"max_intensity",
max_intensity,
is_mutable = False,
is_saved = False))
## [x_size, y_size] = [2048, 2048]
## cam_params.add("x_start", params.ParameterRangeInt("AOI X start",
## "x_start",
## 1, 1, x_size))
## cam_params.add("x_end", params.ParameterRangeInt("AOI X end",
## "x_end",
## x_size, 1, x_size))
## cam_params.add("y_start", params.ParameterRangeInt("AOI Y start",
## "y_start",
## 1, 1, y_size))
## cam_params.add("y_end", params.ParameterRangeInt("AOI Y end",
## "y_end",
## y_size, 1, y_size))
##
## [x_max_bin, y_max_bin] = [4,4]
## cam_params.add("x_bin", params.ParameterRangeInt("Binning in X",
## "x_bin",
## 1, 1, x_max_bin))
## cam_params.add("y_bin", params.ParameterRangeInt("Binning in Y",
## "y_bin",
## 1, 1, y_max_bin))
cam_params.add("AOIBinning", params.ParameterSetString("AOI Binning",
"AOIBinning",
"1x1",
["1x1", "2x2", "3x3", "4x4", "8x8"]))
cam_params.add("AOIWidth", params.ParameterRangeInt("AOI Width",
"AOIWidth",
2048,
128, 2048))
cam_params.add("AOIHeight", params.ParameterRangeInt("AOI Height",
"AOIHeight",
2048,
128, 2048))
cam_params.add("AOILeft", params.ParameterRangeInt("AOI Left",
"AOILeft",
1,
1, 1028))
cam_params.add("AOITop", params.ParameterRangeInt("AOI Top",
"AOITop",
1,
1, 1028))
cam_params.add("FanSpeed", params.ParameterSetString("Fan Speed",
"FanSpeed",
"On",
["On", "Off"]))
cam_params.add("SensorCooling", params.ParameterSetBoolean("Sensor cooling",
"SensorCooling",
True))
cam_params.add("SimplePreAmpGainControl", params.ParameterSetString("Pre-amp gain control",
"SimplePreAmpGainControl",
"16-bit (low noise & high well capacity)",
["16-bit (low noise & high well capacity)",
"Something else.."]))
cam_params.add("ExposureTime", params.ParameterRangeFloat("Exposure time (seconds)",
"ExposureTime",
0.1, 0.0, 10.0))
def __init__(self, hardware, parameters, parent=None):
miscControl.MiscControl.__init__(self, parameters, parent)
self.em_filter_pos = 0
self.em_filter_wheel = filterWheel.QPriorFilterWheel()
self.filter_wheel = filterWheel.QPriorFilterWheel()
# Add parameters.
misc_params = parameters.addSubSection("misc")
misc_params.add(
"filter_names",
params.ParameterString("Filter names", "filter_names",
"1,2,3,4,5,6"))
misc_params.add(
"filter_position",
params.ParameterRangeInt("Filter position", "filter_position", 0,
0, 5))
misc_params.add(
"em_checked",
params.ParameterSetBoolean(
"Change emission filter position during filming", "em_checked",
False))
misc_params.add(
"em_filter",
params.ParameterRangeInt("Emission filter position", "em_filter",
0, 0, 5))
misc_params.add(
"em_period",
params.ParameterInt("Emission filter update period in frames",
"em_period", 60))
# UI setup
self.ui = miscControlsUi.Ui_Dialog()
self.ui.setupUi(self)
self.setWindowTitle(parameters.get("setup_name") + " Misc Control")
# connect signals
if self.have_parent:
self.ui.okButton.setText("Close")
self.ui.okButton.clicked.connect(self.handleOk)
else:
self.ui.okButton.setText("Quit")
self.ui.okButton.clicked.connect(self.handleQuit)
# setup (turret) filter wheel
self.filters = [
self.ui.filter1Button, self.ui.filter2Button,
self.ui.filter3Button, self.ui.filter4Button,
self.ui.filter5Button, self.ui.filter6Button
]
for afilter in self.filters:
afilter.clicked.connect(self.handleFilter)
if self.filter_wheel:
self.filters[self.filter_wheel.getPosition(1) - 1].click()
# setup (emission) filter wheel
self.ui.emFilter6Button.hide()
self.ui.emFilter7Button.hide()
self.ui.emFilter8Button.hide()
self.ui.emFilter9Button.hide()
self.ui.emFilter10Button.hide()
self.em_filters = [
self.ui.emFilter1Button, self.ui.emFilter2Button,
self.ui.emFilter3Button, self.ui.emFilter4Button,
self.ui.emFilter5Button, self.ui.emFilter6Button,
self.ui.emFilter7Button, self.ui.emFilter8Button,
self.ui.emFilter9Button, self.ui.emFilter10Button
]
for afilter in self.em_filters:
afilter.clicked.connect(self.handleEmFilter)
if self.em_filter_wheel:
self.em_filters[self.filter_wheel.getPosition(2) - 1].click()
self.ui.emCheckBox.setChecked(parameters.get("misc.em_checked"))
self.ui.emSpinBox.setValue(parameters.get("misc.em_period"))
