mirror of https://github.com/arendst/Tasmota.git
2029 lines
56 KiB
C++
2029 lines
56 KiB
C++
/*
|
|
xsns_27_apds9960.ino - Support for I2C APDS9960 Proximity Sensor for Tasmota
|
|
|
|
Copyright (C) 2021 Shawn Hymel/Sparkfun and Theo Arends
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
- Redistributions of source code must retain the above copyright notice,
|
|
this list of conditions and the following disclaimer.
|
|
- Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
|
|
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
|
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
|
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
|
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
|
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
|
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#ifdef USE_I2C
|
|
#ifdef USE_APDS9960
|
|
/*********************************************************************************************\
|
|
* APDS9960 - Digital Proximity Ambient Light RGB and Gesture Sensor
|
|
*
|
|
* Source: Shawn Hymel (SparkFun Electronics)
|
|
* Adaption for TASMOTA: Christian Baars
|
|
*
|
|
* I2C Address: 0x39 - standard address
|
|
\*********************************************************************************************/
|
|
|
|
// #if defined(USE_SHT) || defined(USE_VEML6070) || defined(USE_TSL2561)
|
|
// #warning **** Turned off conflicting drivers SHT and VEML6070 ****
|
|
// #ifdef USE_SHT
|
|
// #undef USE_SHT // SHT-Driver blocks gesture sensor
|
|
// #endif
|
|
// #ifdef USE_VEML6070
|
|
// #undef USE_VEML6070 // address conflict on the I2C-bus
|
|
// #endif
|
|
// #ifdef USE_TSL2561
|
|
// #undef USE_TSL2561 // possible address conflict on the I2C-bus
|
|
// #endif
|
|
// #endif
|
|
|
|
#define XSNS_27 27
|
|
#define XI2C_21 21 // See I2CDEVICES.md
|
|
|
|
|
|
#define APDS9960_I2C_ADDR 0x39
|
|
|
|
#define APDS9960_CHIPID_1 0xAB
|
|
#define APDS9960_CHIPID_2 0x9C
|
|
#define APDS9960_CHIPID_3 0xA8
|
|
|
|
#define APDS9930_CHIPID_1 0x12 // we will check, if someone got an incorrect sensor
|
|
#define APDS9930_CHIPID_2 0x39 // there are case reports about "accidentially bought" 9930's
|
|
|
|
#define APDS9960_MODE_GESTURE 0
|
|
#define APDS9960_MODE_COLOR 1
|
|
|
|
/* Gesture parameters */
|
|
#define GESTURE_THRESHOLD_OUT 10
|
|
#define GESTURE_SENSITIVITY_1 50
|
|
#define GESTURE_SENSITIVITY_2 20
|
|
|
|
#define APDS9960_LONG_RECOVERY 50 // long pause after sensor overload in loops
|
|
#define APDS9960_MAX_GESTURE_CYCLES 50 // how many FIFO-reads are allowed to prevent crash
|
|
|
|
/******************************************************************************\
|
|
* Constants
|
|
\******************************************************************************/
|
|
|
|
const char APDS9960_TAG[] PROGMEM = "APDS9960"; // Only one actualy
|
|
|
|
#ifdef USE_WEBSERVER
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
const char HTTP_SNS_GESTURE[] PROGMEM = "{s}%s " D_GESTURE "{m}%s{e}";
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
#ifdef USE_APDS9960_COLOR
|
|
const char HTTP_SNS_CCT[] PROGMEM = "{s}%s " D_CCT "{m}%u " D_UNIT_KELVIN "{e}";
|
|
#endif // USE_APDS9960_COLOR
|
|
|
|
#ifdef USE_APDS9960_PROXIMITY
|
|
const char HTTP_SNS_PROXIMITY[] PROGMEM = "{s}%s " D_PROXIMITY "{m}%u{e}";
|
|
#endif // USE_APDS9960_PROXIMITY
|
|
|
|
#endif // USE_WEBSERVER
|
|
|
|
/******************************************************************************\
|
|
* APDS9960
|
|
*
|
|
* Programmer : APDS9960 Datasheet and Sparkfun
|
|
\******************************************************************************/
|
|
|
|
/* Misc parameters */
|
|
#define FIFO_PAUSE_TIME 30 // Wait period (ms) between FIFO reads
|
|
|
|
/* APDS-9960 register addresses */
|
|
#define APDS9960_ENABLE 0x80
|
|
#define APDS9960_ATIME 0x81
|
|
#define APDS9960_WTIME 0x83
|
|
#define APDS9960_AILTL 0x84
|
|
#define APDS9960_AILTH 0x85
|
|
#define APDS9960_AIHTL 0x86
|
|
#define APDS9960_AIHTH 0x87
|
|
#define APDS9960_PILT 0x89
|
|
#define APDS9960_PIHT 0x8B
|
|
#define APDS9960_PERS 0x8C
|
|
#define APDS9960_CONFIG1 0x8D
|
|
#define APDS9960_PPULSE 0x8E
|
|
#define APDS9960_CONTROL 0x8F
|
|
#define APDS9960_CONFIG2 0x90
|
|
#define APDS9960_ID 0x92
|
|
#define APDS9960_STATUS 0x93
|
|
#define APDS9960_CDATAL 0x94
|
|
#define APDS9960_CDATAH 0x95
|
|
#define APDS9960_RDATAL 0x96
|
|
#define APDS9960_RDATAH 0x97
|
|
#define APDS9960_GDATAL 0x98
|
|
#define APDS9960_GDATAH 0x99
|
|
#define APDS9960_BDATAL 0x9A
|
|
#define APDS9960_BDATAH 0x9B
|
|
#define APDS9960_PDATA 0x9C
|
|
#define APDS9960_POFFSET_UR 0x9D
|
|
#define APDS9960_POFFSET_DL 0x9E
|
|
#define APDS9960_CONFIG3 0x9F
|
|
#define APDS9960_GPENTH 0xA0
|
|
#define APDS9960_GEXTH 0xA1
|
|
#define APDS9960_GCONF1 0xA2
|
|
#define APDS9960_GCONF2 0xA3
|
|
#define APDS9960_GOFFSET_U 0xA4
|
|
#define APDS9960_GOFFSET_D 0xA5
|
|
#define APDS9960_GOFFSET_L 0xA7
|
|
#define APDS9960_GOFFSET_R 0xA9
|
|
#define APDS9960_GPULSE 0xA6
|
|
#define APDS9960_GCONF3 0xAA
|
|
#define APDS9960_GCONF4 0xAB
|
|
#define APDS9960_GFLVL 0xAE
|
|
#define APDS9960_GSTATUS 0xAF
|
|
#define APDS9960_IFORCE 0xE4
|
|
#define APDS9960_PICLEAR 0xE5
|
|
#define APDS9960_CICLEAR 0xE6
|
|
#define APDS9960_AICLEAR 0xE7
|
|
#define APDS9960_GFIFO_U 0xFC
|
|
#define APDS9960_GFIFO_D 0xFD
|
|
#define APDS9960_GFIFO_L 0xFE
|
|
#define APDS9960_GFIFO_R 0xFF
|
|
|
|
/* Bit fields */
|
|
#define APDS9960_PON 0b00000001
|
|
#define APDS9960_AEN 0b00000010
|
|
#define APDS9960_PEN 0b00000100
|
|
#define APDS9960_WEN 0b00001000
|
|
#define APDS9960_AIEN 0b00010000
|
|
#define APDS9960_PIEN 0b00100000
|
|
#define APDS9960_GEN 0b01000000
|
|
|
|
#define APDS9960_GVALID 0b00000001
|
|
|
|
/* On/Off definitions */
|
|
#define OFF 0
|
|
#define ON 1
|
|
|
|
/* Acceptable parameters for setMode */
|
|
#define POWER 0
|
|
#define AMBIENT_LIGHT 1
|
|
#define PROXIMITY 2
|
|
#define WAIT 3
|
|
#define AMBIENT_LIGHT_INT 4
|
|
#define PROXIMITY_INT 5
|
|
#define GESTURE 6
|
|
#define ALL 7
|
|
|
|
/* LED Drive values */
|
|
#define LED_DRIVE_100MA 0
|
|
#define LED_DRIVE_50MA 1
|
|
#define LED_DRIVE_25MA 2
|
|
#define LED_DRIVE_12_5MA 3
|
|
|
|
/* Proximity Gain (PGAIN) values */
|
|
#define PGAIN_1X 0
|
|
#define PGAIN_2X 1
|
|
#define PGAIN_4X 2
|
|
#define PGAIN_8X 3
|
|
|
|
/* ALS Gain (AGAIN) values */
|
|
#define AGAIN_1X 0
|
|
#define AGAIN_4X 1
|
|
#define AGAIN_16X 2
|
|
#define AGAIN_64X 3
|
|
|
|
/* Gesture Gain (GGAIN) values */
|
|
#define GGAIN_1X 0
|
|
#define GGAIN_2X 1
|
|
#define GGAIN_4X 2
|
|
#define GGAIN_8X 3
|
|
|
|
/* LED Boost values */
|
|
#define LED_BOOST_100 0
|
|
#define LED_BOOST_150 1
|
|
#define LED_BOOST_200 2
|
|
#define LED_BOOST_300 3
|
|
|
|
/* Gesture wait time values */
|
|
#define GWTIME_0MS 0
|
|
#define GWTIME_2_8MS 1
|
|
#define GWTIME_5_6MS 2
|
|
#define GWTIME_8_4MS 3
|
|
#define GWTIME_14_0MS 4
|
|
#define GWTIME_22_4MS 5
|
|
#define GWTIME_30_8MS 6
|
|
#define GWTIME_39_2MS 7
|
|
|
|
|
|
|
|
/* Default values */
|
|
#define DEFAULT_ATIME 0xdb // 103ms = 0xdb = 219
|
|
#define DEFAULT_WTIME 246 // 27ms
|
|
#define DEFAULT_PROX_PPULSE 0x87 // 16us, 8 pulses
|
|
#define DEFAULT_GESTURE_PPULSE 0x89 // 16us, 10 pulses ---89
|
|
#define DEFAULT_POFFSET_UR 0 // 0 offset
|
|
#define DEFAULT_POFFSET_DL 0 // 0 offset
|
|
#define DEFAULT_CONFIG1 0x60 // No 12x wait (WTIME) factor
|
|
#define DEFAULT_LDRIVE LED_DRIVE_100MA
|
|
#define DEFAULT_PGAIN PGAIN_4X
|
|
#define DEFAULT_AGAIN AGAIN_4X // we have to divide by the same facot at the end
|
|
#define DEFAULT_PILT 0 // Low proximity threshold
|
|
#define DEFAULT_PIHT 50 // High proximity threshold
|
|
#define DEFAULT_AILT 0xFFFF // Force interrupt for calibration
|
|
#define DEFAULT_AIHT 0
|
|
#define DEFAULT_PERS 0x11 // 2 consecutive prox or ALS for int.
|
|
#define DEFAULT_CONFIG2 0x01 // No saturation interrupts or LED boost
|
|
#define DEFAULT_CONFIG3 0 // Enable all photodiodes, no SAI
|
|
#define DEFAULT_GPENTH 40 // Threshold for entering gesture mode
|
|
#define DEFAULT_GEXTH 30 // Threshold for exiting gesture mode
|
|
#define DEFAULT_GCONF1 0x40 // 4 gesture events for int., 1 for exit
|
|
#define DEFAULT_GGAIN GGAIN_4X
|
|
#define DEFAULT_GLDRIVE LED_DRIVE_100MA // default 100ma
|
|
#define DEFAULT_GWTIME GWTIME_2_8MS // default 2_8MS
|
|
#define DEFAULT_GOFFSET 0 // No offset scaling for gesture mode
|
|
#define DEFAULT_GPULSE 0xC9 // 32us, 10 pulses
|
|
#define DEFAULT_GCONF3 0 // All photodiodes active during gesture
|
|
#define DEFAULT_GIEN 0 // Disable gesture interrupts
|
|
|
|
#define APDS9960_ERROR 0xFF
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
|
|
/* Direction definitions */
|
|
const char GESTURE_UP[] PROGMEM = "Up";
|
|
const char GESTURE_DOWN[] PROGMEM = "Down";
|
|
const char GESTURE_LEFT[] PROGMEM = "Left";
|
|
const char GESTURE_RIGHT[] PROGMEM = "Right";
|
|
const char GESTURE_LONG[] PROGMEM = "Long";
|
|
const char GESTURE_NONE[] PROGMEM = "None";
|
|
|
|
enum {
|
|
DIR_NONE,
|
|
DIR_LEFT,
|
|
DIR_RIGHT,
|
|
DIR_UP,
|
|
DIR_DOWN,
|
|
DIR_NEAR,
|
|
DIR_FAR,
|
|
DIR_ALL
|
|
};
|
|
|
|
/* State definitions*/
|
|
/*
|
|
enum {
|
|
APDS9960_NA_STATE,
|
|
APDS9960_NEAR_STATE,
|
|
APDS9960_FAR_STATE,
|
|
APDS9960_ALL_STATE
|
|
};
|
|
*/
|
|
|
|
/* Container for gesture data */
|
|
typedef struct gesture_data_type {
|
|
uint8_t u_data[32];
|
|
uint8_t d_data[32];
|
|
uint8_t l_data[32];
|
|
uint8_t r_data[32];
|
|
uint8_t index;
|
|
uint8_t total_gestures;
|
|
uint8_t in_threshold;
|
|
uint8_t out_threshold;
|
|
} gesture_data_t;
|
|
|
|
typedef struct gesture_type {
|
|
int16_t ud_delta_ = 0;
|
|
int16_t lr_delta_ = 0;
|
|
int16_t ud_count_ = 0;
|
|
int16_t lr_count_ = 0;
|
|
int16_t state_ = 0;
|
|
int16_t motion_ = DIR_NONE;
|
|
} gesture_t;
|
|
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
#if defined(USE_APDS9960_COLOR) || defined(USE_APDS9960_PROXIMITY)
|
|
typedef struct color_data_type {
|
|
uint16_t a; // measured ambient
|
|
uint16_t r; // Red
|
|
uint16_t g; // Green
|
|
uint16_t b; // Blue
|
|
uint8_t p; // proximity
|
|
|
|
uint16_t cct; // calculated color temperature
|
|
uint16_t lux; // calculated illuminance - atm only from rgb
|
|
} color_data_t;
|
|
#endif // USE_APDS9960_COLOR || USE_APDS9960_PROXIMITY
|
|
|
|
/******************************************************************************\
|
|
* Globals
|
|
\******************************************************************************/
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
gesture_data_t gesture_data;
|
|
gesture_t gesture;
|
|
char currentGesture[6];
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
#if defined(USE_APDS9960_COLOR) || defined(USE_APDS9960_PROXIMITY)
|
|
color_data_t color_data;
|
|
#endif // USE_APDS9960_COLOR || USE_APDS9960_PROXIMITY
|
|
|
|
volatile uint8_t recovery_loop_counter = 0; // count number of stateloops to switch the sensor off, if needed
|
|
bool APDS9960_overload = false;
|
|
uint8_t APDS9960_aTime = DEFAULT_ATIME;
|
|
uint8_t APDS9960_type = 0;
|
|
uint8_t gesture_mode = 1; // 1 : Gesture | 2 : Color
|
|
|
|
/******************************************************************************\
|
|
* Helper functions
|
|
\******************************************************************************/
|
|
|
|
#ifdef USE_APDS9960_COLOR
|
|
/**
|
|
* Taken from the Adafruit-library
|
|
* @brief Converts the raw R/G/B values to color temperature in degrees
|
|
* Kelvin
|
|
*/
|
|
void calculateColorTemperature(void) {
|
|
float X, Y, Z; /* RGB to XYZ correlation */
|
|
float xc, yc; /* Chromaticity co-ordinates */
|
|
float n; /* McCamy's formula */
|
|
float cct;
|
|
|
|
/* 1. Map RGB values to their XYZ counterparts. */
|
|
/* Based on 6500K fluorescent, 3000K fluorescent */
|
|
/* and 60W incandescent values for a wide range. */
|
|
/* Note: Y = Illuminance or lux */
|
|
X = (-0.14282F * color_data.r) + (1.54924F * color_data.g) + (-0.95641F * color_data.b);
|
|
Y = (-0.32466F * color_data.r) + (1.57837F * color_data.g) + (-0.73191F * color_data.b); // this is Lux ... under certain circumstances
|
|
Z = (-0.68202F * color_data.r) + (0.77073F * color_data.g) + (+0.56332F * color_data.b);
|
|
|
|
/* 2. Calculate the chromaticity co-ordinates */
|
|
xc = (X) / (X + Y + Z);
|
|
yc = (Y) / (X + Y + Z);
|
|
|
|
/* 3. Use McCamy's formula to determine the CCT */
|
|
n = (xc - 0.3320F) / (0.1858F - yc);
|
|
|
|
/* Calculate the final CCT */
|
|
color_data.cct = (449.0F * FastPrecisePowf(n, 3)) + (3525.0F * FastPrecisePowf(n, 2)) + (6823.3F * n) + 5520.33F;
|
|
|
|
return;
|
|
}
|
|
#endif // USE_APDS9960_COLOR
|
|
|
|
/******************************************************************************\
|
|
* Getters and setters for register values
|
|
\******************************************************************************/
|
|
|
|
/**
|
|
* @brief Returns the lower threshold for proximity detection
|
|
*
|
|
* @return lower threshold
|
|
*/
|
|
uint8_t getProxIntLowThresh(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from PILT register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_PILT);
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the lower threshold for proximity detection
|
|
*
|
|
* @param[in] threshold the lower proximity threshold
|
|
*/
|
|
inline void setProxIntLowThresh(uint8_t threshold) {
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PILT, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns the high threshold for proximity detection
|
|
*
|
|
* @return high threshold
|
|
*/
|
|
uint8_t getProxIntHighThresh(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from PIHT register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_PIHT);
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the high threshold for proximity detection
|
|
*
|
|
* @param[in] threshold the high proximity threshold
|
|
*/
|
|
inline void setProxIntHighThresh(uint8_t threshold) {
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PIHT, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns LED drive strength for proximity and ALS
|
|
*
|
|
* Value LED Current
|
|
* 0 100 mA
|
|
* 1 50 mA
|
|
* 2 25 mA
|
|
* 3 12.5 mA
|
|
*
|
|
* @return the value of the LED drive strength. 0xFF on failure.
|
|
*/
|
|
uint8_t getLEDDrive(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Shift and mask out LED drive bits */
|
|
val = (val >> 6) & 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the LED drive strength for proximity and ALS
|
|
*
|
|
* Value LED Current
|
|
* 0 100 mA
|
|
* 1 50 mA
|
|
* 2 25 mA
|
|
* 3 12.5 mA
|
|
*
|
|
* @param[in] drive the value (0-3) for the LED drive strength
|
|
*/
|
|
void setLEDDrive(uint8_t drive) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Set bits in register to given value */
|
|
drive &= 0b00000011;
|
|
drive = drive << 6;
|
|
val &= 0b00111111;
|
|
val |= drive;
|
|
|
|
/* Write register value back into CONTROL register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONTROL, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns receiver gain for proximity detection
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 2x
|
|
* 2 4x
|
|
* 3 8x
|
|
*
|
|
* @return the value of the proximity gain. 0xFF on failure.
|
|
*/
|
|
uint8_t getProximityGain(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Shift and mask out PDRIVE bits */
|
|
val = (val >> 2) & 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the receiver gain for proximity detection
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 2x
|
|
* 2 4x
|
|
* 3 8x
|
|
*
|
|
* @param[in] drive the value (0-3) for the gain
|
|
*/
|
|
void setProximityGain(uint8_t drive) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Set bits in register to given value */
|
|
drive &= 0b00000011;
|
|
drive = drive << 2;
|
|
val &= 0b11110011;
|
|
val |= drive;
|
|
|
|
/* Write register value back into CONTROL register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONTROL, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Returns receiver gain for the ambient light sensor (ALS)
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 4x
|
|
* 2 16x
|
|
* 3 64x
|
|
*
|
|
* @return the value of the ALS gain. 0xFF on failure.
|
|
*/
|
|
uint8_t getAmbientLightGain() {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Shift and mask out ADRIVE bits */
|
|
val &= 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the receiver gain for the ambient light sensor (ALS)
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 4x
|
|
* 2 16x
|
|
* 3 64x
|
|
*
|
|
* @param[in] drive the value (0-3) for the gain
|
|
*/
|
|
void setAmbientLightGain(uint8_t drive) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONTROL register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONTROL);
|
|
|
|
/* Set bits in register to given value */
|
|
drive &= 0b00000011;
|
|
val &= 0b11111100;
|
|
val |= drive;
|
|
|
|
/* Write register value back into CONTROL register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONTROL, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Get the current LED boost value
|
|
*
|
|
* Value Boost Current
|
|
* 0 100%
|
|
* 1 150%
|
|
* 2 200%
|
|
* 3 300%
|
|
*
|
|
* @return The LED boost value. 0xFF on failure.
|
|
*/
|
|
uint8_t getLEDBoost(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG2);
|
|
|
|
/* Shift and mask out LED_BOOST bits */
|
|
val = (val >> 4) & 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the LED current boost value
|
|
*
|
|
* Value Boost Current
|
|
* 0 100%
|
|
* 1 150%
|
|
* 2 200%
|
|
* 3 300%
|
|
*
|
|
* @param[in] drive the value (0-3) for current boost (100-300%)
|
|
*/
|
|
void setLEDBoost(uint8_t boost) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG2);
|
|
|
|
/* Set bits in register to given value */
|
|
boost &= 0b00000011;
|
|
boost = boost << 4;
|
|
val &= 0b11001111;
|
|
val |= boost;
|
|
|
|
/* Write register value back into CONFIG2 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG2, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets proximity gain compensation enable
|
|
*
|
|
* @return 1 if compensation is enabled. 0 if not. 0xFF on error.
|
|
*/
|
|
uint8_t getProxGainCompEnable(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG3 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
|
|
|
|
/* Shift and mask out PCMP bits */
|
|
val = (val >> 5) & 0b00000001;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the proximity gain compensation enable
|
|
*
|
|
* @param[in] enable 1 to enable compensation. 0 to disable compensation.
|
|
*/
|
|
void setProxGainCompEnable(uint8_t enable) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG3 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
|
|
|
|
/* Set bits in register to given value */
|
|
enable &= 0b00000001;
|
|
enable = enable << 5;
|
|
val &= 0b11011111;
|
|
val |= enable;
|
|
|
|
/* Write register value back into CONFIG3 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG3, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the current mask for enabled/disabled proximity photodiodes
|
|
*
|
|
* 1 = disabled, 0 = enabled
|
|
* Bit Photodiode
|
|
* 3 UP
|
|
* 2 DOWN
|
|
* 1 LEFT
|
|
* 0 RIGHT
|
|
*
|
|
* @return Current proximity mask for photodiodes. 0xFF on error.
|
|
*/
|
|
uint8_t getProxPhotoMask(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG3 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
|
|
|
|
/* Mask out photodiode enable mask bits */
|
|
val &= 0b00001111;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the mask for enabling/disabling proximity photodiodes
|
|
*
|
|
* 1 = disabled, 0 = enabled
|
|
* Bit Photodiode
|
|
* 3 UP
|
|
* 2 DOWN
|
|
* 1 LEFT
|
|
* 0 RIGHT
|
|
*
|
|
* @param[in] mask 4-bit mask value
|
|
*/
|
|
void setProxPhotoMask(uint8_t mask) {
|
|
uint8_t val;
|
|
|
|
/* Read value from CONFIG3 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
|
|
|
|
/* Set bits in register to given value */
|
|
mask &= 0b00001111;
|
|
val &= 0b11110000;
|
|
val |= mask;
|
|
|
|
/* Write register value back into CONFIG3 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG3, val);
|
|
}
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
|
|
/**
|
|
* @brief Gets the entry proximity threshold for gesture sensing
|
|
*
|
|
* @return Current entry proximity threshold.
|
|
*/
|
|
uint8_t getGestureEnterThresh(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GPENTH register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GPENTH);
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the entry proximity threshold for gesture sensing
|
|
*
|
|
* @param[in] threshold proximity value needed to start gesture mode
|
|
*/
|
|
inline void setGestureEnterThresh(uint8_t threshold) {
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GPENTH, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the exit proximity threshold for gesture sensing
|
|
*
|
|
* @return Current exit proximity threshold.
|
|
*/
|
|
uint8_t getGestureExitThresh(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GEXTH register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GEXTH);
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the exit proximity threshold for gesture sensing
|
|
*
|
|
* @param[in] threshold proximity value needed to end gesture mode
|
|
*/
|
|
inline void setGestureExitThresh(uint8_t threshold) {
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GEXTH, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the gain of the photodiode during gesture mode
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 2x
|
|
* 2 4x
|
|
* 3 8x
|
|
*
|
|
* @return the current photodiode gain. 0xFF on error.
|
|
*/
|
|
uint8_t getGestureGain(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Shift and mask out GGAIN bits */
|
|
val = (val >> 5) & 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the gain of the photodiode during gesture mode
|
|
*
|
|
* Value Gain
|
|
* 0 1x
|
|
* 1 2x
|
|
* 2 4x
|
|
* 3 8x
|
|
*
|
|
* @param[in] gain the value for the photodiode gain
|
|
*/
|
|
void setGestureGain(uint8_t gain) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Set bits in register to given value */
|
|
gain &= 0b00000011;
|
|
gain = gain << 5;
|
|
val &= 0b10011111;
|
|
val |= gain;
|
|
|
|
/* Write register value back into GCONF2 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF2, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the drive current of the LED during gesture mode
|
|
*
|
|
* Value LED Current
|
|
* 0 100 mA
|
|
* 1 50 mA
|
|
* 2 25 mA
|
|
* 3 12.5 mA
|
|
*
|
|
* @return the LED drive current value. 0xFF on error.
|
|
*/
|
|
uint8_t getGestureLEDDrive(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Shift and mask out GLDRIVE bits */
|
|
val = (val >> 3) & 0b00000011;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the LED drive current during gesture mode
|
|
*
|
|
* Value LED Current
|
|
* 0 100 mA
|
|
* 1 50 mA
|
|
* 2 25 mA
|
|
* 3 12.5 mA
|
|
*
|
|
* @param[in] drive the value for the LED drive current
|
|
*/
|
|
void setGestureLEDDrive(uint8_t drive) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Set bits in register to given value */
|
|
drive &= 0b00000011;
|
|
drive = drive << 3;
|
|
val &= 0b11100111;
|
|
val |= drive;
|
|
|
|
/* Write register value back into GCONF2 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF2, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the time in low power mode between gesture detections
|
|
*
|
|
* Value Wait time
|
|
* 0 0 ms
|
|
* 1 2.8 ms
|
|
* 2 5.6 ms
|
|
* 3 8.4 ms
|
|
* 4 14.0 ms
|
|
* 5 22.4 ms
|
|
* 6 30.8 ms
|
|
* 7 39.2 ms
|
|
*
|
|
* @return the current wait time between gestures. 0xFF on error.
|
|
*/
|
|
uint8_t getGestureWaitTime(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Mask out GWTIME bits */
|
|
val &= 0b00000111;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the time in low power mode between gesture detections
|
|
*
|
|
* Value Wait time
|
|
* 0 0 ms
|
|
* 1 2.8 ms
|
|
* 2 5.6 ms
|
|
* 3 8.4 ms
|
|
* 4 14.0 ms
|
|
* 5 22.4 ms
|
|
* 6 30.8 ms
|
|
* 7 39.2 ms
|
|
*
|
|
* @param[in] the value for the wait time
|
|
*/
|
|
void setGestureWaitTime(uint8_t time) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF2 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF2);
|
|
|
|
/* Set bits in register to given value */
|
|
time &= 0b00000111;
|
|
val &= 0b11111000;
|
|
val |= time;
|
|
|
|
/* Write register value back into GCONF2 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF2, val);
|
|
}
|
|
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
/**
|
|
* @brief Gets the low threshold for ambient light interrupts
|
|
*
|
|
* @param[out] threshold current low threshold stored on the APDS-9960
|
|
*/
|
|
void getLightIntLowThreshold(uint16_t &threshold) {
|
|
uint8_t val_byte;
|
|
threshold = 0;
|
|
|
|
/* Read value from ambient light low threshold, low byte register */
|
|
val_byte = I2cRead8(APDS9960_I2C_ADDR, APDS9960_AILTL);
|
|
threshold = val_byte;
|
|
|
|
/* Read value from ambient light low threshold, high byte register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AILTH, val_byte);
|
|
threshold = threshold + ((uint16_t)val_byte << 8);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the low threshold for ambient light interrupts
|
|
*
|
|
* @param[in] threshold low threshold value for interrupt to trigger
|
|
*/
|
|
void setLightIntLowThreshold(uint16_t threshold) {
|
|
uint8_t val_low;
|
|
uint8_t val_high;
|
|
|
|
/* Break 16-bit threshold into 2 8-bit values */
|
|
val_low = threshold & 0x00FF;
|
|
val_high = (threshold & 0xFF00) >> 8;
|
|
|
|
/* Write low byte */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AILTL, val_low);
|
|
|
|
/* Write high byte */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AILTH, val_high);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the high threshold for ambient light interrupts
|
|
*
|
|
* @param[out] threshold current low threshold stored on the APDS-9960
|
|
*/
|
|
void getLightIntHighThreshold(uint16_t &threshold) {
|
|
uint8_t val_byte;
|
|
threshold = 0;
|
|
|
|
/* Read value from ambient light high threshold, low byte register */
|
|
val_byte = I2cRead8(APDS9960_I2C_ADDR, APDS9960_AIHTL);
|
|
threshold = val_byte;
|
|
|
|
/* Read value from ambient light high threshold, high byte register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AIHTH, val_byte);
|
|
threshold = threshold + ((uint16_t)val_byte << 8);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the high threshold for ambient light interrupts
|
|
*
|
|
* @param[in] threshold high threshold value for interrupt to trigger
|
|
*/
|
|
void setLightIntHighThreshold(uint16_t threshold) {
|
|
uint8_t val_low;
|
|
uint8_t val_high;
|
|
|
|
/* Break 16-bit threshold into 2 8-bit values */
|
|
val_low = threshold & 0x00FF;
|
|
val_high = (threshold & 0xFF00) >> 8;
|
|
|
|
/* Write low byte */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AIHTL, val_low);
|
|
|
|
/* Write high byte */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_AIHTH, val_high);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the low threshold for proximity interrupts
|
|
*
|
|
* @param[out] threshold current low threshold stored on the APDS-9960
|
|
*/
|
|
void getProximityIntLowThreshold(uint8_t &threshold) {
|
|
threshold = 0;
|
|
|
|
/* Read value from proximity low threshold register */
|
|
threshold = I2cRead8(APDS9960_I2C_ADDR, APDS9960_PILT);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the low threshold for proximity interrupts
|
|
*
|
|
* @param[in] threshold low threshold value for interrupt to trigger
|
|
*/
|
|
void setProximityIntLowThreshold(uint8_t threshold) {
|
|
/* Write threshold value to register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PILT, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets the high threshold for proximity interrupts
|
|
*
|
|
* @param[out] threshold current low threshold stored on the APDS-9960
|
|
*/
|
|
void getProximityIntHighThreshold(uint8_t &threshold) {
|
|
threshold = 0;
|
|
|
|
/* Read value from proximity low threshold register */
|
|
threshold = I2cRead8(APDS9960_I2C_ADDR, APDS9960_PIHT);
|
|
}
|
|
|
|
/**
|
|
* @brief Sets the high threshold for proximity interrupts
|
|
*
|
|
* @param[in] threshold high threshold value for interrupt to trigger
|
|
*/
|
|
void setProximityIntHighThreshold(uint8_t threshold) {
|
|
/* Write threshold value to register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PIHT, threshold);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets if ambient light interrupts are enabled or not
|
|
*
|
|
* @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
|
|
*/
|
|
uint8_t getAmbientLightIntEnable(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from ENABLE register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ENABLE);
|
|
|
|
/* Shift and mask out AIEN bit */
|
|
val = (val >> 4) & 0b00000001;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Turns ambient light interrupts on or off
|
|
*
|
|
* @param[in] enable 1 to enable interrupts, 0 to turn them off
|
|
*/
|
|
void setAmbientLightIntEnable(uint8_t enable) {
|
|
uint8_t val;
|
|
|
|
/* Read value from ENABLE register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ENABLE);
|
|
|
|
/* Set bits in register to given value */
|
|
enable &= 0b00000001;
|
|
enable = enable << 4;
|
|
val &= 0b11101111;
|
|
val |= enable;
|
|
|
|
/* Write register value back into ENABLE register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ENABLE, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets if proximity interrupts are enabled or not
|
|
*
|
|
* @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
|
|
*/
|
|
uint8_t getProximityIntEnable(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from ENABLE register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ENABLE);
|
|
|
|
/* Shift and mask out PIEN bit */
|
|
val = (val >> 5) & 0b00000001;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Turns proximity interrupts on or off
|
|
*
|
|
* @param[in] enable 1 to enable interrupts, 0 to turn them off
|
|
*/
|
|
void setProximityIntEnable(uint8_t enable) {
|
|
uint8_t val;
|
|
|
|
/* Read value from ENABLE register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ENABLE);
|
|
|
|
/* Set bits in register to given value */
|
|
enable &= 0b00000001;
|
|
enable = enable << 5;
|
|
val &= 0b11011111;
|
|
val |= enable;
|
|
|
|
/* Write register value back into ENABLE register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ENABLE, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Gets if gesture interrupts are enabled or not
|
|
*
|
|
* @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
|
|
*/
|
|
uint8_t getGestureIntEnable(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF4 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF4);
|
|
|
|
/* Shift and mask out GIEN bit */
|
|
val = (val >> 1) & 0b00000001;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Turns gesture-related interrupts on or off
|
|
*
|
|
* @param[in] enable 1 to enable interrupts, 0 to turn them off
|
|
*/
|
|
void setGestureIntEnable(uint8_t enable) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF4 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF4);
|
|
|
|
/* Set bits in register to given value */
|
|
enable &= 0b00000001;
|
|
enable = enable << 1;
|
|
val &= 0b11111101;
|
|
val |= enable;
|
|
|
|
/* Write register value back into GCONF4 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF4, val);
|
|
}
|
|
|
|
/**
|
|
* @brief Clears the ambient light interrupt
|
|
*
|
|
*/
|
|
void clearAmbientLightInt(void) {
|
|
uint8_t throwaway;
|
|
throwaway = I2cRead8(APDS9960_I2C_ADDR, APDS9960_AICLEAR);
|
|
}
|
|
|
|
/**
|
|
* @brief Clears the proximity interrupt
|
|
*
|
|
*/
|
|
void clearProximityInt(void) {
|
|
uint8_t throwaway;
|
|
throwaway = I2cRead8(APDS9960_I2C_ADDR, APDS9960_PICLEAR);
|
|
}
|
|
|
|
/**
|
|
* @brief Tells if the gesture state machine is currently running
|
|
*
|
|
* @return 1 if gesture state machine is running, 0 if not. 0xFF on error.
|
|
*/
|
|
uint8_t getGestureMode(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF4 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF4);
|
|
|
|
/* Mask out GMODE bit */
|
|
val &= 0b00000001;
|
|
|
|
return val;
|
|
}
|
|
|
|
/**
|
|
* @brief Tells the state machine to either enter or exit gesture state machine
|
|
*
|
|
* @param[in] mode 1 to enter gesture state machine, 0 to exit.
|
|
*/
|
|
void setGestureMode(uint8_t mode) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GCONF4 register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GCONF4);
|
|
|
|
/* Set bits in register to given value */
|
|
mode &= 0b00000001;
|
|
val &= 0b11111110;
|
|
val |= mode;
|
|
|
|
/* Write register value back into GCONF4 register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF4, val);
|
|
}
|
|
|
|
|
|
bool APDS9960_init(void) {
|
|
setMode(ALL, OFF);
|
|
|
|
/* Set default values for ambient light and proximity registers */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ATIME, DEFAULT_ATIME);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_WTIME, DEFAULT_WTIME);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PPULSE, DEFAULT_PROX_PPULSE);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_POFFSET_UR, DEFAULT_POFFSET_UR);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_POFFSET_DL, DEFAULT_POFFSET_DL);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG1, DEFAULT_CONFIG1);
|
|
|
|
setLEDDrive(DEFAULT_LDRIVE);
|
|
setProximityGain(DEFAULT_PGAIN);
|
|
setAmbientLightGain(DEFAULT_AGAIN);
|
|
setProxIntLowThresh(DEFAULT_PILT);
|
|
setProxIntHighThresh(DEFAULT_PIHT);
|
|
setLightIntLowThreshold(DEFAULT_AILT);
|
|
setLightIntHighThreshold(DEFAULT_AIHT);
|
|
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PERS, DEFAULT_PERS);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG2, DEFAULT_CONFIG2);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_CONFIG3, DEFAULT_CONFIG3);
|
|
|
|
/* Set default values for gesture sense registers */
|
|
#ifdef USE_APDS9960_GESTURE
|
|
setGestureEnterThresh(DEFAULT_GPENTH);
|
|
setGestureExitThresh(DEFAULT_GEXTH);
|
|
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF1, DEFAULT_GCONF1);
|
|
|
|
setGestureGain(DEFAULT_GGAIN);
|
|
setGestureLEDDrive(DEFAULT_GLDRIVE);
|
|
setGestureWaitTime(DEFAULT_GWTIME);
|
|
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GOFFSET_U, DEFAULT_GOFFSET);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GOFFSET_D, DEFAULT_GOFFSET);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GOFFSET_L, DEFAULT_GOFFSET);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GOFFSET_R, DEFAULT_GOFFSET);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GPULSE, DEFAULT_GPULSE);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_GCONF3, DEFAULT_GCONF3);
|
|
|
|
setGestureIntEnable(DEFAULT_GIEN);
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
disablePower(); // go to sleep
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/******************************************************************************\
|
|
* Public methods for controlling the APDS-9960
|
|
\******************************************************************************/
|
|
|
|
/**
|
|
* @brief Reads and returns the contents of the ENABLE register
|
|
*
|
|
* @return Contents of the ENABLE register. 0xFF if error.
|
|
*/
|
|
inline uint8_t getMode(void) {
|
|
uint8_t enable_value;
|
|
|
|
/* Read current ENABLE register */
|
|
enable_value = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ENABLE);
|
|
|
|
return enable_value;
|
|
}
|
|
|
|
/**
|
|
* @brief Enables or disables a feature in the APDS-9960
|
|
*
|
|
* @param[in] mode which feature to enable
|
|
* @param[in] enable ON (1) or OFF (0)
|
|
*/
|
|
void setMode(uint8_t mode, uint8_t enable) {
|
|
uint8_t reg_val;
|
|
|
|
/* Read current ENABLE register */
|
|
reg_val = getMode();
|
|
|
|
/* Change bit(s) in ENABLE register */
|
|
enable = enable & 0x01;
|
|
if (mode <= 6) {
|
|
if (enable) {
|
|
reg_val |= (1 << mode);
|
|
} else {
|
|
reg_val &= ~(1 << mode);
|
|
}
|
|
} else if (mode == ALL) {
|
|
if (enable) {
|
|
reg_val = 0x7F;
|
|
} else {
|
|
reg_val = 0x00;
|
|
}
|
|
}
|
|
|
|
/* Write value back to ENABLE register */
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ENABLE, reg_val);
|
|
}
|
|
|
|
/**
|
|
* @brief Starts the light (R/G/B/Ambient) sensor on the APDS-9960
|
|
*
|
|
* no interrupts
|
|
*/
|
|
void enableLightSensor(void) {
|
|
/* Set default gain, interrupts, enable power, and enable sensor */
|
|
setAmbientLightGain(DEFAULT_AGAIN);
|
|
setAmbientLightIntEnable(OFF);
|
|
enablePower();
|
|
setMode(AMBIENT_LIGHT, ON);
|
|
}
|
|
|
|
/**
|
|
* @brief Ends the light sensor on the APDS-9960
|
|
*
|
|
*/
|
|
void disableLightSensor(void) {
|
|
setAmbientLightIntEnable(OFF);
|
|
setMode(AMBIENT_LIGHT, OFF);
|
|
}
|
|
|
|
/**
|
|
* @brief Starts the proximity sensor on the APDS-9960
|
|
*
|
|
* no interrupts
|
|
*/
|
|
void enableProximitySensor(void) {
|
|
/* Set default gain, LED, interrupts, enable power, and enable sensor */
|
|
setProximityGain(DEFAULT_PGAIN);
|
|
setLEDDrive(DEFAULT_LDRIVE);
|
|
setProximityIntEnable(OFF);
|
|
enablePower();
|
|
setMode(PROXIMITY, ON);
|
|
}
|
|
|
|
/**
|
|
* @brief Ends the proximity sensor on the APDS-9960
|
|
*
|
|
*/
|
|
void disableProximitySensor(void) {
|
|
setProximityIntEnable(OFF);
|
|
setMode(PROXIMITY, OFF);
|
|
}
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
/**
|
|
* @brief Starts the gesture recognition engine on the APDS-9960
|
|
*
|
|
* no interrupts
|
|
*/
|
|
void enableGestureSensor(void) {
|
|
/* Enable gesture mode
|
|
Set ENABLE to 0 (power off)
|
|
Set WTIME to 0xFF
|
|
Set AUX to LED_BOOST_300
|
|
Enable PON, WEN, PEN, GEN in ENABLE
|
|
*/
|
|
|
|
resetGestureParameters();
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_WTIME, 0xFF);
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_PPULSE, DEFAULT_GESTURE_PPULSE);
|
|
setLEDBoost(LED_BOOST_100); // tip from jonn26 - 100 for 300 ---- 200 from Adafruit
|
|
setGestureIntEnable(OFF);
|
|
setGestureMode(ON);
|
|
enablePower();
|
|
setMode(WAIT, ON);
|
|
setMode(PROXIMITY, ON);
|
|
setMode(GESTURE, ON);
|
|
}
|
|
|
|
/**
|
|
* @brief Ends the gesture recognition engine on the APDS-9960
|
|
*
|
|
*/
|
|
void disableGestureSensor(void) {
|
|
resetGestureParameters();
|
|
setGestureIntEnable(OFF);
|
|
setGestureMode(OFF);
|
|
setMode(GESTURE, OFF);
|
|
}
|
|
|
|
/**
|
|
* @brief Determines if there is a gesture available for reading
|
|
*
|
|
* @return True if gesture available. False otherwise.
|
|
*/
|
|
bool isGestureAvailable(void) {
|
|
uint8_t val;
|
|
|
|
/* Read value from GSTATUS register */
|
|
val = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GSTATUS);
|
|
|
|
/* Shift and mask out GVALID bit */
|
|
val &= APDS9960_GVALID;
|
|
|
|
/* Return true/false based on GVALID bit */
|
|
return (val == 1);
|
|
}
|
|
|
|
/**
|
|
* @brief Processes a gesture event and returns best guessed gesture
|
|
*
|
|
* @return Number corresponding to gesture. -1 on error.
|
|
*/
|
|
int16_t readGesture(void) {
|
|
uint8_t fifo_level = 0;
|
|
uint8_t fifo_data[128];
|
|
uint8_t gstatus;
|
|
int16_t motion;
|
|
uint16_t i;
|
|
uint8_t gesture_loop_counter = 0; // don't loop forever later
|
|
int8_t bytes_read = 0;
|
|
|
|
/* Make sure that power and gesture is on and data is valid */
|
|
if (!isGestureAvailable() || !(getMode() & 0b01000001)) {
|
|
return DIR_NONE;
|
|
}
|
|
|
|
/* Keep looping as long as gesture data is valid */
|
|
while (1) {
|
|
if (gesture_loop_counter == APDS9960_MAX_GESTURE_CYCLES) { // We will escape after a few loops
|
|
disableGestureSensor(); // stop the sensor to prevent problems with power consumption/blocking and return to the main loop
|
|
APDS9960_overload = true; // we report this as "long"-gesture
|
|
AddLog(LOG_LEVEL_DEBUG, PSTR("Sensor overload"));
|
|
}
|
|
gesture_loop_counter += 1;
|
|
|
|
/* Wait some time to collect next batch of FIFO data */
|
|
delay(FIFO_PAUSE_TIME);
|
|
|
|
/* Get the contents of the STATUS register. Is data still valid? */
|
|
gstatus = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GSTATUS);
|
|
|
|
/* If we have valid data, read in FIFO */
|
|
if ((gstatus & APDS9960_GVALID) == APDS9960_GVALID) {
|
|
/* Read the current FIFO level */
|
|
fifo_level = I2cRead8(APDS9960_I2C_ADDR, APDS9960_GFLVL);
|
|
|
|
#ifdef USE_DEBUG_DRIVER
|
|
AddLog(LOG_LEVEL_DEBUG, PSTR("DRV: FIFO Level : %d"), fifo_level);
|
|
#endif // USE_DEBUG_DRIVER
|
|
|
|
/* If there's stuff in the FIFO, read it into our data block */
|
|
if (fifo_level > 0) {
|
|
bytes_read = (fifo_level * 4);
|
|
|
|
if (I2cReadBuffer(APDS9960_I2C_ADDR, APDS9960_GFIFO_U, (uint8_t*)fifo_data, bytes_read)) {
|
|
return APDS9960_ERROR;
|
|
}
|
|
|
|
#ifdef USE_DEBUG_DRIVER
|
|
char output[(bytes_read * 2) + 1];
|
|
char *ptr = &output[0];
|
|
|
|
for ( i = 0; i < bytes_read; i++ ) {
|
|
ptr += sprintf(ptr, "%02X", fifo_data[i]);
|
|
}
|
|
AddLog(LOG_LEVEL_DEBUG, PSTR("DRV: FIFO Dump : %s"), output);
|
|
#endif // USE_DEBUG_DRIVER
|
|
|
|
/* If at least 1 set of data, sort the data into U/D/L/R */
|
|
if (bytes_read >= 4) {
|
|
for (i = 0; i < bytes_read; i += 4) {
|
|
gesture_data.u_data[gesture_data.index] = fifo_data[i + 0];
|
|
gesture_data.d_data[gesture_data.index] = fifo_data[i + 1];
|
|
gesture_data.l_data[gesture_data.index] = fifo_data[i + 2];
|
|
gesture_data.r_data[gesture_data.index] = fifo_data[i + 3];
|
|
gesture_data.index++;
|
|
gesture_data.total_gestures++;
|
|
}
|
|
|
|
/* Filter and process gesture data. Decode near/far state */
|
|
if (processGestureData()) {
|
|
if (decodeGesture()) {
|
|
// TODO(xx): U-Turn Gestures
|
|
}
|
|
}
|
|
/* Reset data */
|
|
gesture_data.index = 0;
|
|
gesture_data.total_gestures = 0;
|
|
}
|
|
}
|
|
} else {
|
|
/* Determine best guessed gesture and clean up */
|
|
delay(FIFO_PAUSE_TIME);
|
|
decodeGesture();
|
|
motion = gesture.motion_;
|
|
resetGestureParameters();
|
|
return motion;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
/**
|
|
* Turn the APDS-9960 on
|
|
*
|
|
*/
|
|
inline void enablePower(void) {
|
|
setMode(POWER, ON);
|
|
}
|
|
|
|
/**
|
|
* Turn the APDS-9960 off
|
|
*
|
|
*/
|
|
inline void disablePower(void) {
|
|
setMode(POWER, OFF);
|
|
}
|
|
|
|
|
|
/******************************************************************************\
|
|
* Ambient light and color sensor controls
|
|
\******************************************************************************/
|
|
|
|
#if defined(USE_APDS9960_COLOR) || defined(USE_APDS9960_PROXIMITY)
|
|
/**
|
|
* @brief Reads the ARGB-Data and fills color_data
|
|
*/
|
|
inline void readAllColorAndProximityData(void) {
|
|
if (I2cReadBuffer(APDS9960_I2C_ADDR, APDS9960_CDATAL, (uint8_t *) &color_data, (uint16_t)9)) {
|
|
// not absolutely shure, if this is a correct way to do this, but it is very short
|
|
// we fill the struct byte by byte
|
|
}
|
|
}
|
|
|
|
void APDS9960_adjustATime(void) { // not really used atm
|
|
// readAllColorAndProximityData();
|
|
I2cValidRead16LE(&color_data.a, APDS9960_I2C_ADDR, APDS9960_CDATAL);
|
|
// disablePower();
|
|
|
|
if (color_data.a < (uint16_t)20) {
|
|
APDS9960_aTime = 0x40;
|
|
} else if (color_data.a < (uint16_t)40) {
|
|
APDS9960_aTime = 0x80;
|
|
} else if (color_data.a < (uint16_t)50) {
|
|
APDS9960_aTime = DEFAULT_ATIME;
|
|
} else if (color_data.a < (uint16_t)70) {
|
|
APDS9960_aTime = 0xc0;
|
|
}
|
|
|
|
if (color_data.a < 200) {
|
|
APDS9960_aTime = 0xe9;
|
|
}
|
|
/* if (color_data.a < 10000){
|
|
APDS9960_aTime = 0xF0;
|
|
}*/
|
|
else {
|
|
APDS9960_aTime = 0xff;
|
|
}
|
|
|
|
// disableLightSensor();
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ATIME, APDS9960_aTime);
|
|
enablePower();
|
|
enableLightSensor();
|
|
delay(20);
|
|
}
|
|
#endif // USE_APDS9960_COLOR || USE_APDS9960_PROXIMITY
|
|
|
|
/******************************************************************************\
|
|
* High-level gesture controls
|
|
\******************************************************************************/
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
|
|
/**
|
|
* @brief Resets all the parameters in the gesture data member
|
|
*/
|
|
void resetGestureParameters(void) {
|
|
gesture_data.index = 0;
|
|
gesture_data.total_gestures = 0;
|
|
|
|
gesture.ud_delta_ = 0;
|
|
gesture.lr_delta_ = 0;
|
|
|
|
gesture.ud_count_ = 0;
|
|
gesture.lr_count_ = 0;
|
|
|
|
gesture.state_ = 0;
|
|
gesture.motion_ = DIR_NONE;
|
|
}
|
|
|
|
/**
|
|
* @brief Processes the raw gesture data to determine swipe direction
|
|
*
|
|
* @return True if near or far state seen. False otherwise.
|
|
*/
|
|
bool processGestureData(void) {
|
|
uint8_t u_first = 0;
|
|
uint8_t d_first = 0;
|
|
uint8_t l_first = 0;
|
|
uint8_t r_first = 0;
|
|
uint8_t u_last = 0;
|
|
uint8_t d_last = 0;
|
|
uint8_t l_last = 0;
|
|
uint8_t r_last = 0;
|
|
uint16_t ud_ratio_first;
|
|
uint16_t lr_ratio_first;
|
|
uint16_t ud_ratio_last;
|
|
uint16_t lr_ratio_last;
|
|
uint16_t ud_delta;
|
|
uint16_t lr_delta;
|
|
uint16_t i;
|
|
|
|
/* If we have less than 4 total gestures, that's not enough */
|
|
if (gesture_data.total_gestures <= 4) {
|
|
return false;
|
|
}
|
|
|
|
/* Check to make sure our data isn't out of bounds */
|
|
if ((gesture_data.total_gestures <= 32) && \
|
|
(gesture_data.total_gestures > 0)) {
|
|
/* Find the first value in U/D/L/R above the threshold */
|
|
for (i = 0; i < gesture_data.total_gestures; i++) {
|
|
if ((gesture_data.u_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.d_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.l_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.r_data[i] > GESTURE_THRESHOLD_OUT) ) {
|
|
u_first = gesture_data.u_data[i];
|
|
d_first = gesture_data.d_data[i];
|
|
l_first = gesture_data.l_data[i];
|
|
r_first = gesture_data.r_data[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* If one of the _first values is 0, then there is no good data */
|
|
if ((u_first == 0) || (d_first == 0) || (l_first == 0) || (r_first == 0)) {
|
|
return false;
|
|
}
|
|
|
|
/* Find the last value in U/D/L/R above the threshold */
|
|
for (i = gesture_data.total_gestures - 1; i >= 0; i--) {
|
|
if ((gesture_data.u_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.d_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.l_data[i] > GESTURE_THRESHOLD_OUT) &&
|
|
(gesture_data.r_data[i] > GESTURE_THRESHOLD_OUT)) {
|
|
u_last = gesture_data.u_data[i];
|
|
d_last = gesture_data.d_data[i];
|
|
l_last = gesture_data.l_data[i];
|
|
r_last = gesture_data.r_data[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Calculate the first vs. last ratio of up/down and left/right */
|
|
ud_ratio_first = ((u_first - d_first) * 100) / (u_first + d_first);
|
|
lr_ratio_first = ((l_first - r_first) * 100) / (l_first + r_first);
|
|
ud_ratio_last = ((u_last - d_last) * 100) / (u_last + d_last);
|
|
lr_ratio_last = ((l_last - r_last) * 100) / (l_last + r_last);
|
|
|
|
/* Determine the difference between the first and last ratios */
|
|
ud_delta = ud_ratio_last - ud_ratio_first;
|
|
lr_delta = lr_ratio_last - lr_ratio_first;
|
|
|
|
/* Accumulate the UD and LR delta values */
|
|
gesture.ud_delta_ += ud_delta;
|
|
gesture.lr_delta_ += lr_delta;
|
|
|
|
/* Determine U/D gesture */
|
|
if (gesture.ud_delta_ >= GESTURE_SENSITIVITY_1) {
|
|
gesture.ud_count_ = 1;
|
|
} else if (gesture.ud_delta_ <= -GESTURE_SENSITIVITY_1) {
|
|
gesture.ud_count_ = -1;
|
|
} else {
|
|
gesture.ud_count_ = 0;
|
|
}
|
|
|
|
/* Determine L/R gesture */
|
|
if (gesture.lr_delta_ >= GESTURE_SENSITIVITY_1) {
|
|
gesture.lr_count_ = 1;
|
|
} else if (gesture.lr_delta_ <= -GESTURE_SENSITIVITY_1) {
|
|
gesture.lr_count_ = -1;
|
|
} else {
|
|
gesture.lr_count_ = 0;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @brief Determines swipe direction or near/far state
|
|
*
|
|
* @return True if near/far event. False otherwise.
|
|
*/
|
|
bool decodeGesture(void) {
|
|
/* Determine swipe direction */
|
|
if ((gesture.ud_count_ == -1) && (gesture.lr_count_ == 0)) {
|
|
gesture.motion_ = DIR_UP;
|
|
} else if ((gesture.ud_count_ == 1) && (gesture.lr_count_ == 0)) {
|
|
gesture.motion_ = DIR_DOWN;
|
|
} else if ((gesture.ud_count_ == 0) && (gesture.lr_count_ == 1)) {
|
|
gesture.motion_ = DIR_RIGHT;
|
|
} else if ((gesture.ud_count_ == 0) && (gesture.lr_count_ == -1)) {
|
|
gesture.motion_ = DIR_LEFT;
|
|
} else if ((gesture.ud_count_ == -1) && (gesture.lr_count_ == 1)) {
|
|
if (abs(gesture.ud_delta_) > abs(gesture.lr_delta_)) {
|
|
gesture.motion_ = DIR_UP;
|
|
} else {
|
|
gesture.motion_ = DIR_RIGHT;
|
|
}
|
|
} else if ((gesture.ud_count_ == 1) && (gesture.lr_count_ == -1)) {
|
|
if (abs(gesture.ud_delta_) > abs(gesture.lr_delta_)) {
|
|
gesture.motion_ = DIR_DOWN;
|
|
} else {
|
|
gesture.motion_ = DIR_LEFT;
|
|
}
|
|
} else if ((gesture.ud_count_ == -1) && (gesture.lr_count_ == -1)) {
|
|
if (abs(gesture.ud_delta_) > abs(gesture.lr_delta_)) {
|
|
gesture.motion_ = DIR_UP;
|
|
} else {
|
|
gesture.motion_ = DIR_LEFT;
|
|
}
|
|
} else if ((gesture.ud_count_ == 1) && (gesture.lr_count_ == 1)) {
|
|
if (abs(gesture.ud_delta_) > abs(gesture.lr_delta_)) {
|
|
gesture.motion_ = DIR_DOWN;
|
|
} else {
|
|
gesture.motion_ = DIR_RIGHT;
|
|
}
|
|
} else {
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
void handleGesture(void) {
|
|
if (isGestureAvailable()) {
|
|
switch (readGesture()) {
|
|
case DIR_UP:
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_UP);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_UP);
|
|
break;
|
|
case DIR_DOWN:
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_DOWN);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_DOWN);
|
|
break;
|
|
case DIR_LEFT:
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_LEFT);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_LEFT);
|
|
break;
|
|
case DIR_RIGHT:
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_RIGHT);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_RIGHT);
|
|
break;
|
|
default:
|
|
if (APDS9960_overload) {
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_LONG);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_LONG);
|
|
} else {
|
|
AddLog(LOG_LEVEL_DEBUG, GESTURE_NONE);
|
|
snprintf_P(currentGesture, sizeof(currentGesture), GESTURE_NONE);
|
|
}
|
|
break;
|
|
}
|
|
MqttPublishSensor();
|
|
}
|
|
currentGesture[0] = '\0';
|
|
}
|
|
|
|
void APDS9960_loop(void) {
|
|
if (recovery_loop_counter > 0) {
|
|
recovery_loop_counter -= 1;
|
|
}
|
|
|
|
if (recovery_loop_counter == 1 && APDS9960_overload) { // restart sensor just before the end of recovery from long press
|
|
enableGestureSensor();
|
|
APDS9960_overload = false;
|
|
Response_P(PSTR("{\"Gesture\":\"On\"}"));
|
|
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, APDS9960_TAG); // only after the long break we report, that we are online again
|
|
gesture_mode = 1;
|
|
}
|
|
|
|
if (gesture_mode) {
|
|
if (recovery_loop_counter == 0) {
|
|
handleGesture();
|
|
|
|
if (APDS9960_overload) {
|
|
disableGestureSensor();
|
|
recovery_loop_counter = APDS9960_LONG_RECOVERY; // long pause after overload/long press - number of stateloops
|
|
Response_P(PSTR("{\"Gesture\":\"Off\"}"));
|
|
MqttPublishPrefixTopicRulesProcess_P(RESULT_OR_TELE, APDS9960_TAG);
|
|
gesture_mode = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
void APDS9960_detect(void) {
|
|
if (APDS9960_type || !I2cSetDevice(APDS9960_I2C_ADDR)) { return; }
|
|
|
|
APDS9960_type = I2cRead8(APDS9960_I2C_ADDR, APDS9960_ID);
|
|
|
|
#ifdef USE_DEBUG_DRIVER
|
|
// Debug new chip
|
|
AddLog(LOG_LEVEL_DEBUG, PSTR("DRV: %s Chip %X"), APDS9960_TAG, APDS9960_type);
|
|
#endif // USE_DEBUG_DRIVER
|
|
|
|
if (APDS9960_type == APDS9960_CHIPID_1 || APDS9960_type == APDS9960_CHIPID_2 || APDS9960_type == APDS9960_CHIPID_3) {
|
|
if (APDS9960_init()) {
|
|
I2cSetActiveFound(APDS9960_I2C_ADDR, APDS9960_TAG);
|
|
|
|
enableProximitySensor();
|
|
|
|
#if defined(USE_APDS9960_GESTURE) && USE_APDS9960_STARTMODE == APDS9960_MODE_GESTURE
|
|
gesture_mode = 1;
|
|
enableGestureSensor();
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
#if ( defined(USE_APDS9960_COLOR) || defined(USE_APDS9960_PROXIMITY) ) && USE_APDS9960_STARTMODE == APDS9960_MODE_COLOR
|
|
gesture_mode = 0;
|
|
enableLightSensor();
|
|
APDS9960_overload = false;
|
|
#endif // USE_APDS9960_GESTURE
|
|
} else {
|
|
APDS9960_type = 0;
|
|
}
|
|
} else {
|
|
APDS9960_type = 0;
|
|
}
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
currentGesture[0] = '\0';
|
|
#endif // USE_APDS9960_GESTURE
|
|
}
|
|
|
|
/*********************************************************************************************\
|
|
* Presentation
|
|
\*********************************************************************************************/
|
|
|
|
void APDS9960_show(bool json) {
|
|
if (!APDS9960_type) { return; }
|
|
|
|
if (!gesture_mode && !APDS9960_overload) {
|
|
|
|
#if defined(USE_APDS9960_COLOR) || defined(USE_APDS9960_PROXIMITY)
|
|
uint16_t ambient;
|
|
|
|
readAllColorAndProximityData();
|
|
ambient = color_data.a/4;
|
|
|
|
/* disableLightSensor();
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ATIME, DEFAULT_ATIME); // reset to default
|
|
enableLightSensor();*/
|
|
|
|
#ifdef USE_APDS9960_COLOR
|
|
calculateColorTemperature(); // and calculate Lux
|
|
#endif // USE_APDS9960_COLOR
|
|
if (json) {
|
|
#if defined(USE_APDS9960_COLOR) && defined(USE_APDS9960_PROXIMITY)
|
|
ResponseAppend_P(PSTR(",\"%s\":{\"Red\":%u,\"Green\":%u,\"Blue\":%u,\"" D_JSON_ILLUMINANCE "\":%u,\"CCT\":%u,\"Proximity\":%u}"),
|
|
APDS9960_TAG,
|
|
color_data.r,
|
|
color_data.g,
|
|
color_data.b,
|
|
ambient,
|
|
color_data.cct,
|
|
color_data.p);
|
|
#else
|
|
|
|
#ifdef USE_APDS9960_COLOR
|
|
ResponseAppend_P(PSTR(",\"%s\":{\"Red\":%u,\"Green\":%u,\"Blue\":%u,\"" D_JSON_ILLUMINANCE "\":%u,\"CCT\":%u}"),
|
|
APDS9960_TAG,
|
|
color_data.r,
|
|
color_data.g,
|
|
color_data.b,
|
|
ambient,
|
|
color_data.cct);
|
|
#endif // USE_APDS9960_COLOR
|
|
|
|
#ifdef USE_APDS9960_PROXIMITY
|
|
ResponseAppend_P(PSTR(",\"%s\":{\"Proximity\":%u}"),
|
|
APDS9960_TAG,
|
|
color_data.p);
|
|
#endif // USE_APDS9960_PROXIMITY
|
|
|
|
#endif // USE_APDS9960_COLOR && USE_APDS9960_PROXIMITY
|
|
#ifdef USE_WEBSERVER
|
|
} else {
|
|
|
|
#ifdef USE_APDS9960_COLOR
|
|
WSContentSend_PD(HTTP_SNS_COLOR_RED, APDS9960_TAG, color_data.r);
|
|
WSContentSend_PD(HTTP_SNS_COLOR_GREEN, APDS9960_TAG, color_data.g);
|
|
WSContentSend_PD(HTTP_SNS_COLOR_BLUE, APDS9960_TAG, color_data.b);
|
|
WSContentSend_PD(HTTP_SNS_ILLUMINANCE, APDS9960_TAG, ambient);
|
|
WSContentSend_PD(HTTP_SNS_CCT, APDS9960_TAG, color_data.cct);
|
|
#endif // USE_APDS9960_COLOR
|
|
|
|
#ifdef USE_APDS9960_PROXIMITY
|
|
WSContentSend_PD(HTTP_SNS_PROXIMITY, APDS9960_TAG, color_data.p);
|
|
#endif // USE_APDS9960_PROXIMITY
|
|
|
|
#endif // USE_WEBSERVER
|
|
}
|
|
#endif // USE_APDS9960_COLOR || USE_APDS9960_PROXIMITY
|
|
|
|
#ifdef USE_APDS9960_GESTURE
|
|
} else {
|
|
if (currentGesture[0] != '\0') {
|
|
if (json) {
|
|
ResponseAppend_P(PSTR(",\"%s\":{\"%s\":1}"), APDS9960_TAG, currentGesture);
|
|
#ifdef USE_WEBSERVER
|
|
} else {
|
|
WSContentSend_PD(HTTP_SNS_GESTURE, APDS9960_TAG, currentGesture);
|
|
#endif // USE_WEBSERVER
|
|
currentGesture[0] = '\0';
|
|
}
|
|
}
|
|
#endif // USE_APDS9960_GESTURE
|
|
|
|
}
|
|
}
|
|
|
|
/*********************************************************************************************\
|
|
* Command Sensor27
|
|
*
|
|
* Command | Payload | Description
|
|
* ---------|---------|--------------------------
|
|
* Sensor27 | | Show current gesture mode
|
|
* Sensor27 | 0 / Off | Disable gesture mode
|
|
* Sensor27 | 1 / On | Enable gesture mode
|
|
* Sensor27 | 2 / On | Enable gesture mode with half gain
|
|
\*********************************************************************************************/
|
|
|
|
bool APDS9960CommandSensor(void) {
|
|
bool serviced = true;
|
|
|
|
switch (XdrvMailbox.payload) {
|
|
case 0: // Off
|
|
#ifdef USE_APDS9960_GESTURE
|
|
disableGestureSensor();
|
|
#endif // USE_APDS9960_GESTURE
|
|
gesture_mode = 0;
|
|
enableLightSensor();
|
|
APDS9960_overload = false; // prevent unwanted re-enabling
|
|
break;
|
|
#ifdef USE_APDS9960_GESTURE
|
|
case 1: // On with default gain of 4x
|
|
if (APDS9960_type) {
|
|
setGestureGain(DEFAULT_GGAIN);
|
|
setProximityGain(DEFAULT_PGAIN);
|
|
disableLightSensor();
|
|
enableGestureSensor();
|
|
gesture_mode = 1;
|
|
}
|
|
break;
|
|
case 2: // gain of 2x , needed for some models
|
|
if (APDS9960_type) {
|
|
setGestureGain(GGAIN_2X);
|
|
setProximityGain(PGAIN_2X);
|
|
disableLightSensor();
|
|
enableGestureSensor();
|
|
gesture_mode = 1;
|
|
}
|
|
break;
|
|
#endif // USE_APDS9960_GESTURE
|
|
default:
|
|
int temp_aTime = (uint8_t)XdrvMailbox.payload;
|
|
if (temp_aTime > 2 && temp_aTime < 256) {
|
|
disablePower();
|
|
I2cWrite8(APDS9960_I2C_ADDR, APDS9960_ATIME, temp_aTime);
|
|
enablePower();
|
|
enableLightSensor();
|
|
}
|
|
break;
|
|
}
|
|
Response_P(S_JSON_SENSOR_INDEX_SVALUE, XSNS_27, GetStateText(gesture_mode));
|
|
|
|
return serviced;
|
|
}
|
|
|
|
/*********************************************************************************************\
|
|
* Interface
|
|
\*********************************************************************************************/
|
|
|
|
bool Xsns27(uint32_t function) {
|
|
if (!I2cEnabled(XI2C_21)) { return false; }
|
|
|
|
bool result = false;
|
|
|
|
if (FUNC_INIT == function) {
|
|
APDS9960_detect();
|
|
} else if (APDS9960_type) {
|
|
switch (function) {
|
|
#ifdef USE_APDS9960_GESTURE
|
|
case FUNC_EVERY_50_MSECOND:
|
|
APDS9960_loop();
|
|
break;
|
|
#endif // USE_APDS9960_GESTURE
|
|
case FUNC_COMMAND_SENSOR:
|
|
if (XSNS_27 == XdrvMailbox.index) {
|
|
result = APDS9960CommandSensor();
|
|
}
|
|
break;
|
|
case FUNC_JSON_APPEND:
|
|
APDS9960_show(1);
|
|
break;
|
|
#ifdef USE_WEBSERVER
|
|
case FUNC_WEB_SENSOR:
|
|
APDS9960_show(0);
|
|
break;
|
|
#endif // USE_WEBSERVER
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#endif // USE_APDS9960
|
|
#endif // USE_I2C
|