def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector.
Returns
-------
???
the initialized status.
See Also
--------
set_Mock_data
"""
self.status.update(
edict(initialized=False,
info="",
x_axis=None,
y_axis=None,
controller=None))
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 = "Mock controller"
self.set_Mock_data()
self.emit_status(
ThreadCommand('update_main_settings',
[['wait_time'],
self.settings.child(
('wait_time')).value(), 'value']))
# initialize viewers with the future type of data
self.data_grabed_signal.emit([
DataFromPlugins(name='Mock1',
data=[np.array(0)],
dim='Data0D',
labels=['Mock1', 'label2'])
])
self.status.initialized = True
self.status.controller = self.controller
return self.status
def update_settings(self, settings_parameter_dict):
"""
Update the settings tree from settings_parameter_dict.
Finally do a commit to activate changes.
========================== ============= =====================================================
**Parameters** **Type** **Description**
*settings_parameter_dict* dictionnnary a dictionnary listing path and associated parameter
========================== ============= =====================================================
See Also
--------
send_param_status, commit_settings
"""
# settings_parameter_dict=edict(path=path,param=param)
try:
path = settings_parameter_dict['path']
param = settings_parameter_dict['param']
change = settings_parameter_dict['change']
try:
self.settings.sigTreeStateChanged.disconnect(
self.send_param_status)
except:
pass
if change == 'value':
self.settings.child(*path[1:]).setValue(
param.value()) #blocks signal back to main UI
elif change == 'childAdded':
child = Parameter.create(name='tmp')
child.restoreState(param)
self.settings.child(*path[1:]).addChild(
child) #blocks signal back to main UI
param = child
elif change == 'parent':
children = custom_tree.get_param_from_name(
self.settings, param.name())
if children is not None:
path = custom_tree.get_param_path(children)
self.settings.child(*path[1:-1]).removeChild(children)
self.settings.sigTreeStateChanged.connect(self.send_param_status)
self.commit_settings(param)
except Exception as e:
self.emit_status(ThreadCommand("Update_Status", [str(e), 'log']))
def set_option(self,**option):
for key in option:
if hasattr(self.pid, key):
if key == 'sample_time':
setattr(self.pid, key, option[key]/1000)
else:
setattr(self.pid,key, option[key])
if key == 'setpoint' and not self.pid.auto_mode:
dt = time.perf_counter() - self.current_time
self.output = option[key]
self.output_to_actuator = self.model_class.convert_output(self.output, dt, stab=False)
for ind_move, cmd in enumerate(self.move_modules_commands):
cmd.emit(ThreadCommand('move_Abs', [self.output_to_actuator[ind_move]]))
self.current_time = time.perf_counter()
if key == 'output_limits':
self.output_limits = option[key]
def __init__(self, parent=None, params_state=None):
super(DAQ_Move_Kinesis, self).__init__(parent, params_state)
self.controller = None
self.settings.child(('epsilon')).setValue(0.01)
try:
#kinesis_path=os.environ['Kinesis'] #environement variable pointing to 'C:\\Program Files\\Thorlabs\\Kinesis'
#to be adjusted on the different computers
self.move_done_action = self.Action[self.UInt64](self.move_done)
except Exception as e:
self.emit_status(
ThreadCommand("Update_Status",
[getLineInfo() + str(e), 'log']))
raise Exception(getLineInfo() + str(e))
def check_position(self):
"""
Get the current hardware position with scaling conversion given by get_position_with_scaling.
"""
position = self.controller.get_position(
self.settings.child('multiaxes', 'axis').value())
# the position given by the controller is in nanometers, we convert in micrometers
position = float(position) / 1e3
# convert position if scaling options have been used, mandatory here
position = self.get_position_with_scaling(position)
self.current_position = position
self.emit_status(ThreadCommand('check_position', [position]))
return position
def commit_settings(self, param):
"""
| Activate parameters changes on the hardware from parameter's name.
|
=============== ================================ =========================
**Parameters** **Type** **Description**
*param* instance of pyqtgraph parameter The parameter to activate
=============== ================================ =========================
Three profile of parameter :
* **bin_x** : set binning camera from bin_x parameter's value
* **bin_y** : set binning camera from bin_y parameter's value
* **set_point** : Set the camera's temperature from parameter's value.
"""
try:
if param.name() == 'bin_x':
self.controller.setBinning(param.value(), self.settings.child('binning_settings', 'bin_y').value())
Nx, Ny = self.controller.getImageSize()
self.settings.child('image_size', 'Nx').setValue(Nx)
self.settings.child('image_size', 'Ny').setValue(Ny)
elif param.name() == 'bin_y':
self.controller.setBinning(self.settings.child('binning_settings', 'bin_x').value(), param.value())
Nx, Ny = self.controller.getImageSize()
self.settings.child('image_size', 'Nx').setValue(Nx)
self.settings.child('image_size', 'Ny').setValue(Ny)
elif param.name() == 'exposure':
self.controller.setExposureTime(self.settings.child(('exposure')).value())
elif param.name() == 'set_point':
self.controller.setTemperature(param.value())
elif param.name() == 'manufacturer':
mod = sys.modules[__name__] # current module
models = getattr(mod, '{:s}_models'.format(param.name()))
if models == []:
models = ['']
self.settings.child(('model')).setOpts(limits=models)
if 'PIXIS: 256E' in models:
self.settings.child(('model')).setValue('PIXIS: 256E')
elif param.name() == 'camera_mode':
self.update_camera_mode(param.value())
except Exception as e:
self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
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=self.VISA_rm.open_resource(self.settings.child(('VISA_ressources')).value(), read_termination='\r')
self.controller.timeout=self.settings.child(('timeout')).value()
self.controller.write("*rst; status:preset; *cls;")
txt=self.controller.query('*IDN?')
self.settings.child(('id')).setValue(txt)
self.controller.write('CONF:'+self.settings.child('config','meas_type').value())
self.controller.write(':FORM:ELEM READ;DATA ASC;')
self.controller.write('ARM:SOUR IMM;')
self.controller.write('ARM:COUNt 1;')
self.controller.write('TRIG:SOUR IMM;')
#%%
data=self.controller.query_ascii_values('READ?')
self.status.initialized=True
self.status.controller=self.controller
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 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 = active_dso
usb_address = "USBTMC:" + self.settings.child(
('VISA_ressources')).value()
self.controller.MakeConnection(usb_address)
# set the timeout of the scope to 10 seconds
# may be not needed
self.controller.setTimeout(10)
self.status.initialized = True
self.status.controller = self.controller
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 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=self.VISA_rm.open_resource(self.settings.child(('VISA_ressources')).value())
self.controller.timeout=self.settings.child(('timeout')).value()
idn = self.controller.query('OUTX1;*IDN?;')
idn = idn.rstrip('\n')
idn = idn.rsplit(',')
if len(idn)>=0:
self.settings.child(('manufacturer')).setValue(idn[0])
if len(idn) >= 1:
self.settings.child(('model')).setValue(idn[1])
if len(idn) >= 2:
self.settings.child(('serial_number')).setValue(idn[2])
self.reset()
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 ini_detector(self, controller=None):
"""
Initialisation procedure of the detector initializing the status dictionnary.
See Also
--------
daq_utils.ThreadCommand, get_xaxis, get_yaxis
"""
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 = "Mock controller"
self.x_axis = self.get_xaxis()
self.y_axis = self.get_yaxis()
# initialize viewers with the future type of data but with 0value data
self.data_grabed_signal_temp.emit(self.average_data(1, True))
# OrderedDict(name='Mock3', data=[np.zeros((128,))], type='Data1D')])
self.status.x_axis = self.x_axis
self.status.y_axis = self.y_axis
self.status.initialized = True
self.status.controller = self.controller
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 ini_detector(self, controller=None):
"""
Initialisation procedure of the detector initializing the status dictionnary.
See Also
--------
daq_utils.ThreadCommand, get_xaxis, get_yaxis
"""
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 = MokeMockController(
noise=self.settings.child('noise').value(),
amp=self.settings.child('amp').value(),
flake_size=self.settings['flake'],
degree=self.settings['degree'])
self.x_axis = self.controller.get_xaxis()
self.y_axis = self.controller.get_yaxis()
self.status.x_axis = self.x_axis
self.status.y_axis = self.y_axis
self.status.initialized = True
self.status.controller = self.controller
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 emit_data_tmp(self):
"""
"""
try:
mode = self.settings.child('acquisition', 'acq_type').value()
if mode == 'Counting' or mode == 'Histo' or mode == 'T3':
super(DAQ_2DViewer_FLIM, self).emit_data_tmp()
elif mode == 'FLIM':
self.data_grabed_signal_temp.emit([OrderedDict(name='TH260', data=self.datas, type='DataND', nav_axes=(0, 1),
nav_x_axis=self.get_nav_xaxis(),
nav_y_axis=self.get_nav_yaxis(),
xaxis=self.get_xaxis())])
except Exception as e:
self.emit_status(ThreadCommand('Update_Status', [getLineInfo() + str(e), 'log']))
def command_done(self, command_sock):
try:
sock = self.find_socket_within_connected_clients(self.client_type)
if sock is not None: # if client self.client_type is connected then send it the command
data = self.read_data(sock)
else:
data = self.data_mock
if command_sock is None:
# self.data_grabed_signal.emit([OrderedDict(data=[data],name='TCP GRABBER', type='Data2D')]) #to be directly send to a viewer
self.data_ready(data)
# print(data)
else:
self.send_data(command_sock, data) # to be send to a client
except Exception as e:
self.emit_status(ThreadCommand("Update_Status", [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
"""
if not self.controller.isOpened():
self.controller.open(self.settings.child(('camera_index')).value())
ret, frame = self.controller.read()
# print(ret)
# print(frame[:,:,0])
# print(frame.shape)
# QThread.msleep(500)
if ret:
if self.settings.child(('colors')).value() == 'gray':
data_cam = [cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)]
data_cam[0] = data_cam[0].astype(np.float32)
else:
if len(frame.shape) == 3:
data_cam = [
frame[:, :, ind] for ind in range(frame.shape[2])
]
else:
data_cam = [cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)]
else:
data_cam = [np.zeros((len(self.y_axis), len(self.x_axis)))]
self.emit_status(
ThreadCommand('Update_Status',
['no return from the controller', 'log']))
data = [DataFromPlugins(name='OpenCV', data=data_cam, dim='Data2D')]
self.data_grabed_signal.emit(data)
def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector with Picoscope 5000A profile.
See Also
--------
daq_utils.ThreadCommand, update_pico_settings
"""
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.pico=controller
try:
self.pico.stop()
status=self.pico.close_unit()
except:
pass
else:
self.pico=picoscope.Picoscope_5000A()
status=self.pico.open_unit(None,dynamic_range= picoscope.DAQ_Picoscope_dynamic[self.settings.child('main_settings','dynamic').value()].value)
if status[0]=="PICO_OK":
self.update_pico_settings()
self.pico.overflow_signal.connect(self.set_overflow)
self.status.initialized=True
self.status.controller=self.pico
return self.status
else:
#self.emit_status(ThreadCommand('Update_Status',[status[0],'log']))
self.status.info=status[0]
self.status.initialized=False
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 ini_detector(self, controller=None):
"""
Initialisation procedure of the detector initializing the status dictionnary.
See Also
--------
DAQ_utils.ThreadCommand, get_xaxis, get_yaxis
"""
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 = cv2.VideoCapture(
self.settings.child(('camera_index')).value())
#self.get_active_properties() #to add settable settings to the param list (but driver builtin settings window is prefered (OpenCVProp['CV_CAP_PROP_SETTINGS'])
self.x_axis = self.get_xaxis()
self.y_axis = self.get_yaxis()
self.status.x_axis = self.x_axis
self.status.y_axis = self.y_axis
self.status.initialized = True
self.status.controller = self.controller
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 commit_settings(self,param):
"""
Setting the mock data
============== ========= =================
**Parameters** **Type** **Description**
*param* none not used
============== ========= =================
See Also
--------
set_Mock_data
"""
if param.name() == 'show_navigator':
self.emit_status(ThreadCommand('show_navigator'))
param.setValue(False)
else:
self.set_Mock_data()
def check_position(self):
"""Get the current position from the hardware with scaling conversion.
Returns
-------
float: The position obtained after scaling conversion.
"""
#pos = self.target_position
while not self.controller['ai'].isTaskDone():
self.controller['ai'].task.StopTask()
data = self.controller['ai'].readAnalog(len(self.channels_ai), self.clock_settings_ai)
pos = np.mean(data) / self.settings.child('ai', 'resistor').value()
pos = self.get_position_with_scaling(pos)
self.emit_status(ThreadCommand('check_position', [pos]))
return pos
def __init__(self, parent=None, params_state=None):
super(DAQ_Move_Conex, self).__init__(parent, params_state)
self.settings.child(('epsilon')).setValue(0.0001)
#to be adjusted on the different computers
try:
sys.path.append(self.settings.child(('conex_lib')).value())
clr.AddReference("ConexAGAPCmdLib")
import Newport.ConexAGAPCmdLib as Conexcmd
self.controller = Conexcmd.ConexAGAPCmds()
self.settings.child('bounds', 'is_bounds').setValue(True)
self.settings.child('bounds', 'min_bound').setValue(-0.02)
self.settings.child('bounds', 'max_bound').setValue(0.02)
except Exception as e:
self.emit_status(
ThreadCommand("Update_Status", [getLineInfo() + str(e)]))
raise Exception(getLineInfo() + str(e))
def move_Rel(self, position):
""" Move the actuator to the relative target actuator value defined by position
Parameters
----------
position: (flaot) value of the relative target positioning
"""
position = self.check_bound(self.current_position +
position) - self.current_position
self.target_position = position + self.current_position
## TODO for your custom plugin
self.controller.your_method_to_set_a_relative_value()
self.emit_status(
ThreadCommand('Update_Status', ['Some info you want to log']))
##############################
self.poll_moving()
def grab_data(self, Naverage=1, **kwargs):
"""
"""
try:
datas=[]
for ind_spectro in range(len(self.spectro_names)):
if self.settings.child('spectrometers','spectro{:d}'.format(ind_spectro),'grab').value():
self.controller.setScansToAverage(ind_spectro,Naverage)
data_chelou=self.controller.getSpectrum(ind_spectro)
data=np.array([data_chelou[ind] for ind in range(len(data_chelou))])
datas.append(OrderedDict(name=self.spectro_names[ind_spectro],data=[data], type='Data1D'))
QtWidgets.QApplication.processEvents()
self.data_grabed_signal.emit(datas)
except Exception as e:
self.emit_status(ThreadCommand('Update_Status',[getLineInfo()+ str(e),"log"]))
def check_position(self):
"""
Check the current position from the hardware.
Returns
-------
float
The position of the hardware.
See Also
--------
DAQ_Move_base.get_position_with_scaling, daq_utils.ThreadCommand
"""
position = self.controller.get_position(self._axis)
pos = self.get_position_with_scaling(position)
self.current_position = pos
self.emit_status(ThreadCommand('check_position', [pos]))
return self.target_position
def init_connection(self):
# %%
try:
# create an INET, STREAMing socket
self.socket = Socket(
socket.socket(socket.AF_INET, socket.SOCK_STREAM))
# now connect to the web server on port 80 - the normal http port
self.socket.connect((self.ipaddress, self.port))
self.cmd_signal.emit(ThreadCommand('connected'))
self.socket.send_string(self.client_type)
self.send_infos_xml(
custom_tree.parameter_to_xml_string(self.settings))
self.cmd_signal.emit(ThreadCommand('get_axis'))
self.connected = True
# %%
while True:
try:
ready_to_read, ready_to_write, in_error = \
select.select([self.socket.socket], [self.socket.socket], [self.socket.socket], 0)
if len(ready_to_read) != 0:
message = self.socket.get_string()
# print(message)
self.get_data(message)
if len(in_error) != 0:
self.connected = False
self.cmd_signal.emit(ThreadCommand('disconnected'))
QtWidgets.QApplication.processEvents()
except Exception as e:
try:
self.cmd_signal.emit(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
self.socket.send_string('Quit')
self.socket.close()
except:
pass
finally:
break
except ConnectionRefusedError as e:
self.connected = False
self.cmd_signal.emit(ThreadCommand('disconnected'))
self.cmd_signal.emit(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
def move_Rel(self, position):
""" Move the actuator to the relative target actuator value defined by position
Parameters
----------
position: (flaot) value of the relative target positioning
"""
position = self.check_bound(self.current_position +
position) - self.current_position
self.target_position = position + self.current_position
axis = self.settings.child('multiaxes', 'axis').value()
if axis != 'offset':
self.settings.child(axis, f'{axis}_val').setValue(position)
else:
self.settings.child(axis).setValue(position)
self.check_led_and_update()
self.emit_status(
ThreadCommand('Update_Status', ['Some info you want to log']))
def commit_settings(self, param):
"""
Setting the mock data.
============== ========= =================
**Parameters** **Type** **Description**
*param* none not used
============== ========= =================
See Also
--------
set_Mock_data
"""
self.set_Mock_data()
if param.name() == 'wait_time':
self.emit_status(
ThreadCommand(
'update_main_settings',
[['wait_time'], param.value(), 'value']))
def check_position(self):
"""
Get the current position from the hardware with scaling conversion.
Returns
-------
float
The position obtained after scaling conversion.
See Also
--------
DAQ_Move_base.get_position_with_scaling, daq_utils.ThreadCommand
"""
pos=self.current_position
#print('Pos from controller is {}'.format(pos))
#pos=self.get_position_with_scaling(pos)
#self.current_position=pos
self.emit_status(ThreadCommand('check_position',[pos]))
return pos
def ini_detector(self, controller=None):
"""
Initialisation procedure of the detector updating the status dictionnary.
See Also
--------
set_Mock_data, 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 = Labspec6Client()
ret, data, extra = self.controller.connect(self.settings.child('connection', 'ip_address').value(),
self.settings.child('connection', 'port').value())
if ret != 'OK':
raise IOError('Wrong return from Server')
self.settings.child('connection', 'controllerid').setValue(data)
self.controller.timeout_mult = self.settings.child('connection', 'timeout').value()
self.init_params()
# initialize viewers with the future type of data
self.x_axis = self.controller.get_x_axis()
self.data_grabed_signal_temp.emit([DataFromPlugins(name='LabSpec6', data=[self.x_axis*0], dim='Data1D',
x_axis=Axis(data=self.x_axis, units='nm', label='Wavelength'), labels=['Spectrum']),])
self.status.initialized = True
self.status.controller = self.controller
self.status.x_axis = self.x_axis
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 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:
if param.name() == 'timeout':
self.inst.timeout = self.settings.child(('timeout')).value()
elif param.name() == 'mode':
self.query_str('REFMODE {}'.format(
ReferenceModes[param.value()].value))
elif param.name() == 'channels':
data_init = []
for channel in param.value()['selected']:
if self.settings.child('config',
'separate_viewers').value():
data_init.append(
OrderedDict(name=channel,
data=[np.array([0])],
type='Data0D'))
else:
data_init.append(np.array([0]))
if self.settings.child('config', 'separate_viewers').value():
self.data_grabed_signal_temp.emit(data_init)
else:
self.data_grabed_signal_temp.emit([
OrderedDict(name='Keithley',
data=data_init,
type='Data0D')
])
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
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:
pass
except Exception as e:
self.emit_status(
ThreadCommand('Update_Status',
[getLineInfo() + str(e), 'log']))
def emit_data(self):
"""
Function used to emit data when data ready. optional see Plugins documentation
"""
try:
########################## to modify below #####################
#################################################################
self.ind_grabbed+=1
sizey = self.settings.child('camera_settings','image_size','Ny').value()
sizex = self.settings.child('camera_settings','image_size','Nx').value()
self.controller.GetAcquiredDataNumpy(self.data_pointer, sizex*sizey)
self.data_grabed_signal.emit([OrderedDict(name='Camera',data=[np.squeeze(self.data.reshape((sizey, sizex)).astype(np.float))], type=self.data_shape)])
#######################################################################
##################################################################
except Exception as e:
self.emit_status(ThreadCommand('Update_Status',[str(e),'log']))
