Implement OPT4048 color sensor library with complete functionality
- Add comprehensive XYZ color sensor functionality - Implement threshold and interrupt configuration - Add CIE chromaticity coordinates calculation - Create detailed example sketch demonstrating all features - Use double precision for color calculations 🤖 Generated with [Claude Code](https://claude.ai/code) Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
ladyada
parent
164e6ec634
commit
60e34ac844
3 changed files with 1184 additions and 41 deletions
|
|
@ -1,3 +1,26 @@
|
|||
/*!
|
||||
* @file Adafruit_OPT4048.cpp
|
||||
*
|
||||
* @mainpage Adafruit OPT4048 High Speed High Precision Tristimulus XYZ Color Sensor
|
||||
*
|
||||
* @section intro_sec Introduction
|
||||
*
|
||||
* This is a library for the Adafruit OPT4048 breakout board
|
||||
* ----> https://www.adafruit.com/products/XXX (replace with actual product URL)
|
||||
*
|
||||
* Adafruit invests time and resources providing this open source code,
|
||||
* please support Adafruit and open-source hardware by purchasing
|
||||
* products from Adafruit!
|
||||
*
|
||||
* @section author Author
|
||||
*
|
||||
* Written by Limor Fried/Ladyada for Adafruit Industries.
|
||||
*
|
||||
* @section license License
|
||||
*
|
||||
* MIT license, all text here must be included in any redistribution
|
||||
*/
|
||||
|
||||
#include "Adafruit_OPT4048.h"
|
||||
|
||||
/**
|
||||
|
|
@ -46,21 +69,30 @@ bool Adafruit_OPT4048::begin(uint8_t addr, TwoWire *wire) {
|
|||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
// Set interrupt direction to default (high threshold active)
|
||||
// Even though this is the device default, we set it explicitly for clarity
|
||||
setInterruptDirection(true);
|
||||
|
||||
// Set interrupt configuration to "data ready for all channels"
|
||||
setInterruptConfig(OPT4048_INT_CFG_DATA_READY_ALL);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Read all four channels, verify CRC, and return raw ADC code values.
|
||||
*
|
||||
* Reads registers for channels 0-3 in one burst, checks the CRC bits for each,
|
||||
* and computes the 20-bit ADC code = mantissa << exponent.
|
||||
*
|
||||
* @param ch0 Pointer to store channel 0 ADC code.
|
||||
* @param ch1 Pointer to store channel 1 ADC code.
|
||||
* @param ch2 Pointer to store channel 2 ADC code.
|
||||
* @param ch3 Pointer to store channel 3 ADC code.
|
||||
* @param ch0 Pointer to store channel 0 (X) ADC code.
|
||||
* @param ch1 Pointer to store channel 1 (Y) ADC code.
|
||||
* @param ch2 Pointer to store channel 2 (Z) ADC code.
|
||||
* @param ch3 Pointer to store channel 3 (W) ADC code.
|
||||
* @return true if read succeeds and all CRC checks pass, false otherwise.
|
||||
*/
|
||||
bool Adafruit_OPT4048::getChannels(float *ch0, float *ch1, float *ch2, float *ch3) {
|
||||
bool Adafruit_OPT4048::getChannelsRaw(uint32_t *ch0, uint32_t *ch1, uint32_t *ch2, uint32_t *ch3) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
|
@ -69,13 +101,19 @@ bool Adafruit_OPT4048::getChannels(float *ch0, float *ch1, float *ch2, float *ch
|
|||
if (!i2c_dev->write_then_read(®, 1, buf, sizeof(buf))) {
|
||||
return false;
|
||||
}
|
||||
|
||||
for (uint8_t ch = 0; ch < 4; ch++) {
|
||||
uint16_t msb = ((uint16_t)buf[4 * ch] << 8) | buf[4 * ch + 1];
|
||||
uint16_t lsb = ((uint16_t)buf[4 * ch + 2] << 8) | buf[4 * ch + 3];
|
||||
uint8_t exp = (msb >> 12) & 0x0F;
|
||||
uint32_t mant = ((msb & 0x0FFF) << 8) | ((lsb >> 8) & 0xFF);
|
||||
|
||||
// Convert to 20-bit mantissa << exponent format
|
||||
// This is safe because the sensor only uses exponents 0-6 in actual measurements
|
||||
// (even when auto-range mode (12) is enabled in the configuration register)
|
||||
uint32_t code = mant << exp;
|
||||
uint8_t crc = lsb & 0x0F;
|
||||
|
||||
// Compute CRC bits
|
||||
uint8_t x0 = 0;
|
||||
for (uint8_t i = 0; i < 4; i++) {
|
||||
|
|
@ -87,29 +125,806 @@ bool Adafruit_OPT4048::getChannels(float *ch0, float *ch1, float *ch2, float *ch
|
|||
for (uint8_t i = 0; i < 4; i++) {
|
||||
x0 ^= (crc >> i) & 1;
|
||||
}
|
||||
|
||||
uint8_t x1 = ((crc >> 1) & 1) ^ ((crc >> 3) & 1);
|
||||
for (uint8_t i = 1; i < 20; i += 2) {
|
||||
x1 ^= (mant >> i) & 1;
|
||||
}
|
||||
x1 ^= (exp >> 1) & 1;
|
||||
x1 ^= (exp >> 3) & 1;
|
||||
|
||||
uint8_t x2 = ((crc >> 3) & 1);
|
||||
for (uint8_t i = 3; i < 20; i += 4) {
|
||||
x2 ^= (mant >> i) & 1;
|
||||
}
|
||||
x2 ^= (exp >> 3) & 1;
|
||||
|
||||
uint8_t x3 = ((mant >> 3) & 1) ^ ((mant >> 11) & 1) ^ ((mant >> 19) & 1);
|
||||
|
||||
// Verify CRC
|
||||
if (((crc & 1) != x0) || (((crc >> 1) & 1) != x1) || (((crc >> 2) & 1) != x2) || (((crc >> 3) & 1) != x3)) {
|
||||
if (((crc & 1) != x0) || (((crc >> 1) & 1) != x1) ||
|
||||
(((crc >> 2) & 1) != x2) || (((crc >> 3) & 1) != x3)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Assign output
|
||||
switch (ch) {
|
||||
case 0: *ch0 = (float)code; break;
|
||||
case 1: *ch1 = (float)code; break;
|
||||
case 2: *ch2 = (float)code; break;
|
||||
case 3: *ch3 = (float)code; break;
|
||||
case 0: *ch0 = code; break;
|
||||
case 1: *ch1 = code; break;
|
||||
case 2: *ch2 = code; break;
|
||||
case 3: *ch3 = code; break;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current low threshold value
|
||||
*
|
||||
* Reads the low threshold register (0x08) and converts the exponent/mantissa
|
||||
* format to a single 32-bit value.
|
||||
*
|
||||
* As per page 18 of the datasheet, threshold calculation is:
|
||||
* ADC_CODES_TL = THRESHOLD_L_RESULT << (8 + THRESHOLD_L_EXPONENT)
|
||||
*
|
||||
* @return The current low threshold value
|
||||
*/
|
||||
uint32_t Adafruit_OPT4048::getThresholdLow(void) {
|
||||
if (!i2c_dev) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold register
|
||||
Adafruit_BusIO_Register threshold_reg(i2c_dev, OPT4048_REG_THRESHOLD_LOW, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the exponent (top 4 bits) and mantissa (lower 12 bits)
|
||||
Adafruit_BusIO_RegisterBits exponent_bits(&threshold_reg, 4, 12);
|
||||
Adafruit_BusIO_RegisterBits mantissa_bits(&threshold_reg, 12, 0);
|
||||
|
||||
// Read the exponent and mantissa
|
||||
uint8_t exponent = exponent_bits.read();
|
||||
uint32_t mantissa = mantissa_bits.read();
|
||||
|
||||
// Calculate ADC code value by applying the exponent as a bit shift
|
||||
// ADD 8 to the exponent as per datasheet equations 12-13
|
||||
return mantissa << (8 + exponent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the low threshold value for interrupt generation
|
||||
*
|
||||
* Configures the low threshold register (0x08) with the given value in
|
||||
* the sensor's exponent/mantissa format.
|
||||
*
|
||||
* Value is stored as THRESHOLD_L_RESULT and THRESHOLD_L_EXPONENT where:
|
||||
* ADC_CODES_TL = THRESHOLD_L_RESULT << (8 + THRESHOLD_L_EXPONENT)
|
||||
*
|
||||
* @param thl The low threshold value
|
||||
* @return true if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setThresholdLow(uint32_t thl) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Find the appropriate exponent and mantissa values that represent the threshold
|
||||
// In this case, we need to find the smallest exponent that allows mantissa to fit in 12 bits
|
||||
uint8_t exponent = 0;
|
||||
uint32_t mantissa = thl;
|
||||
|
||||
// The mantissa needs to fit in 12 bits, so we start by shifting right
|
||||
// to determine how many shifts we need (which gives us the exponent)
|
||||
// Note that the threshold registers already have 8 added to exponent internally
|
||||
// so we first subtract 8 from our target exponent
|
||||
if (mantissa > 0xFFF) { // If value won't fit in 12 bits
|
||||
while (mantissa > 0xFFF && exponent < 15) {
|
||||
mantissa >>= 1;
|
||||
exponent++;
|
||||
}
|
||||
if (mantissa > 0xFFF) { // If still won't fit with max exponent, clamp
|
||||
mantissa = 0xFFF;
|
||||
exponent = 15 - 8; // Max exponent (15) minus the 8 that's added internally
|
||||
}
|
||||
}
|
||||
|
||||
// Create the register object for the threshold register
|
||||
Adafruit_BusIO_Register threshold_reg(i2c_dev, OPT4048_REG_THRESHOLD_LOW, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the exponent (top 4 bits) and mantissa (lower 12 bits)
|
||||
Adafruit_BusIO_RegisterBits exponent_bits(&threshold_reg, 4, 12);
|
||||
Adafruit_BusIO_RegisterBits mantissa_bits(&threshold_reg, 12, 0);
|
||||
|
||||
// Write the exponent and mantissa to the register
|
||||
exponent_bits.write(exponent);
|
||||
mantissa_bits.write(mantissa);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current high threshold value
|
||||
*
|
||||
* Reads the high threshold register (0x09) and converts the exponent/mantissa
|
||||
* format to a single 32-bit value.
|
||||
*
|
||||
* As per page 18 of the datasheet, threshold calculation is:
|
||||
* ADC_CODES_TH = THRESHOLD_H_RESULT << (8 + THRESHOLD_H_EXPONENT)
|
||||
*
|
||||
* @return The current high threshold value
|
||||
*/
|
||||
uint32_t Adafruit_OPT4048::getThresholdHigh(void) {
|
||||
if (!i2c_dev) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold register
|
||||
Adafruit_BusIO_Register threshold_reg(i2c_dev, OPT4048_REG_THRESHOLD_HIGH, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the exponent (top 4 bits) and mantissa (lower 12 bits)
|
||||
Adafruit_BusIO_RegisterBits exponent_bits(&threshold_reg, 4, 12);
|
||||
Adafruit_BusIO_RegisterBits mantissa_bits(&threshold_reg, 12, 0);
|
||||
|
||||
// Read the exponent and mantissa
|
||||
uint8_t exponent = exponent_bits.read();
|
||||
uint32_t mantissa = mantissa_bits.read();
|
||||
|
||||
// Calculate ADC code value by applying the exponent as a bit shift
|
||||
// ADD 8 to the exponent as per datasheet equations 10-11
|
||||
return mantissa << (8 + exponent);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the high threshold value for interrupt generation
|
||||
*
|
||||
* Configures the high threshold register (0x09) with the given value in
|
||||
* the sensor's exponent/mantissa format.
|
||||
*
|
||||
* Value is stored as THRESHOLD_H_RESULT and THRESHOLD_H_EXPONENT where:
|
||||
* ADC_CODES_TH = THRESHOLD_H_RESULT << (8 + THRESHOLD_H_EXPONENT)
|
||||
*
|
||||
* @param thh The high threshold value
|
||||
* @return true if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setThresholdHigh(uint32_t thh) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Find the appropriate exponent and mantissa values that represent the threshold
|
||||
// In this case, we need to find the smallest exponent that allows mantissa to fit in 12 bits
|
||||
uint8_t exponent = 0;
|
||||
uint32_t mantissa = thh;
|
||||
|
||||
// The mantissa needs to fit in 12 bits, so we start by shifting right
|
||||
// to determine how many shifts we need (which gives us the exponent)
|
||||
// Note that the threshold registers already have 8 added to exponent internally
|
||||
// so we first subtract 8 from our target exponent
|
||||
if (mantissa > 0xFFF) { // If value won't fit in 12 bits
|
||||
while (mantissa > 0xFFF && exponent < 15) {
|
||||
mantissa >>= 1;
|
||||
exponent++;
|
||||
}
|
||||
if (mantissa > 0xFFF) { // If still won't fit with max exponent, clamp
|
||||
mantissa = 0xFFF;
|
||||
exponent = 15 - 8; // Max exponent (15) minus the 8 that's added internally
|
||||
}
|
||||
}
|
||||
|
||||
// Create the register object for the threshold register
|
||||
Adafruit_BusIO_Register threshold_reg(i2c_dev, OPT4048_REG_THRESHOLD_HIGH, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the exponent (top 4 bits) and mantissa (lower 12 bits)
|
||||
Adafruit_BusIO_RegisterBits exponent_bits(&threshold_reg, 4, 12);
|
||||
Adafruit_BusIO_RegisterBits mantissa_bits(&threshold_reg, 12, 0);
|
||||
|
||||
// Write the exponent and mantissa to the register
|
||||
exponent_bits.write(exponent);
|
||||
mantissa_bits.write(mantissa);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Enable or disable Quick Wake-up feature
|
||||
*
|
||||
* Controls the QWAKE bit (bit 15) in the configuration register (0x0A).
|
||||
* When enabled, the sensor doesn't power down completely in one-shot mode,
|
||||
* allowing faster wake-up from standby with lower power consumption.
|
||||
*
|
||||
* From the datasheet (page 29):
|
||||
* "Quick Wake-up from Standby in one shot mode by not powering down all circuits.
|
||||
* Applicable only in One-shot mode and helps get out of standby mode faster
|
||||
* with penalty in power consumption compared to full standby mode."
|
||||
*
|
||||
* @param enable True to enable Quick Wake, false to disable
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setQuickWake(bool enable) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the QWAKE bit (bit 15)
|
||||
Adafruit_BusIO_RegisterBits qwake_bit(&config_reg, 1, 15);
|
||||
|
||||
// Set the QWAKE bit according to the enable parameter
|
||||
return qwake_bit.write(enable);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current state of the Quick Wake feature
|
||||
*
|
||||
* Reads the QWAKE bit (bit 15) from the configuration register (0x0A)
|
||||
* to determine if Quick Wake is enabled or disabled.
|
||||
*
|
||||
* @return True if Quick Wake is enabled, false if disabled
|
||||
*/
|
||||
bool Adafruit_OPT4048::getQuickWake(void) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the QWAKE bit (bit 15)
|
||||
Adafruit_BusIO_RegisterBits qwake_bit(&config_reg, 1, 15);
|
||||
|
||||
// Read the QWAKE bit
|
||||
return qwake_bit.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the range for light measurements
|
||||
*
|
||||
* Controls the RANGE field (bits 10-13) in the configuration register (0x0A).
|
||||
* Allows setting a fixed range or enabling automatic range selection.
|
||||
*
|
||||
* From the datasheet (page 29):
|
||||
* "Controls the full-scale light level range of the device. The format of this
|
||||
* register is same as the EXPONENT register for all values from 0 to 6.
|
||||
* 0: 2.2klux
|
||||
* 1: 4.5kux
|
||||
* 2: 9klux
|
||||
* 3: 18klux
|
||||
* 4: 36klux
|
||||
* 5: 72klux
|
||||
* 6: 144klux
|
||||
* 12: Auto-Range"
|
||||
*
|
||||
* @param range The range setting to use from opt4048_range_t enum
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setRange(opt4048_range_t range) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the RANGE field (bits 10-13)
|
||||
Adafruit_BusIO_RegisterBits range_bits(&config_reg, 4, 10);
|
||||
|
||||
// Set the RANGE field according to the range parameter
|
||||
return range_bits.write(range);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current range setting
|
||||
*
|
||||
* Reads the RANGE field (bits 10-13) from the configuration register (0x0A)
|
||||
* to determine the current range setting.
|
||||
*
|
||||
* @return The current range setting as opt4048_range_t enum value
|
||||
*/
|
||||
opt4048_range_t Adafruit_OPT4048::getRange(void) {
|
||||
if (!i2c_dev) {
|
||||
return OPT4048_RANGE_AUTO; // Default to auto-range if no device
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the RANGE field (bits 10-13)
|
||||
Adafruit_BusIO_RegisterBits range_bits(&config_reg, 4, 10);
|
||||
|
||||
// Read the RANGE field and return as enum value
|
||||
return (opt4048_range_t)range_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the conversion time per channel
|
||||
*
|
||||
* Controls the CONVERSION_TIME field (bits 6-9) in the configuration register (0x0A).
|
||||
* This sets how long each channel will take to convert, ranging from 600 microseconds
|
||||
* to 800 milliseconds per channel.
|
||||
*
|
||||
* @param convTime The conversion time setting from opt4048_conversion_time_t enum
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setConversionTime(opt4048_conversion_time_t convTime) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the CONVERSION_TIME field (bits 6-9)
|
||||
Adafruit_BusIO_RegisterBits convTime_bits(&config_reg, 4, 6);
|
||||
|
||||
// Set the CONVERSION_TIME field according to the convTime parameter
|
||||
return convTime_bits.write(convTime);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current conversion time setting
|
||||
*
|
||||
* Reads the CONVERSION_TIME field (bits 6-9) from the configuration register (0x0A)
|
||||
* to determine the current conversion time setting.
|
||||
*
|
||||
* @return The current conversion time setting as opt4048_conversion_time_t enum value
|
||||
*/
|
||||
opt4048_conversion_time_t Adafruit_OPT4048::getConversionTime(void) {
|
||||
if (!i2c_dev) {
|
||||
return OPT4048_CONVERSION_TIME_100MS; // Default to 100ms if no device
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the CONVERSION_TIME field (bits 6-9)
|
||||
Adafruit_BusIO_RegisterBits convTime_bits(&config_reg, 4, 6);
|
||||
|
||||
// Read the CONVERSION_TIME field and return as enum value
|
||||
return (opt4048_conversion_time_t)convTime_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the operating mode of the sensor
|
||||
*
|
||||
* Controls the OPERATING_MODE field (bits 4-5) in the configuration register (0x0A).
|
||||
* This sets the device's operating mode: power-down, one-shot, or continuous.
|
||||
*
|
||||
* @param mode The operating mode setting from opt4048_mode_t enum
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setMode(opt4048_mode_t mode) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the OPERATING_MODE field (bits 4-5)
|
||||
Adafruit_BusIO_RegisterBits mode_bits(&config_reg, 2, 4);
|
||||
|
||||
// Set the OPERATING_MODE field according to the mode parameter
|
||||
return mode_bits.write(mode);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current operating mode setting
|
||||
*
|
||||
* Reads the OPERATING_MODE field (bits 4-5) from the configuration register (0x0A)
|
||||
* to determine the current operating mode.
|
||||
*
|
||||
* @return The current operating mode as opt4048_mode_t enum value
|
||||
*/
|
||||
opt4048_mode_t Adafruit_OPT4048::getMode(void) {
|
||||
if (!i2c_dev) {
|
||||
return OPT4048_MODE_POWERDOWN; // Default to power-down if no device
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the OPERATING_MODE field (bits 4-5)
|
||||
Adafruit_BusIO_RegisterBits mode_bits(&config_reg, 2, 4);
|
||||
|
||||
// Read the OPERATING_MODE field and return as enum value
|
||||
return (opt4048_mode_t)mode_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the interrupt latch mode
|
||||
*
|
||||
* Controls the LATCH bit (bit 3) in the configuration register (0x0A).
|
||||
* This sets whether interrupts are latched or transparent.
|
||||
*
|
||||
* When latched (true), the interrupt pin remains active until the flag registers
|
||||
* are read, regardless of whether the interrupt condition still exists.
|
||||
*
|
||||
* When transparent/non-latched (false), the interrupt pin state is updated with
|
||||
* each measurement and reflects the current comparison result.
|
||||
*
|
||||
* @param latch True for latched mode, false for transparent mode
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setInterruptLatch(bool latch) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the LATCH bit (bit 3)
|
||||
Adafruit_BusIO_RegisterBits latch_bit(&config_reg, 1, 3);
|
||||
|
||||
// Set the LATCH bit according to the latch parameter
|
||||
return latch_bit.write(latch);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current interrupt latch mode
|
||||
*
|
||||
* Reads the LATCH bit (bit 3) from the configuration register (0x0A)
|
||||
* to determine the current latch mode.
|
||||
*
|
||||
* @return True if interrupts are latched, false if transparent
|
||||
*/
|
||||
bool Adafruit_OPT4048::getInterruptLatch(void) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the LATCH bit (bit 3)
|
||||
Adafruit_BusIO_RegisterBits latch_bit(&config_reg, 1, 3);
|
||||
|
||||
// Read the LATCH bit
|
||||
return latch_bit.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the interrupt pin polarity
|
||||
*
|
||||
* Controls the INT_POL bit (bit 2) in the configuration register (0x0A).
|
||||
* This sets the active state of the interrupt pin.
|
||||
*
|
||||
* @param activeHigh True for active-high (1 = interrupt active),
|
||||
* false for active-low (0 = interrupt active)
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setInterruptPolarity(bool activeHigh) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the INT_POL bit (bit 2)
|
||||
Adafruit_BusIO_RegisterBits polarity_bit(&config_reg, 1, 2);
|
||||
|
||||
// Set the INT_POL bit according to the activeHigh parameter
|
||||
return polarity_bit.write(activeHigh);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current interrupt pin polarity
|
||||
*
|
||||
* Reads the INT_POL bit (bit 2) from the configuration register (0x0A)
|
||||
* to determine the current interrupt polarity.
|
||||
*
|
||||
* @return True if interrupts are active-high, false if active-low
|
||||
*/
|
||||
bool Adafruit_OPT4048::getInterruptPolarity(void) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the INT_POL bit (bit 2)
|
||||
Adafruit_BusIO_RegisterBits polarity_bit(&config_reg, 1, 2);
|
||||
|
||||
// Read the INT_POL bit
|
||||
return polarity_bit.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the fault count for interrupt generation
|
||||
*
|
||||
* Controls the FAULT_COUNT field (bits 0-1) in the configuration register (0x0A).
|
||||
* This sets how many consecutive measurements must be above/below thresholds
|
||||
* before an interrupt is triggered.
|
||||
*
|
||||
* @param count The fault count setting from opt4048_fault_count_t enum
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setFaultCount(opt4048_fault_count_t count) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the FAULT_COUNT field (bits 0-1)
|
||||
Adafruit_BusIO_RegisterBits fault_count_bits(&config_reg, 2, 0);
|
||||
|
||||
// Set the FAULT_COUNT field according to the count parameter
|
||||
return fault_count_bits.write(count);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current fault count setting
|
||||
*
|
||||
* Reads the FAULT_COUNT field (bits 0-1) from the configuration register (0x0A)
|
||||
* to determine the current fault count setting.
|
||||
*
|
||||
* @return The current fault count setting as opt4048_fault_count_t enum value
|
||||
*/
|
||||
opt4048_fault_count_t Adafruit_OPT4048::getFaultCount(void) {
|
||||
if (!i2c_dev) {
|
||||
return OPT4048_FAULT_COUNT_1; // Default to 1 fault count if no device
|
||||
}
|
||||
|
||||
// Create the register object for the configuration register
|
||||
Adafruit_BusIO_Register config_reg(i2c_dev, OPT4048_REG_CONFIG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the FAULT_COUNT field (bits 0-1)
|
||||
Adafruit_BusIO_RegisterBits fault_count_bits(&config_reg, 2, 0);
|
||||
|
||||
// Read the FAULT_COUNT field and return as enum value
|
||||
return (opt4048_fault_count_t)fault_count_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the channel to be used for threshold comparison
|
||||
*
|
||||
* Controls the THRESHOLD_CH_SEL field (bits 5-6) in the threshold configuration register (0x0B).
|
||||
* This sets which channel's ADC code is compared against the thresholds.
|
||||
*
|
||||
* @param channel Channel number (0-3) to use for threshold comparison:
|
||||
* 0 = Channel 0 (X)
|
||||
* 1 = Channel 1 (Y)
|
||||
* 2 = Channel 2 (Z)
|
||||
* 3 = Channel 3 (W)
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setThresholdChannel(uint8_t channel) {
|
||||
if (!i2c_dev || channel > 3) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the THRESHOLD_CH_SEL field (bits 5-6)
|
||||
Adafruit_BusIO_RegisterBits thresh_ch_sel_bits(&thresh_cfg_reg, 2, 5);
|
||||
|
||||
// Set the THRESHOLD_CH_SEL field according to the channel parameter
|
||||
return thresh_ch_sel_bits.write(channel);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the channel currently used for threshold comparison
|
||||
*
|
||||
* Reads the THRESHOLD_CH_SEL field (bits 5-6) from the threshold configuration register (0x0B)
|
||||
* to determine which channel is being used for threshold comparison.
|
||||
*
|
||||
* @return The channel number (0-3) currently used for threshold comparison:
|
||||
* 0 = Channel 0 (X)
|
||||
* 1 = Channel 1 (Y)
|
||||
* 2 = Channel 2 (Z)
|
||||
* 3 = Channel 3 (W)
|
||||
*/
|
||||
uint8_t Adafruit_OPT4048::getThresholdChannel(void) {
|
||||
if (!i2c_dev) {
|
||||
return 0; // Default to channel 0 if no device
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the THRESHOLD_CH_SEL field (bits 5-6)
|
||||
Adafruit_BusIO_RegisterBits thresh_ch_sel_bits(&thresh_cfg_reg, 2, 5);
|
||||
|
||||
// Read the THRESHOLD_CH_SEL field
|
||||
return thresh_ch_sel_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the direction of the interrupt generation
|
||||
*
|
||||
* Controls the INT_DIR bit (bit 4) in the threshold configuration register (0x0B).
|
||||
* This sets whether an interrupt is generated when the measured value is below
|
||||
* the low threshold or above the high threshold.
|
||||
*
|
||||
* @param thresholdHighActive True for interrupt when measurement > high threshold,
|
||||
* false for interrupt when measurement < low threshold
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setInterruptDirection(bool thresholdHighActive) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the INT_DIR bit (bit 4)
|
||||
Adafruit_BusIO_RegisterBits int_dir_bit(&thresh_cfg_reg, 1, 4);
|
||||
|
||||
// Set the INT_DIR bit according to the thresholdHighActive parameter
|
||||
return int_dir_bit.write(thresholdHighActive);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current interrupt direction setting
|
||||
*
|
||||
* Reads the INT_DIR bit (bit 4) from the threshold configuration register (0x0B)
|
||||
* to determine the current interrupt direction.
|
||||
*
|
||||
* @return True if interrupts are generated when measurement > high threshold,
|
||||
* false if interrupts are generated when measurement < low threshold
|
||||
*/
|
||||
bool Adafruit_OPT4048::getInterruptDirection(void) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bit for the INT_DIR bit (bit 4)
|
||||
Adafruit_BusIO_RegisterBits int_dir_bit(&thresh_cfg_reg, 1, 4);
|
||||
|
||||
// Read the INT_DIR bit
|
||||
return int_dir_bit.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Set the interrupt configuration
|
||||
*
|
||||
* Controls the INT_CFG field (bits 2-3) in the threshold configuration register (0x0B).
|
||||
* This sets the interrupt mechanism after end of conversion.
|
||||
*
|
||||
* @param config The interrupt configuration setting from opt4048_int_cfg_t enum
|
||||
* @return True if successful, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::setInterruptConfig(opt4048_int_cfg_t config) {
|
||||
if (!i2c_dev) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the INT_CFG field (bits 2-3)
|
||||
Adafruit_BusIO_RegisterBits int_cfg_bits(&thresh_cfg_reg, 2, 2);
|
||||
|
||||
// Set the INT_CFG field according to the config parameter
|
||||
return int_cfg_bits.write(config);
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current interrupt configuration
|
||||
*
|
||||
* Reads the INT_CFG field (bits 2-3) from the threshold configuration register (0x0B)
|
||||
* to determine the current interrupt configuration.
|
||||
*
|
||||
* @return The current interrupt configuration as opt4048_int_cfg_t enum value
|
||||
*/
|
||||
opt4048_int_cfg_t Adafruit_OPT4048::getInterruptConfig(void) {
|
||||
if (!i2c_dev) {
|
||||
return OPT4048_INT_CFG_SMBUS_ALERT; // Default to SMBUS Alert if no device
|
||||
}
|
||||
|
||||
// Create the register object for the threshold configuration register
|
||||
Adafruit_BusIO_Register thresh_cfg_reg(i2c_dev, OPT4048_REG_THRESHOLD_CFG, 2, MSBFIRST);
|
||||
|
||||
// Create register bits for the INT_CFG field (bits 2-3)
|
||||
Adafruit_BusIO_RegisterBits int_cfg_bits(&thresh_cfg_reg, 2, 2);
|
||||
|
||||
// Read the INT_CFG field and return as enum value
|
||||
return (opt4048_int_cfg_t)int_cfg_bits.read();
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Get the current status flags
|
||||
*
|
||||
* Reads the status register (0x0C) to determine the current state of various flags.
|
||||
* Reading this register also clears latched interrupt flags.
|
||||
*
|
||||
* @return 8-bit value where:
|
||||
* - bit 0 (0x01): FLAG_L - Flag low (measurement below threshold)
|
||||
* - bit 1 (0x02): FLAG_H - Flag high (measurement above threshold)
|
||||
* - bit 2 (0x04): CONVERSION_READY_FLAG - Conversion complete
|
||||
* - bit 3 (0x08): OVERLOAD_FLAG - Overflow condition
|
||||
*/
|
||||
uint8_t Adafruit_OPT4048::getFlags(void) {
|
||||
if (!i2c_dev) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Create the register object for the status register
|
||||
Adafruit_BusIO_Register status_reg(i2c_dev, OPT4048_REG_STATUS, 2, MSBFIRST);
|
||||
|
||||
// Read the status register and return the lower byte (contains all flag bits)
|
||||
uint16_t status = status_reg.read();
|
||||
return status & 0x0F; // Mask to get only the lower 4 bits with the flags
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Calculate CIE chromaticity coordinates and lux from raw sensor values
|
||||
*
|
||||
* Reads all four channels and calculates CIE x and y chromaticity coordinates
|
||||
* and illuminance (lux) using a matrix transformation.
|
||||
*
|
||||
* @param CIEx Pointer to store the calculated CIE x coordinate
|
||||
* @param CIEy Pointer to store the calculated CIE y coordinate
|
||||
* @param lux Pointer to store the calculated illuminance in lux
|
||||
* @return True if calculation succeeded, false otherwise
|
||||
*/
|
||||
bool Adafruit_OPT4048::getCIE(double *CIEx, double *CIEy, double *lux) {
|
||||
if (!i2c_dev || !CIEx || !CIEy || !lux) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Read all four channels
|
||||
uint32_t ch0, ch1, ch2, ch3;
|
||||
if (!getChannelsRaw(&ch0, &ch1, &ch2, &ch3)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// Matrix multiplication coefficients (from datasheet)
|
||||
const double m0x = 2.34892992e-04;
|
||||
const double m0y = -1.89652390e-05;
|
||||
const double m0z = 1.20811684e-05;
|
||||
const double m0l = 0;
|
||||
|
||||
const double m1x = 4.07467441e-05;
|
||||
const double m1y = 1.98958202e-04;
|
||||
const double m1z = -1.58848115e-05;
|
||||
const double m1l = 2.15e-3;
|
||||
|
||||
const double m2x = 9.28619404e-05;
|
||||
const double m2y = -1.69739553e-05;
|
||||
const double m2z = 6.74021520e-04;
|
||||
const double m2l = 0;
|
||||
|
||||
const double m3x = 0;
|
||||
const double m3y = 0;
|
||||
const double m3z = 0;
|
||||
const double m3l = 0;
|
||||
|
||||
// The equation from the datasheet is a matrix multiplication:
|
||||
// [ch0 ch1 ch2 ch3] * [m0x m0y m0z m0l] = [X Y Z Lux]
|
||||
// [m1x m1y m1z m1l]
|
||||
// [m2x m2y m2z m2l]
|
||||
// [m3x m3y m3z m3l]
|
||||
double X = ch0 * m0x + ch1 * m1x + ch2 * m2x + ch3 * m3x;
|
||||
double Y = ch0 * m0y + ch1 * m1y + ch2 * m2y + ch3 * m3y;
|
||||
double Z = ch0 * m0z + ch1 * m1z + ch2 * m2z + ch3 * m3z;
|
||||
double L = ch0 * m0l + ch1 * m1l + ch2 * m2l + ch3 * m3l;
|
||||
|
||||
// Set illuminance in lux
|
||||
*lux = L;
|
||||
|
||||
// Calculate CIE x, y chromaticity coordinates
|
||||
double sum = X + Y + Z;
|
||||
if (sum <= 0) {
|
||||
// Avoid division by zero
|
||||
*CIEx = 0;
|
||||
*CIEy = 0;
|
||||
*lux = 0;
|
||||
return false;
|
||||
}
|
||||
|
||||
*CIEx = X / sum;
|
||||
*CIEy = Y / sum;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
|
@ -1,10 +1,21 @@
|
|||
/*
|
||||
This is a library for the OPT4048 ambient light sensor
|
||||
Designed to work with Adafruit BusIO: https://github.com/adafruit/Adafruit_BusIO
|
||||
|
||||
Written by Adafruit Industries, 2025.
|
||||
*/
|
||||
|
||||
/*!
|
||||
* @file Adafruit_OPT4048.h
|
||||
*
|
||||
* Arduino library for the OPT4048 High Speed High Precision Tristimulus XYZ Color Sensor.
|
||||
*
|
||||
* This is a library for the Adafruit OPT4048 breakout
|
||||
* ----> https://www.adafruit.com/products/XXX (replace with actual product URL)
|
||||
*
|
||||
* Adafruit invests time and resources providing this open source code,
|
||||
* please support Adafruit and open-source hardware by purchasing
|
||||
* products from Adafruit!
|
||||
*
|
||||
* Written by Limor Fried/Ladyada for Adafruit Industries.
|
||||
*
|
||||
* MIT license, all text here must be included in any redistribution.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef ADAFRUIT_OPT4048_H
|
||||
#define ADAFRUIT_OPT4048_H
|
||||
|
||||
|
|
@ -16,21 +27,98 @@
|
|||
// Default I2C address (ADDR pin connected to GND)
|
||||
#define OPT4048_DEFAULT_ADDR 0x44
|
||||
|
||||
/**
|
||||
* @brief Available range settings for the OPT4048 sensor
|
||||
*
|
||||
* Full-scale light level ranges as described in datasheet page 29.
|
||||
*/
|
||||
typedef enum {
|
||||
OPT4048_RANGE_2K_LUX = 0, ///< 2.2 klux
|
||||
OPT4048_RANGE_4K_LUX = 1, ///< 4.5 klux
|
||||
OPT4048_RANGE_9K_LUX = 2, ///< 9 klux
|
||||
OPT4048_RANGE_18K_LUX = 3, ///< 18 klux
|
||||
OPT4048_RANGE_36K_LUX = 4, ///< 36 klux
|
||||
OPT4048_RANGE_72K_LUX = 5, ///< 72 klux
|
||||
OPT4048_RANGE_144K_LUX = 6, ///< 144 klux
|
||||
OPT4048_RANGE_AUTO = 12 ///< Auto-range
|
||||
} opt4048_range_t;
|
||||
|
||||
/**
|
||||
* @brief Available conversion time settings for the OPT4048 sensor
|
||||
*
|
||||
* These control the device conversion time per channel as described in datasheet page 29.
|
||||
*/
|
||||
typedef enum {
|
||||
OPT4048_CONVERSION_TIME_600US = 0, ///< 600 microseconds
|
||||
OPT4048_CONVERSION_TIME_1MS = 1, ///< 1 millisecond
|
||||
OPT4048_CONVERSION_TIME_1_8MS = 2, ///< 1.8 milliseconds
|
||||
OPT4048_CONVERSION_TIME_3_4MS = 3, ///< 3.4 milliseconds
|
||||
OPT4048_CONVERSION_TIME_6_5MS = 4, ///< 6.5 milliseconds
|
||||
OPT4048_CONVERSION_TIME_12_7MS = 5, ///< 12.7 milliseconds
|
||||
OPT4048_CONVERSION_TIME_25MS = 6, ///< 25 milliseconds
|
||||
OPT4048_CONVERSION_TIME_50MS = 7, ///< 50 milliseconds
|
||||
OPT4048_CONVERSION_TIME_100MS = 8, ///< 100 milliseconds
|
||||
OPT4048_CONVERSION_TIME_200MS = 9, ///< 200 milliseconds
|
||||
OPT4048_CONVERSION_TIME_400MS = 10, ///< 400 milliseconds
|
||||
OPT4048_CONVERSION_TIME_800MS = 11 ///< 800 milliseconds
|
||||
} opt4048_conversion_time_t;
|
||||
|
||||
/**
|
||||
* @brief Available operating mode settings for the OPT4048 sensor
|
||||
*
|
||||
* Controls the device mode of operation as described in datasheet page 29.
|
||||
*/
|
||||
typedef enum {
|
||||
OPT4048_MODE_POWERDOWN = 0, ///< Power-down mode
|
||||
OPT4048_MODE_AUTO_ONESHOT = 1, ///< Forced auto-range one-shot mode
|
||||
OPT4048_MODE_ONESHOT = 2, ///< One-shot mode
|
||||
OPT4048_MODE_CONTINUOUS = 3 ///< Continuous mode
|
||||
} opt4048_mode_t;
|
||||
|
||||
/**
|
||||
* @brief Available fault count settings for the OPT4048 sensor
|
||||
*
|
||||
* Controls how many consecutive fault events are needed to trigger an interrupt.
|
||||
*/
|
||||
typedef enum {
|
||||
OPT4048_FAULT_COUNT_1 = 0, ///< 1 fault count (default)
|
||||
OPT4048_FAULT_COUNT_2 = 1, ///< 2 consecutive fault counts
|
||||
OPT4048_FAULT_COUNT_4 = 2, ///< 4 consecutive fault counts
|
||||
OPT4048_FAULT_COUNT_8 = 3 ///< 8 consecutive fault counts
|
||||
} opt4048_fault_count_t;
|
||||
|
||||
/**
|
||||
* @brief Interrupt configuration settings for the OPT4048 sensor
|
||||
*
|
||||
* Controls the interrupt mechanism after end of conversion.
|
||||
*/
|
||||
typedef enum {
|
||||
OPT4048_INT_CFG_SMBUS_ALERT = 0, ///< SMBUS Alert
|
||||
OPT4048_INT_CFG_DATA_READY_NEXT = 1, ///< INT Pin data ready for next channel
|
||||
OPT4048_INT_CFG_DATA_READY_ALL = 3 ///< INT Pin data ready for all channels
|
||||
} opt4048_int_cfg_t;
|
||||
|
||||
// Register addresses
|
||||
#define OPT4048_REG_CH0_MSB 0x00
|
||||
#define OPT4048_REG_CH0_LSB 0x01
|
||||
#define OPT4048_REG_CH1_MSB 0x02
|
||||
#define OPT4048_REG_CH1_LSB 0x03
|
||||
#define OPT4048_REG_CH2_MSB 0x04
|
||||
#define OPT4048_REG_CH2_LSB 0x05
|
||||
#define OPT4048_REG_CH3_MSB 0x06
|
||||
#define OPT4048_REG_CH3_LSB 0x07
|
||||
#define OPT4048_REG_THRESHOLD_LOW 0x08
|
||||
#define OPT4048_REG_THRESHOLD_HIGH 0x09
|
||||
#define OPT4048_REG_CONFIG 0x0A
|
||||
#define OPT4048_REG_THRESHOLD_CFG 0x0B
|
||||
#define OPT4048_REG_STATUS 0x0C
|
||||
#define OPT4048_REG_DEVICE_ID 0x11
|
||||
#define OPT4048_REG_CH0_MSB 0x00 // X channel MSB
|
||||
#define OPT4048_REG_CH0_LSB 0x01 // X channel LSB
|
||||
#define OPT4048_REG_CH1_MSB 0x02 // Y channel MSB
|
||||
#define OPT4048_REG_CH1_LSB 0x03 // Y channel LSB
|
||||
#define OPT4048_REG_CH2_MSB 0x04 // Z channel MSB
|
||||
#define OPT4048_REG_CH2_LSB 0x05 // Z channel LSB
|
||||
#define OPT4048_REG_CH3_MSB 0x06 // W channel MSB
|
||||
#define OPT4048_REG_CH3_LSB 0x07 // W channel LSB
|
||||
#define OPT4048_REG_THRESHOLD_LOW 0x08 // Low threshold register
|
||||
#define OPT4048_REG_THRESHOLD_HIGH 0x09 // High threshold register
|
||||
#define OPT4048_REG_CONFIG 0x0A // Configuration register
|
||||
#define OPT4048_REG_THRESHOLD_CFG 0x0B // Threshold configuration register
|
||||
#define OPT4048_REG_STATUS 0x0C // Status register
|
||||
#define OPT4048_REG_DEVICE_ID 0x11 // Device ID register
|
||||
|
||||
// Status register (0x0C) bit flags
|
||||
#define OPT4048_FLAG_L 0x01 // Flag low - measurement smaller than threshold
|
||||
#define OPT4048_FLAG_H 0x02 // Flag high - measurement larger than threshold
|
||||
#define OPT4048_FLAG_CONVERSION_READY 0x04 // Conversion ready
|
||||
#define OPT4048_FLAG_OVERLOAD 0x08 // Overflow condition
|
||||
|
||||
/**
|
||||
@brief Class that stores state and functions for interacting with the OPT4048 sensor.
|
||||
|
|
@ -48,11 +136,48 @@ public:
|
|||
* @return true on success, false on failure
|
||||
*/
|
||||
bool begin(uint8_t addr = OPT4048_DEFAULT_ADDR, TwoWire *wire = &Wire);
|
||||
/** Read all four channels, verify CRC, and return raw ADC code values */
|
||||
bool getChannels(float *ch0, float *ch1, float *ch2, float *ch3);
|
||||
|
||||
/**
|
||||
* @brief Read all four channels, verify CRC, and return raw ADC code values
|
||||
*
|
||||
* @param ch0 Pointer to store channel 0 (X) value
|
||||
* @param ch1 Pointer to store channel 1 (Y) value
|
||||
* @param ch2 Pointer to store channel 2 (Z) value
|
||||
* @param ch3 Pointer to store channel 3 (W) value
|
||||
* @return true if successful, false otherwise
|
||||
*/
|
||||
bool getChannelsRaw(uint32_t *ch0, uint32_t *ch1, uint32_t *ch2, uint32_t *ch3);
|
||||
|
||||
bool setThresholdLow(uint32_t thl);
|
||||
uint32_t getThresholdLow(void);
|
||||
bool setThresholdHigh(uint32_t thh);
|
||||
uint32_t getThresholdHigh(void);
|
||||
bool setQuickWake(bool enable);
|
||||
bool getQuickWake(void);
|
||||
bool setRange(opt4048_range_t range);
|
||||
opt4048_range_t getRange(void);
|
||||
bool setConversionTime(opt4048_conversion_time_t convTime);
|
||||
opt4048_conversion_time_t getConversionTime(void);
|
||||
bool setMode(opt4048_mode_t mode);
|
||||
opt4048_mode_t getMode(void);
|
||||
bool setInterruptLatch(bool latch);
|
||||
bool getInterruptLatch(void);
|
||||
bool setInterruptPolarity(bool activeHigh);
|
||||
bool getInterruptPolarity(void);
|
||||
bool setFaultCount(opt4048_fault_count_t count);
|
||||
opt4048_fault_count_t getFaultCount(void);
|
||||
bool setThresholdChannel(uint8_t channel);
|
||||
uint8_t getThresholdChannel(void);
|
||||
bool setInterruptDirection(bool activeHigh);
|
||||
bool getInterruptDirection(void);
|
||||
bool setInterruptConfig(opt4048_int_cfg_t config);
|
||||
opt4048_int_cfg_t getInterruptConfig(void);
|
||||
uint8_t getFlags(void);
|
||||
bool getCIE(double *CIEx, double *CIEy, double *lux);
|
||||
|
||||
private:
|
||||
Adafruit_I2CDevice *i2c_dev;
|
||||
void encodeValue(uint32_t value, uint8_t *exp, uint32_t *mant);
|
||||
};
|
||||
|
||||
#endif // ADAFRUIT_OPT4048_H
|
||||
|
|
@ -1,29 +1,232 @@
|
|||
/*
|
||||
test_opt4048.ino
|
||||
Example sketch for OPT4048 ambient light sensor
|
||||
*/
|
||||
/*!
|
||||
* @file test_opt4048.ino
|
||||
*
|
||||
* A basic demo for using the OPT4048 tristimulus XYZ color sensor
|
||||
*
|
||||
* This example reads the sensor values from all four channels (X, Y, Z, W),
|
||||
* demonstrates setting and getting threshold values, and displays the results.
|
||||
*/
|
||||
|
||||
#include <Wire.h>
|
||||
#include "Adafruit_OPT4048.h"
|
||||
|
||||
// Create sensor object
|
||||
Adafruit_OPT4048 sensor;
|
||||
|
||||
void setup() {
|
||||
// Initialize serial communication
|
||||
Serial.begin(115200);
|
||||
|
||||
// Wait for serial monitor to open
|
||||
while (!Serial) {
|
||||
delay(10);
|
||||
}
|
||||
Serial.println("OPT4048 Test");
|
||||
|
||||
Serial.println("Adafruit OPT4048 Tristimulus XYZ Color Sensor Test");
|
||||
|
||||
// Initialize the sensor
|
||||
if (!sensor.begin()) {
|
||||
Serial.println("Failed to find OPT4048 chip");
|
||||
while (1) {
|
||||
delay(10);
|
||||
}
|
||||
}
|
||||
Serial.println("OPT4048 found!");
|
||||
|
||||
Serial.println("OPT4048 sensor found!");
|
||||
|
||||
// Set low and high thresholds for interrupts
|
||||
uint32_t lowThreshold = 1000;
|
||||
uint32_t highThreshold = 10000;
|
||||
|
||||
Serial.print("Setting low threshold to: ");
|
||||
Serial.println(lowThreshold);
|
||||
sensor.setThresholdLow(lowThreshold);
|
||||
|
||||
Serial.print("Setting high threshold to: ");
|
||||
Serial.println(highThreshold);
|
||||
sensor.setThresholdHigh(highThreshold);
|
||||
|
||||
// Read back the thresholds to verify
|
||||
uint32_t readLowThreshold = sensor.getThresholdLow();
|
||||
uint32_t readHighThreshold = sensor.getThresholdHigh();
|
||||
|
||||
Serial.print("Read back low threshold: ");
|
||||
Serial.println(readLowThreshold);
|
||||
Serial.print("Read back high threshold: ");
|
||||
Serial.println(readHighThreshold);
|
||||
|
||||
// Enable Quick Wake feature
|
||||
Serial.println("\nEnabling Quick Wake feature...");
|
||||
sensor.setQuickWake(true);
|
||||
|
||||
// Read back Quick Wake status
|
||||
bool quickWakeStatus = sensor.getQuickWake();
|
||||
Serial.print("Quick Wake status: ");
|
||||
Serial.println(quickWakeStatus ? "Enabled" : "Disabled");
|
||||
|
||||
// Set range to auto
|
||||
Serial.println("\nSetting range to Auto...");
|
||||
sensor.setRange(OPT4048_RANGE_AUTO);
|
||||
|
||||
// Read back range setting
|
||||
opt4048_range_t currentRange = sensor.getRange();
|
||||
Serial.print("Current range setting: ");
|
||||
switch (currentRange) {
|
||||
case OPT4048_RANGE_2K_LUX: Serial.println("2.2 klux"); break;
|
||||
case OPT4048_RANGE_4K_LUX: Serial.println("4.5 klux"); break;
|
||||
case OPT4048_RANGE_9K_LUX: Serial.println("9 klux"); break;
|
||||
case OPT4048_RANGE_18K_LUX: Serial.println("18 klux"); break;
|
||||
case OPT4048_RANGE_36K_LUX: Serial.println("36 klux"); break;
|
||||
case OPT4048_RANGE_72K_LUX: Serial.println("72 klux"); break;
|
||||
case OPT4048_RANGE_144K_LUX: Serial.println("144 klux"); break;
|
||||
case OPT4048_RANGE_AUTO: Serial.println("Auto"); break;
|
||||
default: Serial.println("Unknown"); break;
|
||||
}
|
||||
|
||||
// Set conversion time to 100ms
|
||||
Serial.println("\nSetting conversion time to 100ms...");
|
||||
sensor.setConversionTime(OPT4048_CONVERSION_TIME_100MS);
|
||||
|
||||
// Read back conversion time setting
|
||||
opt4048_conversion_time_t currentConvTime = sensor.getConversionTime();
|
||||
Serial.print("Current conversion time setting: ");
|
||||
switch (currentConvTime) {
|
||||
case OPT4048_CONVERSION_TIME_600US: Serial.println("600 microseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_1MS: Serial.println("1 millisecond"); break;
|
||||
case OPT4048_CONVERSION_TIME_1_8MS: Serial.println("1.8 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_3_4MS: Serial.println("3.4 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_6_5MS: Serial.println("6.5 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_12_7MS: Serial.println("12.7 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_25MS: Serial.println("25 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_50MS: Serial.println("50 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_100MS: Serial.println("100 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_200MS: Serial.println("200 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_400MS: Serial.println("400 milliseconds"); break;
|
||||
case OPT4048_CONVERSION_TIME_800MS: Serial.println("800 milliseconds"); break;
|
||||
default: Serial.println("Unknown"); break;
|
||||
}
|
||||
|
||||
// Set operating mode to continuous
|
||||
Serial.println("\nSetting operating mode to Continuous...");
|
||||
sensor.setMode(OPT4048_MODE_CONTINUOUS);
|
||||
|
||||
// Read back operating mode setting
|
||||
opt4048_mode_t currentMode = sensor.getMode();
|
||||
Serial.print("Current operating mode: ");
|
||||
switch (currentMode) {
|
||||
case OPT4048_MODE_POWERDOWN: Serial.println("Power-down"); break;
|
||||
case OPT4048_MODE_AUTO_ONESHOT: Serial.println("Forced auto-range one-shot"); break;
|
||||
case OPT4048_MODE_ONESHOT: Serial.println("One-shot"); break;
|
||||
case OPT4048_MODE_CONTINUOUS: Serial.println("Continuous"); break;
|
||||
default: Serial.println("Unknown"); break;
|
||||
}
|
||||
|
||||
// Configure interrupt settings
|
||||
Serial.println("\nConfiguring interrupt settings...");
|
||||
sensor.setInterruptLatch(true); // Use latched interrupts
|
||||
sensor.setInterruptPolarity(true); // Use active-high interrupts
|
||||
|
||||
// Read back interrupt settings
|
||||
bool latchMode = sensor.getInterruptLatch();
|
||||
bool polarityMode = sensor.getInterruptPolarity();
|
||||
|
||||
Serial.print("Interrupt latch mode: ");
|
||||
Serial.println(latchMode ? "Latched" : "Transparent");
|
||||
|
||||
Serial.print("Interrupt polarity: ");
|
||||
Serial.println(polarityMode ? "Active-high" : "Active-low");
|
||||
|
||||
// Configure fault count
|
||||
Serial.println("\nSetting fault count to 4 consecutive faults...");
|
||||
sensor.setFaultCount(OPT4048_FAULT_COUNT_4);
|
||||
|
||||
// Read back fault count setting
|
||||
opt4048_fault_count_t faultCount = sensor.getFaultCount();
|
||||
Serial.print("Fault count setting: ");
|
||||
switch (faultCount) {
|
||||
case OPT4048_FAULT_COUNT_1: Serial.println("1 fault count"); break;
|
||||
case OPT4048_FAULT_COUNT_2: Serial.println("2 consecutive fault counts"); break;
|
||||
case OPT4048_FAULT_COUNT_4: Serial.println("4 consecutive fault counts"); break;
|
||||
case OPT4048_FAULT_COUNT_8: Serial.println("8 consecutive fault counts"); break;
|
||||
default: Serial.println("Unknown"); break;
|
||||
}
|
||||
|
||||
// Configure threshold channel
|
||||
Serial.println("\nSetting threshold channel to Channel 1 (Y)...");
|
||||
sensor.setThresholdChannel(1);
|
||||
|
||||
// Read back threshold channel setting
|
||||
uint8_t threshChannel = sensor.getThresholdChannel();
|
||||
Serial.print("Threshold channel setting: Channel ");
|
||||
Serial.print(threshChannel);
|
||||
switch (threshChannel) {
|
||||
case 0: Serial.println(" (X)"); break;
|
||||
case 1: Serial.println(" (Y)"); break;
|
||||
case 2: Serial.println(" (Z)"); break;
|
||||
case 3: Serial.println(" (W)"); break;
|
||||
default: Serial.println(" (Unknown)"); break;
|
||||
}
|
||||
|
||||
// Configure interrupt configuration
|
||||
Serial.println("\nSetting interrupt configuration to data ready for all channels...");
|
||||
sensor.setInterruptConfig(OPT4048_INT_CFG_DATA_READY_ALL);
|
||||
|
||||
// Read back interrupt configuration setting
|
||||
opt4048_int_cfg_t intConfig = sensor.getInterruptConfig();
|
||||
Serial.print("Interrupt configuration: ");
|
||||
switch (intConfig) {
|
||||
case OPT4048_INT_CFG_SMBUS_ALERT: Serial.println("SMBUS Alert"); break;
|
||||
case OPT4048_INT_CFG_DATA_READY_NEXT: Serial.println("INT Pin data ready for next channel"); break;
|
||||
case OPT4048_INT_CFG_DATA_READY_ALL: Serial.println("INT Pin data ready for all channels"); break;
|
||||
default: Serial.println("Unknown"); break;
|
||||
}
|
||||
Serial.println();
|
||||
}
|
||||
|
||||
void loop() {
|
||||
// Nothing to do (testing only initialization)
|
||||
delay(1000);
|
||||
uint32_t x, y, z, w;
|
||||
|
||||
// Read all four channels from the sensor (raw ADC values)
|
||||
if (sensor.getChannelsRaw(&x, &y, &z, &w)) {
|
||||
Serial.println("Channel readings (raw values):");
|
||||
Serial.print("X (CH0): "); Serial.println(x);
|
||||
Serial.print("Y (CH1): "); Serial.println(y);
|
||||
Serial.print("Z (CH2): "); Serial.println(z);
|
||||
Serial.print("W (CH3): "); Serial.println(w);
|
||||
|
||||
// Read and print status flags
|
||||
uint8_t flags = sensor.getFlags();
|
||||
Serial.println("\nStatus Flags:");
|
||||
if (flags & OPT4048_FLAG_L) {
|
||||
Serial.println("- Measurement below low threshold");
|
||||
}
|
||||
if (flags & OPT4048_FLAG_H) {
|
||||
Serial.println("- Measurement above high threshold");
|
||||
}
|
||||
if (flags & OPT4048_FLAG_CONVERSION_READY) {
|
||||
Serial.println("- Conversion complete");
|
||||
}
|
||||
if (flags & OPT4048_FLAG_OVERLOAD) {
|
||||
Serial.println("- Overflow condition detected");
|
||||
}
|
||||
if (flags == 0) {
|
||||
Serial.println("- No flags set");
|
||||
}
|
||||
|
||||
// Calculate and display CIE chromaticity coordinates and lux
|
||||
double CIEx, CIEy, lux;
|
||||
if (sensor.getCIE(&CIEx, &CIEy, &lux)) {
|
||||
Serial.println("\nCIE Coordinates:");
|
||||
Serial.print("CIE x: "); Serial.println(CIEx, 8);
|
||||
Serial.print("CIE y: "); Serial.println(CIEy, 8);
|
||||
Serial.print("Lux: "); Serial.println(lux, 4);
|
||||
} else {
|
||||
Serial.println("\nError calculating CIE coordinates");
|
||||
}
|
||||
Serial.println();
|
||||
} else {
|
||||
Serial.println("Error reading sensor data");
|
||||
}
|
||||
|
||||
delay(1000); // Read once per second
|
||||
}
|
||||
Loading…
Reference in a new issue