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