Пример #1
0
    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)
Пример #3
0
def poll_image(encoder_input, device_uri, debug, sleep_time):
    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

    if isinstance(encoder_input, str):
        encoder_input = open(encoder_input, "wb", 0)

    # sleep_time = lima_tango_device.video_exposure
    last_frame_number = -1
    dtlist = []
    mean_poll_t = sleep_time

    while True:
        try:
            t0 = time.perf_counter()
            data, width, height, frame_number = get_image(lima_tango_device)

            if last_frame_number != frame_number:
                encoder_input.write(data)
                last_frame_number = frame_number

            dt = time.perf_counter() - t0
            dtlist.append(dt)

            if len(dtlist) > 25:
                mean_poll_t = statistics.mean(dtlist)
                if debug:
                    print("Poll took, %s(s) \n" % mean_poll_t)

                dtlist = []

        except Exception as ex:
            print(ex)
        finally:
            _sleep_time = sleep_time - mean_poll_t

            if _sleep_time < 0:
                _sleep_time = 0

            time.sleep(_sleep_time)
Пример #4
0
    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
Пример #5
0
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')
Пример #6
0
 def populate_startup_nodes(self):
     nodes = self.db.nodes
     print dt.now(), ":", 'populating leaves'
     for i in nodes.find({'type': 'leaf'}):
         device = i['name'] + " - " + i['attr']
         if device in self.checkedLeaves:
             continue
         proxy = DeviceProxy(i['name'])
         deviceFlag = 1
         while deviceFlag:
             try:
                 proxy.ping()
                 deviceFlag = 0
                 t = threading.Thread(target=self.aggregate_data,
                                      args=([device]))
                 t.start()
                 self.checkedLeaves.append(device)
             except Exception as ex:
                 print "Warning" + "Start the device server" + device
Пример #7
0
    def run(self):
        """
        Starts a process
        :return:
        """
        self.debug("Starting a pytango runner ({}/{}/{})".format(
            self.device, self.attr, self.value))

        try:
            d = DeviceProxy(self.device)
            d.ping()

            state = d.state()
            if state == DevState.FAULT:
                raise DevFailed

            d.write_attribute(self.attr, self.value)
        except DevFailed:
            self.error("Error with the pytango runner ({}/{}/{})".format(
                self.device, self.attr, self.value))
Пример #8
0
 def populate_startup_nodes(self):
     nodes = self.db.nodes
     print dt.now(), ":", 'populating leaves'
     for i in nodes.find({'type': 'leaf'}):
         device = i['name'] + " - " + i['attr']
         if device in self.checkedLeaves:
             continue
         proxy = DeviceProxy(i['name'])
         deviceFlag = 1
         while deviceFlag:
             try:
                 proxy.ping()
                 deviceFlag = 0
                 t = threading.Thread(target=self.aggregate_data,
                                      args=([device]))
                 t.start()
                 self.update_tree(self.dataSourcesTreeItem, i['name'],
                                  i['attr'])
                 self.checkedLeaves.append(device)
             except Exception as ex:
                 QtGui.QMessageBox.critical(self, "Warning",
                                            "Start the device server " + device)
     print dt.now(), ":", 'populating branches'
     for i in nodes.find({'type': 'branch'}):
         device = i['name']
         treeBranch = QtGui.QTreeWidgetItem(self.ui.treeWidget)
         treeBranch.setText(0, device)
         for j in i['children']:
             if '-' in j:
                 temp = j.split(' - ')
                 self.update_tree(treeBranch, temp[0], temp[1])
             else:
                 self.update_tree(treeBranch, j, "")
         t = threading.Thread(
             target=self.aggregate_branch_data, args=([device]))
         t.start()
Пример #9
0
 def populate_startup_nodes(self):
     nodes = self.db.nodes
     print dt.now(), ":", 'populating leaves'
     for i in nodes.find({'type': 'leaf'}):
         device = i['name'] + " - " + i['attr']
         if device in self.checkedLeaves:
             continue
         proxy = DeviceProxy(i['name'])
         deviceFlag = 1
         while deviceFlag:
             try:
                 proxy.ping()
                 deviceFlag = 0
                 t = threading.Thread(target=self.aggregate_data,
                                      args=([device]))
                 t.start()
                 self.update_tree(self.dataSourcesTreeItem, i['name'],
                                  i['attr'])
                 self.checkedLeaves.append(device)
             except Exception as ex:
                 QtGui.QMessageBox.critical(
                     self, "Warning", "Start the device server " + device)
     print dt.now(), ":", 'populating branches'
     for i in nodes.find({'type': 'branch'}):
         device = i['name']
         treeBranch = QtGui.QTreeWidgetItem(self.ui.treeWidget)
         treeBranch.setText(0, device)
         for j in i['children']:
             if '-' in j:
                 temp = j.split(' - ')
                 self.update_tree(treeBranch, temp[0], temp[1])
             else:
                 self.update_tree(treeBranch, j, "")
         t = threading.Thread(target=self.aggregate_branch_data,
                              args=([device]))
         t.start()
Пример #10
0
class TangoTestContext(object):
    """ Context to run a device without a database."""

    nodb = "#dbase=no"
    command = "{0} {1} -ORBendPoint giop:tcp::{2} -file={3}"
    connect_time = 6.0

    def __init__(self, device, device_cls=None, server_name=None,
                 instance_name=None, device_name=None, properties={},
                 db=None, port=0, debug=5, daemon=False, process=False):
        """Inititalize the context to run a given device."""
        # Argument
        tangoclass = device.__name__
        if not server_name:
            server_name = tangoclass
        if not instance_name:
            instance_name = server_name.lower()
        if not device_name:
            device_name = 'test/nodb/' + server_name.lower()
        if not port:
            port = get_port()
        if db is None:
            _, db = tempfile.mkstemp()
        # Attributes
        self.db = db
        self.port = port
        self.device_name = device_name
        self.server_name = "/".join(("dserver", server_name, instance_name))
        self.host = "{0}:{1}/".format(platform.node(), self.port)
        self.device = self.server = None
        # File
        self.generate_db_file(server_name, instance_name, device_name,
                              tangoclass, properties)
        # Command args
        string = self.command.format(server_name, instance_name, port, db)
        string += " -v{0}".format(debug) if debug else ""
        cmd_args = string.split()
        # Target and arguments
        if device_cls:
            target = run
            args = ({tangoclass: (device_cls, device)}, cmd_args)
        elif not hasattr(device, 'run_server'):
            target = run
            args = ((device,), cmd_args)
        else:
            target = device.run_server
            args = (cmd_args,)
        # Thread
        cls = Process if process else Thread
        self.thread = cls(target=target, args=args)
        self.thread.daemon = daemon

    def generate_db_file(self, server, instance, device,
                         tangoclass=None, properties={}):
        """Generate a database file corresponding to the given arguments."""
        if not tangoclass:
            tangoclass = server
        # Open the file
        with open(self.db, 'w') as f:
            f.write("/".join((server, instance, "DEVICE", tangoclass)))
            f.write(': "' + device + '"\n')
        # Create database
        db = Database(self.db)
        # Patched the property dict to avoid a PyTango bug
        patched = dict((key, value if value != '' else ' ')
                       for key, value in properties.items())
        # Write properties
        db.put_device_property(device, patched)
        return db

    def get_device_access(self):
        """Return the full device name."""
        return self.host+self.device_name+self.nodb

    def get_server_access(self):
        """Return the full server name."""
        return self.host+self.server_name+self.nodb

    def start(self):
        """Run the server."""
        self.thread.start()
        self.connect()
        return self

    @retry(connect_time, [ConnectionFailed, DevFailed])
    def connect(self):
        self.device = DeviceProxy(self.get_device_access())
        self.device.ping()
        self.server = DeviceProxy(self.get_server_access())
        self.server.ping()

    def stop(self, timeout=None):
        """Kill the server."""
        if self.server:
            self.server.command_inout('Kill')
        self.thread.join(timeout)
        os.unlink(self.db)

    def join(self, timeout=None):
        self.thread.join(timeout)

    def __enter__(self):
        """Enter method for context support."""
        if not self.thread.is_alive():
            self.start()
        return self.device

    def __exit__(self, exc_type, exception, trace):
        """Exit method for context support."""
        self.stop()
Пример #11
0
def ping_to_device():
    print('server asked to ping from device')
    p = DeviceProxy("sys/tg_test/1")
    elapsed_time = p.ping()
    emit("pong from device", {'elapsed': elapsed_time})
    print('client ponged from device')