def addParameters(parameters):
"""
Add parameters specific to staying in lock.
"""
p = parameters.addSubSection(LockedMixin.lm_pname)
p.add(params.ParameterInt(description = "Number of repeats for the lock to be considered good.",
name = "buffer_length",
value = 5))
p.add(params.ParameterRangeFloat(description = "Lock response gain (near target offset).",
name = "lock_gain",
value = 0.5,
min_value = 0.0,
max_value = 1.0))
p.add(params.ParameterRangeFloat(description = "Lock response maximum gain (far from target offset).",
name = "lock_gain_max",
value = 0.7,
min_value = 0.0,
max_value = 1.0))
p.add(params.ParameterFloat(description = "Maximum allowed difference to still be in lock (nm).",
name = "offset_threshold",
value = 20.0))
p.add(params.ParameterFloat(description = "Minimum sum to be considered locked (AU).",
name = "minimum_sum",
value = -1.0))
def addParameters(parameters):
"""
Add parameters specific to scan mode.
"""
p = parameters.addSubSection(ScanMixin.sm_pname)
p.add(
params.ParameterFloat(
description="Minimum sum for finding the correct offset (AU).",
name="minimum_sum",
value=-1.0))
p.add(
params.ParameterFloat(
description=
"Maximum allowed difference for finding the correct offset (nm).",
name="offset_threshold",
value=100.0))
p.add(
params.ParameterFloat(description="Scan range in microns.",
name="scan_range",
value=10.0))
p.add(
params.ParameterFloat(description="Scan step size in microns.",
name="scan_step",
value=0.05))
def addParameters(parameters):
"""
Add parameters specific to staying in lock.
"""
p = parameters.addSubSection(LockedMixin.lm_pname)
p.add(params.ParameterInt(description = "Number of repeats for the lock to be considered good.",
name = "buffer_length",
value = 5))
p.add(params.ParameterFloat(description = "Maximum allowed difference to still be in lock (nm).",
name = "offset_threshold",
value = 20.0))
p.add(params.ParameterFloat(description = "Minimum sum to be considered locked (AU).",
name = "minimum_sum",
value = -1.0))
def __init__(self, configuration=None, **kwds):
super().__init__(**kwds)
self.current_mode = None
self.modes = []
self.parameters = params.StormXMLObject()
self.ui = focuslockUi.Ui_Dialog()
self.ui.setupUi(self)
# Add parameters
self.parameters.add(
params.ParameterFloat(description="Z stage jump size",
name="jump_size",
value=0.1))
# Set up lock display.
self.lock_display = lockDisplay.LockDisplay(
configuration=configuration, jump_signal=self.jump, parent=self)
layout = QtWidgets.QGridLayout(self.ui.lockDisplayWidget)
layout.setContentsMargins(0, 0, 0, 0)
layout.addWidget(self.lock_display)
# Configure modes.
lockModes.FindSumMixin.addParameters(self.parameters)
lockModes.LockedMixin.addParameters(self.parameters)
lockModes.ScanMixin.addParameters(self.parameters)
for mode_class_name in configuration.get("lock_modes").split(","):
a_class = getattr(lockModes, mode_class_name.strip())
a_object = a_class(parameters=self.parameters, parent=self)
self.ui.modeComboBox.addItem(a_object.getName())
self.modes.append(a_object)
# Set parameters values based on the config file parameters.
c_params = configuration.get("parameters")
for attr in params.difference(c_params, self.parameters):
print(attr, c_params.get(attr))
self.parameters.setv(attr, c_params.get(attr))
self.newParameters(self.parameters)
# Connect signals.
self.ui.jumpNButton.clicked.connect(self.handleJumpNButton)
self.ui.jumpPButton.clicked.connect(self.handleJumpPButton)
self.ui.lockButton.clicked.connect(self.handleLockButton)
self.ui.lockTargetSpinBox.valueChanged.connect(self.handleLockTarget)
self.ui.modeComboBox.currentIndexChanged.connect(
self.handleModeComboBox)
self.setEnabled(False)
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("timing"):
self.control.setTimingFunctionality(
message.getData()["properties"]["functionality"])
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Focus Lock",
"item data": "focus lock"
}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.view.getParameters()}))
elif message.isType("configure2"):
# Get functionalities. Do this here because the modules that provide these functionalities
# will likely need functionalities from other modules. The IR laser for example might
# need a functionality from a DAQ module.
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name":
self.configuration.get("ir_laser"),
"extra data":
"ir_laser"
}))
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name":
self.configuration.get("qpd"),
"extra data": "qpd"
}))
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name":
self.configuration.get("z_stage"),
"extra data": "z_stage"
}))
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"old parameters": self.view.getParameters().copy()}))
self.view.newParameters(p.get(self.module_name))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.view.getParameters()}))
elif message.isType("show"):
if (message.getData()["show"] == "focus lock"):
self.view.show()
elif message.isType("start"):
self.view.start()
self.control.start()
if message.getData()["show_gui"]:
self.view.showIfVisible()
elif message.isType("start film"):
self.control.startFilm(message.getData()["film settings"])
elif message.isType("stop film"):
self.control.stopFilm()
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.view.getParameters().copy()}))
lock_good = params.ParameterSetBoolean(
name="good_lock", value=self.control.isGoodLock())
lock_mode = params.ParameterString(
name="lock_mode", value=self.control.getLockModeName())
lock_sum = params.ParameterFloat(
name="lock_sum", value=self.control.getQPDSumSignal())
lock_target = params.ParameterFloat(
name="lock_target", value=self.control.getLockTarget())
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={
"acquisition":
[lock_good, lock_mode, lock_sum, lock_target]
}))
elif message.isType("tcp message"):
# See control handles this message.
handled = self.control.handleTCPMessage(message)
# If not, check view.
if not handled:
handled = self.view.handleTCPMessage(message)
# Mark if we handled the message.
if handled:
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={"handled": True}))
def createParameters(self, cam_fn, parameters_from_file):
"""
Create (initial) parameters for the current feed.
cam_fn - A camera / feed functionality object.
parameters_from_file - The parameters that were read from the XML file.
"""
# Check that we are not writing over something that already exists.
if (self.parameters.has(self.getFeedName())):
msg = "Display parameters for " + self.getFeedName() + " already exists."
raise halExceptions.HalException(msg)
# Create a sub-section for this camera / feed.
p = self.parameters.addSubSection(self.getFeedName())
# Add display specific parameters.
p.add(params.ParameterFloat(name = "center_x",
value = 0.0,
is_mutable = False))
p.add(params.ParameterFloat(name = "center_y",
value = 0.0,
is_mutable = False))
p.add(params.ParameterSetString(description = "Color table",
name = "colortable",
value = self.color_tables.getColorTableNames()[0],
allowed = self.color_tables.getColorTableNames()))
p.add(params.ParameterInt(description = "Display maximum",
name = "display_max",
value = 100))
p.add(params.ParameterInt(description = "Display minimum",
name = "display_min",
value = 0))
p.add(params.ParameterSetBoolean(name = "initialized",
value = False,
is_mutable = False))
p.add(params.ParameterInt(name = "max_intensity",
value = 100,
is_mutable = False,
is_saved = False))
p.add(params.ParameterInt(name = "scale",
value = 0,
is_mutable = False))
p.add(params.ParameterInt(description = "Frame to display when filming with a shutter sequence",
name = "sync",
value = 0))
# Set parameters with default values from feed/camera functionality
if cam_fn.hasParameter("colortable"):
p.setv("colortable", cam_fn.getParameter("colortable"))
else:
p.setv("colortable", self.default_colortable)
p.setv("display_max", cam_fn.getParameter("default_max"))
p.setv("display_min", cam_fn.getParameter("default_min"))
p.setv("max_intensity", cam_fn.getParameter("max_intensity"))
# If they exist, update with the values that we loaded from a file.
# Also, some parameters files will have 'extra' parameters, typically
# sub-sections for the different feeds. We skip these here as this
# will be handled when we change to the feed and call the
# setCameraFunctionality() method.
#
if parameters_from_file is not None:
for attr in parameters_from_file.getAttrs():
if p.has(attr):
p.setv(attr, parameters_from_file.get(attr))
def __init__(self, camera_name=None, config=None, **kwds):
"""
camera_name - This is the name of this camera's section in the config XML file.
config - These are the values in the parameters section as a StormXMLObject().
"""
super().__init__(**kwds)
# This is the hardware module that will actually control the camera.
self.camera = None
# Sub-classes should set this to a CameraFunctionality object.
self.camera_functionality = None
self.camera_name = camera_name
# This is a flag for whether or not the camera is in a working state.
# It might not be if for example the parameters were bad.
self.camera_working = True
# The length of a fixed length film.
self.film_length = None
# The current frame number, this gets reset by startCamera().
self.frame_number = 0
# The camera parameters.
self.parameters = params.StormXMLObject()
# This is how we tell the thread that is handling actually talking
# to the camera hardware to stop.
self.running = False
# This is how we know that the camera thread that is talking to the
# camera actually started.
self.thread_started = False
#
# These are the minimal parameters that every camera must provide
# to work with HAL.
#
# The exposure time.
self.parameters.add(
params.ParameterFloat(description="Exposure time (seconds)",
name="exposure_time",
value=1.0))
# This is frames per second as reported by the camera. It is used
# for hardware timed waveforms (if any).
self.parameters.add(
params.ParameterFloat(name="fps", value=0, is_mutable=False))
#
# Chip size, ROI of the chip and the well depth.
#
x_size = 256
y_size = 256
self.parameters.add(
params.ParameterInt(name="x_chip",
value=x_size,
is_mutable=False,
is_saved=False))
self.parameters.add(
params.ParameterInt(name="y_chip",
value=y_size,
is_mutable=False,
is_saved=False))
self.parameters.add(
params.ParameterInt(name="max_intensity",
value=128,
is_mutable=False,
is_saved=False))
#
# Note: These are all expected to be in units of binned pixels. For
# example if the camera is 512 x 512 and we are binning by 2s then
# the maximum value of these would 256 x 256.
#
self.parameters.add(
params.ParameterRangeInt(description="AOI X start",
name="x_start",
value=1,
min_value=1,
max_value=x_size))
self.parameters.add(
params.ParameterRangeInt(description="AOI X end",
name="x_end",
value=x_size,
min_value=1,
max_value=x_size))
self.parameters.add(
params.ParameterRangeInt(description="AOI Y start",
name="y_start",
value=1,
min_value=1,
max_value=y_size))
self.parameters.add(
params.ParameterRangeInt(description="AOI Y end",
name="y_end",
value=y_size,
min_value=1,
max_value=y_size))
self.parameters.add(
params.ParameterInt(name="x_pixels", value=0, is_mutable=False))
self.parameters.add(
params.ParameterInt(name="y_pixels", value=0, is_mutable=False))
self.parameters.add(
params.ParameterRangeInt(description="Binning in X",
name="x_bin",
value=1,
min_value=1,
max_value=4))
self.parameters.add(
params.ParameterRangeInt(description="Binning in Y",
name="y_bin",
value=1,
min_value=1,
max_value=4))
# Frame size in bytes.
self.parameters.add(
params.ParameterInt(name="bytes_per_frame",
value=x_size * y_size * 2,
is_mutable=False,
is_saved=False))
#
# How/if data from this camera is saved.
#
self.parameters.add(
params.ParameterString(
description="Camera save filename extension",
name="extension",
value=""))
self.parameters.add(
params.ParameterSetBoolean(
description="Save data from this camera when filming",
name="saved",
value=True))
self.parameters.set("extension", config.get("extension", ""))
self.parameters.set("saved", config.get("saved", True))
#
# Camera display orientation. Values can only be changed by
# changing the config.xml file.
#
self.parameters.add(
params.ParameterSetBoolean(name="flip_horizontal",
value=False,
is_mutable=False))
self.parameters.add(
params.ParameterSetBoolean(name="flip_vertical",
value=False,
is_mutable=False))
self.parameters.add(
params.ParameterSetBoolean(name="transpose",
value=False,
is_mutable=False))
self.parameters.set("flip_horizontal",
config.get("flip_horizontal", False))
self.parameters.set("flip_vertical",
config.get("flip_vertical", False))
self.parameters.set("transpose", config.get("transpose", False))
#
# Camera default display minimum and maximum.
#
# These are the values the display will use by default. They can
# only be changed by changing the config.xml file.
#
self.parameters.add(
params.ParameterInt(name="default_max",
value=2000,
is_mutable=False))
self.parameters.add(
params.ParameterInt(name="default_min",
value=100,
is_mutable=False))
self.parameters.set("default_max", config.get("default_max", 2000))
self.parameters.set("default_min", config.get("default_min", 100))
self.finished.connect(self.handleFinished)
self.newData.connect(self.handleNewData)