|
|
use serde::Serialize;
|
|
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize)]
|
|
|
pub(crate) enum Telemetry {
|
|
|
HeartRate { bpm: u16 },
|
|
|
Cadence { rpm: f32 },
|
|
|
Power { watts: i16 },
|
|
|
Battery { percent: u8 },
|
|
|
}
|
|
|
|
|
|
/// Сырые данные CSC: кумулятивные счётчики шатуна.
|
|
|
#[derive(Debug, PartialEq, Eq)]
|
|
|
pub(crate) struct CscRaw {
|
|
|
pub crank_revs: u16,
|
|
|
pub crank_time: u16,
|
|
|
}
|
|
|
|
|
|
/// Heart Rate Measurement (0x2A37): флаг + значение (uint8 или uint16).
|
|
|
pub(crate) fn parse_hr(bytes: &[u8]) -> Option<Telemetry> {
|
|
|
let flags = *bytes.first()?;
|
|
|
if flags & 0x01 != 0 {
|
|
|
let bpm = u16::from_le_bytes([*bytes.get(1)?, *bytes.get(2)?]);
|
|
|
Some(Telemetry::HeartRate { bpm })
|
|
|
} else {
|
|
|
Some(Telemetry::HeartRate { bpm: *bytes.get(1)? as u16 })
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/// Cycling Power Measurement (0x2A63): мгновенная мощность sint16 (LE).
|
|
|
pub(crate) fn parse_power(bytes: &[u8]) -> Option<Telemetry> {
|
|
|
if bytes.len() < 4 {
|
|
|
return None;
|
|
|
}
|
|
|
let watts = i16::from_le_bytes([bytes[2], bytes[3]]);
|
|
|
Some(Telemetry::Power { watts })
|
|
|
}
|
|
|
|
|
|
/// Indoor Bike Data (0x2AD2): variable-length, fields driven by flags.
|
|
|
/// Extracts instantaneous cadence (bit 3) and instantaneous power (bit 5).
|
|
|
pub(crate) fn parse_indoor_bike_data(bytes: &[u8]) -> Vec<Telemetry> {
|
|
|
if bytes.len() < 2 {
|
|
|
return Vec::new();
|
|
|
}
|
|
|
let flags = u16::from_le_bytes([bytes[0], bytes[1]]);
|
|
|
let mut out = Vec::new();
|
|
|
|
|
|
// Byte offset of instantaneous cadence (after the 2-byte flags).
|
|
|
let cadence_off = 2
|
|
|
+ if flags & 0x0100 != 0 { 2 } else { 0 } // instantaneous speed
|
|
|
+ if flags & 0x0002 != 0 { 2 } else { 0 }; // average speed
|
|
|
|
|
|
// Byte offset of instantaneous power.
|
|
|
let power_off = cadence_off
|
|
|
+ if flags & 0x0008 != 0 { 2 } else { 0 } // instantaneous cadence
|
|
|
+ if flags & 0x0010 != 0 { 2 } else { 0 } // average cadence
|
|
|
+ if flags & 0x0004 != 0 { 3 } else { 0 } // total distance (uint24)
|
|
|
+ if flags & 0x0080 != 0 { 2 } else { 0 }; // resistance level
|
|
|
|
|
|
if flags & 0x0008 != 0 && cadence_off + 2 <= bytes.len() {
|
|
|
let raw = u16::from_le_bytes([bytes[cadence_off], bytes[cadence_off + 1]]);
|
|
|
out.push(Telemetry::Cadence { rpm: raw as f32 / 2.0 });
|
|
|
}
|
|
|
if flags & 0x0020 != 0 && power_off + 2 <= bytes.len() {
|
|
|
let raw = u16::from_le_bytes([bytes[power_off], bytes[power_off + 1]]);
|
|
|
out.push(Telemetry::Power { watts: raw as i16 });
|
|
|
}
|
|
|
|
|
|
out
|
|
|
}
|
|
|
|
|
|
/// Battery Level (0x2A19): один байт 0..=100.
|
|
|
pub(crate) fn parse_battery(bytes: &[u8]) -> Option<Telemetry> {
|
|
|
let percent = *bytes.first()?;
|
|
|
(percent <= 100).then_some(Telemetry::Battery { percent })
|
|
|
}
|
|
|
|
|
|
/// CSC Measurement (0x2A5B): извлекаем кумулятивные счётчики шатуна.
|
|
|
pub(crate) fn parse_csc(bytes: &[u8]) -> Option<CscRaw> {
|
|
|
let flags = *bytes.first()?;
|
|
|
if flags & 0x02 == 0 {
|
|
|
return None; // нет данных шатуна
|
|
|
}
|
|
|
let mut idx = 1;
|
|
|
if flags & 0x01 != 0 {
|
|
|
idx += 6; // пропускаем данные колеса (uint32 + uint16)
|
|
|
}
|
|
|
if bytes.len() < idx + 4 {
|
|
|
return None;
|
|
|
}
|
|
|
let crank_revs = u16::from_le_bytes([bytes[idx], bytes[idx + 1]]);
|
|
|
let crank_time = u16::from_le_bytes([bytes[idx + 2], bytes[idx + 3]]);
|
|
|
Some(CscRaw { crank_revs, crank_time })
|
|
|
}
|
|
|
|
|
|
/// Превращает кумулятивные счётчики CSC в обороты в минуту.
|
|
|
pub(crate) struct CscAccumulator {
|
|
|
last_revs: Option<u16>,
|
|
|
last_time: Option<u16>,
|
|
|
}
|
|
|
|
|
|
impl CscAccumulator {
|
|
|
pub(crate) fn new() -> Self {
|
|
|
Self { last_revs: None, last_time: None }
|
|
|
}
|
|
|
|
|
|
/// Возвращает rpm или None (нужно минимум два измерения).
|
|
|
pub(crate) fn push(&mut self, raw: CscRaw) -> Option<f32> {
|
|
|
let (Some(prev_revs), Some(prev_time)) = (self.last_revs, self.last_time) else {
|
|
|
self.last_revs = Some(raw.crank_revs);
|
|
|
self.last_time = Some(raw.crank_time);
|
|
|
return None;
|
|
|
};
|
|
|
self.last_revs = Some(raw.crank_revs);
|
|
|
self.last_time = Some(raw.crank_time);
|
|
|
|
|
|
let d_revs = raw.crank_revs.wrapping_sub(prev_revs) as f32;
|
|
|
let d_time = raw.crank_time.wrapping_sub(prev_time) as f32; // 1/1024 с
|
|
|
if d_time == 0.0 {
|
|
|
return None;
|
|
|
}
|
|
|
Some(d_revs * 60.0 * 1024.0 / d_time)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
#[cfg(test)]
|
|
|
mod tests {
|
|
|
use super::*;
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_hr_8bit() {
|
|
|
// flags=0x00 (8-бит), значение 120
|
|
|
assert_eq!(parse_hr(&[0x00, 0x78]), Some(Telemetry::HeartRate { bpm: 120 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_hr_16bit() {
|
|
|
// flags=0x01 (16-бит), значение 180 = 0x00B4
|
|
|
assert_eq!(parse_hr(&[0x01, 0xB4, 0x00]), Some(Telemetry::HeartRate { bpm: 180 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_hr_empty() {
|
|
|
assert_eq!(parse_hr(&[]), None);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_hr_missing_value() {
|
|
|
assert_eq!(parse_hr(&[0x00]), None); // 8-бит, но значения нет
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_power() {
|
|
|
// flags=0x0000, мощность 200 = 0x00C8 (LE)
|
|
|
assert_eq!(parse_power(&[0x00, 0x00, 0xC8, 0x00]), Some(Telemetry::Power { watts: 200 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_power_negative() {
|
|
|
// -200 = 0xFF38 (sint16 LE)
|
|
|
assert_eq!(parse_power(&[0x00, 0x00, 0x38, 0xFF]), Some(Telemetry::Power { watts: -200 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_power_too_short() {
|
|
|
assert_eq!(parse_power(&[0x00, 0x00, 0xC8]), None);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_indoor_bike_cadence_and_power() {
|
|
|
// flags: bit 3 (cadence) + bit 5 (power) = 0x0028
|
|
|
// cadence uint16 = 180 (0.5 rpm) => 90 rpm; power sint16 = 250 W
|
|
|
let bytes = [0x28, 0x00, 0xB4, 0x00, 0xFA, 0x00];
|
|
|
assert_eq!(
|
|
|
parse_indoor_bike_data(&bytes),
|
|
|
vec![
|
|
|
Telemetry::Cadence { rpm: 90.0 },
|
|
|
Telemetry::Power { watts: 250 },
|
|
|
]
|
|
|
);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_indoor_bike_too_short() {
|
|
|
assert!(parse_indoor_bike_data(&[0x28]).is_empty());
|
|
|
assert!(parse_indoor_bike_data(&[]).is_empty());
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_battery() {
|
|
|
assert_eq!(parse_battery(&[100]), Some(Telemetry::Battery { percent: 100 }));
|
|
|
assert_eq!(parse_battery(&[0]), Some(Telemetry::Battery { percent: 0 }));
|
|
|
assert_eq!(parse_battery(&[101]), None); // вне диапазона
|
|
|
assert_eq!(parse_battery(&[]), None);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_csc_crank_only() {
|
|
|
// flags=0x02 (только шатун), revs=5, time=256
|
|
|
let bytes = [0x02, 0x05, 0x00, 0x00, 0x01];
|
|
|
assert_eq!(parse_csc(&bytes), Some(CscRaw { crank_revs: 5, crank_time: 256 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_csc_with_wheel() {
|
|
|
// flags=0x03 (колесо+шатун), колесо 6 байт, затем revs=5, time=256
|
|
|
let bytes = [0x03, 0, 0, 0, 0, 0, 0, 0x05, 0x00, 0x00, 0x01];
|
|
|
assert_eq!(parse_csc(&bytes), Some(CscRaw { crank_revs: 5, crank_time: 256 }));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_parse_csc_no_crank() {
|
|
|
// flags=0x01 (только колесо) — данных шатуна нет
|
|
|
let bytes = [0x01, 0, 0, 0, 0, 0, 0];
|
|
|
assert_eq!(parse_csc(&bytes), None);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_accumulator_needs_two_samples() {
|
|
|
let mut acc = CscAccumulator::new();
|
|
|
assert_eq!(acc.push(CscRaw { crank_revs: 0, crank_time: 0 }), None);
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_accumulator_computes_rpm() {
|
|
|
let mut acc = CscAccumulator::new();
|
|
|
acc.push(CscRaw { crank_revs: 0, crank_time: 0 });
|
|
|
// 1 оборот за 1024 тика (1 с) = 60 rpm
|
|
|
assert_eq!(acc.push(CscRaw { crank_revs: 1, crank_time: 1024 }), Some(60.0));
|
|
|
}
|
|
|
|
|
|
#[test]
|
|
|
fn test_accumulator_zero_time_returns_none() {
|
|
|
let mut acc = CscAccumulator::new();
|
|
|
acc.push(CscRaw { crank_revs: 0, crank_time: 0 });
|
|
|
assert_eq!(acc.push(CscRaw { crank_revs: 5, crank_time: 0 }), None);
|
|
|
}
|
|
|
}
|
