klemen-home/st-anything
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

IP Configuration

Browse Source
This commit is contained in:
Gašper Dobrovoljc
2023-03-11 15:11:03 +01:00
commit ec125f27db
662 changed files with 103738 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

601
lib/Adafruit_TCS34725/Adafruit_TCS34725.cpp Normal file
View File

@@ -0,0 +1,601 @@
/*!
* @file Adafruit_TCS34725.cpp
*
* @mainpage Driver for the TCS34725 digital color sensors.
*
* @section intro_sec Introduction
*
* 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
*
* KTOWN (Adafruit Industries)
*
* @section license License
*
* BSD (see license.txt)
*
* @section HISTORY
*
* v1.0 - First release
*/
#ifdef __AVR
#include <avr/pgmspace.h>
#elif defined(ESP8266)
#include <pgmspace.h>
#endif
#include <math.h>
#include <stdlib.h>
#include "Adafruit_TCS34725.h"
/*!
* @brief Implements missing powf function
* @param x
* Base number
* @param y
* Exponent
* @return x raised to the power of y
*/
float powf(const float x, const float y) {
return (float)(pow((double)x, (double)y));
}
/*!
* @brief Writes a register and an 8 bit value over I2C
* @param reg
* @param value
*/
void Adafruit_TCS34725::write8(uint8_t reg, uint32_t value) {
_wire->beginTransmission(_i2caddr);
#if ARDUINO >= 100
_wire->write(TCS34725_COMMAND_BIT | reg);
_wire->write(value & 0xFF);
#else
_wire->send(TCS34725_COMMAND_BIT | reg);
_wire->send(value & 0xFF);
#endif
_wire->endTransmission();
}
/*!
* @brief Reads an 8 bit value over I2C
* @param reg
* @return value
*/
uint8_t Adafruit_TCS34725::read8(uint8_t reg) {
_wire->beginTransmission(_i2caddr);
#if ARDUINO >= 100
_wire->write(TCS34725_COMMAND_BIT | reg);
#else
_wire->send(TCS34725_COMMAND_BIT | reg);
#endif
_wire->endTransmission();
_wire->requestFrom(_i2caddr, 1);
#if ARDUINO >= 100
return _wire->read();
#else
return _wire->receive();
#endif
}
/*!
* @brief Reads a 16 bit values over I2C
* @param reg
* @return value
*/
uint16_t Adafruit_TCS34725::read16(uint8_t reg) {
uint16_t x;
uint16_t t;
_wire->beginTransmission(_i2caddr);
#if ARDUINO >= 100
_wire->write(TCS34725_COMMAND_BIT | reg);
#else
_wire->send(TCS34725_COMMAND_BIT | reg);
#endif
_wire->endTransmission();
_wire->requestFrom(_i2caddr, 2);
#if ARDUINO >= 100
t = _wire->read();
x = _wire->read();
#else
t = _wire->receive();
x = _wire->receive();
#endif
x <<= 8;
x |= t;
return x;
}
/*!
* @brief Enables the device
*/
void Adafruit_TCS34725::enable() {
write8(TCS34725_ENABLE, TCS34725_ENABLE_PON);
delay(3);
write8(TCS34725_ENABLE, TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN);
/* Set a delay for the integration time.
This is only necessary in the case where enabling and then
immediately trying to read values back. This is because setting
AEN triggers an automatic integration, so if a read RGBC is
performed too quickly, the data is not yet valid and all 0's are
returned */
switch (_tcs34725IntegrationTime) {
case TCS34725_INTEGRATIONTIME_2_4MS:
delay(3);
break;
case TCS34725_INTEGRATIONTIME_24MS:
delay(24);
break;
case TCS34725_INTEGRATIONTIME_50MS:
delay(50);
break;
case TCS34725_INTEGRATIONTIME_101MS:
delay(101);
break;
case TCS34725_INTEGRATIONTIME_154MS:
delay(154);
break;
case TCS34725_INTEGRATIONTIME_700MS:
delay(700);
break;
}
}
/*!
* @brief Disables the device (putting it in lower power sleep mode)
*/
void Adafruit_TCS34725::disable() {
/* Turn the device off to save power */
uint8_t reg = 0;
reg = read8(TCS34725_ENABLE);
write8(TCS34725_ENABLE, reg & ~(TCS34725_ENABLE_PON | TCS34725_ENABLE_AEN));
}
/*!
* @brief Constructor
* @param it
* Integration Time
* @param gain
* Gain
*/
Adafruit_TCS34725::Adafruit_TCS34725(tcs34725IntegrationTime_t it,
tcs34725Gain_t gain) {
_tcs34725Initialised = false;
_tcs34725IntegrationTime = it;
_tcs34725Gain = gain;
}
/*!
* @brief Initializes I2C and configures the sensor
* @param addr
* i2c address
* @return True if initialization was successful, otherwise false.
*/
boolean Adafruit_TCS34725::begin(uint8_t addr) {
_i2caddr = addr;
_wire = &Wire;
return init();
}
/*!
* @brief Initializes I2C and configures the sensor
* @param addr
* i2c address
* @param *theWire
* The Wire object
* @return True if initialization was successful, otherwise false.
*/
boolean Adafruit_TCS34725::begin(uint8_t addr, TwoWire *theWire) {
_i2caddr = addr;
_wire = theWire;
return init();
}
/*!
* @brief Initializes I2C and configures the sensor
* @return True if initialization was successful, otherwise false.
*/
boolean Adafruit_TCS34725::begin() {
_i2caddr = TCS34725_ADDRESS;
_wire = &Wire;
return init();
}
/*!
* @brief Part of begin
* @return True if initialization was successful, otherwise false.
*/
boolean Adafruit_TCS34725::init() {
_wire->begin();
/* Make sure we're actually connected */
uint8_t x = read8(TCS34725_ID);
if ((x != 0x44) && (x != 0x10)) {
return false;
}
_tcs34725Initialised = true;
/* Set default integration time and gain */
setIntegrationTime(_tcs34725IntegrationTime);
setGain(_tcs34725Gain);
/* Note: by default, the device is in power down mode on bootup */
enable();
return true;
}
/*!
* @brief Sets the integration time for the TC34725
* @param it
* Integration Time
*/
void Adafruit_TCS34725::setIntegrationTime(tcs34725IntegrationTime_t it) {
if (!_tcs34725Initialised)
begin();
/* Update the timing register */
write8(TCS34725_ATIME, it);
/* Update value placeholders */
_tcs34725IntegrationTime = it;
}
/*!
* @brief Adjusts the gain on the TCS34725
* @param gain
* Gain (sensitivity to light)
*/
void Adafruit_TCS34725::setGain(tcs34725Gain_t gain) {
if (!_tcs34725Initialised)
begin();
/* Update the timing register */
write8(TCS34725_CONTROL, gain);
/* Update value placeholders */
_tcs34725Gain = gain;
}
/*!
* @brief Reads the raw red, green, blue and clear channel values
* @param *r
* Red value
* @param *g
* Green value
* @param *b
* Blue value
* @param *c
* Clear channel value
*/
void Adafruit_TCS34725::getRawData(uint16_t *r, uint16_t *g, uint16_t *b,
uint16_t *c) {
if (!_tcs34725Initialised)
begin();
*c = read16(TCS34725_CDATAL);
*r = read16(TCS34725_RDATAL);
*g = read16(TCS34725_GDATAL);
*b = read16(TCS34725_BDATAL);
/* Set a delay for the integration time */
switch (_tcs34725IntegrationTime) {
case TCS34725_INTEGRATIONTIME_2_4MS:
delay(3);
break;
case TCS34725_INTEGRATIONTIME_24MS:
delay(24);
break;
case TCS34725_INTEGRATIONTIME_50MS:
delay(50);
break;
case TCS34725_INTEGRATIONTIME_101MS:
delay(101);
break;
case TCS34725_INTEGRATIONTIME_154MS:
delay(154);
break;
case TCS34725_INTEGRATIONTIME_700MS:
delay(700);
break;
}
}
/*!
* @brief Reads the raw red, green, blue and clear channel values in
* one-shot mode (e.g., wakes from sleep, takes measurement, enters
* sleep)
* @param *r
* Red value
* @param *g
* Green value
* @param *b
* Blue value
* @param *c
* Clear channel value
*/
void Adafruit_TCS34725::getRawDataOneShot(uint16_t *r, uint16_t *g, uint16_t *b,
uint16_t *c) {
if (!_tcs34725Initialised)
begin();
enable();
getRawData(r, g, b, c);
disable();
}
/*!
* @brief Read the RGB color detected by the sensor.
* @param *r
* Red value normalized to 0-255
* @param *g
* Green value normalized to 0-255
* @param *b
* Blue value normalized to 0-255
*/
void Adafruit_TCS34725::getRGB(float *r, float *g, float *b) {
uint16_t red, green, blue, clear;
getRawData(&red, &green, &blue, &clear);
uint32_t sum = clear;
// Avoid divide by zero errors ... if clear = 0 return black
if (clear == 0) {
*r = *g = *b = 0;
return;
}
*r = (float)red / sum * 255.0;
*g = (float)green / sum * 255.0;
*b = (float)blue / sum * 255.0;
}
/*!
* @brief Converts the raw R/G/B values to color temperature in degrees Kelvin
* @param r
* Red value
* @param g
* Green value
* @param b
* Blue value
* @return Color temperature in degrees Kelvin
*/
uint16_t Adafruit_TCS34725::calculateColorTemperature(uint16_t r, uint16_t g,
uint16_t b) {
float X, Y, Z; /* RGB to XYZ correlation */
float xc, yc; /* Chromaticity co-ordinates */
float n; /* McCamy's formula */
float cct;
/* 1. Map RGB values to their XYZ counterparts. */
/* Based on 6500K fluorescent, 3000K fluorescent */
/* and 60W incandescent values for a wide range. */
/* Note: Y = Illuminance or lux */
X = (-0.14282F * r) + (1.54924F * g) + (-0.95641F * b);
Y = (-0.32466F * r) + (1.57837F * g) + (-0.73191F * b);
Z = (-0.68202F * r) + (0.77073F * g) + (0.56332F * b);
/* 2. Calculate the chromaticity co-ordinates */
xc = (X) / (X + Y + Z);
yc = (Y) / (X + Y + Z);
/* 3. Use McCamy's formula to determine the CCT */
n = (xc - 0.3320F) / (0.1858F - yc);
/* Calculate the final CCT */
cct =
(449.0F * powf(n, 3)) + (3525.0F * powf(n, 2)) + (6823.3F * n) + 5520.33F;
/* Return the results in degrees Kelvin */
return (uint16_t)cct;
}
/*!
* @brief Converts the raw R/G/B values to color temperature in degrees
* Kelvin using the algorithm described in DN40 from Taos (now AMS).
* @param r
* Red value
* @param g
* Green value
* @param b
* Blue value
* @param c
* Clear channel value
* @return Color temperature in degrees Kelvin
*/
uint16_t Adafruit_TCS34725::calculateColorTemperature_dn40(uint16_t r,
uint16_t g,
uint16_t b,
uint16_t c) {
int rc; /* Error return code */
uint16_t r2, g2, b2; /* RGB values minus IR component */
int gl; /* Results of the initial lux conversion */
uint8_t gain_int; /* Gain multiplier as a normal integer */
uint16_t sat; /* Digital saturation level */
uint16_t ir; /* Inferred IR content */
/* Analog/Digital saturation:
*
* (a) As light becomes brighter, the clear channel will tend to
* saturate first since R+G+B is approximately equal to C.
* (b) The TCS34725 accumulates 1024 counts per 2.4ms of integration
* time, up to a maximum values of 65535. This means analog
* saturation can occur up to an integration time of 153.6ms
* (64*2.4ms=153.6ms).
* (c) If the integration time is > 153.6ms, digital saturation will
* occur before analog saturation. Digital saturation occurs when
* the count reaches 65535.
*/
if ((256 - _tcs34725IntegrationTime) > 63) {
/* Track digital saturation */
sat = 65535;
} else {
/* Track analog saturation */
sat = 1024 * (256 - _tcs34725IntegrationTime);
}
/* Ripple rejection:
*
* (a) An integration time of 50ms or multiples of 50ms are required to
* reject both 50Hz and 60Hz ripple.
* (b) If an integration time faster than 50ms is required, you may need
* to average a number of samples over a 50ms period to reject ripple
* from fluorescent and incandescent light sources.
*
* Ripple saturation notes:
*
* (a) If there is ripple in the received signal, the value read from C
* will be less than the max, but still have some effects of being
* saturated. This means that you can be below the 'sat' value, but
* still be saturating. At integration times >150ms this can be
* ignored, but <= 150ms you should calculate the 75% saturation
* level to avoid this problem.
*/
if ((256 - _tcs34725IntegrationTime) <= 63) {
/* Adjust sat to 75% to avoid analog saturation if atime < 153.6ms */
sat -= sat / 4;
}
/* Check for saturation and mark the sample as invalid if true */
if (c >= sat) {
return 0;
}
/* AMS RGB sensors have no IR channel, so the IR content must be */
/* calculated indirectly. */
ir = (r + g + b > c) ? (r + g + b - c) / 2 : 0;
/* Remove the IR component from the raw RGB values */
r2 = r - ir;
g2 = g - ir;
b2 = b - ir;
/* Convert gain to a usable integer value */
switch (_tcs34725Gain) {
case TCS34725_GAIN_4X: /* GAIN 4X */
gain_int = 4;
break;
case TCS34725_GAIN_16X: /* GAIN 16X */
gain_int = 16;
break;
case TCS34725_GAIN_60X: /* GAIN 60X */
gain_int = 60;
break;
case TCS34725_GAIN_1X: /* GAIN 1X */
default:
gain_int = 1;
break;
}
/* Calculate the counts per lux (CPL), taking into account the optional
* arguments for Glass Attenuation (GA) and Device Factor (DF).
*
* GA = 1/T where T is glass transmissivity, meaning if glass is 50%
* transmissive, the GA is 2 (1/0.5=2), and if the glass attenuates light
* 95% the GA is 20 (1/0.05). A GA of 1.0 assumes perfect transmission.
*
* NOTE: It is recommended to have a CPL > 5 to have a lux accuracy
* < +/- 0.5 lux, where the digitization error can be calculated via:
* 'DER = (+/-2) / CPL'.
*/
float cpl =
(((256 - _tcs34725IntegrationTime) * 2.4f) * gain_int) / (1.0f * 310.0f);
/* Determine lux accuracy (+/- lux) */
float der = 2.0f / cpl;
/* Determine the maximum lux value */
float max_lux = 65535.0 / (cpl * 3);
/* Lux is a function of the IR-compensated RGB channels and the associated
* color coefficients, with G having a particularly heavy influence to
* match the nature of the human eye.
*
* NOTE: The green value should be > 10 to ensure the accuracy of the lux
* conversions. If it is below 10, the gain should be increased, but
* the clear<100 check earlier should cover this edge case.
*/
gl = 0.136f * (float)r2 + /** Red coefficient. */
1.000f * (float)g2 + /** Green coefficient. */
-0.444f * (float)b2; /** Blue coefficient. */
float lux = gl / cpl;
/* A simple method of measuring color temp is to use the ratio of blue */
/* to red light, taking IR cancellation into account. */
uint16_t cct = (3810 * (uint32_t)b2) / /** Color temp coefficient. */
(uint32_t)r2 +
1391; /** Color temp offset. */
return cct;
}
/*!
* @brief Converts the raw R/G/B values to lux
* @param r
* Red value
* @param g
* Green value
* @param b
* Blue value
* @return Lux value
*/
uint16_t Adafruit_TCS34725::calculateLux(uint16_t r, uint16_t g, uint16_t b) {
float illuminance;
/* This only uses RGB ... how can we integrate clear or calculate lux */
/* based exclusively on clear since this might be more reliable? */
illuminance = (-0.32466F * r) + (1.57837F * g) + (-0.73191F * b);
return (uint16_t)illuminance;
}
/*!
* @brief Sets inerrupt for TCS34725
* @param i
* Interrupt (True/False)
*/
void Adafruit_TCS34725::setInterrupt(boolean i) {
uint8_t r = read8(TCS34725_ENABLE);
if (i) {
r |= TCS34725_ENABLE_AIEN;
} else {
r &= ~TCS34725_ENABLE_AIEN;
}
write8(TCS34725_ENABLE, r);
}
/*!
* @brief Clears inerrupt for TCS34725
*/
void Adafruit_TCS34725::clearInterrupt() {
_wire->beginTransmission(_i2caddr);
#if ARDUINO >= 100
_wire->write(TCS34725_COMMAND_BIT | 0x66);
#else
_wire->send(TCS34725_COMMAND_BIT | 0x66);
#endif
_wire->endTransmission();
}
/*!
* @brief Sets inerrupt limits
* @param low
* Low limit
* @param high
* High limit
*/
void Adafruit_TCS34725::setIntLimits(uint16_t low, uint16_t high) {
write8(0x04, low & 0xFF);
write8(0x05, low >> 8);
write8(0x06, high & 0xFF);
write8(0x07, high >> 8);
}

204
lib/Adafruit_TCS34725/Adafruit_TCS34725.h Normal file
View File

@@ -0,0 +1,204 @@
/*!
* @file Adafruit_TCS34725.h
*
* Software License Agreement (BSD License)
*
* Copyright (c) 2013, Adafruit Industries
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
* DAMAGE.
*/
#ifndef _TCS34725_H_
#define _TCS34725_H_
#if ARDUINO >= 100
#include <Arduino.h>
#else
#include <WProgram.h>
#endif
#include <Wire.h>
#define TCS34725_ADDRESS (0x29) /**< I2C address **/
#define TCS34725_COMMAND_BIT (0x80) /**< Command bit **/
#define TCS34725_ENABLE (0x00) /**< Interrupt Enable register */
#define TCS34725_ENABLE_AIEN (0x10) /**< RGBC Interrupt Enable */
#define TCS34725_ENABLE_WEN \
(0x08) /**< Wait Enable - Writing 1 activates the wait timer */
#define TCS34725_ENABLE_AEN \
(0x02) /**< RGBC Enable - Writing 1 actives the ADC, 0 disables it */
#define TCS34725_ENABLE_PON \
(0x01) /**< Power on - Writing 1 activates the internal oscillator, 0 \
disables it */
#define TCS34725_ATIME (0x01) /**< Integration time */
#define TCS34725_WTIME \
(0x03) /**< Wait time (if TCS34725_ENABLE_WEN is asserted) */
#define TCS34725_WTIME_2_4MS (0xFF) /**< WLONG0 = 2.4ms WLONG1 = 0.029s */
#define TCS34725_WTIME_204MS (0xAB) /**< WLONG0 = 204ms WLONG1 = 2.45s */
#define TCS34725_WTIME_614MS (0x00) /**< WLONG0 = 614ms WLONG1 = 7.4s */
#define TCS34725_AILTL \
(0x04) /**< Clear channel lower interrupt threshold (lower byte) */
#define TCS34725_AILTH \
(0x05) /**< Clear channel lower interrupt threshold (higher byte) */
#define TCS34725_AIHTL \
(0x06) /**< Clear channel upper interrupt threshold (lower byte) */
#define TCS34725_AIHTH \
(0x07) /**< Clear channel upper interrupt threshold (higher byte) */
#define TCS34725_PERS \
(0x0C) /**< Persistence register - basic SW filtering mechanism for \
interrupts */
#define TCS34725_PERS_NONE \
(0b0000) /**< Every RGBC cycle generates an interrupt */
#define TCS34725_PERS_1_CYCLE \
(0b0001) /**< 1 clean channel value outside threshold range generates an \
interrupt */
#define TCS34725_PERS_2_CYCLE \
(0b0010) /**< 2 clean channel values outside threshold range generates an \
interrupt */
#define TCS34725_PERS_3_CYCLE \
(0b0011) /**< 3 clean channel values outside threshold range generates an \
interrupt */
#define TCS34725_PERS_5_CYCLE \
(0b0100) /**< 5 clean channel values outside threshold range generates an \
interrupt */
#define TCS34725_PERS_10_CYCLE \
(0b0101) /**< 10 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_15_CYCLE \
(0b0110) /**< 15 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_20_CYCLE \
(0b0111) /**< 20 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_25_CYCLE \
(0b1000) /**< 25 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_30_CYCLE \
(0b1001) /**< 30 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_35_CYCLE \
(0b1010) /**< 35 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_40_CYCLE \
(0b1011) /**< 40 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_45_CYCLE \
(0b1100) /**< 45 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_50_CYCLE \
(0b1101) /**< 50 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_55_CYCLE \
(0b1110) /**< 55 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_PERS_60_CYCLE \
(0b1111) /**< 60 clean channel values outside threshold range generates an \
interrupt*/
#define TCS34725_CONFIG (0x0D) /**< Configuration **/
#define TCS34725_CONFIG_WLONG \
(0x02) /**< Choose between short and long (12x) wait times via \
TCS34725_WTIME */
#define TCS34725_CONTROL (0x0F) /**< Set the gain level for the sensor */
#define TCS34725_ID \
(0x12) /**< 0x44 = TCS34721/TCS34725, 0x4D = TCS34723/TCS34727 */
#define TCS34725_STATUS (0x13) /**< Device status **/
#define TCS34725_STATUS_AINT (0x10) /**< RGBC Clean channel interrupt */
#define TCS34725_STATUS_AVALID \
(0x01) /**< Indicates that the RGBC channels have completed an integration \
cycle */
#define TCS34725_CDATAL (0x14) /**< Clear channel data low byte */
#define TCS34725_CDATAH (0x15) /**< Clear channel data high byte */
#define TCS34725_RDATAL (0x16) /**< Red channel data low byte */
#define TCS34725_RDATAH (0x17) /**< Red channel data high byte */
#define TCS34725_GDATAL (0x18) /**< Green channel data low byte */
#define TCS34725_GDATAH (0x19) /**< Green channel data high byte */
#define TCS34725_BDATAL (0x1A) /**< Blue channel data low byte */
#define TCS34725_BDATAH (0x1B) /**< Blue channel data high byte */
/** Integration time settings for TCS34725 */
typedef enum {
TCS34725_INTEGRATIONTIME_2_4MS =
0xFF, /**< 2.4ms - 1 cycle - Max Count: 1024 */
TCS34725_INTEGRATIONTIME_24MS =
0xF6, /**< 24ms - 10 cycles - Max Count: 10240 */
TCS34725_INTEGRATIONTIME_50MS =
0xEB, /**< 50ms - 20 cycles - Max Count: 20480 */
TCS34725_INTEGRATIONTIME_101MS =
0xD5, /**< 101ms - 42 cycles - Max Count: 43008 */
TCS34725_INTEGRATIONTIME_154MS =
0xC0, /**< 154ms - 64 cycles - Max Count: 65535 */
TCS34725_INTEGRATIONTIME_700MS =
0x00 /**< 700ms - 256 cycles - Max Count: 65535 */
} tcs34725IntegrationTime_t;
/** Gain settings for TCS34725 */
typedef enum {
TCS34725_GAIN_1X = 0x00, /**< No gain */
TCS34725_GAIN_4X = 0x01, /**< 4x gain */
TCS34725_GAIN_16X = 0x02, /**< 16x gain */
TCS34725_GAIN_60X = 0x03 /**< 60x gain */
} tcs34725Gain_t;
/*!
* @brief Class that stores state and functions for interacting with
* TCS34725 Color Sensor
*/
class Adafruit_TCS34725 {
public:
Adafruit_TCS34725(tcs34725IntegrationTime_t = TCS34725_INTEGRATIONTIME_2_4MS,
tcs34725Gain_t = TCS34725_GAIN_1X);
boolean begin(uint8_t addr, TwoWire *theWire);
boolean begin(uint8_t addr);
boolean begin();
boolean init();
void setIntegrationTime(tcs34725IntegrationTime_t it);
void setGain(tcs34725Gain_t gain);
void getRawData(uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c);
void getRGB(float *r, float *g, float *b);
void getRawDataOneShot(uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c);
uint16_t calculateColorTemperature(uint16_t r, uint16_t g, uint16_t b);
uint16_t calculateColorTemperature_dn40(uint16_t r, uint16_t g, uint16_t b,
uint16_t c);
uint16_t calculateLux(uint16_t r, uint16_t g, uint16_t b);
void write8(uint8_t reg, uint32_t value);
uint8_t read8(uint8_t reg);
uint16_t read16(uint8_t reg);
void setInterrupt(boolean flag);
void clearInterrupt();
void setIntLimits(uint16_t l, uint16_t h);
void enable();
void disable();
private:
TwoWire *_wire;
uint8_t _i2caddr;
boolean _tcs34725Initialised;
tcs34725Gain_t _tcs34725Gain;
tcs34725IntegrationTime_t _tcs34725IntegrationTime;
};
#endif

21
lib/Adafruit_TCS34725/README.md Normal file
View File

@@ -0,0 +1,21 @@
# Adafruit TCS34725 Color Sensor Driver [![Build Status](https://travis-ci.com/adafruit/Adafruit_TCS34725.svg?branch=master)](https://travis-ci.com/adafruit/Adafruit_TCS34725)
<a href="https://www.adafruit.com/product/1334"><img src="assets/board.jpg?raw=true" width="500px"></a>
This driver is for the Adafruit TCS34725 Breakout.
Tested and works great with the Adafruit MCP9808 Breakout Board
* http://www.adafruit.com/products/1334
These modules use I2C to communicate, 2 pins are required to
interface
Adafruit invests time and resources providing this open source code,
please support Adafruit and open-source hardware by purchasing
products from Adafruit!
Written by Kevin (KTOWN) Townsend for Adafruit Industries.
BSD license, check license.txt for more information
All text above must be included in any redistribution
To install, use the Arduino Library Manager and search for 'Adafruit TCS34725' and install the library

BIN
lib/Adafruit_TCS34725/assets/board.jpg Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 772 KiB

127
lib/Adafruit_TCS34725/code-of-conduct.md Normal file
View File

@@ -0,0 +1,127 @@
# Adafruit Community Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as
contributors and leaders pledge to making participation in our project and
our community a harassment-free experience for everyone, regardless of age, body
size, disability, ethnicity, gender identity and expression, level or type of
experience, education, socio-economic status, nationality, personal appearance,
race, religion, or sexual identity and orientation.
## Our Standards
We are committed to providing a friendly, safe and welcoming environment for
all.
Examples of behavior that contributes to creating a positive environment
include:
* Be kind and courteous to others
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Collaborating with other community members
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and sexual attention or advances
* The use of inappropriate images, including in a community member's avatar
* The use of inappropriate language, including in a community member's nickname
* Any spamming, flaming, baiting or other attention-stealing behavior
* Excessive or unwelcome helping; answering outside the scope of the question
asked
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic
address, without explicit permission
* Other conduct which could reasonably be considered inappropriate
The goal of the standards and moderation guidelines outlined here is to build
and maintain a respectful community. We ask that you don’t just aim to be
"technically unimpeachable", but rather try to be your best self.
We value many things beyond technical expertise, including collaboration and
supporting others within our community. Providing a positive experience for
other community members can have a much more significant impact than simply
providing the correct answer.
## Our Responsibilities
Project leaders are responsible for clarifying the standards of acceptable
behavior and are expected to take appropriate and fair corrective action in
response to any instances of unacceptable behavior.
Project leaders have the right and responsibility to remove, edit, or
reject messages, comments, commits, code, issues, and other contributions
that are not aligned to this Code of Conduct, or to ban temporarily or
permanently any community member for other behaviors that they deem
inappropriate, threatening, offensive, or harmful.
## Moderation
Instances of behaviors that violate the Adafruit Community Code of Conduct
may be reported by any member of the community. Community members are
encouraged to report these situations, including situations they witness
involving other community members.
You may report in the following ways:
In any situation, you may send an email to <support@adafruit.com>.
On the Adafruit Discord, you may send an open message from any channel
to all Community Helpers by tagging @community helpers. You may also send an
open message from any channel, or a direct message to @kattni#1507,
@tannewt#4653, @Dan Halbert#1614, @cater#2442, @sommersoft#0222, or
@Andon#8175.
Email and direct message reports will be kept confidential.
In situations on Discord where the issue is particularly egregious, possibly
illegal, requires immediate action, or violates the Discord terms of service,
you should also report the message directly to Discord.
These are the steps for upholding our community’s standards of conduct.
1. Any member of the community may report any situation that violates the
Adafruit Community Code of Conduct. All reports will be reviewed and
investigated.
2. If the behavior is an egregious violation, the community member who
committed the violation may be banned immediately, without warning.
3. Otherwise, moderators will first respond to such behavior with a warning.
4. Moderators follow a soft "three strikes" policy - the community member may
be given another chance, if they are receptive to the warning and change their
behavior.
5. If the community member is unreceptive or unreasonable when warned by a
moderator, or the warning goes unheeded, they may be banned for a first or
second offense. Repeated offenses will result in the community member being
banned.
## Scope
This Code of Conduct and the enforcement policies listed above apply to all
Adafruit Community venues. This includes but is not limited to any community
spaces (both public and private), the entire Adafruit Discord server, and
Adafruit GitHub repositories. Examples of Adafruit Community spaces include
but are not limited to meet-ups, audio chats on the Adafruit Discord, or
interaction at a conference.
This Code of Conduct applies both within project spaces and in public spaces
when an individual is representing the project or its community. As a community
member, you are representing our community, and are expected to behave
accordingly.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
version 1.4, available at
<https://www.contributor-covenant.org/version/1/4/code-of-conduct.html>,
and the [Rust Code of Conduct](https://www.rust-lang.org/en-US/conduct.html).
For other projects adopting the Adafruit Community Code of
Conduct, please contact the maintainers of those projects for enforcement.
If you wish to use this code of conduct for your own project, consider
explicitly mentioning your moderation policy or making a copy with your
own moderation policy so as to avoid confusion.

111
lib/Adafruit_TCS34725/examples/colorview/colorview.ino Normal file
View File

@@ -0,0 +1,111 @@
#include <Wire.h>
#include "Adafruit_TCS34725.h"
// Pick analog outputs, for the UNO these three work well
// use ~560 ohm resistor between Red & Blue, ~1K for green (its brighter)
#define redpin 3
#define greenpin 5
#define bluepin 6
// for a common anode LED, connect the common pin to +5V
// for common cathode, connect the common to ground
// set to false if using a common cathode LED
#define commonAnode true
// our RGB -> eye-recognized gamma color
byte gammatable[256];
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_50MS, TCS34725_GAIN_4X);
void setup() {
Serial.begin(9600);
//Serial.println("Color View Test!");
if (tcs.begin()) {
//Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1); // halt!
}
// use these three pins to drive an LED
#if defined(ARDUINO_ARCH_ESP32)
ledcAttachPin(redpin, 1);
ledcSetup(1, 12000, 8);
ledcAttachPin(greenpin, 2);
ledcSetup(2, 12000, 8);
ledcAttachPin(bluepin, 3);
ledcSetup(3, 12000, 8);
#else
pinMode(redpin, OUTPUT);
pinMode(greenpin, OUTPUT);
pinMode(bluepin, OUTPUT);
#endif
// thanks PhilB for this gamma table!
// it helps convert RGB colors to what humans see
for (int i=0; i<256; i++) {
float x = i;
x /= 255;
x = pow(x, 2.5);
x *= 255;
if (commonAnode) {
gammatable[i] = 255 - x;
} else {
gammatable[i] = x;
}
//Serial.println(gammatable[i]);
}
}
// The commented out code in loop is example of getRawData with clear value.
// Processing example colorview.pde can work with this kind of data too, but It requires manual conversion to
// [0-255] RGB value. You can still uncomments parts of colorview.pde and play with clear value.
void loop() {
float red, green, blue;
tcs.setInterrupt(false); // turn on LED
delay(60); // takes 50ms to read
tcs.getRGB(&red, &green, &blue);
tcs.setInterrupt(true); // turn off LED
Serial.print("R:\t"); Serial.print(int(red));
Serial.print("\tG:\t"); Serial.print(int(green));
Serial.print("\tB:\t"); Serial.print(int(blue));
// Serial.print("\t");
// Serial.print((int)red, HEX); Serial.print((int)green, HEX); Serial.print((int)blue, HEX);
Serial.print("\n");
// uint16_t red, green, blue, clear;
//
// tcs.setInterrupt(false); // turn on LED
//
// delay(60); // takes 50ms to read
//
// tcs.getRawData(&red, &green, &blue, &clear);
//
// tcs.setInterrupt(true); // turn off LED
//
// Serial.print("C:\t"); Serial.print(int(clear));
// Serial.print("R:\t"); Serial.print(int(red));
// Serial.print("\tG:\t"); Serial.print(int(green));
// Serial.print("\tB:\t"); Serial.print(int(blue));
// Serial.println();
#if defined(ARDUINO_ARCH_ESP32)
ledcWrite(1, gammatable[(int)red]);
ledcWrite(2, gammatable[(int)green]);
ledcWrite(3, gammatable[(int)blue]);
#else
analogWrite(redpin, gammatable[(int)red]);
analogWrite(greenpin, gammatable[(int)green]);
analogWrite(bluepin, gammatable[(int)blue]);
#endif
}

80
lib/Adafruit_TCS34725/examples/colorview/processing/colorview/colorview.pde Normal file
View File

@@ -0,0 +1,80 @@
/* For use with the colorview Arduino example sketch
Update the Serial() new call to match your serial port
e.g. COM4, /dev/usbserial, etc!
*/
import processing.serial.*;
import java.awt.datatransfer.*;
import java.awt.Toolkit;
Serial port;
void setup(){
size(200,200);
port = new Serial(this, "COM4", 9600); //remember to replace COM20 with the appropriate serial port on your computer
}
String buff = "";
int wRed, wGreen, wBlue, wClear;
String hexColor = "ffffff";
void draw(){
background(wRed,wGreen,wBlue);
// check for serial, and process
while (port.available() > 0) {
serialEvent(port.read());
}
}
void serialEvent(int serial) {
if(serial != '\n') {
buff += char(serial);
} else {
//println(buff);
int cRed = buff.indexOf("R");
int cGreen = buff.indexOf("G");
int cBlue = buff.indexOf("B");
int clear = buff.indexOf("C");
if(clear >=0){
String val = buff.substring(clear+3);
val = val.split("\t")[0];
wClear = Integer.parseInt(val.trim());
} else { return; }
if(cRed >=0){
String val = buff.substring(cRed+3);
val = val.split("\t")[0];
wRed = Integer.parseInt(val.trim());
} else { return; }
if(cGreen >=0) {
String val = buff.substring(cGreen+3);
val = val.split("\t")[0];
wGreen = Integer.parseInt(val.trim());
} else { return; }
if(cBlue >=0) {
String val = buff.substring(cBlue+3);
val = val.split("\t")[0];
wBlue = Integer.parseInt(val.trim());
} else { return; }
print("Red: "); print(wRed);
print("\tGrn: "); print(wGreen);
print("\tBlue: "); print(wBlue);
print("\tClr: "); println(wClear);
wRed *= 255; wRed /= wClear;
wGreen *= 255; wGreen /= wClear;
wBlue *= 255; wBlue /= wClear;
hexColor = hex(color(wRed, wGreen, wBlue), 6);
println(hexColor);
buff = "";
}
}

69
lib/Adafruit_TCS34725/examples/interrupt/interrupt.ino Normal file
View File

@@ -0,0 +1,69 @@
#include <Wire.h>
#include <Adafruit_TCS34725.h>
/* Initialise with specific int time and gain values */
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);
const int interruptPin = 2;
volatile boolean state = false;
//Interrupt Service Routine
void isr()
{
state = true;
}
/* tcs.getRawData() does a delay(Integration_Time) after the sensor readout.
We don't need to wait for the next integration cycle because we receive an interrupt when the integration cycle is complete*/
void getRawData_noDelay(uint16_t *r, uint16_t *g, uint16_t *b, uint16_t *c)
{
*c = tcs.read16(TCS34725_CDATAL);
*r = tcs.read16(TCS34725_RDATAL);
*g = tcs.read16(TCS34725_GDATAL);
*b = tcs.read16(TCS34725_BDATAL);
}
void setup() {
pinMode(interruptPin, INPUT_PULLUP); //TCS interrupt output is Active-LOW and Open-Drain
attachInterrupt(digitalPinToInterrupt(interruptPin), isr, FALLING);
Serial.begin(9600);
if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1);
}
// Set persistence filter to generate an interrupt for every RGB Cycle, regardless of the integration limits
tcs.write8(TCS34725_PERS, TCS34725_PERS_NONE);
tcs.setInterrupt(true);
Serial.flush();
}
void loop() {
if (state) {
uint16_t r, g, b, c, colorTemp, lux;
getRawData_noDelay(&r, &g, &b, &c);
colorTemp = tcs.calculateColorTemperature(r, g, b);
lux = tcs.calculateLux(r, g, b);
Serial.print("Color Temp: "); Serial.print(colorTemp, DEC); Serial.print(" K - ");
Serial.print("Lux: "); Serial.print(lux, DEC); Serial.print(" - ");
Serial.print("R: "); Serial.print(r, DEC); Serial.print(" ");
Serial.print("G: "); Serial.print(g, DEC); Serial.print(" ");
Serial.print("B: "); Serial.print(b, DEC); Serial.print(" ");
Serial.print("C: "); Serial.print(c, DEC); Serial.print(" ");
Serial.println(" ");
Serial.flush();
tcs.clearInterrupt();
state = false;
}
}

45
lib/Adafruit_TCS34725/examples/tcs34725/tcs34725.ino Normal file
View File

@@ -0,0 +1,45 @@
#include <Wire.h>
#include "Adafruit_TCS34725.h"
/* Example code for the Adafruit TCS34725 breakout library */
/* Connect SCL to analog 5
Connect SDA to analog 4
Connect VDD to 3.3V DC
Connect GROUND to common ground */
/* Initialise with default values (int time = 2.4ms, gain = 1x) */
// Adafruit_TCS34725 tcs = Adafruit_TCS34725();
/* Initialise with specific int time and gain values */
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);
void setup(void) {
Serial.begin(9600);
if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1);
}
// Now we're ready to get readings!
}
void loop(void) {
uint16_t r, g, b, c, colorTemp, lux;
tcs.getRawData(&r, &g, &b, &c);
// colorTemp = tcs.calculateColorTemperature(r, g, b);
colorTemp = tcs.calculateColorTemperature_dn40(r, g, b, c);
lux = tcs.calculateLux(r, g, b);
Serial.print("Color Temp: "); Serial.print(colorTemp, DEC); Serial.print(" K - ");
Serial.print("Lux: "); Serial.print(lux, DEC); Serial.print(" - ");
Serial.print("R: "); Serial.print(r, DEC); Serial.print(" ");
Serial.print("G: "); Serial.print(g, DEC); Serial.print(" ");
Serial.print("B: "); Serial.print(b, DEC); Serial.print(" ");
Serial.print("C: "); Serial.print(c, DEC); Serial.print(" ");
Serial.println(" ");
}

44
lib/Adafruit_TCS34725/examples/tcs34725/tcs34725.pde Normal file
View File

@@ -0,0 +1,44 @@
#include <Wire.h>
#include "Adafruit_TCS34725.h"
/* Example code for the Adafruit TCS34725 breakout library */
/* Connect SCL to analog 5
Connect SDA to analog 4
Connect VDD to 3.3V DC
Connect GROUND to common ground */
/* Initialise with default values (int time = 2.4ms, gain = 1x) */
// Adafruit_TCS34725 tcs = Adafruit_TCS34725();
/* Initialise with specific int time and gain values */
Adafruit_TCS34725 tcs = Adafruit_TCS34725(TCS34725_INTEGRATIONTIME_700MS, TCS34725_GAIN_1X);
void setup(void) {
Serial.begin(9600);
if (tcs.begin()) {
Serial.println("Found sensor");
} else {
Serial.println("No TCS34725 found ... check your connections");
while (1);
}
// Now we're ready to get readings!
}
void loop(void) {
uint16_t r, g, b, c, colorTemp, lux;
tcs.getRawData(&r, &g, &b, &c);
colorTemp = tcs.calculateColorTemperature(r, g, b);
lux = tcs.calculateLux(r, g, b);
Serial.print("Color Temp: "); Serial.print(colorTemp, DEC); Serial.print(" K - ");
Serial.print("Lux: "); Serial.print(lux, DEC); Serial.print(" - ");
Serial.print("R: "); Serial.print(r, DEC); Serial.print(" ");
Serial.print("G: "); Serial.print(g, DEC); Serial.print(" ");
Serial.print("B: "); Serial.print(b, DEC); Serial.print(" ");
Serial.print("C: "); Serial.print(c, DEC); Serial.print(" ");
Serial.println(" ");
}

211
lib/Adafruit_TCS34725/examples/tcs34725autorange/tcs34725autorange.ino Normal file
View File

@@ -0,0 +1,211 @@
#include <Wire.h>
#include "Adafruit_TCS34725.h"
//
// An experimental wrapper class that implements the improved lux and color temperature from
// TAOS and a basic autorange mechanism.
//
// Written by ductsoup, public domain
//
// RGB Color Sensor with IR filter and White LED - TCS34725
// I2C 7-bit address 0x29, 8-bit address 0x52
//
// http://www.adafruit.com/product/1334
// http://learn.adafruit.com/adafruit-color-sensors/overview
// http://www.adafruit.com/datasheets/TCS34725.pdf
// http://www.ams.com/eng/Products/Light-Sensors/Color-Sensor/TCS34725
// http://www.ams.com/eng/content/view/download/265215 <- DN40, calculations
// http://www.ams.com/eng/content/view/download/181895 <- DN39, some thoughts on autogain
// http://www.ams.com/eng/content/view/download/145158 <- DN25 (original Adafruit calculations)
//
// connect LED to digital 4 or GROUND for ambient light sensing
// connect SCL to analog 5
// connect SDA to analog 4
// connect Vin to 3.3-5V DC
// connect GROUND to common ground
// some magic numbers for this device from the DN40 application note
#define TCS34725_R_Coef 0.136
#define TCS34725_G_Coef 1.000
#define TCS34725_B_Coef -0.444
#define TCS34725_GA 1.0
#define TCS34725_DF 310.0
#define TCS34725_CT_Coef 3810.0
#define TCS34725_CT_Offset 1391.0
// Autorange class for TCS34725
class tcs34725 {
private:
struct tcs_agc {
tcs34725Gain_t ag;
tcs34725IntegrationTime_t at;
uint16_t mincnt;
uint16_t maxcnt;
};
static const tcs_agc agc_lst[];
uint16_t agc_cur;
void setGainTime(void);
Adafruit_TCS34725 tcs;
public:
tcs34725(void);
boolean begin(void);
void getData(void);
boolean isAvailable, isSaturated;
uint16_t againx, atime, atime_ms;
uint16_t r, g, b, c;
uint16_t ir;
uint16_t r_comp, g_comp, b_comp, c_comp;
uint16_t saturation, saturation75;
float cratio, cpl, ct, lux, maxlux;
};
//
// Gain/time combinations to use and the min/max limits for hysteresis
// that avoid saturation. They should be in order from dim to bright.
//
// Also set the first min count and the last max count to 0 to indicate
// the start and end of the list.
//
const tcs34725::tcs_agc tcs34725::agc_lst[] = {
{ TCS34725_GAIN_60X, TCS34725_INTEGRATIONTIME_700MS, 0, 20000 },
{ TCS34725_GAIN_60X, TCS34725_INTEGRATIONTIME_154MS, 4990, 63000 },
{ TCS34725_GAIN_16X, TCS34725_INTEGRATIONTIME_154MS, 16790, 63000 },
{ TCS34725_GAIN_4X, TCS34725_INTEGRATIONTIME_154MS, 15740, 63000 },
{ TCS34725_GAIN_1X, TCS34725_INTEGRATIONTIME_154MS, 15740, 0 }
};
tcs34725::tcs34725() : agc_cur(0), isAvailable(0), isSaturated(0) {
}
// initialize the sensor
boolean tcs34725::begin(void) {
tcs = Adafruit_TCS34725(agc_lst[agc_cur].at, agc_lst[agc_cur].ag);
if ((isAvailable = tcs.begin()))
setGainTime();
return(isAvailable);
}
// Set the gain and integration time
void tcs34725::setGainTime(void) {
tcs.setGain(agc_lst[agc_cur].ag);
tcs.setIntegrationTime(agc_lst[agc_cur].at);
atime = int(agc_lst[agc_cur].at);
atime_ms = ((256 - atime) * 2.4);
switch(agc_lst[agc_cur].ag) {
case TCS34725_GAIN_1X:
againx = 1;
break;
case TCS34725_GAIN_4X:
againx = 4;
break;
case TCS34725_GAIN_16X:
againx = 16;
break;
case TCS34725_GAIN_60X:
againx = 60;
break;
}
}
// Retrieve data from the sensor and do the calculations
void tcs34725::getData(void) {
// read the sensor and autorange if necessary
tcs.getRawData(&r, &g, &b, &c);
while(1) {
if (agc_lst[agc_cur].maxcnt && c > agc_lst[agc_cur].maxcnt)
agc_cur++;
else if (agc_lst[agc_cur].mincnt && c < agc_lst[agc_cur].mincnt)
agc_cur--;
else break;
setGainTime();
delay((256 - atime) * 2.4 * 2); // shock absorber
tcs.getRawData(&r, &g, &b, &c);
break;
}
// DN40 calculations
ir = (r + g + b > c) ? (r + g + b - c) / 2 : 0;
r_comp = r - ir;
g_comp = g - ir;
b_comp = b - ir;
c_comp = c - ir;
cratio = float(ir) / float(c);
saturation = ((256 - atime) > 63) ? 65535 : 1024 * (256 - atime);
saturation75 = (atime_ms < 150) ? (saturation - saturation / 4) : saturation;
isSaturated = (atime_ms < 150 && c > saturation75) ? 1 : 0;
cpl = (atime_ms * againx) / (TCS34725_GA * TCS34725_DF);
maxlux = 65535 / (cpl * 3);
lux = (TCS34725_R_Coef * float(r_comp) + TCS34725_G_Coef * float(g_comp) + TCS34725_B_Coef * float(b_comp)) / cpl;
ct = TCS34725_CT_Coef * float(b_comp) / float(r_comp) + TCS34725_CT_Offset;
}
tcs34725 rgb_sensor;
void setup(void) {
Serial.begin(115200);
rgb_sensor.begin();
pinMode(4, OUTPUT);
digitalWrite(4, LOW); // @gremlins Bright light, bright light!
}
void loop(void) {
rgb_sensor.getData();
Serial.print(F("Gain:"));
Serial.print(rgb_sensor.againx);
Serial.print(F("x "));
Serial.print(F("Time:"));
Serial.print(rgb_sensor.atime_ms);
Serial.print(F("ms (0x"));
Serial.print(rgb_sensor.atime, HEX);
Serial.println(F(")"));
Serial.print(F("Raw R:"));
Serial.print(rgb_sensor.r);
Serial.print(F(" G:"));
Serial.print(rgb_sensor.g);
Serial.print(F(" B:"));
Serial.print(rgb_sensor.b);
Serial.print(F(" C:"));
Serial.println(rgb_sensor.c);
Serial.print(F("IR:"));
Serial.print(rgb_sensor.ir);
Serial.print(F(" CRATIO:"));
Serial.print(rgb_sensor.cratio);
Serial.print(F(" Sat:"));
Serial.print(rgb_sensor.saturation);
Serial.print(F(" Sat75:"));
Serial.print(rgb_sensor.saturation75);
Serial.print(F(" "));
Serial.println(rgb_sensor.isSaturated ? "*SATURATED*" : "");
Serial.print(F("CPL:"));
Serial.print(rgb_sensor.cpl);
Serial.print(F(" Max lux:"));
Serial.println(rgb_sensor.maxlux);
Serial.print(F("Compensated R:"));
Serial.print(rgb_sensor.r_comp);
Serial.print(F(" G:"));
Serial.print(rgb_sensor.g_comp);
Serial.print(F(" B:"));
Serial.print(rgb_sensor.b_comp);
Serial.print(F(" C:"));
Serial.println(rgb_sensor.c_comp);
Serial.print(F("Lux:"));
Serial.print(rgb_sensor.lux);
Serial.print(F(" CT:"));
Serial.print(rgb_sensor.ct);
Serial.println(F("K"));
Serial.println();
delay(2000);
}

82
lib/Adafruit_TCS34725/examples_processing/colorview/colorview.pde Normal file
View File

@@ -0,0 +1,82 @@
/* For use with the colorview Arduino example sketch
Update the Serial() new call to match your serial port
e.g. COM4, /dev/usbserial, etc!
*/
import processing.serial.*;
import java.awt.datatransfer.*;
import java.awt.Toolkit;
Serial port;
void setup(){
size(200,200);
// remember to replace COM20 with the appropriate serial port on your computer ex Serial.list()[1]
port = new Serial(this, "COM20", 9600);
port.clear();
}
String buff = "";
int wRed, wGreen, wBlue, wClear;
String hexColor = "ffffff";
void draw(){
background(wRed,wGreen,wBlue);
// check for serial, and process
while (port.available() > 0) {
serialEvent(port.read());
}
}
void serialEvent(int serial) {
if(serial != '\n') {
buff += char(serial);
} else {
int cRed = buff.indexOf("R");
int cGreen = buff.indexOf("G");
int cBlue = buff.indexOf("B");
//int clear = buff.indexOf("C");
//if(clear >=0){
// String val = buff.substring(clear+3);
// val = val.split("\t")[0];
// wClear = Integer.parseInt(val.trim());
//} else { return; }
if(cRed >=0){
String val = buff.substring(cRed+3);
val = val.split("\t")[0];
wRed = Integer.parseInt(val.trim());
} else { return; }
if(cGreen >=0) {
String val = buff.substring(cGreen+3);
val = val.split("\t")[0];
wGreen = Integer.parseInt(val.trim());
} else { return; }
if(cBlue >=0) {
String val = buff.substring(cBlue+3);
val = val.split("\t")[0];
wBlue = Integer.parseInt(val.trim());
} else { return; }
//wRed *= 255; wRed /= wClear;
//wGreen *= 255; wGreen /= wClear;
//wBlue *= 255; wBlue /= wClear;
print("Red: "); print(wRed);
print("\tGrn: "); print(wGreen);
print("\tBlue: "); print(wBlue);
//print("\tClr: "); println(wClear);
hexColor = hex(color(wRed, wGreen, wBlue), 6);
print("\t HEX: ");
print(hexColor);
println();
buff = "";
}
}

9
lib/Adafruit_TCS34725/library.properties Normal file
View File

@@ -0,0 +1,9 @@
name=Adafruit TCS34725
version=1.3.0
author=Adafruit
maintainer=Adafruit <info@adafruit.com>
sentence=Driver for Adafruit's TCS34725 RGB Color Sensor Breakout
paragraph=Driver for Adafruit's TCS34725 RGB Color Sensor Breakout
category=Sensors
url=https://github.com/adafruit/Adafruit_TCS34725
architectures=*

26
lib/Adafruit_TCS34725/license.txt Normal file
View File

@@ -0,0 +1,26 @@
Software License Agreement (BSD License)
Copyright (c) 2012, Adafruit Industries
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
3. Neither the name of the copyright holders nor the
names of its contributors may be used to endorse or promote products
derived from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ''AS IS'' AND ANY
EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.