def processMessage(self, message):
if message.isType("configure1"):
self.sendMessage(halMessage.HalMessage(m_type = "add to menu",
data = {"item name" : "Z Stage",
"item data" : "z stage"}))
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : self.configuration.get("z_stage_fn")}))
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.view.getParameters()}))
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"] == "z stage"):
self.view.show()
elif message.isType("start"):
if message.getData()["show_gui"]:
self.view.showIfVisible()
def getFunctionality(self, message):
if (message.getData()["name"] == self.module_name + ".stage"):
if self.stage_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.stage_functionality}))
elif (message.getData()["name"] == self.module_name + ".focus"):
if self.focus_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.focus_functionality}))
elif (message.getData()["name"] == self.module_name +
".filter_wheel1"):
if self.fwheel1_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.fwheel1_functionality}))
elif (message.getData()["name"] == self.module_name +
".filter_wheel2"):
if self.fwheel2_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.fwheel2_functionality}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("stage"):
stage_fn_name = message.getData()["properties"]["stage functionality name"]
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : stage_fn_name,
"extra data" : "stage_fn"}))
elif message.isType("configure1"):
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.control.getParameters()}))
elif message.isType("film lockout"):
# This means that filming has started (True), or stopped (False).
self.filming = message.getData()["locked out"]
# HAL has responded so we can stop ignoring the film button.
self.waiting_for_film = False
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.control.getParameters().copy()}))
self.control.newParameters(p.get(self.module_name))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.control.getParameters()}))
elif message.isType("stop film"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.control.getParameters()}))
def updateParameters(self, message):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.camera_control.getParameters().copy()}))
p = message.getData()["parameters"].get(self.module_name)
self.camera_control.newParameters(p)
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.camera_control.getParameters()}))
def processMessage(self, message):
if message.isType("configure1"):
# Initial UI configuration.
self.view.setObjectiveText(getObjectiveName(self.parameters))
# Add view to HAL UI display.
self.sendMessage(halMessage.HalMessage(m_type = "add to ui",
data = self.configure_dict))
# Broadcast initial parameters.
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.parameters}))
# Broadcast initial pixel size.
self.sendPixelSize(getObjectivePixelSize(self.parameters))
elif message.isType("new parameters"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.parameters.copy()}))
# Update parameters.
p = message.getData()["parameters"].get(self.module_name)
if (self.parameters.get("objective") != p.get("objective")):
objective = p.get("objective")
self.parameters.setv("objective", objective)
self.view.setObjectiveText(getObjectiveName(self.parameters))
self.sendPixelSize(getObjectivePixelSize(self.parameters))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.parameters}))
elif message.isType("stop film"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.parameters}))
elif message.isType("tcp message"):
tcp_message = message.getData()["tcp message"]
if tcp_message.isType("Get Mosaic Settings"):
if not tcp_message.isTest():
i = 1
pname = "obj" + str(i)
while self.parameters.has(pname):
tcp_message.addResponse(pname, self.parameters.get(pname))
i += 1
pname = "obj" + str(i)
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"handled" : True}))
elif tcp_message.isType("Get Objective"):
if not tcp_message.isTest():
obj_data = self.parameters.get(self.parameters.get("objective"))
tcp_message.addResponse("objective", obj_data.split(",")[0])
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"handled" : True}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("focuslock"):
qpd_fn_name = message.getData(
)["properties"]["qpd functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": qpd_fn_name,
"extra data": "qpd_fn"
}))
elif message.sourceIs("stage"):
stage_fn_name = message.getData(
)["properties"]["stage functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": stage_fn_name,
"extra data": "stage_fn"
}))
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": "display",
"extra data":
"camera_frame_viewer_fn"
}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.bt_control.getParameters()}))
elif message.isType("film lockout"):
if message.getData()["locked out"]:
self.bt_control.startFilm()
else:
self.bt_control.stopFilm()
elif message.isType("new parameters"):
p = message.getData()["parameters"]
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={
"old parameters":
self.bt_control.getParameters().copy()
}))
self.bt_control.newParameters(p.get(self.module_name))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.bt_control.getParameters()}))
def processMessage(self, message):
if message.isType("change directory"):
self.view.setDirectory(message.getData()["directory"])
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Stage",
"item data": "stage"
}))
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={"name": self.stage_fn_name}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.view.getParameters()}))
self.sendMessage(
halMessage.HalMessage(m_type="configuration",
data={
"properties": {
"stage functionality name":
self.stage_fn_name
}
}))
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"] == "stage"):
self.view.show()
elif message.isType("start"):
if message.getData()["show_gui"]:
self.view.showIfVisible()
elif message.isType("stop film"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.view.getParameters()}))
def tcpMessage(self, message):
tcp_message = message.getData()["tcp message"]
if tcp_message.isType("Move Stage"):
if tcp_message.isTest():
tcp_message.addResponse("duration", 1)
else:
#
# We don't want HAL to finalize this message until
# the stage has finished the move.
#
message.incRefCount()
#
# Create a TCPMoveHandler object. This object will store the message until
# the stage sends a signal that it is no longer moving.
#
tcp_move_handler = TCPMoveHandler(
hal_message=message,
stage_functionality=self.stage_functionality,
watchdog_timeout=self.watchdog_timeout)
self.stage_functionality.isMoving.connect(
tcp_move_handler.handleIsMoving)
#
# Tell the stage to move.
#
self.stage_functionality.goAbsolute(
tcp_message.getData("stage_x"),
tcp_message.getData("stage_y"))
#
# FIXME: After the move we need some way to gaurantee that the stage
# reports it's current position, which is hopefully where it
# was told to go, and not some stale position. This will be a
# problem if the movies are so short that the stages updateTimer()
# does not get a chance to go off before we finish taking the
# film. However, maybe we don't want to wait the X milliseconds
# it would take the stage to update? For TCP moves just return
# the position where the stage should be?
#
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={"handled": True}))
elif tcp_message.isType("Get Stage Position"):
if not tcp_message.isTest():
pos_dict = self.stage_functionality.getCurrentPosition()
tcp_message.addResponse("stage_x", pos_dict["x"])
tcp_message.addResponse("stage_y", pos_dict["y"])
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={"handled": True}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("feeds"):
cur_time_base = self.parameters.get("time_base")
self.parameters.getp("time_base").setAllowed(message.getData()["properties"]["feed names"])
self.parameters.setv("time_base", cur_time_base)
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.parameters}))
# Let film.film know that it needs to wait for us
# to get ready before starting the cameras.
self.sendMessage(halMessage.HalMessage(m_type = "wait for",
data = {"module names" : ["film"]}))
elif message.isType("new parameters"):
#
# FIXME: The problem is that we won't know the allowed set of feed names until
# feeds.feeds sends the 'configuration' message. Using the old allowed
# might cause a problem as the new time base might not exist in the
# old allowed. For now we are just setting allowed to be whatever the
# time_base parameter value is. Then at 'feed names' we check that
# that the parameter is valid. If it is not valid this will break HAL
# at an unexpected point, the error should have been detected in
# 'new parameters'. Also the editor won't work because the version of the
# parameter that it has only allows one value. Somehow we need to know
# the valid feed names at the new parameter stage..
#
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.parameters.copy()}))
p = message.getData()["parameters"].get(self.module_name)
self.setAllowed([p.get("time_base")])
self.parameters.setv("time_base", p.get("time_base"))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.parameters}))
elif message.isType("start film"):
self.timing_functionality = TimingFunctionality(time_base = self.parameters.get("time_base"))
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : self.timing_functionality.getTimeBase()}))
elif message.isType("stop film"):
self.timing_functionality.disconnectCameraFunctionality()
self.timing_functionality = None
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.parameters.copy()}))
def getFunctionality(self, message):
fn_name = message.getData()["name"]
if (fn_name in self.aotf_channel_fns):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.aotf_channel_fns[fn_name]}))
def getFunctionality(self, message):
daq_fn_name = message.getData()["name"]
if daq_fn_name in self.daq_fns:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.daq_fns[daq_fn_name]}))
def processMessage(self, message):
if message.isType("get functionality"):
if (message.getData()["name"] == self.module_name):
if self.z_stage_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(source = self.module_name,
data = {"functionality" : self.z_stage_functionality}))
def getFunctionality(self, message):
if (message.getData()["name"]
== self.module_name) and (self.laser_functionality
is not None):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.laser_functionality}))
def stopFilm(self, message):
self.stage_functionality.mustRun(task = self.stage.joystickOnOff,
args = [True])
pos_dict = self.stage_functionality.getCurrentPosition()
pos_string = "{0:.2f},{1:.2f}".format(pos_dict["x"], pos_dict["y"])
pos_param = params.ParameterCustom(name = "stage_position",
value = pos_string)
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"acquisition" : [pos_param]}))
def processMessage(self, message):
if message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(
m_type="get functionality",
data={"name": self.configuration.get("ai_fn_name")}))
elif message.isType("get functionality"):
if (message.getData()["name"] == self.module_name):
if self.qpd_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.qpd_functionality}))
def processMessage(self, message):
if message.isType("add to menu"):
self.view.addMenuItem(message.getData()["item name"],
message.getData()["item data"])
elif message.isType("add to ui"):
[module, parent_widget] = message.getData()["ui_parent"].split(".")
if (module == self.module_name):
self.view.addUiWidget(parent_widget,
message.getData()["ui_widget"],
message.getData().get("ui_order"))
elif message.isType("change directory"):
self.view.setFilmDirectory(message.getData()["directory"])
elif message.isType("start"):
if message.getData()["show_gui"]:
self.view.addMenuItems()
self.view.addWidgets()
self.view.show()
self.sendMessage(
halMessage.HalMessage(
m_type="change directory",
data={"directory": self.view.getFilmDirectory()}))
elif message.isType("start film"):
self.view.startFilm(message.getData()["film settings"])
elif message.isType("stop film"):
self.view.stopFilm()
notes_param = params.ParameterString(
name="notes", value=self.view.getNotesEditText())
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"acquisition": [notes_param]}))
elif message.isType("tests done"):
self.view.close()
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("timing"):
self.galvo_functionality.setTimingFunctionality(
message.getData()["properties"]["functionality"])
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(
m_type="get functionality",
data={"name": self.configuration.get("ao_fn_name")}))
elif message.isType("get functionality"):
if (message.getData()["name"] == self.module_name):
if self.galvo_functionality is not None:
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.galvo_functionality}))
elif message.isType("start film"):
self.galvo_functionality.startFilm(
message.getData()["film settings"])
def getFunctionality(self, message):
if message.getData()["name"] in self.functionalities:
fn = self.functionalities[message.getData()["name"]]
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"functionality" : fn}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("feeds"):
feed_names = message.getData()["properties"]["feed names"]
for viewer in self.viewers:
viewer.setFeedNames(feed_names)
elif message.sourceIs("illumination"):
shutters_info = message.getData(
)["properties"]["shutters info"]
for viewer in self.viewers:
viewer.setSyncMax(shutters_info.getFrames())
elif message.sourceIs("stage"):
stage_fn_name = message.getData(
)["properties"]["stage functionality name"]
self.sendMessage(
halMessage.HalMessage(m_type="get functionality",
data={
"name": stage_fn_name,
"extra data": "stage_fn"
}))
elif message.isType("configure1"):
# The ClassicViewer might need to tell other modules to
# incorporate some of it's UI elements.
self.viewers[0].configure1()
# Add a menu option(s) to generate more viewers.
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Feed Viewer",
"item data": "new feed viewer"
}))
if not self.is_classic:
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Camera Viewer",
"item data": "new camera viewer"
}))
elif message.isType("current parameters"):
for viewer in self.viewers:
message.addResponse(
halMessage.HalMessageResponse(
source=viewer.getViewerName(),
data={"parameters": viewer.getParameters().copy()}))
elif message.isType("new parameters"):
p = message.getData()["parameters"]
for viewer in self.viewers:
message.addResponse(
halMessage.HalMessageResponse(
source=viewer.getViewerName(),
data={"old parameters":
viewer.getParameters().copy()}))
viewer.newParameters(
p.get(viewer.getViewerName(),
viewer.getDefaultParameters()))
message.addResponse(
halMessage.HalMessageResponse(
source=viewer.getViewerName(),
data={"new parameters": viewer.getParameters()}))
elif message.isType("show"):
if (message.getData()["show"] == "new camera viewer"):
self.newCameraViewer()
elif (message.getData()["show"] == "new feed viewer"):
self.newFeedViewer()
elif message.isType("start"):
self.show_gui = message.getData()["show_gui"]
self.viewers[0].showViewer(self.show_gui)
elif message.isType("start film"):
for viewer in self.viewers:
viewer.startFilm(message.getData()["film settings"])
elif message.isType("stop film"):
for viewer in self.viewers:
viewer.stopFilm()
message.addResponse(
halMessage.HalMessageResponse(
source=viewer.getViewerName(),
data={"parameters": viewer.getParameters()}))
def processMessage(self, message):
if message.isType("changing parameters"):
if not message.getData()["changing"]:
self.newAnalyzers()
elif message.isType("configuration"):
if message.sourceIs("feeds"):
self.feed_names = []
for name in message.getData()["properties"]["feed names"]:
self.feed_names.append(name)
elif message.sourceIs("illumination"):
self.shutters_info = message.getData(
)["properties"]["shutters info"]
for analyzer in self.analyzers:
analyzer.setShuttersInfo(self.shutters_info)
elif message.sourceIs("mosaic"):
self.pixel_size = message.getData()["properties"]["pixel_size"]
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(
halMessage.HalMessage(m_type="initial parameters",
data={"parameters": self.parameters}))
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Spot Counter",
"item data": "spot counter"
}))
elif message.isType("new parameters"):
#
# Just record the new parameters here. Then when we get a 'configuration' message
# from feeds.feeds we'll get the names of the new feeds. And finally when we get
# the 'changing parameters' message we'll update the analyzers.
#
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"old parameters": self.parameters.copy()}))
self.parameters = message.getData()["parameters"].get(
self.module_name)
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.parameters}))
elif message.isType("show"):
if (message.getData()["show"] == "spot counter"):
self.view.show()
elif message.isType("start"):
self.newAnalyzers()
if message.getData()["show_gui"]:
self.view.showIfVisible()
elif message.isType("start film"):
film_settings = message.getData()["film settings"]
if film_settings.isSaved():
self.basename = film_settings.getBasename()
for analyzer in self.analyzers:
analyzer.startFilm(film_settings)
elif message.isType("stop film"):
total_spots = 0
for analyzer in self.analyzers:
analyzer.stopFilm()
total_spots += analyzer.getCounts()
if self.basename is not None:
analyzer.savePicture(self.basename)
self.basename = None
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.parameters.copy()}))
counts_param = params.ParameterInt(name="spot_counts",
value=total_spots)
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"acquisition": [counts_param]}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("timing"):
timing_fn = message.getData()["properties"]["functionality"]
is_time_base = (timing_fn.getTimeBase() == self.module_name)
halModule.runWorkerTask(self,
message,
lambda : self.startFilm(is_time_base))
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.camera_control.getParameters()}))
# Send 'configuration' message with information about this camera.
p_dict = {"module name" : self.module_name,
"is camera" : True,
"is master" : self.is_master}
self.sendMessage(halMessage.HalMessage(m_type = "configuration",
data = {"properties" : p_dict}))
elif message.isType("current parameters"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.camera_control.getParameters().copy()}))
elif message.isType("get functionality"):
# This message comes from display.cameraDisplay among others.
if (message.getData()["name"] == self.module_name):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"functionality" : self.camera_control.getCameraFunctionality()}))
elif message.isType("new parameters"):
# This message comes from settings.settings
halModule.runWorkerTask(self,
message,
lambda : self.updateParameters(message))
elif message.isType("shutter clicked"):
# This message comes from the shutter button.
if (message.getData()["camera"] == self.module_name):
halModule.runWorkerTask(self,
message,
self.toggleShutter)
elif message.isType("start camera"):
# This message comes from film.film. It is sent once for slaved
# cameras and once for master cameras.
if (message.getData()["master"] == self.is_master):
halModule.runWorkerTask(self, message, self.startCamera)
elif message.isType("start film"):
# This message comes from film.film, we save the film settings
# but don't actually do anything until we get a 'configuration'
# message from timing.timing.
self.film_settings = message.getData()["film settings"]
elif message.isType("stop camera"):
# This message comes from film.film. It is sent once for slaved
# cameras and once for master cameras.
if (message.getData()["master"] == self.is_master):
halModule.runWorkerTask(self, message, self.stopCamera)
elif message.isType("stop film"):
# This message comes from film.film, it goes to all camera at once.
self.film_length = None
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.camera_control.getParameters()}))
halModule.runWorkerTask(self, message, self.stopFilm)
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("feeds"):
cur_time_base = self.parameters.get("time_base")
allowed = self.also_allowed + message.getData(
)["properties"]["feed names"]
if not (cur_time_base in allowed):
print(">>> Warning current time base", cur_time_base,
"doesn't exist in", allowed)
allowed.append(cur_time_base)
self.setAllowed(allowed)
# Look for message about hardware timing modules in this setup. This
# message is the same as the ones created by the camera modules, but
# the 'is camera' field will be False.
if ("is camera" in message.getData()["properties"]):
m_data = message.getData()["properties"]
if not m_data["is camera"]:
self.also_allowed.append(m_data["module name"])
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(
halMessage.HalMessage(m_type="initial parameters",
data={"parameters": self.parameters}))
# Let film.film know that it needs to wait for us
# to get ready before starting the cameras.
self.sendMessage(
halMessage.HalMessage(m_type="wait for",
data={"module names": ["film"]}))
elif message.isType("current parameters"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.parameters.copy()}))
elif message.isType("new parameters"):
#
# FIXME: The problem is that we won't know the allowed set of feed names until
# feeds.feeds sends the 'configuration' message. Using the old allowed
# might cause a problem as the new time base might not exist in the
# old allowed. For now we are just setting allowed to be whatever the
# time_base parameter value is. Then at 'configuration' from feeds we
# check that that the parameter is valid. If it is not valid this will
# break HAL at an unexpected point, the error should have been detected in
# 'new parameters'. Also the editor won't work because the version of the
# parameter that it has only allows one value. Somehow we need to know
# the valid feed names at the new parameter stage..
#
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"old parameters": self.parameters.copy()}))
p = message.getData()["parameters"].get(self.module_name)
self.setAllowed([p.get("time_base")])
self.parameters.setv("time_base", p.get("time_base"))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.parameters}))
elif message.isType("start film"):
self.timing_functionality = TimingFunctionality(
time_base=self.parameters.get("time_base"))
self.sendMessage(
halMessage.HalMessage(
m_type="get functionality",
data={"name": self.timing_functionality.getTimeBase()}))
elif message.isType("stop film"):
self.timing_functionality.disconnectCameraFunctionality()
self.timing_functionality = None
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.parameters.copy()}))
def processMessage(self, message):
if message.isType("configuration"):
if message.sourceIs("timing"):
self.view.setTimingFunctionality(
message.getData()["properties"]["functionality"])
elif message.isType("configure1"):
self.sendMessage(
halMessage.HalMessage(m_type="add to menu",
data={
"item name": "Illumination",
"item data": "illumination"
}))
self.sendMessage(
halMessage.HalMessage(
m_type="initial parameters",
data={"parameters": self.view.getParameters()}))
self.view.getFunctionalities()
elif message.isType("current parameters"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.view.getParameters().copy()}))
elif message.isType("get functionality"):
if (message.getData()["name"] == self.module_name):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.ilm_functionality}))
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.setXMLDirectory(os.path.dirname(
p.get("parameters_file")))
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("new shutters file"):
self.view.newShutters(message.getData()["filename"])
elif message.isType("show"):
if (message.getData()["show"] == "illumination"):
self.view.show()
elif message.isType("start"):
# This is here because we need to have gotten the hardware functionalities
# in order to correctly handle parameter (and shutter) initialization.
self.view.newParameters(self.view.getParameters())
if message.getData()["show_gui"]:
self.view.showIfVisible()
elif message.isType("start film"):
self.view.startFilm(message.getData()["film settings"])
elif message.isType("stop film"):
self.view.stopFilm()
#
# Fix shutters file information to be an absolute path as the shutters
# file won't be saved in the same directory as the movie.
#
p = self.view.getParameters().copy()
p.set("shutters", os.path.abspath(p.get("shutters")))
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={"parameters": p}))
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 processMessage(self, message):
if message.isType("configuration"):
# Look for message about the cameras in this setup.
if ("is camera" in message.getData()["properties"]):
m_data = message.getData()["properties"]
if m_data["is camera"]:
self.camera_names.append(m_data["module name"])
elif message.isType("configure1"):
# Let the settings.settings module know that it needs
# to wait for us during a parameter change.
self.sendMessage(halMessage.HalMessage(m_type = "wait for",
data = {"module names" : ["settings"]}))
elif message.isType("configure2"):
self.feed_names = copy.copy(self.camera_names)
self.broadcastCurrentFeeds()
elif message.isType("get functionality"):
if self.feed_controller is not None:
feed_name = message.getData()["name"]
if feed_name in self.feed_controller.getFeedNames():
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"functionality" : self.feed_controller.getFeed(feed_name)}))
elif message.isType("get feed names"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"feed names" : self.feed_names}))
elif message.isType("new parameters"):
params = message.getData()["parameters"]
checkParameters(params)
if self.feed_controller is not None:
self.feed_controller.disconnectFeeds()
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.feed_controller.getParameters().copy()}))
self.feed_controller = None
if params.has("feeds"):
self.feed_controller = FeedController(parameters = params.get("feeds"))
elif message.isType("updated parameters"):
self.feed_names = copy.copy(self.camera_names)
if self.feed_controller is not None:
for feed in self.feed_controller.getFeeds():
self.feed_names.append(feed.getCameraName())
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : feed.getParameter("source"),
"extra data" : feed.getCameraName()}))
else:
self.broadcastCurrentFeeds()
self.sendMessage(halMessage.HalMessage(m_type = "parameters changed"))
elif message.isType("start film"):
if self.feed_controller is not None:
self.feed_controller.resetFeeds()
elif message.isType("stop film"):
if self.feed_controller is not None:
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.feed_controller.getParameters()}))
def processMessage(self, message):
if message.isType("change directory"):
self.view.setDirectory(message.getData()["directory"])
elif message.isType("configuration"):
if message.sourceIs("timing"):
self.view.setTimingFunctionality(message.getData()["properties"]["functionality"])
elif message.isType("configure1"):
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : self.ilm_fn_name}))
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.view.getParameters()}))
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"] == "progressions"):
self.view.show()
elif message.isType("start"):
if message.getData()["show_gui"] and self.view.haveFunctionality():
self.view.showIfVisible()
elif message.isType("start film"):
self.view.startFilm()
elif message.isType("stop film"):
self.view.stopFilm()
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.view.getParameters()}))
elif message.isType("tcp message"):
tcp_message = message.getData()["tcp message"]
if (tcp_message.isType("Set Progression")):
if not tcp_message.isTest():
if (tcp_message.getData("type") == "lockedout"):
self.view.tcpHandleProgressionLockout()
elif (tcp_message.getData("type") == "file"):
if self.checkTCPFilename(tcp_message):
self.view.tcpHandleProgressionType(tcp_message.getData("type"))
self.view.tcpHandleProgressionFile(tcp_message.getData("filename"))
else:
self.view.tcpHandleProgressionType(tcp_message.getData("type"))
for channel in tcp_message.getData("channels"):
self.view.tcpHandleProgressionSet(channel[0],
channel[1],
channel[2],
channel[3])
else:
if (tcp_message.getData("type") == "file"):
self.checkTCPFilename(tcp_message)
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"handled" : True}))
def processMessage(self, message):
if message.isType("configuration"):
# Check for master cameras. If they exist this is an error in the setup
# configuration.
if ("is camera" in message.getData()["properties"]):
if not self.allow_master:
m_data = message.getData()["properties"]
if m_data["is camera"] and m_data["is master"]:
raise halExceptions.HalException(
"Master camera detected in hardware timed setup!")
# Check if we are the time base for the film.
#
# If we are and this is a fixed length film then
# set the hardware counter appropriately.
#
elif message.sourceIs("timing"):
timing_fn = message.getData()["properties"]["functionality"]
if (timing_fn.getTimeBase() == self.module_name
) and self.film_settings.isFixedLength():
self.hardware_timing_functionality.setFilmLength(
self.film_settings.getFilmLength())
elif message.isType("configure1"):
# Broadcast initial parameters.
self.sendMessage(
halMessage.HalMessage(m_type="initial parameters",
data={"parameters": self.parameters}))
# Send 'configuration' message with information about this hardware timing
# module. This module is always a master, but is not a camera.
p_dict = {
"module name": self.module_name,
"is camera": False,
"is master": True
}
self.sendMessage(
halMessage.HalMessage(m_type="configuration",
data={"properties": p_dict}))
# Get DAQ counter like functionality.
self.sendMessage(
halMessage.HalMessage(
m_type="get functionality",
data={
"name": self.configuration.get("counter_fn_name"),
"extra data": "counter"
}))
elif message.isType("current parameters"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.parameters.copy()}))
elif message.isType("get functionality"):
if (message.getData()["name"] == self.module_name):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={
"functionality": self.hardware_timing_functionality
}))
elif message.isType("new parameters"):
#
# FIXME: We have a similar problem here as with timing.timing. We don't know
# the allowed FPS range for the cameras based on their new parameters
# at this point. By the time we do know at 'updated parameters' it is
# to late to change the allowed range that settings.settings will show
# in the parameter editor GUI.
#
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"old parameters": self.parameters.copy()}))
p = message.getData()["parameters"].get(self.module_name)
self.parameters.setv("fps", p.get("fps"))
self.hardware_timing_functionality.setFPS(p.get("fps"))
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"new parameters": self.parameters}))
elif message.isType("start"):
if self.hardware_timing_functionality is None:
raise halExceptions.HalException(
"no counter functionality available for hardware timing.")
elif message.isType("start camera"):
# This message comes from film.film. This module behaves
# like a master camera.
if message.getData()["master"]:
self.hardware_timing_functionality.startCounter()
elif message.isType("start film"):
# This message comes from film.film, we save the film settings
# but don't actually do anything until we get a 'configuration'
# message from timing.timing.
self.film_settings = message.getData()["film settings"]
elif message.isType("stop camera"):
# This message comes from film.film. This module behaves
# like a master camera.
if message.getData()["master"]:
self.hardware_timing_functionality.stopCounter()
elif message.isType("stop film"):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"parameters": self.parameters.copy()}))
def getFunctionality(self, message):
if (message.getData()["name"] == self.module_name):
message.addResponse(
halMessage.HalMessageResponse(
source=self.module_name,
data={"functionality": self.em_wheel_functionality}))
def processMessage(self, message):
if message.isType("configure1"):
self.newMessage.emit(
halMessage.HalMessage(source=self,
m_type="add to ui",
data=self.configure_dict))
elif message.isType("configure2"):
self.view.copyDefaultParameters()
self.view.markCurrentAsInitialized()
elif message.isType("get parameters"):
p = self.view.getParameters(message.getData()["index or name"])
if p is None:
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={"found": False}))
else:
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={
"parameters": p,
"found": True
}))
elif message.isType("initial parameters"):
# It is okay for other modules to just send their parameters as we make
# a copy before storing them in this module.
self.view.updateCurrentParameters(
message.getSourceName(),
message.getData()["parameters"].copy())
elif message.isType("new parameters file"):
# Ignore this message if the UI is disabled and send a warning.
if not self.view.getEnabled():
msg = "Parameters files cannot be added during editting / filming"
message.addError(
halMessage.HalMessageError(source=self.module_name,
message=msg))
return
data = message.getData()
# Check if these parameters should be default parameters. For now
# anyway this should only be possible at initialization.
is_default = False
if "is default" in data:
is_default = data["is default"]
# Process new parameters file.
self.view.newParametersFile(data["filename"], is_default)
elif message.isType("parameters changed"):
self.waiting_on.remove(message.getSourceName())
if message.getData() is not None:
self.view.updateCurrentParameters(
message.getSourceName(),
message.getData()["new parameters"].copy())
# All modules have finished changing parameters.
if (len(self.waiting_on) == 0):
self.updateComplete()
elif message.isType("set parameters"):
if self.locked_out:
raise halExceptions.HalException(
"'set parameters' received while locked out.")
[found, current
] = self.view.setParameters(message.getData()["index or name"])
message.addResponse(
halMessage.HalMessageResponse(source=self.module_name,
data={
"current": current,
"found": found
}))
elif message.isType("start film"):
self.view.enableUI(False)
elif message.isType("stop film"):
self.view.enableUI(True)
elif message.isType("wait for"):
if self.module_name in message.getData()["module names"]:
self.wait_for.append(message.getSourceName())
def processMessage(self, message):
if message.isType("change directory"):
self.view.setDirectory(message.getData()["directory"])
elif message.isType("configuration"):
if message.sourceIs("feeds"):
self.camera_functionalities = []
for name in message.getData()["properties"]["feed names"]:
self.sendMessage(halMessage.HalMessage(m_type = "get functionality",
data = {"name" : name}))
self.number_fn_requested += 1
elif message.sourceIs("illumination"):
properties = message.getData()["properties"]
if "shutters filename" in properties:
self.view.setShutters(properties["shutters filename"])
elif message.sourceIs("mosaic"):
#
# We need to keep track of the current value so that
# we can save this in the tif images / stacks.
#
self.pixel_size = message.getData()["properties"]["pixel_size"]
elif message.sourceIs("timing"):
#
# We'll get this message from timing.timing, the part we are interested in is
# the timing functionality which we will use both to update the frame counter
# and to know when a fixed length film is complete.
#
self.timing_functionality = message.getData()["properties"]["functionality"]
self.timing_functionality.newFrame.connect(self.handleNewFrame)
self.timing_functionality.stopped.connect(self.stopFilmingLevel1)
elif message.isType("configure1"):
self.sendMessage(halMessage.HalMessage(m_type = "add to ui",
data = self.configure_dict))
self.sendMessage(halMessage.HalMessage(m_type = "initial parameters",
data = {"parameters" : self.view.getParameters()}))
# Let the settings.settings module know that it needs
# to wait for us during a parameter change.
self.sendMessage(halMessage.HalMessage(m_type = "wait for",
data = {"module names" : ["settings"]}))
elif message.isType("current parameters"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.view.getParameters().copy()}))
elif message.isType("live mode") and message.sourceIs("testing"):
self.view.setLiveMode(message.getData()["live mode"])
elif message.isType("new parameters"):
if self.locked_out:
raise halExceptions.HalException("'new parameters' received while locked out.")
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"old parameters" : self.view.getParameters().copy()}))
# Update parameters.
self.view.newParameters(message.getData()["parameters"].get(self.module_name))
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"new parameters" : self.view.getParameters()}))
elif message.isType("new shutters file"):
self.view.setShutters(message.getData()["filename"])
elif message.isType("ready to film"):
self.waiting_on.remove(message.getSourceName())
# All modules are ready, so start the cameras.
if (len(self.waiting_on) == 0):
self.startCameras()
elif message.isType("start"):
if self.view.amInLiveMode():
self.startCameras()
elif message.isType("start camera"):
if self.locked_out and (message.getSource() != self):
raise halExceptions.HalException("'start camera' received while locked out.")
elif message.isType("start film request"):
if self.locked_out:
raise halExceptions.HalException("'start film request' received while locked out.")
self.setLockout(True)
film_settings = self.view.getFilmSettings(message.getData()["request"])
if film_settings is not None:
film_settings.setPixelSize(self.pixel_size)
self.startFilmingLevel1(film_settings)
else:
self.setLockout(False)
elif message.isType("stop camera"):
if self.locked_out and (message.getSource() != self):
raise halException.HalException("'stop camera' received while locked out.")
elif message.isType("stop film"):
message.addResponse(halMessage.HalMessageResponse(source = self.module_name,
data = {"parameters" : self.view.getParameters()}))
elif message.isType("stop film request"):
if (self.film_state != "run"):
raise halExceptions.HalException("Stop film request received while not filming.")
self.stopFilmingLevel1()
elif message.isType("updated parameters"):
self.parameter_change = True
elif message.isType("wait for"):
if self.module_name in message.getData()["module names"]:
self.wait_for.append(message.getSourceName())
