def init(self):
self.distance_motor_hwobj = self.getObjectByRole("distance_motor")
self.devname = self.getProperty("tangoname")
try:
self.latency_time = float(self.getProperty("latency_time"))
except Exception:
self.latency_time = None
if self.latency_time is None:
logging.getLogger("HWR").debug(
"Cannot obtain latency time from Pilatus XML. Using %s" %
self.default_latency_time)
self.latency_time = self.default_latency_time
self.devspecific = self.getProperty("device_specific")
exp_time_limits = self.getProperty("exposure_limits")
self.exp_time_limits = map(float, exp_time_limits.strip().split(","))
self.device = DeviceProxy(self.devname)
self.device_specific = DeviceProxy(self.devspecific)
self.device.set_timeout_millis(30000)
self.beamx_chan = self.get_channel_object("beamx")
self.beamy_chan = self.get_channel_object("beamy")
def test_hdf5_lima():
config_xml = """
<config>
<controller class="mockup">
<axis name="m0">
<steps_per_unit value="10000"/>
<!-- degrees per second -->
<velocity value="10"/>
<acceleration value="100"/>
</axis>
</controller>
</config>"""
emotion.load_cfg_fromstring(config_xml)
m0 = emotion.get_axis("m0")
chain = AcquisitionChain()
emotion_master = SoftwarePositionTriggerMaster(m0, 5, 10, 5, time=5)
lima_dev = DeviceProxy("id30a3/limaccd/simulation")
params = {
"acq_nb_frames": 5,
"acq_expo_time": 3 / 10.0,
"acq_trigger_mode": "INTERNAL_TRIGGER_MULTI"
}
lima_acq_dev = LimaAcquisitionMaster(lima_dev, **params)
chain.add(emotion_master, lima_acq_dev)
file_organizer = Hdf5Organizer(root_path='/tmp')
toto = Container('toto', file_organizer=file_organizer)
dm = ScanRecorder('test_acq', toto)
scan = Scan(chain, dm)
scan.prepare()
scan.start()
def test_lima_basler():
config = beacon_get_config()
m0 = config.get("bcumot2")
m0.velocity(360)
m0.acceleration(720)
chain = AcquisitionChain()
nb_points = 4
emotion_master = SoftwarePositionTriggerMaster(m0,
0,
360,
nb_points,
time=1)
tango_host = "lid00limax:20000"
lima_dev = DeviceProxy("//%s/id00/limaccds/basler_bcu" % tango_host)
params = {
"acq_nb_frames": nb_points,
"acq_expo_time": 10e-3,
"acq_trigger_mode": "INTERNAL_TRIGGER_MULTI"
}
lima_acq_dev = LimaAcquisitionMaster(lima_dev, **params)
chain.add(emotion_master, lima_acq_dev)
hdf5_writer = hdf5.Writer(root_path='/tmp')
toto = Container('test_lima_basler')
scan = Scan(chain, name='test_acq', parent=toto, writer=hdf5_writer)
scan.run()
def init(self):
sc3_pucks = self.getProperty('sc3_pucks', True)
for i in range(8):
cell = Cell(self, i + 1, sc3_pucks)
self._addComponent(cell)
self.robot = self.getProperty('tango_device')
if self.robot:
self.robot = DeviceProxy(self.robot)
self.exporter_addr = self.getProperty('exporter_address')
if self.exporter_addr:
self.swstate_attr = self.addChannel(
{
'type': 'exporter',
'exporter_address': self.exporter_addr,
'name': 'swstate'
}, 'State')
self.controller = self.getObjectByRole('controller')
self.prepareLoad = self.getCommandObject('moveToLoadingPosition')
self.timeout = 3
self.gripper_types = {
-1: "No Gripper",
1: "UNIPUCK",
2: "MINISPINE",
3: "FLIPPING",
4: "UNIPUCK_DOUBLE",
5: "PLATE"
}
return SampleChanger.init(self)
def init(self):
"""Initialise properties and polling"""
super(BlissHutchTrigger, self).init()
self._bliss_obj = self.getObjectByRole("controller")
tango_device = self.getProperty("pss_tango_device")
try:
self._proxy = DeviceProxy(tango_device)
except DevFailed as _traceback:
last_error = _traceback[-1]
msg = f"{self.name()}: {last_error['desc']}"
raise RuntimeError(msg)
pss = self.getProperty("pss_card_ch")
try:
self.card, self.channel = map(int, pss.split("/"))
except AttributeError:
msg = f"{self.name()}: cannot find PSS number"
raise RuntimeError(msg)
# polling interval [s]
self._polling_interval = self.getProperty("polling_interval", 5)
self._pss_value = self.get_pss_value()
# enable by default
self.update_value(self.VALUES.ENABLED)
self._poll_task = spawn(self._do_polling)
def test_lima():
config_xml = """
<config>
<controller class="mockup">
<axis name="m0">
<steps_per_unit value="10000"/>
<!-- degrees per second -->
<velocity value="10"/>
<acceleration value="100"/>
</axis>
</controller>
</config>"""
emotion.load_cfg_fromstring(config_xml)
m0 = emotion.get_axis("m0")
def cb(*args, **kwargs):
print args, kwargs
chain = AcquisitionChain()
emotion_master = SoftwarePositionTriggerMaster(m0, 5, 10, 10, time=5)
lima_dev = DeviceProxy("id30a3/limaccd/simulation")
params = {
"acq_nb_frames": 10,
"acq_expo_time": 3 / 10.0,
"acq_trigger_mode": "INTERNAL_TRIGGER_MULTI"
}
lima_acq_dev = LimaAcquisitionMaster(lima_dev, **params)
dispatcher.connect(cb, sender=lima_acq_dev)
chain.add(emotion_master, lima_acq_dev)
scan = Scan(chain)
scan.run()
m0.wait_move()
print m0.velocity() == 10
def init_device(self):
try:
self.device = DeviceProxy(self.deviceName)
except PyTango.DevFailed as traceback:
self.imported = False
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()),
last_error['desc'])
else:
self.imported = True
try:
self.device.ping()
except PyTango.ConnectionFailed:
self.device = None
raise ConnectionError
else:
self.device.set_timeout_millis(self.timeout)
# check that the attribute exists (to avoid Abort in PyTango grrr)
if not self.attributeName.lower() in [
attr.name.lower()
for attr in self.device.attribute_list_query()
]:
logging.getLogger("HWR").error(
"no attribute %s in Tango device %s",
self.attributeName, self.deviceName)
self.device = None
def init(self):
sc3_pucks = self.getProperty("sc3_pucks", True)
for i in range(8):
cell = Cell(self, i + 1, sc3_pucks)
self._addComponent(cell)
self.robot = self.getProperty("tango_device")
if self.robot:
self.robot = DeviceProxy(self.robot)
self.exporter_addr = self.getProperty("exporter_address")
if self.exporter_addr:
self.swstate_attr = self.addChannel(
{
"type": "exporter",
"exporter_address": self.exporter_addr,
"name": "swstate",
},
"State",
)
self.controller = self.getObjectByRole("controller")
self.prepareLoad = self.getCommandObject("moveToLoadingPosition")
self.timeout = 3
self.gripper_types = {
-1: "No Gripper",
1: "UNIPUCK",
2: "MINISPINE",
3: "FLIPPING",
4: "UNIPUCK_DOUBLE",
5: "PLATE",
}
return SampleChanger.init(self)
def _monitor(self):
self.tg_device = None
while True:
if self.tg_device is None:
self.tg_device = DeviceProxy(self.get_property("tangoname"))
try:
temp = self.tg_device.Gas_temp
except Exception:
self.tg_device = None
else:
# if n2level != self.n2level:
# self.n2level = n2level
# self.emit("levelChanged", (n2level, ))
if temp != self.temp:
self.temp = temp
self.emit("temperatureChanged", (temp, 0))
# if cryo_status != self.cryo_status:
# self.cryo_status = cryo_status
# self.emit("cryoStatusChanged", (CRYO_STATUS[cryo_status], ))
# if dry_status != self.dry_status:
# self.dry_status = dry_status
# if dry_status != 9999:
# self.emit("dryStatusChanged", (CRYO_STATUS[dry_status], ))
# if sdry_status != self.sdry_status:
# self.sdry_status = sdry_status
# if sdry_status != 9999:
# self.emit("sdryStatusChanged", (CRYO_STATUS[sdry_status], ))
time.sleep(3)
def init(self):
self.device = None
try:
self._video_mode = self.getProperty("video_mode", "RGB24")
self.device = DeviceProxy(self.tangoname)
# try a first call to get an exception if the device
# is not exported
self.device.ping()
except PyTango.DevFailed as traceback:
last_error = traceback[-1]
logging.getLogger("HWR").error("%s: %s", str(self.name()),
last_error.desc)
self.device = BaseHardwareObjects.Null()
else:
if self.getProperty("exposure_time"):
self._sleep_time = float(self.getProperty("exposure_time"))
elif self.getProperty("interval"):
self._sleep_time = float(self.getProperty("interval")) / 1000.0
if self.getProperty("control_video", "True"):
logging.getLogger("HWR").info("MXCuBE controlling video")
if self.device.video_live:
self.device.video_live = False
self.device.video_mode = self._video_mode
self.set_exposure(self._sleep_time)
self.device.video_live = True
else:
logging.getLogger("HWR").info("MXCuBE NOT controlling video")
self.setIsReady(True)
def init_device(self):
try:
self.device = DeviceProxy(self.deviceName)
except PyTango.DevFailed, traceback:
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()),
last_error['desc'])
self.device = None
def init(self):
controller = self.getObjectByRole("controller")
self.musst = controller.musst
self.shutter = self.getDeviceByRole("shutter")
self.factor = self.getProperty("current_photons_factor")
self.shutter.connect("shutterStateChanged", self.shutterStateChanged)
self.tg_device = DeviceProxy(self.getProperty("tango_device"))
self.counts_reading_task = self._read_counts_task(wait=False)
def init(self):
controller = self.getObjectByRole("controller")
self.musst = controller.musst
self.energy_motor = self.getDeviceByRole("energy")
self.shutter = self.getDeviceByRole("shutter")
self.factor = self.getProperty("current_photons_factor")
self.shutter.connect("shutterStateChanged", self.shutterStateChanged)
self.tg_device = DeviceProxy("id30/keithley_massif1/i0")
self.counts_reading_task = self._read_counts_task(wait=False)
def init(self):
# cmdToggle = self.get_command_object('toggle')
# cmdToggle.connectSignal('connected', self.connected)
# cmdToggle.connectSignal('disconnected', self.disconnected)
# Connect to device FP_Parser defined "tangoname" in the xml file
try:
# self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False)
self.Attenuatordevice = DeviceProxy(self.getProperty("tangoname"))
except Exception:
self.errorDeviceInstance(self.getProperty("tangoname"))
try:
# self.Attenuatordevice = SimpleDevice(self.getProperty("tangoname"), verbose=False)
self.Constdevice = DeviceProxy(self.getProperty("tangoname_const"))
except Exception:
self.errorDeviceInstance(self.getProperty("tangoname_const"))
# Connect to device Primary slit horizontal defined "tangonamePs_h" in the
# xml file
try:
# self.Ps_hdevice = SimpleDevice(self.getProperty("tangonamePs_h"), verbose=False)
self.Ps_hdevice = DeviceProxy(self.getProperty("tangonamePs_h"))
except Exception:
self.errorDeviceInstance(self.getProperty("tangonamePs_h"))
# Connect to device Primary slit vertical defined "tangonamePs_v" in the
# xml file
try:
# self.Ps_vdevice = SimpleDevice(self.getProperty("tangonamePs_v"), verbose=False)
self.Ps_vdevice = DeviceProxy(self.getProperty("tangonamePs_v"))
except Exception:
self.errorDeviceInstance(self.getProperty("tangonamePs_v"))
if self.deviceOk:
self.connected()
self.chanAttState = self.get_channel_object("State")
self.chanAttState.connectSignal("update", self.attStateChanged)
self.chanAttFactor = self.get_channel_object("TrueTrans_FP")
self.chanAttFactor.connectSignal("update", self.attFactorChanged)
def init_device(self):
try:
self.device = DeviceProxy(self.deviceName)
except PyTango.DevFailed as traceback:
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()),
last_error['desc'])
self.device = None
else:
try:
self.device.ping()
except PyTango.ConnectionFailed:
self.device = None
raise ConnectionError
def init(self):
self.device = None
try:
self.device = DeviceProxy(self.tangoname)
#try a first call to get an exception if the device
#is not exported
self.device.ping()
except PyTango.DevFailed, traceback:
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()),
last_error.desc)
self.device = BaseHardwareObjects.Null()
def init(self):
self.counter = DeviceProxy(self.getProperty("url"))
try:
self.threshold = map(float, self.getProperty("threshold").split())
except AttributeError:
self.threshold = [0, 9999]
self.shutter = self.getDeviceByRole("shutter")
self.aperture = self.getObjectByRole("aperture")
fname = self.getProperty("calibrated_diodes_file")
self.flux_calc = CalculateFlux()
self.flux_calc.init(fname)
self.shutter.connect("shutterStateChanged", self.shutterStateChanged)
self.counts_reading_task = self._read_counts_task(wait=False)
def init(self):
self.device = None
try:
self.device = DeviceProxy(self.tangoname)
#try a first call to get an exception if the device
#is not exported
self.device.ping()
except PyTango.DevFailed as traceback:
last_error = traceback[-1]
logging.getLogger('HWR').error("%s: %s", str(self.name()), last_error.desc)
self.device = BaseHardwareObjects.Null()
else:
self.setExposure(self.getProperty("interval")/1000.0)
self.device.video_mode = "BAYER_RG16"
self.setIsReady(True)
def init(self):
sc3_pucks = self.get_property("sc3_pucks", True)
for i in range(8):
cell = Cell(self, i + 1, sc3_pucks)
self._add_component(cell)
self.robot = self.get_property("tango_device")
if self.robot:
self.robot = DeviceProxy(self.robot)
self.exporter_addr = self.get_property("exporter_address")
if self.exporter_addr:
self.swstate_attr = self.add_channel(
{
"type": "exporter",
"exporter_address": self.exporter_addr,
"name": "swstate",
},
"State",
)
self.controller = self.get_object_by_role("controller")
self.prepareLoad = self.get_command_object("moveToLoadingPosition")
self.timeout = 3
self.gripper_types = {
-1: "No Gripper",
1: "UNIPUCK",
2: "MINISPINE",
3: "FLIPPING",
4: "UNIPUCK_DOUBLE",
5: "PLATE",
}
SampleChanger.init(self)
# self._set_state(SampleChangerState.Disabled)
self._update_selection()
self.state = self._read_state()
def errorDeviceInstance(self, device):
db = DeviceProxy("sys/database/dbds1")
logging.getLogger().error("Check Instance of Device server %s" %
db.DbGetDeviceInfo(device)[1][3])
self.sDisconnected()
def prepare_intensity_monitors(self):
i1 = DeviceProxy("id30/keithley_massif3/i1")
i0 = DeviceProxy("id30/keithley_massif3/i0")
i1.autorange = False
i1.range = i0.range
