Kenji Arai / TSL2561

Luminosity sensor by Texas Advanced Optoelectronic Solutions Inc.. Device combines one broadband photodiode (visible plus infrared) and one infrared-responding photodiode. Sets Gain x1 and 402mS as default.

Dependents:   MusicBoxForFathersDay FTHR_SensorHub Affich_Lum_Moist Projetv0 ... more

TSL2561.cpp@5:5b1b625fda6f, 2018-09-21 (annotated)

Committer:
kenjiArai
Date:
Fri Sep 21 22:57:07 2018 +0000
Revision:
5:5b1b625fda6f
Parent:
4:05d322353720 
based on Adafruit program and keep interface functions

Who changed what in which revision?

UserRevisionLine numberNew contents of line
kenjiArai 5:5b1b625fda6f 1 /*!
kenjiArai 5:5b1b625fda6f 2 * @file Adafruit_TSL2561_U.cpp
kenjiArai 5:5b1b625fda6f 3 *
kenjiArai 5:5b1b625fda6f 4 * @mainpage Adafruit TSL2561 Light/Lux sensor driver
kenjiArai 5:5b1b625fda6f 5 *
kenjiArai 5:5b1b625fda6f 6 * @section intro_sec Introduction
kenjiArai 5:5b1b625fda6f 7 *
kenjiArai 5:5b1b625fda6f 8 * This is the documentation for Adafruit's TSL2561 driver for the
kenjiArai 5:5b1b625fda6f 9 * Arduino platform. It is designed specifically to work with the
kenjiArai 5:5b1b625fda6f 10 * Adafruit TSL2561 breakout: http://www.adafruit.com/products/439
kenjiArai 5:5b1b625fda6f 11 *
kenjiArai 5:5b1b625fda6f 12 * These sensors use I2C to communicate, 2 pins (SCL+SDA) are required
kenjiArai 5:5b1b625fda6f 13 * to interface with the breakout.
kenjiArai 5:5b1b625fda6f 14 *
kenjiArai 5:5b1b625fda6f 15 * Adafruit invests time and resources providing this open source code,
kenjiArai 5:5b1b625fda6f 16 * please support Adafruit and open-source hardware by purchasing
kenjiArai 5:5b1b625fda6f 17 * products from Adafruit!
kenjiArai 5:5b1b625fda6f 18 *
kenjiArai 5:5b1b625fda6f 19 * @section dependencies Dependencies
kenjiArai 5:5b1b625fda6f 20 *
kenjiArai 5:5b1b625fda6f 21 * This library depends on
kenjiArai 5:5b1b625fda6f 22 * <a href="https://github.com/adafruit/Adafruit_Sensor">
kenjiArai 5:5b1b625fda6f 23 * Adafruit_Sensor</a> being present on your system. Please make sure you have
kenjiArai 5:5b1b625fda6f 24 * installed the latest version before using this library.
kenjiArai 5:5b1b625fda6f 25 *
kenjiArai 5:5b1b625fda6f 26 * @section author Author
kenjiArai 5:5b1b625fda6f 27 *
kenjiArai 5:5b1b625fda6f 28 * Written by Kevin "KTOWN" Townsend for Adafruit Industries.
kenjiArai 0:eec7bcd27c52 29 *
kenjiArai 5:5b1b625fda6f 30 * @section license License
kenjiArai 5:5b1b625fda6f 31 *
kenjiArai 5:5b1b625fda6f 32 * BSD license, all text here must be included in any redistribution.
kenjiArai 5:5b1b625fda6f 33 *
kenjiArai 5:5b1b625fda6f 34 * @section HISTORY
kenjiArai 5:5b1b625fda6f 35 *
kenjiArai 5:5b1b625fda6f 36 * v2.0 - Rewrote driver for Adafruit_Sensor and Auto-Gain support, and
kenjiArai 5:5b1b625fda6f 37 * added lux clipping check (returns 0 lux on sensor saturation)
kenjiArai 5:5b1b625fda6f 38 * v1.0 - First release (previously TSL2561)
kenjiArai 5:5b1b625fda6f 39 */
kenjiArai 5:5b1b625fda6f 40 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 41
kenjiArai 5:5b1b625fda6f 42 //------- Modified by ----------------------------------------------------------
kenjiArai 5:5b1b625fda6f 43 // Kenji Arai / JH1PJL
kenjiArai 5:5b1b625fda6f 44 // http://www.page.sannet.ne.jp/kenjia/index.html
kenjiArai 5:5b1b625fda6f 45 // http://mbed.org/users/kenjiArai/
kenjiArai 5:5b1b625fda6f 46 // Created: Feburary 21st, 2015
kenjiArai 5:5b1b625fda6f 47 // Revised: August 23rd, 2017
kenjiArai 5:5b1b625fda6f 48 // Revised: Feburary 20th, 2018 bug fix -> read_ID() & who_am_i()
kenjiArai 5:5b1b625fda6f 49 // Thanks PARK JAICHANG
kenjiArai 5:5b1b625fda6f 50 // Revised: March 31st, 2018 Added "Auto Range mode"
kenjiArai 5:5b1b625fda6f 51 // Use Adafruit library
kenjiArai 5:5b1b625fda6f 52 //
kenjiArai 5:5b1b625fda6f 53 // Original information https://www.adafruit.com/product/439
kenjiArai 5:5b1b625fda6f 54 // Original source files https://github.com/adafruit/TSL2561-Arduino-Library
kenjiArai 5:5b1b625fda6f 55 // https://github.com/adafruit/Adafruit_TSL2561
kenjiArai 5:5b1b625fda6f 56 // Change for Mbed platform
kenjiArai 5:5b1b625fda6f 57 // modified -> all related files
kenjiArai 5:5b1b625fda6f 58 //------------------------------------------------------------------------------
kenjiArai 0:eec7bcd27c52 59
kenjiArai 0:eec7bcd27c52 60 #include "TSL2561.h"
kenjiArai 0:eec7bcd27c52 61
kenjiArai 5:5b1b625fda6f 62 // T, FN and CL package values
kenjiArai 5:5b1b625fda6f 63 #define TSL2561_LUX_K1T (0x0040) ///< 0.125 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 64 #define TSL2561_LUX_B1T (0x01f2) ///< 0.0304 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 65 #define TSL2561_LUX_M1T (0x01be) ///< 0.0272 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 66 #define TSL2561_LUX_K2T (0x0080) ///< 0.250 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 67 #define TSL2561_LUX_B2T (0x0214) ///< 0.0325 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 68 #define TSL2561_LUX_M2T (0x02d1) ///< 0.0440 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 69 #define TSL2561_LUX_K3T (0x00c0) ///< 0.375 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 70 #define TSL2561_LUX_B3T (0x023f) ///< 0.0351 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 71 #define TSL2561_LUX_M3T (0x037b) ///< 0.0544 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 72 #define TSL2561_LUX_K4T (0x0100) ///< 0.50 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 73 #define TSL2561_LUX_B4T (0x0270) ///< 0.0381 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 74 #define TSL2561_LUX_M4T (0x03fe) ///< 0.0624 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 75 #define TSL2561_LUX_K5T (0x0138) ///< 0.61 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 76 #define TSL2561_LUX_B5T (0x016f) ///< 0.0224 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 77 #define TSL2561_LUX_M5T (0x01fc) ///< 0.0310 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 78 #define TSL2561_LUX_K6T (0x019a) ///< 0.80 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 79 #define TSL2561_LUX_B6T (0x00d2) ///< 0.0128 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 80 #define TSL2561_LUX_M6T (0x00fb) ///< 0.0153 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 81 #define TSL2561_LUX_K7T (0x029a) ///< 1.3 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 82 #define TSL2561_LUX_B7T (0x0018) ///< 0.00146 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 83 #define TSL2561_LUX_M7T (0x0012) ///< 0.00112 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 84 #define TSL2561_LUX_K8T (0x029a) ///< 1.3 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 85 #define TSL2561_LUX_B8T (0x0000) ///< 0.000 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 86 #define TSL2561_LUX_M8T (0x0000) ///< 0.000 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 87
kenjiArai 5:5b1b625fda6f 88 // CS package values
kenjiArai 5:5b1b625fda6f 89 #define TSL2561_LUX_K1C (0x0043) ///< 0.130 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 90 #define TSL2561_LUX_B1C (0x0204) ///< 0.0315 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 91 #define TSL2561_LUX_M1C (0x01ad) ///< 0.0262 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 92 #define TSL2561_LUX_K2C (0x0085) ///< 0.260 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 93 #define TSL2561_LUX_B2C (0x0228) ///< 0.0337 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 94 #define TSL2561_LUX_M2C (0x02c1) ///< 0.0430 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 95 #define TSL2561_LUX_K3C (0x00c8) ///< 0.390 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 96 #define TSL2561_LUX_B3C (0x0253) ///< 0.0363 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 97 #define TSL2561_LUX_M3C (0x0363) ///< 0.0529 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 98 #define TSL2561_LUX_K4C (0x010a) ///< 0.520 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 99 #define TSL2561_LUX_B4C (0x0282) ///< 0.0392 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 100 #define TSL2561_LUX_M4C (0x03df) ///< 0.0605 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 101 #define TSL2561_LUX_K5C (0x014d) ///< 0.65 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 102 #define TSL2561_LUX_B5C (0x0177) ///< 0.0229 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 103 #define TSL2561_LUX_M5C (0x01dd) ///< 0.0291 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 104 #define TSL2561_LUX_K6C (0x019a) ///< 0.80 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 105 #define TSL2561_LUX_B6C (0x0101) ///< 0.0157 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 106 #define TSL2561_LUX_M6C (0x0127) ///< 0.0180 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 107 #define TSL2561_LUX_K7C (0x029a) ///< 1.3 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 108 #define TSL2561_LUX_B7C (0x0037) ///< 0.00338 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 109 #define TSL2561_LUX_M7C (0x002b) ///< 0.00260 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 110 #define TSL2561_LUX_K8C (0x029a) ///< 1.3 * 2^RATIO_SCALE
kenjiArai 5:5b1b625fda6f 111 #define TSL2561_LUX_B8C (0x0000) ///< 0.000 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 112 #define TSL2561_LUX_M8C (0x0000) ///< 0.000 * 2^LUX_SCALE
kenjiArai 5:5b1b625fda6f 113
kenjiArai 5:5b1b625fda6f 114 // Auto-gain thresholds
kenjiArai 5:5b1b625fda6f 115 #define TSL2561_AGC_THI_13MS (4850) ///< Max value at Ti 13ms = 5047
kenjiArai 5:5b1b625fda6f 116 #define TSL2561_AGC_TLO_13MS (100) ///< Min value at Ti 13ms = 100
kenjiArai 5:5b1b625fda6f 117 #define TSL2561_AGC_THI_101MS (36000) ///< Max value at Ti 101ms = 37177
kenjiArai 5:5b1b625fda6f 118 #define TSL2561_AGC_TLO_101MS (200) ///< Min value at Ti 101ms = 200
kenjiArai 5:5b1b625fda6f 119 #define TSL2561_AGC_THI_402MS (63000) ///< Max value at Ti 402ms = 65535
kenjiArai 5:5b1b625fda6f 120 #define TSL2561_AGC_TLO_402MS (500) ///< Min value at Ti 402ms = 500
kenjiArai 5:5b1b625fda6f 121
kenjiArai 5:5b1b625fda6f 122 // Clipping thresholds ///< # Counts that trigger a change in gain/integration
kenjiArai 5:5b1b625fda6f 123 #define TSL2561_CLIPPING_13MS (4900)
kenjiArai 5:5b1b625fda6f 124 #define TSL2561_CLIPPING_101MS (37000)
kenjiArai 5:5b1b625fda6f 125 #define TSL2561_CLIPPING_402MS (65000)
kenjiArai 5:5b1b625fda6f 126
kenjiArai 5:5b1b625fda6f 127 // Delay for integration times
kenjiArai 5:5b1b625fda6f 128 #define TSL2561_DELAY_INTTIME_13MS (15) ///< Wait 15ms for 13ms integration
kenjiArai 5:5b1b625fda6f 129 #define TSL2561_DELAY_INTTIME_101MS (120) ///< Wait 120ms for 101ms integration
kenjiArai 5:5b1b625fda6f 130 #define TSL2561_DELAY_INTTIME_402MS (450) ///< Wait 450ms for 402ms integration
kenjiArai 5:5b1b625fda6f 131
kenjiArai 5:5b1b625fda6f 132 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 133 /* CONSTRUCTORS */
kenjiArai 5:5b1b625fda6f 134 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 135
kenjiArai 2:17591031447b 136 TSL2561::TSL2561 (PinName p_sda, PinName p_scl)
kenjiArai 5:5b1b625fda6f 137 : _i2c_p(new I2C(p_sda, p_scl)), _i2c(*_i2c_p)
kenjiArai 0:eec7bcd27c52 138 {
kenjiArai 5:5b1b625fda6f 139 _addr = TSL2561_ADDR_LOW;
kenjiArai 0:eec7bcd27c52 140 init();
kenjiArai 0:eec7bcd27c52 141 }
kenjiArai 0:eec7bcd27c52 142
kenjiArai 2:17591031447b 143 TSL2561::TSL2561 (PinName p_sda, PinName p_scl, uint8_t addr)
kenjiArai 5:5b1b625fda6f 144 : _i2c_p(new I2C(p_sda, p_scl)), _i2c(*_i2c_p)
kenjiArai 0:eec7bcd27c52 145 {
kenjiArai 5:5b1b625fda6f 146 _addr = addr;
kenjiArai 0:eec7bcd27c52 147 init();
kenjiArai 0:eec7bcd27c52 148 }
kenjiArai 0:eec7bcd27c52 149
kenjiArai 2:17591031447b 150 TSL2561::TSL2561 (I2C& p_i2c)
kenjiArai 5:5b1b625fda6f 151 : _i2c(p_i2c)
kenjiArai 0:eec7bcd27c52 152 {
kenjiArai 5:5b1b625fda6f 153 _addr = TSL2561_ADDR_LOW;
kenjiArai 0:eec7bcd27c52 154 init();
kenjiArai 0:eec7bcd27c52 155 }
kenjiArai 0:eec7bcd27c52 156
kenjiArai 2:17591031447b 157 TSL2561::TSL2561 (I2C& p_i2c, uint8_t addr)
kenjiArai 5:5b1b625fda6f 158 : _i2c(p_i2c)
kenjiArai 0:eec7bcd27c52 159 {
kenjiArai 5:5b1b625fda6f 160 _addr = addr;
kenjiArai 0:eec7bcd27c52 161 init();
kenjiArai 0:eec7bcd27c52 162 }
kenjiArai 0:eec7bcd27c52 163
kenjiArai 5:5b1b625fda6f 164 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 165 /* PUBLIC FUNCTIONS */
kenjiArai 5:5b1b625fda6f 166 /*========================================================================*/
kenjiArai 0:eec7bcd27c52 167 /////////////// Read Lux from sensor //////////////////////
kenjiArai 0:eec7bcd27c52 168 /*
kenjiArai 0:eec7bcd27c52 169 For 0 < CH1/CH0 < 0.50 Lux = 0.0304 x CH0-0.062 x CH0 x ((CH1/CH0)1.4)
kenjiArai 0:eec7bcd27c52 170 For 0.50 < CH1/CH0 < 0.61 Lux = 0.0224 x CH0-0.031 x CH1
kenjiArai 0:eec7bcd27c52 171 For 0.61 < CH1/CH0 < 0.80 Lux = 0.0128 x CH0-0.0153 x CH1
kenjiArai 0:eec7bcd27c52 172 For 0.80 < CH1/CH0 < 1.30 Lux = 0.00146 x CH0-0.00112x CH1
kenjiArai 0:eec7bcd27c52 173 For CH1/CH0 > 1.30 Lux = 0
kenjiArai 0:eec7bcd27c52 174 */
kenjiArai 0:eec7bcd27c52 175 float TSL2561::lux()
kenjiArai 0:eec7bcd27c52 176 {
kenjiArai 0:eec7bcd27c52 177 double lux0, lux1;
kenjiArai 0:eec7bcd27c52 178 double ratio;
kenjiArai 0:eec7bcd27c52 179 double dlux;
kenjiArai 0:eec7bcd27c52 180
kenjiArai 5:5b1b625fda6f 181 _TSL2561AutoGain = false;
kenjiArai 5:5b1b625fda6f 182 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_13MS;
kenjiArai 5:5b1b625fda6f 183 _TSL2561Gain = TSL2561_GAIN_1X;
kenjiArai 5:5b1b625fda6f 184 /* Set default integration time and gain */
kenjiArai 5:5b1b625fda6f 185 setIntegrationTime(_TSL2561IntegrationTime);
kenjiArai 5:5b1b625fda6f 186 setGain(_TSL2561Gain);
kenjiArai 5:5b1b625fda6f 187 uint16_t x0, x1;
kenjiArai 5:5b1b625fda6f 188 getLuminosity(&x0, &x1);
kenjiArai 5:5b1b625fda6f 189 ch0 = x0;
kenjiArai 5:5b1b625fda6f 190 ch1 = x1;
kenjiArai 5:5b1b625fda6f 191 //printf("ch0 = %d, ch1 = %d\r\n", ch0, ch1);
kenjiArai 5:5b1b625fda6f 192 //printf("Integ. Time = %d, Gain %d\r\n",
kenjiArai 5:5b1b625fda6f 193 // _TSL2561IntegrationTime, _TSL2561Gain);
kenjiArai 1:25a700e9b8ec 194 lux0 = (double)ch0;
kenjiArai 1:25a700e9b8ec 195 lux1 = (double)ch1;
kenjiArai 0:eec7bcd27c52 196 ratio = lux1 / lux0;
kenjiArai 1:25a700e9b8ec 197 read_timing_reg();
kenjiArai 5:5b1b625fda6f 198 lux0 *= (402.0/(double)integ_time);
kenjiArai 5:5b1b625fda6f 199 lux1 *= (402.0/(double)integ_time);
kenjiArai 1:25a700e9b8ec 200 lux0 /= gain;
kenjiArai 1:25a700e9b8ec 201 lux1 /= gain;
kenjiArai 5:5b1b625fda6f 202 //printf("Integ. Time = %f, Gain %d\r\n", integ_time, gain);
kenjiArai 0:eec7bcd27c52 203 if (ratio <= 0.5) {
kenjiArai 0:eec7bcd27c52 204 dlux = 0.03040 * lux0 - 0.06200 * lux0 * pow(ratio,1.4);
kenjiArai 0:eec7bcd27c52 205 } else if (ratio <= 0.61) {
kenjiArai 0:eec7bcd27c52 206 dlux = 0.02240 * lux0 - 0.03100 * lux1;
kenjiArai 0:eec7bcd27c52 207 } else if (ratio <= 0.80) {
kenjiArai 0:eec7bcd27c52 208 dlux = 0.01280 * lux0 - 0.01530 * lux1;
kenjiArai 0:eec7bcd27c52 209 } else if (ratio <= 1.30) {
kenjiArai 0:eec7bcd27c52 210 dlux = 0.00146 * lux0 - 0.00112 * lux1;
kenjiArai 0:eec7bcd27c52 211 } else {
kenjiArai 0:eec7bcd27c52 212 dlux = 0;
kenjiArai 0:eec7bcd27c52 213 }
kenjiArai 5:5b1b625fda6f 214 disable();
kenjiArai 0:eec7bcd27c52 215 return (float)dlux;
kenjiArai 0:eec7bcd27c52 216 }
kenjiArai 0:eec7bcd27c52 217
kenjiArai 5:5b1b625fda6f 218 float TSL2561::lux_auto(void)
kenjiArai 5:5b1b625fda6f 219 {
kenjiArai 5:5b1b625fda6f 220 uint32_t data;
kenjiArai 5:5b1b625fda6f 221
kenjiArai 5:5b1b625fda6f 222 enableAutoRange(true);
kenjiArai 5:5b1b625fda6f 223 getEvent(&data);
kenjiArai 5:5b1b625fda6f 224 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 225 return (float)data;
kenjiArai 5:5b1b625fda6f 226 }
kenjiArai 5:5b1b625fda6f 227
kenjiArai 5:5b1b625fda6f 228 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 229 /*!
kenjiArai 5:5b1b625fda6f 230 @brief Initializes I2C connection and settings.
kenjiArai 5:5b1b625fda6f 231 Attempts to determine if the sensor is contactable, then sets up a default
kenjiArai 5:5b1b625fda6f 232 integration time and gain. Then powers down the chip.
kenjiArai 5:5b1b625fda6f 233 @returns True if sensor is found and initialized, false otherwise.
kenjiArai 5:5b1b625fda6f 234 */
kenjiArai 5:5b1b625fda6f 235 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 236 bool TSL2561::init()
kenjiArai 5:5b1b625fda6f 237 {
kenjiArai 5:5b1b625fda6f 238 _TSL2561Initialised = false;
kenjiArai 5:5b1b625fda6f 239 _TSL2561AutoGain = false;
kenjiArai 5:5b1b625fda6f 240 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_13MS;
kenjiArai 5:5b1b625fda6f 241 _TSL2561Gain = TSL2561_GAIN_1X;
kenjiArai 5:5b1b625fda6f 242
kenjiArai 5:5b1b625fda6f 243 /* Make sure we're actually connected */
kenjiArai 5:5b1b625fda6f 244 uint8_t x = read8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_ID);
kenjiArai 5:5b1b625fda6f 245 if (x & 0xF0 != 0x50) { // ID code for TSL2561
kenjiArai 5:5b1b625fda6f 246 //printf("initialize error!\r\n");
kenjiArai 5:5b1b625fda6f 247 return false;
kenjiArai 5:5b1b625fda6f 248 }
kenjiArai 5:5b1b625fda6f 249 //printf("ID=0x%02x\r\n", x);
kenjiArai 5:5b1b625fda6f 250 _TSL2561Initialised = true;
kenjiArai 5:5b1b625fda6f 251
kenjiArai 5:5b1b625fda6f 252 /* Set default integration time and gain */
kenjiArai 5:5b1b625fda6f 253 setIntegrationTime(_TSL2561IntegrationTime);
kenjiArai 5:5b1b625fda6f 254 setGain(_TSL2561Gain);
kenjiArai 5:5b1b625fda6f 255 read_timing_reg();
kenjiArai 5:5b1b625fda6f 256
kenjiArai 5:5b1b625fda6f 257 /* Note: by default, the device is in power down mode on bootup */
kenjiArai 5:5b1b625fda6f 258 disable();
kenjiArai 5:5b1b625fda6f 259
kenjiArai 5:5b1b625fda6f 260 t.reset();
kenjiArai 5:5b1b625fda6f 261 t.start();
kenjiArai 5:5b1b625fda6f 262 //printf("Integ. Time = %d, Gain %d\r\n",
kenjiArai 5:5b1b625fda6f 263 // _TSL2561IntegrationTime, _TSL2561Gain);
kenjiArai 5:5b1b625fda6f 264 //printf("initialize finished!\r\n");
kenjiArai 5:5b1b625fda6f 265 x = read8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING);
kenjiArai 5:5b1b625fda6f 266 //printf("TIMING REG=0x%02x\r\n", x);
kenjiArai 5:5b1b625fda6f 267 return true;
kenjiArai 5:5b1b625fda6f 268 }
kenjiArai 5:5b1b625fda6f 269
kenjiArai 5:5b1b625fda6f 270 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 271 /*!
kenjiArai 5:5b1b625fda6f 272 @brief Enables or disables the auto-gain settings when reading
kenjiArai 5:5b1b625fda6f 273 data from the sensor
kenjiArai 5:5b1b625fda6f 274 @param enable Set to true to enable, False to disable
kenjiArai 5:5b1b625fda6f 275 */
kenjiArai 5:5b1b625fda6f 276 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 277 void TSL2561::enableAutoRange(bool enable)
kenjiArai 5:5b1b625fda6f 278 {
kenjiArai 5:5b1b625fda6f 279 _TSL2561AutoGain = enable ? true : false;
kenjiArai 5:5b1b625fda6f 280 }
kenjiArai 5:5b1b625fda6f 281
kenjiArai 5:5b1b625fda6f 282 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 283 /*!
kenjiArai 5:5b1b625fda6f 284 @brief Sets the integration time for the TSL2561. Higher time means
kenjiArai 5:5b1b625fda6f 285 more light captured (better for low light conditions) but will
kenjiArai 5:5b1b625fda6f 286 take longer to run readings.
kenjiArai 5:5b1b625fda6f 287 @param time The amount of time we'd like to add up values
kenjiArai 5:5b1b625fda6f 288 */
kenjiArai 5:5b1b625fda6f 289 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 290 void TSL2561::setIntegrationTime(TSL2561IntegrationTime_t time)
kenjiArai 5:5b1b625fda6f 291 {
kenjiArai 5:5b1b625fda6f 292 /* Enable the device by setting the control bit to 0x03 */
kenjiArai 5:5b1b625fda6f 293 enable();
kenjiArai 5:5b1b625fda6f 294 /* Update the timing register */
kenjiArai 5:5b1b625fda6f 295 write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, time | _TSL2561Gain);
kenjiArai 5:5b1b625fda6f 296 /* Update value placeholders */
kenjiArai 5:5b1b625fda6f 297 _TSL2561IntegrationTime = time;
kenjiArai 5:5b1b625fda6f 298 /* Turn the device off to save power */
kenjiArai 5:5b1b625fda6f 299 disable();
kenjiArai 5:5b1b625fda6f 300 }
kenjiArai 5:5b1b625fda6f 301
kenjiArai 5:5b1b625fda6f 302 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 303 /*!
kenjiArai 5:5b1b625fda6f 304 @brief Adjusts the gain on the TSL2561 (adjusts the sensitivity to light)
kenjiArai 5:5b1b625fda6f 305 @param gain The value we'd like to set the gain to
kenjiArai 5:5b1b625fda6f 306 */
kenjiArai 5:5b1b625fda6f 307 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 308 void TSL2561::setGain(TSL2561Gain_t gain)
kenjiArai 5:5b1b625fda6f 309 {
kenjiArai 5:5b1b625fda6f 310 /* Enable the device by setting the control bit to 0x03 */
kenjiArai 5:5b1b625fda6f 311 enable();
kenjiArai 5:5b1b625fda6f 312 /* Update the timing register */
kenjiArai 5:5b1b625fda6f 313 write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, _TSL2561IntegrationTime | gain);
kenjiArai 5:5b1b625fda6f 314 /* Update value placeholders */
kenjiArai 5:5b1b625fda6f 315 _TSL2561Gain = gain;
kenjiArai 5:5b1b625fda6f 316 /* Turn the device off to save power */
kenjiArai 5:5b1b625fda6f 317 disable();
kenjiArai 5:5b1b625fda6f 318 }
kenjiArai 5:5b1b625fda6f 319
kenjiArai 5:5b1b625fda6f 320 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 321 /*!
kenjiArai 5:5b1b625fda6f 322 @brief Gets the broadband (mixed lighting) and IR only values from
kenjiArai 5:5b1b625fda6f 323 the TSL2561, adjusting gain if auto-gain is enabled
kenjiArai 5:5b1b625fda6f 324 @param broadband Pointer to a uint16_t we will fill with a sensor
kenjiArai 5:5b1b625fda6f 325 reading from the IR+visible light diode.
kenjiArai 5:5b1b625fda6f 326 @param ir Pointer to a uint16_t we will fill with a sensor the
kenjiArai 5:5b1b625fda6f 327 IR-only light diode.
kenjiArai 5:5b1b625fda6f 328 */
kenjiArai 5:5b1b625fda6f 329 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 330 void TSL2561::getLuminosity (uint16_t *broadband, uint16_t *ir)
kenjiArai 5:5b1b625fda6f 331 {
kenjiArai 5:5b1b625fda6f 332 bool valid = false;
kenjiArai 5:5b1b625fda6f 333
kenjiArai 5:5b1b625fda6f 334 /* If Auto gain disabled get a single reading and continue */
kenjiArai 5:5b1b625fda6f 335 if(!_TSL2561AutoGain) {
kenjiArai 5:5b1b625fda6f 336 //printf("Get data without Auto gain\r\n");
kenjiArai 5:5b1b625fda6f 337 getData (broadband, ir);
kenjiArai 5:5b1b625fda6f 338 return;
kenjiArai 5:5b1b625fda6f 339 }
kenjiArai 5:5b1b625fda6f 340 //printf("Get data with Auto gain\r\n");
kenjiArai 5:5b1b625fda6f 341 /* Read data until we find a valid range */
kenjiArai 5:5b1b625fda6f 342 bool _agcCheck = false;
kenjiArai 5:5b1b625fda6f 343 do {
kenjiArai 5:5b1b625fda6f 344 uint16_t _b, _ir;
kenjiArai 5:5b1b625fda6f 345 uint16_t _hi, _lo;
kenjiArai 5:5b1b625fda6f 346 TSL2561IntegrationTime_t _it = _TSL2561IntegrationTime;
kenjiArai 5:5b1b625fda6f 347
kenjiArai 5:5b1b625fda6f 348 /* Get the hi/low threshold for the current integration time */
kenjiArai 5:5b1b625fda6f 349 switch(_it) {
kenjiArai 5:5b1b625fda6f 350 case TSL2561_INTEGRATIONTIME_13MS:
kenjiArai 5:5b1b625fda6f 351 _hi = TSL2561_AGC_THI_13MS;
kenjiArai 5:5b1b625fda6f 352 _lo = TSL2561_AGC_TLO_13MS;
kenjiArai 5:5b1b625fda6f 353 break;
kenjiArai 5:5b1b625fda6f 354 case TSL2561_INTEGRATIONTIME_101MS:
kenjiArai 5:5b1b625fda6f 355 _hi = TSL2561_AGC_THI_101MS;
kenjiArai 5:5b1b625fda6f 356 _lo = TSL2561_AGC_TLO_101MS;
kenjiArai 5:5b1b625fda6f 357 break;
kenjiArai 5:5b1b625fda6f 358 default:
kenjiArai 5:5b1b625fda6f 359 _hi = TSL2561_AGC_THI_402MS;
kenjiArai 5:5b1b625fda6f 360 _lo = TSL2561_AGC_TLO_402MS;
kenjiArai 5:5b1b625fda6f 361 break;
kenjiArai 5:5b1b625fda6f 362 }
kenjiArai 5:5b1b625fda6f 363
kenjiArai 5:5b1b625fda6f 364 getData(&_b, &_ir);
kenjiArai 5:5b1b625fda6f 365
kenjiArai 5:5b1b625fda6f 366 /* Run an auto-gain check if we haven't already done so ... */
kenjiArai 5:5b1b625fda6f 367 if (!_agcCheck) {
kenjiArai 5:5b1b625fda6f 368 if ((_b < _lo) && (_TSL2561Gain == TSL2561_GAIN_1X)) {
kenjiArai 5:5b1b625fda6f 369 /* Increase the gain and try again */
kenjiArai 5:5b1b625fda6f 370 setGain(TSL2561_GAIN_16X);
kenjiArai 5:5b1b625fda6f 371 /* Drop the previous conversion results */
kenjiArai 5:5b1b625fda6f 372 getData(&_b, &_ir);
kenjiArai 5:5b1b625fda6f 373 /* Set a flag to indicate we've adjusted the gain */
kenjiArai 5:5b1b625fda6f 374 _agcCheck = true;
kenjiArai 5:5b1b625fda6f 375 } else if ((_b > _hi) && (_TSL2561Gain == TSL2561_GAIN_16X)) {
kenjiArai 5:5b1b625fda6f 376 /* Drop gain to 1x and try again */
kenjiArai 5:5b1b625fda6f 377 setGain(TSL2561_GAIN_1X);
kenjiArai 5:5b1b625fda6f 378 /* Drop the previous conversion results */
kenjiArai 5:5b1b625fda6f 379 getData(&_b, &_ir);
kenjiArai 5:5b1b625fda6f 380 /* Set a flag to indicate we've adjusted the gain */
kenjiArai 5:5b1b625fda6f 381 _agcCheck = true;
kenjiArai 5:5b1b625fda6f 382 } else {
kenjiArai 5:5b1b625fda6f 383 /* Nothing to look at here, keep moving ....
kenjiArai 5:5b1b625fda6f 384 Reading is either valid, or we're already at the chips limits */
kenjiArai 5:5b1b625fda6f 385 *broadband = _b;
kenjiArai 5:5b1b625fda6f 386 *ir = _ir;
kenjiArai 5:5b1b625fda6f 387 valid = true;
kenjiArai 5:5b1b625fda6f 388 }
kenjiArai 5:5b1b625fda6f 389 } else {
kenjiArai 5:5b1b625fda6f 390 /* If we've already adjusted the gain once, just return the new results.
kenjiArai 5:5b1b625fda6f 391 This avoids endless loops where a value is at one extreme pre-gain,
kenjiArai 5:5b1b625fda6f 392 and the the other extreme post-gain */
kenjiArai 5:5b1b625fda6f 393 *broadband = _b;
kenjiArai 5:5b1b625fda6f 394 *ir = _ir;
kenjiArai 5:5b1b625fda6f 395 valid = true;
kenjiArai 5:5b1b625fda6f 396 }
kenjiArai 5:5b1b625fda6f 397 } while (!valid);
kenjiArai 5:5b1b625fda6f 398 }
kenjiArai 5:5b1b625fda6f 399
kenjiArai 5:5b1b625fda6f 400 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 401 /*!
kenjiArai 5:5b1b625fda6f 402 Enables the device
kenjiArai 5:5b1b625fda6f 403 */
kenjiArai 5:5b1b625fda6f 404 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 405 void TSL2561::enable(void)
kenjiArai 5:5b1b625fda6f 406 {
kenjiArai 5:5b1b625fda6f 407 /* Enable the device by setting the control bit to 0x03 */
kenjiArai 5:5b1b625fda6f 408 write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWERON);
kenjiArai 5:5b1b625fda6f 409 }
kenjiArai 5:5b1b625fda6f 410
kenjiArai 5:5b1b625fda6f 411 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 412 /*!
kenjiArai 5:5b1b625fda6f 413 Disables the device (putting it in lower power sleep mode)
kenjiArai 5:5b1b625fda6f 414 */
kenjiArai 5:5b1b625fda6f 415 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 416 void TSL2561::disable(void)
kenjiArai 5:5b1b625fda6f 417 {
kenjiArai 5:5b1b625fda6f 418 /* Turn the device off to save power */
kenjiArai 5:5b1b625fda6f 419 write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_CONTROL, TSL2561_CONTROL_POWEROFF);
kenjiArai 5:5b1b625fda6f 420 }
kenjiArai 5:5b1b625fda6f 421
kenjiArai 5:5b1b625fda6f 422 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 423 /*!
kenjiArai 5:5b1b625fda6f 424 Private function to read luminosity on both channels
kenjiArai 5:5b1b625fda6f 425 */
kenjiArai 5:5b1b625fda6f 426 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 427 void TSL2561::getData (uint16_t *broadband, uint16_t *ir)
kenjiArai 0:eec7bcd27c52 428 {
kenjiArai 5:5b1b625fda6f 429 /* Enable the device by setting the control bit to 0x03 */
kenjiArai 5:5b1b625fda6f 430 enable();
kenjiArai 5:5b1b625fda6f 431
kenjiArai 5:5b1b625fda6f 432 /* Wait x ms for ADC to complete */
kenjiArai 5:5b1b625fda6f 433 switch (_TSL2561IntegrationTime) {
kenjiArai 5:5b1b625fda6f 434 case TSL2561_INTEGRATIONTIME_13MS:
kenjiArai 5:5b1b625fda6f 435 wait_ms(TSL2561_DELAY_INTTIME_13MS);
kenjiArai 5:5b1b625fda6f 436 break;
kenjiArai 5:5b1b625fda6f 437 case TSL2561_INTEGRATIONTIME_101MS:
kenjiArai 5:5b1b625fda6f 438 wait_ms(TSL2561_DELAY_INTTIME_101MS);
kenjiArai 5:5b1b625fda6f 439 break;
kenjiArai 5:5b1b625fda6f 440 default:
kenjiArai 5:5b1b625fda6f 441 wait_ms(TSL2561_DELAY_INTTIME_402MS);
kenjiArai 5:5b1b625fda6f 442 break;
kenjiArai 5:5b1b625fda6f 443 }
kenjiArai 5:5b1b625fda6f 444
kenjiArai 5:5b1b625fda6f 445 /* Reads a two byte value from channel 0 (visible + infrared) */
kenjiArai 5:5b1b625fda6f 446 *broadband = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN0_LOW);
kenjiArai 5:5b1b625fda6f 447
kenjiArai 5:5b1b625fda6f 448 /* Reads a two byte value from channel 1 (infrared) */
kenjiArai 5:5b1b625fda6f 449 *ir = read16(TSL2561_COMMAND_BIT | TSL2561_WORD_BIT | TSL2561_REGISTER_CHAN1_LOW);
kenjiArai 5:5b1b625fda6f 450
kenjiArai 5:5b1b625fda6f 451 /* Turn the device off to save power */
kenjiArai 5:5b1b625fda6f 452 disable();
kenjiArai 1:25a700e9b8ec 453 }
kenjiArai 1:25a700e9b8ec 454
kenjiArai 5:5b1b625fda6f 455 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 456 /*!
kenjiArai 5:5b1b625fda6f 457 @brief Converts the raw sensor values to the standard SI lux equivalent.
kenjiArai 5:5b1b625fda6f 458 @param broadband The 16-bit sensor reading from the IR+visible light diode.
kenjiArai 5:5b1b625fda6f 459 @param ir The 16-bit sensor reading from the IR-only light diode.
kenjiArai 5:5b1b625fda6f 460 @returns The integer Lux value we calcuated.
kenjiArai 5:5b1b625fda6f 461 Returns 0 if the sensor is saturated and the values are
kenjiArai 5:5b1b625fda6f 462 unreliable, or 65536 if the sensor is saturated.
kenjiArai 5:5b1b625fda6f 463 */
kenjiArai 5:5b1b625fda6f 464 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 465 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 466 /*!
kenjiArai 5:5b1b625fda6f 467
kenjiArai 5:5b1b625fda6f 468 Returns
kenjiArai 5:5b1b625fda6f 469 */
kenjiArai 5:5b1b625fda6f 470 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 471 uint32_t TSL2561::calculateLux(uint16_t broadband, uint16_t ir)
kenjiArai 5:5b1b625fda6f 472 {
kenjiArai 5:5b1b625fda6f 473 unsigned long chScale;
kenjiArai 5:5b1b625fda6f 474 unsigned long channel1;
kenjiArai 5:5b1b625fda6f 475 unsigned long channel0;
kenjiArai 5:5b1b625fda6f 476
kenjiArai 5:5b1b625fda6f 477 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 478 /* Make sure the sensor isn't saturated! */
kenjiArai 5:5b1b625fda6f 479 uint16_t clipThreshold;
kenjiArai 5:5b1b625fda6f 480 //printf("_TSL2561IntegrationTime=%d\r\n", _TSL2561IntegrationTime);
kenjiArai 5:5b1b625fda6f 481 switch (_TSL2561IntegrationTime) {
kenjiArai 5:5b1b625fda6f 482 case TSL2561_INTEGRATIONTIME_13MS:
kenjiArai 5:5b1b625fda6f 483 clipThreshold = TSL2561_CLIPPING_13MS;
kenjiArai 5:5b1b625fda6f 484 chScale = TSL2561_LUX_CHSCALE_TINT0;
kenjiArai 5:5b1b625fda6f 485 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 486 break;
kenjiArai 5:5b1b625fda6f 487 case TSL2561_INTEGRATIONTIME_101MS:
kenjiArai 5:5b1b625fda6f 488 clipThreshold = TSL2561_CLIPPING_101MS;
kenjiArai 5:5b1b625fda6f 489 chScale = TSL2561_LUX_CHSCALE_TINT1;
kenjiArai 5:5b1b625fda6f 490 break;
kenjiArai 5:5b1b625fda6f 491 default:
kenjiArai 5:5b1b625fda6f 492 clipThreshold = TSL2561_CLIPPING_402MS;
kenjiArai 5:5b1b625fda6f 493 chScale = (1 << TSL2561_LUX_CHSCALE);
kenjiArai 5:5b1b625fda6f 494 break;
kenjiArai 5:5b1b625fda6f 495 }
kenjiArai 5:5b1b625fda6f 496 //printf("clipThreshold=%d\r\n", clipThreshold);
kenjiArai 5:5b1b625fda6f 497 /* Return 65536 lux if the sensor is saturated */
kenjiArai 5:5b1b625fda6f 498 if ((broadband > clipThreshold) || (ir > clipThreshold)) {
kenjiArai 5:5b1b625fda6f 499 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 500 return 65536;
kenjiArai 5:5b1b625fda6f 501 }
kenjiArai 5:5b1b625fda6f 502
kenjiArai 5:5b1b625fda6f 503 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 504 //printf("chScale=%d\r\n", chScale);
kenjiArai 5:5b1b625fda6f 505 /* Scale for gain (1x or 16x) */
kenjiArai 5:5b1b625fda6f 506 if (!_TSL2561Gain) {
kenjiArai 5:5b1b625fda6f 507 chScale = chScale << 4;
kenjiArai 5:5b1b625fda6f 508 }
kenjiArai 5:5b1b625fda6f 509 //printf("chScale=%d\r\n", chScale);
kenjiArai 5:5b1b625fda6f 510 /* Scale the channel values */
kenjiArai 5:5b1b625fda6f 511 channel0 = (broadband * chScale) >> TSL2561_LUX_CHSCALE;
kenjiArai 5:5b1b625fda6f 512 channel1 = (ir * chScale) >> TSL2561_LUX_CHSCALE;
kenjiArai 5:5b1b625fda6f 513 //printf("channel0=%d, channel1=%d\r\n", channel0, channel1);
kenjiArai 5:5b1b625fda6f 514
kenjiArai 5:5b1b625fda6f 515 /* Find the ratio of the channel values (Channel1/Channel0) */
kenjiArai 5:5b1b625fda6f 516 unsigned long ratio1 = 0;
kenjiArai 5:5b1b625fda6f 517 if (channel0 != 0) {
kenjiArai 5:5b1b625fda6f 518 ratio1 = (channel1 << (TSL2561_LUX_RATIOSCALE+1)) / channel0;
kenjiArai 5:5b1b625fda6f 519 }
kenjiArai 5:5b1b625fda6f 520
kenjiArai 5:5b1b625fda6f 521 /* round the ratio value */
kenjiArai 5:5b1b625fda6f 522 long ratio = (ratio1 + 1) >> 1;
kenjiArai 5:5b1b625fda6f 523 //printf("ratio1=%d, ratio=%d\r\n", ratio1, ratio);
kenjiArai 5:5b1b625fda6f 524 unsigned int b, m;
kenjiArai 5:5b1b625fda6f 525
kenjiArai 5:5b1b625fda6f 526 #ifdef TSL2561_PACKAGE_CS
kenjiArai 5:5b1b625fda6f 527 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 528 if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1C)) {
kenjiArai 5:5b1b625fda6f 529 b=TSL2561_LUX_B1C;
kenjiArai 5:5b1b625fda6f 530 m=TSL2561_LUX_M1C;
kenjiArai 5:5b1b625fda6f 531 } else if (ratio <= TSL2561_LUX_K2C) {
kenjiArai 5:5b1b625fda6f 532 b=TSL2561_LUX_B2C;
kenjiArai 5:5b1b625fda6f 533 m=TSL2561_LUX_M2C;
kenjiArai 5:5b1b625fda6f 534 } else if (ratio <= TSL2561_LUX_K3C) {
kenjiArai 5:5b1b625fda6f 535 b=TSL2561_LUX_B3C;
kenjiArai 5:5b1b625fda6f 536 m=TSL2561_LUX_M3C;
kenjiArai 5:5b1b625fda6f 537 } else if (ratio <= TSL2561_LUX_K4C) {
kenjiArai 5:5b1b625fda6f 538 b=TSL2561_LUX_B4C;
kenjiArai 5:5b1b625fda6f 539 m=TSL2561_LUX_M4C;
kenjiArai 5:5b1b625fda6f 540 } else if (ratio <= TSL2561_LUX_K5C) {
kenjiArai 5:5b1b625fda6f 541 b=TSL2561_LUX_B5C;
kenjiArai 5:5b1b625fda6f 542 m=TSL2561_LUX_M5C;
kenjiArai 5:5b1b625fda6f 543 } else if (ratio <= TSL2561_LUX_K6C) {
kenjiArai 5:5b1b625fda6f 544 b=TSL2561_LUX_B6C;
kenjiArai 5:5b1b625fda6f 545 m=TSL2561_LUX_M6C;
kenjiArai 5:5b1b625fda6f 546 } else if (ratio <= TSL2561_LUX_K7C) {
kenjiArai 5:5b1b625fda6f 547 b=TSL2561_LUX_B7C;
kenjiArai 5:5b1b625fda6f 548 m=TSL2561_LUX_M7C;
kenjiArai 5:5b1b625fda6f 549 } else if (ratio > TSL2561_LUX_K8C) {
kenjiArai 5:5b1b625fda6f 550 b=TSL2561_LUX_B8C;
kenjiArai 5:5b1b625fda6f 551 m=TSL2561_LUX_M8C;
kenjiArai 5:5b1b625fda6f 552 }
kenjiArai 5:5b1b625fda6f 553 #else
kenjiArai 5:5b1b625fda6f 554 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 555 if ((ratio >= 0) && (ratio <= TSL2561_LUX_K1T)) {
kenjiArai 5:5b1b625fda6f 556 b=TSL2561_LUX_B1T;
kenjiArai 5:5b1b625fda6f 557 m=TSL2561_LUX_M1T;
kenjiArai 5:5b1b625fda6f 558 } else if (ratio <= TSL2561_LUX_K2T) {
kenjiArai 5:5b1b625fda6f 559 b=TSL2561_LUX_B2T;
kenjiArai 5:5b1b625fda6f 560 m=TSL2561_LUX_M2T;
kenjiArai 5:5b1b625fda6f 561 } else if (ratio <= TSL2561_LUX_K3T) {
kenjiArai 5:5b1b625fda6f 562 b=TSL2561_LUX_B3T;
kenjiArai 5:5b1b625fda6f 563 m=TSL2561_LUX_M3T;
kenjiArai 5:5b1b625fda6f 564 } else if (ratio <= TSL2561_LUX_K4T) {
kenjiArai 5:5b1b625fda6f 565 b=TSL2561_LUX_B4T;
kenjiArai 5:5b1b625fda6f 566 m=TSL2561_LUX_M4T;
kenjiArai 5:5b1b625fda6f 567 } else if (ratio <= TSL2561_LUX_K5T) {
kenjiArai 5:5b1b625fda6f 568 b=TSL2561_LUX_B5T;
kenjiArai 5:5b1b625fda6f 569 m=TSL2561_LUX_M5T;
kenjiArai 5:5b1b625fda6f 570 } else if (ratio <= TSL2561_LUX_K6T) {
kenjiArai 5:5b1b625fda6f 571 b=TSL2561_LUX_B6T;
kenjiArai 5:5b1b625fda6f 572 m=TSL2561_LUX_M6T;
kenjiArai 5:5b1b625fda6f 573 } else if (ratio <= TSL2561_LUX_K7T) {
kenjiArai 5:5b1b625fda6f 574 b=TSL2561_LUX_B7T;
kenjiArai 5:5b1b625fda6f 575 m=TSL2561_LUX_M7T;
kenjiArai 5:5b1b625fda6f 576 } else if (ratio > TSL2561_LUX_K8T) {
kenjiArai 5:5b1b625fda6f 577 b=TSL2561_LUX_B8T;
kenjiArai 5:5b1b625fda6f 578 m=TSL2561_LUX_M8T;
kenjiArai 5:5b1b625fda6f 579 }
kenjiArai 5:5b1b625fda6f 580 #endif
kenjiArai 5:5b1b625fda6f 581
kenjiArai 5:5b1b625fda6f 582 long temp;
kenjiArai 5:5b1b625fda6f 583 temp = ((channel0 * b) - (channel1 * m));
kenjiArai 5:5b1b625fda6f 584
kenjiArai 5:5b1b625fda6f 585 /* Do not allow negative lux value */
kenjiArai 5:5b1b625fda6f 586 if (temp < 0L) {
kenjiArai 5:5b1b625fda6f 587 temp = 0;
kenjiArai 5:5b1b625fda6f 588 }
kenjiArai 5:5b1b625fda6f 589 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 590 /* Round lsb (2^(LUX_SCALE-1)) */
kenjiArai 5:5b1b625fda6f 591 temp += (1 << (TSL2561_LUX_LUXSCALE-1));
kenjiArai 5:5b1b625fda6f 592
kenjiArai 5:5b1b625fda6f 593 /* Strip off fractional portion */
kenjiArai 5:5b1b625fda6f 594 uint32_t lux = temp >> TSL2561_LUX_LUXSCALE;
kenjiArai 5:5b1b625fda6f 595
kenjiArai 5:5b1b625fda6f 596 /* Signal I2C had no errors */
kenjiArai 5:5b1b625fda6f 597 //printf("Lux=%d\r\n", lux);
kenjiArai 5:5b1b625fda6f 598 return lux;
kenjiArai 5:5b1b625fda6f 599 }
kenjiArai 5:5b1b625fda6f 600
kenjiArai 5:5b1b625fda6f 601 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 602 /*!
kenjiArai 5:5b1b625fda6f 603 @brief Gets the most recent sensor event
kenjiArai 5:5b1b625fda6f 604 @param event Pointer to a sensor_event_t type that will be filled
kenjiArai 5:5b1b625fda6f 605 with the lux value, timestamp, data type and sensor ID.
kenjiArai 5:5b1b625fda6f 606 @returns True if sensor reading is between 0 and 65535 lux,
kenjiArai 5:5b1b625fda6f 607 false if sensor is saturated
kenjiArai 5:5b1b625fda6f 608 */
kenjiArai 5:5b1b625fda6f 609 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 610 bool TSL2561::getEvent(uint32_t *event)
kenjiArai 5:5b1b625fda6f 611 {
kenjiArai 5:5b1b625fda6f 612 uint16_t broadband, ir;
kenjiArai 5:5b1b625fda6f 613
kenjiArai 5:5b1b625fda6f 614 /* Calculate the actual lux value */
kenjiArai 5:5b1b625fda6f 615 getLuminosity(&broadband, &ir);
kenjiArai 5:5b1b625fda6f 616 //printf("broadband=%d, ir=%d\r\n", broadband, ir);
kenjiArai 5:5b1b625fda6f 617 *event = calculateLux(broadband, ir);
kenjiArai 5:5b1b625fda6f 618 //printf("LUX=%f\r\n", event->light);
kenjiArai 5:5b1b625fda6f 619 //printf("LUX=%d\r\n", *event);
kenjiArai 5:5b1b625fda6f 620 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 621 if (*event == 65536) {
kenjiArai 5:5b1b625fda6f 622 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 623 return false;
kenjiArai 5:5b1b625fda6f 624 }
kenjiArai 5:5b1b625fda6f 625 //printf("line:%d\r\n", __LINE__);
kenjiArai 5:5b1b625fda6f 626 return true;
kenjiArai 5:5b1b625fda6f 627 }
kenjiArai 5:5b1b625fda6f 628
kenjiArai 5:5b1b625fda6f 629 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 630 /*!
kenjiArai 5:5b1b625fda6f 631 @brief Gets the sensor_t data
kenjiArai 5:5b1b625fda6f 632 @param sensor A pointer to a sensor_t structure that we will fill with
kenjiArai 5:5b1b625fda6f 633 details about the TSL2561 and its capabilities
kenjiArai 5:5b1b625fda6f 634 */
kenjiArai 5:5b1b625fda6f 635 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 636 void TSL2561::getSensor(sensor_t *sensor)
kenjiArai 5:5b1b625fda6f 637 {
kenjiArai 5:5b1b625fda6f 638 /* Insert the sensor name in the fixed length char array */
kenjiArai 5:5b1b625fda6f 639 //sensor->version = 1;
kenjiArai 5:5b1b625fda6f 640 sensor->min_delay = 0;
kenjiArai 5:5b1b625fda6f 641 sensor->max_value = 17000.0; /* Based on trial and error ... confirm! */
kenjiArai 5:5b1b625fda6f 642 sensor->min_value = 1.0;
kenjiArai 5:5b1b625fda6f 643 sensor->resolution = 1.0;
kenjiArai 5:5b1b625fda6f 644 }
kenjiArai 5:5b1b625fda6f 645
kenjiArai 5:5b1b625fda6f 646 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 647 /* PRIVATE FUNCTIONS */
kenjiArai 5:5b1b625fda6f 648 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 649
kenjiArai 5:5b1b625fda6f 650 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 651 /*!
kenjiArai 5:5b1b625fda6f 652 @brief Writes a register and an 8 bit value over I2C
kenjiArai 5:5b1b625fda6f 653 @param reg I2C register to write the value to
kenjiArai 5:5b1b625fda6f 654 @param value The 8-bit value we're writing to the register
kenjiArai 5:5b1b625fda6f 655 */
kenjiArai 5:5b1b625fda6f 656 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 657 void TSL2561::write8 (uint8_t reg, uint8_t value)
kenjiArai 5:5b1b625fda6f 658 {
kenjiArai 5:5b1b625fda6f 659 dt[0] = reg;
kenjiArai 5:5b1b625fda6f 660 dt[1] = value;
kenjiArai 5:5b1b625fda6f 661 _i2c.write((int)_addr, (char *)dt, 2, false);
kenjiArai 5:5b1b625fda6f 662 }
kenjiArai 5:5b1b625fda6f 663
kenjiArai 5:5b1b625fda6f 664 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 665 /*!
kenjiArai 5:5b1b625fda6f 666 @brief Reads an 8 bit value over I2C
kenjiArai 5:5b1b625fda6f 667 @param reg I2C register to read from
kenjiArai 5:5b1b625fda6f 668 @returns 8-bit value containing single byte data read
kenjiArai 5:5b1b625fda6f 669 */
kenjiArai 5:5b1b625fda6f 670 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 671 uint8_t TSL2561::read8(uint8_t reg)
kenjiArai 5:5b1b625fda6f 672 {
kenjiArai 5:5b1b625fda6f 673 dt[0] = reg;
kenjiArai 5:5b1b625fda6f 674 _i2c.write((int)_addr, (char *)dt, 1, true);
kenjiArai 5:5b1b625fda6f 675 _i2c.read(_addr, (char *)dt, 1, false);
kenjiArai 5:5b1b625fda6f 676 return dt[0];
kenjiArai 5:5b1b625fda6f 677 }
kenjiArai 5:5b1b625fda6f 678
kenjiArai 5:5b1b625fda6f 679 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 680 /*!
kenjiArai 5:5b1b625fda6f 681 @brief Reads a 16 bit values over I2C
kenjiArai 5:5b1b625fda6f 682 @param reg I2C register to read from
kenjiArai 5:5b1b625fda6f 683 @returns 16-bit value containing 2-byte data read
kenjiArai 5:5b1b625fda6f 684 */
kenjiArai 5:5b1b625fda6f 685 /**************************************************************************/
kenjiArai 5:5b1b625fda6f 686 uint16_t TSL2561::read16(uint8_t reg)
kenjiArai 5:5b1b625fda6f 687 {
kenjiArai 5:5b1b625fda6f 688 dt[0] = reg;
kenjiArai 5:5b1b625fda6f 689 _i2c.write((int)_addr, (char *)dt, 1, true);
kenjiArai 5:5b1b625fda6f 690 _i2c.read(_addr, (char *)dt, 2, false);
kenjiArai 5:5b1b625fda6f 691 uint16_t data = ((uint16_t)dt[1] << 8) + dt[0];
kenjiArai 5:5b1b625fda6f 692 return data;
kenjiArai 5:5b1b625fda6f 693 }
kenjiArai 5:5b1b625fda6f 694
kenjiArai 5:5b1b625fda6f 695 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 696 /* JH1PJL Original Functions -> Keep compacibility for older revision */
kenjiArai 5:5b1b625fda6f 697 /*========================================================================*/
kenjiArai 5:5b1b625fda6f 698
kenjiArai 1:25a700e9b8ec 699 /////////////// Timing Register ///////////////////////////
kenjiArai 1:25a700e9b8ec 700 uint8_t TSL2561::set_timing_reg(uint8_t parameter)
kenjiArai 1:25a700e9b8ec 701 {
kenjiArai 5:5b1b625fda6f 702 enable();
kenjiArai 5:5b1b625fda6f 703 write8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING, parameter);
kenjiArai 5:5b1b625fda6f 704 return read8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING);
kenjiArai 1:25a700e9b8ec 705 }
kenjiArai 1:25a700e9b8ec 706
kenjiArai 1:25a700e9b8ec 707 uint8_t TSL2561::read_timing_reg(void)
kenjiArai 1:25a700e9b8ec 708 {
kenjiArai 5:5b1b625fda6f 709 uint8_t i, data;
kenjiArai 1:25a700e9b8ec 710
kenjiArai 5:5b1b625fda6f 711 data = read8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_TIMING);
kenjiArai 5:5b1b625fda6f 712 if (data & TSL2561_GAIN_16X) {
kenjiArai 1:25a700e9b8ec 713 gain = 16;
kenjiArai 5:5b1b625fda6f 714 _TSL2561Gain = TSL2561_GAIN_16X;
kenjiArai 1:25a700e9b8ec 715 } else {
kenjiArai 1:25a700e9b8ec 716 gain = 1;
kenjiArai 5:5b1b625fda6f 717 _TSL2561Gain = TSL2561_GAIN_1X;
kenjiArai 1:25a700e9b8ec 718 }
kenjiArai 5:5b1b625fda6f 719 i = data & 0x3;
kenjiArai 1:25a700e9b8ec 720 switch (i) {
kenjiArai 1:25a700e9b8ec 721 case 0:
kenjiArai 1:25a700e9b8ec 722 integ_time = 13.7;
kenjiArai 5:5b1b625fda6f 723 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_13MS;
kenjiArai 1:25a700e9b8ec 724 break;
kenjiArai 1:25a700e9b8ec 725 case 1:
kenjiArai 1:25a700e9b8ec 726 integ_time = 101.0;
kenjiArai 5:5b1b625fda6f 727 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_101MS;
kenjiArai 1:25a700e9b8ec 728 break;
kenjiArai 1:25a700e9b8ec 729 case 2:
kenjiArai 1:25a700e9b8ec 730 integ_time = 402.0;
kenjiArai 5:5b1b625fda6f 731 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_402MS;
kenjiArai 1:25a700e9b8ec 732 break;
kenjiArai 1:25a700e9b8ec 733 default:
kenjiArai 1:25a700e9b8ec 734 integ_time = 0;
kenjiArai 5:5b1b625fda6f 735 _TSL2561IntegrationTime = TSL2561_INTEGRATIONTIME_13MS;
kenjiArai 1:25a700e9b8ec 736 break;
kenjiArai 1:25a700e9b8ec 737 }
kenjiArai 1:25a700e9b8ec 738 return dt[0];
kenjiArai 0:eec7bcd27c52 739 }
kenjiArai 0:eec7bcd27c52 740
kenjiArai 0:eec7bcd27c52 741 /////////////// ID ////////////////////////////////////////
kenjiArai 3:d60d8198d76d 742 uint8_t TSL2561::read_ID()
kenjiArai 3:d60d8198d76d 743 {
kenjiArai 5:5b1b625fda6f 744 id_number = read8(TSL2561_COMMAND_BIT | TSL2561_REGISTER_ID);
kenjiArai 0:eec7bcd27c52 745 return id_number;
kenjiArai 0:eec7bcd27c52 746 }
kenjiArai 0:eec7bcd27c52 747
kenjiArai 0:eec7bcd27c52 748 uint8_t TSL2561::who_am_i()
kenjiArai 0:eec7bcd27c52 749 {
kenjiArai 0:eec7bcd27c52 750 read_ID();
kenjiArai 3:d60d8198d76d 751 if ((id_number >> 4) == I_AM_TSL2561CS) {
kenjiArai 3:d60d8198d76d 752 return 1;
kenjiArai 3:d60d8198d76d 753 } else if ((id_number >> 4) == I_AM_TSL2561T_FN_CL) {
kenjiArai 0:eec7bcd27c52 754 return 1;
kenjiArai 0:eec7bcd27c52 755 } else {
kenjiArai 0:eec7bcd27c52 756 return 0;
kenjiArai 0:eec7bcd27c52 757 }
kenjiArai 0:eec7bcd27c52 758 }
kenjiArai 0:eec7bcd27c52 759
kenjiArai 0:eec7bcd27c52 760 /////////////// Power ON/OFF //////////////////////////////
kenjiArai 0:eec7bcd27c52 761 void TSL2561::power_up()
kenjiArai 0:eec7bcd27c52 762 {
kenjiArai 5:5b1b625fda6f 763 enable();
kenjiArai 0:eec7bcd27c52 764 }
kenjiArai 0:eec7bcd27c52 765
kenjiArai 0:eec7bcd27c52 766 void TSL2561::power_down()
kenjiArai 0:eec7bcd27c52 767 {
kenjiArai 5:5b1b625fda6f 768 disable();
kenjiArai 0:eec7bcd27c52 769 }
kenjiArai 0:eec7bcd27c52 770
kenjiArai 0:eec7bcd27c52 771 /////////////// I2C Freq. /////////////////////////////////
kenjiArai 0:eec7bcd27c52 772 void TSL2561::frequency(int hz)
kenjiArai 0:eec7bcd27c52 773 {
kenjiArai 0:eec7bcd27c52 774 _i2c.frequency(hz);
kenjiArai 0:eec7bcd27c52 775 }