def _read_header(self) -> None:
self._sr = self._read_sample_rate()
self._sensors = self._read_enabled_sensors()
self._channels = self.get_data_channels(self._sensors)
self._channel_dtypes = get_ch_dtypes(self._channels)
self._rtc_diff = self._read_rtc_clock_diff()
self._start_ts = self._read_start_time()
self._trial_config = self._read_trial_config()
self._exg_regs = self._read_exg_regs()
self._samples_per_block, self._block_size = self._calculate_block_size(
)
def test_get_ch_dtypes(self):
channels = [EChannelType.INTERNAL_ADC_13, EChannelType.GYRO_MPU9150_Y]
r = get_ch_dtypes(channels)
self.assertEqual(len(r), 2)
first, second = r
self.assertEqual(first.size, 2)
self.assertEqual(first.little_endian, True)
self.assertEqual(first.signed, False)
self.assertEqual(second.size, 2)
self.assertEqual(second.little_endian, False)
self.assertEqual(second.signed, True)
def test_parsing_w_sync(self):
fpath, _ = get_synced_bin_vs_consensys_pair_fpath()
with open(fpath, 'rb') as f:
reader = ShimmerBinaryReader(f)
exp_dr = 64
exp_sensors = [ESensorGroup.CH_A13]
exp_channels = [
EChannelType.TIMESTAMP, EChannelType.INTERNAL_ADC_13
]
exp_offsets = np.array([372, 362, 364, 351])
exp_sync_ts = np.array([3725366, 4071094, 4397558, 4724022])
exp_exg_reg1 = ExGRegister(
b'\x00\x80\x10\x00\x00\x00\x00\x00\x02\x01')
exp_exg_reg2 = ExGRegister(
b'\x00\x80\x10\x00\x00\x00\x00\x00\x02\x01')
sample_size = sum([dt.size for dt in get_ch_dtypes(exp_channels)])
samples_per_block = int((512 - 9) / sample_size)
block_size = samples_per_block * sample_size + 9
self.assertEqual(reader.has_global_clock, True)
self.assertEqual(reader.has_sync, True)
self.assertEqual(reader.is_sync_master, False)
self.assertEqual(reader.enabled_sensors, exp_sensors)
self.assertEqual(reader.enabled_channels, exp_channels)
self.assertEqual(reader.sample_rate, exp_dr)
self.assertEqual(reader.samples_per_block, samples_per_block)
self.assertEqual(reader.start_timestamp, 3085110)
self.assertEqual(reader.block_size, block_size)
self.assertEqual(reader.get_exg_reg(0), exp_exg_reg1)
self.assertEqual(reader.get_exg_reg(1), exp_exg_reg2)
self.assertEqual(reader.exg_reg1, exp_exg_reg1)
self.assertEqual(reader.exg_reg2, exp_exg_reg2)
samples, (off_index, sync_off) = reader.read_data()
ts = samples[EChannelType.TIMESTAMP]
np.testing.assert_equal(ts[off_index], exp_sync_ts)
np.testing.assert_equal(sync_off, exp_offsets)
# Sanity check on the timestamps: they should all be spaced equally apart with a stride that is equal
# to the sampling rate.
ts = samples[EChannelType.TIMESTAMP]
ts_diff = np.diff(ts)
correct_diff = np.sum(ts_diff == exp_dr)
self.assertTrue(correct_diff / len(ts_diff) > 0.98)
def test_parsing_wo_sync(self):
fpath = get_binary_sample_fpath()
with open(fpath, 'rb') as f:
reader = ShimmerBinaryReader(f)
exp_dr = 65
exp_sensors = [
ESensorGroup.ACCEL_LN, ESensorGroup.BATTERY,
ESensorGroup.CH_A13
]
exp_channels = [
EChannelType.TIMESTAMP, EChannelType.ACCEL_LN_X,
EChannelType.ACCEL_LN_Y, EChannelType.ACCEL_LN_Z,
EChannelType.VBATT, EChannelType.INTERNAL_ADC_13
]
sample_size = sum([dt.size for dt in get_ch_dtypes(exp_channels)])
samples_per_block = int(512 / sample_size)
block_size = samples_per_block * sample_size
self.assertEqual(reader.enabled_sensors, exp_sensors)
self.assertEqual(reader.enabled_channels, exp_channels)
self.assertEqual(reader.sample_rate, exp_dr)
self.assertEqual(reader.has_global_clock, True)
self.assertEqual(reader.has_sync, False)
self.assertEqual(reader.is_sync_master, False)
self.assertEqual(reader.samples_per_block, samples_per_block)
self.assertEqual(reader.start_timestamp, 31291951)
self.assertEqual(reader.block_size, block_size)
self.assertEqual(reader.exg_reg1.binary,
b'\x00\x80\x10\x00\x00\x00\x00\x00\x02\x01')
self.assertEqual(reader.exg_reg2.binary,
b'\x00\x80\x10\x00\x00\x00\x00\x00\x02\x01')
data, _ = reader.read_data()
ts = data[EChannelType.TIMESTAMP]
# Sanity check on the timestamps: they should all be spaced equally apart with a stride that is equal
# to the sampling rate.
ts_diff = np.diff(ts)
correct_diff = np.sum(ts_diff == exp_dr)
self.assertTrue(correct_diff / len(ts_diff) > 0.98)
