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)
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, 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, feed_name, parent=None):
QtGui.QFrame.__init__(self, parent)
# General (alphabetically ordered).
self.color_gradient = 0
self.color_table = 0
self.color_tables = colorTables.ColorTables(
"./colorTables/all_tables/")
self.cycle_length = 0
self.display_timer = QtCore.QTimer(self)
self.feed_controller = False
self.feed_name = feed_name
self.filming = False
self.frame = False
self.max_intensity = parameters.get("max_intensity")
self.parameters = parameters
self.show_grid = 0
self.show_info = 1
self.show_target = 0
self.sync_value = 0
self.sync_values_by_feedname = None
self.sync_values_by_params = {}
#
# Add display specific parameters, if they are not already present.
#
# Note these parameters are feed specific and not display specific so two
# different viewers that are displaying the same feed will be changing
# the same parameters.
#
if not self.parameters.has("colortable"):
self.parameters.add(
"colortable",
params.ParameterSetString(
"Color table", "colortable", "idl5.ctbl",
self.color_tables.getColorTableNames()))
self.parameters.add(
"drag_multiplier",
params.ParameterFloat("",
"drag_multiplier",
0.16,
is_mutable=False,
is_saved=False))
self.parameters.add(
"scalemax",
params.ParameterInt("", "scalemax", 2000, is_mutable=False))
self.parameters.add(
"scalemin",
params.ParameterInt("", "scalemin", 100, is_mutable=False))
self.parameters.add("sync", 0)
# UI setup.
self.ui = cameraDisplayUi.Ui_Frame()
self.ui.setupUi(self)
self.ui.cameraScrollArea.setStyleSheet(
"QScrollArea { background-color: black } ")
self.ui.rangeSlider = qtRangeSlider.QVRangeSlider()
layout = QtGui.QGridLayout(self.ui.rangeSliderWidget)
layout.setMargin(1)
layout.addWidget(self.ui.rangeSlider)
self.ui.rangeSliderWidget.setLayout(layout)
self.ui.rangeSlider.setRange([0.0, self.max_intensity, 1.0])
self.ui.rangeSlider.setEmitWhileMoving(True)
for color_name in self.color_tables.getColorTableNames():
self.ui.colorComboBox.addItem(color_name[:-5])
self.ui.gridAct = QtGui.QAction(self.tr("Show Grid"), self)
self.ui.infoAct = QtGui.QAction(self.tr("Hide Info"), self)
self.ui.targetAct = QtGui.QAction(self.tr("Show Target"), self)
self.ui.cameraShutterButton.hide()
self.ui.recordButton.hide()
self.ui.syncLabel.hide()
self.ui.syncSpinBox.hide()
# Camera display widget.
#
# This is probably not the best way to do this, but the goal is to have the feed viewers
# use the same display widget as the camera viewers. Knowing that the camera viewers
# will get initialized first we save what widget they used as a global variable in this
# module. Then when we go to create a feed viewers (where hardware will be None), we
# get the widget from this global variable.
#
if hardware is not None:
display_module = hardware.get("module_name")
a_module = __import__('display.' + display_module, globals(),
locals(), [display_module], -1)
a_class = getattr(a_module, hardware.get("class_name"))
global default_widget
default_widget = a_class
else:
a_class = default_widget
self.camera_widget = a_class(parameters, self.ui.cameraScrollArea)
self.ui.cameraScrollArea.setWidget(self.camera_widget)
self.camera_widget.intensityInfo.connect(self.handleIntensityInfo)
self.ui.autoScaleButton.clicked.connect(self.handleAutoScale)
self.ui.colorComboBox.currentIndexChanged[str].connect(
self.handleColorTableChange)
self.ui.feedComboBox.currentIndexChanged[str].connect(
self.handleFeedChange)
self.ui.gridAct.triggered.connect(self.handleGrid)
self.ui.infoAct.triggered.connect(self.handleInfo)
self.ui.rangeSlider.doubleClick.connect(self.handleAutoScale)
self.ui.rangeSlider.rangeChanged.connect(self.handleRangeChange)
self.ui.syncSpinBox.valueChanged.connect(self.handleSync)
self.ui.targetAct.triggered.connect(self.handleTarget)
# Display timer
self.display_timer.setInterval(100)
self.display_timer.timeout.connect(self.displayFrame)
self.display_timer.start()