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?
User | Revision | Line number | New 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 | } |