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

87.88

/src/device_impl.rs

use crate::{
    interface::{I2cInterface, ReadData, SpiInterface, WriteData},
    types::{AccelerometerRange, GyroRange},
    AccelerometerPowerMode, BitFlags, Bmi160, Error, GyroscopePowerMode, MagnetometerPowerMode,
    Register, SensorPowerMode, SlaveAddr, Status,
};

impl<I2C> Bmi160<I2cInterface<I2C>> {
    /// Create new instance of the BMI160 device communicating through I2C.
    pub fn new_with_i2c(i2c: I2C, address: SlaveAddr) -> Self {
        Bmi160 {
            iface: I2cInterface {
                i2c,
                address: address.addr(),
            },
            accel_range: AccelerometerRange::default(),
            gyro_range: GyroRange::default(),
        }
    }

    /// Destroy driver instance, return I2C bus.
    pub fn destroy(self) -> I2C {
        self.iface.i2c
    }
}

impl<SPI> Bmi160<SpiInterface<SPI>> {
    /// Create new instance of the BMI160 device communicating through SPI.
    pub fn new_with_spi(spi: SPI) -> Self {
        Bmi160 {
            iface: SpiInterface { spi },
            accel_range: AccelerometerRange::default(),
            gyro_range: GyroRange::default(),
        }
    }

    /// Destroy driver instance, return SPI device instance.
    pub fn destroy(self) -> SPI {
        self.iface.spi
    }
}

impl<DI, CommE> Bmi160<DI>
where
    DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
{
    /// Get chip ID
    pub fn chip_id(&mut self) -> Result<u8, Error<CommE>> {
        self.iface.read_register(Register::CHIPID)
    }

    /// Get sensor power mode
    pub fn power_mode(&mut self) -> Result<SensorPowerMode, Error<CommE>> {
        let status = self.iface.read_register(Register::PMU_STATUS)?;
        let accel = match status & (0b11 << 4) {
            0 => AccelerometerPowerMode::Suspend,
            0b10_0000 => AccelerometerPowerMode::LowPower,
            _ => AccelerometerPowerMode::Normal,
        };
        let magnet = match status & 0b11 {
            0 => MagnetometerPowerMode::Suspend,
            2 => MagnetometerPowerMode::LowPower,
            _ => MagnetometerPowerMode::Normal,
        };
        let gyro = match status & (0b11 << 2) {
            0 => GyroscopePowerMode::Suspend,
            0b1100 => GyroscopePowerMode::FastStartUp,
            _ => GyroscopePowerMode::Normal,
        };
        Ok(SensorPowerMode {
            accel,
            gyro,
            magnet,
        })
    }

    /// Get sensor status
    pub fn status(&mut self) -> Result<Status, Error<CommE>> {
        let status = self.iface.read_register(Register::STATUS)?;
        Ok(Status {
            accel_data_ready: (status & BitFlags::DRDY_ACC) != 0,
            gyro_data_ready: (status & BitFlags::DRDY_GYR) != 0,
            magnet_data_ready: (status & BitFlags::DRDY_MAG) != 0,
            nvm_ready: (status & BitFlags::NVM_RDY) != 0,
            foc_ready: (status & BitFlags::FOC_RDY) != 0,
            magnet_manual_op: (status & BitFlags::MAG_MAN_OP) != 0,
            gyro_self_test_ok: (status & BitFlags::GYR_SELF_TEST_OK) != 0,
        })
    }

    /// Configure accelerometer power mode
    pub fn set_accel_power_mode(
        &mut self,
        mode: AccelerometerPowerMode,
    ) -> Result<(), Error<CommE>> {
        let cmd = match mode {
            AccelerometerPowerMode::Suspend => 0b0001_0000,
            AccelerometerPowerMode::Normal => 0b0001_0001,
            AccelerometerPowerMode::LowPower => 0b0001_0010,
        };
        self.iface.write_register(Register::CMD, cmd)
    }

    /// Configure gyroscope power mode
    pub fn set_gyro_power_mode(&mut self, mode: GyroscopePowerMode) -> Result<(), Error<CommE>> {
        let cmd = match mode {
            GyroscopePowerMode::Suspend => 0b0001_0100,
            GyroscopePowerMode::Normal => 0b0001_0101,
            GyroscopePowerMode::FastStartUp => 0b0001_0111,
        };
        self.iface.write_register(Register::CMD, cmd)
    }

    /// Configure magnetometer power mode
    pub fn set_magnet_power_mode(
        &mut self,
        mode: MagnetometerPowerMode,
    ) -> Result<(), Error<CommE>> {
        let cmd = match mode {
            MagnetometerPowerMode::Suspend => 0b0001_1000,
            MagnetometerPowerMode::Normal => 0b0001_1001,
            MagnetometerPowerMode::LowPower => 0b0001_1010,
        };
        self.iface.write_register(Register::CMD, cmd)
    }

    /// Set the accelerometer range
    pub fn set_accel_range(&mut self, range: AccelerometerRange) -> Result<(), Error<CommE>> {
        self.accel_range = range;
        self.iface.write_register(Register::ACC_RANGE, range as u8)
    }

    /// Set the gyro range
    pub fn set_gyro_range(&mut self, range: GyroRange) -> Result<(), Error<CommE>> {
        self.gyro_range = range;
        self.iface.write_register(Register::GYR_RANGE, range as u8)
    }
}

1	use crate::{
2	interface::{I2cInterface, ReadData, SpiInterface, WriteData},
3	types::{AccelerometerRange, GyroRange},
4	AccelerometerPowerMode, BitFlags, Bmi160, Error, GyroscopePowerMode, MagnetometerPowerMode,
5	Register, SensorPowerMode, SlaveAddr, Status,
6	};
7
8	impl<I2C> Bmi160<I2cInterface<I2C>> {
9	/// Create new instance of the BMI160 device communicating through I2C.
10	pub fn new_with_i2c(i2c: I2C, address: SlaveAddr) -> Self {	3✔
11	Bmi160 {
12	iface: I2cInterface {	3✔
13	i2c,
14	address: address.addr(),
15	},
16	accel_range: AccelerometerRange::default(),	3✔
17	gyro_range: GyroRange::default(),	3✔
18	}
19	}
20
21	/// Destroy driver instance, return I2C bus.
22	pub fn destroy(self) -> I2C {	×
23	self.iface.i2c	3✔
24	}
25	}
26
27	impl<SPI> Bmi160<SpiInterface<SPI>> {
28	/// Create new instance of the BMI160 device communicating through SPI.
29	pub fn new_with_spi(spi: SPI) -> Self {	1✔
30	Bmi160 {
31	iface: SpiInterface { spi },	1✔
32	accel_range: AccelerometerRange::default(),	1✔
33	gyro_range: GyroRange::default(),	1✔
34	}
35	}
36
37	/// Destroy driver instance, return SPI device instance.
UNCOV 38	pub fn destroy(self) -> SPI {	×
39	self.iface.spi	1✔
40	}
41	}
42
43	impl<DI, CommE> Bmi160<DI>
44	where
45	DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
46	{
47	/// Get chip ID
48	pub fn chip_id(&mut self) -> Result<u8, Error<CommE>> {	1✔
49	self.iface.read_register(Register::CHIPID)	1✔
50	}
51
52	/// Get sensor power mode
53	pub fn power_mode(&mut self) -> Result<SensorPowerMode, Error<CommE>> {	1✔
54	let status = self.iface.read_register(Register::PMU_STATUS)?;	1✔
55	let accel = match status & (0b11 << 4) {	1✔
56	0 => AccelerometerPowerMode::Suspend,	1✔
57	0b10_0000 => AccelerometerPowerMode::LowPower,	1✔
58	_ => AccelerometerPowerMode::Normal,	1✔
59	};
60	let magnet = match status & 0b11 {	1✔
61	0 => MagnetometerPowerMode::Suspend,	1✔
62	2 => MagnetometerPowerMode::LowPower,	1✔
63	_ => MagnetometerPowerMode::Normal,	1✔
64	};
65	let gyro = match status & (0b11 << 2) {	1✔
66	0 => GyroscopePowerMode::Suspend,	1✔
67	0b1100 => GyroscopePowerMode::FastStartUp,	1✔
68	_ => GyroscopePowerMode::Normal,	1✔
69	};
70	Ok(SensorPowerMode {	1✔
71	accel,	1✔
72	gyro,	1✔
73	magnet,	1✔
74	})
75	}
76
77	/// Get sensor status
78	pub fn status(&mut self) -> Result<Status, Error<CommE>> {	1✔
79	let status = self.iface.read_register(Register::STATUS)?;	1✔
80	Ok(Status {	1✔
81	accel_data_ready: (status & BitFlags::DRDY_ACC) != 0,	1✔
82	gyro_data_ready: (status & BitFlags::DRDY_GYR) != 0,	1✔
83	magnet_data_ready: (status & BitFlags::DRDY_MAG) != 0,	1✔
84	nvm_ready: (status & BitFlags::NVM_RDY) != 0,	1✔
85	foc_ready: (status & BitFlags::FOC_RDY) != 0,	1✔
86	magnet_manual_op: (status & BitFlags::MAG_MAN_OP) != 0,	1✔
87	gyro_self_test_ok: (status & BitFlags::GYR_SELF_TEST_OK) != 0,	1✔
88	})
89	}
90
91	/// Configure accelerometer power mode
92	pub fn set_accel_power_mode(	1✔
93	&mut self,
94	mode: AccelerometerPowerMode,
95	) -> Result<(), Error<CommE>> {
96	let cmd = match mode {	1✔
97	AccelerometerPowerMode::Suspend => 0b0001_0000,	1✔
98	AccelerometerPowerMode::Normal => 0b0001_0001,	1✔
99	AccelerometerPowerMode::LowPower => 0b0001_0010,	1✔
100	};
101	self.iface.write_register(Register::CMD, cmd)	1✔
102	}
103
104	/// Configure gyroscope power mode
105	pub fn set_gyro_power_mode(&mut self, mode: GyroscopePowerMode) -> Result<(), Error<CommE>> {	1✔
106	let cmd = match mode {	1✔
107	GyroscopePowerMode::Suspend => 0b0001_0100,	1✔
108	GyroscopePowerMode::Normal => 0b0001_0101,	1✔
109	GyroscopePowerMode::FastStartUp => 0b0001_0111,	1✔
110	};
111	self.iface.write_register(Register::CMD, cmd)	1✔
112	}
113
114	/// Configure magnetometer power mode
115	pub fn set_magnet_power_mode(	1✔
116	&mut self,
117	mode: MagnetometerPowerMode,
118	) -> Result<(), Error<CommE>> {
119	let cmd = match mode {	1✔
120	MagnetometerPowerMode::Suspend => 0b0001_1000,	1✔
121	MagnetometerPowerMode::Normal => 0b0001_1001,	1✔
122	MagnetometerPowerMode::LowPower => 0b0001_1010,	1✔
123	};
124	self.iface.write_register(Register::CMD, cmd)	1✔
125	}
126
127	/// Set the accelerometer range
NEW 128	pub fn set_accel_range(&mut self, range: AccelerometerRange) -> Result<(), Error<CommE>> {	×
NEW 129	self.accel_range = range;	×
NEW 130	self.iface.write_register(Register::ACC_RANGE, range as u8)	×
131	}
132
133	/// Set the gyro range
NEW 134	pub fn set_gyro_range(&mut self, range: GyroRange) -> Result<(), Error<CommE>> {	×
NEW 135	self.gyro_range = range;	×
NEW 136	self.iface.write_register(Register::GYR_RANGE, range as u8)	×
137	}
138	}

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