Example #1
0
    def _get_next(self):
        packet = self._recv_packet(allow_recovery_skip=True)

        if not isinstance(packet, protocol.StreamData):
            raise ClientError("got unexpected type of frame")

        info = {}
        for addr, enc_val in packet.result_info:
            try:
                reg = regmap.get_reg(addr, self._mode)
                val = reg.decode(enc_val)
            except (protocol.ProtocolError, ValueError):
                log.info("got unknown reg val in result info")
                log.info("addr: {}, value: {}".format(addr, fmt_enc_val(enc_val)))
            else:
                k = reg.stripped_name
                k = regmap.STRIPPED_NAME_TO_INFO_REMAP.get(k, k)

                if k is None:
                    continue

                info[k] = val

        sweeps_per_frame = getattr(self._config, "sweeps_per_frame", None)
        data = protocol.decode_output_buffer(packet.buffer, self._mode, sweeps_per_frame)

        if self.squeeze:
            return info, data
        else:
            return [info], np.expand_dims(data, 0)
Example #2
0
    def _get_next(self):
        ret_cmd, ret_args = self._data_queue.get()
        if ret_cmd == "error":
            raise ClientError("exception raised in SPI communcation process")
        elif ret_cmd != "get_next":
            raise ClientError
        info, buffer = ret_args

        sweeps_per_frame = getattr(self._config, "sweeps_per_frame", None)
        data = protocol.decode_output_buffer(buffer, self._mode, sweeps_per_frame)

        if self.squeeze:
            return info, data
        else:
            return [info], np.expand_dims(data, 0)
    def _get_next(self):
        if self._measure_on_call:
            self._write_reg("main_control", "clear_status")

        poll_t = time()

        while True:
            status = self._read_reg("status")

            if status & regmap.STATUS_MASKS.ERROR_MASK:
                raise ClientError("server error: " + str(status).split(".")[1])
            elif status & regmap.STATUS_FLAGS.DATA_READY:
                break
            else:
                if (time() - poll_t) > self._poll_timeout:
                    raise ClientError("gave up polling")

                continue

        buffer = self._read_buf_raw()

        info = {}
        info_regs = regmap.get_data_info_regs(self._config.mode)
        for reg in info_regs:
            k = reg.stripped_name
            k = regmap.STRIPPED_NAME_TO_INFO_REMAP.get(k, k)

            if k is None:
                continue

            info[k] = self._read_reg(reg)

        if not self._measure_on_call:
            self._write_reg("main_control", "clear_status")

        sweeps_per_frame = getattr(self._config, "sweeps_per_frame", None)
        data = protocol.decode_output_buffer(buffer, self._mode,
                                             sweeps_per_frame)

        if self.squeeze:
            return info, data
        else:
            return [info], np.expand_dims(data, 0)