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())