Crate veml6030

This is a platform agnostic Rust driver for the VEML6030 and VEML7700 high-accuracy ambient light sensors using the embedded-hal traits.

This driver allows you to:

• Enable/disable the device. See: enable().
• Read the measured lux value. See: read_lux().
• Read the white channel measurement. See: read_white().
• Read the measured ALS value in raw format. See: read_raw().
• Calculate the compensated lux for a raw ALS value. See: convert_raw_als_to_lux().
• Set the gain. See: set_gain().
• Set the integration time. See: set_integration_time().
• Set the fault count. See: set_fault_count().
• Enable/disable and configure power saving mode. See: enable_power_saving().
• Enable/disable interrupts. See: enable_interrupts().
• Read the interrupt status. See: read_interrupt_status().
• Set the high/low thresholds in lux or raw. See: set_high_threshold_lux().
• Calculate the compensated raw threshold value ahead of time. See: calculate_raw_threshold_value().

Introductory blog post

The devices

Vishay's VEML6030 / VEML7700 are high accuracy ambient light digital 16-bit resolution sensors in a miniature transparent package. They include a high sensitive photodiode, a low noise amplifier, a 16-bit A/D converter and support an easy to use I2C bus communication interface and additional interrupt feature. The ambient light result is as digital value available.

Datasheets: VEML6030 - VEML7700

Application Note:

• Designing the VEML6030 into an application
• Designing the VEML7700 into an application

Usage examples (see also examples folder)

To use this driver, import this crate and an embedded_hal implementation, then instantiate the appropriate device.

VEML6030 and VEML7700 expose the same interface over I2C. To communicate with a VEML7700 simply use this driver as if communicating with a VEML6030.

Please find additional examples using hardware in this repository: driver-examples

Read the lux

use linux_embedded_hal::I2cdev;
use veml6030::{SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.enable().unwrap();
loop {
    let lux = sensor.read_lux().unwrap();
    println!("lux: {:2}", lux);
}

Provide an alternative address

use linux_embedded_hal::I2cdev;
use veml6030::{SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let address = SlaveAddr::Alternative(true);
let mut sensor = Veml6030::new(dev, address);

Set the gain and integration time

use linux_embedded_hal::I2cdev;
use veml6030::{Gain, IntegrationTime, SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.set_gain(Gain::OneQuarter).unwrap();
sensor.set_integration_time(IntegrationTime::Ms200).unwrap();
sensor.enable().unwrap();

Enable power-saving mode

use linux_embedded_hal::I2cdev;
use veml6030::{PowerSavingMode, SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.enable_power_saving(PowerSavingMode::One).unwrap();
sensor.enable().unwrap();

Set thresholds, fault count and enable interrupts

use linux_embedded_hal::I2cdev;
use veml6030::{
    FaultCount, Gain, IntegrationTime, SlaveAddr, Veml6030
};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.set_gain(Gain::OneQuarter).unwrap();
// this will compensate the value automatically before setting it
sensor.set_high_threshold_lux(10000.0).unwrap();
sensor.set_low_threshold_lux(100.0).unwrap();
sensor.set_fault_count(FaultCount::Four).unwrap();
sensor.enable_interrupts().unwrap();
sensor.enable().unwrap();

Precalculate and set compensated threshold values

Using current device configuration

use linux_embedded_hal::I2cdev;
use veml6030::{Gain, IntegrationTime, SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.set_gain(Gain::OneEighth).unwrap();
sensor.set_integration_time(IntegrationTime::Ms200).unwrap();
let high_th_raw = sensor.calculate_raw_threshold_value(10000.0);
// ...
sensor.set_high_threshold_raw(high_th_raw).unwrap();
// this requires no compensation because the value is < 1000
sensor.set_low_threshold_lux(100.0).unwrap();

Precalculate and set compensated threshold values

Using free function

use linux_embedded_hal::I2cdev;
use veml6030::{
    calculate_raw_threshold_value,
    Gain, IntegrationTime, SlaveAddr, Veml6030
};

let gain = Gain::OneEighth;
let it = IntegrationTime::Ms200;
let high_th_raw = calculate_raw_threshold_value(it, gain, 10000.0);
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.set_gain(gain).unwrap();
sensor.set_integration_time(it).unwrap();
// ...
sensor.set_high_threshold_raw(high_th_raw).unwrap();
// this requires no compensation because the value is < 1000
sensor.set_low_threshold_lux(100.0).unwrap();
sensor.enable_interrupts().unwrap();
sensor.enable().unwrap();

Read interrupt status

use linux_embedded_hal::I2cdev;
use veml6030::{SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
// ...
loop {
    let status = sensor.read_interrupt_status().unwrap();
    if status.was_too_high {
        // ...
    }
    if status.was_too_low {
        // ...
    }
}

Read the raw ALS measurement and convert to lux separately

Using current device configuration

use linux_embedded_hal::I2cdev;
use veml6030::{SlaveAddr, Veml6030};

let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.enable().unwrap();
loop {
    let raw = sensor.read_raw().unwrap();
    // ...
    let lux = sensor.convert_raw_als_to_lux(raw);
    println!("lux: {:2}", lux);
}

Read the raw ALS measurement and convert to lux separately

Using free function

use linux_embedded_hal::I2cdev;
use veml6030::{
    convert_raw_als_to_lux,
    Gain, IntegrationTime, SlaveAddr, Veml6030
};

let gain = Gain::OneEighth;
let it = IntegrationTime::Ms200;
let dev = I2cdev::new("/dev/i2c-1").unwrap();
let mut sensor = Veml6030::new(dev, SlaveAddr::default());
sensor.set_gain(gain).unwrap();
sensor.set_integration_time(it).unwrap();
sensor.enable().unwrap();
loop {
    let raw = sensor.read_raw().unwrap();
    // ...
    let lux = convert_raw_als_to_lux(it, gain, raw);
    println!("lux: {:2}", lux);
}

Structs

InterruptStatus	Interrupt status
Veml6030	VEML6030 device driver

Enums

Error	All possible errors in this crate
FaultCount	Fault count
Gain	Gain
IntegrationTime	Integration time
PowerSavingMode	Power-saving mode
SlaveAddr	Possible slave addresses

Functions

calculate_raw_threshold_value	Calculate raw value for threshold applying compensation if necessary.
convert_raw_als_to_lux	Calculate lux value for a raw ALS measurement.