def complete_initialization(app):
app.beamline = get_hardware_object(hwr, cmdline_options.beamline_setup)
app.xml_rpc_server = get_hardware_object(hwr, 'xml-rpc-server')
app.actions = hwr.getHardwareObject(cmdline_options.beamline_actions)
app.plotting = hwr.getHardwareObject(cmdline_options.plotting)
app.session = get_hardware_object(app.beamline, "session")
app.collect = get_hardware_object(app.beamline, "collect")
app.workflow = get_hardware_object(app.beamline, "workflow")
app.shapes = get_hardware_object(app.beamline, "shape_history")
app.diffractometer = get_hardware_object(app.beamline, "diffractometer")
app.db_connection = get_hardware_object(app.beamline, "lims_client")
app.sample_changer = get_hardware_object(app.beamline, "sample_changer")
app.sc_maintenance = get_hardware_object(app.beamline,
"sample_changer_maintenance")
app.rest_lims = get_hardware_object(app.beamline, "lims_rest_client")
Utils.enable_snapshots(app.collect)
init_app_state(app)
init_sample_video(app)
try:
SampleCentring.init_signals()
SampleChanger.init_signals()
Beamline.init_signals()
Diffractometer.init_signals()
except Exception:
sys.excepthook(*sys.exc_info())
INIT_EVENT.set()
def complete_initialization(app):
app.beamline = hwr.getHardwareObject(cmdline_options.beamline_setup)
app.session = app.beamline.getObjectByRole("session")
app.collect = app.beamline.getObjectByRole("collect")
Utils.enable_snapshots(app.collect)
app.diffractometer = app.beamline.getObjectByRole("diffractometer")
if getattr(app.diffractometer, 'centring_motors_list', None) is None:
# centring_motors_list is the list of roles corresponding to diffractometer motors
app.diffractometer.centring_motors_list = app.diffractometer.getPositions(
).keys()
app.db_connection = app.beamline.getObjectByRole("lims_client")
app.empty_queue = pickle.dumps(
hwr.getHardwareObject(cmdline_options.queue_model))
app.sample_changer = app.beamline.getObjectByRole("sample_changer")
app.rest_lims = app.beamline.getObjectByRole("lims_rest_client")
app.queue = qutils.new_queue()
try:
SampleCentring.init_signals()
SampleChanger.init_signals()
Beamline.init_signals()
except Exception:
sys.excepthook(*sys.exc_info())
def complete_initialization(app):
app.beamline = hwr.getHardwareObject(cmdline_options.beamline_setup)
app.session = app.beamline.getObjectByRole("session")
app.collect = app.beamline.getObjectByRole("collect")
Utils.enable_snapshots(app.collect)
app.diffractometer = app.beamline.getObjectByRole("diffractometer")
if getattr(app.diffractometer, 'centring_motors_list', None) is None:
# centring_motors_list is the list of roles corresponding to diffractometer motors
app.diffractometer.centring_motors_list = app.diffractometer.getPositions().keys()
app.db_connection = app.beamline.getObjectByRole("lims_client")
app.empty_queue = pickle.dumps(hwr.getHardwareObject(cmdline_options.queue_model))
app.sample_changer = app.beamline.getObjectByRole("sample_changer")
app.rest_lims = app.beamline.getObjectByRole("lims_rest_client")
app.queue = qutils.new_queue()
try:
SampleCentring.init_signals()
SampleChanger.init_signals()
Beamline.init_signals()
except Exception:
sys.excepthook(*sys.exc_info())
def beamline():
hwr_path = os.path.join(HWR_DIR, "configuration/test")
HWR._instance = HWR.beamline = None
HWR.init_hardware_repository(hwr_path)
hwr = HWR.getHardwareRepository()
hwr.connect()
return HWR.beamline
def init(self):
super(GphlWorkflowConnection, self).init()
if self.hasObject("connection_parameters"):
self._connection_parameters.update(
self["connection_parameters"].getProperties())
if self.hasObject("ssh_options"):
# We are running through ssh - so we need python_address
# If not, we stick to default, which is localhost (127.0.0.1)
self._connection_parameters["python_address"] = socket.gethostname(
)
locations = next(
self.getObjects("directory_locations")).getProperties()
paths = self.software_paths
props = self.java_properties
dd0 = next(self.getObjects("software_paths")).getProperties()
for tag, val in dd0.items():
val2 = val.format(**locations)
if not os.path.isabs(val2):
val2 = HWR.getHardwareRepository().findInRepository(val)
if val2 is None:
raise ValueError("File path %s not recognised" % val)
paths[tag] = val2
dd0 = next(self.getObjects("software_properties")).getProperties()
for tag, val in dd0.items():
val2 = val.format(**locations)
if not os.path.isabs(val2):
val2 = HWR.getHardwareRepository().findInRepository(val)
if val2 is None:
raise ValueError("File path %s not recognised" % val)
paths[tag] = props[tag] = val2
#
pp0 = props["co.gphl.wf.bin"] = paths["GPHL_INSTALLATION"]
paths["BDG_home"] = paths.get("co.gphl.wf.bdg_licence_dir") or pp0
def init(self):
try:
self.aperture_HO = HardwareRepository.getHardwareRepository().getHardwareObject(
self.getProperty("aperture")
)
self.connect(self.aperture_HO, "apertureChanged", self.aperture_pos_changed)
except BaseException:
logging.getLogger("HWR").debug("BeamInfo: aperture not defined correctly")
try:
self.slits_HO = HardwareRepository.getHardwareRepository().getHardwareObject(
self.getProperty("slits")
)
self.connect(self.slits_HO, "gapSizeChanged", self.slits_gap_changed)
except BaseException:
logging.getLogger("HWR").debug("BeamInfo: slits not defined correctly")
try:
self.beam_definer_HO = HardwareRepository.getHardwareRepository().getHardwareObject(
self.getProperty("definer")
)
self.connect(
self.beam_definer_HO, "definerPosChanged", self.definer_pos_changed
)
except BaseException:
logging.getLogger("HWR").debug(
"BeamInfo: beam definer not defined correctly"
)
self.beam_position_hor = self.getChannelObject("beam_position_hor")
self.beam_position_hor.connectSignal("update", self.beam_pos_hor_changed)
self.beam_position_ver = self.getChannelObject("beam_position_ver")
self.beam_position_ver.connectSignal("update", self.beam_pos_ver_changed)
self.chan_beam_size_microns = self.getChannelObject("beam_size_microns")
self.chan_beam_shape_ellipse = self.getChannelObject("beam_shape_ellipse")
def complete_initialization(app):
app.beamline = hwr.getHardwareObject(cmdline_options.beamline_setup)
app.xml_rpc_server = hwr.getHardwareObject('xml-rpc-server')
app.session = app.beamline.getObjectByRole("session")
app.collect = app.beamline.getObjectByRole("collect")
app.workflow = app.beamline.getObjectByRole("workflow")
app.shapes = app.beamline.getObjectByRole("shape_history")
Utils.enable_snapshots(app.collect)
app.diffractometer = app.beamline.getObjectByRole("diffractometer")
if getattr(app.diffractometer, 'centring_motors_list', None) is None:
# centring_motors_list is the list of roles corresponding to diffractometer motors
app.diffractometer.centring_motors_list = app.diffractometer.getPositions().keys()
app.db_connection = app.beamline.getObjectByRole("lims_client")
app.empty_queue = pickle.dumps(hwr.getHardwareObject(cmdline_options.queue_model))
app.sample_changer = app.beamline.getObjectByRole("sample_changer")
app.sc_maintenance = app.beamline.getObjectByRole("sample_changer_maintenance")
app.rest_lims = app.beamline.getObjectByRole("lims_rest_client")
app.queue = qutils.new_queue()
app.actions = hwr.getHardwareObject(cmdline_options.beamline_actions)
app.plotting = hwr.getHardwareObject(cmdline_options.plotting)
# SampleID of currently mounted sample
app.CURRENTLY_MOUNTED_SAMPLE = None
app.SAMPLE_TO_BE_MOUNTED = ''
app.AUTO_MOUNT_SAMPLE = False
app.AUTO_ADD_DIFFPLAN = False
app.CENTRING_METHOD = CENTRING_METHOD.LOOP
app.NUM_SNAPSHOTS = app.collect.getProperty('num_snapshots', 4)
app.NODE_ID_TO_LIMS_ID = {}
app.INITIAL_FILE_LIST = []
app.SC_CONTENTS = {"FROM_CODE": {}, "FROM_LOCATION": {}}
app.SAMPLE_LIST = {"sampleList": {}, 'sampleOrder': []}
app.TEMP_DISABLED = []
# set up streaming
from mxcube3.video import streaming
try:
streaming.init(app.diffractometer.camera, cmdline_options.video_device)
except RuntimeError as ex:
logging.getLogger('HWR').info(str(ex))
app.VIDEO_DEVICE = None
else:
app.VIDEO_DEVICE = cmdline_options.video_device
try:
SampleCentring.init_signals()
SampleChanger.init_signals()
Beamline.init_signals()
Diffractometer.init_signals()
except Exception:
sys.excepthook(*sys.exc_info())
logging.getLogger("HWR").info("MXCuBE 3 initialized, it took %.1f seconds" % (time.time() - t0))
def beamline():
hwr_path = "%s%s%s" % (os.path.join(
HWR_DIR, "configuration/mockup"), os.path.pathsep,
os.path.join(HWR_DIR, "configuration/mockup/test"))
HWR._instance = HWR.beamline = None
HWR.init_hardware_repository(hwr_path)
hwr = HWR.get_hardware_repository()
hwr.connect()
return HWR.beamline
def _connect_hwserver(self):
print self.hwr_directory
self.hwr_server = HardwareRepository.HardwareRepository(self.hwr_directory)
self.hwr_server.connect()
hwo_path = os.path.join(self.mxcube_dir, "HardwareObjects")
sc_hwo_path = os.path.join(hwo_path, "sample_changer")
if self.institute:
inst_hwo_path = os.path.join(hwo_path, self.institute)
HardwareRepository.addHardwareObjectsDirs([hwo_path, inst_hwo_path, sc_hwo_path])
def _connect_hwserver(self):
print self.hwr_directory
self.hwr_server = HardwareRepository.HardwareRepository(self.hwr_directory)
self.hwr_server.connect()
hwo_path = os.path.join(self.mxcube_dir,"HardwareObjects")
sc_hwo_path = os.path.join(hwo_path, "sample_changer")
if self.institute:
inst_hwo_path = os.path.join(hwo_path, self.institute)
HardwareRepository.add_hardware_objects_dirs([hwo_path, inst_hwo_path, sc_hwo_path])
def complete_initialization(app):
app.beamline = hwr.getHardwareObject(cmdline_options.beamline_setup)
app.session = app.beamline.getObjectByRole("session")
app.collect = app.beamline.getObjectByRole("collect")
app.diffractometer = app.beamline.getObjectByRole("diffractometer")
app.db_connection = app.beamline.getObjectByRole("lims_client")
app.empty_queue = jsonpickle.encode(hwr.getHardwareObject(cmdline_options.queue_model))
app.sample_changer = app.beamline.getObjectByRole("sample_changer")
try:
routes.SampleCentring.init_signals()
except Exception:
sys.excepthook(*sys.exc_info())
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
flux = hwr.get_hardware_object("/flux")
print("PX1 Flux is ", flux.get_value())
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
shut = hwr.get_hardware_object("/fastshutter")
print(("Shutter State is: ", shut.readShutterState()))
def __init__(self, parent=None, widgetName=""):
Connectable.Connectable.__init__(self)
QWidget.__init__(self, parent, widgetName)
self.setSizePolicy(QSizePolicy.MinimumExpanding, QSizePolicy.MinimumExpanding)
self.propertyBag = PropertyBag.PropertyBag()
self.__enabledState = True # saved enabled state
self.__loadedHardwareObjects = []
self._signalSlotFilters = {}
self._widgetEvents = []
#
# add what's this help
#
QWhatsThis.add(self, "%s (%s)\n" % (widgetName, self.__class__.__name__))
#
# add properties shared by all BlissWidgets
#
self.addProperty("fontSize", "string", str(self.font().pointSize()))
# self.addProperty("alignment", "combo", ("none", "top center", "top left", "top right", "bottom center", "bottom left", "bottom right", "center", "left", "right"), "none")
self.addProperty("instanceAllowAlways", "boolean", False) # , hidden=True)
self.addProperty("instanceAllowConnected", "boolean", False) # , hidden=True)
#
# connect signals / slots
#
dispatcher.connect(
self.__hardwareObjectDiscarded,
"hardwareObjectDiscarded",
HardwareRepository.getHardwareRepository(),
)
self.defineSlot("enable_widget", ())
def init(self):
"""
Ggonio axes definitions are static
motorHO is expected to have getPosition() that returns coordinate in mm
"""
self.motorConstraints = []
self.gonioAxes = []
for axis in self['gonioAxes']:
self.gonioAxes.append({'type':axis.type,'direction':eval(axis.direction),\
'motor_name':axis.motorname,'motor_HO':
HardwareRepository.HardwareRepository().getHardwareObject(axis.motorHO) })
"""
This version is lacking video microscope object. Therefore we model only
static camera axes directions, but no camera axes scaling or center - which
are dynamic. Therefore, camera coordinates are relative, in mm.
"""
self.cameraAxes = []
for axis in self['cameraAxes']:
self.cameraAxes.append({
'axis_name': axis.axisname,
'direction': eval(axis.direction)
})
self.mI = numpy.diag([1., 1., 1.]) #identity matrix
self.calibrate()
def init(self):
"""
Ggonio axes definitions are static
motorHO is expected to have get_value() that returns coordinate in mm
"""
self.motorConstraints = []
self.gonioAxes = []
for axis in self["gonioAxes"]:
self.gonioAxes.append({
"type":
axis.type,
"direction":
eval(axis.direction),
"motor_name":
axis.motorname,
"motor_HO":
HWR.get_hardware_repository().get_hardware_object(
axis.motorHO),
})
"""
This version is lacking video microscope object. Therefore we model only
static camera axes directions, but no camera axes scaling or center - which
are dynamic. Therefore, camera coordinates are relative, in mm.
"""
self.cameraAxes = []
for axis in self["cameraAxes"]:
self.cameraAxes.append({
"axis_name": axis.axisname,
"direction": eval(axis.direction)
})
self.mI = numpy.diag([1.0, 1.0, 1.0]) # identity matrix
self.calibrate()
def get_hardware_object(self, hardware_object_name, optional=False):
splash_screen = gui.get_splash_screen()
if splash_screen:
splash_screen.set_message(
"Loading hardware object defined in %s.xml" % hardware_object_name
)
if not hardware_object_name in self.__loaded_hardware_objects:
if splash_screen:
splash_screen.inc_progress_value()
self.__loaded_hardware_objects.append(hardware_object_name)
hwobj = HardwareRepository.getHardwareRepository().getHardwareObject(
hardware_object_name
)
if hwobj is not None:
self.connect(hwobj, "progressInit", self.progress_init)
self.connect(hwobj, "progressStep", self.progress_step)
self.connect(hwobj, "progressStop", self.progress_stop)
self.connect(hwobj, "statusMessage", self.status_message_changed)
if hwobj is None and not optional:
logging.getLogger("GUI").error(
"%s: Unable to initialize hardware object defined in %s.xml"
% (self.objectName(), hardware_object_name[1:])
)
self.set_background_color(Colors.LIGHT_RED)
self.__failed_to_load_hwobj = True
self.setDisabled(True)
return hwobj
def test():
hwr_directory = os.environ["XML_FILES_PATH"]
print hwr_directory
hwr = HardwareRepository.HardwareRepository(os.path.abspath(hwr_directory))
hwr.connect()
conn = hwr.getHardwareObject("/ldapconnection")
#conn.login("20141015", "4dBM0lx3pw")
#ok,name = conn.login("99140198", "5u4Twf70K5")
#ok,name = conn.login("mx20100023", "tisabet")
#ok,name = conn.login("anything", "tisabet")
#info = conn.getinfo("legrand")
#info = conn.getinfo("20100023")
#conn.find_groups_for_username('houdusse')
#grps = conn.find_groups_for_username('houdusse')
#for grp,users in grps.iteritems():
#print grp, " : " , users
user = '******' #'20100023'
sess = conn.find_sessions_for_user("%s" % user)
for onesess in sess:
print "Session for %s" % user, onesess
validsess = conn.find_valid_sessions_for_user(user)
for valid in validsess:
print "Valid session for today", valid
def __init__(self,
design_mode=False,
show_maximized=False,
no_border=False):
"""init"""
QWidget.__init__(self)
self.framework = None
self.gui_config_file = None
self.user_file_dir = None
self.configuration = None
self.user_settings = None
self.launch_in_design_mode = design_mode
self.hardware_repository = HardwareRepository.HardwareRepository()
self.show_maximized = show_maximized
self.no_border = no_border
self.windows = []
self.splash_screen = BlissSplashScreen(Qt4_Icons.load_pixmap('splash'))
set_splash_screen(self.splash_screen)
self.splash_screen.show()
self.timestamp = 0
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
shut = hwr.getHardwareObject("/fastshutter")
print("Shutter State is: ", shut.readShutterState())
def _init(self):
self.currentResolution = None
self.currentDistance = None
self.currentWavelength = None
self.currentEnergy = None
self.connect("equipmentReady", self.equipmentReady)
self.connect("equipmentNotReady", self.equipmentNotReady)
self.device = DeviceProxy( self.getProperty("tangoname") )
#self.monodevice = SimpleDevice(self.getProperty("tangoname2"), waitMoves = False, verbose=False)
self.blenergyHOname = self.getProperty("BLEnergy")
if self.blenergyHOname is None:
logging.getLogger("HWR").error('TangoResolution: you must specify the %s hardware object' % self.blenergyHOname)
hobj=None
self.configOk=False
else:
hobj=HardwareRepository.HardwareRepository().getHardwareObject(self.blenergyHOname)
if hobj is None:
logging.getLogger("HWR").error('TangoResolution: invalid %s hardware object' % self.blenergyHOname)
self.configOk=False
self.blenergyHO=hobj
self.connect(self.blenergyHO,qt.PYSIGNAL('energyChanged'), self.energyChanged)
# creer un chanel sur l'energy: pour faire un update
positChan = self.getChannelObject("position") # utile seulement si statechan n'est pas defini dans le code
positChan.connectSignal("update", self.positionChanged)
stateChan = self.getChannelObject("state") # utile seulement si statechan n'est pas defini dans le code
stateChan.connectSignal("update", self.stateChanged)
self.currentDistance = self.device.position
self.currentEnergy = self.blenergyHO.getCurrentEnergy()
self.currentWavelength = self.blenergyHO.getCurrentWavelength()
return BaseHardwareObjects.Equipment._init(self)
def init(self):
"""
Description:
"""
for position in self['positions']:
temp_name = str(position.getProperty('posName'))
if not temp_name == "Out":
temp_name = "%s%sm" %(temp_name, unichr(956))
self.positions_list.append({
'origin_name' : str(position.getProperty('posName')),
'name' : temp_name,
'modes' : position.getProperty('modesAllowed'),
'size' : eval(position.getProperty('size'))})
self.default_position = self.getProperty('defaultPosition')
self.chan_active_position = self.getChannelObject('CurrentApertureDiameterIndex')
if self.chan_active_position is not None:
self.chan_active_position.connectSignal('update', self.active_position_changed)
self.active_position_changed(self.chan_active_position.getValue())
if self.getProperty('beamFocusHO') is not None:
try:
self.beam_focus_hwobj = HardwareRepository.HardwareRepository().\
getHardwareObject(self.getProperty('beamFocusHO'))
self.connect(self.beam_focus_hwobj, 'definerPosChanged', \
self.beam_focus_changed)
except:
logging.getLogger("HWR").debug('BeamAperture: Focusing hwobj not defined')
self.active_position = 0
self.active_focus_mode = "Unfocused"
self.evaluate_aperture()
def getHardwareObject(self, hardwareObjectName):
if not hardwareObjectName in self.__loadedHardwareObjects:
self.__loadedHardwareObjects.append(hardwareObjectName)
ho = HardwareRepository.HardwareRepository().getHardwareObject(hardwareObjectName)
return ho
def getHardwareObject(self, hardware_object_name, optional=False):
"""
Descript. :
"""
splash_screen = BlissFramework.get_splash_screen()
if splash_screen:
splash_screen.set_message(\
"Loading hardware object defined in %s.xml" %
hardware_object_name)
if not hardware_object_name in self.__loaded_hardware_objects:
self.__loaded_hardware_objects.append(hardware_object_name)
hwobj = HardwareRepository.HardwareRepository().\
getHardwareObject(hardware_object_name)
if hwobj is not None:
self.connect(hwobj, "progressInit", self.progress_init)
self.connect(hwobj, 'progressStep', self.progress_step)
self.connect(hwobj, 'progressStop', self.progress_stop)
self.connect(hwobj, 'statusMessage', self.status_message_changed)
if hwobj is None and not optional:
logging.getLogger("GUI").error(\
"%s: Unable to initialize hardware object defined in %s.xml" % \
(self.objectName(),
hardware_object_name[1:]))
self.set_background_color(Qt4_widget_colors.LIGHT_RED)
self.__failed_to_load_hwobj = True
self.setDisabled(True)
return hwobj
def addPage(self, pageName):
self.__pages.append(ProcedureWidgets.ProcedurePanel(self))
self.__pages[-1].setProcedure(HardwareRepository.HardwareRepository().getProcedure(self['mnemonic']))
self.procedureTab.addTab(self.__pages[-1], pageName)
return self.__pages[-1]
def test():
hwr = HWR.get_hardware_repository()
hwr.connect()
conn = hwr.get_hardware_object("/ldapconnection")
# conn.login("20141015", "4dBM0lx3pw")
# ok,name = conn.login("99140198", "5u4Twf70K5")
# ok,name = conn.login("mx20100023", "tisabet")
# ok,name = conn.login("anything", "tisabet")
# info = conn.getinfo("legrand")
# info = conn.getinfo("20100023")
# conn.find_groups_for_username('houdusse')
# grps = conn.find_groups_for_username('houdusse')
# for grp,users in grps.items():
# print grp, " : " , users
user = "******" # '20100023'
sess = conn.find_sessions_for_user("%s" % user)
for onesess in sess:
print("Session for %s" % user, onesess)
validsess = conn.find_valid_sessions_for_user(user)
for valid in validsess:
print("Valid session for today", valid)
def getHardwareObject(self, hardware_object_name, optional=False):
"""
Descript. :
"""
if not hardware_object_name in self.__loaded_hardware_objects:
self.__loaded_hardware_objects.append(hardware_object_name)
hwobj = HardwareRepository.HardwareRepository().\
getHardwareObject(hardware_object_name)
if hwobj is not None:
self.connect(hwobj, "progressInit", self.progress_init)
self.connect(hwobj, 'progressStep', self.progress_step)
self.connect(hwobj, 'progressStop', self.progress_stop)
if hwobj is None and not optional:
logging.getLogger("GUI").error(\
"Unable to initialize hardware: %s.xml. " % hardware_object_name[1:] + \
"If the restarting of MXCuBE do not help, " + \
"please contact your local support.")
self.set_background_color(Qt4_widget_colors.LIGHT_RED)
self.__failed_to_load_hwobj = True
self.setDisabled(True)
return hwobj
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
conn = hwr.getHardwareObject("/ldapconnection")
# conn.login("20141015", "4dBM0lx3pw")
# ok,name = conn.login("99140198", "5u4Twf70K5")
# ok,name = conn.login("mx20100023", "tisabet")
# ok,name = conn.login("anything", "tisabet")
# info = conn.getinfo("legrand")
# info = conn.getinfo("20100023")
# conn.find_groups_for_username('houdusse')
# grps = conn.find_groups_for_username('houdusse')
# for grp,users in grps.iteritems():
# print grp, " : " , users
user = "******" # '20100023'
sess = conn.find_sessions_for_user("%s" % user)
for onesess in sess:
print "Session for %s" % user, onesess
validsess = conn.find_valid_sessions_for_user(user)
for valid in validsess:
print "Valid session for today", valid
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
shut = hwr.getHardwareObject("/fastshutter")
print("Shutter State is: ", shut.readShutterState())
def test_hwo():
from gui.utils.QtImport import *
import time
from HardwareRepository import HardwareRepository as HWR
hwr = HWR.get_hardware_repository()
hwr.connect()
hwo = hwr.get_hardware_object("/singleton_objects/limavideo")
print("Image dimensions: ", hwo.get_image_dimensions())
print("Live Mode: ", hwo.get_video_live())
app = QApplication([])
win = QMainWindow()
lab = QLabel("toto")
print("Image dimensions: ", hwo.get_image_dimensions())
hwo.set_video_live(True)
hwo.set_exposure_time(0.05)
time.sleep(1)
qimg = hwo.get_new_image()
px = QPixmap(qimg)
px = px.scaled(QSize(px.width() * 0.5, px.height() * 0.5))
lab.setPixmap(px)
win.setCentralWidget(lab)
win.show()
app.exec_()
def get_hardware_object(self, hardware_object_name, optional=False):
splash_screen = gui.get_splash_screen()
if splash_screen:
splash_screen.set_message(
"Loading hardware object defined in %s.xml" %
hardware_object_name)
if not hardware_object_name in self.__loaded_hardware_objects:
if splash_screen:
splash_screen.inc_progress_value()
self.__loaded_hardware_objects.append(hardware_object_name)
hwobj = HardwareRepository.getHardwareRepository().getHardwareObject(
hardware_object_name)
if hwobj is not None:
self.connect(hwobj, "progressInit", self.progress_init)
self.connect(hwobj, "progressStep", self.progress_step)
self.connect(hwobj, "progressStop", self.progress_stop)
self.connect(hwobj, "statusMessage", self.status_message_changed)
if hwobj is None and not optional:
logging.getLogger("GUI").error(
"%s: Unable to initialize hardware object defined in %s.xml" %
(self.objectName(), hardware_object_name[1:]))
self.set_background_color(Colors.LIGHT_RED)
self.__failed_to_load_hwobj = True
self.setDisabled(True)
return hwobj
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
flux = hwr.getHardwareObject("/flux")
print "PX1 Flux is ", flux.getCurrentFlux()
def __init__(self,
design_mode=False,
show_maximized=False,
no_border=False):
"""Main mxcube gui widget"""
QtImport.QWidget.__init__(self)
self.framework = None
self.gui_config_file = None
self.user_file_dir = None
self.configuration = None
self.user_settings = None
self.launch_in_design_mode = design_mode
self.hardware_repository = HardwareRepository.getHardwareRepository()
self.show_maximized = show_maximized
self.no_border = no_border
self.windows = []
self.splash_screen = SplashScreen(Icons.load_pixmap("splash"))
set_splash_screen(self.splash_screen)
self.splash_screen.show()
self.time_stamp = 0
def test():
import os
hwr_directory = os.environ["XML_FILES_PATH"]
hwr = HardwareRepository.HardwareRepository(os.path.abspath(hwr_directory))
hwr.connect()
detector = hwr.getHardwareObject("/eiger")
def test():
import sys
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
ruche = hwr.getHardwareObject("/ruche")
filename = sys.argv[1]
ruche.trigger_sync(filename)
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
light = hwr.getHardwareObject("/frontlight")
print '\nLight control for "%s"\n' % light.getUserName()
print " Level limits are:", light.getLimits()
print " Current level is:", light.getLevel()
print " Current state is:", light.getState()
def hardwareObjectClicked(self, item):
_instance = HardwareRepository()
try:
#item could be None
name = str(item.text(2))
except:
return
else:
if len(name) == 0:
return
if item.isOn() and not self.itemStates[name]:
_instance.loadHardwareObject(name)
elif not item.isOn() and self.itemStates[name]:
_instance.discardHardwareObject(name)
self.itemStates[name] = item.isOn()
def setProcedure(self, proc):
if proc is None:
self.procedure = None
else:
import weakref
self.procedure = weakref.ref(proc)()
QtCore.QObject.connect(HardwareRepository.emitter(self.procedure), SIGNAL('replyArrived'), self.replyArrived)
def setProcedure(self, proc):
if proc is None:
self.procedure = None
else:
import weakref
self.procedure = weakref.ref(proc)()
self.connect( HardwareRepository.emitter(self.procedure), 'replyArrived', self.replyArrived)
def test():
import sys
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
ruche = hwr.getHardwareObject("/ruche")
filename = sys.argv[1]
ruche.trigger_sync(filename)
def test():
import os
hwr_directory = os.environ["XML_FILES_PATH"]
hwr = HardwareRepository.HardwareRepository(os.path.abspath(hwr_directory))
hwr.connect()
detcen = hwr.getHardwareObject("/detector_beamcenter")
print_me(detcen)
def test():
hwr_directory = os.environ["XML_FILES_PATH"]
print "Loading hardware repository from ", os.path.abspath(hwr_directory)
hwr = HardwareRepository.HardwareRepository(os.path.abspath(hwr_directory))
hwr.connect()
calib = hwr.getHardwareObject("/calibration")
print "Calibration is: ", calib.getCalibration()
def addPage(self, pageName):
self.__pages.append(ProcedureWidgets.ProcedurePanel(self))
self.__pages[-1].setProcedure(
HardwareRepository.getHardwareRepository().getProcedure(self["mnemonic"])
)
self.procedureTab.addTab(self.__pages[-1], pageName)
return self.__pages[-1]
def test():
hwr = HWR.getHardwareRepository()
hwr.connect()
light = hwr.getHardwareObject("/frontlight")
print('\nLight control for "%s"\n' % light.getUserName())
print(" Level limits are:", light.get_limits())
print(" Current level is:", light.getLevel())
print(" Current state is:", light.get_state())
def init(self):
controller = HWR.get_hardware_repository().get_hardware_object(
self.get_property("controller"))
cryostat = self.get_property("cryostat")
self.interval = self.get_property("interval") or 10
self.ctrl = getattr(controller, cryostat)
if self.ctrl is not None:
# self.get_params()
gevent.spawn(self._do_polling)
def __init__(self, parent=None, widget_name=''):
"""
Descript. :
"""
Connectable.Connectable.__init__(self)
QFrame.__init__(self, parent)
self.setObjectName(widget_name)
self.property_bag = PropertyBag.PropertyBag()
self.__enabledState = True
self.__loaded_hardware_objects = []
self.__failed_to_load_hwobj = False
self.__use_progress_dialog = False
self._signal_slot_filters = {}
self._widget_events = []
self.setWhatsThis("%s (%s)\n" % (widget_name, self.__class__.__name__))
self.addProperty('fontSize',
'string',
str(self.font().pointSize()))
self.addProperty('frame',
'boolean',
False,
comment="Draw a frame around the widget")
self.addProperty('instanceAllowAlways',
'boolean',
False,
comment="Allow to control brick in all modes")
self.addProperty('instanceAllowConnected',
'boolean',
False,
comment="Allow to control brick in slave mode")
self.addProperty('fixedWidth',
'integer',
'-1',
comment="Set fixed width in pixels")
self.addProperty('fixedHeight',
'integer',
'-1',
comment="Set fixed height in pixels")
self.addProperty('hide',
'boolean',
False,
comment="Hide widget")
dispatcher.connect(self.__hardwareObjectDiscarded,
'hardwareObjectDiscarded',
HardwareRepository.getHardwareRepository())
self.defineSlot('enable_widget', ())
self.defineSlot('disable_widget', ())
#If PySide used then connect method was not overriden
#This solution of redirecting methods works...
self.connect = self.connect_hwobj
self.diconnect = self.disconnect_hwobj
def init(self):
controller = HardwareRepository.getHardwareRepository().getHardwareObject(
self.getProperty("controller")
)
cryostat = self.getProperty("cryostat")
self.interval = self.getProperty("interval") or 10
self.ctrl = getattr(controller, cryostat)
if self.ctrl is not None:
self.get_params()
gevent.spawn(self._do_polling)
def getAxisMotor(self):
hwmot = None
motorname = self.getProperty("motor")
if motorname:
hwmot = HardwareRepository.getHardwareRepository().getHardwareObject(
motorname
)
return hwmot
def init(self):
self.__axis = []
for token in self:
if token.name() == "axis":
axis_name = token.getProperty("objectName")
if axis_name is not None:
axis = HardwareRepository.getHardwareRepository().getHardwareObject(
axis_name
)
if axis is not None:
self.__axis.append(axis)
def get_hardware_objects_info(self):
info_dict = {}
for ho_name in self.__loaded_hardware_objects:
info = HardwareRepository.getHardwareRepository().getInfo(ho_name)
if len(info) > 0:
info_dict[ho_name] = info
if len(info_dict):
return "Hardware Objects:\n\n%s" % pprint.pformat(info_dict)
else:
return ""
def __init__(self, parent=None, widget_name=""):
Connectable.Connectable.__init__(self)
QtImport.QFrame.__init__(self, parent)
self.setObjectName(widget_name)
self.property_bag = PropertyBag.PropertyBag()
self.__enabled_state = True
self.__loaded_hardware_objects = []
self.__failed_to_load_hwobj = False
self.__use_progress_dialog = False
self._signal_slot_filters = {}
self._widget_events = []
self.setWhatsThis("%s (%s)\n" % (widget_name, self.__class__.__name__))
self.add_property("fontSize", "string", str(self.font().pointSize()))
self.add_property(
"frame", "boolean", False, comment="Draw a frame around the widget"
)
self.add_property(
"instanceAllowAlways",
"boolean",
False,
comment="Allow to control brick in all modes",
)
self.add_property(
"instanceAllowConnected",
"boolean",
False,
comment="Allow to control brick in slave mode",
)
self.add_property(
"fixedWidth", "integer", "-1", comment="Set fixed width in pixels"
)
self.add_property(
"fixedHeight", "integer", "-1", comment="Set fixed height in pixels"
)
self.add_property("hide", "boolean", False, comment="Hide widget")
dispatcher.connect(
self.__hardware_object_discarded,
"hardwareObjectDiscarded",
HardwareRepository.getHardwareRepository(),
)
self.define_slot("enable_widget", ())
self.define_slot("disable_widget", ())
# If PySide used then connect method was not overriden
# This solution of redirecting methods works...
self.connect = self.connect_hwobj
self.diconnect = self.disconnect_hwobj
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
ap_pos = hwr.getHardwareObject("/aperture_position")
ap_diam = hwr.getHardwareObject("/aperture_diameter")
yag_pos = hwr.getHardwareObject("/scintillator")
md2_phase = hwr.getHardwareObject("/md2j_phase")
print "Aperture Position: ", ap_pos.getState()
print "Aperture Diameter: ", ap_diam.getState()
print "Yag Posiion: ", yag_pos.getState()
print "MD2 Phase: ", md2_phase.getState()
def getHardwareObject(self, hardwareObjectName):
if not hardwareObjectName in self.__loadedHardwareObjects:
self.__loadedHardwareObjects.append(hardwareObjectName)
screen = get_splash_screen()
if screen is not None:
screen.set_message("Loading hardware object: %s" % hardwareObjectName)
ho = HardwareRepository.getHardwareRepository().getHardwareObject(
hardwareObjectName
)
return ho
def getHardwareObjectsInfo(self):
d = {}
for ho_name in self.__loadedHardwareObjects:
info = HardwareRepository.getHardwareRepository().getInfo(ho_name)
if len(info) > 0:
d[ho_name] = info
if len(d):
return "Hardware Objects:\n\n%s" % pprint.pformat(d)
else:
return ""
def __init__(self, designMode=False, showMaximized=False, noBorder=False):
qt.QWidget.__init__(self)
self.launchInDesignMode = designMode
self.hardwareRepository = HardwareRepository.getHardwareRepository()
self.showMaximized = showMaximized
self.noBorder = noBorder
self.windows = []
self.splashScreen = BlissSplashScreen(
Icons.load("splash"), qt.Qt.WDestructiveClose
)
self.splashScreen.show()
self.timestamp = 0
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
zoom = hwr.getHardwareObject("/zoom-auto-brightness")
print type(zoom.getState())
print " Zoom position is : ", zoom.getPosition()
print "Zoom position name is : ", zoom.getCurrentPositionName()
print " Moving : ", zoom.motorIsMoving()
print " State : ", zoom.getState()
print " Positions : ", zoom.getPredefinedPositionsList()
def test():
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
sess = hwr.getHardwareObject("/session")
sess.set_user_info("mx2014", "143301", "14330", "20100023")
path = "/927bis/ccd/2015_Run2/visitor/mx2014/px2/20150120/ARCHIVE/mx2014/mx2014_2_4.snapshot.jpeg"
ispyb_path = sess.path_to_ispyb(path)
print path
print " will become "
print ispyb_path
def test():
import sys
hwr = HardwareRepository.getHardwareRepository()
hwr.connect()
conn = hwr.getHardwareObject(sys.argv[1])
print "Machine current: ", conn.getCurrent()
print "Life time: ", conn.getLifeTime()
print "TopUp remaining: ", conn.getTopUpRemaining()
print "Message: ", conn.getMessage()
while True:
gevent.wait(timeout=0.1)
def setMotor(self, motor_mne):
if self.motor is not None:
QObject.disconnect(self.motor, PYSIGNAL('positionChanged'), self.motorPositionChanged)
self.motor = HardwareRepository.getHardwareRepository().getHardwareObject(motor_mne)
if self.motor is not None:
self.cmdMotorPosition.setEnabled(True)
QObject.connect(self.motor, PYSIGNAL('positionChanged'), self.motorPositionChanged)
if self.motor.isReady():
self.motorPositionChanged(self.motor.getPosition())
else:
self.motorPositionChanged('unavailable')
else:
self.cmdMotorPosition.setText(MotorPositionReminder.NOPOSITION)
self.cmdMotorPosition.setEnabled(False)
