//! This is a platform agnostic Rust driver for the TMP102 and TMP112
//! high-accuracy, low-power, digital temperature sensors, based on the
//! [`embedded-hal`] traits.
//!
//! [`embedded-hal`]: https://github.com/rust-embedded/embedded-hal
//!
//! This driver allows you to:
//! - Change into one-shot or continuous conversion mode.
//! - Read the temperature.
//! - Enable/disable the extended measurement mode.
//! - Trigger a one-shot measurement.
//! - Read whether the one-shot measurement result is ready.
//! - Set the conversion rate.
//! - Set the high/low temperature threshold.
//! - Set the fault queue.
//! - Set the alert polarity.
//! - Set the thermostat mode.
//! - Read whether a comparator mode alert is active.
//!
//! ## The devices
//!
//! This driver is compatible with both the TMP102 device as well as the TMP112
//! family of devices, including TMP112A, TMP112B and TMP112N.
//!
//! These temperature sensors are highly linear and do not require complex
//! calculations or lookup tables to derive the temperature. The on-chip
//! 12-bit ADC offers resolutions down to 0.0625°C.
//!
//! The TMP102 device is a digital temperature sensor ideal for NTC/PTC
//! thermistor replacement where high accuracy is required. The device offers an
//! accuracy of +/-0.5°C without requiring calibration or external component
//! signal conditioning.
//!
//! The TMP112 family of devices are digital temperature sensors designed for
//! high-accuracy, low-power, NTC/PTC thermistor replacements where high accuracy
//! is required. The TMP112A and TMP112B offers 0.5°C accuracy and are optimized
//! to provide the best PSR performance for 3.3V and 1.8V operation respectively,
//! while TMP112N offers 1°C accuracy.
//!
//! The devices feature SMBus(TM), two-wire and I2C interface compatibility,
//! and allows up to four devices on one bus.
//!
//! Datasheets:
//! - [TMP102](http://www.ti.com/lit/ds/symlink/tmp102.pdf)
//! - [TMP112x](http://www.ti.com/lit/ds/symlink/tmp112.pdf)
//!
//! ## Usage examples (see also examples folder)
//!
//! ### Read temperature in continuous mode
//!
//! Import this crate and an `embedded_hal` implementation, then instantiate
//! the device:
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let address = SlaveAddr::default();
//! // Per default the device is in continuous mode
//! let mut sensor = Tmp1x2::new(dev, address);
//! let temperature = sensor.read_temperature().unwrap();
//! println!("Temperature: {}", temperature);
//! ```
//!
//! ### Provide an alternative address
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let (a1, a0) = (false, true);
//! let address = SlaveAddr::Alternative(a1, a0);
//! let mut sensor = Tmp1x2::new(dev, address);
//! ```
//!
//! ### Change into one-shot mode and trigger a measurement
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use nb::block;
//! use tmp1x2::{Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! let mut sensor = sensor.into_one_shot().ok().expect("Mode change error");
//! let temperature = block!(sensor.read_temperature());
//! ```
//!
//! ### Get the device back if there was an error during a mode change
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{ModeChangeError, Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor_continuous = Tmp1x2::new(dev, SlaveAddr::default());
//! let result = sensor_continuous.into_one_shot();
//! if let Err(ModeChangeError::I2C(e, dev)) = result {
//! sensor_continuous = dev;
//! } else if let Ok(one_shot_sensor) = result {
//! // do something with one-shot sensor...
//! } else {
//! unreachable!();
//! }
//! ```
//!
//! ### Enable the extended measurement mode
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.enable_extended_mode().unwrap();
//! ```
//!
//! ### Set the conversion rate to 1Hz
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr, ConversionRate};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.set_conversion_rate(ConversionRate::_1Hz).unwrap();
//! ```
//!
//! ### Set the high and low temperature thresholds
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr, ConversionRate};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.set_low_temperature_threshold(-15.0).unwrap();
//! sensor.set_high_temperature_threshold(60.0).unwrap();
//! ```
//!
//! ### Set the fault queue
//!
//! This sets the number of consecutive faults that will trigger an alert.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr, FaultQueue};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.set_fault_queue(FaultQueue::_4).unwrap();
//! ```
//!
//! ### Set the alert polarity
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{ Tmp1x2, SlaveAddr, AlertPolarity };
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.set_alert_polarity(AlertPolarity::ActiveHigh).unwrap();
//! ```
//!
//! ### Set the thermostat mode
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{ Tmp1x2, SlaveAddr, ThermostatMode };
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! sensor.set_thermostat_mode(ThermostatMode::Interrupt).unwrap();
//! ```
//!
//! ### Check whether an alert is active as defined by the comparator mode
//!
//! Note that this ignores the thermostat mode setting and always refers to
//! the status as defined by the comparator mode.
//!
//! ```no_run
//! use linux_embedded_hal::I2cdev;
//! use tmp1x2::{Tmp1x2, SlaveAddr};
//!
//! let dev = I2cdev::new("/dev/i2c-1").unwrap();
//! let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());
//! let alert = sensor.is_comparator_mode_alert_active().unwrap();
//! ```
use PhantomData;
use i2c;
pub use nb;
/// Possible errors in this crate
/// Error type for mode changes.
///
/// This allows to retrieve the unchanged device in case of an error.
/// Conversion rate for continuous conversion mode
/// Fault queue
///
/// Number of consecutive faults necessary to trigger an alert.
/// Alert polarity
/// Thermostat mode
/// Possible slave addresses
const DEVICE_BASE_ADDRESS: u8 = 0b100_1000;
;
;
;
/// TMP1X2 device driver.
//impl<E> core::fmt::Debug for nb::Error<E> {}