sps30_i2c/
sps30.rs

1use crate::register_access::sps30::{DEV_ADDR, Register, StatusRegisterBits};
2use crate::Sps30;
3use crate::types::{AirInfo, Error, StatusRegisterResult};
4use byteorder::{BigEndian, ByteOrder};
5use embedded_hal::blocking::{delay, i2c};
6
7impl<I2C, D, E> Sps30<I2C, D>
8where I2C: i2c::Read<Error = E> + i2c::Write<Error = E>,
9D: delay::DelayMs<u8> {
10    /// Create new instance of the SPS30 device
11    pub fn new_sps30(i2c: I2C, delay: D) -> Self {
12        Sps30 {
13            i2c,
14            delay,
15            address: DEV_ADDR,
16        }
17    }
18
19    /// Destory driver instance
20    pub fn destroy(self) -> I2C {
21        self.i2c
22    }
23
24    /// Enter measurement mode
25    /// Command execution time: 20 ms
26    pub fn start_measurement(&mut self) -> Result<(), Error<E>> {
27        let mut data: [u8; 5] = [0; 5];
28        data[..2].clone_from_slice(&Register::START_MEASUREMENT[..2]);
29        data[2] = 0x03;
30    
31        self.write_data(&mut data)?;
32        self.delay.delay_ms(20);
33
34        Ok(())
35    }
36
37    /// Exit measurement mode
38    /// Command execution time: 20 ms
39    pub fn stop_measurement(&mut self) -> Result<(), Error<E>> {
40        let mut data: [u8; 2] = Register::STOP_MEASUREMENT;
41
42        self.write_data(&mut data)?;
43        self.delay.delay_ms(20);
44
45        Ok(())
46    }
47
48    /// Poll for the availability of new measurements
49    /// Command execution time: -
50    pub fn read_data_ready_flag(&mut self) -> Result<bool, Error<E>> {
51        let mut data: [u8; 2] = Register::READ_DATA_READY_FLAG;
52        self.write_data(&mut data)?;
53
54        let mut buffer: [u8; 3] = [0; 3];
55        self.read_data(&mut buffer)?;
56
57        if buffer[1] == 0 {
58            Ok(false)
59        } else {
60            Ok(true)
61        }
62    }
63
64    /// Read the measured values
65    /// Command execution time: -
66    pub fn read_measured_values(&mut self) -> Result<AirInfo, Error<E>> {
67        let mut data: [u8; 2] = Register::READ_MEASURED_VALUES;
68        self.write_data(&mut data)?;
69
70        let mut buffer: [u8; 60] = [0; 60];
71        self.read_data(&mut buffer)?;
72
73        let air_info: AirInfo = AirInfo {
74            mass_pm1_0: BigEndian::read_f32(&buffer[0..]),
75            mass_pm2_5: BigEndian::read_f32(&buffer[4..]), 
76            mass_pm4_0: BigEndian::read_f32(&buffer[4 * 2..]),
77            mass_pm10: BigEndian::read_f32(&buffer[4 * 3..]),
78            number_pm0_5: BigEndian::read_f32(&buffer[4 * 4..]),
79            number_pm1_0: BigEndian::read_f32(&buffer[4 * 5..]),
80            number_pm2_5: BigEndian::read_f32(&buffer[4 * 6..]),
81            number_pm4_0: BigEndian::read_f32(&buffer[4 * 7..]),
82            number_pm10: BigEndian::read_f32(&buffer[4 * 8..]),
83            typical_size: BigEndian::read_f32(&buffer[4 * 9..]),
84        };
85
86        Ok(air_info)
87    }
88    
89    /// Enter sleep mode
90    /// Command execution time: 5 ms
91    pub fn sleep(&mut self) -> Result<(), Error<E>> {
92        let mut data: [u8; 2] = Register::SLEEP;
93
94        self.write_data(&mut data)?;
95        self.delay.delay_ms(5);
96
97        Ok(())
98    }
99
100    /// Exit sleep mode
101    /// Command execution time: 5 ms
102    pub fn wake_up(&mut self) -> Result<(), Error<E>> {
103        let mut data: [u8; 2] = Register::WAKE_UP;
104    
105        self.write_data(&mut [])?;
106        self.write_data(&mut data)?;
107        self.delay.delay_ms(5);
108
109        Ok(())
110    }
111
112    /// Start the fan-cleaning manually
113    /// This commmand can only be executed in Measurement-Mode
114    /// Command execution time: 5 ms
115    pub fn start_fan_cleaning(&mut self) -> Result<(), Error<E>> {
116        let mut data: [u8; 2] = Register::START_FAN_CLEANING;
117
118        self.write_data(&mut data)?;
119        self.delay.delay_ms(5);
120
121        Ok(())
122    }
123
124    /// Read the interval[s] of the periodic fan-cleaning
125    /// Command execution time: 5 ms
126    pub fn read_auto_cleaning_interval(&mut self) -> Result<u32, Error<E>> {
127        let mut data: [u8; 2] = Register::READ_WRITE_AUTO_CLEANING_INTERVAL;
128
129        self.write_data(&mut data)?;
130        self.delay.delay_ms(5);
131
132        let mut buffer: [u8; 6] = [0; 6];
133        self.read_data(&mut buffer)?;
134
135        Ok(BigEndian::read_u32(&buffer))
136    }
137
138    /// Write the interval[s] of the periodic fan-cleaning
139    /// Command execution time: 20 ms
140    pub fn write_auto_cleaning_interval(&mut self, n: u32) -> Result<(), Error<E>> {
141        let mut data: [u8; 8] = [0; 8];
142        data[..2].clone_from_slice(&Register::READ_WRITE_AUTO_CLEANING_INTERVAL[..2]);
143        BigEndian::write_u32(&mut data[2..], n);
144
145        self.write_data(&mut data)?;
146        self.delay.delay_ms(20);
147
148        Ok(())
149    }
150
151    /// Read device product type
152    /// Command execution time: -
153    pub fn read_device_product_type(&mut self) -> Result<[u8; 8], Error<E>> {
154        let mut data: [u8; 2] = Register::READ_DEVICE_PRODUCT_TYPE;
155        self.write_data(&mut data)?;
156
157        let mut buffer: [u8; 12] = [0; 12];
158        self.read_data(&mut buffer)?;
159        
160        let mut res: [u8; 8] = [0; 8];
161        res[..8].clone_from_slice(&buffer[..8]);
162
163        Ok(res)
164    }
165
166    /// Read device serial number
167    /// Command execution time: -
168    pub fn read_device_serial_number(&mut self) -> Result<[u8; 32], Error<E>> {
169        let mut data: [u8; 2] = Register::READ_DEVICE_SERIAL_NUMBER;
170        self.write_data(&mut data)?;
171
172        let mut buffer: [u8; 48] = [0; 48];
173        self.read_data(&mut buffer)?;
174
175        let mut res: [u8; 32] = [0; 32];
176        res[..32].clone_from_slice(&buffer[..32]);
177
178        Ok(res)
179    }
180
181    /// Read firmware version
182    /// Command execution time: -
183    pub fn read_firmware_version(&mut self) -> Result<(u8, u8), Error<E>> {
184        let mut data: [u8; 2] = Register::READ_FIRMWARE_VERSION;
185        self.write_data(&mut data)?;
186
187        let mut buffer: [u8; 3] = [0; 3];
188        self.read_data(&mut buffer)?;
189
190        Ok((buffer[0], buffer[1]))
191    }
192
193    /// Read device status register
194    /// Command execution time: -
195    pub fn read_device_status_register(&mut self) -> Result<StatusRegisterResult, Error<E>> {
196        let mut data: [u8; 2] = Register::READ_DEVICE_STATUS_REGISTER;
197        self.write_data(&mut data)?;
198
199        let mut buffer: [u8; 6] = [0; 6];
200        self.read_data(&mut buffer)?;
201
202        let res = BigEndian::read_u32(&buffer);
203
204        let status_speed: bool = {
205            (res & StatusRegisterBits::SPEED) != 0
206        };
207
208        let status_laser: bool = {
209            (res & StatusRegisterBits::LASER) != 0
210        };
211
212        let status_fan: bool = {
213            (res & StatusRegisterBits::FAN) != 0
214        };
215
216        Ok(StatusRegisterResult{
217            speed: status_speed,
218            laser: status_laser,
219            fan: status_fan,
220        })
221    }
222
223    /// Clear device status register
224    /// Command execution time: 5 ms
225    pub fn clear_device_status_register(&mut self) -> Result<(), Error<E>> {
226        let mut data: [u8; 2] = Register::CLEAR_DEVICE_STATUS_REGISTER;
227
228        self.write_data(&mut data)?;
229        self.delay.delay_ms(5);
230
231        Ok(())
232    }
233
234    /// Reset the device
235    /// Command execution time: 100 ms
236    pub fn device_reset(&mut self) -> Result<(), Error<E>> {
237        let mut data: [u8; 2] = Register::DEVICE_RESET;
238
239        self.write_data(&mut data)?;
240        self.delay.delay_ms(100);
241        
242        Ok(())
243    }
244}
sps30_i2c/sps30.rs

sps30_i2c/
sps30.rs
