### Implementing Temperature Monitoring in Rust

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

A complete application example demonstrating sensor initialization, alert threshold configuration, and a continuous monitoring loop.

```rust
use linux_embedded_hal::I2cdev;
use nb::block;
use tmp1x2::{
    AlertPolarity, ConversionRate, FaultQueue, SlaveAddr,
    ThermostatMode, Tmp1x2
};

fn main() {
    // Initialize sensor on I2C bus
    let dev = I2cdev::new("/dev/i2c-1").unwrap();
    let mut sensor = Tmp1x2::new(dev, SlaveAddr::default());

    // Configure alert system for thermal protection
    sensor.set_high_temperature_threshold(75.0).unwrap();
    sensor.set_low_temperature_threshold(10.0).unwrap();
    sensor.set_fault_queue(FaultQueue::_2).unwrap();
    sensor.set_alert_polarity(AlertPolarity::ActiveLow).unwrap();
    sensor.set_thermostat_mode(ThermostatMode::Comparator).unwrap();
    sensor.set_conversion_rate(ConversionRate::_1Hz).unwrap();

    // Continuous monitoring loop
    loop {
        let temp = sensor.read_temperature().unwrap();
        let alert = sensor.is_comparator_mode_alert_active().unwrap();

        println!("Temperature: {:.2}°C {}", temp,
            if alert { "[ALERT]" } else { "" });

        std::thread::sleep(std::time::Duration::from_secs(1));
    }
}
```

--------------------------------

### Initialize TMP1x2 Sensor Instance

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Initialize a TMP1x2 sensor with either the default I2C address (0x48) or an alternative address. The device starts in continuous conversion mode by default.

```rust
use linux_embedded_hal::I2cdev;
use tmp1x2::{Tmp1x2, SlaveAddr};

// Using the default I2C address (0x48)
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::default();
let mut sensor = Tmp1x2::new(dev, address);

// Using an alternative address (A1=false, A0=true gives 0x49)
let dev2 = I2cdev::new("/dev/i2c-1").unwrap();
let alt_address = SlaveAddr::Alternative(false, true);
let mut sensor2 = Tmp1x2::new(dev2, alt_address);

// Alternative addresses available:
// SlaveAddr::Alternative(false, false) -> 0x48 (same as default)
// SlaveAddr::Alternative(false, true)  -> 0x49
// SlaveAddr::Alternative(true, false)  -> 0x4A
// SlaveAddr::Alternative(true, true)   -> 0x4B
```

--------------------------------

### Read temperature with TMP1x2

Source: https://github.com/eldruin/tmp1x2-rs/blob/master/README.md

Initializes the sensor on an I2C bus and performs a temperature reading.

```rust
use linux_embedded_hal::I2cdev;
use tmp1x2::{Tmp1x2, SlaveAddr};

fn main() {
    let dev = I2cdev::new("/dev/i2c-1").unwrap();
    let address = SlaveAddr::default();
    let mut sensor = Tmp1x2::new(dev, address);
    let temperature = sensor.read_temperature().unwrap();
    println!("Temperature: {:.1}ºC", temperature);
}
```

--------------------------------

### Configure Thermostat Mode for TMP1x2

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Selects between comparator mode (hysteresis) for applications like fan control, and interrupt mode for event-driven systems. Comparator mode uses separate high and low thresholds for activation and deactivation.

```rust
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());

// Comparator mode (default) - hysteresis behavior
// Alert activates when temp >= high threshold
// Alert deactivates when temp < low threshold
sensor.set_thermostat_mode(ThermostatMode::Comparator).unwrap();

// Interrupt mode - edge-triggered behavior
// Alert activates when temp exceeds high OR falls below low
// Alert clears after reading temperature register
sensor.set_thermostat_mode(ThermostatMode::Interrupt).unwrap();

// Example: Fan control with hysteresis
sensor.set_thermostat_mode(ThermostatMode::Comparator).unwrap();
sensor.set_high_temperature_threshold(45.0).unwrap(); // Fan ON at 45°C
sensor.set_low_temperature_threshold(35.0).unwrap();  // Fan OFF at 35°C
```

--------------------------------

### Set Temperature Thresholds and Check Alerts for TMP1x2

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Configures high and low temperature thresholds to trigger alerts. It also checks if an alert is currently active, indicating the temperature is outside the set thresholds.

```rust
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());

// Set temperature thresholds (in degrees Celsius)
sensor.set_high_temperature_threshold(60.0).unwrap();  // Alert if temp >= 60°C
sensor.set_low_temperature_threshold(-15.0).unwrap();  // Alert if temp <= -15°C

// Values are clamped to valid ranges:
// Normal mode:   [-128.0, 127.9375]
// Extended mode: [-256.0, 255.875]

// Check if alert is currently active
let alert_active = sensor.is_comparator_mode_alert_active().unwrap();
if alert_active {
    println!("Temperature alert! Outside threshold range.");
}
```

--------------------------------

### Configure Alert Polarity for TMP1x2

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Sets the alert output pin to be active-high or active-low to match specific hardware requirements. The default is ActiveLow.

```rust
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());

// Set alert pin polarity
sensor.set_alert_polarity(AlertPolarity::ActiveLow).unwrap();  // Default - alert pulls low
sensor.set_alert_polarity(AlertPolarity::ActiveHigh).unwrap(); // Alert drives high

// ActiveLow:  Alert pin is LOW when alert condition is true
// ActiveHigh: Alert pin is HIGH when alert condition is true
```

--------------------------------

### Set Temperature Conversion Rate

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Configure the temperature conversion rate for continuous mode. Lower rates reduce power consumption while higher rates provide more responsive readings. Power consumption scales with conversion rate; use slower rates for battery-powered applications.

```rust
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());

// Available conversion rates:
sensor.set_conversion_rate(ConversionRate::_0_25Hz).unwrap(); // 0.25 Hz (lowest power)
sensor.set_conversion_rate(ConversionRate::_1Hz).unwrap();    // 1 Hz
sensor.set_conversion_rate(ConversionRate::_4Hz).unwrap();    // 4 Hz (default)
sensor.set_conversion_rate(ConversionRate::_8Hz).unwrap();    // 8 Hz (fastest response)

// Power consumption scales with conversion rate
// Use slower rates for battery-powered applications
```

--------------------------------

### Enable Extended Measurement Mode for TMP1x2

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Enables extended mode to measure temperatures above 128°C, up to 255.875°C, using 13-bit resolution. Remember to disable it when returning to the normal range.

```rust
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());

// Enable extended mode for high temperature applications
sensor.enable_extended_mode().unwrap();

// Now can read temperatures up to 255.875°C
let high_temp = sensor.read_temperature().unwrap();
println!("High temperature: {:.2}°C", high_temp);

// Disable extended mode to return to normal range
sensor.disable_extended_mode().unwrap();

// Temperature ranges:
// Normal mode:   -128.0°C to +127.9375°C (12-bit)
// Extended mode: -256.0°C to +255.875°C  (13-bit)
```

--------------------------------

### One-Shot Conversion Mode for Power Efficiency

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Switch to one-shot mode for power-efficient measurements. The sensor enters shutdown state between measurements. Uses non-blocking `nb` crate semantics for async-compatible polling. Handle mode change errors gracefully by checking the result of `into_one_shot` and `into_continuous`.

```rust
use linux_embedded_hal::I2cdev;
use nb::block;
use tmp1x2::{Tmp1x2, SlaveAddr, ModeChangeError};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let sensor = Tmp1x2::new(dev, SlaveAddr::default());

// Switch to one-shot mode (consumes and returns new sensor instance)
let mut sensor = sensor.into_one_shot().ok().expect("Mode change error");

// Trigger measurement and block until complete
// First call triggers conversion, subsequent calls poll until ready
let temperature = block!(sensor.read_temperature()).unwrap();
println!("One-shot temperature: {:.2}°C", temperature);

// Switch back to continuous mode if needed
let sensor = sensor.into_continuous().ok().expect("Mode change error");

// Handle mode change errors gracefully
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 {
    // Get the unchanged device back on error
    sensor_continuous = dev;
    println!("Mode change failed: {:?}", e);
}
```

--------------------------------

### Resetting Driver State in Rust

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Synchronizes the driver's internal state with the device after an external hardware reset.

```rust
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());

// After performing an external reset on the device
// (e.g., I2C general-call reset)
sensor.reset_internal_driver_state();

// Driver's cached configuration now matches device defaults
// This ensures subsequent operations work correctly
```

--------------------------------

### Configure Fault Queue for TMP1x2 Alerts

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Sets the number of consecutive out-of-range readings required to trigger an alert, helping to filter out transient noise and prevent false alarms. Higher values offer more noise immunity but slower response.

```rust
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());

// Set number of consecutive faults required to trigger alert
sensor.set_fault_queue(FaultQueue::_1).unwrap(); // 1 fault (default, most sensitive)
sensor.set_fault_queue(FaultQueue::_2).unwrap(); // 2 consecutive faults
sensor.set_fault_queue(FaultQueue::_4).unwrap(); // 4 consecutive faults
sensor.set_fault_queue(FaultQueue::_6).unwrap(); // 6 consecutive faults (most filtering)

// Higher fault queue values provide better noise immunity
// but slower response to actual temperature excursions
```

--------------------------------

### Release I2C Bus from TMP1x2 Driver

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Releases the underlying I2C device from the TMP1x2 driver, allowing the bus to be shared with other devices or for resource cleanup. The released device can be reused.

```rust
use linux_embedded_hal::I2cdev;
use tmp1x2::{Tmp1x2, SlaveAddr};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let sensor = Tmp1x2::new(dev, SlaveAddr::default());

// ... use the sensor ...

// Release the I2C device when done
let i2c_device = sensor.destroy();
// i2c_device can now be used for other purposes or reused
```

--------------------------------

### Read Temperature in Continuous Mode

Source: https://context7.com/eldruin/tmp1x2-rs/llms.txt

Read the current temperature in continuous conversion mode. The sensor automatically performs measurements at the configured conversion rate (default 4Hz) and returns the latest reading. Temperature range: Normal mode: -128.0°C to 127.9375°C, Extended mode: -256.0°C to 255.875°C. Resolution: 0.0625°C.

```rust
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());

// Read temperature (returns f32 in degrees Celsius)
let temperature = sensor.read_temperature().unwrap();
println!("Temperature: {:.2}°C", temperature);
// Output: Temperature: 23.50°C

// Temperature range:
// Normal mode:   -128.0°C to 127.9375°C
// Extended mode: -256.0°C to 255.875°C
// Resolution:    0.0625°C
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.