tinkerforge_async/bindings/
co2_bricklet.rs

1/* ***********************************************************
2 * This file was automatically generated on 2024-02-16.      *
3 *                                                           *
4 * Rust Bindings Version 2.0.20                              *
5 *                                                           *
6 * If you have a bugfix for this file and want to commit it, *
7 * please fix the bug in the generator. You can find a link  *
8 * to the generators git repository on tinkerforge.com       *
9 *************************************************************/
10
11//! Measures CO2 concentration in ppm.
12//!
13//! See also the documentation [here](https://www.tinkerforge.com/en/doc/Software/Bricklets/CO2_Bricklet_Rust.html).
14#[allow(unused_imports)]
15use crate::{
16    base58::Uid, byte_converter::*, device::*, error::TinkerforgeError, ip_connection::async_io::AsyncIpConnection,
17    low_level_traits::LowLevelRead,
18};
19#[allow(unused_imports)]
20use futures_core::Stream;
21#[allow(unused_imports)]
22use tokio_stream::StreamExt;
23pub enum Co2BrickletFunction {
24    GetCo2Concentration,
25    SetCo2ConcentrationCallbackPeriod,
26    GetCo2ConcentrationCallbackPeriod,
27    SetCo2ConcentrationCallbackThreshold,
28    GetCo2ConcentrationCallbackThreshold,
29    SetDebouncePeriod,
30    GetDebouncePeriod,
31    GetIdentity,
32    CallbackCo2Concentration,
33    CallbackCo2ConcentrationReached,
34}
35impl From<Co2BrickletFunction> for u8 {
36    fn from(fun: Co2BrickletFunction) -> Self {
37        match fun {
38            Co2BrickletFunction::GetCo2Concentration => 1,
39            Co2BrickletFunction::SetCo2ConcentrationCallbackPeriod => 2,
40            Co2BrickletFunction::GetCo2ConcentrationCallbackPeriod => 3,
41            Co2BrickletFunction::SetCo2ConcentrationCallbackThreshold => 4,
42            Co2BrickletFunction::GetCo2ConcentrationCallbackThreshold => 5,
43            Co2BrickletFunction::SetDebouncePeriod => 6,
44            Co2BrickletFunction::GetDebouncePeriod => 7,
45            Co2BrickletFunction::GetIdentity => 255,
46            Co2BrickletFunction::CallbackCo2Concentration => 8,
47            Co2BrickletFunction::CallbackCo2ConcentrationReached => 9,
48        }
49    }
50}
51pub const CO2_BRICKLET_THRESHOLD_OPTION_OFF: char = 'x';
52pub const CO2_BRICKLET_THRESHOLD_OPTION_OUTSIDE: char = 'o';
53pub const CO2_BRICKLET_THRESHOLD_OPTION_INSIDE: char = 'i';
54pub const CO2_BRICKLET_THRESHOLD_OPTION_SMALLER: char = '<';
55pub const CO2_BRICKLET_THRESHOLD_OPTION_GREATER: char = '>';
56
57#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
58pub struct Co2ConcentrationCallbackThreshold {
59    pub option: char,
60    pub min: u16,
61    pub max: u16,
62}
63impl FromByteSlice for Co2ConcentrationCallbackThreshold {
64    fn bytes_expected() -> usize {
65        5
66    }
67    fn from_le_byte_slice(bytes: &[u8]) -> Co2ConcentrationCallbackThreshold {
68        Co2ConcentrationCallbackThreshold {
69            option: <char>::from_le_byte_slice(&bytes[0..1]),
70            min: <u16>::from_le_byte_slice(&bytes[1..3]),
71            max: <u16>::from_le_byte_slice(&bytes[3..5]),
72        }
73    }
74}
75
76#[derive(Clone, Debug, Default, PartialEq, Eq, Hash)]
77pub struct Identity {
78    pub uid: String,
79    pub connected_uid: String,
80    pub position: char,
81    pub hardware_version: [u8; 3],
82    pub firmware_version: [u8; 3],
83    pub device_identifier: u16,
84}
85impl FromByteSlice for Identity {
86    fn bytes_expected() -> usize {
87        25
88    }
89    fn from_le_byte_slice(bytes: &[u8]) -> Identity {
90        Identity {
91            uid: <String>::from_le_byte_slice(&bytes[0..8]),
92            connected_uid: <String>::from_le_byte_slice(&bytes[8..16]),
93            position: <char>::from_le_byte_slice(&bytes[16..17]),
94            hardware_version: <[u8; 3]>::from_le_byte_slice(&bytes[17..20]),
95            firmware_version: <[u8; 3]>::from_le_byte_slice(&bytes[20..23]),
96            device_identifier: <u16>::from_le_byte_slice(&bytes[23..25]),
97        }
98    }
99}
100
101/// Measures CO2 concentration in ppm
102#[derive(Clone)]
103pub struct Co2Bricklet {
104    device: Device,
105}
106impl Co2Bricklet {
107    pub const DEVICE_IDENTIFIER: u16 = 262;
108    pub const DEVICE_DISPLAY_NAME: &'static str = "CO2 Bricklet";
109    /// Creates an object with the unique device ID `uid`. This object can then be used after the IP Connection `ip_connection` is connected.
110    pub fn new(uid: Uid, connection: AsyncIpConnection) -> Co2Bricklet {
111        let mut result = Co2Bricklet { device: Device::new([2, 0, 10], uid, connection, Self::DEVICE_DISPLAY_NAME) };
112        result.device.response_expected[u8::from(Co2BrickletFunction::GetCo2Concentration) as usize] = ResponseExpectedFlag::AlwaysTrue;
113        result.device.response_expected[u8::from(Co2BrickletFunction::SetCo2ConcentrationCallbackPeriod) as usize] =
114            ResponseExpectedFlag::True;
115        result.device.response_expected[u8::from(Co2BrickletFunction::GetCo2ConcentrationCallbackPeriod) as usize] =
116            ResponseExpectedFlag::AlwaysTrue;
117        result.device.response_expected[u8::from(Co2BrickletFunction::SetCo2ConcentrationCallbackThreshold) as usize] =
118            ResponseExpectedFlag::True;
119        result.device.response_expected[u8::from(Co2BrickletFunction::GetCo2ConcentrationCallbackThreshold) as usize] =
120            ResponseExpectedFlag::AlwaysTrue;
121        result.device.response_expected[u8::from(Co2BrickletFunction::SetDebouncePeriod) as usize] = ResponseExpectedFlag::True;
122        result.device.response_expected[u8::from(Co2BrickletFunction::GetDebouncePeriod) as usize] = ResponseExpectedFlag::AlwaysTrue;
123        result.device.response_expected[u8::from(Co2BrickletFunction::GetIdentity) as usize] = ResponseExpectedFlag::AlwaysTrue;
124        result
125    }
126
127    /// Returns the response expected flag for the function specified by the function ID parameter.
128    /// It is true if the function is expected to send a response, false otherwise.
129    ///
130    /// For getter functions this is enabled by default and cannot be disabled, because those
131    /// functions will always send a response. For callback configuration functions it is enabled
132    /// by default too, but can be disabled by [`set_response_expected`](crate::co2_bricklet::Co2Bricklet::set_response_expected).
133    /// For setter functions it is disabled by default and can be enabled.
134    ///
135    /// Enabling the response expected flag for a setter function allows to detect timeouts
136    /// and other error conditions calls of this setter as well. The device will then send a response
137    /// for this purpose. If this flag is disabled for a setter function then no response is sent
138    /// and errors are silently ignored, because they cannot be detected.
139    ///
140    /// See [`set_response_expected`](crate::co2_bricklet::Co2Bricklet::set_response_expected) for the list of function ID constants available for this function.
141    pub fn get_response_expected(&mut self, fun: Co2BrickletFunction) -> Result<bool, GetResponseExpectedError> {
142        self.device.get_response_expected(u8::from(fun))
143    }
144
145    /// Changes the response expected flag of the function specified by the function ID parameter.
146    /// This flag can only be changed for setter (default value: false) and callback configuration
147    /// functions (default value: true). For getter functions it is always enabled.
148    ///
149    /// Enabling the response expected flag for a setter function allows to detect timeouts and
150    /// other error conditions calls of this setter as well. The device will then send a response
151    /// for this purpose. If this flag is disabled for a setter function then no response is sent
152    /// and errors are silently ignored, because they cannot be detected.
153    pub fn set_response_expected(&mut self, fun: Co2BrickletFunction, response_expected: bool) -> Result<(), SetResponseExpectedError> {
154        self.device.set_response_expected(u8::from(fun), response_expected)
155    }
156
157    /// Changes the response expected flag for all setter and callback configuration functions of this device at once.
158    pub fn set_response_expected_all(&mut self, response_expected: bool) {
159        self.device.set_response_expected_all(response_expected)
160    }
161
162    /// Returns the version of the API definition (major, minor, revision) implemented by this API bindings.
163    /// This is neither the release version of this API bindings nor does it tell you anything about the represented Brick or Bricklet.
164    pub fn get_api_version(&self) -> [u8; 3] {
165        self.device.api_version
166    }
167
168    /// This receiver is triggered periodically with the period that is set by
169    /// [`set_co2_concentration_callback_period`]. The parameter is the CO2
170    /// concentration of the sensor.
171    ///
172    /// The [`get_co2_concentration_callback_receiver`] receiver is only triggered if the CO2 concentration
173    /// has changed since the last triggering.
174    ///
175    /// [`set_co2_concentration_callback_period`]: #method.set_co2_concentration_callback_period
176    /// [`get_co2_concentration_callback_receiver`]: #method.get_co2_concentration_callback_receiver
177    pub async fn get_co2_concentration_callback_receiver(&mut self) -> impl Stream<Item = u16> {
178        self.device
179            .get_callback_receiver(u8::from(Co2BrickletFunction::CallbackCo2Concentration))
180            .await
181            .map(|p| u16::from_le_byte_slice(p.body()))
182    }
183
184    /// This receiver is triggered when the threshold as set by
185    /// [`set_co2_concentration_callback_threshold`] is reached.
186    /// The parameter is the CO2 concentration.
187    ///
188    /// If the threshold keeps being reached, the receiver is triggered periodically
189    /// with the period as set by [`set_debounce_period`].
190    pub async fn get_co2_concentration_reached_callback_receiver(&mut self) -> impl Stream<Item = u16> {
191        self.device
192            .get_callback_receiver(u8::from(Co2BrickletFunction::CallbackCo2ConcentrationReached))
193            .await
194            .map(|p| u16::from_le_byte_slice(p.body()))
195    }
196
197    /// Returns the measured CO2 concentration.
198    ///
199    /// If you want to get the CO2 concentration periodically, it is recommended to use
200    /// the [`get_co2_concentration_callback_receiver`] receiver and set the period with
201    /// [`set_co2_concentration_callback_period`].
202    pub async fn get_co2_concentration(&mut self) -> Result<u16, TinkerforgeError> {
203        let payload = [0; 0];
204
205        #[allow(unused_variables)]
206        let result = self.device.get(u8::from(Co2BrickletFunction::GetCo2Concentration), &payload).await?;
207        Ok(u16::from_le_byte_slice(result.body()))
208    }
209
210    /// Sets the period with which the [`get_co2_concentration_callback_receiver`] receiver is
211    /// triggered periodically. A value of 0 turns the receiver off.
212    ///
213    /// The [`get_co2_concentration_callback_receiver`] receiver is only triggered if the CO2 concentration
214    /// has changed since the last triggering.
215    pub async fn set_co2_concentration_callback_period(&mut self, period: u32) -> Result<(), TinkerforgeError> {
216        let mut payload = [0; 4];
217        period.write_to_slice(&mut payload[0..4]);
218
219        #[allow(unused_variables)]
220        let result = self.device.set(u8::from(Co2BrickletFunction::SetCo2ConcentrationCallbackPeriod), &payload).await?;
221        Ok(())
222    }
223
224    /// Returns the period as set by [`set_co2_concentration_callback_period`].
225    pub async fn get_co2_concentration_callback_period(&mut self) -> Result<u32, TinkerforgeError> {
226        let payload = [0; 0];
227
228        #[allow(unused_variables)]
229        let result = self.device.get(u8::from(Co2BrickletFunction::GetCo2ConcentrationCallbackPeriod), &payload).await?;
230        Ok(u32::from_le_byte_slice(result.body()))
231    }
232
233    /// Sets the thresholds for the [`get_co2_concentration_reached_callback_receiver`] receiver.
234    ///
235    /// The following options are possible:
236    ///
237    ///  Option| Description
238    ///  --- | ---
239    ///  'x'|    Receiver is turned off
240    ///  'o'|    Receiver is triggered when the CO2 concentration is *outside* the min and max values
241    ///  'i'|    Receiver is triggered when the CO2 concentration is *inside* the min and max values
242    ///  '<'|    Receiver is triggered when the CO2 concentration is smaller than the min value (max is ignored)
243    ///  '>'|    Receiver is triggered when the CO2 concentration is greater than the min value (max is ignored)
244    ///
245    /// Associated constants:
246    /// * CO2_BRICKLET_THRESHOLD_OPTION_OFF
247    ///	* CO2_BRICKLET_THRESHOLD_OPTION_OUTSIDE
248    ///	* CO2_BRICKLET_THRESHOLD_OPTION_INSIDE
249    ///	* CO2_BRICKLET_THRESHOLD_OPTION_SMALLER
250    ///	* CO2_BRICKLET_THRESHOLD_OPTION_GREATER
251    pub async fn set_co2_concentration_callback_threshold(&mut self, option: char, min: u16, max: u16) -> Result<(), TinkerforgeError> {
252        let mut payload = [0; 5];
253        option.write_to_slice(&mut payload[0..1]);
254        min.write_to_slice(&mut payload[1..3]);
255        max.write_to_slice(&mut payload[3..5]);
256
257        #[allow(unused_variables)]
258        let result = self.device.set(u8::from(Co2BrickletFunction::SetCo2ConcentrationCallbackThreshold), &payload).await?;
259        Ok(())
260    }
261
262    /// Returns the threshold as set by [`set_co2_concentration_callback_threshold`].
263    ///
264    /// Associated constants:
265    /// * CO2_BRICKLET_THRESHOLD_OPTION_OFF
266    ///	* CO2_BRICKLET_THRESHOLD_OPTION_OUTSIDE
267    ///	* CO2_BRICKLET_THRESHOLD_OPTION_INSIDE
268    ///	* CO2_BRICKLET_THRESHOLD_OPTION_SMALLER
269    ///	* CO2_BRICKLET_THRESHOLD_OPTION_GREATER
270    pub async fn get_co2_concentration_callback_threshold(&mut self) -> Result<Co2ConcentrationCallbackThreshold, TinkerforgeError> {
271        let payload = [0; 0];
272
273        #[allow(unused_variables)]
274        let result = self.device.get(u8::from(Co2BrickletFunction::GetCo2ConcentrationCallbackThreshold), &payload).await?;
275        Ok(Co2ConcentrationCallbackThreshold::from_le_byte_slice(result.body()))
276    }
277
278    /// Sets the period with which the threshold receivers
279    ///
280    /// * [`get_co2_concentration_reached_callback_receiver`],
281    ///
282    /// are triggered, if the thresholds
283    ///
284    /// * [`set_co2_concentration_callback_threshold`],
285    ///
286    /// keep being reached.
287    pub async fn set_debounce_period(&mut self, debounce: u32) -> Result<(), TinkerforgeError> {
288        let mut payload = [0; 4];
289        debounce.write_to_slice(&mut payload[0..4]);
290
291        #[allow(unused_variables)]
292        let result = self.device.set(u8::from(Co2BrickletFunction::SetDebouncePeriod), &payload).await?;
293        Ok(())
294    }
295
296    /// Returns the debounce period as set by [`set_debounce_period`].
297    pub async fn get_debounce_period(&mut self) -> Result<u32, TinkerforgeError> {
298        let payload = [0; 0];
299
300        #[allow(unused_variables)]
301        let result = self.device.get(u8::from(Co2BrickletFunction::GetDebouncePeriod), &payload).await?;
302        Ok(u32::from_le_byte_slice(result.body()))
303    }
304
305    /// Returns the UID, the UID where the Bricklet is connected to,
306    /// the position, the hardware and firmware version as well as the
307    /// device identifier.
308    ///
309    /// The position can be 'a', 'b', 'c', 'd', 'e', 'f', 'g' or 'h' (Bricklet Port).
310    /// A Bricklet connected to an [Isolator Bricklet](isolator_bricklet) is always at
311    /// position 'z'.
312    ///
313    /// The device identifier numbers can be found [here](device_identifier).
314    /// |device_identifier_constant|
315    pub async fn get_identity(&mut self) -> Result<Identity, TinkerforgeError> {
316        let payload = [0; 0];
317
318        #[allow(unused_variables)]
319        let result = self.device.get(u8::from(Co2BrickletFunction::GetIdentity), &payload).await?;
320        Ok(Identity::from_le_byte_slice(result.body()))
321    }
322}
tinkerforge_async/bindings/co2_bricklet.rs

tinkerforge_async/bindings/
co2_bricklet.rs
