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)
