8913546430

Committed 01 May 2024 06:47PM UTC coverage: 72.308% (-14.4%) from 86.709%

Build # 8913546430

Build Type

Pull #9

github

Committed by

web-flow

Commit Message

Merge 24fcadd15 into 631159c4e

Pull Request Pull Request #9: Read scaled output values using set gyro and acceleromter ranges

Run Details

4 of 37 new or added lines in 3 files covered. (10.81%)

2 existing lines in 2 files now uncovered.

141 of 195 relevant lines covered (72.31%)

1.33 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

74.6

/src/read_sensor_data.rs

use crate::{
    interface::{ReadData, WriteData},
    types::{DataScaled, Sensor3DDataScaled},
    Bmi160, Data, Error, MagnetometerData, Register, Sensor3DData, SensorSelector,
};

impl<DI, CommE> Bmi160<DI>
where
    DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
{
    /// Read latest sensor data
    pub fn data(&mut self, selector: SensorSelector) -> Result<Data, Error<CommE>> {
        let result = if selector != SensorSelector::new() {
            let (begin, end) = get_data_addresses(selector);
            let mut data = [0_u8; 24];
            data[0] = begin;
            let len = (1 + end - begin) as usize;
            self.iface.read_data(&mut data[0..len])?;
            get_data(selector, &data[1..], (begin - Register::MAG) as usize)
        } else {
            Data {
                accel: None,
                gyro: None,
                magnet: None,
                time: None,
            }
        };
        Ok(result)
    }

    /// Read latest sensor data and scale it using the gyroscope and accelerometer ranges
    pub fn data_scaled(&mut self, selector: SensorSelector) -> Result<DataScaled, Error<CommE>> {
        let raw_data = self.data(selector)?;

        let accel_multiplier = self.accel_range.multiplier();
        let gyro_multiplier = self.gyro_range.multiplier();

        Ok(DataScaled {
            accel: raw_data.accel.map(|d| Sensor3DDataScaled {
                x: d.x as f32 * accel_multiplier,
                y: d.y as f32 * accel_multiplier,
                z: d.z as f32 * accel_multiplier,
            }),
            gyro: raw_data.gyro.map(|d| Sensor3DDataScaled {
                x: d.x as f32 * gyro_multiplier,
                y: d.y as f32 * gyro_multiplier,
                z: d.z as f32 * gyro_multiplier,
            }),
            magnet: raw_data.magnet,
            time: raw_data.time,
        })
    }
}

fn get_data(selector: SensorSelector, data: &[u8], data_offset: usize) -> Data {
    let mut result = Data {
        accel: None,
        gyro: None,
        magnet: None,
        time: None,
    };
    if selector.magnet {
        result.magnet = Some(MagnetometerData {
            axes: get_sensor3d_data(&data[0..6]),
            hall_resistence: (u16::from(data[6]) | (u16::from(data[7]) << 8)),
        });
    }
    if selector.gyro {
        result.gyro = Some(get_sensor3d_data(&data[8 - data_offset..14 - data_offset]));
    }
    if selector.accel {
        result.accel = Some(get_sensor3d_data(&data[14 - data_offset..20 - data_offset]));
    }
    if selector.time {
        result.time = Some(
            u32::from(data[20 - data_offset])
                | (u32::from(data[21 - data_offset]) << 8)
                | (u32::from(data[22 - data_offset]) << 16),
        );
    }
    result
}

fn get_sensor3d_data(data: &[u8]) -> Sensor3DData {
    Sensor3DData {
        x: (u16::from(data[0]) | (u16::from(data[1]) << 8)) as i16,
        y: (u16::from(data[2]) | (u16::from(data[3]) << 8)) as i16,
        z: (u16::from(data[4]) | (u16::from(data[5]) << 8)) as i16,
    }
}

fn get_data_addresses(selector: SensorSelector) -> (u8, u8) {
    let begin = if selector.magnet {
        Register::MAG
    } else if selector.gyro {
        Register::GYR
    } else if selector.accel {
        Register::ACC
    } else if selector.time {
        Register::SENSORTIME
    } else {
        0
    };

    let end = if selector.time {
        Register::SENSORTIME + 3
    } else if selector.accel {
        Register::ACC + 6
    } else if selector.gyro {
        Register::GYR + 6
    } else if selector.magnet {
        Register::MAG + 8
    } else {
        0
    };

    (begin, end)
}

#[cfg(test)]
mod tests {
    use super::*;

    mod data_addresses {
        use super::*;
        #[test]
        fn all() {
            let result = get_data_addresses(SensorSelector::all());
            assert_eq!(result, (Register::MAG, Register::SENSORTIME + 3));
        }

        #[test]
        fn none() {
            let result = get_data_addresses(SensorSelector::new());
            assert_eq!(result, (0, 0));
        }

        #[test]
        fn only_accel() {
            let result = get_data_addresses(SensorSelector::new().accel());
            assert_eq!(result, (Register::ACC, Register::ACC + 6));
        }

        #[test]
        fn only_gyro() {
            let result = get_data_addresses(SensorSelector::new().gyro());
            assert_eq!(result, (Register::GYR, Register::GYR + 6));
        }

        #[test]
        fn only_magnet() {
            let result = get_data_addresses(SensorSelector::new().magnet());
            assert_eq!(result, (Register::MAG, Register::MAG + 8));
        }

        #[test]
        fn accel_and_time() {
            let result = get_data_addresses(SensorSelector::new().accel().time());
            assert_eq!(result, (Register::ACC, Register::SENSORTIME + 3));
        }

        #[test]
        fn gyro_and_time() {
            let result = get_data_addresses(SensorSelector::new().gyro().time());
            assert_eq!(result, (Register::GYR, Register::SENSORTIME + 3));
        }
    }

    mod sensor3d_data {
        use super::*;

        #[test]
        fn can_decode_positive_array() {
            let result = get_sensor3d_data(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
            assert_eq!(
                result,
                Sensor3DData {
                    x: 0x0201,
                    y: 0x0403,
                    z: 0x0605
                }
            );
        }

        #[test]
        fn can_decode_negative_array() {
            let result = get_sensor3d_data(&[0x0B, 0x86, 0x0B, 0x86, 0x0B, 0x86]);
            assert_eq!(
                result,
                Sensor3DData {
                    x: -31221,
                    y: -31221,
                    z: -31221
                }
            );
        }
    }
}

1	use crate::{
2	interface::{ReadData, WriteData},
3	types::{DataScaled, Sensor3DDataScaled},
4	Bmi160, Data, Error, MagnetometerData, Register, Sensor3DData, SensorSelector,
5	};
6
7	impl<DI, CommE> Bmi160<DI>
8	where
9	DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
10	{
11	/// Read latest sensor data
12	pub fn data(&mut self, selector: SensorSelector) -> Result<Data, Error<CommE>> {	1✔
13	let result = if selector != SensorSelector::new() {	2✔
14	let (begin, end) = get_data_addresses(selector);	1✔
15	let mut data = [0_u8; 24];	1✔
16	data[0] = begin;	1✔
17	let len = (1 + end - begin) as usize;	2✔
18	self.iface.read_data(&mut data[0..len])?;	2✔
19	get_data(selector, &data[1..], (begin - Register::MAG) as usize)	2✔
20	} else {
21	Data {
22	accel: None,
23	gyro: None,
24	magnet: None,
25	time: None,
26	}
27	};
28	Ok(result)	1✔
29	}
30
31	/// Read latest sensor data and scale it using the gyroscope and accelerometer ranges
NEW 32	pub fn data_scaled(&mut self, selector: SensorSelector) -> Result<DataScaled, Error<CommE>> {	×
NEW 33	let raw_data = self.data(selector)?;	×
34
NEW 35	let accel_multiplier = self.accel_range.multiplier();	×
NEW 36	let gyro_multiplier = self.gyro_range.multiplier();	×
37
NEW 38	Ok(DataScaled {	×
NEW 39	accel: raw_data.accel.map(\|d\| Sensor3DDataScaled {	×
NEW 40	x: d.x as f32 * accel_multiplier,	×
NEW 41	y: d.y as f32 * accel_multiplier,	×
NEW 42	z: d.z as f32 * accel_multiplier,	×
43	}),
NEW 44	gyro: raw_data.gyro.map(\|d\| Sensor3DDataScaled {	×
NEW 45	x: d.x as f32 * gyro_multiplier,	×
NEW 46	y: d.y as f32 * gyro_multiplier,	×
NEW 47	z: d.z as f32 * gyro_multiplier,	×
48	}),
NEW 49	magnet: raw_data.magnet,	×
NEW 50	time: raw_data.time,	×
51	})
52	}
53	}
54
55	fn get_data(selector: SensorSelector, data: &[u8], data_offset: usize) -> Data {	1✔
56	let mut result = Data {
57	accel: None,
58	gyro: None,
59	magnet: None,
60	time: None,
61	};
62	if selector.magnet {	2✔
63	result.magnet = Some(MagnetometerData {	1✔
64	axes: get_sensor3d_data(&data[0..6]),	1✔
65	hall_resistence: (u16::from(data[6]) \| (u16::from(data[7]) << 8)),	3✔
66	});
67	}
68	if selector.gyro {	2✔
69	result.gyro = Some(get_sensor3d_data(&data[8 - data_offset..14 - data_offset]));	1✔
70	}
71	if selector.accel {	2✔
72	result.accel = Some(get_sensor3d_data(&data[14 - data_offset..20 - data_offset]));	1✔
73	}
74	if selector.time {	2✔
75	result.time = Some(	1✔
76	u32::from(data[20 - data_offset])	3✔
77	\| (u32::from(data[21 - data_offset]) << 8)	3✔
78	\| (u32::from(data[22 - data_offset]) << 16),	3✔
79	);
80	}
81	result	1✔
82	}
83
84	fn get_sensor3d_data(data: &[u8]) -> Sensor3DData {	2✔
85	Sensor3DData {
86	x: (u16::from(data[0]) \| (u16::from(data[1]) << 8)) as i16,	6✔
87	y: (u16::from(data[2]) \| (u16::from(data[3]) << 8)) as i16,	8✔
88	z: (u16::from(data[4]) \| (u16::from(data[5]) << 8)) as i16,	8✔
89	}
90	}
91
92	fn get_data_addresses(selector: SensorSelector) -> (u8, u8) {	2✔
93	let begin = if selector.magnet {	4✔
94	Register::MAG	2✔
95	} else if selector.gyro {	4✔
96	Register::GYR	2✔
97	} else if selector.accel {	4✔
98	Register::ACC	2✔
99	} else if selector.time {	2✔
100	Register::SENSORTIME	×
101	} else {
102	0	1✔
103	};
104
105	let end = if selector.time {	4✔
106	Register::SENSORTIME + 3	4✔
107	} else if selector.accel {	3✔
108	Register::ACC + 6	2✔
109	} else if selector.gyro {	4✔
110	Register::GYR + 6	4✔
111	} else if selector.magnet {	3✔
112	Register::MAG + 8	2✔
113	} else {
114	0	1✔
115	};
116
117	(begin, end)	2✔
118	}
119
120	#[cfg(test)]
121	mod tests {
122	use super::*;
123
124	mod data_addresses {
125	use super::*;
126	#[test]
127	fn all() {
128	let result = get_data_addresses(SensorSelector::all());
129	assert_eq!(result, (Register::MAG, Register::SENSORTIME + 3));
130	}
131
132	#[test]
133	fn none() {
134	let result = get_data_addresses(SensorSelector::new());
135	assert_eq!(result, (0, 0));
136	}
137
138	#[test]
139	fn only_accel() {
140	let result = get_data_addresses(SensorSelector::new().accel());
141	assert_eq!(result, (Register::ACC, Register::ACC + 6));
142	}
143
144	#[test]
145	fn only_gyro() {
146	let result = get_data_addresses(SensorSelector::new().gyro());
147	assert_eq!(result, (Register::GYR, Register::GYR + 6));
148	}
149
150	#[test]
151	fn only_magnet() {
152	let result = get_data_addresses(SensorSelector::new().magnet());
153	assert_eq!(result, (Register::MAG, Register::MAG + 8));
154	}
155
156	#[test]
157	fn accel_and_time() {
158	let result = get_data_addresses(SensorSelector::new().accel().time());
159	assert_eq!(result, (Register::ACC, Register::SENSORTIME + 3));
160	}
161
162	#[test]
163	fn gyro_and_time() {
164	let result = get_data_addresses(SensorSelector::new().gyro().time());
165	assert_eq!(result, (Register::GYR, Register::SENSORTIME + 3));
166	}
167	}
168
169	mod sensor3d_data {
170	use super::*;
171
172	#[test]
173	fn can_decode_positive_array() {
174	let result = get_sensor3d_data(&[0x01, 0x02, 0x03, 0x04, 0x05, 0x06]);
175	assert_eq!(
176	result,
177	Sensor3DData {
178	x: 0x0201,
179	y: 0x0403,
180	z: 0x0605
181	}
182	);
183	}
184
185	#[test]
186	fn can_decode_negative_array() {
187	let result = get_sensor3d_data(&[0x0B, 0x86, 0x0B, 0x86, 0x0B, 0x86]);
188	assert_eq!(
189	result,
190	Sensor3DData {
191	x: -31221,
192	y: -31221,
193	z: -31221
194	}
195	);
196	}
197	}
198	}

eldruin / bmi160-rs / 8913546430

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous