adafruit/Adafruit_TSL2561
1
0
Fork 1
mirror of https://github.com/adafruit/Adafruit_TSL2561.git synced 2025-08-01 01:44:27 +02:00
Code Issues Packages Projects Releases Wiki Activity

Moved repository to actions

Browse Source
This commit is contained in:
dherrada
2020-05-26 11:37:42 -04:00
parent df395e8712
commit f882164c9b
6 changed files with 328 additions and 325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
.github/workflows/githubci.yml vendored Normal file
View File

@@ -0,0 +1,32 @@
name: Arduino Library CI
on: [pull_request, push, repository_dispatch]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/setup-python@v1
with:
python-version: '3.x'
- uses: actions/checkout@v2
- uses: actions/checkout@v2
with:
repository: adafruit/ci-arduino
path: ci
- name: pre-install
run: bash ci/actions_install.sh
- name: test platforms
run: python3 ci/build_platform.py main_platforms
- name: clang
run: python3 ci/run-clang-format.py -e "ci/*" -e "bin/*" -r .
- name: doxygen
env:
GH_REPO_TOKEN: ${{ secrets.GH_REPO_TOKEN }}
PRETTYNAME : "Adafruit TSL2561 Light Sensor Library"
run: bash ci/doxy_gen_and_deploy.sh

27
.travis.yml
View File

@@ -1,27 +0,0 @@
language: c
sudo: false
# Blacklist
branches:
except:
- gh-pages
env:
global:
- PRETTYNAME="Adafruit TSL2561 Arduino Library"
# Optional, will default to "$TRAVIS_BUILD_DIR/Doxyfile"
# - DOXYFILE: $TRAVIS_BUILD_DIR/Doxyfile
before_install:
- source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/install.sh)
install:
- arduino --install-library "Adafruit Unified Sensor"
script:
- build_main_platforms
# Generate and deploy documentation
after_success:
- source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/library_check.sh)
- source <(curl -SLs https://raw.githubusercontent.com/adafruit/travis-ci-arduino/master/doxy_gen_and_deploy.sh)

221
Adafruit_TSL2561_U.cpp
View File

@@ -18,9 +18,10 @@
* *
* @section dependencies Dependencies * @section dependencies Dependencies
* *
* This library depends on <a href="https://github.com/adafruit/Adafruit_Sensor"> * This library depends on <a
* Adafruit_Sensor</a> being present on your system. Please make sure you have * href="https://github.com/adafruit/Adafruit_Sensor"> Adafruit_Sensor</a> being
* installed the latest version before using this library. * present on your system. Please make sure you have installed the latest
* version before using this library.
* *
* @section author Author * @section author Author
* *
@@ -52,8 +53,8 @@
keep track if you have many sensors in use keep track if you have many sensors in use
*/ */
/**************************************************************************/ /**************************************************************************/
Adafruit_TSL2561_Unified::Adafruit_TSL2561_Unified(uint8_t addr, int32_t sensorID) Adafruit_TSL2561_Unified::Adafruit_TSL2561_Unified(uint8_t addr,
{ int32_t sensorID) {
_addr = addr; _addr = addr;
_tsl2561Initialised = false; _tsl2561Initialised = false;
_tsl2561AutoGain = false; _tsl2561AutoGain = false;
@@ -73,8 +74,7 @@ Adafruit_TSL2561_Unified::Adafruit_TSL2561_Unified(uint8_t addr, int32_t sensorI
@returns True if sensor is found and initialized, false otherwise. @returns True if sensor is found and initialized, false otherwise.
*/ */
/**************************************************************************/ /**************************************************************************/
boolean Adafruit_TSL2561_Unified::begin() boolean Adafruit_TSL2561_Unified::begin() {
{
_i2c = &Wire; _i2c = &Wire;
_i2c->begin(); _i2c->begin();
return init(); return init();
@@ -88,8 +88,7 @@ boolean Adafruit_TSL2561_Unified::begin()
@returns True if sensor is found and initialized, false otherwise. @returns True if sensor is found and initialized, false otherwise.
*/ */
/**************************************************************************/ /**************************************************************************/
boolean Adafruit_TSL2561_Unified::begin(TwoWire *theWire) boolean Adafruit_TSL2561_Unified::begin(TwoWire *theWire) {
{
_i2c = theWire; _i2c = theWire;
_i2c->begin(); _i2c->begin();
return init(); return init();
@@ -103,8 +102,7 @@ boolean Adafruit_TSL2561_Unified::begin(TwoWire *theWire)
@returns True if sensor is found and initialized, false otherwise. @returns True if sensor is found and initialized, false otherwise.
*/ */
/**************************************************************************/ /**************************************************************************/
boolean Adafruit_TSL2561_Unified::init() boolean Adafruit_TSL2561_Unified::init() {
{
/* Make sure we're actually connected */ /* Make sure we're actually connected */
uint8_t x = read8(TSL2561_REGISTER_ID); uint8_t x = read8(TSL2561_REGISTER_ID);
if (x & 0x05) { // ID code for TSL2561 if (x & 0x05) { // ID code for TSL2561
@@ -129,8 +127,7 @@ boolean Adafruit_TSL2561_Unified::init()
@param enable Set to true to enable, False to disable @param enable Set to true to enable, False to disable
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::enableAutoRange(bool enable) void Adafruit_TSL2561_Unified::enableAutoRange(bool enable) {
{
_tsl2561AutoGain = enable; _tsl2561AutoGain = enable;
} }
@@ -142,9 +139,10 @@ void Adafruit_TSL2561_Unified::enableAutoRange(bool enable)
@param time The amount of time we'd like to add up values @param time The amount of time we'd like to add up values
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::setIntegrationTime(tsl2561IntegrationTime_t time) void Adafruit_TSL2561_Unified::setIntegrationTime(
{ tsl2561IntegrationTime_t time) {
if (!_tsl2561Initialised) begin(); if (!_tsl2561Initialised)
begin();
/* Enable the device by setting the control bit to 0x03 */ /* Enable the device by setting the control bit to 0x03 */
enable(); enable();
@@ -165,15 +163,16 @@ void Adafruit_TSL2561_Unified::setIntegrationTime(tsl2561IntegrationTime_t time)
@param gain The value we'd like to set the gain to @param gain The value we'd like to set the gain to
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::setGain(tsl2561Gain_t gain) void Adafruit_TSL2561_Unified::setGain(tsl2561Gain_t gain) {
{ if (!_tsl2561Initialised)
if (!_tsl2561Initialised) begin(); begin();
/* Enable the device by setting the control bit to 0x03 */ /* Enable the device by setting the control bit to 0x03 */
enable(); enable();
/* Update the timing register */ /* Update the timing register */
write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, _tsl2561IntegrationTime | gain); write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING,
_tsl2561IntegrationTime | gain);
/* Update value placeholders */ /* Update value placeholders */
_tsl2561Gain = gain; _tsl2561Gain = gain;
@@ -192,30 +191,28 @@ void Adafruit_TSL2561_Unified::setGain(tsl2561Gain_t gain)
IR-only light diode. IR-only light diode.
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::getLuminosity (uint16_t *broadband, uint16_t *ir) void Adafruit_TSL2561_Unified::getLuminosity(uint16_t *broadband,
{ uint16_t *ir) {
bool valid = false; bool valid = false;
if (!_tsl2561Initialised) begin(); if (!_tsl2561Initialised)
begin();
/* If Auto gain disabled get a single reading and continue */ /* If Auto gain disabled get a single reading and continue */
if(!_tsl2561AutoGain) if (!_tsl2561AutoGain) {
{
getData(broadband, ir); getData(broadband, ir);
return; return;
} }
/* Read data until we find a valid range */ /* Read data until we find a valid range */
bool _agcCheck = false; bool _agcCheck = false;
do do {
{
uint16_t _b, _ir; uint16_t _b, _ir;
uint16_t _hi, _lo; uint16_t _hi, _lo;
tsl2561IntegrationTime_t _it = _tsl2561IntegrationTime; tsl2561IntegrationTime_t _it = _tsl2561IntegrationTime;
/* Get the hi/low threshold for the current integration time */ /* Get the hi/low threshold for the current integration time */
switch(_it) switch (_it) {
{
case TSL2561_INTEGRATIONTIME_13MS: case TSL2561_INTEGRATIONTIME_13MS:
_hi = TSL2561_AGC_THI_13MS; _hi = TSL2561_AGC_THI_13MS;
_lo = TSL2561_AGC_TLO_13MS; _lo = TSL2561_AGC_TLO_13MS;
@@ -233,37 +230,29 @@ void Adafruit_TSL2561_Unified::getLuminosity (uint16_t *broadband, uint16_t *ir)
getData(&_b, &_ir); getData(&_b, &_ir);
/* Run an auto-gain check if we haven't already done so ... */ /* Run an auto-gain check if we haven't already done so ... */
if (!_agcCheck) if (!_agcCheck) {
{ if ((_b < _lo) && (_tsl2561Gain == TSL2561_GAIN_1X)) {
if ((_b < _lo) && (_tsl2561Gain == TSL2561_GAIN_1X))
{
/* Increase the gain and try again */ /* Increase the gain and try again */
setGain(TSL2561_GAIN_16X); setGain(TSL2561_GAIN_16X);
/* Drop the previous conversion results */ /* Drop the previous conversion results */
getData(&_b, &_ir); getData(&_b, &_ir);
/* Set a flag to indicate we've adjusted the gain */ /* Set a flag to indicate we've adjusted the gain */
_agcCheck = true; _agcCheck = true;
} } else if ((_b > _hi) && (_tsl2561Gain == TSL2561_GAIN_16X)) {
else if ((_b > _hi) && (_tsl2561Gain == TSL2561_GAIN_16X))
{
/* Drop gain to 1x and try again */ /* Drop gain to 1x and try again */
setGain(TSL2561_GAIN_1X); setGain(TSL2561_GAIN_1X);
/* Drop the previous conversion results */ /* Drop the previous conversion results */
getData(&_b, &_ir); getData(&_b, &_ir);
/* Set a flag to indicate we've adjusted the gain */ /* Set a flag to indicate we've adjusted the gain */
_agcCheck = true; _agcCheck = true;
} } else {
else
{
/* Nothing to look at here, keep moving .... /* Nothing to look at here, keep moving ....
Reading is either valid, or we're already at the chips limits */ Reading is either valid, or we're already at the chips limits */
*broadband = _b; *broadband = _b;
*ir = _ir; *ir = _ir;
valid = true; valid = true;
} }
} } else {
else
{
/* If we've already adjusted the gain once, just return the new results. /* If we've already adjusted the gain once, just return the new results.
This avoids endless loops where a value is at one extreme pre-gain, This avoids endless loops where a value is at one extreme pre-gain,
and the the other extreme post-gain */ and the the other extreme post-gain */
@@ -274,17 +263,15 @@ void Adafruit_TSL2561_Unified::getLuminosity (uint16_t *broadband, uint16_t *ir)
} while (!valid); } while (!valid);
} }
/**************************************************************************/ /**************************************************************************/
/*! /*!
Enables the device Enables the device
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::enable(void) void Adafruit_TSL2561_Unified::enable(void) {
{
/* Enable the device by setting the control bit to 0x03 */ /* Enable the device by setting the control bit to 0x03 */
write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWERON); write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL,
TSL2561_CONTROL_POWERON);
} }
/**************************************************************************/ /**************************************************************************/
@@ -292,10 +279,10 @@ void Adafruit_TSL2561_Unified::enable(void)
Disables the device (putting it in lower power sleep mode) Disables the device (putting it in lower power sleep mode)
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::disable(void) void Adafruit_TSL2561_Unified::disable(void) {
{
/* Turn the device off to save power */ /* Turn the device off to save power */
write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWEROFF); write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL,
TSL2561_CONTROL_POWEROFF);
} }
/**************************************************************************/ /**************************************************************************/
@@ -303,14 +290,12 @@ void Adafruit_TSL2561_Unified::disable(void)
Private function to read luminosity on both channels Private function to read luminosity on both channels
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::getData (uint16_t *broadband, uint16_t *ir) void Adafruit_TSL2561_Unified::getData(uint16_t *broadband, uint16_t *ir) {
{
/* Enable the device by setting the control bit to 0x03 */ /* Enable the device by setting the control bit to 0x03 */
enable(); enable();
/* Wait x ms for ADC to complete */ /* Wait x ms for ADC to complete */
switch (_tsl2561IntegrationTime) switch (_tsl2561IntegrationTime) {
{
case TSL2561_INTEGRATIONTIME_13MS: case TSL2561_INTEGRATIONTIME_13MS:
delay(TSL2561_DELAY_INTTIME_13MS); // KTOWN: Was 14ms delay(TSL2561_DELAY_INTTIME_13MS); // KTOWN: Was 14ms
break; break;
@@ -323,16 +308,17 @@ void Adafruit_TSL2561_Unified::getData (uint16_t *broadband, uint16_t *ir)
} }
/* Reads a two byte value from channel 0 (visible + infrared) */ /* Reads a two byte value from channel 0 (visible + infrared) */
*broadband = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW); *broadband = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT |
TSL2561_REGISTER_CHAN0_LOW);
/* Reads a two byte value from channel 1 (infrared) */ /* Reads a two byte value from channel 1 (infrared) */
*ir = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW); *ir = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT |
TSL2561_REGISTER_CHAN1_LOW);
/* Turn the device off to save power */ /* Turn the device off to save power */
disable(); disable();
} }
/**************************************************************************/ /**************************************************************************/
/*! /*!
@brief Converts the raw sensor values to the standard SI lux equivalent. @brief Converts the raw sensor values to the standard SI lux equivalent.
@@ -349,16 +335,15 @@ void Adafruit_TSL2561_Unified::getData (uint16_t *broadband, uint16_t *ir)
Returns Returns
*/ */
/**************************************************************************/ /**************************************************************************/
uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir) uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband,
{ uint16_t ir) {
unsigned long chScale; unsigned long chScale;
unsigned long channel1; unsigned long channel1;
unsigned long channel0; unsigned long channel0;
/* Make sure the sensor isn't saturated! */ /* Make sure the sensor isn't saturated! */
uint16_t clipThreshold; uint16_t clipThreshold;
switch (_tsl2561IntegrationTime) switch (_tsl2561IntegrationTime) {
{
case TSL2561_INTEGRATIONTIME_13MS: case TSL2561_INTEGRATIONTIME_13MS:
clipThreshold = TSL2561_CLIPPING_13MS; clipThreshold = TSL2561_CLIPPING_13MS;
break; break;
@@ -371,14 +356,12 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
} }
/* Return 65536 lux if the sensor is saturated */ /* Return 65536 lux if the sensor is saturated */
if ((broadband > clipThreshold) || (ir > clipThreshold)) if ((broadband > clipThreshold) || (ir > clipThreshold)) {
{
return 65536; return 65536;
} }
/* Get the correct scale depending on the intergration time */ /* Get the correct scale depending on the intergration time */
switch (_tsl2561IntegrationTime) switch (_tsl2561IntegrationTime) {
{
case TSL2561_INTEGRATIONTIME_13MS: case TSL2561_INTEGRATIONTIME_13MS:
chScale = TSL2561_LUX_CHSCALE_TINT0; chScale = TSL2561_LUX_CHSCALE_TINT0;
break; break;
@@ -391,7 +374,8 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
} }
/* Scale for gain (1x or 16x) */ /* Scale for gain (1x or 16x) */
if (!_tsl2561Gain) chScale = chScale << 4; if (!_tsl2561Gain)
chScale = chScale << 4;
/* Scale the channel values */ /* Scale the channel values */
channel0 = (broadband * chScale) >> TSL2561_LUX_CHSCALE; channel0 = (broadband * chScale) >> TSL2561_LUX_CHSCALE;
@@ -399,7 +383,8 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
/* Find the ratio of the channel values (Channel1/Channel0) */ /* Find the ratio of the channel values (Channel1/Channel0) */
unsigned long ratio1 = 0; unsigned long ratio1 = 0;
if (channel0 != 0) ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE+1)) / channel0; if (channel0 != 0)
ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE + 1)) / channel0;
/* round the ratio value */ /* round the ratio value */
unsigned long ratio = (ratio1 + 1) >> 1; unsigned long ratio = (ratio1 + 1) >> 1;
@@ -407,39 +392,57 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
unsigned int b, m; unsigned int b, m;
#ifdef TSL2561_PACKAGE_CS #ifdef TSL2561_PACKAGE_CS
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C)) if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C)) {
{b=TSL2561_LUX_B1C; m=TSL2561_LUX_M1C;} b = TSL2561_LUX_B1C;
else if (ratio <= TSL2561_LUX_K2C) m = TSL2561_LUX_M1C;
{b=TSL2561_LUX_B2C; m=TSL2561_LUX_M2C;} } else if (ratio <= TSL2561_LUX_K2C) {
else if (ratio <= TSL2561_LUX_K3C) b = TSL2561_LUX_B2C;
{b=TSL2561_LUX_B3C; m=TSL2561_LUX_M3C;} m = TSL2561_LUX_M2C;
else if (ratio <= TSL2561_LUX_K4C) } else if (ratio <= TSL2561_LUX_K3C) {
{b=TSL2561_LUX_B4C; m=TSL2561_LUX_M4C;} b = TSL2561_LUX_B3C;
else if (ratio <= TSL2561_LUX_K5C) m = TSL2561_LUX_M3C;
{b=TSL2561_LUX_B5C; m=TSL2561_LUX_M5C;} } else if (ratio <= TSL2561_LUX_K4C) {
else if (ratio <= TSL2561_LUX_K6C) b = TSL2561_LUX_B4C;
{b=TSL2561_LUX_B6C; m=TSL2561_LUX_M6C;} m = TSL2561_LUX_M4C;
else if (ratio <= TSL2561_LUX_K7C) } else if (ratio <= TSL2561_LUX_K5C) {
{b=TSL2561_LUX_B7C; m=TSL2561_LUX_M7C;} b = TSL2561_LUX_B5C;
else if (ratio > TSL2561_LUX_K8C) m = TSL2561_LUX_M5C;
{b=TSL2561_LUX_B8C; m=TSL2561_LUX_M8C;} } else if (ratio <= TSL2561_LUX_K6C) {
b = TSL2561_LUX_B6C;
m = TSL2561_LUX_M6C;
} else if (ratio <= TSL2561_LUX_K7C) {
b = TSL2561_LUX_B7C;
m = TSL2561_LUX_M7C;
} else if (ratio > TSL2561_LUX_K8C) {
b = TSL2561_LUX_B8C;
m = TSL2561_LUX_M8C;
}
#else #else
if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T)) if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T)) {
{b=TSL2561_LUX_B1T; m=TSL2561_LUX_M1T;} b = TSL2561_LUX_B1T;
else if (ratio <= TSL2561_LUX_K2T) m = TSL2561_LUX_M1T;
{b=TSL2561_LUX_B2T; m=TSL2561_LUX_M2T;} } else if (ratio <= TSL2561_LUX_K2T) {
else if (ratio <= TSL2561_LUX_K3T) b = TSL2561_LUX_B2T;
{b=TSL2561_LUX_B3T; m=TSL2561_LUX_M3T;} m = TSL2561_LUX_M2T;
else if (ratio <= TSL2561_LUX_K4T) } else if (ratio <= TSL2561_LUX_K3T) {
{b=TSL2561_LUX_B4T; m=TSL2561_LUX_M4T;} b = TSL2561_LUX_B3T;
else if (ratio <= TSL2561_LUX_K5T) m = TSL2561_LUX_M3T;
{b=TSL2561_LUX_B5T; m=TSL2561_LUX_M5T;} } else if (ratio <= TSL2561_LUX_K4T) {
else if (ratio <= TSL2561_LUX_K6T) b = TSL2561_LUX_B4T;
{b=TSL2561_LUX_B6T; m=TSL2561_LUX_M6T;} m = TSL2561_LUX_M4T;
else if (ratio <= TSL2561_LUX_K7T) } else if (ratio <= TSL2561_LUX_K5T) {
{b=TSL2561_LUX_B7T; m=TSL2561_LUX_M7T;} b = TSL2561_LUX_B5T;
else if (ratio > TSL2561_LUX_K8T) m = TSL2561_LUX_M5T;
{b=TSL2561_LUX_B8T; m=TSL2561_LUX_M8T;} } else if (ratio <= TSL2561_LUX_K6T) {
b = TSL2561_LUX_B6T;
m = TSL2561_LUX_M6T;
} else if (ratio <= TSL2561_LUX_K7T) {
b = TSL2561_LUX_B7T;
m = TSL2561_LUX_M7T;
} else if (ratio > TSL2561_LUX_K8T) {
b = TSL2561_LUX_B8T;
m = TSL2561_LUX_M8T;
}
#endif #endif
unsigned long temp; unsigned long temp;
@@ -448,7 +451,8 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
temp = 0; temp = 0;
/* Do not allow negative lux value */ /* Do not allow negative lux value */
if (channel0 > channel1) temp = channel0 - channel1; if (channel0 > channel1)
temp = channel0 - channel1;
/* Round lsb (2^(LUX_SCALE-1)) */ /* Round lsb (2^(LUX_SCALE-1)) */
temp += (1 << (TSL2561_LUX_LUXSCALE - 1)); temp += (1 << (TSL2561_LUX_LUXSCALE - 1));
@@ -469,8 +473,7 @@ uint32_t Adafruit_TSL2561_Unified::calculateLux(uint16_t broadband, uint16_t ir)
false if sensor is saturated false if sensor is saturated
*/ */
/**************************************************************************/ /**************************************************************************/
bool Adafruit_TSL2561_Unified::getEvent(sensors_event_t *event) bool Adafruit_TSL2561_Unified::getEvent(sensors_event_t *event) {
{
uint16_t broadband, ir; uint16_t broadband, ir;
/* Clear the event */ /* Clear the event */
@@ -498,8 +501,7 @@ bool Adafruit_TSL2561_Unified::getEvent(sensors_event_t *event)
details about the TSL2561 and its capabilities details about the TSL2561 and its capabilities
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::getSensor(sensor_t *sensor) void Adafruit_TSL2561_Unified::getSensor(sensor_t *sensor) {
{
/* Clear the sensor_t object */ /* Clear the sensor_t object */
memset(sensor, 0, sizeof(sensor_t)); memset(sensor, 0, sizeof(sensor_t));
@@ -515,8 +517,6 @@ void Adafruit_TSL2561_Unified::getSensor(sensor_t *sensor)
sensor->resolution = 1.0; sensor->resolution = 1.0;
} }
/*========================================================================*/ /*========================================================================*/
/* PRIVATE FUNCTIONS */ /* PRIVATE FUNCTIONS */
/*========================================================================*/ /*========================================================================*/
@@ -528,8 +528,7 @@ void Adafruit_TSL2561_Unified::getSensor(sensor_t *sensor)
@param value The 8-bit value we're writing to the register @param value The 8-bit value we're writing to the register
*/ */
/**************************************************************************/ /**************************************************************************/
void Adafruit_TSL2561_Unified::write8 (uint8_t reg, uint8_t value) void Adafruit_TSL2561_Unified::write8(uint8_t reg, uint8_t value) {
{
_i2c->beginTransmission(_addr); _i2c->beginTransmission(_addr);
_i2c->write(reg); _i2c->write(reg);
_i2c->write(value); _i2c->write(value);
@@ -543,8 +542,7 @@ void Adafruit_TSL2561_Unified::write8 (uint8_t reg, uint8_t value)
@returns 8-bit value containing single byte data read @returns 8-bit value containing single byte data read
*/ */
/**************************************************************************/ /**************************************************************************/
uint8_t Adafruit_TSL2561_Unified::read8(uint8_t reg) uint8_t Adafruit_TSL2561_Unified::read8(uint8_t reg) {
{
_i2c->beginTransmission(_addr); _i2c->beginTransmission(_addr);
_i2c->write(reg); _i2c->write(reg);
_i2c->endTransmission(); _i2c->endTransmission();
@@ -560,8 +558,7 @@ uint8_t Adafruit_TSL2561_Unified::read8(uint8_t reg)
@returns 16-bit value containing 2-byte data read @returns 16-bit value containing 2-byte data read
*/ */
/**************************************************************************/ /**************************************************************************/
uint16_t Adafruit_TSL2561_Unified::read16(uint8_t reg) uint16_t Adafruit_TSL2561_Unified::read16(uint8_t reg) {
{
uint16_t x, t; uint16_t x, t;
_i2c->beginTransmission(_addr); _i2c->beginTransmission(_addr);

40
Adafruit_TSL2561_U.h
View File

@@ -21,8 +21,8 @@
#ifndef ADAFRUIT_TSL2561_H_ #ifndef ADAFRUIT_TSL2561_H_
#define ADAFRUIT_TSL2561_H_ #define ADAFRUIT_TSL2561_H_
#include <Arduino.h>
#include <Adafruit_Sensor.h> #include <Adafruit_Sensor.h>
#include <Arduino.h>
#include <Wire.h> #include <Wire.h>
#define TSL2561_VISIBLE 2 ///< channel 0 - channel 1 #define TSL2561_VISIBLE 2 ///< channel 0 - channel 1
@@ -39,12 +39,14 @@
#define TSL2561_PACKAGE_T_FN_CL ///< Dual Flat No-Lead package #define TSL2561_PACKAGE_T_FN_CL ///< Dual Flat No-Lead package
#define TSL2561_COMMAND_BIT (0x80) ///< Must be 1 #define TSL2561_COMMAND_BIT (0x80) ///< Must be 1
#define TSL2561_CLEAR_BIT (0x40) ///< Clears any pending interrupt (write 1 to clear) #define TSL2561_CLEAR_BIT \
(0x40) ///< Clears any pending interrupt (write 1 to clear)
#define TSL2561_WORD_BIT (0x20) ///< 1 = read/write word (rather than byte) #define TSL2561_WORD_BIT (0x20) ///< 1 = read/write word (rather than byte)
#define TSL2561_BLOCK_BIT (0x10) ///< 1 = using block read/write #define TSL2561_BLOCK_BIT (0x10) ///< 1 = using block read/write
#define TSL2561_CONTROL_POWERON (0x03) ///< Control register setting to turn on #define TSL2561_CONTROL_POWERON (0x03) ///< Control register setting to turn on
#define TSL2561_CONTROL_POWEROFF (0x00) ///< Control register setting to turn off #define TSL2561_CONTROL_POWEROFF \
(0x00) ///< Control register setting to turn off
#define TSL2561_LUX_LUXSCALE (14) ///< Scale by 2^14 #define TSL2561_LUX_LUXSCALE (14) ///< Scale by 2^14
#define TSL2561_LUX_RATIOSCALE (9) ///< Scale ratio by 2^9 #define TSL2561_LUX_RATIOSCALE (9) ///< Scale ratio by 2^9
@@ -113,9 +115,12 @@
#define TSL2561_AGC_TLO_402MS (500) ///< Min value at Ti 402ms = 500 #define TSL2561_AGC_TLO_402MS (500) ///< Min value at Ti 402ms = 500
// Clipping thresholds // Clipping thresholds
#define TSL2561_CLIPPING_13MS (4900) ///< # Counts that trigger a change in gain/integration #define TSL2561_CLIPPING_13MS \
#define TSL2561_CLIPPING_101MS (37000) ///< # Counts that trigger a change in gain/integration (4900) ///< # Counts that trigger a change in gain/integration
#define TSL2561_CLIPPING_402MS (65000) ///< # Counts that trigger a change in gain/integration #define TSL2561_CLIPPING_101MS \
(37000) ///< # Counts that trigger a change in gain/integration
#define TSL2561_CLIPPING_402MS \
(65000) ///< # Counts that trigger a change in gain/integration
// Delay for integration times // Delay for integration times
#define TSL2561_DELAY_INTTIME_13MS (15) ///< Wait 15ms for 13ms integration #define TSL2561_DELAY_INTTIME_13MS (15) ///< Wait 15ms for 13ms integration
@@ -123,14 +128,14 @@
#define TSL2561_DELAY_INTTIME_402MS (450) ///< Wait 450ms for 402ms integration #define TSL2561_DELAY_INTTIME_402MS (450) ///< Wait 450ms for 402ms integration
/** TSL2561 I2C Registers */ /** TSL2561 I2C Registers */
enum enum {
{
TSL2561_REGISTER_CONTROL = 0x00, // Control/power register TSL2561_REGISTER_CONTROL = 0x00, // Control/power register
TSL2561_REGISTER_TIMING = 0x01, // Set integration time register TSL2561_REGISTER_TIMING = 0x01, // Set integration time register
TSL2561_REGISTER_THRESHHOLDL_LOW = 0x02, // Interrupt low threshold low-byte TSL2561_REGISTER_THRESHHOLDL_LOW = 0x02, // Interrupt low threshold low-byte
TSL2561_REGISTER_THRESHHOLDL_HIGH = 0x03, // Interrupt low threshold high-byte TSL2561_REGISTER_THRESHHOLDL_HIGH = 0x03, // Interrupt low threshold high-byte
TSL2561_REGISTER_THRESHHOLDH_LOW = 0x04, // Interrupt high threshold low-byte TSL2561_REGISTER_THRESHHOLDH_LOW = 0x04, // Interrupt high threshold low-byte
TSL2561_REGISTER_THRESHHOLDH_HIGH = 0x05, // Interrupt high threshold high-byte TSL2561_REGISTER_THRESHHOLDH_HIGH =
0x05, // Interrupt high threshold high-byte
TSL2561_REGISTER_INTERRUPT = 0x06, // Interrupt settings TSL2561_REGISTER_INTERRUPT = 0x06, // Interrupt settings
TSL2561_REGISTER_CRC = 0x08, // Factory use only TSL2561_REGISTER_CRC = 0x08, // Factory use only
TSL2561_REGISTER_ID = 0x0A, // TSL2561 identification setting TSL2561_REGISTER_ID = 0x0A, // TSL2561 identification setting
@@ -141,27 +146,22 @@ enum
}; };
/** Three options for how long to integrate readings for */ /** Three options for how long to integrate readings for */
typedef enum typedef enum {
{
TSL2561_INTEGRATIONTIME_13MS = 0x00, // 13.7ms TSL2561_INTEGRATIONTIME_13MS = 0x00, // 13.7ms
TSL2561_INTEGRATIONTIME_101MS = 0x01, // 101ms TSL2561_INTEGRATIONTIME_101MS = 0x01, // 101ms
TSL2561_INTEGRATIONTIME_402MS = 0x02 // 402ms TSL2561_INTEGRATIONTIME_402MS = 0x02 // 402ms
} } tsl2561IntegrationTime_t;
tsl2561IntegrationTime_t;
/** TSL2561 offers 2 gain settings */ /** TSL2561 offers 2 gain settings */
typedef enum typedef enum {
{
TSL2561_GAIN_1X = 0x00, // No gain TSL2561_GAIN_1X = 0x00, // No gain
TSL2561_GAIN_16X = 0x10, // 16x gain TSL2561_GAIN_16X = 0x10, // 16x gain
} } tsl2561Gain_t;
tsl2561Gain_t;
/**************************************************************************/ /**************************************************************************/
/*! /*!
@brief Class that stores state and functions for interacting with TSL2561 Light Sensor @brief Class that stores state and functions for interacting with TSL2561
Light Sensor
*/ */
/**************************************************************************/ /**************************************************************************/
class Adafruit_TSL2561_Unified : public Adafruit_Sensor { class Adafruit_TSL2561_Unified : public Adafruit_Sensor {

2
README.md
View File

@@ -1,4 +1,4 @@
# Adafruit TSL2561 Light Sensor Driver [![Build Status](https://travis-ci.com/adafruit/Adafruit_TSL2561.svg?branch=master)](https://travis-ci.com/adafruit/Adafruit_TSL2561) # Adafruit TSL2561 Light Sensor Driver [![Build Status](https://github.com/adafruit/Adafruit_TSL2561/workflows/Arduino%20Library%20CI/badge.svg)](https://github.com/adafruit/Adafruit_TSL2561/actions)[![Documentation](https://github.com/adafruit/ci-arduino/blob/master/assets/doxygen_badge.svg)](http://adafruit.github.io/Adafruit_TSL2561/html/index.html)
This driver is for the Adafruit TSL2561 Breakout, and is based on Adafruit's Unified Sensor Library (Adafruit_Sensor). This driver is for the Adafruit TSL2561 Breakout, and is based on Adafruit's Unified Sensor Library (Adafruit_Sensor).

3
library.properties
View File

@@ -1,5 +1,5 @@
name=Adafruit TSL2561 name=Adafruit TSL2561
version=1.0.3 version=1.1.0
author=Adafruit author=Adafruit
maintainer=Adafruit <info@adafruit.com> maintainer=Adafruit <info@adafruit.com>
sentence=Unified sensor driver for Adafruit's TSL2561 breakouts sentence=Unified sensor driver for Adafruit's TSL2561 breakouts
@@ -7,3 +7,4 @@ paragraph=Unified sensor driver for Adafruit's TSL2561 breakouts
category=Sensors category=Sensors
url=https://github.com/adafruit/Adafruit_TSL2561 url=https://github.com/adafruit/Adafruit_TSL2561
architectures=* architectures=*
depends=Adafruit Unified Sensor