Пример #1
0
    def _setup_session(self, config):
        if len(config.sensor) > 1:
            raise ValueError(
                "the register protocol does not support multiple sensors")
        if config.sensor[0] != 1:
            raise ValueError(
                "the register protocol currently only supports using sensor 1")

        mode = config.mode
        self._mode = mode
        self._config = config

        self._write_reg("main_control", "stop")
        self._write_reg("mode_selection", mode)
        self._write_reg("update_rate", 0)

        for key, reg in regmap.get_config_key_to_reg_map(mode).items():
            val = getattr(config, key)

            if val is None:
                continue

            self._write_reg(reg, val)

        self._write_reg("sensor_power_mode", "active")
        self._write_reg("streaming_control", self._streaming_control_val)

        self._write_reg("main_control", "create")
        self._wait_status(regmap.STATUS_FLAGS.CREATED)

        info = {}
        info_regs = regmap.get_session_info_regs(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 MODE_INFOS[mode].fixed_buffer_size:
            self._data_length = info.get("data_length")

            log.info("data length: {}".format(self._data_length))
            log.info("buffer size: {} B".format(self._buffer_size))
        else:
            self._data_length = None

        if self._data_rate is not None:
            log.info("requested data rate: {:.2f} Mbit/s".format(
                self._data_rate * 1e-6))

        return info
def test_config_to_reg_map_completeness():
    all_param_keys = set()

    for mode, config_class in configs.MODE_TO_CONFIG_CLASS_MAP.items():
        params = {
            k: v
            for k, v in inspect.getmembers(config_class)
            if isinstance(v, cb.Parameter)
        }
        all_param_keys.update(params.keys())

        expected_config_key_to_reg_map = {}

        for param_name, param in params.items():
            if param.is_dummy:
                continue

            reg_name = regmap.CONFIG_TO_STRIPPED_REG_NAME_MAP[param_name]

            if reg_name is None:
                continue

            reg = regmap.get_reg(reg_name, mode)

            assert reg.category in [
                regmap.Category.CONFIG, regmap.Category.GENERAL
            ]

            expected_config_key_to_reg_map[param_name] = reg

        assert regmap.get_config_key_to_reg_map(
            mode) == expected_config_key_to_reg_map

    unknown_keys_in_map = set(
        regmap.CONFIG_TO_STRIPPED_REG_NAME_MAP.keys()) - all_param_keys
    assert not unknown_keys_in_map