9599236444

Committed 20 Jun 2024 02:23PM UTC coverage: 83.307% (-2.9%) from 86.196%

Build # 9599236444

Build Type

Pull #31

github

Committed by

web-flow

Commit Message

Merge 48aac2194 into 322cb031a

Pull Request Pull Request #31: implement embedded-hal-async traits using maybe-async-cfg

Run Details

103 of 131 new or added lines in 5 files covered. (78.63%)

7 existing lines in 3 files now uncovered.

529 of 635 relevant lines covered (83.31%)

2.6 hits per line

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

81.82

/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 {	7✔
17	Lsm303agr {
18	iface: I2cInterface { i2c },	7✔
19	ctrl_reg1_a: CtrlReg1A::default(),	7✔
20	ctrl_reg3_a: CtrlReg3A::default(),	7✔
21	ctrl_reg4_a: CtrlReg4A::default(),	7✔
22	ctrl_reg5_a: CtrlReg5A::default(),	7✔
23	cfg_reg_a_m: CfgRegAM::default(),	7✔
24	cfg_reg_b_m: CfgRegBM::default(),	7✔
25	cfg_reg_c_m: CfgRegCM::default(),	7✔
26	temp_cfg_reg_a: TempCfgRegA::default(),	7✔
27	fifo_ctrl_reg_a: FifoCtrlRegA::default(),	7✔
28	accel_odr: None,
29	_mag_mode: PhantomData,
30	}
31	}
32	}
33
34	impl<I2C, MODE> Lsm303agr<I2cInterface<I2C>, MODE> {
35	/// Destroy driver instance, return I2C bus.
36	pub fn destroy(self) -> I2C {	×
37	self.iface.i2c	9✔
38	}
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 {	4✔
44	Lsm303agr {
45	iface: SpiInterface {	4✔
46	spi_xl: spi_accel,
47	spi_mag,
48	},
49	ctrl_reg1_a: CtrlReg1A::default(),	4✔
50	ctrl_reg3_a: CtrlReg3A::default(),	4✔
51	ctrl_reg4_a: CtrlReg4A::default(),	4✔
52	ctrl_reg5_a: CtrlReg5A::default(),	4✔
53	cfg_reg_a_m: CfgRegAM::default(),	4✔
54	cfg_reg_b_m: CfgRegBM::default(),	4✔
55	cfg_reg_c_m: CfgRegCM::default(),	4✔
56	temp_cfg_reg_a: TempCfgRegA::default(),	4✔
57	fifo_ctrl_reg_a: FifoCtrlRegA::default(),	4✔
58	accel_odr: None,
59	_mag_mode: PhantomData,
60	}
61	}
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) {	4✔
67	(self.iface.spi_xl, self.iface.spi_mag)	4✔
68	}
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	}
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?;	4✔
90	self.ctrl_reg4_a = reg4;	2✔
91
92	Ok(())	2✔
93	}
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?;	4✔
102	self.temp_cfg_reg_a = temp_cfg_reg;	2✔
103
104	Ok(())	2✔
105	}
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?;	4✔
112	self.cfg_reg_c_m = regc;	2✔
113
114	Ok(())	2✔
115	}
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>> {	1✔
121	let mut reg5 = self.ctrl_reg5_a;	1✔
122	reg5.set(CtrlReg5A::FIFO_EN, mode != FifoMode::Bypass);	1✔
123	self.iface.write_accel_register(reg5).await?;	1✔
124	self.ctrl_reg5_a = reg5;	1✔
125
126	let fifo_ctrl = self	1✔
127	.fifo_ctrl_reg_a	×
128	.with_mode(mode)	×
129	.with_full_threshold(fth);	×
130	self.iface.write_accel_register(fifo_ctrl).await?;	2✔
131	self.fifo_ctrl_reg_a = fifo_ctrl;	1✔
132
133	Ok(())	1✔
134	}
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?;	2✔
140	self.ctrl_reg3_a = reg3;	1✔
141
142	Ok(())	1✔
143	}
144
145	/// Disable accelerometer interrupt.
146	pub async fn acc_disable_interrupt(	1✔
147	&mut self,
148	interrupt: Interrupt,
149	) -> Result<(), Error<CommE>> {
150	let reg3 = self.ctrl_reg3_a.without_interrupt(interrupt);	1✔
151	self.iface.write_accel_register(reg3).await?;	2✔
152	self.ctrl_reg3_a = reg3;	1✔
153
154	Ok(())	1✔
155	}
156
157	/// Configure the DRDY pin as a digital output.
NEW 158	pub async fn mag_enable_int(&mut self) -> Result<(), Error<CommE>> {	×
159	let regc = self.cfg_reg_c_m \| CfgRegCM::INT_MAG;	×
NEW 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?;	2✔
170	self.cfg_reg_b_m = regb;	1✔
171
172	Ok(())	1✔
173	}
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?;	2✔
179	self.cfg_reg_b_m = regb;	1✔
180
181	Ok(())	1✔
182	}
183
184	/// Accelerometer status
185	pub async fn accel_status(&mut self) -> Result<Status, Error<CommE>> {	1✔
186	self.iface	1✔
187	.read_accel_register::<StatusRegA>()
NEW 188	.await	×
UNCOV 189	.map(Status::new)	×
190	}
191
192	/// Get measured acceleration.
193	pub async fn acceleration(&mut self) -> Result<Acceleration, Error<CommE>> {	2✔
194	let (x, y, z) = self	2✔
NEW 195	.iface	×
196	.read_accel_3_double_registers::<Acceleration>()
NEW 197	.await?;	×
198
199	Ok(Acceleration {	2✔
200	x,	×
201	y,	×
202	z,	×
203	mode: self.get_accel_mode().await,	2✔
204	scale: self.get_accel_scale().await,	2✔
205	})
206	}
207
208	/// Magnetometer status
209	pub async fn mag_status(&mut self) -> Result<Status, Error<CommE>> {	2✔
210	self.iface	2✔
211	.read_mag_register::<StatusRegM>()
NEW 212	.await	×
UNCOV 213	.map(Status::new)	×
214	}
215
216	/// Get the accelerometer device ID.
217	pub async fn accelerometer_id(&mut self) -> Result<AccelerometerId, Error<CommE>> {	2✔
218	self.iface.read_accel_register::<WhoAmIA>().await	2✔
219	}
220
221	/// Get the magnetometer device ID.
222	pub async fn magnetometer_id(&mut self) -> Result<MagnetometerId, Error<CommE>> {	2✔
223	self.iface.read_mag_register::<WhoAmIM>().await	2✔
224	}
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	}
230
231	/// Temperature sensor status
232	pub async fn temperature_status(&mut self) -> Result<TemperatureStatus, Error<CommE>> {	1✔
233	self.iface	1✔
234	.read_accel_register::<StatusRegAuxA>()
NEW 235	.await	×
UNCOV 236	.map(TemperatureStatus::new)	×
237	}
238	}

eldruin / lsm303agr-rs / 9599236444

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