def macro_start(self, name, wait=True):
with MutexContainer(self._mutex):
self.XYZ_c.MAC_START(name)
if wait:
time.sleep(1)
while self.is_macro_running():
time.sleep(1)
def run_waveform(self, time_step, X, wait=True, measure_time_step=None):
with MutexContainer(self._mutex):
# Get stage coordinates
X[:, :3] = self.XmtoXs(X[:, :3])
self._lastXs = X[-1, :3].copy()
wait_time = self.XYZ_c.run_waveform(
time_step, X, measure_time_step=measure_time_step)
if wait:
self.XYZ_c.wait_end_wave(wait_time)
def focus(self,
stage,
*,
start_offset=None,
stop_offset=None,
step=None,
intensity=None,
Nloops=None,
wait=False,
checkid=None,
change_coordinates=True,
speed=None,
quick=None):
"""
start_offset:
How far back from current position
stop_offset:
How far forth from surrent position
step:
Step size
Nloops default 1:
Each loop has a 10X smaller step size.
wait default False:
Should the thread wait for completion
"""
if not self.app_delegate.camera_delegate.isZoomed():
raise FocusError('Must select ROI to focus!')
if self.thread.isRunning():
raise FocusError('Already Focusing')
with MutexContainer(self._mutex):
self._last_result = None
if intensity is not None:
self._settings["intensity"] = intensity
if start_offset is not None:
self._settings["From"] = start_offset
if stop_offset is not None:
self._settings["To"] = stop_offset
if step is not None:
self._settings["Step"] = step
if Nloops is not None:
self._settings["Nloops"] = Nloops
if speed is not None:
self._settings["speed"] = speed
if quick is not None:
self._settings["quick"] = quick
self.update_settings.emit(self._settings)
self.thread.set_args(self._settings, stage, checkid,
change_coordinates)
self.thread.start()
if wait:
self.wait_thread()
def _set_hardware(self, hardware):
with MutexContainer(type(self)._mutex):
type(self)._isConnecting = False
if hardware is None or hardware == type(self)._hardware:
return
type(self)._hardware = hardware
print(f'{self._name} set')
if self._isConnected() and self._connect_callback is not None:
self._connect_callback()
self.on_connect_signal.emit()
def __init__(self, name, connect_callback=None):
super().__init__()
with MutexContainer(Hardware_Singleton.__mutex):
if "_number_instances" not in dir(type(self)):
type(self)._hardware = None
type(self)._isConnecting = False
type(self)._mutex = QtCore.QMutex(QtCore.QMutex.Recursive)
type(self)._number_instances = 1
type(self)._name = name
type(self)._thread = Hardware_Thread(
self._set_hardware, self._open_connection)
else:
type(self)._number_instances += 1
self._set_attribute("_connect_callback", connect_callback)
self._connect()
def _disconnect(self):
with MutexContainer(type(self)._mutex):
if self._isConnected():
self._close_connection()
type(self)._hardware = None
def _connect(self):
with MutexContainer(type(self)._mutex):
if not self._isConnected() and not type(self)._isConnecting:
type(self)._isConnecting = True
print(f'{self._name} connecting')
type(self)._thread.start()
def __setattr__(self, name, value):
self._wait_connected()
with MutexContainer(type(self)._mutex):
setattr(type(self)._hardware, name, value)
def __getattr__(self, name):
self._wait_connected()
with MutexContainer(type(self)._mutex):
return getattr(type(self)._hardware, name)
def goto_position(self,
XTo,
speed=np.nan,
*,
wait=False,
checkid=None,
useLastPos=False,
isRaw=False):
"""Moves to the position
Parameters:
----------
Xm:
Position to go to [um]
speed:
Speed [um/s]
wait:
Should the call be blocking?
checkid:
If the movment is locked, the checkid
useLastPos:
Use for performance. Avoid calling pos()
(Might be useless)
isRaw:
Is Xm raw or corrected?
Note:
Any value of Xm set to nan will not be moved
"""
# Check lock
if not self._checklock(checkid):
return
with MutexContainer(self._mutex):
# get starting point
XsFrom = None
if useLastPos:
XsFrom = self._lastXs
else:
XsFrom = self._XSPOS()
XsTo, XmTo, Vs, travel_time = self.move_parameters(
XTo, XsFrom, speed, isRaw)
# Don't move if final = now
if np.linalg.norm(XsTo - XsFrom) < 1e-3:
return
# Move
self.move_signal.emit(list(XmTo), speed)
self._MOVVEL(XsTo, Vs)
# Wait for movment to end
if wait:
tstart = time.time()
self.wait_end_motion(travel_time, 300)
twait = time.time() - tstart
if twait - travel_time > 1:
with open('waitlog.txt', 'a') as f:
f.write(
f'expected: {travel_time} actual:{twait} from:{XsFrom} to:{XsTo}\r\n'
)