Struct thermal_camera::grideye::GridEye

pub struct GridEye<I2C> { /* fields omitted */ }

Implementations

impl<I2C> GridEye<I2C> where
    I2C: Transactional, 

pub fn new(bus: I2C, address: Address) -> Self

pub fn power_mode(&mut self) -> Result<PowerControlValue, I2C::Error>

Retrieve the current power mode the sensor is in. See PowerControlValue for a description of the different modes.

pub fn set_power_mode(
    &mut self,
    value: PowerControlValue
) -> Result<(), I2C::Error>

Set the sensor’s power mode. See PowerControlValue for a description of the different settings as well as the process for waking up from PowerControlValue::Sleep.

pub fn reset_flags(&mut self) -> Result<(), I2C::Error>

Reset status flags and the interrupt table.

pub fn reset_initial(&mut self) -> Result<(), I2C::Error>

Perform a soft-reset, clearing status flags, the interrupt table, and re-read calibration data. This should only be used when moving from PowerControlValue::Sleep to PowerControlValue::Normal.

pub fn frame_rate(&mut self) -> Result<FrameRateValue, I2C::Error>

Get the current camera frame rate.

pub fn set_frame_rate(
    &mut self,
    value: FrameRateValue
) -> Result<(), I2C::Error>

Set the camera frame rate.

pub fn interrupts_enabled(&mut self) -> Result<bool, I2C::Error>

Check if external interrupts are being generated.

pub fn enable_interrupts(&mut self) -> Result<(), I2C::Error>

Enable external interrupts.

pub fn disable_interrupts(&mut self) -> Result<(), I2C::Error>

Disable external interrupts.

pub fn interrupt_mode(&mut self) -> Result<InterruptControlMode, I2C::Error>

Get the current interrupt mode. Interrupts are either generated when a pixel’s value exceeds the interrupt levels (absolute mode), or if the change in temperature exceeds the interrupt levels (difference mode).

pub fn set_interrupt_mode(
    &mut self,
    mode: InterruptControlMode
) -> Result<(), I2C::Error>

Set the interrupt mode.

pub fn flags(&mut self) -> Result<StatusValue, I2C::Error>

Get the current status flags.

pub fn overflow_flag(&mut self) -> Result<bool, I2C::Error>

Check if the temperature overflow flag has been set.

pub fn interrupt_flag(&mut self) -> Result<bool, I2C::Error>

Check if the interrupt flag has been set.

pub fn clear_all_flags(&mut self) -> Result<(), I2C::Error>

Clear both status flags.

pub fn clear_overflow_flag(&mut self) -> Result<(), I2C::Error>

Clear the temperature overflow flag.

pub fn clear_interrupt_flag(&mut self) -> Result<(), I2C::Error>

Clear the interrupt flag.

pub fn moving_average_enabled(&mut self) -> Result<bool, I2C::Error>

Check if moving average mode is enabled.

pub fn enable_moving_average(&mut self) -> Result<(), I2C::Error>

Enable moving average mode. There’re references to it averaging the values of the last 10 frames of a pixel (twice?), but it isn’t clear how this interacts with the frame rate setting.

pub fn disable_moving_average(&mut self) -> Result<(), I2C::Error>

Disable moving average mode.

pub fn upper_interrupt_level(&mut self) -> Result<f32, I2C::Error>

Get the current upper interrupt temperature limit in degrees Celsius.

pub fn lower_interrupt_level(&mut self) -> Result<f32, I2C::Error>

Get the current lower interrupt temperature limit in degrees Celsius.

pub fn hysteresis_interrupt_level(&mut self) -> Result<f32, I2C::Error>

Get the current interrupt hysteresis level.

pub fn set_upper_interrupt_level(
    &mut self,
    value: &f32
) -> Result<(), I2C::Error>

Set the upper interrupt temperature limit in degrees Celsius.

pub fn set_lower_interrupt_level(
    &mut self,
    value: &f32
) -> Result<(), I2C::Error>

Set the lower interrupt temperature limit in degrees Celsius.

pub fn set_hysteresis_interrupt_level(
    &mut self,
    value: &f32
) -> Result<(), I2C::Error>

Set the interrupt hysteresis level. The format is the same as the upper and lower levels, but the datasheet isn’t clear how it interacts with the interrupt generation.

pub fn thermistor(&mut self) -> Result<f32, I2C::Error>

Get the temperature of the sensor itself using the built-in thermistor. It has a range of -20° to 80° with a resolution of 0.0625° (all units in Celsius).

Trait Implementations

impl<I2C> ThermalCamera for GridEye<I2C> where
    I2C: Transactional, 

type Error = I2C::Error

fn temperature(&mut self) -> Option<f32>

Get the temperature of the camera.

fn image(&mut self) -> Result<Array2<f32>, Self::Error>

Return a two-dimensional array representing an image from the thermal camera. Currently the order of the pixels in the image is camera-dependent, but that’s probably going to change at some point.