class NamingTrasher(threading.Thread):
def __init__(self, nsuri, number):
threading.Thread.__init__(self)
self.daemon = True
self.number = number
self.ns = Proxy(nsuri)
self.mustStop = False
def list(self):
items = self.ns.list()
def register(self):
for i in range(4):
try:
self.ns.register(randomname(), 'PYRO:objname@host:555')
except Pyro5.errors.NamingError:
pass
def remove(self):
self.ns.remove(randomname())
def lookup(self):
try:
uri = self.ns.lookup(randomname())
except Pyro5.errors.NamingError:
pass
def listprefix(self):
entries = self.ns.list(prefix="stresstest.51")
def listregex(self):
entries = self.ns.list(regex=r"stresstest\.??\.41.*")
def run(self):
print("Name Server trasher running.")
self.ns._pyroClaimOwnership()
while not self.mustStop:
random.choice((self.list, self.register, self.remove, self.lookup, self.listregex, self.listprefix))()
sys.stdout.write("%d " % self.number)
sys.stdout.flush()
time.sleep(0.001)
print("Trasher exiting.")
class SEM(model.HwComponent):
"""
Class to communicate with a Microscope server via the ZeroRPC protocol.
"""
def __init__(self, name, role, children, address, daemon=None, **kwargs):
"""
Parameters
----------
address: str
server address and port of the Microscope server, e.g. "PYRO:Microscope@localhost:4242"
timeout: float
Time in seconds the client should wait for a response from the server.
"""
model.HwComponent.__init__(self, name, role, daemon=daemon, **kwargs)
self._proxy_access = threading.Lock()
try:
self.server = Proxy(address)
self.server._pyroTimeout = 30 # seconds
self._swVersion = self.server.get_software_version()
self._hwVersion = self.server.get_hardware_version()
except Exception as err:
raise HwError(
"Failed to connect to XT server '%s'. Check that the "
"uri is correct and XT server is"
" connected to the network. %s" % (address, err))
# create the scanner child
try:
kwargs = children["scanner"]
except (KeyError, TypeError):
raise KeyError("SEM was not given a 'scanner' child")
self._scanner = Scanner(parent=self, daemon=daemon, **kwargs)
self.children.value.add(self._scanner)
# create the stage child, if requested
if "stage" in children:
ckwargs = children["stage"]
self._stage = Stage(parent=self, daemon=daemon, **ckwargs)
self.children.value.add(self._stage)
# create a focuser, if requested
if "focus" in children:
ckwargs = children["focus"]
self._focus = Focus(parent=self, daemon=daemon, **ckwargs)
self.children.value.add(self._focus)
def list_available_channels(self):
"""
List all available channels and their current state as a dict.
Returns
-------
available channels: dict
A dict of the names of the available channels as keys and the corresponding channel state as values.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.list_available_channels()
def move_stage(self, position, rel=False):
"""
Move the stage the given position in meters. This is non-blocking. Throws an error when the requested position
is out of range.
Parameters
----------
position: dict(string->float)
Absolute or relative position to move the stage to per axes in m. Axes are 'x' and 'y'.
rel: boolean
If True the staged is moved relative to the current position of the stage, by the distance specified in
position. If False the stage is moved to the absolute position.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.move_stage(position, rel)
def stage_is_moving(self):
"""Returns: (bool) True if the stage is moving and False if the stage is not moving."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.stage_is_moving()
def stop_stage_movement(self):
"""Stop the movement of the stage."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.stop_stage_movement()
def get_stage_position(self):
"""
Returns: (dict) the axes of the stage as keys with their corresponding position.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_stage_position()
def stage_info(self):
"""Returns: (dict) the unit and range of the stage position."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.stage_info()
def acquire_image(self, channel_name):
"""
Acquire an image observed via the currently set channel. Note: the channel needs to be stopped before an image
can be acquired. To acquire multiple consecutive images the channel needs to be started and stopped. This
causes the acquisition speed to be approximately 1 fps.
Returns
-------
image: numpy array
The acquired image.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
x_enc = self.server.acquire_image(channel_name)
x_dec = base64.b64decode(x_enc['data'])
x_rec = msgpack.unpackb(x_dec, object_hook=m.decode)
return x_rec
def set_scan_mode(self, mode):
"""
Set the scan mode.
Parameters
----------
mode: str
Name of desired scan mode, one of: unknown, external, full_frame, spot, or line.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_scan_mode(mode)
def set_selected_area(self, start_position, size):
"""
Specify a selected area in the scan field area.
Parameters
----------
start_position: (tuple of int)
(x, y) of where the area starts in pixel, (0,0) is at the top left.
size: (tuple of int)
(width, height) of the size in pixel.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_selected_area(start_position, size)
def get_selected_area(self):
"""
Returns
-------
x, y, width, height: pixels
The current selected area. If selected area is not active it returns the stored selected area.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
x, y, width, height = self.server.get_selected_area()
return x, y, width, height
def selected_area_info(self):
"""Returns: (dict) the unit and range of set selected area."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.selected_area_info()
def reset_selected_area(self):
"""Reset the selected area to select the entire image."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.reset_selected_area()
def set_scanning_size(self, x):
"""
Set the size of the to be scanned area (aka field of view or the size, which can be scanned with the current
settings).
Parameters
----------
x: (float)
size for X in meters.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_scanning_size(x)
def get_scanning_size(self):
"""
Returns: (tuple of floats) x and y scanning size in meters.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_scanning_size()
def scanning_size_info(self):
"""Returns: (dict) the scanning size unit and range."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.scanning_size_info()
def set_ebeam_spotsize(self, spotsize):
"""
Setting the spot size of the ebeam.
Parameters
----------
spotsize: float
desired spotsize, unitless
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_ebeam_spotsize(spotsize)
def get_ebeam_spotsize(self):
"""Returns: (float) the current spotsize of the electron beam (unitless)."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_ebeam_spotsize()
def spotsize_info(self):
"""Returns: (dict) the unit and range of the spotsize. Unit is None means the spotsize is unitless."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.spotsize_info()
def set_dwell_time(self, dwell_time):
"""
Parameters
----------
dwell_time: float
dwell time in seconds
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_dwell_time(dwell_time)
def get_dwell_time(self):
"""Returns: (float) the dwell time in seconds."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_dwell_time()
def dwell_time_info(self):
"""Returns: (dict) range of the dwell time and corresponding unit."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.dwell_time_info()
def set_ht_voltage(self, voltage):
"""
Set the high voltage.
Parameters
----------
voltage: float
Desired high voltage value in volt.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_ht_voltage(voltage)
def get_ht_voltage(self):
"""Returns: (float) the HT Voltage in volt."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_ht_voltage()
def ht_voltage_info(self):
"""Returns: (dict) the unit and range of the HT Voltage."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.ht_voltage_info()
def blank_beam(self):
"""Blank the electron beam."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.blank_beam()
def unblank_beam(self):
"""Unblank the electron beam."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.unblank_beam()
def beam_is_blanked(self):
"""Returns: (bool) True if the beam is blanked and False if the beam is not blanked."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.beam_is_blanked()
def pump(self):
"""Pump the microscope's chamber. Note that pumping takes some time. This is blocking."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.pump()
def get_vacuum_state(self):
"""Returns: (string) the vacuum state of the microscope chamber to see if it is pumped or vented."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_vacuum_state()
def vent(self):
"""Vent the microscope's chamber. Note that venting takes time (appr. 3 minutes). This is blocking."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.vent()
def get_pressure(self):
"""Returns: (float) the chamber pressure in pascal."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_pressure()
def home_stage(self):
"""Home stage asynchronously. This is non-blocking."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.home_stage()
def is_homed(self):
"""Returns: (bool) True if the stage is homed and False otherwise."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.is_homed()
def set_channel_state(self, name, state):
"""
Stop or start running the channel. This is non-blocking.
Parameters
----------
name: str
name of channel.
state: "run" or "stop"
desired state of the channel.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_channel_state(name, state)
def wait_for_state_changed(self, desired_state, name, timeout=10):
"""
Wait until the state of the channel has changed to the desired state, if it has not changed after a certain
timeout an error will be raised.
Parameters
----------
desired_state: "run", "stop" or "cancel"
The state the channel should change into.
name: str
name of channel.
timeout: int
Amount of time in seconds to wait until the channel state has changed.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.wait_for_state_changed(desired_state, name, timeout)
def get_channel_state(self, name):
"""Returns: (str) the state of the channel: "run", "stop" or "cancel"."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_channel_state(name)
def get_free_working_distance(self):
"""Returns: (float) the free working distance in meters."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_free_working_distance()
def set_free_working_distance(self, free_working_distance):
"""
Set the free working distance.
Parameters
----------
free_working_distance: float
free working distance in meters.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_free_working_distance(free_working_distance)
def fwd_info(self):
"""Returns the unit and range of the free working distance."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.fwd_info()
def get_fwd_follows_z(self):
"""
Returns: (bool) True if Z follows free working distance.
When Z follows FWD and Z-axis of stage moves, FWD is updated to keep image in focus.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_fwd_follows_z()
def set_fwd_follows_z(self, follow_z):
"""
Set if z should follow the free working distance. When Z follows FWD and Z-axis of stage moves, FWD is updated
to keep image in focus.
Parameters
---------
follow_z: bool
True if Z should follow free working distance.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_fwd_follows_z(follow_z)
def set_autofocusing(self, channel, state):
"""
Set the state of autofocus, beam must be turned on. This is non-blocking.
Parameters
----------
channel: xtlib channel object
One of the electron channels, the channel must be running.
state: "start", "cancel" or "stop"
If state is start, autofocus starts. States cancel and stop both stop the autofocusing. Some microscopes
might need stop, while others need cancel.
"""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_autofocusing(channel, state)
def is_autofocusing(self):
"""Returns: (bool) True if autofocus is running and False if autofocus is not running."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.is_autofocusing()
def get_beam_shift(self):
"""Returns: (float) the current beam shift x and y values in meters."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_beam_shift()
def set_beam_shift(self, x_shift, y_shift):
"""Set the current beam shift values in meters."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_beam_shift(x_shift, y_shift)
def beam_shift_info(self):
"""Returns: (dict) the unit and xy-range of the beam shift."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.beam_shift_info()
def get_rotation(self):
"""Returns: (float) the current rotation value in rad."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.get_rotation()
def set_rotation(self, rotation):
"""Set the current rotation value in rad."""
with self._proxy_access:
self.server._pyroClaimOwnership()
self.server.set_rotation(rotation)
def rotation_info(self):
"""Returns: (dict) the unit and range of the rotation."""
with self._proxy_access:
self.server._pyroClaimOwnership()
return self.server.rotation_info()
