def commit_settings(self, param): """ Activate the parameters changes in the hardware. =============== ================================= ============================ **Parameters** **Type** **Description** *param* instance of pyqtgraph.parameter The parameter to be checked. =============== ================================= ============================ See Also -------- daq_utils.ThreadCommand """ try: self.status_timer.stop() if 'diag_' in param.name(): id = int(param.name().split('diag_')[1]) diag = self.controller.get_diag_from_id(id) self.controller.set_diag(id, int(param.value() * diag['divider']).to_bytes(diag['reply'], 'big')) QThread.msleep(200) self.update_diag(id) elif param.name() == 'timeout': self.controller.timeout = param.value() param.setValue(self.controller.timeout) elif param.name() == 'update_diags': self.update_all_diags() self.update_status() elif param.name() == 'laser': self.controller.set_laser(param.value()) elif param.name() == 'shutter': self.controller.set_shutter(param.value()) self.status_timer.start(1000) except Exception as e: self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
def close(self): """ close the current instance of the visa session. """ self.status_timer.stop() QThread.msleep(1000) self.controller.close_communication()
def grab_data(self, Naverage=1, **kwargs): """ | Start new acquisition For each integer step of naverage range: * set mock data * wait 100 ms * update the data_tot array | Send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of spectrum to average. Specify the threshold of the mean calculation =============== ======== =============================================== See Also -------- set_Mock_data """ Naverage = 1 data_tot = self.set_Mock_data() for ind in range(Naverage - 1): data_tmp = self.set_Mock_data() QThread.msleep(self.settings.child('exposure_ms').value()) for ind, data in enumerate(data_tmp): data_tot[ind] += data data_tot = [data / Naverage for data in data_tot] QThread.msleep(self.settings.child('exposure_ms').value()) self.data_grabed_signal.emit( [DataFromPlugins(name='Mock1', data=data_tot, dim='Data1D')])
def commit_settings(self, param): """ Activate parameters changes on the hardware. =============== ================================ =========================== **Parameters** **Type** **Description** *param* instance of pyqtgraph Parameter the parameter to activate =============== ================================ =========================== See Also -------- set_Mock_data """ try: if param.name() in putils.iter_children( self.settings.child(('cam_settings')), []): self.stop() while self.controller.is_acquiring_images: self.stop() QtWidgets.QApplication.processEvents() feature = self.controller.device.node_map.get_node( param.name()) interface_type = feature.node.principal_interface_type if interface_type == EInterfaceType.intfIInteger: val = int((param.value() // param.opts['step']) * param.opts['step']) else: val = param.value() feature.value = val #set the desired value param.setValue(feature.value) # retrieve the actually set one #self.update_features() if param.name() in ['Height', 'Width', 'OffsetX', 'OffsetY']: if param.name() in ['Height', 'Width' ] and not self.settings.child( 'ROIselect', 'use_ROI').value(): self.width = self.controller.device.node_map.get_node( 'Width').value self.height = self.controller.device.node_map.get_node( 'Height').value self.data = np.zeros((self.height, self.width)) if param.name() in putils.iter_children( self.settings.child(('ROIselect')), []): while self.controller.is_acquiring_images: QThread.msleep(50) self.stop() QtWidgets.QApplication.processEvents() self.set_ROI() except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
def grab_data(self, Naverage=1, **kwargs): """ | For each integer step of naverage range set mock data. | Construct the data matrix and send the data_grabed_signal once done. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int The number of images to average. specify the threshold of the mean calculation =============== ======== =============================================== See Also -------- set_Mock_data """ "live is an attempt to export data as fast as possible" if 'live' in kwargs: if kwargs['live']: self.live = True self.live = False # don't want to use that for the moment if self.live: while self.live: data = self.average_data(Naverage) QThread.msleep(100) self.data_grabed_signal.emit(data) QtWidgets.QApplication.processEvents() else: data = self.average_data(Naverage) QThread.msleep(000) self.data_grabed_signal.emit(data)
def update_all_diags(self): for diag in self.controller.diagnostics: try: QThread.msleep(200) self.update_diag(diag['id']) except Exception as e: print(e)
def grab_data(self, Naverage=1, **kwargs): """ Start a new acquisition. Grab the current values. Send the Parameters ---------- Naverage: (int) Number of hardware averaging kwargs: (dict) of others optionals arguments """ # The following seems to be important to refresh the scope buffer. # Otherwise a long scan will crash the daq_scan. self.controller.DeviceClear(False) QtWidgets.QApplication.processEvents() QThread.msleep(100) QtWidgets.QApplication.processEvents() channel = self.settings.child('channels').value()['selected'] waveform = self.controller.GetScaledWaveformWithTimes( channel[0], 1e8, 0) if self.sample_mode == "Sequence": while True: self.controller.WriteString( r"""vbs? 'return=app.acquisition.horizontal.acquiredsegments' """, 1) acquired_segments = self.controller.ReadString(8) if acquired_segments == self.number_of_segments: break time.sleep(0.01) else: pass # The ErrorFlag property checks that there is no error concerning ActiveDSO. # If the user changes some parameters on the oscilloscope (for example the # horizontal scale) while pymodaq acquisition is running, it will raise this # error. We do not know how to deal with this problem. # If the error is raised you will probably have to restart the oscilloscope to # get the communication back. # Restarting can be done with a little script using the DeviceClear(True) method # of ActiveDSO. It is much faster than doing it manually. # # To prevent the error, the user should use the STOP button on pymodaq GUI, then # change the parameter of his choice on the oscilloscope and then RUN pymodaq # acquisition. if self.controller.ErrorFlag: raise Exception(self.controller.ErrorString) data = [np.array(waveform[1])] self.data_grabed_signal.emit([ DataFromPlugins(name='Lecroy Waverunner', data=data, type='Data1D', labels=["", ""]) ])
def run(self): logger = logging.getLogger("SCAN") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos # check on which side first request is # to_right = True to_right = incomming[0].cylinder >= current_pos time = 0 self.setHeadPos(current_pos) while True: for request in list(incomming): if request.arrive_time <= time: queue.append(request) incomming.remove(request) self.addRequest(request.cylinder) # decrease disc size and max arrive time to generate more interesting results for request_in_cylinder in [req for req in queue if req.cylinder == current_pos]: logger.debug("Request {} scaned on pos {}".format(request_in_cylinder.request_id, request_in_cylinder.cylinder)) queue.remove(request_in_cylinder) completed.append(request_in_cylinder) QThread.msleep(100) self.removeRequest(request_in_cylinder.cylinder) time = time + 1 if to_right: if current_pos == self.disk_size: to_right = False else: current_pos = current_pos + 1 else: if current_pos == 0: to_right = True else: current_pos = current_pos - 1 QThread.msleep(100) self.setHeadPos(current_pos) for other in list(queue): other.add_wait_time(1) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= SCAN =================") logger.info("Average waiting time: {}".format(round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info("Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}". format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time))
def run(self): logger = logging.getLogger("SSTF-EDF") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos time = incomming[0].arrive_time self.setHeadPos(current_pos) while True: for request in list(incomming): if request.arrive_time <= time: queue.append(request) incomming.remove(request) self.addRequest(request.cylinder) if len(queue) != 0: # check for real time requests real_time = [req for req in queue if req.real_time] if len(real_time) > 0: # find shortest real time request nearest = min(real_time, key=operator.attrgetter("deadline")) else: # fallback to sstf nearest: Request = min( queue, key=lambda req: abs(current_pos - req.cylinder)) queue.remove(nearest) completed.append(nearest) QThread.msleep(100) self.removeRequest(nearest.cylinder) # calculate delta of head position and add it to time delta = abs(current_pos - nearest.cylinder) current_pos = nearest.cylinder time = time + delta QThread.msleep(100) self.setHeadPos(current_pos) for other in list(queue): other.add_wait_time(delta) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= SSTF-EDF =================") logger.info("Switches to FCFS if real time requests arrive.") logger.info("Average waiting time: {}".format( round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info( "Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}, Real-time: {}" .format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time, longest_waiting.real_time))
def ini_detector(self, controller=None): """ Initialisation procedure of the detector. Returns ------- The initialized status. See Also -------- daq_utils.ThreadCommand """ self.status.update(edict(initialized=False, info="", x_axis=None, y_axis=None, controller=None)) try: if self.settings.child(('controller_status')).value() == "Slave": if controller is None: raise Exception('no controller has been defined externally while this detector is a slave one') else: self.controller = controller else: self.controller = AmplitudeSystemsCRC16() self.controller.init_communication(self.settings.child(('com_port')).value()) self.settings.child(('timeout')).setValue(self.controller.timeout) try: self.settings.child(('serial_number')).setValue(self.controller.get_sn()) QThread.msleep(200) except Exception as e: logger.exception(str(e)) try: self.settings.child(('version')).setValue(self.controller.get_version()) QThread.msleep(200) except Exception as e: logger.exception(str(e)) self.update_status() for stat in self.controller.status: self.settings.child('status', f'stat_{stat["id"]}').setValue(stat['value']) self.update_all_diags() self.status_timer = QTimer() self.status_timer.timeout.connect(self.update_status) self.status_timer.start(1000) self.status.controller = self.controller self.status.initialized = True return self.status except Exception as e: self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log'])) self.status.info = getLineInfo() + str(e) self.status.initialized = False return self.status
def start_PID(self, sync_detectors=True, sync_acts=False): """Start the pid controller loop Parameters ---------- sync_detectors: (bool) if True will make sure all selected detectors (if any) all got their data before calling the model sync_acts: (bool) if True will make sure all selected actuators (if any) all reached their target position before calling the model """ self.running = True try: if sync_detectors: self.modules_manager.connect_detectors() if sync_acts: self.modules_manager.connect_actuators() self.current_time = time.perf_counter() logger.info('PID loop starting') while self.running: # print('input: {}'.format(self.input)) # # GRAB DATA FIRST AND WAIT ALL DETECTORS RETURNED self.det_done_datas = self.modules_manager.grab_datas() self.inputs_from_dets = self.model_class.convert_input(self.det_done_datas) # # EXECUTE THE PID self.outputs = [] for ind, pid in enumerate(self.pids): self.outputs.append(pid(self.inputs_from_dets.values[ind])) # # APPLY THE PID OUTPUT TO THE ACTUATORS if self.outputs is None: self.outputs = [pid.setpoint for pid in self.pids] dt = time.perf_counter() - self.current_time self.outputs_to_actuators = self.model_class.convert_output(self.outputs, dt, stab=True) if not self.paused: self.modules_manager.move_actuators(self.outputs_to_actuators.values, self.outputs_to_actuators.mode, polling=False) self.current_time = time.perf_counter() QtWidgets.QApplication.processEvents() QThread.msleep(int(self.sample_time * 1000)) logger.info('PID loop exiting') self.modules_manager.connect_actuators(False) self.modules_manager.connect_detectors(False) except Exception as e: logger.exception(str(e))
def run(self): logger = logging.getLogger("C-SCAN") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos time = 0 self.setHeadPos(current_pos) while True: for request in list(incomming): if request.arrive_time <= time: queue.append(request) incomming.remove(request) self.addRequest(request.cylinder) for request_in_cylinder in [ req for req in queue if req.cylinder == current_pos ]: logger.debug("Request {} scaned on pos {}".format( request_in_cylinder.request_id, request_in_cylinder.cylinder)) queue.remove(request_in_cylinder) completed.append(request_in_cylinder) QThread.msleep(100) self.removeRequest(request_in_cylinder.cylinder) time = time + 1 if current_pos == self.disk_size: # time = time + current_pos current_pos = 0 else: current_pos = current_pos + 1 QThread.msleep(100) self.setHeadPos(current_pos) for other in list(queue): other.add_wait_time(1) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= C-SCAN =================") logger.info("Average waiting time: {}".format( round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info( "Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}" .format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time))
def grab_data(self, Naverage=1, **kwargs): """ """ coeff = self.settings.child(('width_coeff')).value() fun_type = self.settings.child(('fun_type')).value() self.datas = np.zeros((self.Ny, self.Nx)) self.stop_flag = False if self.scan_parameters is not None: for ind in range(self.scan_parameters.Nsteps): if self.stop_flag: break positions = (self.x_axis[self.scan_parameters.axes_indexes[ind, 0]], self.y_axis[self.scan_parameters.axes_indexes[ind, 1]]) if fun_type == 'Gaussians': self.datas[self.scan_parameters.axes_indexes[ind, 1], self.scan_parameters.axes_indexes[ ind, 0]] = random_hypergaussians2D_signal( positions, coeff) else: self.datas[self.scan_parameters.axes_indexes[ind, 1], self.scan_parameters.axes_indexes[ ind, 0]] = diverging2D_signal(positions, coeff) if ind % 100 == 0: # refresh plot every 100 grabed points self.data_grabed_signal_temp.emit([ utils.DataFromPlugins( name='MockScanner', data=[self.datas], dim='Data2D', x_axis=utils.Axis(data=self.x_axis), y_axis=utils.Axis(data=self.y_axis)) ]) QtWidgets.QApplication.processEvents() QThread.msleep(100) self.data_grabed_signal.emit([ utils.DataFromPlugins(name='MockScanner', data=[self.datas], dim='Data2D', x_axis=utils.Axis(data=self.x_axis), y_axis=utils.Axis(data=self.y_axis)) ]) self.ind_data += 1
def run(self): while(self.is_processing): value = self.buffer.get() if value: self.do_zoom.emit() self.is_zooming = True # wait for zoom to finish. while(self.is_zooming): QThread.msleep(10) # one more, to prevent hiccups. QThread.msleep(10)
def run(self): logger = logging.getLogger("SSTF") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos time = incomming[0].arrive_time self.setHeadPos(current_pos) while True: for request in list(incomming): if request.arrive_time <= time: queue.append(request) incomming.remove(request) self.addRequest(request.cylinder) if len(queue) != 0: nearest: Request = min( queue, key=lambda req: abs(current_pos - req.cylinder)) queue.remove(nearest) completed.append(nearest) QThread.msleep(100) self.removeRequest(nearest.cylinder) # calculate delta of head position and add it to time delta = abs(current_pos - nearest.cylinder) current_pos = nearest.cylinder time = time + delta QThread.msleep(100) self.setHeadPos(current_pos) for other in list(queue): other.add_wait_time(delta) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= SSTF =================") logger.info("High starvation rate for requests on \"edges\" of disk.") logger.info("Average waiting time: {}".format( round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info( "Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}" .format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time))
def setup_docks(self): ''' subclass method from CustomApp ''' logger.debug('setting docks') self.dock_settings = Dock('Settings', size=(350, 350)) self.dockarea.addDock(self.dock_settings, 'left') self.dock_settings.addWidget(self.settings_tree, 10) self.dock_logger = Dock("Logger") self.logger_list = QtWidgets.QListWidget() self.logger_list.setMinimumWidth(300) self.dock_logger.addWidget(self.logger_list) self.dockarea.addDock(self.dock_logger, 'bottom', self.dock_settings) # create a dock containing a viewer object, could be 0D, 1D or 2D depending what kind of data one want to plot here a 0D dock_Viewer0D = Dock('Viewer dock', size=(350, 350)) self.dockarea.addDock(dock_Viewer0D, 'right', self.dock_logger) target_widget = QtWidgets.QWidget() self.target_viewer = Viewer0D(target_widget) dock_Viewer0D.addWidget(target_widget) # create 2 docks to display the DAQ_Viewer (one for its settings, one for its viewer) self.dock_detector_settings = Dock("Detector Settings", size=(350, 350)) self.dockarea.addDock(self.dock_detector_settings, 'right', self.dock_settings) self.dock_detector = Dock("Detector Viewer", size=(350, 350)) self.dockarea.addDock(self.dock_detector, 'right', self.dock_detector_settings) # init one daq_viewer object named detector self.detector = DAQ_Viewer(self.dockarea, dock_settings=self.dock_detector_settings, dock_viewer=self.dock_detector, title="A detector", DAQ_type='DAQ0D') # set its type to 'Mock' self.detector.daq_type = 'Mock' # init the detector and wait 1000ms for the completion self.detector.init_det() self.detector.settings.child('main_settings', 'wait_time').setValue(100) QtWidgets.QApplication.processEvents() QThread.msleep(1000) logger.debug('docks are set')
def grab_data(self, Naverage=1, **kwargs): """ """ self.status_timer.stop() data_tot = [] selected_channels = self.settings.child(('channels')).value()['selected'] for channel in selected_channels: data, diag = self.controller.get_diag_from_name(channel) data = int.from_bytes(data, 'big') / diag['divider'] self.settings.child('diagnostics', f'diag_{diag["id"]}').setValue(data) data_tot.append(np.array([data])) QThread.msleep(200) self.data_grabed_signal.emit( [DataFromPlugins(name='AmplitudeSystems', data=data_tot, dim='Data0D', labels=selected_channels)]) self.status_timer.start(1000)
def grab_data(self, Naverage=1, **kwargs): #for rapid block mode """ | Start a new acquisition. | | grab the current values with Picoscope 5000A profile procedure. =============== ======== =============================================== **Parameters** **Type** **Description** *Naverage* int Number of spectrum to average =============== ======== =============================================== Returns ------- string list the updated status. See Also -------- daq_utils.ThreadCommand """ try: self.Naverage = Naverage N_pre_trigger = int(self.Nsample_available * self.settings.child( 'main_settings', 'trigger', 'trig_pretrigger').value() / 100) N_post_trigger = self.Nsample_available - N_pre_trigger status = self.pico.setNoOfCapture( self.settings.child('main_settings', 'Nsegments').value()) if status != "PICO_OK": self.emit_status( ThreadCommand("Update_Status", [status, 'log'])) status = self.pico.run_block(N_pre_trigger, N_post_trigger, ind_segment=0) if status[0] == "PICO_OK": if type(status[1]) == int: QThread.msleep(status[1]) return status except Exception as e: self.emit_status( ThreadCommand("Update_Status", [getLineInfo() + str(e), 'log']))
def quit_fun(self): """ """ try: try: self.PIDThread.exit() except Exception as e: print(e) areas = self.dock_area.tempAreas[:] for area in areas: area.win.close() QtWidgets.QApplication.processEvents() QThread.msleep(1000) QtWidgets.QApplication.processEvents() self.dock_area.parent().close() except Exception as e: print(e)
def stop(self): """ not implemented. """ ind = 0 while self.controller.is_acquiring_images and ind < 10: try: self.controller.stop_image_acquisition() except Exception as e: pass QThread.msleep(500) print('stopping acquisition') return "" # if __name__ == '__main__': # from pyicic.IC_ImagingControl import * # # open lib # ic_ic = IC_ImagingControl() # ic_ic.init_library() # # # open first available camera device # cam_names = ic_ic.get_unique_device_names() # cam = ic_ic.get_device(cam_names[0]) # cam.open() # # change camera properties # cam.list_property_names() # ['gain', 'exposure', 'hue', etc...] # cam.gain.auto = True # enable auto gain # emin = cam.exposure.min # 0 # emax = cam.exposure.max # 10 # cam.exposure.value =int((emin + emax) / 2) # disables auto exposure and sets value to half of range # # change camera settings # formats = cam.list_video_formats() # cam.set_video_format(formats[8]) # # pass
def start_logging(self): """ Start a logging. """ self.status_widget.setText('Starting logging') self.overshoot = False res = self.set_logging() # mandatory to deal with multithreads if self.logger_thread is not None: self.command_DAQ_signal.disconnect() if self.logger_thread.isRunning(): self.logger_thread.exit() while not self.logger_thread.isFinished(): QThread.msleep(100) self.logger_thread = None self.logger_thread = QThread() log_acquisition = DAQ_Logging(self.settings, self.logger, self.modules_manager) log_acquisition.moveToThread(self.logger_thread) self.command_DAQ_signal[list].connect(log_acquisition.queue_command) log_acquisition.status_sig[list].connect(self.thread_status) self.logger_thread.log_acquisition = log_acquisition self.logger_thread.start() self._actions['start'].setEnabled(False) QtWidgets.QApplication.processEvents() self.logging_state.set_as_false() self.command_DAQ_signal.emit(["start_logging"]) self.status_widget.setText('Running acquisition')
def run(self): logger = logging.getLogger("FCFS") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos time = incomming[0].arrive_time self.setHeadPos(current_pos) while True: QThread.msleep(100) for request in list(incomming): if request.arrive_time <= time: incomming.remove(request) queue.append(request) self.addRequest(request.cylinder) if len(queue) != 0: request = queue.popleft() QThread.msleep(100) self.removeRequest(request.cylinder) # processes are sorted by arrive time so we do not have search for min # request: Request = min(queue, key=operator.attrgetter("arrive_time")) # queue.remove(request) completed.append(request) # calculate delta of head position and add it to time delta = abs(current_pos - request.cylinder) QThread.msleep(100) self.setHeadPos(current_pos) current_pos = request.cylinder time = time + delta for other in list(queue): other.add_wait_time(delta) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= FCFS =================") logger.info("Average waiting time: {}".format(round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info("Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}". format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time))
def listen_client(self): """ Server function. Used to connect or listen incoming message from a client. """ try: self.processing = True # QtWidgets.QApplication.processEvents() #to let external commands in read_sockets, write_sockets, error_sockets = self.select( [client['socket'] for client in self.connected_clients], [], [client['socket'] for client in self.connected_clients], 0) for sock in error_sockets: self.remove_client(sock) for sock in read_sockets: QThread.msleep(100) if sock == self.serversocket: # New connection # means a new socket (client) try to reach the server (client_socket, address) = self.serversocket.accept() DAQ_type = client_socket.get_string() if DAQ_type not in self.socket_types: self.emit_status( ThreadCommand( "Update_Status", [DAQ_type + ' is not a valid type', 'log'])) client_socket.close() break self.connected_clients.append( dict(socket=client_socket, type=DAQ_type)) self.settings.child(('conn_clients')).setValue( self.set_connected_clients_table()) self.emit_status( ThreadCommand("Update_Status", [ DAQ_type + ' connected with ' + address[0] + ':' + str(address[1]), 'log' ])) QtWidgets.QApplication.processEvents() else: # Some incoming message from a client # Data received from client, process it try: message = sock.get_string() if message in [ 'Done', 'Info', 'Infos', 'Info_xml', 'position_is', 'move_done' ]: self.process_cmds(message, command_sock=None) elif message == 'Quit': raise Exception("socket disconnect by user") else: self.process_cmds(message, command_sock=sock) # client disconnected, so remove from socket list except Exception as e: self.remove_client(sock) self.processing = False except Exception as e: self.emit_status(ThreadCommand("Update_Status", [str(e), 'log']))
def set_Mock_data(self): """ | Set the x_axis and y_axis with a linspace distribution from settings parameters. | Once done, set the data mock with parameters : * **Amp** : The amplitude * **x0** : the origin of x * **dx** : the derivative x pos * **y0** : the origin of y * **dy** : the derivative y pos * **n** : ??? * **amp_noise** : the noise amplitude Returns ------- The computed data mock. """ image = np.zeros( (self.settings.child('spatial_settings', 'Ny').value(), self.settings.child('spatial_settings', 'Nx').value(), self.settings.child('temp_settings', 'Nt').value())) self.time_axis = np.linspace( 0, self.settings.child('temp_settings', 'Nt').value(), self.settings.child('temp_settings', 'Nt').value(), endpoint=False) if self.settings.child('ROIselect', 'use_ROI').value(): self.x_axis = np.linspace( self.settings.child('ROIselect', 'x0').value(), self.settings.child('ROIselect', 'x0').value() + self.settings.child('ROIselect', 'width').value(), self.settings.child('ROIselect', 'width').value(), endpoint=False) self.y_axis = np.linspace( self.settings.child('ROIselect', 'y0').value(), self.settings.child('ROIselect', 'y0').value() + self.settings.child('ROIselect', 'height').value(), self.settings.child('ROIselect', 'height').value(), endpoint=False) data_mock = self.settings.child( 'spatial_settings', 'amp').value() * (utils.gauss2D( self.x_axis, self.settings.child('spatial_settings', 'x0').value(), self.settings.child('spatial_settings', 'dx').value(), self.y_axis, self.settings.child('spatial_settings', 'y0').value(), self.settings.child('spatial_settings', 'dy').value(), self.settings.child('spatial_settings', 'n').value() )) + self.settings.child( ('amp_noise')).value() * np.random.rand( len(self.y_axis), len(self.x_axis)) for indy in range(data_mock.shape[0]): data_mock[indy, :] = data_mock[indy, :] * np.sin( self.x_axis / self.settings.child('spatial_settings', 'lambda').value())**2 data_mock = np.roll(data_mock, self.ind_data * self.settings.child('rolling').value(), axis=1) try: self.image[ self.settings.child('ROIselect', 'y0').value(): self.settings.child('ROIselect', 'y0').value() + self.settings.child('ROIselect', 'height').value(), self.settings.child('ROIselect', 'x0').value(): self.settings.child('ROIselect', 'x0').value() + self.settings.child('ROIselect', 'width').value()] \ = data_mock except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log'])) else: self.x_axis = np.linspace( 0, self.settings.child('spatial_settings', 'Nx').value(), self.settings.child('spatial_settings', 'Nx').value(), endpoint=False) self.y_axis = np.linspace( 0, self.settings.child('spatial_settings', 'Ny').value(), self.settings.child('spatial_settings', 'Ny').value(), endpoint=False) data_mock = self.settings.child('spatial_settings', 'amp').value() * ( utils.gauss2D(self.x_axis, self.settings.child('spatial_settings', 'x0').value(), self.settings.child('spatial_settings', 'dx').value(), self.y_axis, self.settings.child('spatial_settings', 'y0').value(), self.settings.child('spatial_settings', 'dy').value(), self.settings.child('spatial_settings', 'n').value())) + \ self.settings.child(('amp_noise')).value() * \ np.random.rand(len(self.y_axis), len(self.x_axis)) for indy in range(data_mock.shape[0]): data_mock[indy, :] = data_mock[indy, :] * np.sin( self.x_axis / self.settings.child('spatial_settings', 'lambda').value())**2 ind = 0 for indy in range(data_mock.shape[0]): for indx in range(data_mock.shape[1]): image[indy, indx, :] = data_mock[indy, indx] * \ utils.gauss1D(self.time_axis, self.settings.child('temp_settings', 't0').value(), self.settings.child('temp_settings', 'dt').value(), self.settings.child('temp_settings', 'n').value()) * \ np.sin(np.roll(self.time_axis, ind) / 4) ** 2 ind += 1 image = np.roll(image, self.ind_data * self.settings.child( ('rolling')).value(), axis=1) self.image = image self.ind_data += 1 QThread.msleep(100) return self.image
def set_Mock_data(self): """ | Set the x_axis and y_axis with a linspace distribution from settings parameters. | Once done, set the data mock with parameters : * **Amp** : The amplitude * **x0** : the origin of x * **dx** : the derivative x pos * **y0** : the origin of y * **dy** : the derivative y pos * **n** : ??? * **amp_noise** : the noise amplitude Returns ------- The computed data mock. """ if self.settings.child('ROIselect', 'use_ROI').value(): x_axis = np.linspace( self.settings.child('ROIselect', 'x0').value(), self.settings.child('ROIselect', 'x0').value() + self.settings.child('ROIselect', 'width').value(), self.settings.child('ROIselect', 'width').value(), endpoint=False) y_axis = np.linspace( self.settings.child('ROIselect', 'y0').value(), self.settings.child('ROIselect', 'y0').value() + self.settings.child('ROIselect', 'height').value(), self.settings.child('ROIselect', 'height').value(), endpoint=False) data_mock = self.settings.child(('Amp')).value() * (mylib.gauss2D( x_axis, self.settings.child(('x0')).value(), self.settings.child(('dx')).value(), y_axis, self.settings.child(('y0')).value(), self.settings.child(('dy')).value(), self.settings.child(('n')).value())) + self.settings.child( ('amp_noise')).value() * np.random.rand( len(y_axis), len(x_axis)) for indy in range(data_mock.shape[0]): data_mock[indy, :] = data_mock[indy, :] * np.sin(x_axis / 8)**2 data_mock = np.roll(data_mock, self.ind_data * self.settings.child( ('rolling')).value(), axis=1) try: self.image[self.settings.child('ROIselect', 'y0').value( ):self.settings.child('ROIselect', 'y0').value() + self.settings.child('ROIselect', 'height').value(), self.settings.child('ROIselect', 'x0').value( ):self.settings.child('ROIselect', 'x0').value() + self.settings.child('ROIselect', 'width').value( )] = data_mock except Exception as e: self.emit_status( ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log'])) else: x_axis = np.linspace(0, self.settings.child(('Nx')).value(), self.settings.child(('Nx')).value(), endpoint=False) y_axis = np.linspace(0, self.settings.child(('Ny')).value(), self.settings.child(('Ny')).value(), endpoint=False) data_mock = self.settings.child(('Amp')).value() * (mylib.gauss2D( x_axis, self.settings.child(('x0')).value(), self.settings.child(('dx')).value(), y_axis, self.settings.child(('y0')).value(), self.settings.child(('dy')).value(), self.settings.child(('n')).value())) + self.settings.child( ('amp_noise')).value() * np.random.rand( len(y_axis), len(x_axis)) for indy in range(data_mock.shape[0]): data_mock[indy, :] = data_mock[indy, :] * np.sin(x_axis / 4)**2 data_mock = np.roll(data_mock, self.ind_data * self.settings.child( ('rolling')).value(), axis=1) self.image = data_mock self.ind_data += 1 QThread.msleep(100) return self.image
app = QtWidgets.QApplication(sys.argv) win = QtWidgets.QMainWindow() area = DockArea() win.setCentralWidget(area) win.resize(1000, 500) win.setWindowTitle('pymodaq main') fake = FakeDaqScan(area) prog = DAQ_Viewer(area, title="Testing", DAQ_type='DAQ2D', parent_scan=fake) prog.ui.IniDet_pb.click() QThread.msleep(1000) QtWidgets.QApplication.processEvents() prog2 = DAQ_Viewer(area, title="Testing2", DAQ_type='DAQ2D', parent_scan=fake) prog2.ui.IniDet_pb.click() QThread.msleep(1000) QtWidgets.QApplication.processEvents() fake.detector_modules = [prog, prog2] items = OrderedDict() items[prog.title] = dict( viewers=[view for view in prog.ui.viewers], names=[view.title for view in prog.ui.viewers], )
def move_actuators(self, positions, mode='abs', polling=True): """will apply positions to each currently selected actuators. By Default the mode is absolute but can be Parameters ---------- positions: (list) the list of position to apply. Its length must be equal to the number of selected actutors mode: (str) either 'abs' for absolute positionning or 'rel' for relative poll: (bool) if True will wait for the selected actuators to reach their target positions (they have to be connected to a method checking for the position and letting the programm know the move is done (default connection is this object `move_done` method) Returns ------- (OrderedDict) with the selected actuators's name as key and current actuators's value as value See Also -------- move_done """ self.move_done_positions = OrderedDict() self.move_done_flag = False self.settings.child(('move_done')).setValue(self.move_done_flag) if mode == 'abs': command = 'move_Abs' elif mode == 'rel': command = 'move_Rel' else: logger.error(f'Invalid positioning mode: {mode}') return self.move_done_positions if not hasattr(positions, '__iter__'): positions = [positions] if len(positions) == self.Nactuators: if isinstance(positions, dict): for k in positions: act = self.get_mod_from_name(k, 'act') if act is not None: act.command_stage.emit( utils.ThreadCommand( command=command, attributes=[positions[k], polling])) else: for ind, act in enumerate(self.actuators): act.command_stage.emit( utils.ThreadCommand( command=command, attributes=[positions[ind], polling])) else: logger.error( 'Invalid number of positions compared to selected actuators') return self.move_done_positions tzero = time.perf_counter() if polling: while not self.move_done_flag: # polling move done QtWidgets.QApplication.processEvents() if time.perf_counter() - tzero > self.timeout: self.timeout_signal.emit(True) logger.error( 'Timeout Fired during waiting for data to be acquired') break QThread.msleep(20) self.move_done_signal.emit(self.move_done_positions) return self.move_done_positions
def ini_model(self): """ Defines all the action to be performed on the initialized modules (main pid, actuators, detectors) Either here for specific things (ROI, ...) or within the preset of the current model """ model_name = self.pid_controller.settings.child( 'models', 'model_class').value() self.pid_controller.detector_modules[0].ui.viewers[0].ui.roiBtn.click() #try to get corresponding roi file filename = os.path.join(get_set_pid_path(), model_name + '.roi2D') if os.path.isfile(filename): self.pid_controller.detector_modules[0].ui.viewers[0].load_ROI( filename) QtWidgets.QApplication.processEvents() if self.pid_controller.detector_modules[0].Initialized_state: #self.pid_controller.detector_modules[0].settings.child('main_settings', 'wait_time').setValue(0) self.pid_controller.detector_modules[0].grab_data() QThread.msleep(500) QtWidgets.QApplication.processEvents() self.pid_controller.settings.child('main_settings', 'update_modules').setValue(True) QtWidgets.QApplication.processEvents() QThread.msleep(500) QtWidgets.QApplication.processEvents() items = self.pid_controller.settings.child( 'main_settings', 'detector_modules').value().copy() if items is not None: items['selected'] = items['all_items'][0:2] self.pid_controller.settings.child( 'main_settings', 'detector_modules').setValue(items) self.pid_controller.settings.child( 'main_settings', 'pid_controls', 'output_limits', 'output_limit_min').setValue(0) #in microns self.pid_controller.settings.child( 'main_settings', 'pid_controls', 'output_limits', 'output_limit_min_enabled').setValue(True) self.pid_controller.settings.child( 'main_settings', 'pid_controls', 'output_limits', 'output_limit_max').setValue(15) #in microns self.pid_controller.settings.child( 'main_settings', 'pid_controls', 'output_limits', 'output_limit_max_enabled').setValue(True) self.pid_controller.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kp').setValue(0.5) self.pid_controller.settings.child('main_settings', 'pid_controls', 'pid_constants', 'ki').setValue(0.2) self.pid_controller.settings.child('main_settings', 'pid_controls', 'pid_constants', 'kd').setValue(0.0001) self.pid_controller.settings.child('main_settings', 'pid_controls', 'filter', 'filter_enable').setValue(True) self.pid_controller.settings.child( 'main_settings', 'pid_controls', 'filter', 'filter_step').setValue( self.settings.child('stabilization', 'laser_wl').value() / 1000 / 6 / 2) #in microns self.pid_controller.setpoint_sb.setValue(7.5) self.pid_controller.settings.child('main_settings', 'pid_controls', 'sample_time').setValue(50)
def run(self): logger = logging.getLogger("SSTF-FDF-SCAN") incomming = collections.deque(copy.deepcopy(self.que)) queue = collections.deque() completed = collections.deque() current_pos = self.start_pos time = incomming[0].arrive_time target = None self.setHeadPos(current_pos) while True: for request in list(incomming): if request.arrive_time <= time: queue.append(request) incomming.remove(request) self.addRequest(request.cylinder) logger.debug("POS: {} QUEUE: {}".format(current_pos, [ str(req.cylinder) + "*" if req.real_time else str(req.cylinder) for req in queue ])) if len(queue) != 0: if target: if target.cylinder == current_pos: logger.debug( "Head over target cylinder {}".format(current_pos)) queue.remove(target) completed.append(target) QThread.msleep(100) self.removeRequest(target.cylinder) target = None else: for request_in_cylinder in [ req for req in queue if req.cylinder == current_pos ]: logger.debug("Request {} scaned on pos {}".format( request_in_cylinder.request_id, request_in_cylinder.cylinder)) queue.remove(request_in_cylinder) completed.append(request_in_cylinder) self.removeRequest(request_in_cylinder.cylinder) time = time + 1 if current_pos < target.cylinder: current_pos = current_pos + 1 else: current_pos = current_pos - 1 time = time + 1 for other in list(queue): other.add_wait_time(1) QThread.msleep(100) self.setHeadPos(current_pos) else: # no target, check for new real time requests real_time = [req for req in queue if req.real_time] if len(real_time) > 0: nearest_realtime: Request = min( real_time, key=operator.attrgetter("deadline")) if nearest_realtime.deadline >= abs( current_pos - nearest_realtime.cylinder): target = nearest_realtime logger.debug( "Target set to request {}, Deadline {} >= Delta pos {}" .format( nearest_realtime.cylinder, nearest_realtime.deadline, abs(current_pos - nearest_realtime.cylinder))) else: # request too far, fallback to sstf logger.debug( "Not worth to process request {}, Deadline: {} < Delta pos {}" .format( nearest_realtime.cylinder, nearest_realtime.deadline, abs(current_pos - nearest_realtime.cylinder))) nearest: Request = min( queue, key=lambda req: abs(current_pos - req.cylinder )) queue.remove(nearest) completed.append(nearest) self.removeRequest(nearest.cylinder) # calculate delta of head position and add it to time delta = abs(current_pos - nearest.cylinder) current_pos = nearest.cylinder time = time + delta for other in list(queue): other.add_wait_time(delta) QThread.msleep(100) self.setHeadPos(current_pos) else: # no real time requests, fallback to sstf nearest: Request = min( queue, key=lambda req: abs(current_pos - req.cylinder)) queue.remove(nearest) completed.append(nearest) self.removeRequest(nearest.cylinder) # calculate delta of head position and add it to time delta = abs(current_pos - nearest.cylinder) current_pos = nearest.cylinder time = time + delta for other in list(queue): other.add_wait_time(delta) QThread.msleep(100) self.setHeadPos(current_pos) if len(incomming) == 0 and len(queue) == 0: break longest_waiting = max(completed, key=operator.attrgetter("wait_time")) logger.info("================= SSTF-FDF-SCAN =================") logger.info("Switches to SCAN if real time requests arrive.") logger.info("Average waiting time: {}".format( round(sum(req.wait_time for req in completed) / len(completed), 2))) logger.info( "Request with longest waiting time ID: {}, Time: {}, Cylinder: {}, Arrived: {}, Real-time: {}" .format(longest_waiting.request_id, longest_waiting.wait_time, longest_waiting.cylinder, longest_waiting.arrive_time, longest_waiting.real_time))