def test_alarm_propagation(self): device_name = '%s/sub1/1' % self.DOMAIN_NAME members_template = ['%s/capability/sub1cap1', '%s/capability/sub1cap2'] members = [member % self.DOMAIN_NAME for member in members_template] self.add_members(device_name, 'tiles', members) dp = DeviceProxy(device_name) self.assertNotEqual(dp.state(), AttrQuality.ATTR_ALARM) member_dp = DeviceProxy(members[0]) alarm_data = json.dumps({ 'name': 'an_attr', 'min_alarm': '20', 'max_alarm': '50' }) member_dp.command_inout('set_attribute_alarm', alarm_data) member_dp.an_attr = 10 attr = AttributeProxy(members[0] + '/an_attr') self.assertEqual(attr.read().quality, AttrQuality.ATTR_ALARM) self.assertEqual(member_dp.state(), PyTango._PyTango.DevState.ALARM) i = 0 while (dp.state() != PyTango._PyTango.DevState.ALARM) and i < 3: sleep(1) i += 1 self.assertEqual(dp.state(), PyTango._PyTango.DevState.ALARM)
def __init__(self, poolName, mntgrpName, flagClear): self.db = Database() # # the pool for the Mg # try: self.poolMg = DeviceProxy(poolName) except Exception as e: Except.print_exception(e) print("failed to get proxy to ", poolName) sys.exit(255) # # find the MG # try: self.mg = DeviceProxy(mntgrpName) except Exception: lst = [mntgrpName, 'exp_t01', 'exp_c01', 'exp_c02'] self.poolMg.command_inout('CreateMeasurementGroup', lst) self.mg = DeviceProxy(mntgrpName) if not flagClear: self.hsh = json.loads(self.mg.Configuration) self.masterTimer = self.findMasterTimer() self.index = len(self.mg.ElementList) else: self.hsh = {} self.hsh[u'controllers'] = {} self.hsh[u'description'] = "Measurement Group" self.hsh[u'label'] = mntgrpName self.index = 0
def init(self): self.moving = None self.deviceOk = True self.prev_state = None self.doBacklashCompensation = False # Channel and commands for monochormator pitch. # it will be used here to make sure it is on before moving energy (PX2) # not needed on PX1 self.mono_mt_rx_statech = None self.mono_mt_rx_oncmd = None # Connect to device BLEnergy defined "tangoname" in the xml file try: self.BLEnergydevice = DeviceProxy(self.getProperty("tangoname")) except: self.errorDeviceInstance(self.getProperty("tangoname")) # Connect to device mono defined "tangoname2" in the xml file # used for conversion in wavelength try: self.monodevice = DeviceProxy(self.getProperty("tangoname2")) except: self.errorDeviceInstance(self.getProperty("tangoname2")) # Nom du device bivu (Energy to gap) : necessaire pour amelioration du positionnement de l'onduleur (Backlash) try: # self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3"), movingState="RUNNING") # Modif suite a changement par ICA de l etat du device U20 RUNNING devient MOVING self.U20Energydevice = DeviceProxy(self.getProperty("tangoname3")) except: self.errorDeviceInstance(self.getProperty("tangoname3")) self.doBacklashCompensation = self.getProperty("backlash") # print self.doBacklashCompensation try: self.mono_mt_rx_statech = self.getChannelObject("mono_mt_rx_state") self.mono_mt_rx_oncmd = self.getCommandObject("mono_mt_rx_on") except KeyError: logging.info( "Beware that mt_rx control is not properly defined for BLEnergy" ) # parameters for polling if self.deviceOk: self.isConnected() self.prev_state = str(self.BLEnergydevice.State()) energyChan = self.getChannelObject("energy") energyChan.connectSignal("update", self.energyChanged) stateChan = self.getChannelObject( "state" ) # utile seulement si statechan n'est pas defini dans le code stateChan.connectSignal("update", self.stateChanged)
def main(): # Find out what we're supposed to be doing... config = parse_args(sys.argv[1:]) # ...and set up the reduced set of parameters we're interested in. make_reduced_attribs() # Construct all the names of the motors we're interested in dev_names = generate_device_names(config['server'], config['dev_ids']) all_motors = set(itertools.chain.from_iterable(dev_names.values())) if config['write_params']: input_motor_params = read_dat(config['input_file']) # We check that all of the motors we are interested in have an entry in our input file motors_with_params = set(input_motor_params.keys()) motors_to_update = list(all_motors & motors_with_params) # The input file should contain only motors which are on the given # server or, the input file should contain parameters for all motors # when device IDs have been specified. if set(motors_with_params).issubset(all_motors) or (bool(config['dev_ids']) and all_motors.issubset(motors_with_params)): for motor in sorted(motors_to_update): oms_dp = DeviceProxy('{}/{}/motor/{}'.format(config['tango_host'], config['beamline'], motor)) zmx_dp = DeviceProxy('{}/{}/ZMX/{}'.format(config['tango_host'], config['beamline'], motor)) print('Writing config to motor {}'.format(motor)) write_parameters(oms_dp, zmx_dp, input_motor_params[motor]) print('{}: DONE'.format(motor)) print('\nSuccessfully updated configuration for motors:\n{}'.format(', '.join(sorted(motors_to_update)))) else: print('ERROR: Configuration for one or more of the requested motors is not in the input file.\nAborting...') sys.exit(1) elif config['compare_params']: # FIXME: this part of function not tested! input_all_motor_params = read_dat(config['input_file']) current_all_motor_params = read_motors(config, dev_names) # As per the write, we check that all of the motors we are interested in have an entry in our input file motors_with_params = set(input_all_motor_params.keys()) motors_to_update = list(all_motors & motors_with_params) if set(motors_with_params).issubset(all_motors) or (bool(config['dev_ids']) and all_motors.issubset(motors_with_params)): for motor in sorted(motors_to_update): motors_equal = True input_this_motor_params = input_all_motor_params[motor] current_this_motor_params = current_all_motor_params[motor] for recorded_param in input_this_motor_params.keys(): curr_param_equal = (input_this_motor_params[recorded_param] == current_this_motor_params[recorded_param]) motors_equal = motors_equal and curr_param_equal if not curr_param_equal: print('{} parameter for motor {} differ! (Input: {} Current: {})'.format(recorded_param, motor, input_this_motor_params[recorded_param], current_this_motor_params[recorded_param])) if motors_equal: print('{}: Input and current params are same\n'.format(motor)) else: print('{}: Input and current params are DIFFERENT\n'.format(motor)) else: all_motor_params = read_motors(config, dev_names) write_dat(all_motor_params)
def create_meas(self, config): """ Create a meas with the given configuration """ # creating mg config = copy.deepcopy(config) self.expchan_names = [] self.tg_names = [] ordered_chns = [None] * 10 for ctrl_name, ctrl_config in config.items(): channels = ctrl_config["channels"] for chn, chn_config in channels.items(): index = chn_config["index"] ordered_chns[index] = chn self.expchan_names = [chn for chn in ordered_chns if chn is not None] self.pool.CreateMeasurementGroup([self.mg_name] + self.expchan_names) for ctrl_name in config.keys(): ctrl_config = config.pop(ctrl_name) channels = ctrl_config["channels"] for chn_name in channels.keys(): chn_config = channels.pop(chn_name) chn_full_name = _get_full_name(DeviceProxy(chn_name)) channels[chn_full_name] = chn_config ctrl_full_name = _get_full_name(DeviceProxy(ctrl_name)) synchronizer = ctrl_config.get("synchronizer") if synchronizer is not None and synchronizer != "software": self.tg_names.append(synchronizer) synchronizer = _get_full_name(DeviceProxy(synchronizer)) ctrl_config["synchronizer"] = synchronizer config[ctrl_full_name] = ctrl_config try: self.meas = PyTango.DeviceProxy(self.mg_name) except: raise Exception('Could not create the MeasurementGroup: %s' % (self.mg_name)) # When measurement group gets created it fills the configuration with # the default values. Reusing read configuration in order to set test # parameters. jcfg = self.meas.read_attribute('configuration').value cfg = json.loads(jcfg) for ctrl in cfg['controllers']: ctrl_config = cfg['controllers'][ctrl] ctrl_test_config = config[ctrl] channels = ctrl_config['channels'] channels_test = ctrl_test_config.pop("channels") for chn, chn_config in channels.items(): chn_test_config = channels_test[chn] chn_config.update(chn_test_config) ctrl_config.update(ctrl_test_config) # Write the built configuration self.meas.write_attribute('configuration', json.dumps(cfg))
def read_motors(config, dev_names): # FIXME: Should have separate test? # For each motor in the list, make Tango servers and query them for information all_motor_params = {} for server in sorted(dev_names.keys()): for motor in dev_names[server]: oms_dp = DeviceProxy('{}/{}/motor/{}'.format(config['tango_host'], config['beamline'], motor)) zmx_dp = DeviceProxy('{}/{}/ZMX/{}'.format(config['tango_host'], config['beamline'], motor)) print('Reading parameters for motor {}...'.format(motor)) all_motor_params[motor] = read_parameters(oms_dp, zmx_dp) print('{}: DONE'.format(motor)) print('\nSuccessfully read configurations for motors:\n{}'.format(', '.join(dev_names[server]))) return all_motor_params
def __init__(self, inst, props, *args, **kwargs): MotorController.__init__(self, inst, props, *args, **kwargs) self.axisAttributes = {} self.interlockProxy = None try: print self.MotorName, self.InterlockDevice self.motorProxy = DeviceProxy(self.MotorName) if self.InterlockDevice != "": self.interlockProxy = DeviceProxy(self.InterlockDevice) except DevFailed, df: de = df[0] self._log.error("__init__ DevFailed: (%s) %s" % (de.reason, de.desc)) self._log.error("__init__ DevFailed: %s" % str(df))
def make_test(self, attr=None): """ Performs a full test of the tango server device If the attribute is given - trying to read it as well :param attr: :return: """ #@TODO : test database res = True try: d = DeviceProxy(self.device) self.debug("Device ({}) ping value ({})".format( self.device, d.ping())) state = d.state() if state == DevState.FAULT or state == DevState.UNKNOWN: raise DevFailed if self.testString(attr): v = d.read_attribute(attr) except (DevFailed, AttributeError) as e: res = False return res
def read_attributes(self, attrs): """ Reads attribute value, returns none in case of na error :param attr: :return: """ res = [] try: if not self.test(self.device): raise ValueError d = DeviceProxy(self.device) d.ping() self.debug("Device ({}) is online".format(self.device)) state = d.state() values = None # read value only if the state is fine if state != DevState.FAULT and state != DevState.UNKNOWN: values = d.read_attributes(attrs) for value in values: res.append(value.value) self.debug("Attributes value ({}/{}/{})".format(state, attrs, res)) except DevFailed: self.error( "There is an error with access to the device ({})".format( self.device)) except ValueError: self.error("User has not provided a valid device name") return res
def _poll_image(sleep_time, video_device, device_uri, video_mode, formats): from PyTango import DeviceProxy connected = False while not connected: try: logging.getLogger("HWR").info("Connecting to %s", device_uri) lima_tango_device = DeviceProxy(device_uri) lima_tango_device.ping() except Exception as ex: logging.getLogger("HWR").exception("") logging.getLogger("HWR").info( "Could not connect to %s, retrying ...", device_uri) connected = False time.sleep(0.2) else: connected = True while True: try: data = poll_image(lima_tango_device, video_mode, formats)[0] video_device.write(data) except Exception as ex: print(ex) finally: time.sleep(sleep_time / 2)
def __init__(self, model, parent=None): QWidget.__init__(self, parent) uic.loadUi("MotorWidget.ui", self) self.connect(self.configButton, SIGNAL("clicked()"), self.openConfig) self.connect(self.goButton, SIGNAL("clicked()"), self.go) self.connect(self.moveNegButton, SIGNAL("clicked()"), self.moveNeg) self.connect(self.movePosButton, SIGNAL("clicked()"), self.movePos) self.connect(self.disableButton, SIGNAL("toggled(bool)"), self.disable) self.stateLabel.setModel("%s/state" % model) self.positionLCD.setModel("%s/position" % model) self.motor = DeviceProxy(str(model)) try: self.nameLabel.setText(self.motor.alias()) except Exception: match = re.search(r"((?:[^/]+/){2}[^/]+)$", model) if not match: self.nameLabel.setText(model) else: self.nameLabel.setText(match.group(1)) pos = AttributeProxy("%s/position" % model) try: self.unitLabel.setText(pos.get_config().unit) except Exception: self.unitLabel.setText("") self.absMotionEdit.setText(str(self.motor.position))
def init(self): self.predefinedPositions = {} self.predefinedLightLevel = {} self.predefinedPositionsNamesList = [] self.delta = self.getProperty('delta') or 10 self.light_dev = DeviceProxy(self.getProperty('tangoname_light')) try: positions = self['positions'] except: logging.getLogger().error('%s does not define positions.', str(self.name())) else: for definedPosition in positions: positionUsername = definedPosition.getProperty('username') try: offset = float(definedPosition.getProperty('offset')) light_level = float(definedPosition.getProperty('lightLevel')) except: logging.getLogger().warning('%s, ignoring position %s: invalid offset.', str(self.name()), positionUsername) else: self.predefinedPositions[positionUsername] = offset self.predefinedLightLevel[positionUsername] = light_level self.sortPredefinedPositionsList()
def subscribe(self, form, callback): """ Tango event subscription. The 'form' argument is an instance of TangoEventSubscriptionForm Throws in case of error """ dev_proxy = DeviceProxy(form.dev) fq_attr_name = event_source_str("{}/{}".format(dev_proxy.dev_name(), form.attr)) if (fq_attr_name, form.evt_type) in self._subscriptions: try: self.unsubscribe(fq_attr_name, form.evt_type) except Exception as e: self.logger.error(e) raise tango_evt = TangoEventInfo( attr=form.attr, dev_proxy=dev_proxy, evt_type=form.evt_type, message_id=form.message_id, user_data=form.user_data, ) pre_subscription_action(form, dev_proxy) self._subscriptions[(fq_attr_name, form.evt_type)] = tango_evt try: tango_evt.subscribe(callback) except: del self._subscriptions[(fq_attr_name, form.evt_type)] raise
def addPilatusD9(self, device): ctrl = self.findDeviceController(device) if ctrl not in self.hsh[u'controllers'].keys(): print("MgUtils.addPilatus adding controller ", ctrl) self.hsh[u'controllers'][ctrl] = {} self.hsh[u'controllers'][ctrl][u'synchronizer'] = "software" self.hsh[u'controllers'][ctrl][u'channels'] = {} self.hsh[u'controllers'][ctrl][u'id'] = 0 self.hsh[u'controllers'][ctrl][u'monitor'] = \ self.findFullDeviceName(device) self.hsh[u'controllers'][ctrl][u'timer'] = \ self.findFullDeviceName(device) self.hsh[u'controllers'][ctrl][u'trigger_type'] = 0 ctrlChannels = self.hsh[u'controllers'][ctrl][u'channels'] fullDeviceName = self.findFullDeviceName(device) if fullDeviceName not in ctrlChannels.keys(): print("adding index", self.index, device) # proxy = DeviceProxy(str(fullDeviceName)) dct = {} dct[u'conditioning'] = u'' dct[u'enabled'] = True dct[u'full_name'] = fullDeviceName dct[u'index'] = self.index self.index += 1 dct[u'label'] = str(device) dct[u'name'] = str(device) dct[u'ndim'] = 2 dct[u'normalization'] = 0 dct[u'output'] = True dct[u'plot_axes'] = [u'<mov>'] dct[u'plot_type'] = 0 dct[u'source'] = fullDeviceName + "/Value" ctrlChannels[fullDeviceName] = dct
def refreshAttributes(self, device): attrs = [] try: db = self.db name = device.name() full_name = db.getFullName() + "/" + name taurus_dev = db.factory().getDevice(full_name, create_if_needed=False) if taurus_dev is None: dev = DeviceProxy(full_name) else: dev = taurus_dev.getDeviceProxy() attr_info_list = dev.attribute_list_query_ex() for attr_info in attr_info_list: full_attr_name = "%s/%s" % (full_name, attr_info.name) attr_obj = TangoAttrInfo(self, name=attr_info.name, full_name=full_attr_name, device=device, info=attr_info) attrs.append(attr_obj) attrs = sorted(attrs, key=lambda attr: attr.name().lower()) except DevFailed as df: pass device.setAttributes(attrs)
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 log(self, details): cmessage = details[3] clevel = details[1] tango_log_level = { "FATAL": 1, "ERROR": 2, "WARN": 3, "INFO": 4, "DEBUG": 5 } level_number = tango_log_level[clevel] clogsource = details[2] if clogsource == details[2]: device = DeviceProxy(clogsource) deviceLogLevel = device.centralLoggingLevel if clevel == "FATAL" and level_number <= deviceLogLevel: self.fatal_stream("%s : %s", clogsource, cmessage) elif clevel == "ERROR" and level_number <= deviceLogLevel: self.error_stream("%s : %s", clogsource, cmessage) elif clevel == "WARN" and level_number <= deviceLogLevel: self.warn_stream("%s : %s", clogsource, cmessage) elif clevel == "INFO" and level_number <= deviceLogLevel: self.info_stream("%s : %s", clogsource, cmessage) elif clevel == "DEBUG" and level_number <= deviceLogLevel: self.debug_stream("%s : %s", clogsource, cmessage) else: pass else: pass
def test_add_member(self): device_name = '%s/sub/1' % self.DOMAIN_NAME group_name = 'capabilities' # self.stop_device_server('Subarray_DS') # self.start_device_server('Subarray_DS') dp = DeviceProxy(device_name) dp.set_logging_level(5) member_device_name_1 = '%s/capability/sub1cap1' % self.DOMAIN_NAME data_1 = json.dumps({ 'group_name': group_name, 'device_name': member_device_name_1 }) dp.command_inout('add_member', data_1) self.assertTrue( member_device_name_1 in dp.get_property(group_name)[group_name]) member_device_name_2 = '%s/capability/sub1cap2' % self.DOMAIN_NAME data_2 = json.dumps({ 'group_name': group_name, 'device_name': member_device_name_2 }) dp.command_inout('add_member', data_2) items = dp.get_property(group_name)[group_name] self.assertTrue(member_device_name_2 in items) self.assertEqual(len(items), 2) dp.command_inout('remove_member', data_2) items = dp.get_property(group_name)[group_name] self.assertFalse(member_device_name_2 in items) self.assertEqual(len(items), 1) dp.command_inout('remove_member', data_1) self.assertFalse( member_device_name_1 in dp.get_property(group_name)[group_name])
def __init__(self, devName, attrName, minPeriod=0.1, minChange=0.001, callbacks=None, *args, **kwargs): super(Monitor, self).__init__(*args, **kwargs) self._devName = devName self._attrName = attrName self._name = "%s/%s" % (devName, attrName) try: self._proxy = DeviceProxy(self._devName) except: raise ReferenceError("DeviceProxy for %s not available" % self._name) self._eventId = None self._value = None self._quality = None self._minPeriod = minPeriod self._minChange = minChange self._timestamp = None self._callbacks = callbacks self.subscribe()
def errorDeviceInstance(self, device): logging.getLogger("HWR").debug("%s: BLEnergy.errorDeviceInstance: %s", self.name(), device) db = DeviceProxy("sys/database/dbds1") logging.getLogger().error("Check Instance of Device server %s" % db.DbGetDeviceInfo(device)[1][3]) self.sDisconnected()
def _init(self): self.MOVESTARTED = 0 self.NOTINITIALIZED = 0 self.UNUSABLE = 0 self.READY = 2 self.MOVING = 4 self.ONLIMIT = 1 self.device = DeviceProxy( self.getProperty("tangoname")) #, verbose=False) self.device.timeout = 6000 # Setting timeout to 6 sec self.device.waitMoves = False logging.getLogger("HWR").info("TangoMotor._init of device %s" % self.device.name) self.setIsReady(True) print "TangoMotor._init of device %s" % self.device.name positionChan = self.getChannelObject( "position" ) # utile seulement si statechan n'est pas defini dans le code positionChan.connectSignal("update", self.positionChanged) stateChan = self.getChannelObject( "state" ) # utile seulement si statechan n'est pas defini dans le code stateChan.connectSignal("update", self.motorStateChanged)
def ping_to_device(): Log('server asked to ping from device', 'd') global disable_Pytango if disable_Pytango: p = DeviceProxy("sys/tg_test/1") elapsed_time = p.ping() emit("pong from device", {'elapsed': elapsed_time}) Log('client ponged from device', 'd')
def add_members(self, device_name, group_name, members=None): dp = DeviceProxy(device_name) for member in members: data = json.dumps({ 'group_name': group_name, 'device_name': member }) dp.command_inout('add_member', data)
def init(self): HardwareObject.init(self) self.template_dir = self.get_property("template_dir") var_dsname = self.get_property("variables_ds") logging.getLogger("HWR").debug( "ALBAAutoProcessing INIT: var_ds=%s, template_dir=%s" % (var_dsname, self.template_dir)) self.var_ds = DeviceProxy(var_dsname)
def get_attribute_list(): print("in get_attribute_list") try: p = DeviceProxy("sys/tg_test/1") attributes = p.get_attribute_list() parsedAttributes = parseStdStringVector(attributes) return jsonify(parsedAttributes) except (CommunicationFailed, ConnectionFailed, DevFailed) as e: return jsonify(handleException(e))
def command_list_query(): print("in command_list_query") try: p = DeviceProxy("sys/tg_test/1") commands = p.command_list_query() parsedCommands = parseCommandInfoList(commands) return jsonify(parsedCommands) except (CommunicationFailed, ConnectionFailed, DevFailed) as e: return jsonify(handleException(e))
def init_graph(self): temp = str(self.itemText).split(' - ') self.ui.hour_label.show() self.ui.hour_value.show() self.ui.minutes_label.show() self.ui.minutes_value.show() if len(temp) > 1: self.attr = temp[1] with open('graph_config', 'r') as fin: graph_nodes = json.loads(fin.read()) current_graph_node = graph_nodes[str(self.itemText)] total_graph_values = int( current_graph_node['total_graph_values']) graph_updation_time = int( current_graph_node['graph_updation_time']) print "----init_graph----" print "total_graph_values:", total_graph_values print "graph_updation_time:", graph_updation_time elif len(temp) == 1: self.attr = str(self.ui.childrenBox.currentText()) with open('graph_config', 'r') as fin: graph_nodes = json.loads(fin.read()) current_graph_node = graph_nodes[str(self.itemText)] self.total_graph_values = int( current_graph_node['total_graph_values']) graph_updation_time = int( current_graph_node['graph_updation_time']) print "----init_graph----" print "total_graph_values:", self.total_graph_values print "graph_updation_time:", graph_updation_time self.branch_time_array = [] self.branch_axis_counter = 0 pg.setConfigOptions(antialias=True) self.ui.graphicsView.clear() self.curve = self.ui.graphicsView.plot(pen='y') try: self.l.scene().removeItem(self.l) except AttributeError: pass self.l = pg.LegendItem((100, 60), offset=(70, 30)) self.l.setParentItem(self.ui.graphicsView.graphicsItem()) self.l.addItem(self.curve, self.attr) self.data = [] self.ptr = 0 if len(temp) > 1: self.proxy = DeviceProxy(temp[0]) params = json.dumps({'period': 1}) data = json.loads(self.proxy.get_data(params)) data = data[self.attr] data_len = len(data) self.data_period = total_graph_values / data_len else: self.proxy = '' self.graphTimer.stop() self.graphTimer.timeout.connect(self.update_plot) self.graphTimer.start(graph_updation_time)
def cmdDevice(domain,deviceClass,deviceInstance): dev = DeviceProxy(domain+"/"+deviceClass+"/"+deviceInstance) json_data = request.get_json() cmd_name = json_data["cmd_name"] cmd_param = json_data["cmd_param"] if (cmd_param== "None"): result = dev.command_inout(cmd_name) else: result = dev.command_inout(cmd_name,cmd_param) return cmd_name
def read_attribute(attribute): if app.testing: print("in read_attribute") try: p = DeviceProxy("sys/tg_test/1") redAttribute = p.read_attribute(attribute) response = parseAttribute(redAttribute) return jsonify(response) except (CommunicationFailed, ConnectionFailed, DevFailed) as e: return jsonify(handleException(e))
def init(self): self.get_object_by_role("controller") self.shutter = self.get_deviceby_role("shutter") self.aperture = self.get_object_by_role("aperture") self.factor = self.get_property("current_photons_factor") self.shutter.connect("shutterStateChanged", self.shutterStateChanged) self.tg_device = DeviceProxy(self.get_property("tango_device")) self.counts_reading_task = self._read_counts_task(wait=False)