idun 0.0.3

Async Rust client, CLI, and TUI for streaming real-time EEG, IMU, and impedance data from IDUN Guardian earbuds over Bluetooth Low Energy
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use idun::types::*;

#[test]
fn eeg_reading_debug() {
    let r = EegReading {
        index: 42,
        timestamp: 1234567890.0,
        raw_data: vec![0xAA, 42, 1, 2, 3],
        samples: None,
        decode_source: DecodeSource::None,
    };
    let dbg = format!("{:?}", r);
    assert!(dbg.contains("42"));
    assert!(dbg.contains("1234567890"));
}

#[test]
fn impedance_reading_kohms() {
    let r = ImpedanceReading {
        impedance_ohms: 5000,
        impedance_kohms: 5.0,
        timestamp: 0.0,
    };
    assert_eq!(r.impedance_kohms, r.impedance_ohms as f64 / 1000.0);
}

#[test]
fn battery_reading_range() {
    let b = BatteryReading { level: 100 };
    assert!(b.level <= 100);
}

#[test]
fn device_info_fields() {
    let d = DeviceInfo {
        mac_address: "AA-BB-CC-DD-EE-FF".into(),
        firmware_version: "1.2.3".into(),
        hardware_version: "3.0a".into(),
    };
    assert!(d.mac_address.contains('-'));
    assert!(!d.firmware_version.is_empty());
    assert!(!d.hardware_version.is_empty());
}

#[test]
fn xyz_sample_default() {
    let s = XyzSample::default();
    assert_eq!(s.x, 0.0);
    assert_eq!(s.y, 0.0);
    assert_eq!(s.z, 0.0);
}

#[test]
fn accelerometer_reading() {
    let r = AccelerometerReading {
        index: 10,
        timestamp: 1000.0,
        sample: XyzSample { x: 0.01, y: -0.02, z: -0.98 },
    };
    assert!((r.sample.z + 0.98).abs() < 0.001);
}

#[test]
fn gyroscope_reading() {
    let r = GyroscopeReading {
        index: 10,
        timestamp: 1000.0,
        sample: XyzSample { x: 1.5, y: -0.3, z: 0.0 },
    };
    assert_eq!(r.sample.x, 1.5);
}

#[test]
fn guardian_event_all_variants() {
    let events: Vec<GuardianEvent> = vec![
        GuardianEvent::Connected("IGEB".into()),
        GuardianEvent::Disconnected,
        GuardianEvent::Eeg(EegReading {
            index: 0,
            timestamp: 0.0,
            raw_data: vec![],
            samples: None,
            decode_source: DecodeSource::None,
        }),
        GuardianEvent::Accelerometer(AccelerometerReading {
            index: 0,
            timestamp: 0.0,
            sample: XyzSample::default(),
        }),
        GuardianEvent::Gyroscope(GyroscopeReading {
            index: 0,
            timestamp: 0.0,
            sample: XyzSample::default(),
        }),
        GuardianEvent::Impedance(ImpedanceReading {
            impedance_ohms: 1000,
            impedance_kohms: 1.0,
            timestamp: 0.0,
        }),
        GuardianEvent::Battery(BatteryReading { level: 50 }),
        GuardianEvent::DeviceInfo(DeviceInfo {
            mac_address: String::new(),
            firmware_version: String::new(),
            hardware_version: String::new(),
        }),
    ];
    assert_eq!(events.len(), 8);
}

#[test]
fn guardian_event_clone() {
    let ev = GuardianEvent::Battery(BatteryReading { level: 75 });
    let ev2 = ev.clone();
    if let GuardianEvent::Battery(b) = ev2 {
        assert_eq!(b.level, 75);
    } else {
        panic!("Clone changed variant");
    }
}

#[test]
fn eeg_reading_with_decoded_samples() {
    let r = EegReading {
        index: 1,
        timestamp: 1000.0,
        raw_data: vec![0xAA, 1, 2, 3],
        samples: Some(vec![0.5, -0.3, 1.2]),
        decode_source: DecodeSource::Local,
    };
    assert_eq!(r.samples.as_ref().unwrap().len(), 3);
    assert_eq!(r.decode_source, DecodeSource::Local);
}

#[test]
fn eeg_reading_cloud_source() {
    let r = EegReading {
        index: 0,
        timestamp: 0.0,
        raw_data: vec![],
        samples: Some(vec![1.0]),
        decode_source: DecodeSource::Cloud,
    };
    assert_eq!(r.decode_source, DecodeSource::Cloud);
    assert_ne!(r.decode_source, DecodeSource::Local);
    assert_ne!(r.decode_source, DecodeSource::None);
}

#[test]
fn decode_source_equality() {
    assert_eq!(DecodeSource::None, DecodeSource::None);
    assert_ne!(DecodeSource::Local, DecodeSource::Cloud);
}