use crate::client::{
AccumulatedCharge, AccumulatedEnergy, AccumulatedTime, AccumulatorClock, AdcConfiguration, BatteryVoltage, Channel,
ChargeAccumulator, Client, CurGpioControlRegister, CurrentSenseVoltage, DcmdId, DieTemperature, EnergyAccumulator,
Error as ClientError, FastControlRegister, FifoTag, GpioControlRegister, GpioCtrl, MuxGainSlot, MuxInput,
NtcConfig, OpsControlRegister, OverCurrentConfig, PositiveRatio, PowerOrVoltage, Quantize, ShuntGainCorrection,
ShuntTcConfig, Signed16Thresholds, SlotValue, SupplyVoltage, Threshold, ThresholdConversionError, ThresholdPair,
TimeBase, LTC2949, T_BOOT_US, T_MLCK_US, T_READY_US,
};
use crate::float24::Float24;
use crate::mocks::{BusError, MockSPIDevice};
use crate::pec15::PEC15;
use alloc::vec;
use alloc::vec::Vec;
use embedded_hal::spi::Operation;
const REGSCTRL_PAGE0: u8 = 0x80;
const REGSCTRL_PAGE1: u8 = 0x81;
const REGSCTRL_PAGE0_LOCK: u8 = 0x90;
fn assert_f32_approx_eq(actual: f32, expected: f32) {
const ABSOLUTE_TOLERANCE: f32 = 1e-15;
const RELATIVE_TOLERANCE: f32 = 1e-6;
let difference = (actual - expected).abs();
let tolerance = ABSOLUTE_TOLERANCE.max(expected.abs() * RELATIVE_TOLERANCE);
assert!(
difference <= tolerance,
"expected {expected}, got {actual}; difference {difference} exceeds tolerance {tolerance}"
);
}
fn assert_f64_approx_eq(actual: f64, expected: f64) {
const ABSOLUTE_TOLERANCE: f64 = 1e-15;
const RELATIVE_TOLERANCE: f64 = 1e-12;
let difference = (actual - expected).abs();
let tolerance = ABSOLUTE_TOLERANCE.max(expected.abs() * RELATIVE_TOLERANCE);
assert!(
difference <= tolerance,
"expected {expected}, got {actual}; difference {difference} exceeds tolerance {tolerance}"
);
}
fn dcmd_write_bytes(addr: u8, data: &[u8]) -> Vec<u8> {
assert!((1..=16).contains(&data.len()));
let mut v = Vec::with_capacity(7 + data.len());
v.push(0xFE);
v.push(addr);
let header_pec = PEC15::calc(&[0xFE, addr]);
v.push(header_pec[0]);
v.push(header_pec[1]);
v.push(make_id(false, (data.len() - 1) as u8));
v.extend_from_slice(data);
let data_pec = PEC15::calc(data);
v.push(data_pec[0]);
v.push(data_pec[1]);
v
}
fn f24(value: f32) -> [u8; 3] {
Float24::new(value).encode()
}
fn f24_high(value: f32) -> [u8; 2] {
Float24::new(value).encode_high()
}
fn dcmd_read_frames(addr: u8, data: &[u8]) -> (Vec<u8>, Vec<u8>) {
assert!((1..=16).contains(&data.len()));
let n = data.len();
let total = 5 + n + 2;
let mut tx = vec![0xFFu8; total];
tx[0] = 0xFE;
tx[1] = addr;
let hpec = PEC15::calc(&[0xFE, addr]);
tx[2] = hpec[0];
tx[3] = hpec[1];
tx[4] = make_id(true, (n - 1) as u8);
let mut rx = vec![0u8; total];
rx[5..5 + n].copy_from_slice(data);
let dpec = PEC15::calc(data);
rx[5 + n] = dpec[0];
rx[6 + n] = dpec[1];
(tx, rx)
}
fn cmd16_bytes(cmd: u16) -> [u8; 4] {
let mut f = [(cmd >> 8) as u8, cmd as u8, 0, 0];
let pec = PEC15::calc(&f[..2]);
f[2] = pec[0];
f[3] = pec[1];
f
}
fn expect_write(mock: &mut MockSPIDevice, expected: Vec<u8>) {
mock.expect_transaction().times(1).returning(move |ops| {
assert_eq!(1, ops.len(), "expected a single Operation in the transaction");
match &ops[0] {
Operation::Write(bytes) => {
assert_eq!(expected.as_slice(), *bytes, "unexpected MOSI bytes on Write");
}
other => panic!("expected Operation::Write, got {:?}", other),
}
Ok(())
});
}
fn expect_transfer(mock: &mut MockSPIDevice, expected_tx: Vec<u8>, rx_payload: Vec<u8>) {
assert_eq!(
expected_tx.len(),
rx_payload.len(),
"test setup: TX and RX must match length"
);
mock.expect_transaction().times(1).returning(move |ops| {
assert_eq!(1, ops.len(), "expected a single Operation in the transaction");
match &mut ops[0] {
Operation::Transfer(rx, tx) => {
assert_eq!(expected_tx.as_slice(), *tx, "unexpected MOSI bytes on Transfer");
assert_eq!(expected_tx.len(), rx.len());
rx.copy_from_slice(&rx_payload);
}
other => panic!("expected Operation::Transfer, got {:?}", other),
}
Ok(())
});
}
fn expect_dcmd_read(mock: &mut MockSPIDevice, addr: u8, data: &[u8]) {
let (tx, rx) = dcmd_read_frames(addr, data);
expect_transfer(mock, tx, rx);
}
fn expect_select_page(mock: &mut MockSPIDevice, page1: bool) {
let byte = if page1 { REGSCTRL_PAGE1 } else { REGSCTRL_PAGE0 };
expect_write(mock, dcmd_write_bytes(0xFF, &[byte]));
}
fn make_id(read: bool, pecc: u8) -> u8 {
let pecc = pecc & 0x0F;
let p3 = (pecc >> 3) & 1;
let p2 = (pecc >> 2) & 1;
let p1 = (pecc >> 1) & 1;
let p0 = pecc & 1;
let rw = u8::from(read);
let not_rw = rw ^ 1;
let bit5 = p3 ^ p2;
let bit2 = p1 ^ p0;
(rw << 7) | (not_rw << 6) | (bit5 << 5) | (p3 << 4) | (p2 << 3) | (bit2 << 2) | (p1 << 1) | p0
}
#[test]
fn id_byte_read_pecc15_is_0x9b() {
assert_eq!(0x9B, make_id(true, 15));
}
#[test]
fn id_byte_write_pecc15_is_0x5b() {
assert_eq!(0x5B, make_id(false, 15));
}
#[test]
fn id_byte_write_pecc1_matches_datasheet_example() {
assert_eq!(0x45, make_id(false, 1));
}
#[test]
fn trigger_adcv_broadcast_emits_0x0260_with_pec() {
let mut mock = MockSPIDevice::new();
expect_write(&mut mock, cmd16_bytes(0x0260).to_vec());
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.trigger_adcv_broadcast().unwrap();
}
#[test]
fn trigger_adax_broadcast_emits_0x0460_with_pec() {
let mut mock = MockSPIDevice::new();
expect_write(&mut mock, cmd16_bytes(0x0460).to_vec());
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.trigger_adax().unwrap();
}
#[test]
fn trigger_adax_propagates_bus_error() {
let mut mock = MockSPIDevice::new();
mock.expect_transaction().times(1).returning(|ops| {
assert_eq!(1, ops.len());
match &ops[0] {
Operation::Write(bytes) => assert_eq!(cmd16_bytes(0x0460).as_slice(), *bytes),
other => panic!("expected Operation::Write, got {:?}", other),
}
Err(BusError::Error1)
});
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.trigger_adax(),
Err(ClientError::BusError(BusError::Error1))
));
}
#[test]
fn wake_up_writes_two_dummy_bytes_then_selects_page_then_clears_wkupack() {
let mut mock = MockSPIDevice::new();
expect_write(&mut mock, vec![0x00]);
expect_write(&mut mock, vec![0x00]);
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0x70, &[0x00]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert_eq!(client.start_wake_up().unwrap(), T_BOOT_US);
client.confirm_wake_up().unwrap();
}
#[test]
fn wake_isospi_emits_single_dummy_byte() {
let mut mock = MockSPIDevice::new();
expect_write(&mut mock, vec![0x00]);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert_eq!(client.wake_isospi().unwrap(), T_READY_US);
}
#[test]
fn wake_up_invalidates_page_cache() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xDF, &[0x00]));
expect_write(&mut mock, vec![0x00]);
expect_write(&mut mock, vec![0x00]);
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0x70, &[0x00]));
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xDF, &[0x00]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_adcconf(AdcConfiguration::default()).unwrap();
client.start_wake_up().unwrap();
client.confirm_wake_up().unwrap();
client.write_adcconf(AdcConfiguration::default()).unwrap();
}
#[test]
fn read_faults_and_extfaults_read_correct_addresses() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xDD, &[0x42]); expect_dcmd_read(&mut mock, 0xDC, &[0x99]);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let faults = client.read_faults().unwrap();
assert!(faults.tsd());
assert!(faults.crccfg());
assert!(!faults.promerr());
assert!(!faults.crcmem());
let extfaults = client.read_extfaults().unwrap();
assert!(extfaults.hd1biterr());
assert!(extfaults.fcaerr());
assert!(extfaults.xramerr());
assert!(extfaults.hwmbistexec());
assert!(!extfaults.romerr());
assert!(!extfaults.memerr());
assert!(!extfaults.iramerr());
}
#[test]
fn read_accumulators1_decodes_row_in_one_coherent_burst() {
let row = [
0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x0A, ];
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x00, &row);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let acc = client.read_accumulators1().unwrap();
assert_eq!(5, acc.charge.raw());
assert_eq!(-1, acc.energy.raw());
assert_eq!(10, acc.time.raw());
}
#[test]
fn read_accumulators2_reads_from_row_0x10() {
let row = [0u8; 16];
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x10, &row);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let acc = client.read_accumulators2().unwrap();
assert_eq!(0, acc.charge.raw());
assert_eq!(0, acc.energy.raw());
assert_eq!(0, acc.time.raw());
}
#[test]
fn memory_lock_request_read_unlock_sequence() {
let mut mock = MockSPIDevice::new();
expect_write(&mut mock, dcmd_write_bytes(0xFF, &[REGSCTRL_PAGE0_LOCK]));
expect_dcmd_read(&mut mock, 0x00, &[0, 0, 0, 0, 0, 1]);
expect_write(&mut mock, dcmd_write_bytes(0xFF, &[REGSCTRL_PAGE0]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert_eq!(client.request_memory_lock().unwrap(), T_MLCK_US);
let charge = client.read_charge1().unwrap();
client.unlock_memory().unwrap();
assert_eq!(charge.raw(), 1);
}
#[test]
fn write_opctrl_cont_emits_dcmd_with_bit3_set() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF0, &[0x08]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_opctrl(OpsControlRegister::default().with_cont(true)).unwrap();
}
#[test]
fn write_opctrl_sleep_and_rst_emits_correct_byte() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF0, &[0x81]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_opctrl(OpsControlRegister::default().with_sleep(true).with_rst(true))
.unwrap();
}
#[test]
fn write_factrl_enables_fast_channels_1_and_2() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF5, &[0x0C]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_factrl(FastControlRegister::default().with_fach1(true).with_fach2(true))
.unwrap();
}
#[test]
fn write_fast_aux_mux_writes_muxn_then_muxp_in_one_burst() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF3, &[0x0F, 0x10]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_fast_aux_mux(MuxInput::VbatM as u8, MuxInput::VbatP as u8).unwrap();
}
#[test]
fn write_fast_aux_mux_propagates_bus_error() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
let expected = dcmd_write_bytes(0xF3, &[0x00, 0x01]);
mock.expect_transaction().times(1).returning(move |ops| {
assert_eq!(1, ops.len());
match &ops[0] {
Operation::Write(bytes) => assert_eq!(expected.as_slice(), *bytes),
other => panic!("expected Operation::Write, got {:?}", other),
}
Err(BusError::Error1)
});
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.write_fast_aux_mux(MuxInput::Agnd as u8, MuxInput::V1 as u8),
Err(ClientError::BusError(BusError::Error1))
));
}
#[test]
fn write_gpio_ctrl_emits_dcmd_to_fgpioctrl() {
let config = GpioControlRegister::new()
.with_gpio1_ctrl(GpioCtrl::High)
.with_gpio2_ctrl(GpioCtrl::Low)
.with_gpio3_ctrl(GpioCtrl::Toggle400kHz)
.with_gpio4_ctrl(GpioCtrl::Tristate);
assert_eq!([0b00_10_01_11], config.into_bytes());
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF2, &[0b00_10_01_11]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_gpio_ctrl(config).unwrap();
}
#[test]
fn write_gpio5_config_emits_dcmd_to_fcurgpioctrl() {
let config = CurGpioControlRegister::new()
.with_gpio5_ctrl(GpioCtrl::Toggle400kHz)
.with_mux_p_cur_pol(true)
.with_mux_p_cur_en(false)
.with_mux_n_cur_pol(false)
.with_mux_n_cur_en(true);
assert_eq!([0b10_01_00_10], config.into_bytes());
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF1, &[0b10_01_00_10]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_gpio5_config(config).unwrap();
}
#[test]
fn write_gpio5_config_propagates_bus_error() {
let config = CurGpioControlRegister::new().with_gpio5_ctrl(GpioCtrl::High);
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
let expected = dcmd_write_bytes(0xF1, &[0x03]);
mock.expect_transaction().times(1).returning(move |ops| {
assert_eq!(1, ops.len());
match &ops[0] {
Operation::Write(bytes) => assert_eq!(expected.as_slice(), *bytes),
other => panic!("expected Operation::Write, got {:?}", other),
}
Err(BusError::Error1)
});
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.write_gpio5_config(config),
Err(ClientError::BusError(BusError::Error1))
));
}
#[test]
fn write_gpio_controls_encodes_gpio5_and_current_sources_in_one_burst() {
let gpio5_and_current = CurGpioControlRegister::new()
.with_gpio5_ctrl(GpioCtrl::Toggle400kHz)
.with_mux_p_cur_pol(true)
.with_mux_p_cur_en(true)
.with_mux_n_cur_pol(false)
.with_mux_n_cur_en(true);
assert_eq!([0b10_11_00_10], gpio5_and_current.into_bytes());
let gpio1_to_4 = GpioControlRegister::new()
.with_gpio1_ctrl(GpioCtrl::Low)
.with_gpio2_ctrl(GpioCtrl::High)
.with_gpio3_ctrl(GpioCtrl::Tristate)
.with_gpio4_ctrl(GpioCtrl::Toggle400kHz);
assert_eq!([0b10_00_11_01], gpio1_to_4.into_bytes());
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF1, &[0b10_11_00_10, 0b10_00_11_01]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_gpio_controls(gpio5_and_current, gpio1_to_4).unwrap();
}
#[test]
fn write_gpio4_hb_success() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xE8, &[0x01]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_gpio4_hb(true).unwrap();
}
#[test]
fn write_gpio4_hb_propagates_bus_error() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
let expected = dcmd_write_bytes(0xE8, &[0x01]);
mock.expect_transaction().times(1).returning(move |ops| {
assert_eq!(1, ops.len());
match &ops[0] {
Operation::Write(bytes) => assert_eq!(expected.as_slice(), *bytes),
other => panic!("expected Operation::Write, got {:?}", other),
}
Err(BusError::Error1)
});
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.write_gpio4_hb(true),
Err(ClientError::BusError(BusError::Error1))
));
}
#[test]
fn write_occ_config_packs_fields_and_writes_both_channels() {
let config1 = OverCurrentConfig {
enable: true,
threshold: 0b011,
deglitch_time: 0b10,
polarity: 0b1,
};
let config2 = OverCurrentConfig {
enable: false,
threshold: 0b001,
deglitch_time: 0b01,
polarity: 0b0,
};
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xDE, &[0x67]));
expect_write(&mut mock, dcmd_write_bytes(0xDF, &[0x12]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_occ_config(config1, config2).unwrap();
}
#[test]
fn write_adcconf_uses_page1_and_writes_to_0xdf() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xDF, &[0x08]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_adcconf(AdcConfiguration::default().with_ntc1(true)).unwrap();
}
#[test]
fn write_non_accumulated_thresholds_convert_si_units_and_target_table67_addresses() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0x80, &[0x00, 0x14, 0xFF, 0xF6]));
expect_write(&mut mock, dcmd_write_bytes(0x8C, &[0x00, 0x28, 0xFF, 0xE2]));
expect_write(&mut mock, dcmd_write_bytes(0x84, &[0x00, 0x3C, 0xFF, 0xCE]));
expect_write(&mut mock, dcmd_write_bytes(0x90, &[0x00, 0x50, 0xFF, 0xBA]));
expect_write(&mut mock, dcmd_write_bytes(0x94, &[0x05, 0xDC, 0x00, 0x00]));
expect_write(&mut mock, dcmd_write_bytes(0x98, &[0x00, 0xC8, 0x00, 0x64]));
expect_write(&mut mock, dcmd_write_bytes(0xA0, &[0x00, 0x64, 0xFF, 0xA6]));
expect_write(&mut mock, dcmd_write_bytes(0xA4, &[0x00, 0x78, 0xFF, 0x92]));
let shunt = 1e-3_f32;
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_current_thresholds(
Channel::One,
ThresholdPair::new(
-10.0 * CurrentSenseVoltage::THRESHOLD_LSB_VOLTS / shunt,
20.0 * CurrentSenseVoltage::THRESHOLD_LSB_VOLTS / shunt,
),
shunt,
)
.unwrap();
client
.write_power_thresholds(
Channel::Two,
ThresholdPair::new(
-30.0 * PowerOrVoltage::POWER_THRESHOLD_LSB_VOLT_SQUARED / shunt,
40.0 * PowerOrVoltage::POWER_THRESHOLD_LSB_VOLT_SQUARED / shunt,
),
shunt,
)
.unwrap();
client
.write_power_as_voltage_thresholds(
Channel::One,
ThresholdPair::new(
-50.0 * PowerOrVoltage::VOLTAGE_THRESHOLD_LSB_VOLTS,
60.0 * PowerOrVoltage::VOLTAGE_THRESHOLD_LSB_VOLTS,
),
)
.unwrap();
client
.write_battery_thresholds(ThresholdPair::new(
-70.0 * BatteryVoltage::LSB_VOLTS,
80.0 * BatteryVoltage::LSB_VOLTS,
))
.unwrap();
client
.write_temperature_thresholds(ThresholdPair::new(
-DieTemperature::ZERO_CELSIUS_KELVIN,
1500.0 * DieTemperature::LSB_KELVIN - DieTemperature::ZERO_CELSIUS_KELVIN,
))
.unwrap();
client
.write_vcc_thresholds(ThresholdPair::new(
100.0 * SupplyVoltage::LSB_VOLTS,
200.0 * SupplyVoltage::LSB_VOLTS,
))
.unwrap();
client
.write_slot_voltage_thresholds(
Channel::One,
ThresholdPair::new(-90.0 * SlotValue::LSB_VOLTS, 100.0 * SlotValue::LSB_VOLTS),
)
.unwrap();
client
.write_slot_temperature_thresholds(
Channel::Two,
ThresholdPair::new(
-110.0 * SlotValue::LSB_DEGREES_CELSIUS,
120.0 * SlotValue::LSB_DEGREES_CELSIUS,
),
)
.unwrap();
}
#[test]
fn half_amp_current_threshold_uses_3_8uv_lsb() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0x80, &[0x00, 0x0D, 0x00, 0x00]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_current_thresholds(Channel::One, ThresholdPair::new(0.0, 0.5), 100e-6)
.unwrap();
}
#[test]
fn write_accumulator_thresholds_cover_all_table67_accumulators() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(
&mut mock,
dcmd_write_bytes(0x00, &[0, 0, 0, 0, 0, 3, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE]),
);
expect_write(
&mut mock,
dcmd_write_bytes(0x20, &[0, 0, 0, 0, 0, 5, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC]),
);
expect_write(&mut mock, dcmd_write_bytes(0x44, &7_i64.to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x54, &(-6_i64).to_be_bytes()));
expect_write(
&mut mock,
dcmd_write_bytes(0x10, &[0, 0, 0, 0, 0, 9, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8]),
);
expect_write(
&mut mock,
dcmd_write_bytes(0x30, &[0, 0, 0, 0, 0, 11, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF6]),
);
expect_write(&mut mock, dcmd_write_bytes(0x64, &13_i64.to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x74, &(-12_i64).to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x0C, &14_u32.to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x2C, &15_u32.to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x4C, &16_u32.to_be_bytes()));
expect_write(&mut mock, dcmd_write_bytes(0x6C, &17_u32.to_be_bytes()));
let shunt = 1e-3_f64;
let charge_lsb = AccumulatedCharge::LSB_VOLT_SECONDS / shunt;
let energy_lsb = AccumulatedEnergy::LSB_VOLT_SQUARED_SECONDS / shunt;
let time_lsb = AccumulatedTime::LSB_SECONDS;
let mut client: LTC2949<_, _> = LTC2949::new(mock);
for (accumulator, low, high) in [
(ChargeAccumulator::Charge1, -2.0, 3.0),
(ChargeAccumulator::Charge2, -4.0, 5.0),
(ChargeAccumulator::Charge3, -6.0, 7.0),
] {
client
.write_charge_thresholds(
accumulator,
ThresholdPair::new(low * charge_lsb, high * charge_lsb),
shunt,
AccumulatorClock::Internal,
)
.unwrap();
}
for (accumulator, low, high) in [
(EnergyAccumulator::Energy1, -8.0, 9.0),
(EnergyAccumulator::Energy2, -10.0, 11.0),
(EnergyAccumulator::Energy4, -12.0, 13.0),
] {
client
.write_energy_thresholds(
accumulator,
ThresholdPair::new(low * energy_lsb, high * energy_lsb),
shunt,
AccumulatorClock::Internal,
)
.unwrap();
}
for (time_base, raw) in [
(TimeBase::Time1, 14.0),
(TimeBase::Time2, 15.0),
(TimeBase::Time3, 16.0),
(TimeBase::Time4, 17.0),
] {
client
.write_time_threshold(time_base, Threshold::new(raw * time_lsb), AccumulatorClock::Internal)
.unwrap();
}
}
#[test]
fn external_clock_threshold_scaling_uses_table27_formula() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0x0C, &10_u32.to_be_bytes()));
let clock = AccumulatorClock::External {
frequency_hz: 10e6,
pre: 4,
div: 19,
};
let time_lsb = 12.8315 / 10e6 * 16.0 * 20.0;
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_time_threshold(TimeBase::Time1, Threshold::new(10.0 * time_lsb), clock)
.unwrap();
}
#[test]
fn invalid_threshold_is_rejected_before_bus_access() {
let mock = MockSPIDevice::new();
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.write_battery_thresholds(ThresholdPair::new(2.0, 1.0)),
Err(ClientError::InvalidThreshold)
));
assert!(matches!(
client.write_current_thresholds(Channel::One, ThresholdPair::new(-1.0, 1.0), 0.0),
Err(ClientError::InvalidThreshold)
));
assert!(matches!(
client.write_time_threshold(TimeBase::Time1, Threshold::new(f64::NAN), AccumulatorClock::Internal),
Err(ClientError::InvalidThreshold)
));
}
#[test]
fn threshold_pair_quantization_reports_conversion_errors() {
let encoded: Signed16Thresholds = ThresholdPair::new(-1.5_f64, 2.5).quantize(1.0).unwrap();
assert_eq!(-2, encoded.low());
assert_eq!(3, encoded.high());
assert_eq!([0x00, 0x03, 0xFF, 0xFE], encoded.to_be_bytes());
assert_eq!(
Err(ThresholdConversionError::LowAboveHigh),
Quantize::<Signed16Thresholds>::quantize(ThresholdPair::new(2.0_f64, 1.0), 1.0)
);
assert_eq!(
Err(ThresholdConversionError::InvalidScale),
Quantize::<Signed16Thresholds>::quantize(ThresholdPair::new(0.0_f64, 1.0), 0.0)
);
assert_eq!(
Err(ThresholdConversionError::OutOfRange),
Quantize::<Signed16Thresholds>::quantize(ThresholdPair::new(0.0_f64, 40_000.0), 1.0)
);
}
#[test]
fn write_gain_corrections_match_table72_addresses_and_examples() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xB0, &[0x3E, 0xF5, 0xF5])); expect_write(&mut mock, dcmd_write_bytes(0xB3, &[0x3F, 0x06, 0x24])); expect_write(&mut mock, dcmd_write_bytes(0xB6, &[0x38, 0x47, 0xAE])); expect_write(&mut mock, dcmd_write_bytes(0xB9, &[0x3E, 0xE6, 0x66]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let calibrated_shunt = ShuntGainCorrection::from_resistances(100e-6, 102e-6);
assert_f32_approx_eq(calibrated_shunt.correction_factor(), 100.0 / 102.0);
client.write_shunt_gain_correction(Channel::One, calibrated_shunt).unwrap();
client
.write_shunt_gain_correction(Channel::Two, ShuntGainCorrection::from_correction_factor(1.024))
.unwrap();
client.write_shunt_ratio(100e-6, 10e-3).unwrap();
client.write_battery_gain_correction(0.95).unwrap();
}
#[test]
fn positive_ratio_validates_and_stores_the_ratio() {
let ratio = PositiveRatio::try_from_parts(100e-6, 10e-3).unwrap();
assert_f32_approx_eq(ratio.value(), 100e-6 / 10e-3);
assert_eq!(
Err(crate::client::PositiveRatioError::NonPositiveOrNonFinite),
PositiveRatio::try_from_ratio(0.0)
);
assert_eq!(
Err(crate::client::PositiveRatioError::NonPositiveOrNonFinite),
PositiveRatio::try_from_parts(-1.0, 2.0)
);
}
#[test]
fn write_mux_gain_corrections_write_float24_factor_and_input_pair() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xC0, &[0x3E, 0xCC, 0xCC]));
expect_write(&mut mock, dcmd_write_bytes(0xBC, &[0x02, 0x01]));
expect_write(&mut mock, dcmd_write_bytes(0xC3, &f24(1.0)));
expect_write(&mut mock, dcmd_write_bytes(0xBE, &[0x0F, 0x10]));
expect_write(&mut mock, dcmd_write_bytes(0xC6, &f24(1.01)));
expect_write(&mut mock, dcmd_write_bytes(0xCC, &[0x11, 0x12]));
expect_write(&mut mock, dcmd_write_bytes(0xC9, &f24(0.99)));
expect_write(&mut mock, dcmd_write_bytes(0xCE, &[0x13, 0x14]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client
.write_mux_gain_correction(MuxGainSlot::One, 0.9, MuxInput::V2, MuxInput::V1)
.unwrap();
client
.write_mux_gain_correction(MuxGainSlot::Two, 1.0, MuxInput::VbatM, MuxInput::VbatP)
.unwrap();
client
.write_mux_gain_correction(MuxGainSlot::Three, 1.01, MuxInput::Cf2M, MuxInput::Cf2P)
.unwrap();
client
.write_mux_gain_correction(MuxGainSlot::Four, 0.99, MuxInput::Cf1M, MuxInput::Cf1P)
.unwrap();
}
#[test]
fn invalid_gain_correction_is_rejected_before_bus_access() {
let mock = MockSPIDevice::new();
let mut client: LTC2949<_, _> = LTC2949::new(mock);
assert!(matches!(
client.write_shunt_gain_correction(Channel::One, ShuntGainCorrection::from_correction_factor(f32::NAN)),
Err(ClientError::InvalidGainCorrection)
));
assert!(matches!(
client.write_shunt_gain_correction(Channel::One, ShuntGainCorrection::from_resistances(100e-6, 0.0)),
Err(ClientError::InvalidGainCorrection)
));
assert!(matches!(
client.write_shunt_gain_correction(Channel::One, ShuntGainCorrection::from_resistances(-100e-6, -102e-6)),
Err(ClientError::InvalidGainCorrection)
));
assert!(matches!(
client.write_shunt_ratio(-100e-6, 10e-3),
Err(ClientError::InvalidGainCorrection)
));
assert!(matches!(
client.write_mux_gain_correction(MuxGainSlot::One, 0.0, MuxInput::V2, MuxInput::V1),
Err(ClientError::InvalidGainCorrection)
));
}
#[test]
fn write_opctrl_then_write_factrl_only_selects_page_once() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xF0, &[0x08])); expect_write(&mut mock, dcmd_write_bytes(0xF5, &[0x01]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_opctrl(OpsControlRegister::default().with_cont(true)).unwrap();
client.write_factrl(FastControlRegister::default().with_faconv(true)).unwrap();
}
#[test]
fn read_uses_dcmd_read_frame_with_read_id() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
let (tx, rx) = dcmd_read_frames(0x80, &[0xA5]);
assert_eq!(0xFE, tx[0]);
assert_eq!(0x80, tx[1]);
assert_eq!(0x80, tx[4]); expect_transfer(&mut mock, tx, rx);
let mut client = LTC2949::new(mock);
let status = client.read_status().unwrap();
assert!(status.uvloa());
assert!(status.uvlostby());
assert!(status.adcerr());
assert!(!status.pora());
assert!(!status.uvlod());
}
#[test]
fn read_opctrl_decodes_bitfield() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xF0, &[0x28]);
let mut client = LTC2949::new(mock);
let value = client.read_opctrl().unwrap();
assert!(value.cont());
assert!(value.adjupd());
assert!(!value.sleep());
assert!(!value.rst());
}
#[test]
fn read_status_decodes_bitfield() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x80, &[0x7F]);
let mut client = LTC2949::new(mock);
let status = client.read_status().unwrap();
assert!(status.uvloa());
assert!(status.pora());
assert!(status.uvlostby());
assert!(status.uvlod());
assert!(status.update());
assert!(status.adcerr());
assert!(status.tberr());
}
#[test]
fn read_alert_registers_use_correct_addresses_and_decode_bitfields() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x81, &[0xA5]); expect_dcmd_read(&mut mock, 0x82, &[0x5A]); expect_dcmd_read(&mut mock, 0x83, &[0x2D]); expect_dcmd_read(&mut mock, 0x85, &[0xB5]); expect_dcmd_read(&mut mock, 0x86, &[0xC3]); expect_dcmd_read(&mut mock, 0x87, &[0x0A]);
let mut client = LTC2949::new(mock);
let vt = client.read_vt_alerts().unwrap();
assert!(vt.bath() && vt.temph() && vt.slot1l() && vt.slot2l());
assert!(!vt.batl() && !vt.templ() && !vt.slot1h() && !vt.slot2h());
let ip = client.read_ip_alerts().unwrap();
assert!(ip.i1l() && ip.p1l() && ip.i2h() && ip.p2h());
assert!(!ip.i1h() && !ip.p1h() && !ip.i2l() && !ip.p2l());
let charge = client.read_c_alerts().unwrap();
assert!(charge.c1h() && charge.c2h() && charge.c2l() && charge.c3l());
assert!(!charge.c1l() && !charge.c3h());
let ceof = client.read_ceof_alerts().unwrap();
assert!(ceof.c1ovf() && ceof.c3ovf() && ceof.e1ovf() && ceof.e2ovf() && ceof.e4ovf());
assert!(!ceof.c2ovf());
let tb = client.read_tb_alerts().unwrap();
assert!(tb.t1th() && tb.t2th() && tb.t3ovf() && tb.t4ovf());
assert!(!tb.t3th() && !tb.t4th() && !tb.t1ovf() && !tb.t2ovf());
let vcc = client.read_vcc_alerts().unwrap();
assert!(vcc.vccl() && vcc.occ2h());
assert!(!vcc.vcch() && !vcc.occ1h());
}
#[test]
fn read_current1_decodes_24bit_signed_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x90, &[0xFF, 0xFF, 0xFF]);
let mut client = LTC2949::new(mock);
let current = client.read_current1().unwrap();
assert_eq!(-1, current.raw());
assert_f32_approx_eq(current.decode(), -950e-9);
}
#[test]
fn read_current1_positive_value() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x90, &[0x00, 0x01, 0x23]);
let mut client = LTC2949::new(mock);
let current = client.read_current1().unwrap();
assert_eq!(0x000123, current.raw());
assert_f32_approx_eq(current.decode(), 0.00027645);
}
#[test]
fn read_current1_avg_reads_moving_average_register() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x9C, &[0x00, 0x04, 0x00]);
let mut client = LTC2949::new(mock);
let current = client.read_current1_avg().unwrap();
assert_eq!(0x000400, current.raw());
assert_f32_approx_eq(current.decode(), 0.0002432);
}
#[test]
fn read_current2_avg_decodes_24bit_signed_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xAC, &[0xFF, 0xFE, 0x00]);
let mut client = LTC2949::new(mock);
let current = client.read_current2_avg().unwrap();
assert_eq!(-512, current.raw());
assert_f32_approx_eq(current.decode(), -0.0001216);
}
#[test]
fn read_power1_decodes_power_or_voltage_value() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x93, &[0x00, 0x01, 0x00]);
let mut client = LTC2949::new(mock);
let result = client.read_power1().unwrap();
assert_eq!(0x000100, result.raw());
assert_f32_approx_eq(result.decode_voltage(), 0.012);
assert_f32_approx_eq(result.decode_power(0.0001), 0.000014942208);
}
#[test]
fn read_power2_decodes_24bit_signed_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x99, &[0xFF, 0xFF, 0xFF]);
let mut client = LTC2949::new(mock);
let result = client.read_power2().unwrap();
assert_eq!(-1, result.raw());
assert_f32_approx_eq(result.decode_voltage(), -46.875e-6);
assert_f32_approx_eq(result.decode_power(1.0), -5.8368e-12);
}
#[test]
fn read_bat_decodes_16bit_signed_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xA0, &[0x7F, 0xFF]);
let mut client = LTC2949::new(mock);
let bat = client.read_bat().unwrap();
assert_eq!(32767, bat.raw());
assert_f32_approx_eq(bat.decode(), 12.287625);
}
#[test]
fn read_temp_decodes_kelvin_and_celsius() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xA2, &[0x05, 0xD4]);
let mut client = LTC2949::new(mock);
let temp = client.read_temp().unwrap();
assert_eq!(1492, temp.raw());
assert_f32_approx_eq(temp.decode_kelvin(), 298.4);
assert_f32_approx_eq(temp.decode_celsius(), 25.25);
}
#[test]
fn read_vcc_decodes_supply_voltage() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xA4, &[0x03, 0xE8]);
let mut client = LTC2949::new(mock);
let vcc = client.read_vcc().unwrap();
assert_eq!(1000, vcc.raw());
assert_f32_approx_eq(vcc.decode(), 2.26);
}
#[test]
fn read_slot1_returns_typed_voltage_or_temperature() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xA6, &[0x00, 0x7D]);
let mut client = LTC2949::new(mock);
let slot = client.read_slot1().unwrap();
assert_eq!(125, slot.raw());
assert_f32_approx_eq(slot.decode_voltage(), 0.046875);
assert_f32_approx_eq(slot.decode_temperature(), 25.0);
}
#[test]
fn accumulated_result_types_decode_internal_clock_scaling() {
let charge = AccumulatedCharge::from_raw(1_000_000);
assert_eq!(1_000_000, charge.raw());
assert_f64_approx_eq(charge.decode(), 377.887e-6);
assert_f64_approx_eq(charge.decode_coulombs(100e-6), 3.77887);
let energy = AccumulatedEnergy::from_raw(1_000_000);
assert_eq!(1_000_000, energy.raw());
assert_f64_approx_eq(energy.decode(), 2.32175e-3);
assert_f64_approx_eq(energy.decode_joules(100e-6), 23.2175);
let time = AccumulatedTime::from_raw(1_000);
assert_eq!(1_000, time.raw());
assert_f64_approx_eq(time.decode(), 0.397777);
let slot = SlotValue::from_raw(-100);
assert_eq!(-100, slot.raw());
assert_f32_approx_eq(slot.decode_voltage(), -0.0375);
assert_f32_approx_eq(slot.decode_temperature(), -20.0);
}
#[test]
fn read_charge1_decodes_48bit_signed_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x00, &[0x00, 0x00, 0x00, 0x00, 0x00, 0x01]);
let mut client = LTC2949::new(mock);
assert_eq!(1, client.read_charge1().unwrap().raw());
}
#[test]
fn read_charge1_decodes_48bit_signed_negative() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x00, &[0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF]);
let mut client = LTC2949::new(mock);
assert_eq!(-1, client.read_charge1().unwrap().raw());
}
#[test]
fn read_charge3_decodes_64bit_signed() {
let payload = [0x12, 0x34, 0x56, 0x78, 0x9A, 0xBC, 0xDE, 0xF0];
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x24, &payload);
let mut client = LTC2949::new(mock);
let expected = i64::from_be_bytes(payload);
assert_eq!(expected, client.read_charge3().unwrap().raw());
}
#[test]
fn read_time1_decodes_32bit_unsigned_be() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0x0C, &[0xDE, 0xAD, 0xBE, 0xEF]);
let mut client = LTC2949::new(mock);
assert_eq!(0xDEAD_BEEF, client.read_time1().unwrap().raw());
}
#[test]
fn page1_write_then_page0_read_toggles_page_bit() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xDF, &[0x08])); expect_select_page(&mut mock, false); expect_dcmd_read(&mut mock, 0x80, &[0x00]);
let mut client = LTC2949::new(mock);
client.write_adcconf(AdcConfiguration::default().with_ntc1(true)).unwrap();
let _ = client.read_status().unwrap();
}
const NTCLE203E_EXAMPLE: NtcConfig = NtcConfig {
r_ref: 10_000.0,
a: 1.1382e-3,
b: 2.3267e-4,
c: 0.93243e-7,
};
#[test]
fn write_ntc1_coefficients_sends_rref_then_abc_burst() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xAA, &f24(10_000.0)));
let mut abc = vec![0u8; 9];
abc[0..3].copy_from_slice(&f24(1.1382e-3));
abc[3..6].copy_from_slice(&f24(2.3267e-4));
abc[6..9].copy_from_slice(&f24(0.93243e-7));
expect_write(&mut mock, dcmd_write_bytes(0xD0, &abc));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_ntc_coefficients(Channel::One, &NTCLE203E_EXAMPLE).unwrap();
}
#[test]
fn write_ntc2_coefficients_targets_distinct_addresses() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xAD, &f24(10_000.0)));
let mut abc = vec![0u8; 9];
abc[0..3].copy_from_slice(&f24(1.1382e-3));
abc[3..6].copy_from_slice(&f24(2.3267e-4));
abc[6..9].copy_from_slice(&f24(0.93243e-7));
expect_write(&mut mock, dcmd_write_bytes(0xE0, &abc));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_ntc_coefficients(Channel::Two, &NTCLE203E_EXAMPLE).unwrap();
}
#[test]
fn write_ntc1_then_ntc2_only_selects_page1_once() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
expect_write(&mut mock, dcmd_write_bytes(0xAA, &f24(10_000.0)));
let mut abc = vec![0u8; 9];
abc[0..3].copy_from_slice(&f24(1.1382e-3));
abc[3..6].copy_from_slice(&f24(2.3267e-4));
abc[6..9].copy_from_slice(&f24(0.93243e-7));
expect_write(&mut mock, dcmd_write_bytes(0xD0, &abc));
expect_write(&mut mock, dcmd_write_bytes(0xAD, &f24(10_000.0)));
expect_write(&mut mock, dcmd_write_bytes(0xE0, &abc));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_ntc_coefficients(Channel::One, &NTCLE203E_EXAMPLE).unwrap();
client.write_ntc_coefficients(Channel::Two, &NTCLE203E_EXAMPLE).unwrap();
}
const COPPER_SHUNT_25C: ShuntTcConfig = ShuntTcConfig {
tc: 0.0039,
t_ref: 20.0,
tc2: 0.0,
};
#[test]
fn write_shunt_tc_channel1_sends_burst_then_tc2() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
let mut burst = vec![0u8; 5];
burst[0..3].copy_from_slice(&f24(0.0039));
burst[3..5].copy_from_slice(&f24_high(20.0));
expect_write(&mut mock, dcmd_write_bytes(0xD9, &burst));
expect_write(&mut mock, dcmd_write_bytes(0x5C, &f24(0.0)));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_shunt_tc(Channel::One, &COPPER_SHUNT_25C).unwrap();
}
#[test]
fn write_shunt_tc_channel2_targets_distinct_addresses() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, true);
let mut burst = vec![0u8; 5];
burst[0..3].copy_from_slice(&f24(0.0039));
burst[3..5].copy_from_slice(&f24_high(20.0));
expect_write(&mut mock, dcmd_write_bytes(0xE9, &burst)); expect_write(&mut mock, dcmd_write_bytes(0x7C, &f24(0.0)));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_shunt_tc(Channel::Two, &COPPER_SHUNT_25C).unwrap();
}
#[test]
fn write_slot_mux_channel1_writes_two_byte_burst_at_0xeb() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xEB, &[0x00, 0x01]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_slot_mux(Channel::One, MuxInput::Agnd, MuxInput::V1).unwrap();
}
#[test]
fn write_slot_mux_channel2_writes_to_0xed() {
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_write(&mut mock, dcmd_write_bytes(0xED, &[15, 16]));
let mut client: LTC2949<_, _> = LTC2949::new(mock);
client.write_slot_mux(Channel::Two, MuxInput::VbatM, MuxInput::VbatP).unwrap();
}
#[test]
fn mux_input_discriminants_match_datasheet_table_57() {
assert_eq!(0, MuxInput::Agnd as u8);
assert_eq!(1, MuxInput::V1 as u8);
assert_eq!(12, MuxInput::V12 as u8);
assert_eq!(15, MuxInput::VbatM as u8);
assert_eq!(16, MuxInput::VbatP as u8);
assert_eq!(20, MuxInput::Cf1P as u8);
assert_eq!(22, MuxInput::Vref2 as u8);
assert_eq!(23, MuxInput::Vref2Via250k as u8);
}
fn fifo_sample_bytes(raw: i16, tag: u8) -> [u8; 3] {
let [msb, lsb] = raw.to_be_bytes();
[msb, lsb, tag]
}
#[test]
fn read_fifo_i1_drains_three_samples_in_one_burst() {
let mut data = Vec::new();
data.extend_from_slice(&fifo_sample_bytes(258, 0x00)); data.extend_from_slice(&fifo_sample_bytes(772, 0x00)); data.extend_from_slice(&fifo_sample_bytes(-1, 0x00));
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xF7, &data);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let samples = client.read_fifo_i1::<3>().unwrap();
assert_eq!(3, samples.len());
assert_eq!(258, samples[0].raw);
assert_eq!(772, samples[1].raw);
assert_eq!(-1, samples[2].raw);
assert!(samples.iter().all(|s| s.tag == FifoTag::Ok));
}
#[test]
fn read_fifo_stops_at_non_ok_terminator_within_a_burst() {
let mut data = Vec::new();
data.extend_from_slice(&fifo_sample_bytes(100, 0x00)); data.extend_from_slice(&fifo_sample_bytes(0, 0x55)); data.extend_from_slice(&fifo_sample_bytes(0, 0x00)); data.extend_from_slice(&fifo_sample_bytes(0, 0x00));
data.extend_from_slice(&fifo_sample_bytes(0, 0x00));
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xF7, &data);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let samples = client.read_fifo_i1::<5>().unwrap();
assert_eq!(2, samples.len());
assert_eq!(FifoTag::Ok, samples[0].tag);
assert_eq!(FifoTag::ReadOverrun, samples[1].tag);
}
#[test]
fn read_fifo_spans_two_bursts_for_more_than_five_samples() {
let first: Vec<u8> = (0..5).flat_map(|i| fifo_sample_bytes(i as i16, 0x00)).collect();
let second: Vec<u8> = (5..7).flat_map(|i| fifo_sample_bytes(i as i16, 0x00)).collect();
let mut mock = MockSPIDevice::new();
expect_select_page(&mut mock, false);
expect_dcmd_read(&mut mock, 0xF8, &first);
expect_dcmd_read(&mut mock, 0xF8, &second);
let mut client: LTC2949<_, _> = LTC2949::new(mock);
let samples = client.read_fifo_i2::<7>().unwrap();
assert_eq!(7, samples.len());
for (i, s) in samples.iter().enumerate() {
assert_eq!(i as i16, s.raw);
}
}
#[test]
fn dcmd_id_read_with_pecc15_encodes_0x9b() {
assert_eq!(0x9B, u8::from(DcmdId::read(15)));
}
#[test]
fn dcmd_id_write_with_pecc15_encodes_0x5b() {
assert_eq!(0x5B, u8::from(DcmdId::write(15)));
}
#[test]
fn dcmd_id_write_with_pecc1_matches_datasheet_example() {
assert_eq!(0x45, u8::from(DcmdId::write(1)));
}
#[test]
fn dcmd_id_pecc_is_limited_to_four_bits() {
assert_eq!(u8::from(DcmdId::read(0x0F)), u8::from(DcmdId::read(0xFF)));
}