9651803572

Committed 24 Jun 2024 08:13PM UTC coverage: 94.544% (+12.0%) from 82.582%

Build # 9651803572

Build Type

push

github

Committed by

eldruin

Commit Message

Update CI

Run Details

953 of 1008 relevant lines covered (94.54%)

11.86 hits per line

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

95.0

/src/device_impl.rs

use maybe_async_cfg::maybe;

use crate::{
    interface::{I2cInterface, ReadData, SpiInterface, WriteData},
    mode,
    register_address::{
        CfgRegAM, CfgRegBM, CfgRegCM, CtrlReg1A, CtrlReg3A, CtrlReg4A, CtrlReg5A, FifoCtrlRegA,
        StatusRegA, StatusRegAuxA, StatusRegM, TempCfgRegA, WhoAmIA, WhoAmIM,
    },
    Acceleration, AccelerometerId, Error, FifoMode, Interrupt, Lsm303agr, MagnetometerId,
    PhantomData, Status, Temperature, TemperatureStatus,
};

impl<I2C> Lsm303agr<I2cInterface<I2C>, mode::MagOneShot> {
    /// Create new instance of the LSM303AGR device communicating through I2C.
    pub fn new_with_i2c(i2c: I2C) -> Self {
        Lsm303agr {
            iface: I2cInterface { i2c },
            ctrl_reg1_a: CtrlReg1A::default(),
            ctrl_reg3_a: CtrlReg3A::default(),
            ctrl_reg4_a: CtrlReg4A::default(),
            ctrl_reg5_a: CtrlReg5A::default(),
            cfg_reg_a_m: CfgRegAM::default(),
            cfg_reg_b_m: CfgRegBM::default(),
            cfg_reg_c_m: CfgRegCM::default(),
            temp_cfg_reg_a: TempCfgRegA::default(),
            fifo_ctrl_reg_a: FifoCtrlRegA::default(),
            accel_odr: None,
            _mag_mode: PhantomData,
        }
    }
}

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

impl<SPIXL, SPIMAG> Lsm303agr<SpiInterface<SPIXL, SPIMAG>, mode::MagOneShot> {
    /// Create new instance of the LSM303AGR device communicating through SPI.
    pub fn new_with_spi(spi_accel: SPIXL, spi_mag: SPIMAG) -> Self {
        Lsm303agr {
            iface: SpiInterface {
                spi_xl: spi_accel,
                spi_mag,
            },
            ctrl_reg1_a: CtrlReg1A::default(),
            ctrl_reg3_a: CtrlReg3A::default(),
            ctrl_reg4_a: CtrlReg4A::default(),
            ctrl_reg5_a: CtrlReg5A::default(),
            cfg_reg_a_m: CfgRegAM::default(),
            cfg_reg_b_m: CfgRegBM::default(),
            cfg_reg_c_m: CfgRegCM::default(),
            temp_cfg_reg_a: TempCfgRegA::default(),
            fifo_ctrl_reg_a: FifoCtrlRegA::default(),
            accel_odr: None,
            _mag_mode: PhantomData,
        }
    }
}

impl<SPIXL, SPIMAG, MODE> Lsm303agr<SpiInterface<SPIXL, SPIMAG>, MODE> {
    /// Destroy driver instance, return SPI bus instance and chip select pin.
    pub fn destroy(self) -> (SPIXL, SPIMAG) {
        (self.iface.spi_xl, self.iface.spi_mag)
    }
}

#[maybe(
    sync(cfg(not(feature = "async")), keep_self,),
    async(cfg(feature = "async"), keep_self,)
)]
impl<DI, CommE, MODE> Lsm303agr<DI, MODE>
where
    DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
{
    /// Initialize registers
    pub async fn init(&mut self) -> Result<(), Error<CommE>> {
        self.acc_enable_temp().await?; // Also enables BDU.
        self.mag_enable_bdu().await
    }

    /// Enable block data update for accelerometer.
    #[inline]
    async fn acc_enable_bdu(&mut self) -> Result<(), Error<CommE>> {
        let reg4 = self.ctrl_reg4_a | CtrlReg4A::BDU;
        self.iface.write_accel_register(reg4).await?;
        self.ctrl_reg4_a = reg4;

        Ok(())
    }

    /// Enable the temperature sensor.
    #[inline]
    async fn acc_enable_temp(&mut self) -> Result<(), Error<CommE>> {
        self.acc_enable_bdu().await?;

        let temp_cfg_reg = self.temp_cfg_reg_a | TempCfgRegA::TEMP_EN;
        self.iface.write_accel_register(temp_cfg_reg).await?;
        self.temp_cfg_reg_a = temp_cfg_reg;

        Ok(())
    }

    /// Enable block data update for magnetometer.
    #[inline]
    async fn mag_enable_bdu(&mut self) -> Result<(), Error<CommE>> {
        let regc = self.cfg_reg_c_m | CfgRegCM::BDU;
        self.iface.write_mag_register(regc).await?;
        self.cfg_reg_c_m = regc;

        Ok(())
    }

    /// Set the accelerometer FIFO mode and full threshold.
    ///
    /// The threshold is clamped to \[0, 31\].
    pub async fn acc_set_fifo_mode(&mut self, mode: FifoMode, fth: u8) -> Result<(), Error<CommE>> {
        let mut reg5 = self.ctrl_reg5_a;
        reg5.set(CtrlReg5A::FIFO_EN, mode != FifoMode::Bypass);
        self.iface.write_accel_register(reg5).await?;
        self.ctrl_reg5_a = reg5;

        let fifo_ctrl = self
            .fifo_ctrl_reg_a
            .with_mode(mode)
            .with_full_threshold(fth);
        self.iface.write_accel_register(fifo_ctrl).await?;
        self.fifo_ctrl_reg_a = fifo_ctrl;

        Ok(())
    }

    /// Enable accelerometer interrupt.
    pub async fn acc_enable_interrupt(&mut self, interrupt: Interrupt) -> Result<(), Error<CommE>> {
        let reg3 = self.ctrl_reg3_a.with_interrupt(interrupt);
        self.iface.write_accel_register(reg3).await?;
        self.ctrl_reg3_a = reg3;

        Ok(())
    }

    /// Disable accelerometer interrupt.
    pub async fn acc_disable_interrupt(
        &mut self,
        interrupt: Interrupt,
    ) -> Result<(), Error<CommE>> {
        let reg3 = self.ctrl_reg3_a.without_interrupt(interrupt);
        self.iface.write_accel_register(reg3).await?;
        self.ctrl_reg3_a = reg3;

        Ok(())
    }

    /// Configure the DRDY pin as a digital output.
    pub async fn mag_enable_int(&mut self) -> Result<(), Error<CommE>> {
        let regc = self.cfg_reg_c_m | CfgRegCM::INT_MAG;
        self.iface.write_mag_register(regc).await?;
        self.cfg_reg_c_m = regc;

        Ok(())
    }

    /// Enable magnetometer low-pass filter.
    pub async fn mag_enable_low_pass_filter(&mut self) -> Result<(), Error<CommE>> {
        let regb = self.cfg_reg_b_m.union(CfgRegBM::LPF);
        self.iface.write_mag_register(regb).await?;
        self.cfg_reg_b_m = regb;

        Ok(())
    }

    /// Disable magnetometer low-pass filter.
    pub async fn mag_disable_low_pass_filter(&mut self) -> Result<(), Error<CommE>> {
        let regb = self.cfg_reg_b_m.difference(CfgRegBM::LPF);
        self.iface.write_mag_register(regb).await?;
        self.cfg_reg_b_m = regb;

        Ok(())
    }

    /// Accelerometer status
    pub async fn accel_status(&mut self) -> Result<Status, Error<CommE>> {
        self.iface
            .read_accel_register::<StatusRegA>()
            .await
            .map(Status::new)
    }

    /// Get measured acceleration.
    pub async fn acceleration(&mut self) -> Result<Acceleration, Error<CommE>> {
        let (x, y, z) = self
            .iface
            .read_accel_3_double_registers::<Acceleration>()
            .await?;

        Ok(Acceleration {
            x,
            y,
            z,
            mode: self.get_accel_mode().await,
            scale: self.get_accel_scale().await,
        })
    }

    /// Magnetometer status
    pub async fn mag_status(&mut self) -> Result<Status, Error<CommE>> {
        self.iface
            .read_mag_register::<StatusRegM>()
            .await
            .map(Status::new)
    }

    /// Get the accelerometer device ID.
    pub async fn accelerometer_id(&mut self) -> Result<AccelerometerId, Error<CommE>> {
        self.iface.read_accel_register::<WhoAmIA>().await
    }

    /// Get the magnetometer device ID.
    pub async fn magnetometer_id(&mut self) -> Result<MagnetometerId, Error<CommE>> {
        self.iface.read_mag_register::<WhoAmIM>().await
    }

    /// Get measured temperature.
    pub async fn temperature(&mut self) -> Result<Temperature, Error<CommE>> {
        self.iface.read_accel_double_register::<Temperature>().await
    }

    /// Temperature sensor status
    pub async fn temperature_status(&mut self) -> Result<TemperatureStatus, Error<CommE>> {
        self.iface
            .read_accel_register::<StatusRegAuxA>()
            .await
            .map(TemperatureStatus::new)
    }
}

1	use maybe_async_cfg::maybe;
2
3	use crate::{
4	interface::{I2cInterface, ReadData, SpiInterface, WriteData},
5	mode,
6	register_address::{
7	CfgRegAM, CfgRegBM, CfgRegCM, CtrlReg1A, CtrlReg3A, CtrlReg4A, CtrlReg5A, FifoCtrlRegA,
8	StatusRegA, StatusRegAuxA, StatusRegM, TempCfgRegA, WhoAmIA, WhoAmIM,
9	},
10	Acceleration, AccelerometerId, Error, FifoMode, Interrupt, Lsm303agr, MagnetometerId,
11	PhantomData, Status, Temperature, TemperatureStatus,
12	};
13
14	impl<I2C> Lsm303agr<I2cInterface<I2C>, mode::MagOneShot> {
15	/// Create new instance of the LSM303AGR device communicating through I2C.
16	pub fn new_with_i2c(i2c: I2C) -> Self {	84✔
17	Lsm303agr {	84✔
18	iface: I2cInterface { i2c },	84✔
19	ctrl_reg1_a: CtrlReg1A::default(),	84✔
20	ctrl_reg3_a: CtrlReg3A::default(),	84✔
21	ctrl_reg4_a: CtrlReg4A::default(),	84✔
22	ctrl_reg5_a: CtrlReg5A::default(),	84✔
23	cfg_reg_a_m: CfgRegAM::default(),	84✔
24	cfg_reg_b_m: CfgRegBM::default(),	84✔
25	cfg_reg_c_m: CfgRegCM::default(),	84✔
26	temp_cfg_reg_a: TempCfgRegA::default(),	84✔
27	fifo_ctrl_reg_a: FifoCtrlRegA::default(),	84✔
28	accel_odr: None,	84✔
29	_mag_mode: PhantomData,	84✔
30	}	84✔
31	}	84✔
32	}
33
34	impl<I2C, MODE> Lsm303agr<I2cInterface<I2C>, MODE> {
35	/// Destroy driver instance, return I2C bus.
36	pub fn destroy(self) -> I2C {	84✔
37	self.iface.i2c	84✔
38	}	84✔
39	}
40
41	impl<SPIXL, SPIMAG> Lsm303agr<SpiInterface<SPIXL, SPIMAG>, mode::MagOneShot> {
42	/// Create new instance of the LSM303AGR device communicating through SPI.
43	pub fn new_with_spi(spi_accel: SPIXL, spi_mag: SPIMAG) -> Self {	9✔
44	Lsm303agr {	9✔
45	iface: SpiInterface {	9✔
46	spi_xl: spi_accel,	9✔
47	spi_mag,	9✔
48	},	9✔
49	ctrl_reg1_a: CtrlReg1A::default(),	9✔
50	ctrl_reg3_a: CtrlReg3A::default(),	9✔
51	ctrl_reg4_a: CtrlReg4A::default(),	9✔
52	ctrl_reg5_a: CtrlReg5A::default(),	9✔
53	cfg_reg_a_m: CfgRegAM::default(),	9✔
54	cfg_reg_b_m: CfgRegBM::default(),	9✔
55	cfg_reg_c_m: CfgRegCM::default(),	9✔
56	temp_cfg_reg_a: TempCfgRegA::default(),	9✔
57	fifo_ctrl_reg_a: FifoCtrlRegA::default(),	9✔
58	accel_odr: None,	9✔
59	_mag_mode: PhantomData,	9✔
60	}	9✔
61	}	9✔
62	}
63
64	impl<SPIXL, SPIMAG, MODE> Lsm303agr<SpiInterface<SPIXL, SPIMAG>, MODE> {
65	/// Destroy driver instance, return SPI bus instance and chip select pin.
66	pub fn destroy(self) -> (SPIXL, SPIMAG) {	9✔
67	(self.iface.spi_xl, self.iface.spi_mag)	9✔
68	}	9✔
69	}
70
71	#[maybe(
72	sync(cfg(not(feature = "async")), keep_self,),
73	async(cfg(feature = "async"), keep_self,)
74	)]
75	impl<DI, CommE, MODE> Lsm303agr<DI, MODE>
76	where
77	DI: ReadData<Error = Error<CommE>> + WriteData<Error = Error<CommE>>,
78	{
79	/// Initialize registers
80	pub async fn init(&mut self) -> Result<(), Error<CommE>> {	2✔
81	self.acc_enable_temp().await?; // Also enables BDU.	2✔
82	self.mag_enable_bdu().await	2✔
83	}	2✔
84
85	/// Enable block data update for accelerometer.
86	#[inline]
87	async fn acc_enable_bdu(&mut self) -> Result<(), Error<CommE>> {	2✔
88	let reg4 = self.ctrl_reg4_a \| CtrlReg4A::BDU;	2✔
89	self.iface.write_accel_register(reg4).await?;	2✔
90	self.ctrl_reg4_a = reg4;	2✔
91		2✔
92	Ok(())	2✔
93	}	2✔
94
95	/// Enable the temperature sensor.
96	#[inline]
97	async fn acc_enable_temp(&mut self) -> Result<(), Error<CommE>> {	2✔
98	self.acc_enable_bdu().await?;	2✔
99
100	let temp_cfg_reg = self.temp_cfg_reg_a \| TempCfgRegA::TEMP_EN;	2✔
101	self.iface.write_accel_register(temp_cfg_reg).await?;	2✔
102	self.temp_cfg_reg_a = temp_cfg_reg;	2✔
103		2✔
104	Ok(())	2✔
105	}	2✔
106
107	/// Enable block data update for magnetometer.
108	#[inline]
109	async fn mag_enable_bdu(&mut self) -> Result<(), Error<CommE>> {	2✔
110	let regc = self.cfg_reg_c_m \| CfgRegCM::BDU;	2✔
111	self.iface.write_mag_register(regc).await?;	2✔
112	self.cfg_reg_c_m = regc;	2✔
113		2✔
114	Ok(())	2✔
115	}	2✔
116
117	/// Set the accelerometer FIFO mode and full threshold.
118	///
119	/// The threshold is clamped to \[0, 31\].
120	pub async fn acc_set_fifo_mode(&mut self, mode: FifoMode, fth: u8) -> Result<(), Error<CommE>> {	3✔
121	let mut reg5 = self.ctrl_reg5_a;	3✔
122	reg5.set(CtrlReg5A::FIFO_EN, mode != FifoMode::Bypass);	3✔
123	self.iface.write_accel_register(reg5).await?;	3✔
124	self.ctrl_reg5_a = reg5;	3✔
125		3✔
126	let fifo_ctrl = self	3✔
127	.fifo_ctrl_reg_a	3✔
128	.with_mode(mode)	3✔
129	.with_full_threshold(fth);	3✔
130	self.iface.write_accel_register(fifo_ctrl).await?;	3✔
131	self.fifo_ctrl_reg_a = fifo_ctrl;	3✔
132		3✔
133	Ok(())	3✔
134	}	3✔
135
136	/// Enable accelerometer interrupt.
137	pub async fn acc_enable_interrupt(&mut self, interrupt: Interrupt) -> Result<(), Error<CommE>> {	1✔
138	let reg3 = self.ctrl_reg3_a.with_interrupt(interrupt);	1✔
139	self.iface.write_accel_register(reg3).await?;	1✔
140	self.ctrl_reg3_a = reg3;	1✔
141		1✔
142	Ok(())	1✔
143	}	1✔
144
145	/// Disable accelerometer interrupt.
146	pub async fn acc_disable_interrupt(	1✔
147	&mut self,	1✔
148	interrupt: Interrupt,	1✔
149	) -> Result<(), Error<CommE>> {	1✔
150	let reg3 = self.ctrl_reg3_a.without_interrupt(interrupt);	1✔
151	self.iface.write_accel_register(reg3).await?;	1✔
152	self.ctrl_reg3_a = reg3;	1✔
153		1✔
154	Ok(())	1✔
155	}	1✔
156
157	/// Configure the DRDY pin as a digital output.
158	pub async fn mag_enable_int(&mut self) -> Result<(), Error<CommE>> {	×
159	let regc = self.cfg_reg_c_m \| CfgRegCM::INT_MAG;	×
160	self.iface.write_mag_register(regc).await?;	×
161	self.cfg_reg_c_m = regc;	×
162		×
163	Ok(())	×
164	}	×
165
166	/// Enable magnetometer low-pass filter.
167	pub async fn mag_enable_low_pass_filter(&mut self) -> Result<(), Error<CommE>> {	1✔
168	let regb = self.cfg_reg_b_m.union(CfgRegBM::LPF);	1✔
169	self.iface.write_mag_register(regb).await?;	1✔
170	self.cfg_reg_b_m = regb;	1✔
171		1✔
172	Ok(())	1✔
173	}	1✔
174
175	/// Disable magnetometer low-pass filter.
176	pub async fn mag_disable_low_pass_filter(&mut self) -> Result<(), Error<CommE>> {	1✔
177	let regb = self.cfg_reg_b_m.difference(CfgRegBM::LPF);	1✔
178	self.iface.write_mag_register(regb).await?;	1✔
179	self.cfg_reg_b_m = regb;	1✔
180		1✔
181	Ok(())	1✔
182	}	1✔
183
184	/// Accelerometer status
185	pub async fn accel_status(&mut self) -> Result<Status, Error<CommE>> {	9✔
186	self.iface	9✔
187	.read_accel_register::<StatusRegA>()	9✔
188	.await	9✔
189	.map(Status::new)	9✔
190	}	9✔
191
192	/// Get measured acceleration.
193	pub async fn acceleration(&mut self) -> Result<Acceleration, Error<CommE>> {	16✔
194	let (x, y, z) = self	16✔
195	.iface	16✔
196	.read_accel_3_double_registers::<Acceleration>()	16✔
197	.await?;	×
198
199	Ok(Acceleration {	16✔
200	x,	16✔
201	y,	16✔
202	z,	16✔
203	mode: self.get_accel_mode().await,	16✔
204	scale: self.get_accel_scale().await,	16✔
205	})	16✔
206	}	16✔
207
208	/// Magnetometer status
209	pub async fn mag_status(&mut self) -> Result<Status, Error<CommE>> {	12✔
210	self.iface	12✔
211	.read_mag_register::<StatusRegM>()	12✔
212	.await	12✔
213	.map(Status::new)	12✔
214	}	12✔
215
216	/// Get the accelerometer device ID.
217	pub async fn accelerometer_id(&mut self) -> Result<AccelerometerId, Error<CommE>> {	4✔
218	self.iface.read_accel_register::<WhoAmIA>().await	4✔
219	}	4✔
220
221	/// Get the magnetometer device ID.
222	pub async fn magnetometer_id(&mut self) -> Result<MagnetometerId, Error<CommE>> {	4✔
223	self.iface.read_mag_register::<WhoAmIM>().await	4✔
224	}	4✔
225
226	/// Get measured temperature.
227	pub async fn temperature(&mut self) -> Result<Temperature, Error<CommE>> {	2✔
228	self.iface.read_accel_double_register::<Temperature>().await	2✔
229	}	2✔
230
231	/// Temperature sensor status
232	pub async fn temperature_status(&mut self) -> Result<TemperatureStatus, Error<CommE>> {	3✔
233	self.iface	3✔
234	.read_accel_register::<StatusRegAuxA>()	3✔
235	.await	3✔
236	.map(TemperatureStatus::new)	3✔
237	}	3✔
238	}

eldruin / lsm303agr-rs / 9651803572

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