def test_get_reg_status(): reg = regmap.get_reg("status") assert reg.full_name == "status" assert reg == regmap.STATUS_REG assert reg.bitset_flags == regmap.STATUS_FLAGS assert reg.bitset_masks == regmap.STATUS_MASKS assert regmap.get_reg(reg) == reg assert regmap.get_reg(reg.addr) == reg
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)
def test_config_to_reg_map_completeness(): m = regmap.CONFIG_TO_STRIPPED_REG_NAME_MAP assert len(m) == len(set(m)) all_config_attrs = set() for mode, config_class in configs.MODE_TO_CONFIG_CLASS_MAP.items(): attrs = [ k for k, v in inspect.getmembers(config_class) if isinstance(v, cb.Parameter) ] all_config_attrs.update(attrs) for attr in attrs: reg_name = m[attr] if reg_name is None: continue reg = regmap.get_reg(reg_name, mode) assert reg.category in [ regmap.Category.CONFIG, regmap.Category.GENERAL ] assert all_config_attrs == set(m.keys())
def test_encode_bool(): reg = regmap.get_reg("tx_disable") assert reg.data_type == regmap.DataType.BOOL assert reg.encode(False) == int(0).to_bytes(4, BO) assert reg.encode(True) == int(1).to_bytes(4, BO) assert reg.encode(0) == int(0).to_bytes(4, BO) assert reg.encode(1) == int(1).to_bytes(4, BO) assert reg.encode(123) == int(1).to_bytes(4, BO)
def test_encode_uint(): reg = regmap.get_reg("downsampling_factor") assert reg.data_type == regmap.DataType.UINT32 assert reg.encode(0) == int(0).to_bytes(4, BO, signed=True) assert reg.encode(1234) == int(1234).to_bytes(4, BO, signed=True) with pytest.raises(ValueError): reg.encode(-123)
def _handshake(self): self._write_reg("main_control", "stop", expect_response=False) exp_addr = regmap.get_reg_addr("main_control") exp_enc_val = regmap.get_reg("main_control").encode("stop") exp_reg_val = protocol.RegVal(exp_addr, exp_enc_val) exp_packet = protocol.RegWriteResponse(exp_reg_val) exp_frame = protocol.insert_packet_into_frame(exp_packet) self._link.recv_until(exp_frame)
def test_encode_float(): reg = regmap.get_reg("range_start") assert reg.full_name == "range_start" assert reg.float_scale == pytest.approx(1000) assert reg.data_type == regmap.DataType.INT32 assert reg.encode(0) == int(0).to_bytes(4, BO, signed=True) assert reg.encode(0.123) == int(123).to_bytes(4, BO, signed=True) assert reg.encode(-0.123) == int(-123).to_bytes(4, BO, signed=True)
def test_encode_enum(): reg = regmap.get_reg("mode_selection") assert reg.data_type == regmap.DataType.ENUM envelope = reg.enum.ENVELOPE truth = int(envelope).to_bytes(4, BO) assert reg.encode(envelope) == truth assert reg.encode(int(envelope)) == truth assert reg.encode("envelope") == truth assert reg.encode("ENVELOPE") == truth # Implicit remapping assert reg.encode(Mode.ENVELOPE) == truth # Explicit remapping reg = regmap.get_reg("repetition_mode") truth = int(reg.enum.STREAMING).to_bytes(4, BO) assert reg.encode( configs.BaseServiceConfig.RepetitionMode.SENSOR_DRIVEN) == truth
def test_unpack_stream_data_segment(): reg = regmap.get_reg("run_factor", Mode.ENVELOPE) rv_addr = reg.addr rv_enc_val = reg.encode(123) rvs = [ptcl.RegVal(rv_addr, rv_enc_val)] buffer = bytearray(b'\x12\x34\x56') unp_stream_data = ptcl.StreamData(rvs, buffer) pkd_stream_data_segment = bytearray() pkd_stream_data_segment.append(ptcl.STREAM_BUFFER) pkd_stream_data_segment.extend(b"\x03\x00") pkd_stream_data_segment.extend(buffer) pkd_stream_data_segment.append(ptcl.STREAM_RESULT_INFO) pkd_stream_data_segment.extend(b"\x05\x00") pkd_stream_data_segment.append(rv_addr) pkd_stream_data_segment.extend(rv_enc_val) unpacked = ptcl.unpack_stream_data_segment(pkd_stream_data_segment) assert unpacked == unp_stream_data
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
def _read_reg(self, reg, mode=None): mode = self._mode if mode is None else mode reg = regmap.get_reg(reg, mode) enc_val = self._read_reg_raw(reg.addr) return reg.decode(enc_val)
def test_decode_enum(): reg = regmap.get_reg("mode_selection") envelope = reg.enum.ENVELOPE assert reg.decode(reg.encode(envelope)) == envelope
def test_decode_float(): reg = regmap.get_reg("range_start") assert reg.decode(reg.encode(0.123)) == pytest.approx(0.123)
def test_get_reg(): with pytest.raises(ValueError): regmap.get_reg("does-not-exist") assert regmap.get_reg("iq_sampling_mode").full_name == "iq_sampling_mode" assert regmap.get_reg("iq_sampling_mode", "iq").full_name == "iq_sampling_mode" assert regmap.get_reg("sampling_mode", "iq").full_name == "iq_sampling_mode" with pytest.raises(ValueError): regmap.get_reg("iq_sampling_mode", "sparse") with pytest.raises(ValueError): regmap.get_reg("sampling_mode") # ambiguous reg = regmap.get_reg("sp_start") with pytest.raises(ValueError): regmap.get_reg(reg.addr) # ambiguous assert regmap.get_reg(reg.addr, reg.modes[0]) == reg
def test_decode_uint(): reg = regmap.get_reg("downsampling_factor") assert reg.decode(reg.encode(1234)) == 1234
def _write_reg(self, reg, val, expect_response=True): reg = regmap.get_reg(reg, self._mode) enc_val = reg.encode(val) self._write_reg_raw(reg.addr, enc_val, expect_response)
def _read_reg(self, reg): reg = regmap.get_reg(reg, self._mode) enc_val = self._read_reg_raw(reg.addr) return reg.decode(enc_val)
def _write_reg(self, reg, val): reg = regmap.get_reg(reg, self._mode) enc_val = reg.encode(val) self._write_reg_raw(reg.addr, enc_val)
def test_decode_bool(): reg = regmap.get_reg("tx_disable") assert reg.decode(reg.encode(True)) is True
def read_reg(self, reg, do_log=True): reg = regmap.get_reg(reg, self.mode) enc_val = self.read_reg_raw(reg.addr, do_log=do_log) return reg.decode(enc_val)
def write_reg(self, reg, val, do_log=True): reg = regmap.get_reg(reg, self.mode) enc_val = reg.encode(val) self.write_reg_raw(reg.addr, enc_val, do_log=do_log)