Roqyun KO / Mbed 2 deprecated MeringueCitron

Important changes to repositories hosted on mbed.com

Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.

To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.

It is also possible to export all your personal repositories from the account settings page.

Dependencies:   mbed DHT

glibr.cpp@1:cfad3d67ca16, 2019-01-07 (annotated)

Committer:
certvert
Date:
Mon Jan 07 11:04:21 2019 +0000
Revision:
1:cfad3d67ca16
Parent:
0:091e1a699d64 
The final version of Polytech EISE4 industrial project, Meringue Citron.; ; Adafruit screen 128x64 - i2c programmed, finite state machine, etc

Who changed what in which revision?

UserRevisionLine numberNew contents of line
certvert 0:091e1a699d64 1 #include "glibr.h"
certvert 0:091e1a699d64 2 #include "mbed.h"
certvert 0:091e1a699d64 3
certvert 0:091e1a699d64 4
certvert 0:091e1a699d64 5 extern Serial pc;
certvert 0:091e1a699d64 6 extern I2C i2c;
certvert 0:091e1a699d64 7
certvert 0:091e1a699d64 8 glibr::glibr()
certvert 0:091e1a699d64 9 {
certvert 0:091e1a699d64 10 gesture_ud_delta_ = 0;
certvert 0:091e1a699d64 11 gesture_lr_delta_ = 0;
certvert 0:091e1a699d64 12
certvert 0:091e1a699d64 13 gesture_ud_count_ = 0;
certvert 0:091e1a699d64 14 gesture_lr_count_ = 0;
certvert 0:091e1a699d64 15
certvert 0:091e1a699d64 16 gesture_near_count_ = 0;
certvert 0:091e1a699d64 17 gesture_far_count_ = 0;
certvert 0:091e1a699d64 18
certvert 0:091e1a699d64 19 gesture_state_ = 0;
certvert 0:091e1a699d64 20 gesture_motion_ = DIR_NONE;
certvert 0:091e1a699d64 21 }
certvert 0:091e1a699d64 22
certvert 0:091e1a699d64 23 glibr::~glibr(){
certvert 0:091e1a699d64 24
certvert 0:091e1a699d64 25 }
certvert 0:091e1a699d64 26
certvert 0:091e1a699d64 27 bool glibr::ginit(){
certvert 0:091e1a699d64 28 uint8_t id;
certvert 0:091e1a699d64 29
certvert 0:091e1a699d64 30 id=I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ID);
certvert 0:091e1a699d64 31
certvert 0:091e1a699d64 32 if( (!(id == APDS9960_ID_1 || id == APDS9960_ID_2))||id==ERROR) {
certvert 0:091e1a699d64 33 return false;
certvert 0:091e1a699d64 34 }
certvert 0:091e1a699d64 35
certvert 0:091e1a699d64 36 if(!setMode(ALL, OFF)) {
certvert 0:091e1a699d64 37 return false;
certvert 0:091e1a699d64 38 }
certvert 0:091e1a699d64 39 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_ATIME, DEFAULT_ATIME)){
certvert 0:091e1a699d64 40 return false;
certvert 0:091e1a699d64 41 }
certvert 0:091e1a699d64 42 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_WTIME, DEFAULT_WTIME)){
certvert 0:091e1a699d64 43 return false;
certvert 0:091e1a699d64 44 }
certvert 0:091e1a699d64 45 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PPULSE, DEFAULT_PROX_PPULSE)){
certvert 0:091e1a699d64 46 return false;
certvert 0:091e1a699d64 47 }
certvert 0:091e1a699d64 48 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_POFFSET_UR, DEFAULT_POFFSET_UR)){
certvert 0:091e1a699d64 49 return false;
certvert 0:091e1a699d64 50 }
certvert 0:091e1a699d64 51 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_POFFSET_DL, DEFAULT_POFFSET_DL)){
certvert 0:091e1a699d64 52 return false;
certvert 0:091e1a699d64 53 }
certvert 0:091e1a699d64 54 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONFIG1, DEFAULT_CONFIG1)){
certvert 0:091e1a699d64 55 return false;
certvert 0:091e1a699d64 56 }
certvert 0:091e1a699d64 57
certvert 0:091e1a699d64 58 if( !setLEDDrive(DEFAULT_LDRIVE) ) {
certvert 0:091e1a699d64 59 return false;
certvert 0:091e1a699d64 60 }
certvert 0:091e1a699d64 61
certvert 0:091e1a699d64 62 if( !setProximityGain(DEFAULT_PGAIN) ) {
certvert 0:091e1a699d64 63 return false;
certvert 0:091e1a699d64 64 }
certvert 0:091e1a699d64 65 if( !setAmbientLightGain(DEFAULT_AGAIN) ) {
certvert 0:091e1a699d64 66 return false;
certvert 0:091e1a699d64 67 }
certvert 0:091e1a699d64 68 if( !setProxIntLowThresh(DEFAULT_PILT) ) {
certvert 0:091e1a699d64 69 return false;
certvert 0:091e1a699d64 70 }
certvert 0:091e1a699d64 71 if( !setProxIntHighThresh(DEFAULT_PIHT) ) {
certvert 0:091e1a699d64 72 return false;
certvert 0:091e1a699d64 73 }
certvert 0:091e1a699d64 74 if( !setLightIntLowThreshold(DEFAULT_AILT) ) {
certvert 0:091e1a699d64 75 return false;
certvert 0:091e1a699d64 76 }
certvert 0:091e1a699d64 77 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONFIG2, DEFAULT_CONFIG2) ) {
certvert 0:091e1a699d64 78 return false;
certvert 0:091e1a699d64 79 }
certvert 0:091e1a699d64 80 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONFIG3, DEFAULT_CONFIG3) ) {
certvert 0:091e1a699d64 81 return false;
certvert 0:091e1a699d64 82 }
certvert 0:091e1a699d64 83
certvert 0:091e1a699d64 84 if( !setGestureEnterThresh(DEFAULT_GPENTH) ) {
certvert 0:091e1a699d64 85 return false;
certvert 0:091e1a699d64 86 }
certvert 0:091e1a699d64 87 if( !setGestureExitThresh(DEFAULT_GEXTH) ) {
certvert 0:091e1a699d64 88 return false;
certvert 0:091e1a699d64 89 }
certvert 0:091e1a699d64 90 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GCONF1, DEFAULT_GCONF1) ) {
certvert 0:091e1a699d64 91 return false;
certvert 0:091e1a699d64 92 }
certvert 0:091e1a699d64 93 if( !setGestureGain(DEFAULT_GGAIN) ) {
certvert 0:091e1a699d64 94 return false;
certvert 0:091e1a699d64 95 }
certvert 0:091e1a699d64 96 if( !setGestureLEDDrive(DEFAULT_GLDRIVE) ) {
certvert 0:091e1a699d64 97 return false;
certvert 0:091e1a699d64 98 }
certvert 0:091e1a699d64 99 if( !setGestureWaitTime(DEFAULT_GWTIME) ) {
certvert 0:091e1a699d64 100 return false;
certvert 0:091e1a699d64 101 }
certvert 0:091e1a699d64 102 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GOFFSET_U, DEFAULT_GOFFSET) ) {
certvert 0:091e1a699d64 103 return false;
certvert 0:091e1a699d64 104 }
certvert 0:091e1a699d64 105 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GOFFSET_D, DEFAULT_GOFFSET) ) {
certvert 0:091e1a699d64 106 return false;
certvert 0:091e1a699d64 107 }
certvert 0:091e1a699d64 108 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GOFFSET_L, DEFAULT_GOFFSET) ) {
certvert 0:091e1a699d64 109 return false;
certvert 0:091e1a699d64 110 }
certvert 0:091e1a699d64 111 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GOFFSET_R, DEFAULT_GOFFSET) ) {
certvert 0:091e1a699d64 112 return false;
certvert 0:091e1a699d64 113 }
certvert 0:091e1a699d64 114 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GPULSE, DEFAULT_GPULSE) ) {
certvert 0:091e1a699d64 115 return false;
certvert 0:091e1a699d64 116 }
certvert 0:091e1a699d64 117 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GCONF3, DEFAULT_GCONF3) ) {
certvert 0:091e1a699d64 118 return false;
certvert 0:091e1a699d64 119 }
certvert 0:091e1a699d64 120 if( !setGestureIntEnable(DEFAULT_GIEN) ) {
certvert 0:091e1a699d64 121 return false;
certvert 0:091e1a699d64 122 }
certvert 0:091e1a699d64 123
certvert 0:091e1a699d64 124 return true;
certvert 0:091e1a699d64 125
certvert 0:091e1a699d64 126 }
certvert 0:091e1a699d64 127
certvert 0:091e1a699d64 128 //#if 0
certvert 0:091e1a699d64 129 // /* Gesture config register dump */
certvert 0:091e1a699d64 130 // uint8_t reg;
certvert 0:091e1a699d64 131 // uint8_t val;
certvert 0:091e1a699d64 132 //
certvert 0:091e1a699d64 133 // for(reg = 0x80; reg <= 0xAF; reg++) {
certvert 0:091e1a699d64 134 // if( (reg != 0x82) && \
certvert 0:091e1a699d64 135 // (reg != 0x8A) && \
certvert 0:091e1a699d64 136 // (reg != 0x91) && \
certvert 0:091e1a699d64 137 // (reg != 0xA8) && \
certvert 0:091e1a699d64 138 // (reg != 0xAC) && \
certvert 0:091e1a699d64 139 // (reg != 0xAD) )
certvert 0:091e1a699d64 140 // {
certvert 0:091e1a699d64 141 // val= I2CreadByte(APDS9960_I2C_ADDR, reg);
certvert 0:091e1a699d64 142 // if(val==ERROR){
certvert 0:091e1a699d64 143 // printf("ERROR");
certvert 0:091e1a699d64 144 // }
certvert 0:091e1a699d64 145 // /*
certvert 0:091e1a699d64 146 // print(reg, HEX);
certvert 0:091e1a699d64 147 // print(": 0x");
certvert 0:091e1a699d64 148 // println(val, HEX);*/
certvert 0:091e1a699d64 149 // }
certvert 0:091e1a699d64 150 // }
certvert 0:091e1a699d64 151 //
certvert 0:091e1a699d64 152 // for(reg = 0xE4; reg <= 0xE7; reg++) {
certvert 0:091e1a699d64 153 // val= I2CreadByte(APDS9960_I2C_ADDR, reg);
certvert 0:091e1a699d64 154 // /* Serial.print(reg, HEX);
certvert 0:091e1a699d64 155 // Serial.print(": 0x");
certvert 0:091e1a699d64 156 // Serial.println(val, HEX);*/
certvert 0:091e1a699d64 157 // }
certvert 0:091e1a699d64 158 //#endif
certvert 0:091e1a699d64 159
certvert 0:091e1a699d64 160 // return true;
certvert 0:091e1a699d64 161
certvert 0:091e1a699d64 162
certvert 0:091e1a699d64 163
certvert 0:091e1a699d64 164
certvert 0:091e1a699d64 165 /**
certvert 0:091e1a699d64 166 * @brief Enables or disables a feature in the APDS-9960
certvert 0:091e1a699d64 167 *
certvert 0:091e1a699d64 168 * @param[in] mode which feature to enable
certvert 0:091e1a699d64 169 * @param[in] enable ON (1) or OFF (0)
certvert 0:091e1a699d64 170 * @return True if operation success. False otherwise.
certvert 0:091e1a699d64 171 */
certvert 0:091e1a699d64 172 bool glibr::setMode(uint8_t mode, uint8_t enable)
certvert 0:091e1a699d64 173 {
certvert 0:091e1a699d64 174 uint8_t reg_val;
certvert 0:091e1a699d64 175
certvert 0:091e1a699d64 176 /* Read current ENABLE register */
certvert 0:091e1a699d64 177 reg_val = getMode();
certvert 0:091e1a699d64 178 if( reg_val == ERROR ) {
certvert 0:091e1a699d64 179 return false;
certvert 0:091e1a699d64 180 }
certvert 0:091e1a699d64 181
certvert 0:091e1a699d64 182 /* Change bit(s) in ENABLE register */
certvert 0:091e1a699d64 183 enable = enable & 0x01;
certvert 0:091e1a699d64 184 if( mode >= 0 && mode <= 6 ) {
certvert 0:091e1a699d64 185 if (enable) {
certvert 0:091e1a699d64 186 reg_val |= (1 << mode);
certvert 0:091e1a699d64 187 } else {
certvert 0:091e1a699d64 188 reg_val &= ~(1 << mode);
certvert 0:091e1a699d64 189 }
certvert 0:091e1a699d64 190 } else if( mode == ALL ) {
certvert 0:091e1a699d64 191 if (enable) {
certvert 0:091e1a699d64 192 reg_val = 0x7F;
certvert 0:091e1a699d64 193 } else {
certvert 0:091e1a699d64 194 reg_val = 0x00;
certvert 0:091e1a699d64 195 }
certvert 0:091e1a699d64 196 }
certvert 0:091e1a699d64 197
certvert 0:091e1a699d64 198 /* Write value back to ENABLE register */
certvert 0:091e1a699d64 199 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_ENABLE, reg_val)){
certvert 0:091e1a699d64 200 return false;
certvert 0:091e1a699d64 201 }
certvert 0:091e1a699d64 202
certvert 0:091e1a699d64 203
certvert 0:091e1a699d64 204
certvert 0:091e1a699d64 205 return true;
certvert 0:091e1a699d64 206 }
certvert 0:091e1a699d64 207
certvert 0:091e1a699d64 208 uint8_t glibr::getMode()
certvert 0:091e1a699d64 209 {
certvert 0:091e1a699d64 210 uint8_t val;
certvert 0:091e1a699d64 211 val= I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ENABLE);
certvert 0:091e1a699d64 212 if(val==ERROR){
certvert 0:091e1a699d64 213 return ERROR;
certvert 0:091e1a699d64 214 }
certvert 0:091e1a699d64 215 return val;
certvert 0:091e1a699d64 216 }
certvert 0:091e1a699d64 217
certvert 0:091e1a699d64 218
certvert 0:091e1a699d64 219
certvert 0:091e1a699d64 220 bool glibr::enableLightSensor(bool interrupts)
certvert 0:091e1a699d64 221 {
certvert 0:091e1a699d64 222
certvert 0:091e1a699d64 223 /* Set default gain, interrupts, enable power, and enable sensor */
certvert 0:091e1a699d64 224 if( !setAmbientLightGain(DEFAULT_AGAIN) ) {
certvert 0:091e1a699d64 225 return false;
certvert 0:091e1a699d64 226 }
certvert 0:091e1a699d64 227 if( interrupts ) {
certvert 0:091e1a699d64 228 if( !setAmbientLightIntEnable(1) ) {
certvert 0:091e1a699d64 229 return false;
certvert 0:091e1a699d64 230 }
certvert 0:091e1a699d64 231 } else {
certvert 0:091e1a699d64 232 if( !setAmbientLightIntEnable(0) ) {
certvert 0:091e1a699d64 233 return false;
certvert 0:091e1a699d64 234 }
certvert 0:091e1a699d64 235 }
certvert 0:091e1a699d64 236 if( !enablePower() ){
certvert 0:091e1a699d64 237 return false;
certvert 0:091e1a699d64 238 }
certvert 0:091e1a699d64 239 if( !setMode(AMBIENT_LIGHT, 1) ) {
certvert 0:091e1a699d64 240 return false;
certvert 0:091e1a699d64 241 }
certvert 0:091e1a699d64 242
certvert 0:091e1a699d64 243 return true;
certvert 0:091e1a699d64 244
certvert 0:091e1a699d64 245 }
certvert 0:091e1a699d64 246
certvert 0:091e1a699d64 247 /**
certvert 0:091e1a699d64 248 * @brief Ends the light sensor on the APDS-9960
certvert 0:091e1a699d64 249 *
certvert 0:091e1a699d64 250 * @return True if sensor disabled correctly. False on error.
certvert 0:091e1a699d64 251 */
certvert 0:091e1a699d64 252 bool glibr::disableLightSensor()
certvert 0:091e1a699d64 253 {
certvert 0:091e1a699d64 254 if( !setAmbientLightIntEnable(0) ) {
certvert 0:091e1a699d64 255 return false;
certvert 0:091e1a699d64 256 }
certvert 0:091e1a699d64 257 if( !setMode(AMBIENT_LIGHT, 0) ) {
certvert 0:091e1a699d64 258 return false;
certvert 0:091e1a699d64 259 }
certvert 0:091e1a699d64 260
certvert 0:091e1a699d64 261 return true;
certvert 0:091e1a699d64 262 }
certvert 0:091e1a699d64 263
certvert 0:091e1a699d64 264 /**
certvert 0:091e1a699d64 265 * @brief Starts the proximity sensor on the APDS-9960
certvert 0:091e1a699d64 266 *
certvert 0:091e1a699d64 267 * @param[in] interrupts true to enable hardware external interrupt on proximity
certvert 0:091e1a699d64 268 * @return True if sensor enabled correctly. False on error.
certvert 0:091e1a699d64 269 */
certvert 0:091e1a699d64 270 bool glibr::enableProximitySensor(bool interrupts)
certvert 0:091e1a699d64 271 {
certvert 0:091e1a699d64 272 /* Set default gain, LED, interrupts, enable power, and enable sensor */
certvert 0:091e1a699d64 273 if( !setProximityGain(DEFAULT_PGAIN) ) {
certvert 0:091e1a699d64 274 return false;
certvert 0:091e1a699d64 275 }
certvert 0:091e1a699d64 276 if( !setLEDDrive(DEFAULT_LDRIVE) ) {
certvert 0:091e1a699d64 277 return false;
certvert 0:091e1a699d64 278 }
certvert 0:091e1a699d64 279 if( interrupts ) {
certvert 0:091e1a699d64 280 if( !setProximityIntEnable(1) ) {
certvert 0:091e1a699d64 281 return false;
certvert 0:091e1a699d64 282 }
certvert 0:091e1a699d64 283 } else {
certvert 0:091e1a699d64 284 if( !setProximityIntEnable(0) ) {
certvert 0:091e1a699d64 285 return false;
certvert 0:091e1a699d64 286 }
certvert 0:091e1a699d64 287 }
certvert 0:091e1a699d64 288 if( !enablePower() ){
certvert 0:091e1a699d64 289 return false;
certvert 0:091e1a699d64 290 }
certvert 0:091e1a699d64 291 if( !setMode(PROXIMITY, 1) ) {
certvert 0:091e1a699d64 292 return false;
certvert 0:091e1a699d64 293 }
certvert 0:091e1a699d64 294
certvert 0:091e1a699d64 295 return true;
certvert 0:091e1a699d64 296 }
certvert 0:091e1a699d64 297
certvert 0:091e1a699d64 298 /**
certvert 0:091e1a699d64 299 * @brief Ends the proximity sensor on the APDS-9960
certvert 0:091e1a699d64 300 *
certvert 0:091e1a699d64 301 * @return True if sensor disabled correctly. False on error.
certvert 0:091e1a699d64 302 */
certvert 0:091e1a699d64 303 bool glibr::disableProximitySensor()
certvert 0:091e1a699d64 304 {
certvert 0:091e1a699d64 305 if( !setProximityIntEnable(0) ) {
certvert 0:091e1a699d64 306 return false;
certvert 0:091e1a699d64 307 }
certvert 0:091e1a699d64 308 if( !setMode(PROXIMITY, 0) ) {
certvert 0:091e1a699d64 309 return false;
certvert 0:091e1a699d64 310 }
certvert 0:091e1a699d64 311
certvert 0:091e1a699d64 312 return true;
certvert 0:091e1a699d64 313 }
certvert 0:091e1a699d64 314
certvert 0:091e1a699d64 315
certvert 0:091e1a699d64 316 /**
certvert 0:091e1a699d64 317 * @brief Starts the gesture recognition engine on the APDS-9960
certvert 0:091e1a699d64 318 *
certvert 0:091e1a699d64 319 * @param[in] interrupts true to enable hardware external interrupt on gesture
certvert 0:091e1a699d64 320 * @return True if engine enabled correctly. False on error.
certvert 0:091e1a699d64 321 */
certvert 0:091e1a699d64 322 bool glibr::enableGestureSensor(bool interrupts)
certvert 0:091e1a699d64 323 {
certvert 0:091e1a699d64 324
certvert 0:091e1a699d64 325 /* Enable gesture mode
certvert 0:091e1a699d64 326 Set ENABLE to 0 (power off)
certvert 0:091e1a699d64 327 Set WTIME to 0xFF
certvert 0:091e1a699d64 328 Set AUX to LED_BOOST_300
certvert 0:091e1a699d64 329 Enable PON, WEN, PEN, GEN in ENABLE
certvert 0:091e1a699d64 330 */
certvert 0:091e1a699d64 331
certvert 0:091e1a699d64 332 resetGestureParameters();
certvert 0:091e1a699d64 333 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_WTIME, 0xFF) ) {
certvert 0:091e1a699d64 334 return false;
certvert 0:091e1a699d64 335 }
certvert 0:091e1a699d64 336 if(I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PPULSE, DEFAULT_GESTURE_PPULSE) ) {
certvert 0:091e1a699d64 337 return false;
certvert 0:091e1a699d64 338 }
certvert 0:091e1a699d64 339 if( !setLEDBoost(LED_BOOST_300) ) {
certvert 0:091e1a699d64 340 return false;
certvert 0:091e1a699d64 341 }
certvert 0:091e1a699d64 342 if( interrupts ) {
certvert 0:091e1a699d64 343 if( !setGestureIntEnable(1) ) {
certvert 0:091e1a699d64 344 return false;
certvert 0:091e1a699d64 345 }
certvert 0:091e1a699d64 346 } else {
certvert 0:091e1a699d64 347 if( !setGestureIntEnable(0) ) {
certvert 0:091e1a699d64 348 return false;
certvert 0:091e1a699d64 349 }
certvert 0:091e1a699d64 350 }
certvert 0:091e1a699d64 351 if( !setGestureMode(1) ) {
certvert 0:091e1a699d64 352 return false;
certvert 0:091e1a699d64 353 }
certvert 0:091e1a699d64 354 if( !enablePower() ){
certvert 0:091e1a699d64 355 return false;
certvert 0:091e1a699d64 356 }
certvert 0:091e1a699d64 357 if( !setMode(WAIT, 1) ) {
certvert 0:091e1a699d64 358 return false;
certvert 0:091e1a699d64 359 }
certvert 0:091e1a699d64 360 if( !setMode(PROXIMITY, 1) ) {
certvert 0:091e1a699d64 361 return false;
certvert 0:091e1a699d64 362 }
certvert 0:091e1a699d64 363 if( !setMode(GESTURE, 1) ) {
certvert 0:091e1a699d64 364 return false;
certvert 0:091e1a699d64 365 }
certvert 0:091e1a699d64 366
certvert 0:091e1a699d64 367 return true;
certvert 0:091e1a699d64 368 }
certvert 0:091e1a699d64 369
certvert 0:091e1a699d64 370 /**
certvert 0:091e1a699d64 371 * @brief Ends the gesture recognition engine on the APDS-9960
certvert 0:091e1a699d64 372 *
certvert 0:091e1a699d64 373 * @return True if engine disabled correctly. False on error.
certvert 0:091e1a699d64 374 */
certvert 0:091e1a699d64 375 bool glibr::disableGestureSensor()
certvert 0:091e1a699d64 376 {
certvert 0:091e1a699d64 377 resetGestureParameters();
certvert 0:091e1a699d64 378 if( !setGestureIntEnable(0) ) {
certvert 0:091e1a699d64 379 return false;
certvert 0:091e1a699d64 380 }
certvert 0:091e1a699d64 381 if( !setGestureMode(0) ) {
certvert 0:091e1a699d64 382 return false;
certvert 0:091e1a699d64 383 }
certvert 0:091e1a699d64 384 if( !setMode(GESTURE, 0) ) {
certvert 0:091e1a699d64 385 return false;
certvert 0:091e1a699d64 386 }
certvert 0:091e1a699d64 387
certvert 0:091e1a699d64 388 return true;
certvert 0:091e1a699d64 389 }
certvert 0:091e1a699d64 390
certvert 0:091e1a699d64 391
certvert 0:091e1a699d64 392 /**
certvert 0:091e1a699d64 393 * @brief Determines if there is a gesture available for reading
certvert 0:091e1a699d64 394 *
certvert 0:091e1a699d64 395 * @return True if gesture available. False otherwise.
certvert 0:091e1a699d64 396 */
certvert 0:091e1a699d64 397 bool glibr::isGestureAvailable()
certvert 0:091e1a699d64 398 {
certvert 0:091e1a699d64 399 uint8_t val;
certvert 0:091e1a699d64 400
certvert 0:091e1a699d64 401 /* Read value from GSTATUS register */
certvert 0:091e1a699d64 402 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_GSTATUS);
certvert 0:091e1a699d64 403 if( val==ERROR) {
certvert 0:091e1a699d64 404 return ERROR;
certvert 0:091e1a699d64 405 }
certvert 0:091e1a699d64 406
certvert 0:091e1a699d64 407 /* Shift and mask out GVALID bit */
certvert 0:091e1a699d64 408 val &= APDS9960_GVALID;
certvert 0:091e1a699d64 409
certvert 0:091e1a699d64 410 /* Return true/false based on GVALID bit */
certvert 0:091e1a699d64 411 if( val == 1) {
certvert 0:091e1a699d64 412 return true;
certvert 0:091e1a699d64 413 } else {
certvert 0:091e1a699d64 414 return false;
certvert 0:091e1a699d64 415 }
certvert 0:091e1a699d64 416 }
certvert 0:091e1a699d64 417
certvert 0:091e1a699d64 418 int glibr::readGesture()
certvert 0:091e1a699d64 419 {
certvert 0:091e1a699d64 420 uint8_t fifo_level = 0;
certvert 0:091e1a699d64 421 // uint8_t bytes_expected= 0;
certvert 0:091e1a699d64 422 int check;
certvert 0:091e1a699d64 423 //char fifo_data[128];
certvert 0:091e1a699d64 424 char fifo_data[128];
certvert 0:091e1a699d64 425 char *fptr;
certvert 0:091e1a699d64 426 fptr= fifo_data;
certvert 0:091e1a699d64 427
certvert 0:091e1a699d64 428 uint8_t gstatus;
certvert 0:091e1a699d64 429 int motion;
certvert 0:091e1a699d64 430 int i;
certvert 0:091e1a699d64 431
certvert 0:091e1a699d64 432 /* Make sure that power and gesture is on and data is valid */
certvert 0:091e1a699d64 433 if( !isGestureAvailable() || !(getMode() & 0x41) ) {
certvert 0:091e1a699d64 434 return DIR_NONE;
certvert 0:091e1a699d64 435 }
certvert 0:091e1a699d64 436
certvert 0:091e1a699d64 437
certvert 0:091e1a699d64 438 /* Keep looping as long as gesture data is valid */
certvert 0:091e1a699d64 439 while(1) {
certvert 0:091e1a699d64 440
certvert 0:091e1a699d64 441 /* Wait some time to collect next batch of FIFO data */
certvert 0:091e1a699d64 442 wait(FIFO_PAUSE_TIME);
certvert 0:091e1a699d64 443
certvert 0:091e1a699d64 444 /* Get the contents of the STATUS register. Is data still valid? */
certvert 0:091e1a699d64 445
certvert 0:091e1a699d64 446 gstatus=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_GSTATUS);
certvert 0:091e1a699d64 447 if( gstatus==ERROR ) {
certvert 0:091e1a699d64 448 return ERROR;
certvert 0:091e1a699d64 449 }
certvert 0:091e1a699d64 450 /* If we have valid data, read in FIFO */
certvert 0:091e1a699d64 451 if( (gstatus & APDS9960_GVALID) == APDS9960_GVALID ) {
certvert 0:091e1a699d64 452
certvert 0:091e1a699d64 453 /* Read the current FIFO level */
certvert 0:091e1a699d64 454 fifo_level=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_GFLVL);
certvert 0:091e1a699d64 455 if( fifo_level==ERROR ) {
certvert 0:091e1a699d64 456 return ERROR;
certvert 0:091e1a699d64 457 }
certvert 0:091e1a699d64 458
certvert 0:091e1a699d64 459 //#if DEBUG
certvert 0:091e1a699d64 460 // Serial.print("FIFO Level: ");
certvert 0:091e1a699d64 461 // Serial.println(fifo_level);
certvert 0:091e1a699d64 462 //#endif
certvert 0:091e1a699d64 463
certvert 0:091e1a699d64 464 /* If there's stuff in the FIFO, read it into our data block */ //NEED TO FIGURE OUT WHAT THIS IS DOING.
certvert 0:091e1a699d64 465
certvert 0:091e1a699d64 466 if( fifo_level > 0) {
certvert 0:091e1a699d64 467 check = I2CReadDataBlock(APDS9960_I2C_ADDR,APDS9960_GFIFO_U,
certvert 0:091e1a699d64 468 fptr,
certvert 0:091e1a699d64 469 (fifo_level * 4) );
certvert 0:091e1a699d64 470
certvert 0:091e1a699d64 471 if( check == -1 ) {
certvert 0:091e1a699d64 472 return ERROR;
certvert 0:091e1a699d64 473 }
certvert 0:091e1a699d64 474
certvert 0:091e1a699d64 475 #if DEBUG
certvert 0:091e1a699d64 476 //Serial.print("FIFO Dump: ");
certvert 0:091e1a699d64 477 for ( i = 0; i < (fifo_level * 4); i++ ) {
certvert 0:091e1a699d64 478 // Serial.print(fifo_data[i]);
certvert 0:091e1a699d64 479 // Serial.print(" ");
certvert 0:091e1a699d64 480 }
certvert 0:091e1a699d64 481 //Serial.println();
certvert 0:091e1a699d64 482 #endif
certvert 0:091e1a699d64 483
certvert 0:091e1a699d64 484 /* If at least 1 set of data, sort the data into U/D/L/R */
certvert 0:091e1a699d64 485 if((fifo_level * 4) >= 4 ) {
certvert 0:091e1a699d64 486 for( i = 0; i < (fifo_level * 4); i += 4 ) {
certvert 0:091e1a699d64 487 gesture_data_.u_data[gesture_data_.sindex] = \
certvert 0:091e1a699d64 488 fifo_data[i + 0];
certvert 0:091e1a699d64 489 gesture_data_.d_data[gesture_data_.sindex] = \
certvert 0:091e1a699d64 490 fifo_data[i + 1];
certvert 0:091e1a699d64 491 gesture_data_.l_data[gesture_data_.sindex] = \
certvert 0:091e1a699d64 492 fifo_data[i + 2];
certvert 0:091e1a699d64 493 gesture_data_.r_data[gesture_data_.sindex] = \
certvert 0:091e1a699d64 494 fifo_data[i + 3];
certvert 0:091e1a699d64 495 gesture_data_.sindex++;
certvert 0:091e1a699d64 496 gesture_data_.total_gestures++;
certvert 0:091e1a699d64 497 }
certvert 0:091e1a699d64 498
certvert 0:091e1a699d64 499 #if DEBUG
certvert 0:091e1a699d64 500 // Serial.print("Up Data: ");
certvert 0:091e1a699d64 501 for ( i = 0; i < gesture_data_.total_gestures; i++ ) {
certvert 0:091e1a699d64 502 // Serial.print(gesture_data_.u_data[i]);
certvert 0:091e1a699d64 503 // Serial.print(" ");
certvert 0:091e1a699d64 504 }
certvert 0:091e1a699d64 505 // Serial.println();
certvert 0:091e1a699d64 506 #endif
certvert 0:091e1a699d64 507
certvert 0:091e1a699d64 508 /* Filter and process gesture data. Decode near/far state */
certvert 0:091e1a699d64 509 if( processGestureData() ) {
certvert 0:091e1a699d64 510 if( decodeGesture() ) {
certvert 0:091e1a699d64 511 //***TODO: U-Turn Gestures
certvert 0:091e1a699d64 512 #if DEBUG
certvert 0:091e1a699d64 513 //Serial.println(gesture_motion_);
certvert 0:091e1a699d64 514 #endif
certvert 0:091e1a699d64 515 }
certvert 0:091e1a699d64 516 }
certvert 0:091e1a699d64 517
certvert 0:091e1a699d64 518 /* Reset data */
certvert 0:091e1a699d64 519 gesture_data_.sindex = 0;
certvert 0:091e1a699d64 520 gesture_data_.total_gestures = 0;
certvert 0:091e1a699d64 521 }
certvert 0:091e1a699d64 522 }
certvert 0:091e1a699d64 523 } else {
certvert 0:091e1a699d64 524
certvert 0:091e1a699d64 525 /* Determine best guessed gesture and clean up */
certvert 0:091e1a699d64 526 wait(FIFO_PAUSE_TIME);
certvert 0:091e1a699d64 527 decodeGesture();
certvert 0:091e1a699d64 528 motion = gesture_motion_;
certvert 0:091e1a699d64 529 #if DEBUG
certvert 0:091e1a699d64 530 // Serial.print("END: ");
certvert 0:091e1a699d64 531 // Serial.println(gesture_motion_);
certvert 0:091e1a699d64 532 #endif
certvert 0:091e1a699d64 533 resetGestureParameters();
certvert 0:091e1a699d64 534 return motion;
certvert 0:091e1a699d64 535 }
certvert 0:091e1a699d64 536 }
certvert 0:091e1a699d64 537 // delete fptr;
certvert 0:091e1a699d64 538 }
certvert 0:091e1a699d64 539 /**
certvert 0:091e1a699d64 540 * Turn the APDS-9960 on
certvert 0:091e1a699d64 541 *
certvert 0:091e1a699d64 542 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 543 */
certvert 0:091e1a699d64 544 bool glibr::enablePower()
certvert 0:091e1a699d64 545 {
certvert 0:091e1a699d64 546 if( !setMode(POWER, 1) ) {
certvert 0:091e1a699d64 547 return false;
certvert 0:091e1a699d64 548 }
certvert 0:091e1a699d64 549
certvert 0:091e1a699d64 550 return true;
certvert 0:091e1a699d64 551 }
certvert 0:091e1a699d64 552
certvert 0:091e1a699d64 553 /**
certvert 0:091e1a699d64 554 * Turn the APDS-9960 off
certvert 0:091e1a699d64 555 *
certvert 0:091e1a699d64 556 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 557 */
certvert 0:091e1a699d64 558 bool glibr::disablePower()
certvert 0:091e1a699d64 559 {
certvert 0:091e1a699d64 560 if( !setMode(POWER, 0) ) {
certvert 0:091e1a699d64 561 return false;
certvert 0:091e1a699d64 562 }
certvert 0:091e1a699d64 563
certvert 0:091e1a699d64 564 return true;
certvert 0:091e1a699d64 565 }
certvert 0:091e1a699d64 566
certvert 0:091e1a699d64 567 /*******************************************************************************
certvert 0:091e1a699d64 568 * Ambient light and color sensor controls
certvert 0:091e1a699d64 569 ******************************************************************************/
certvert 0:091e1a699d64 570
certvert 0:091e1a699d64 571 /**
certvert 0:091e1a699d64 572 * @brief Reads the ambient (clear) light level as a 16-bit value
certvert 0:091e1a699d64 573 *
certvert 0:091e1a699d64 574 * @param[out] val value of the light sensor.
certvert 0:091e1a699d64 575 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 576 */
certvert 0:091e1a699d64 577 bool glibr::readAmbientLight(uint16_t* val)
certvert 0:091e1a699d64 578 {
certvert 0:091e1a699d64 579 uint8_t val_byte;
certvert 0:091e1a699d64 580 *val = 0;
certvert 0:091e1a699d64 581
certvert 0:091e1a699d64 582 /* Read value from clear channel, low byte register */
certvert 0:091e1a699d64 583 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CDATAL);
certvert 0:091e1a699d64 584 if( val_byte==ERROR) {
certvert 0:091e1a699d64 585 return false;
certvert 0:091e1a699d64 586 }
certvert 0:091e1a699d64 587 *val = val_byte;
certvert 0:091e1a699d64 588
certvert 0:091e1a699d64 589 /* Read value from clear channel, high byte register */
certvert 0:091e1a699d64 590
certvert 0:091e1a699d64 591 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CDATAH);
certvert 0:091e1a699d64 592 if( val_byte==ERROR) {
certvert 0:091e1a699d64 593 return false;
certvert 0:091e1a699d64 594 }
certvert 0:091e1a699d64 595 *val = *val + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 596
certvert 0:091e1a699d64 597 return true;
certvert 0:091e1a699d64 598 }
certvert 0:091e1a699d64 599
certvert 0:091e1a699d64 600 /**
certvert 0:091e1a699d64 601 * @brief Reads the red light level as a 16-bit value
certvert 0:091e1a699d64 602 *
certvert 0:091e1a699d64 603 * @param[out] val value of the light sensor.
certvert 0:091e1a699d64 604 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 605 */
certvert 0:091e1a699d64 606 bool glibr::readRedLight(uint16_t *val)
certvert 0:091e1a699d64 607 {
certvert 0:091e1a699d64 608 unsigned char val_byte;
certvert 0:091e1a699d64 609 *val = 0;
certvert 0:091e1a699d64 610
certvert 0:091e1a699d64 611 /* Read value from clear channel, low byte register */
certvert 0:091e1a699d64 612 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_RDATAL);
certvert 0:091e1a699d64 613 if( val_byte==ERROR) {
certvert 0:091e1a699d64 614 return false;
certvert 0:091e1a699d64 615 }
certvert 0:091e1a699d64 616
certvert 0:091e1a699d64 617 *val = val_byte;
certvert 0:091e1a699d64 618
certvert 0:091e1a699d64 619 /* Read value from clear channel, high byte register */
certvert 0:091e1a699d64 620 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_RDATAH);
certvert 0:091e1a699d64 621 if( val_byte==ERROR) {
certvert 0:091e1a699d64 622 return false;
certvert 0:091e1a699d64 623 }
certvert 0:091e1a699d64 624 *val = *val + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 625
certvert 0:091e1a699d64 626 return true;
certvert 0:091e1a699d64 627 }
certvert 0:091e1a699d64 628
certvert 0:091e1a699d64 629 /**
certvert 0:091e1a699d64 630 * @brief Reads the green light level as a 16-bit value
certvert 0:091e1a699d64 631 *
certvert 0:091e1a699d64 632 * @param[out] val value of the light sensor.
certvert 0:091e1a699d64 633 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 634 */
certvert 0:091e1a699d64 635
certvert 0:091e1a699d64 636 bool glibr::readGreenLight(uint16_t *val)
certvert 0:091e1a699d64 637 {
certvert 0:091e1a699d64 638 uint8_t val_byte;
certvert 0:091e1a699d64 639 *val = 0;
certvert 0:091e1a699d64 640
certvert 0:091e1a699d64 641 /* Read value from clear channel, low byte register */
certvert 0:091e1a699d64 642 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_GDATAL);
certvert 0:091e1a699d64 643 if( val_byte==ERROR) {
certvert 0:091e1a699d64 644 return false;
certvert 0:091e1a699d64 645 }
certvert 0:091e1a699d64 646
certvert 0:091e1a699d64 647 *val = val_byte;
certvert 0:091e1a699d64 648
certvert 0:091e1a699d64 649 /* Read value from clear channel, high byte register */
certvert 0:091e1a699d64 650 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_GDATAH);
certvert 0:091e1a699d64 651 if( val_byte==ERROR) {
certvert 0:091e1a699d64 652 return false;
certvert 0:091e1a699d64 653 }
certvert 0:091e1a699d64 654 *val = *val + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 655
certvert 0:091e1a699d64 656 return true;
certvert 0:091e1a699d64 657 }
certvert 0:091e1a699d64 658
certvert 0:091e1a699d64 659 /**
certvert 0:091e1a699d64 660 * @brief Reads the red light level as a 16-bit value
certvert 0:091e1a699d64 661 *
certvert 0:091e1a699d64 662 * @param[out] val value of the light sensor.
certvert 0:091e1a699d64 663 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 664 */
certvert 0:091e1a699d64 665
certvert 0:091e1a699d64 666 bool glibr::readBlueLight(uint16_t *val)
certvert 0:091e1a699d64 667 {
certvert 0:091e1a699d64 668 uint8_t val_byte;
certvert 0:091e1a699d64 669 *val = 0;
certvert 0:091e1a699d64 670
certvert 0:091e1a699d64 671 /* Read value from clear channel, low byte register */
certvert 0:091e1a699d64 672 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_BDATAL);
certvert 0:091e1a699d64 673 if( val_byte==ERROR) {
certvert 0:091e1a699d64 674 return false;
certvert 0:091e1a699d64 675 }
certvert 0:091e1a699d64 676
certvert 0:091e1a699d64 677 *val = val_byte;
certvert 0:091e1a699d64 678
certvert 0:091e1a699d64 679 /* Read value from clear channel, high byte register */
certvert 0:091e1a699d64 680 val_byte=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_BDATAH);
certvert 0:091e1a699d64 681 if( val_byte==ERROR) {
certvert 0:091e1a699d64 682 return false;
certvert 0:091e1a699d64 683 }
certvert 0:091e1a699d64 684 *val = *val + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 685
certvert 0:091e1a699d64 686 return true;
certvert 0:091e1a699d64 687 }
certvert 0:091e1a699d64 688
certvert 0:091e1a699d64 689 /*******************************************************************************
certvert 0:091e1a699d64 690 * Proximity sensor controls
certvert 0:091e1a699d64 691 ******************************************************************************/
certvert 0:091e1a699d64 692
certvert 0:091e1a699d64 693 /**
certvert 0:091e1a699d64 694 * @brief Reads the proximity level as an 8-bit value
certvert 0:091e1a699d64 695 *
certvert 0:091e1a699d64 696 * @param[out] val value of the proximity sensor.
certvert 0:091e1a699d64 697 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 698 */
certvert 0:091e1a699d64 699 bool glibr::readProximity(uint8_t &val)
certvert 0:091e1a699d64 700 {
certvert 0:091e1a699d64 701 val = 0;
certvert 0:091e1a699d64 702
certvert 0:091e1a699d64 703 /* Read value from proximity data register */
certvert 0:091e1a699d64 704 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_PDATA);
certvert 0:091e1a699d64 705
certvert 0:091e1a699d64 706 if(val==ERROR){
certvert 0:091e1a699d64 707 return false;
certvert 0:091e1a699d64 708 }
certvert 0:091e1a699d64 709
certvert 0:091e1a699d64 710 return true;
certvert 0:091e1a699d64 711 }
certvert 0:091e1a699d64 712
certvert 0:091e1a699d64 713 /*******************************************************************************
certvert 0:091e1a699d64 714 * High-level gesture controls
certvert 0:091e1a699d64 715 ******************************************************************************/
certvert 0:091e1a699d64 716
certvert 0:091e1a699d64 717 /**
certvert 0:091e1a699d64 718 * @brief Resets all the parameters in the gesture data member
certvert 0:091e1a699d64 719 */
certvert 0:091e1a699d64 720 void glibr::resetGestureParameters()
certvert 0:091e1a699d64 721 {
certvert 0:091e1a699d64 722 gesture_data_.sindex = 0;
certvert 0:091e1a699d64 723 gesture_data_.total_gestures = 0;
certvert 0:091e1a699d64 724
certvert 0:091e1a699d64 725 gesture_ud_delta_ = 0;
certvert 0:091e1a699d64 726 gesture_lr_delta_ = 0;
certvert 0:091e1a699d64 727
certvert 0:091e1a699d64 728 gesture_ud_count_ = 0;
certvert 0:091e1a699d64 729 gesture_lr_count_ = 0;
certvert 0:091e1a699d64 730
certvert 0:091e1a699d64 731 gesture_near_count_ = 0;
certvert 0:091e1a699d64 732 gesture_far_count_ = 0;
certvert 0:091e1a699d64 733
certvert 0:091e1a699d64 734 gesture_state_ = 0;
certvert 0:091e1a699d64 735 gesture_motion_ = DIR_NONE;
certvert 0:091e1a699d64 736 }
certvert 0:091e1a699d64 737
certvert 0:091e1a699d64 738 bool glibr::processGestureData()
certvert 0:091e1a699d64 739 {
certvert 0:091e1a699d64 740 uint8_t u_first = 0;
certvert 0:091e1a699d64 741 uint8_t d_first = 0;
certvert 0:091e1a699d64 742 uint8_t l_first = 0;
certvert 0:091e1a699d64 743 uint8_t r_first = 0;
certvert 0:091e1a699d64 744 uint8_t u_last = 0;
certvert 0:091e1a699d64 745 uint8_t d_last = 0;
certvert 0:091e1a699d64 746 uint8_t l_last = 0;
certvert 0:091e1a699d64 747 uint8_t r_last = 0;
certvert 0:091e1a699d64 748 int ud_ratio_first;
certvert 0:091e1a699d64 749 int lr_ratio_first;
certvert 0:091e1a699d64 750 int ud_ratio_last;
certvert 0:091e1a699d64 751 int lr_ratio_last;
certvert 0:091e1a699d64 752 int ud_delta;
certvert 0:091e1a699d64 753 int lr_delta;
certvert 0:091e1a699d64 754 int i;
certvert 0:091e1a699d64 755
certvert 0:091e1a699d64 756 /* If we have less than 4 total gestures, that's not enough */
certvert 0:091e1a699d64 757 if( gesture_data_.total_gestures <= 4 ) {
certvert 0:091e1a699d64 758 return false;
certvert 0:091e1a699d64 759 }
certvert 0:091e1a699d64 760
certvert 0:091e1a699d64 761 /* Check to make sure our data isn't out of bounds */
certvert 0:091e1a699d64 762 if( (gesture_data_.total_gestures <= 32) && \
certvert 0:091e1a699d64 763 (gesture_data_.total_gestures > 0) ) {
certvert 0:091e1a699d64 764
certvert 0:091e1a699d64 765 /* Find the first value in U/D/L/R above the threshold */
certvert 0:091e1a699d64 766 for( i = 0; i < gesture_data_.total_gestures; i++ ) {
certvert 0:091e1a699d64 767 if( (gesture_data_.u_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 768 (gesture_data_.d_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 769 (gesture_data_.l_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 770 (gesture_data_.r_data[i] > GESTURE_THRESHOLD_OUT) ) {
certvert 0:091e1a699d64 771
certvert 0:091e1a699d64 772 u_first = gesture_data_.u_data[i];
certvert 0:091e1a699d64 773 d_first = gesture_data_.d_data[i];
certvert 0:091e1a699d64 774 l_first = gesture_data_.l_data[i];
certvert 0:091e1a699d64 775 r_first = gesture_data_.r_data[i];
certvert 0:091e1a699d64 776 break;
certvert 0:091e1a699d64 777 }
certvert 0:091e1a699d64 778 }
certvert 0:091e1a699d64 779
certvert 0:091e1a699d64 780 /* If one of the _first values is 0, then there is no good data */
certvert 0:091e1a699d64 781 if( (u_first == 0) || (d_first == 0) || \
certvert 0:091e1a699d64 782 (l_first == 0) || (r_first == 0) ) {
certvert 0:091e1a699d64 783
certvert 0:091e1a699d64 784 return false;
certvert 0:091e1a699d64 785 }
certvert 0:091e1a699d64 786 /* Find the last value in U/D/L/R above the threshold */
certvert 0:091e1a699d64 787 for( i = gesture_data_.total_gestures - 1; i >= 0; i-- ) {
certvert 0:091e1a699d64 788 /* #if DEBUG
certvert 0:091e1a699d64 789 Serial.print(F("Finding last: "));
certvert 0:091e1a699d64 790 Serial.print(F("U:"));
certvert 0:091e1a699d64 791 Serial.print(gesture_data_.u_data[i]);
certvert 0:091e1a699d64 792 Serial.print(F(" D:"));
certvert 0:091e1a699d64 793 Serial.print(gesture_data_.d_data[i]);
certvert 0:091e1a699d64 794 Serial.print(F(" L:"));
certvert 0:091e1a699d64 795 Serial.print(gesture_data_.l_data[i]);
certvert 0:091e1a699d64 796 Serial.print(F(" R:"));
certvert 0:091e1a699d64 797 Serial.println(gesture_data_.r_data[i]);
certvert 0:091e1a699d64 798 #endif */
certvert 0:091e1a699d64 799 if( (gesture_data_.u_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 800 (gesture_data_.d_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 801 (gesture_data_.l_data[i] > GESTURE_THRESHOLD_OUT) &&
certvert 0:091e1a699d64 802 (gesture_data_.r_data[i] > GESTURE_THRESHOLD_OUT) ) {
certvert 0:091e1a699d64 803
certvert 0:091e1a699d64 804 u_last = gesture_data_.u_data[i];
certvert 0:091e1a699d64 805 d_last = gesture_data_.d_data[i];
certvert 0:091e1a699d64 806 l_last = gesture_data_.l_data[i];
certvert 0:091e1a699d64 807 r_last = gesture_data_.r_data[i];
certvert 0:091e1a699d64 808 break;
certvert 0:091e1a699d64 809 }
certvert 0:091e1a699d64 810 }
certvert 0:091e1a699d64 811 }
certvert 0:091e1a699d64 812
certvert 0:091e1a699d64 813 /* Calculate the first vs. last ratio of up/down and left/right */
certvert 0:091e1a699d64 814 ud_ratio_first = ((u_first - d_first) * 100) / (u_first + d_first);
certvert 0:091e1a699d64 815 lr_ratio_first = ((l_first - r_first) * 100) / (l_first + r_first);
certvert 0:091e1a699d64 816 ud_ratio_last = ((u_last - d_last) * 100) / (u_last + d_last);
certvert 0:091e1a699d64 817 lr_ratio_last = ((l_last - r_last) * 100) / (l_last + r_last);
certvert 0:091e1a699d64 818
certvert 0:091e1a699d64 819 /* #if DEBUG
certvert 0:091e1a699d64 820 Serial.print(F("Last Values: "));
certvert 0:091e1a699d64 821 Serial.print(F("U:"));
certvert 0:091e1a699d64 822 Serial.print(u_last);
certvert 0:091e1a699d64 823 Serial.print(F(" D:"));
certvert 0:091e1a699d64 824 Serial.print(d_last);
certvert 0:091e1a699d64 825 Serial.print(F(" L:"));
certvert 0:091e1a699d64 826 Serial.print(l_last);
certvert 0:091e1a699d64 827 Serial.print(F(" R:"));
certvert 0:091e1a699d64 828 Serial.println(r_last);
certvert 0:091e1a699d64 829
certvert 0:091e1a699d64 830 Serial.print(F("Ratios: "));
certvert 0:091e1a699d64 831 Serial.print(F("UD Fi: "));
certvert 0:091e1a699d64 832 Serial.print(ud_ratio_first);
certvert 0:091e1a699d64 833 Serial.print(F(" UD La: "));
certvert 0:091e1a699d64 834 Serial.print(ud_ratio_last);
certvert 0:091e1a699d64 835 Serial.print(F(" LR Fi: "));
certvert 0:091e1a699d64 836 Serial.print(lr_ratio_first);
certvert 0:091e1a699d64 837 Serial.print(F(" LR La: "));
certvert 0:091e1a699d64 838 Serial.println(lr_ratio_last);
certvert 0:091e1a699d64 839 #endif */
certvert 0:091e1a699d64 840
certvert 0:091e1a699d64 841 /* Determine the difference between the first and last ratios */
certvert 0:091e1a699d64 842 ud_delta = ud_ratio_last - ud_ratio_first;
certvert 0:091e1a699d64 843 lr_delta = lr_ratio_last - lr_ratio_first;
certvert 0:091e1a699d64 844
certvert 0:091e1a699d64 845 /* #if DEBUG
certvert 0:091e1a699d64 846 Serial.print("Deltas: ");
certvert 0:091e1a699d64 847 Serial.print("UD: ");
certvert 0:091e1a699d64 848 Serial.print(ud_delta);
certvert 0:091e1a699d64 849 Serial.print(" LR: ");
certvert 0:091e1a699d64 850 Serial.println(lr_delta);
certvert 0:091e1a699d64 851 #endif */
certvert 0:091e1a699d64 852
certvert 0:091e1a699d64 853 /* Accumulate the UD and LR delta values */
certvert 0:091e1a699d64 854 gesture_ud_delta_ += ud_delta;
certvert 0:091e1a699d64 855 gesture_lr_delta_ += lr_delta;
certvert 0:091e1a699d64 856
certvert 0:091e1a699d64 857 /* #if DEBUG
certvert 0:091e1a699d64 858 Serial.print("Accumulations: ");
certvert 0:091e1a699d64 859 Serial.print("UD: ");
certvert 0:091e1a699d64 860 Serial.print(gesture_ud_delta_);
certvert 0:091e1a699d64 861 Serial.print(" LR: ");
certvert 0:091e1a699d64 862 Serial.println(gesture_lr_delta_);
certvert 0:091e1a699d64 863 #endif */
certvert 0:091e1a699d64 864
certvert 0:091e1a699d64 865 /* Determine U/D gesture */
certvert 0:091e1a699d64 866 if( gesture_ud_delta_ >= GESTURE_SENSITIVITY_1 ) {
certvert 0:091e1a699d64 867 gesture_ud_count_ = 1;
certvert 0:091e1a699d64 868 } else if( gesture_ud_delta_ <= -GESTURE_SENSITIVITY_1 ) {
certvert 0:091e1a699d64 869 gesture_ud_count_ = -1;
certvert 0:091e1a699d64 870 } else {
certvert 0:091e1a699d64 871 gesture_ud_count_ = 0;
certvert 0:091e1a699d64 872 }
certvert 0:091e1a699d64 873
certvert 0:091e1a699d64 874 /* Determine L/R gesture */
certvert 0:091e1a699d64 875 if( gesture_lr_delta_ >= GESTURE_SENSITIVITY_1 ) {
certvert 0:091e1a699d64 876 gesture_lr_count_ = 1;
certvert 0:091e1a699d64 877 } else if( gesture_lr_delta_ <= -GESTURE_SENSITIVITY_1 ) {
certvert 0:091e1a699d64 878 gesture_lr_count_ = -1;
certvert 0:091e1a699d64 879 } else {
certvert 0:091e1a699d64 880 gesture_lr_count_ = 0;
certvert 0:091e1a699d64 881 }
certvert 0:091e1a699d64 882
certvert 0:091e1a699d64 883 /* Determine Near/Far gesture */
certvert 0:091e1a699d64 884 if( (gesture_ud_count_ == 0) && (gesture_lr_count_ == 0) ) {
certvert 0:091e1a699d64 885 if( (abs(ud_delta) < GESTURE_SENSITIVITY_2) && \
certvert 0:091e1a699d64 886 (abs(lr_delta) < GESTURE_SENSITIVITY_2) ) {
certvert 0:091e1a699d64 887
certvert 0:091e1a699d64 888 if( (ud_delta == 0) && (lr_delta == 0) ) {
certvert 0:091e1a699d64 889 gesture_near_count_++;
certvert 0:091e1a699d64 890 } else if( (ud_delta != 0) || (lr_delta != 0) ) {
certvert 0:091e1a699d64 891 gesture_far_count_++;
certvert 0:091e1a699d64 892 }
certvert 0:091e1a699d64 893
certvert 0:091e1a699d64 894 if( (gesture_near_count_ >= 10) && (gesture_far_count_ >= 2) ) {
certvert 0:091e1a699d64 895 if( (ud_delta == 0) && (lr_delta == 0) ) {
certvert 0:091e1a699d64 896 gesture_state_ = NEAR_STATE;
certvert 0:091e1a699d64 897 } else if( (ud_delta != 0) && (lr_delta != 0) ) {
certvert 0:091e1a699d64 898 gesture_state_ = FAR_STATE;
certvert 0:091e1a699d64 899 }
certvert 0:091e1a699d64 900 return true;
certvert 0:091e1a699d64 901 }
certvert 0:091e1a699d64 902 }
certvert 0:091e1a699d64 903 } else {
certvert 0:091e1a699d64 904 if( (abs(ud_delta) < GESTURE_SENSITIVITY_2) && \
certvert 0:091e1a699d64 905 (abs(lr_delta) < GESTURE_SENSITIVITY_2) ) {
certvert 0:091e1a699d64 906
certvert 0:091e1a699d64 907 if( (ud_delta == 0) && (lr_delta == 0) ) {
certvert 0:091e1a699d64 908 gesture_near_count_++;
certvert 0:091e1a699d64 909 }
certvert 0:091e1a699d64 910
certvert 0:091e1a699d64 911 if( gesture_near_count_ >= 5 ) {
certvert 0:091e1a699d64 912 gesture_ud_count_ = 0;
certvert 0:091e1a699d64 913 gesture_lr_count_ = 0;
certvert 0:091e1a699d64 914 gesture_ud_delta_ = 0;
certvert 0:091e1a699d64 915 gesture_lr_delta_ = 0;
certvert 0:091e1a699d64 916 }
certvert 0:091e1a699d64 917 }
certvert 0:091e1a699d64 918 }
certvert 0:091e1a699d64 919
certvert 0:091e1a699d64 920 // #if DEBUG
certvert 0:091e1a699d64 921 /* printf("UD_CT: %d\n",gesture_ud_count_);
certvert 0:091e1a699d64 922 printf("LR_CT: %d\n",gesture_lr_count_);
certvert 0:091e1a699d64 923 printf("NEAR_CT: %d\n",gesture_near_count_);
certvert 0:091e1a699d64 924 printf(" FAR_CT: %d\n",gesture_far_count_);
certvert 0:091e1a699d64 925 printf("----------"); */
certvert 0:091e1a699d64 926 //#endif */
certvert 0:091e1a699d64 927
certvert 0:091e1a699d64 928 return false;
certvert 0:091e1a699d64 929 }
certvert 0:091e1a699d64 930
certvert 0:091e1a699d64 931 /**
certvert 0:091e1a699d64 932 * @brief Determines swipe direction or near/far state
certvert 0:091e1a699d64 933 *
certvert 0:091e1a699d64 934 * @return True if near/far event. False otherwise.
certvert 0:091e1a699d64 935 */
certvert 0:091e1a699d64 936 bool glibr::decodeGesture()
certvert 0:091e1a699d64 937 {
certvert 0:091e1a699d64 938 /* Return if near or far event is detected */
certvert 0:091e1a699d64 939 if( gesture_state_ == NEAR_STATE ) {
certvert 0:091e1a699d64 940 gesture_motion_ = DIR_NEAR;
certvert 0:091e1a699d64 941 return true;
certvert 0:091e1a699d64 942 } else if ( gesture_state_ == FAR_STATE ) {
certvert 0:091e1a699d64 943 gesture_motion_ = DIR_FAR;
certvert 0:091e1a699d64 944 return true;
certvert 0:091e1a699d64 945 }
certvert 0:091e1a699d64 946
certvert 0:091e1a699d64 947 /* Determine swipe direction */
certvert 0:091e1a699d64 948 if( (gesture_ud_count_ == -1) && (gesture_lr_count_ == 0) ) {
certvert 0:091e1a699d64 949 gesture_motion_ = DIR_UP;
certvert 0:091e1a699d64 950 } else if( (gesture_ud_count_ == 1) && (gesture_lr_count_ == 0) ) {
certvert 0:091e1a699d64 951 gesture_motion_ = DIR_DOWN;
certvert 0:091e1a699d64 952 } else if( (gesture_ud_count_ == 0) && (gesture_lr_count_ == 1) ) {
certvert 0:091e1a699d64 953 gesture_motion_ = DIR_RIGHT;
certvert 0:091e1a699d64 954 } else if( (gesture_ud_count_ == 0) && (gesture_lr_count_ == -1) ) {
certvert 0:091e1a699d64 955 gesture_motion_ = DIR_LEFT;
certvert 0:091e1a699d64 956 } else if( (gesture_ud_count_ == -1) && (gesture_lr_count_ == 1) ) {
certvert 0:091e1a699d64 957 if( abs(gesture_ud_delta_) > abs(gesture_lr_delta_) ) {
certvert 0:091e1a699d64 958 gesture_motion_ = DIR_UP;
certvert 0:091e1a699d64 959 } else {
certvert 0:091e1a699d64 960 gesture_motion_ = DIR_RIGHT;
certvert 0:091e1a699d64 961 }
certvert 0:091e1a699d64 962 } else if( (gesture_ud_count_ == 1) && (gesture_lr_count_ == -1) ) {
certvert 0:091e1a699d64 963 if( abs(gesture_ud_delta_) > abs(gesture_lr_delta_) ) {
certvert 0:091e1a699d64 964 gesture_motion_ = DIR_DOWN;
certvert 0:091e1a699d64 965 } else {
certvert 0:091e1a699d64 966 gesture_motion_ = DIR_LEFT;
certvert 0:091e1a699d64 967 }
certvert 0:091e1a699d64 968 } else if( (gesture_ud_count_ == -1) && (gesture_lr_count_ == -1) ) {
certvert 0:091e1a699d64 969 if( abs(gesture_ud_delta_) > abs(gesture_lr_delta_) ) {
certvert 0:091e1a699d64 970 gesture_motion_ = DIR_UP;
certvert 0:091e1a699d64 971 } else {
certvert 0:091e1a699d64 972 gesture_motion_ = DIR_LEFT;
certvert 0:091e1a699d64 973 }
certvert 0:091e1a699d64 974 } else if( (gesture_ud_count_ == 1) && (gesture_lr_count_ == 1) ) {
certvert 0:091e1a699d64 975 if( abs(gesture_ud_delta_) > abs(gesture_lr_delta_) ) {
certvert 0:091e1a699d64 976 gesture_motion_ = DIR_DOWN;
certvert 0:091e1a699d64 977 } else {
certvert 0:091e1a699d64 978 gesture_motion_ = DIR_RIGHT;
certvert 0:091e1a699d64 979 }
certvert 0:091e1a699d64 980 } else {
certvert 0:091e1a699d64 981 return false;
certvert 0:091e1a699d64 982 }
certvert 0:091e1a699d64 983
certvert 0:091e1a699d64 984 return true;
certvert 0:091e1a699d64 985 }
certvert 0:091e1a699d64 986
certvert 0:091e1a699d64 987 /*******************************************************************************
certvert 0:091e1a699d64 988 * Getters and setters for register values
certvert 0:091e1a699d64 989 ******************************************************************************/
certvert 0:091e1a699d64 990
certvert 0:091e1a699d64 991 /**
certvert 0:091e1a699d64 992 * @brief Returns the lower threshold for proximity detection
certvert 0:091e1a699d64 993 *
certvert 0:091e1a699d64 994 * @return lower threshold
certvert 0:091e1a699d64 995 */
certvert 0:091e1a699d64 996
certvert 0:091e1a699d64 997 uint8_t glibr::getProxIntLowThresh()
certvert 0:091e1a699d64 998 {
certvert 0:091e1a699d64 999 uint8_t val;
certvert 0:091e1a699d64 1000
certvert 0:091e1a699d64 1001 /* Read value from PILT register */
certvert 0:091e1a699d64 1002 /* if( !wireReadDataByte(APDS9960_PILT, val) ) {
certvert 0:091e1a699d64 1003 val = 0;
certvert 0:091e1a699d64 1004 }*/
certvert 0:091e1a699d64 1005 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_PILT);
certvert 0:091e1a699d64 1006 if(val==ERROR){
certvert 0:091e1a699d64 1007 val=0;
certvert 0:091e1a699d64 1008 }
certvert 0:091e1a699d64 1009
certvert 0:091e1a699d64 1010 return val;
certvert 0:091e1a699d64 1011 }
certvert 0:091e1a699d64 1012
certvert 0:091e1a699d64 1013 /**
certvert 0:091e1a699d64 1014 * @brief Sets the lower threshold for proximity detection
certvert 0:091e1a699d64 1015 *
certvert 0:091e1a699d64 1016 * @param[in] threshold the lower proximity threshold
certvert 0:091e1a699d64 1017 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1018 */
certvert 0:091e1a699d64 1019 bool glibr::setProxIntLowThresh(uint8_t threshold)
certvert 0:091e1a699d64 1020 {
certvert 0:091e1a699d64 1021 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PILT, threshold) ) {
certvert 0:091e1a699d64 1022 return false;
certvert 0:091e1a699d64 1023 }
certvert 0:091e1a699d64 1024
certvert 0:091e1a699d64 1025 return true;
certvert 0:091e1a699d64 1026 }
certvert 0:091e1a699d64 1027
certvert 0:091e1a699d64 1028 /**
certvert 0:091e1a699d64 1029 * @brief Returns the high threshold for proximity detection
certvert 0:091e1a699d64 1030 *
certvert 0:091e1a699d64 1031 * @return high threshold
certvert 0:091e1a699d64 1032 */
certvert 0:091e1a699d64 1033 uint8_t glibr::getProxIntHighThresh()
certvert 0:091e1a699d64 1034 {
certvert 0:091e1a699d64 1035 uint8_t val;
certvert 0:091e1a699d64 1036
certvert 0:091e1a699d64 1037 /* Read value from PIHT register */
certvert 0:091e1a699d64 1038 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_PILT);
certvert 0:091e1a699d64 1039 if( val==ERROR ) {
certvert 0:091e1a699d64 1040 val = 0;
certvert 0:091e1a699d64 1041 }
certvert 0:091e1a699d64 1042
certvert 0:091e1a699d64 1043 return val;
certvert 0:091e1a699d64 1044 }
certvert 0:091e1a699d64 1045
certvert 0:091e1a699d64 1046 /**
certvert 0:091e1a699d64 1047 * @brief Sets the high threshold for proximity detection
certvert 0:091e1a699d64 1048 *
certvert 0:091e1a699d64 1049 * @param[in] threshold the high proximity threshold
certvert 0:091e1a699d64 1050 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1051 */
certvert 0:091e1a699d64 1052 bool glibr::setProxIntHighThresh(uint8_t threshold)
certvert 0:091e1a699d64 1053 {
certvert 0:091e1a699d64 1054
certvert 0:091e1a699d64 1055 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PIHT, threshold) ) {
certvert 0:091e1a699d64 1056 return false;
certvert 0:091e1a699d64 1057 }
certvert 0:091e1a699d64 1058
certvert 0:091e1a699d64 1059 return true;
certvert 0:091e1a699d64 1060 }
certvert 0:091e1a699d64 1061
certvert 0:091e1a699d64 1062 /**
certvert 0:091e1a699d64 1063 * @brief Returns LED drive strength for proximity and ALS
certvert 0:091e1a699d64 1064 *
certvert 0:091e1a699d64 1065 * Value LED Current
certvert 0:091e1a699d64 1066 * 0 100 mA
certvert 0:091e1a699d64 1067 * 1 50 mA
certvert 0:091e1a699d64 1068 * 2 25 mA
certvert 0:091e1a699d64 1069 * 3 12.5 mA
certvert 0:091e1a699d64 1070 *
certvert 0:091e1a699d64 1071 * @return the value of the LED drive strength. 0xFF on failure.
certvert 0:091e1a699d64 1072 */
certvert 0:091e1a699d64 1073 uint8_t glibr::getLEDDrive()
certvert 0:091e1a699d64 1074 {
certvert 0:091e1a699d64 1075 uint8_t val;
certvert 0:091e1a699d64 1076
certvert 0:091e1a699d64 1077 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1078 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1079 if( val == ERROR ){//!wireReadDataByte(APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1080 return ERROR;
certvert 0:091e1a699d64 1081 }
certvert 0:091e1a699d64 1082
certvert 0:091e1a699d64 1083 /* Shift and mask out LED drive bits */
certvert 0:091e1a699d64 1084 val = (val >> 6) & 0x03;//0b00000011;
certvert 0:091e1a699d64 1085
certvert 0:091e1a699d64 1086 return val;
certvert 0:091e1a699d64 1087 }
certvert 0:091e1a699d64 1088
certvert 0:091e1a699d64 1089 /**
certvert 0:091e1a699d64 1090 * @brief Sets the LED drive strength for proximity and ALS
certvert 0:091e1a699d64 1091 *
certvert 0:091e1a699d64 1092 * Value LED Current
certvert 0:091e1a699d64 1093 * 0 100 mA
certvert 0:091e1a699d64 1094 * 1 50 mA
certvert 0:091e1a699d64 1095 * 2 25 mA
certvert 0:091e1a699d64 1096 * 3 12.5 mA
certvert 0:091e1a699d64 1097 *
certvert 0:091e1a699d64 1098 * @param[in] drive the value (0-3) for the LED drive strength
certvert 0:091e1a699d64 1099 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1100 */
certvert 0:091e1a699d64 1101
certvert 0:091e1a699d64 1102 bool glibr::setLEDDrive(uint8_t drive)
certvert 0:091e1a699d64 1103 {
certvert 0:091e1a699d64 1104 uint8_t val;
certvert 0:091e1a699d64 1105
certvert 0:091e1a699d64 1106 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1107 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1108 if(val==ERROR){
certvert 0:091e1a699d64 1109 return false;
certvert 0:091e1a699d64 1110 }
certvert 0:091e1a699d64 1111 /* Set bits in register to given value */
certvert 0:091e1a699d64 1112 //drive &= 0b00000011
certvert 0:091e1a699d64 1113 drive &= 0x03;
certvert 0:091e1a699d64 1114 drive = drive << 6;
certvert 0:091e1a699d64 1115 //val &= 0b00111111;
certvert 0:091e1a699d64 1116 val &= 0x3F;
certvert 0:091e1a699d64 1117 val |= drive;
certvert 0:091e1a699d64 1118
certvert 0:091e1a699d64 1119 /* Write register value back into CONTROL register */
certvert 0:091e1a699d64 1120 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1121 return false;
certvert 0:091e1a699d64 1122 }
certvert 0:091e1a699d64 1123
certvert 0:091e1a699d64 1124 return true;
certvert 0:091e1a699d64 1125 }
certvert 0:091e1a699d64 1126
certvert 0:091e1a699d64 1127 /**
certvert 0:091e1a699d64 1128 * @brief Returns receiver gain for proximity detection
certvert 0:091e1a699d64 1129 *
certvert 0:091e1a699d64 1130 * Value Gain
certvert 0:091e1a699d64 1131 * 0 1x
certvert 0:091e1a699d64 1132 * 1 2x
certvert 0:091e1a699d64 1133 * 2 4x
certvert 0:091e1a699d64 1134 * 3 8x
certvert 0:091e1a699d64 1135 *
certvert 0:091e1a699d64 1136 * @return the value of the proximity gain. 0xFF on failure.
certvert 0:091e1a699d64 1137 */
certvert 0:091e1a699d64 1138 uint8_t glibr::getProximityGain()
certvert 0:091e1a699d64 1139 {
certvert 0:091e1a699d64 1140 uint8_t val;
certvert 0:091e1a699d64 1141
certvert 0:091e1a699d64 1142 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1143 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1144 if( val == ERROR){//!wireReadDataByte(APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1145 return ERROR;
certvert 0:091e1a699d64 1146 }
certvert 0:091e1a699d64 1147
certvert 0:091e1a699d64 1148 /* Shift and mask out PDRIVE bits */
certvert 0:091e1a699d64 1149 val = (val >> 2) & 0x03;//0b00000011;
certvert 0:091e1a699d64 1150
certvert 0:091e1a699d64 1151 return val;
certvert 0:091e1a699d64 1152 }
certvert 0:091e1a699d64 1153
certvert 0:091e1a699d64 1154 /**
certvert 0:091e1a699d64 1155 * @brief Sets the receiver gain for proximity detection
certvert 0:091e1a699d64 1156 *
certvert 0:091e1a699d64 1157 * Value Gain
certvert 0:091e1a699d64 1158 * 0 1x
certvert 0:091e1a699d64 1159 * 1 2x
certvert 0:091e1a699d64 1160 * 2 4x
certvert 0:091e1a699d64 1161 * 3 8x
certvert 0:091e1a699d64 1162 *
certvert 0:091e1a699d64 1163 * @param[in] drive the value (0-3) for the gain
certvert 0:091e1a699d64 1164 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1165 */
certvert 0:091e1a699d64 1166 bool glibr::setProximityGain(uint8_t drive)
certvert 0:091e1a699d64 1167 {
certvert 0:091e1a699d64 1168 uint8_t val;
certvert 0:091e1a699d64 1169
certvert 0:091e1a699d64 1170 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1171
certvert 0:091e1a699d64 1172 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1173
certvert 0:091e1a699d64 1174 if(val==ERROR){
certvert 0:091e1a699d64 1175 return false;
certvert 0:091e1a699d64 1176 }
certvert 0:091e1a699d64 1177 /* Set bits in register to given value */
certvert 0:091e1a699d64 1178 //drive &= 0b00000011;
certvert 0:091e1a699d64 1179 drive &=0x03;
certvert 0:091e1a699d64 1180 drive = drive << 2;
certvert 0:091e1a699d64 1181 //val &= 0b11110011
certvert 0:091e1a699d64 1182 val &= 0xF3;
certvert 0:091e1a699d64 1183 val |= drive;
certvert 0:091e1a699d64 1184
certvert 0:091e1a699d64 1185 /* Write register value back into CONTROL register */
certvert 0:091e1a699d64 1186 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1187 return false;
certvert 0:091e1a699d64 1188 }
certvert 0:091e1a699d64 1189 return true;
certvert 0:091e1a699d64 1190 }
certvert 0:091e1a699d64 1191
certvert 0:091e1a699d64 1192 /**
certvert 0:091e1a699d64 1193 * @brief Returns receiver gain for the ambient light sensor (ALS)
certvert 0:091e1a699d64 1194 *
certvert 0:091e1a699d64 1195 * Value Gain
certvert 0:091e1a699d64 1196 * 0 1x
certvert 0:091e1a699d64 1197 * 1 4x
certvert 0:091e1a699d64 1198 * 2 16x
certvert 0:091e1a699d64 1199 * 3 64x
certvert 0:091e1a699d64 1200 *
certvert 0:091e1a699d64 1201 * @return the value of the ALS gain. 0xFF on failure.
certvert 0:091e1a699d64 1202 */
certvert 0:091e1a699d64 1203 uint8_t glibr::getAmbientLightGain()
certvert 0:091e1a699d64 1204 {
certvert 0:091e1a699d64 1205 uint8_t val;
certvert 0:091e1a699d64 1206
certvert 0:091e1a699d64 1207 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1208 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1209 if( val == ERROR){//!wireReadDataByte(APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1210 return ERROR;
certvert 0:091e1a699d64 1211 }
certvert 0:091e1a699d64 1212
certvert 0:091e1a699d64 1213 /* Shift and mask out ADRIVE bits */
certvert 0:091e1a699d64 1214 val &= 0x03;//0b00000011;
certvert 0:091e1a699d64 1215
certvert 0:091e1a699d64 1216 return val;
certvert 0:091e1a699d64 1217 }
certvert 0:091e1a699d64 1218
certvert 0:091e1a699d64 1219 /**
certvert 0:091e1a699d64 1220 * @brief Sets the receiver gain for the ambient light sensor (ALS)
certvert 0:091e1a699d64 1221 *
certvert 0:091e1a699d64 1222 * Value Gain
certvert 0:091e1a699d64 1223 * 0 1x
certvert 0:091e1a699d64 1224 * 1 4x
certvert 0:091e1a699d64 1225 * 2 16x
certvert 0:091e1a699d64 1226 * 3 64x
certvert 0:091e1a699d64 1227 *
certvert 0:091e1a699d64 1228 * @param[in] drive the value (0-3) for the gain
certvert 0:091e1a699d64 1229 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1230 */
certvert 0:091e1a699d64 1231 bool glibr::setAmbientLightGain(uint8_t drive){
certvert 0:091e1a699d64 1232
certvert 0:091e1a699d64 1233 uint8_t val;
certvert 0:091e1a699d64 1234
certvert 0:091e1a699d64 1235 /* Read value from CONTROL register */
certvert 0:091e1a699d64 1236
certvert 0:091e1a699d64 1237 val=I2CreadByte(APDS9960_I2C_ADDR,APDS9960_CONTROL);
certvert 0:091e1a699d64 1238
certvert 0:091e1a699d64 1239 if(val==ERROR){
certvert 0:091e1a699d64 1240 return false;
certvert 0:091e1a699d64 1241 }
certvert 0:091e1a699d64 1242 /* Set bits in register to given value */
certvert 0:091e1a699d64 1243 //drive &= 0b00000011;
certvert 0:091e1a699d64 1244 drive &=0x03;
certvert 0:091e1a699d64 1245 drive = drive << 2;
certvert 0:091e1a699d64 1246 //val &=0b11111100
certvert 0:091e1a699d64 1247 val &= 0xF3;
certvert 0:091e1a699d64 1248 val |= drive;
certvert 0:091e1a699d64 1249
certvert 0:091e1a699d64 1250 /* Write register value back into CONTROL register */
certvert 0:091e1a699d64 1251 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONTROL, val) ) {
certvert 0:091e1a699d64 1252 return false;
certvert 0:091e1a699d64 1253 }
certvert 0:091e1a699d64 1254 return true;
certvert 0:091e1a699d64 1255 }
certvert 0:091e1a699d64 1256
certvert 0:091e1a699d64 1257 /**
certvert 0:091e1a699d64 1258 * @brief Get the current LED boost value
certvert 0:091e1a699d64 1259 *
certvert 0:091e1a699d64 1260 * Value Boost Current
certvert 0:091e1a699d64 1261 * 0 100%
certvert 0:091e1a699d64 1262 * 1 150%
certvert 0:091e1a699d64 1263 * 2 200%
certvert 0:091e1a699d64 1264 * 3 300%
certvert 0:091e1a699d64 1265 *
certvert 0:091e1a699d64 1266 * @return The LED boost value. 0xFF on failure.
certvert 0:091e1a699d64 1267 */
certvert 0:091e1a699d64 1268 uint8_t glibr::getLEDBoost() {
certvert 0:091e1a699d64 1269 uint8_t val;
certvert 0:091e1a699d64 1270
certvert 0:091e1a699d64 1271 /* Read value from CONFIG2 register */
certvert 0:091e1a699d64 1272 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG2);
certvert 0:091e1a699d64 1273 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG2, val) ) {
certvert 0:091e1a699d64 1274 return ERROR;
certvert 0:091e1a699d64 1275 }
certvert 0:091e1a699d64 1276
certvert 0:091e1a699d64 1277 /* Shift and mask out LED_BOOST bits */
certvert 0:091e1a699d64 1278 val = (val >> 4) & 0x03;//0b00000011;
certvert 0:091e1a699d64 1279
certvert 0:091e1a699d64 1280 return val;
certvert 0:091e1a699d64 1281 }
certvert 0:091e1a699d64 1282
certvert 0:091e1a699d64 1283 /**
certvert 0:091e1a699d64 1284 * @brief Sets the LED current boost value
certvert 0:091e1a699d64 1285 *
certvert 0:091e1a699d64 1286 * Value Boost Current
certvert 0:091e1a699d64 1287 * 0 100%
certvert 0:091e1a699d64 1288 * 1 150%
certvert 0:091e1a699d64 1289 * 2 200%
certvert 0:091e1a699d64 1290 * 3 300%
certvert 0:091e1a699d64 1291 *
certvert 0:091e1a699d64 1292 * @param[in] drive the value (0-3) for current boost (100-300%)
certvert 0:091e1a699d64 1293 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1294 */
certvert 0:091e1a699d64 1295 bool glibr::setLEDBoost(uint8_t boost)
certvert 0:091e1a699d64 1296 {
certvert 0:091e1a699d64 1297 uint8_t val;
certvert 0:091e1a699d64 1298
certvert 0:091e1a699d64 1299 /* Read value from CONFIG2 register */
certvert 0:091e1a699d64 1300 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG2);
certvert 0:091e1a699d64 1301 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG2, val) ) {
certvert 0:091e1a699d64 1302 return false;
certvert 0:091e1a699d64 1303 }
certvert 0:091e1a699d64 1304
certvert 0:091e1a699d64 1305 /* Set bits in register to given value */
certvert 0:091e1a699d64 1306 boost &= 0x03;//0b00000011;
certvert 0:091e1a699d64 1307 boost = boost << 4;
certvert 0:091e1a699d64 1308 val &= 0xCF;//0b11001111;
certvert 0:091e1a699d64 1309 val |= boost;
certvert 0:091e1a699d64 1310
certvert 0:091e1a699d64 1311 /* Write register value back into CONFIG2 register */
certvert 0:091e1a699d64 1312
certvert 0:091e1a699d64 1313 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONFIG2, val)){//!wireWriteDataByte(APDS9960_CONFIG2, val) ) {
certvert 0:091e1a699d64 1314 return false;
certvert 0:091e1a699d64 1315 }
certvert 0:091e1a699d64 1316
certvert 0:091e1a699d64 1317 return true;
certvert 0:091e1a699d64 1318 }
certvert 0:091e1a699d64 1319
certvert 0:091e1a699d64 1320 /**
certvert 0:091e1a699d64 1321 * @brief Gets proximity gain compensation enable
certvert 0:091e1a699d64 1322 *
certvert 0:091e1a699d64 1323 * @return 1 if compensation is enabled. 0 if not. 0xFF on error.
certvert 0:091e1a699d64 1324 */
certvert 0:091e1a699d64 1325 uint8_t glibr::getProxGainCompEnable()
certvert 0:091e1a699d64 1326 {
certvert 0:091e1a699d64 1327 uint8_t val;
certvert 0:091e1a699d64 1328
certvert 0:091e1a699d64 1329 /* Read value from CONFIG3 register */
certvert 0:091e1a699d64 1330 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
certvert 0:091e1a699d64 1331 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1332 return ERROR;
certvert 0:091e1a699d64 1333 }
certvert 0:091e1a699d64 1334
certvert 0:091e1a699d64 1335 /* Shift and mask out PCMP bits */
certvert 0:091e1a699d64 1336 val = (val >> 5) & 0x01;//0b00000001;
certvert 0:091e1a699d64 1337
certvert 0:091e1a699d64 1338 return val;
certvert 0:091e1a699d64 1339 }
certvert 0:091e1a699d64 1340
certvert 0:091e1a699d64 1341 /**
certvert 0:091e1a699d64 1342 * @brief Sets the proximity gain compensation enable
certvert 0:091e1a699d64 1343 *
certvert 0:091e1a699d64 1344 * @param[in] enable 1 to enable compensation. 0 to disable compensation.
certvert 0:091e1a699d64 1345 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1346 */
certvert 0:091e1a699d64 1347 bool glibr::setProxGainCompEnable(uint8_t enable)
certvert 0:091e1a699d64 1348 {
certvert 0:091e1a699d64 1349 uint8_t val;
certvert 0:091e1a699d64 1350
certvert 0:091e1a699d64 1351 /* Read value from CONFIG3 register */
certvert 0:091e1a699d64 1352 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
certvert 0:091e1a699d64 1353 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1354 return false;
certvert 0:091e1a699d64 1355 }
certvert 0:091e1a699d64 1356
certvert 0:091e1a699d64 1357 /* Set bits in register to given value */
certvert 0:091e1a699d64 1358 enable &= 0x01;//0b00000001;
certvert 0:091e1a699d64 1359 enable = enable << 5;
certvert 0:091e1a699d64 1360 val &= 0xCF;//0b11011111;
certvert 0:091e1a699d64 1361 val |= enable;
certvert 0:091e1a699d64 1362
certvert 0:091e1a699d64 1363 /* Write register value back into CONFIG3 register */
certvert 0:091e1a699d64 1364
certvert 0:091e1a699d64 1365 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_CONFIG3, val)){//!wireWriteDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1366 return false;
certvert 0:091e1a699d64 1367 }
certvert 0:091e1a699d64 1368
certvert 0:091e1a699d64 1369 return true;
certvert 0:091e1a699d64 1370 }
certvert 0:091e1a699d64 1371
certvert 0:091e1a699d64 1372 /**
certvert 0:091e1a699d64 1373 * @brief Gets the current mask for enabled/disabled proximity photodiodes
certvert 0:091e1a699d64 1374 *
certvert 0:091e1a699d64 1375 * 1 = disabled, 0 = enabled
certvert 0:091e1a699d64 1376 * Bit Photodiode
certvert 0:091e1a699d64 1377 * 3 UP
certvert 0:091e1a699d64 1378 * 2 DOWN
certvert 0:091e1a699d64 1379 * 1 LEFT
certvert 0:091e1a699d64 1380 * 0 RIGHT
certvert 0:091e1a699d64 1381 *
certvert 0:091e1a699d64 1382 * @return Current proximity mask for photodiodes. 0xFF on error.
certvert 0:091e1a699d64 1383 */
certvert 0:091e1a699d64 1384 uint8_t glibr::getProxPhotoMask()
certvert 0:091e1a699d64 1385 {
certvert 0:091e1a699d64 1386 uint8_t val;
certvert 0:091e1a699d64 1387
certvert 0:091e1a699d64 1388 /* Read value from CONFIG3 register */
certvert 0:091e1a699d64 1389 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
certvert 0:091e1a699d64 1390 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1391 return ERROR;
certvert 0:091e1a699d64 1392 }
certvert 0:091e1a699d64 1393
certvert 0:091e1a699d64 1394 /* Mask out photodiode enable mask bits */
certvert 0:091e1a699d64 1395 val &= 0x0F;//0b00001111;
certvert 0:091e1a699d64 1396
certvert 0:091e1a699d64 1397 return val;
certvert 0:091e1a699d64 1398 }
certvert 0:091e1a699d64 1399
certvert 0:091e1a699d64 1400 /**
certvert 0:091e1a699d64 1401 * @brief Sets the mask for enabling/disabling proximity photodiodes
certvert 0:091e1a699d64 1402 *
certvert 0:091e1a699d64 1403 * 1 = disabled, 0 = enabled
certvert 0:091e1a699d64 1404 * Bit Photodiode
certvert 0:091e1a699d64 1405 * 3 UP
certvert 0:091e1a699d64 1406 * 2 DOWN
certvert 0:091e1a699d64 1407 * 1 LEFT
certvert 0:091e1a699d64 1408 * 0 RIGHT
certvert 0:091e1a699d64 1409 *
certvert 0:091e1a699d64 1410 * @param[in] mask 4-bit mask value
certvert 0:091e1a699d64 1411 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1412 */
certvert 0:091e1a699d64 1413 bool glibr::setProxPhotoMask(uint8_t mask)
certvert 0:091e1a699d64 1414 {
certvert 0:091e1a699d64 1415 uint8_t val;
certvert 0:091e1a699d64 1416
certvert 0:091e1a699d64 1417 /* Read value from CONFIG3 register */
certvert 0:091e1a699d64 1418 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_CONFIG3);
certvert 0:091e1a699d64 1419 if( val == ERROR){//!wireReadDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1420 return false;
certvert 0:091e1a699d64 1421 }
certvert 0:091e1a699d64 1422
certvert 0:091e1a699d64 1423 /* Set bits in register to given value */
certvert 0:091e1a699d64 1424 mask &= 0x0F;//0b00001111;
certvert 0:091e1a699d64 1425 val &= 0xF0;//0b11110000;
certvert 0:091e1a699d64 1426 val |= mask;
certvert 0:091e1a699d64 1427
certvert 0:091e1a699d64 1428 /* Write register value back into CONFIG3 register */
certvert 0:091e1a699d64 1429 I2CwriteByte(APDS9960_I2C_ADDR, APDS9960_CONFIG3, val);
certvert 0:091e1a699d64 1430 if( val == ERROR){//!wireWriteDataByte(APDS9960_CONFIG3, val) ) {
certvert 0:091e1a699d64 1431 return false;
certvert 0:091e1a699d64 1432 }
certvert 0:091e1a699d64 1433
certvert 0:091e1a699d64 1434 return true;
certvert 0:091e1a699d64 1435 }
certvert 0:091e1a699d64 1436
certvert 0:091e1a699d64 1437 /**
certvert 0:091e1a699d64 1438 * @brief Gets the entry proximity threshold for gesture sensing
certvert 0:091e1a699d64 1439 *
certvert 0:091e1a699d64 1440 * @return Current entry proximity threshold.
certvert 0:091e1a699d64 1441 */
certvert 0:091e1a699d64 1442 uint8_t glibr::getGestureEnterThresh()
certvert 0:091e1a699d64 1443 {
certvert 0:091e1a699d64 1444 uint8_t val;
certvert 0:091e1a699d64 1445
certvert 0:091e1a699d64 1446 /* Read value from GPENTH register */
certvert 0:091e1a699d64 1447 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GPENTH);
certvert 0:091e1a699d64 1448 if( val == ERROR){//!wireReadDataByte(APDS9960_GPENTH, val) ) {
certvert 0:091e1a699d64 1449 val = 0;
certvert 0:091e1a699d64 1450 }
certvert 0:091e1a699d64 1451
certvert 0:091e1a699d64 1452 return val;
certvert 0:091e1a699d64 1453 }
certvert 0:091e1a699d64 1454
certvert 0:091e1a699d64 1455 /**
certvert 0:091e1a699d64 1456 * @brief Sets the entry proximity threshold for gesture sensing
certvert 0:091e1a699d64 1457 *
certvert 0:091e1a699d64 1458 * @param[in] threshold proximity value needed to start gesture mode
certvert 0:091e1a699d64 1459 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1460 */
certvert 0:091e1a699d64 1461 bool glibr::setGestureEnterThresh(uint8_t threshold)
certvert 0:091e1a699d64 1462 {
certvert 0:091e1a699d64 1463
certvert 0:091e1a699d64 1464 if( I2CwriteByte(APDS9960_I2C_ADDR, APDS9960_GPENTH, threshold)){;//!wireWriteDataByte(APDS9960_GPENTH, threshold) ) {
certvert 0:091e1a699d64 1465 return false;
certvert 0:091e1a699d64 1466 }
certvert 0:091e1a699d64 1467
certvert 0:091e1a699d64 1468 return true;
certvert 0:091e1a699d64 1469 }
certvert 0:091e1a699d64 1470
certvert 0:091e1a699d64 1471 /**
certvert 0:091e1a699d64 1472 * @brief Gets the exit proximity threshold for gesture sensing
certvert 0:091e1a699d64 1473 *
certvert 0:091e1a699d64 1474 * @return Current exit proximity threshold.
certvert 0:091e1a699d64 1475 */
certvert 0:091e1a699d64 1476 uint8_t glibr::getGestureExitThresh()
certvert 0:091e1a699d64 1477 {
certvert 0:091e1a699d64 1478 uint8_t val;
certvert 0:091e1a699d64 1479
certvert 0:091e1a699d64 1480 /* Read value from GEXTH register */
certvert 0:091e1a699d64 1481 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GEXTH);
certvert 0:091e1a699d64 1482 if( val == ERROR){//!wireReadDataByte(APDS9960_GEXTH, val) ) {
certvert 0:091e1a699d64 1483 val = 0;
certvert 0:091e1a699d64 1484 }
certvert 0:091e1a699d64 1485
certvert 0:091e1a699d64 1486 return val;
certvert 0:091e1a699d64 1487 }
certvert 0:091e1a699d64 1488
certvert 0:091e1a699d64 1489 /**
certvert 0:091e1a699d64 1490 * @brief Sets the exit proximity threshold for gesture sensing
certvert 0:091e1a699d64 1491 *
certvert 0:091e1a699d64 1492 * @param[in] threshold proximity value needed to end gesture mode
certvert 0:091e1a699d64 1493 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1494 */
certvert 0:091e1a699d64 1495 bool glibr::setGestureExitThresh(uint8_t threshold)
certvert 0:091e1a699d64 1496 {
certvert 0:091e1a699d64 1497 if( I2CwriteByte(APDS9960_I2C_ADDR, APDS9960_GEXTH, threshold)){//!wireWriteDataByte(APDS9960_GEXTH, threshold) ) {
certvert 0:091e1a699d64 1498 return false;
certvert 0:091e1a699d64 1499 }
certvert 0:091e1a699d64 1500
certvert 0:091e1a699d64 1501 return true;
certvert 0:091e1a699d64 1502 }
certvert 0:091e1a699d64 1503
certvert 0:091e1a699d64 1504 /**
certvert 0:091e1a699d64 1505 * @brief Gets the gain of the photodiode during gesture mode
certvert 0:091e1a699d64 1506 *
certvert 0:091e1a699d64 1507 * Value Gain
certvert 0:091e1a699d64 1508 * 0 1x
certvert 0:091e1a699d64 1509 * 1 2x
certvert 0:091e1a699d64 1510 * 2 4x
certvert 0:091e1a699d64 1511 * 3 8x
certvert 0:091e1a699d64 1512 *
certvert 0:091e1a699d64 1513 * @return the current photodiode gain. 0xFF on error.
certvert 0:091e1a699d64 1514 */
certvert 0:091e1a699d64 1515 uint8_t glibr::getGestureGain()
certvert 0:091e1a699d64 1516 {
certvert 0:091e1a699d64 1517 uint8_t val;
certvert 0:091e1a699d64 1518
certvert 0:091e1a699d64 1519 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1520 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1521 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1522 return ERROR;
certvert 0:091e1a699d64 1523 }
certvert 0:091e1a699d64 1524
certvert 0:091e1a699d64 1525 /* Shift and mask out GGAIN bits */
certvert 0:091e1a699d64 1526 val = (val >> 5) & 0x03;//0b00000011;
certvert 0:091e1a699d64 1527
certvert 0:091e1a699d64 1528 return val;
certvert 0:091e1a699d64 1529 }
certvert 0:091e1a699d64 1530
certvert 0:091e1a699d64 1531 /**
certvert 0:091e1a699d64 1532 * @brief Sets the gain of the photodiode during gesture mode
certvert 0:091e1a699d64 1533 *
certvert 0:091e1a699d64 1534 * Value Gain
certvert 0:091e1a699d64 1535 * 0 1x
certvert 0:091e1a699d64 1536 * 1 2x
certvert 0:091e1a699d64 1537 * 2 4x
certvert 0:091e1a699d64 1538 * 3 8x
certvert 0:091e1a699d64 1539 *
certvert 0:091e1a699d64 1540 * @param[in] gain the value for the photodiode gain
certvert 0:091e1a699d64 1541 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1542 */
certvert 0:091e1a699d64 1543 bool glibr::setGestureGain(uint8_t gain)
certvert 0:091e1a699d64 1544 {
certvert 0:091e1a699d64 1545 uint8_t val;
certvert 0:091e1a699d64 1546
certvert 0:091e1a699d64 1547 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1548 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1549 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1550 return false;
certvert 0:091e1a699d64 1551 }
certvert 0:091e1a699d64 1552
certvert 0:091e1a699d64 1553 /* Set bits in register to given value */
certvert 0:091e1a699d64 1554 gain &= 0x03;//0b00000011;
certvert 0:091e1a699d64 1555 gain = gain << 5;
certvert 0:091e1a699d64 1556 val &= 0x9F;//0b10011111;
certvert 0:091e1a699d64 1557 val |= gain;
certvert 0:091e1a699d64 1558
certvert 0:091e1a699d64 1559 /* Write register value back into GCONF2 register */
certvert 0:091e1a699d64 1560 if( I2CwriteByte(APDS9960_I2C_ADDR, APDS9960_GCONF2, val)){//!wireWriteDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1561 return false;
certvert 0:091e1a699d64 1562 }
certvert 0:091e1a699d64 1563
certvert 0:091e1a699d64 1564 return true;
certvert 0:091e1a699d64 1565 }
certvert 0:091e1a699d64 1566
certvert 0:091e1a699d64 1567 /**
certvert 0:091e1a699d64 1568 * @brief Gets the drive current of the LED during gesture mode
certvert 0:091e1a699d64 1569 *
certvert 0:091e1a699d64 1570 * Value LED Current
certvert 0:091e1a699d64 1571 * 0 100 mA
certvert 0:091e1a699d64 1572 * 1 50 mA
certvert 0:091e1a699d64 1573 * 2 25 mA
certvert 0:091e1a699d64 1574 * 3 12.5 mA
certvert 0:091e1a699d64 1575 *
certvert 0:091e1a699d64 1576 * @return the LED drive current value. 0xFF on error.
certvert 0:091e1a699d64 1577 */
certvert 0:091e1a699d64 1578 uint8_t glibr::getGestureLEDDrive()
certvert 0:091e1a699d64 1579 {
certvert 0:091e1a699d64 1580 uint8_t val;
certvert 0:091e1a699d64 1581
certvert 0:091e1a699d64 1582 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1583 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1584 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1585 return ERROR;
certvert 0:091e1a699d64 1586 }
certvert 0:091e1a699d64 1587
certvert 0:091e1a699d64 1588 /* Shift and mask out GLDRIVE bits */
certvert 0:091e1a699d64 1589 val = (val >> 3) & 0x03;//0b00000011;
certvert 0:091e1a699d64 1590
certvert 0:091e1a699d64 1591 return val;
certvert 0:091e1a699d64 1592 }
certvert 0:091e1a699d64 1593
certvert 0:091e1a699d64 1594 /**
certvert 0:091e1a699d64 1595 * @brief Sets the LED drive current during gesture mode
certvert 0:091e1a699d64 1596 *
certvert 0:091e1a699d64 1597 * Value LED Current
certvert 0:091e1a699d64 1598 * 0 100 mA
certvert 0:091e1a699d64 1599 * 1 50 mA
certvert 0:091e1a699d64 1600 * 2 25 mA
certvert 0:091e1a699d64 1601 * 3 12.5 mA
certvert 0:091e1a699d64 1602 *
certvert 0:091e1a699d64 1603 * @param[in] drive the value for the LED drive current
certvert 0:091e1a699d64 1604 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1605 */
certvert 0:091e1a699d64 1606 bool glibr::setGestureLEDDrive(uint8_t drive)
certvert 0:091e1a699d64 1607 {
certvert 0:091e1a699d64 1608 uint8_t val;
certvert 0:091e1a699d64 1609
certvert 0:091e1a699d64 1610 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1611 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1612 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1613 return false;
certvert 0:091e1a699d64 1614 }
certvert 0:091e1a699d64 1615
certvert 0:091e1a699d64 1616 /* Set bits in register to given value */
certvert 0:091e1a699d64 1617 drive &= 0x03;//0b00000011;
certvert 0:091e1a699d64 1618 drive = drive << 3;
certvert 0:091e1a699d64 1619 val &= 0xE7;//0b11100111;
certvert 0:091e1a699d64 1620 val |= drive;
certvert 0:091e1a699d64 1621
certvert 0:091e1a699d64 1622 /* Write register value back into GCONF2 register */
certvert 0:091e1a699d64 1623 if( I2CwriteByte(APDS9960_I2C_ADDR, APDS9960_GCONF2, val)){//!wireWriteDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1624 return false;
certvert 0:091e1a699d64 1625 }
certvert 0:091e1a699d64 1626
certvert 0:091e1a699d64 1627 return true;
certvert 0:091e1a699d64 1628 }
certvert 0:091e1a699d64 1629
certvert 0:091e1a699d64 1630 /**
certvert 0:091e1a699d64 1631 * @brief Gets the time in low power mode between gesture detections
certvert 0:091e1a699d64 1632 *
certvert 0:091e1a699d64 1633 * Value Wait time
certvert 0:091e1a699d64 1634 * 0 0 ms
certvert 0:091e1a699d64 1635 * 1 2.8 ms
certvert 0:091e1a699d64 1636 * 2 5.6 ms
certvert 0:091e1a699d64 1637 * 3 8.4 ms
certvert 0:091e1a699d64 1638 * 4 14.0 ms
certvert 0:091e1a699d64 1639 * 5 22.4 ms
certvert 0:091e1a699d64 1640 * 6 30.8 ms
certvert 0:091e1a699d64 1641 * 7 39.2 ms
certvert 0:091e1a699d64 1642 *
certvert 0:091e1a699d64 1643 * @return the current wait time between gestures. 0xFF on error.
certvert 0:091e1a699d64 1644 */
certvert 0:091e1a699d64 1645 uint8_t glibr::getGestureWaitTime()
certvert 0:091e1a699d64 1646 {
certvert 0:091e1a699d64 1647 uint8_t val;
certvert 0:091e1a699d64 1648
certvert 0:091e1a699d64 1649 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1650 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1651 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1652 return ERROR;
certvert 0:091e1a699d64 1653 }
certvert 0:091e1a699d64 1654
certvert 0:091e1a699d64 1655 /* Mask out GWTIME bits */
certvert 0:091e1a699d64 1656 val &= 0x07;//0b00000111;
certvert 0:091e1a699d64 1657
certvert 0:091e1a699d64 1658 return val;
certvert 0:091e1a699d64 1659 }
certvert 0:091e1a699d64 1660
certvert 0:091e1a699d64 1661 /*
certvert 0:091e1a699d64 1662 *
certvert 0:091e1a699d64 1663 *
certvert 0:091e1a699d64 1664 *
certvert 0:091e1a699d64 1665 *LEFT OFF HERE AT 3:47PM ON 3/6/15
certvert 0:091e1a699d64 1666 *
certvert 0:091e1a699d64 1667 *
certvert 0:091e1a699d64 1668 *
certvert 0:091e1a699d64 1669 *
certvert 0:091e1a699d64 1670 */
certvert 0:091e1a699d64 1671
certvert 0:091e1a699d64 1672
certvert 0:091e1a699d64 1673 /**
certvert 0:091e1a699d64 1674 * @brief Sets the time in low power mode between gesture detections
certvert 0:091e1a699d64 1675 *
certvert 0:091e1a699d64 1676 * Value Wait time
certvert 0:091e1a699d64 1677 * 0 0 ms
certvert 0:091e1a699d64 1678 * 1 2.8 ms
certvert 0:091e1a699d64 1679 * 2 5.6 ms
certvert 0:091e1a699d64 1680 * 3 8.4 ms
certvert 0:091e1a699d64 1681 * 4 14.0 ms
certvert 0:091e1a699d64 1682 * 5 22.4 ms
certvert 0:091e1a699d64 1683 * 6 30.8 ms
certvert 0:091e1a699d64 1684 * 7 39.2 ms
certvert 0:091e1a699d64 1685 *
certvert 0:091e1a699d64 1686 * @param[in] the value for the wait time
certvert 0:091e1a699d64 1687 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1688 */
certvert 0:091e1a699d64 1689 bool glibr::setGestureWaitTime(uint8_t time)
certvert 0:091e1a699d64 1690 {
certvert 0:091e1a699d64 1691 uint8_t val;
certvert 0:091e1a699d64 1692
certvert 0:091e1a699d64 1693 /* Read value from GCONF2 register */
certvert 0:091e1a699d64 1694 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF2);
certvert 0:091e1a699d64 1695 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1696 return false;
certvert 0:091e1a699d64 1697 }
certvert 0:091e1a699d64 1698 /* if( !wireReadDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1699 return false;
certvert 0:091e1a699d64 1700 } */
certvert 0:091e1a699d64 1701
certvert 0:091e1a699d64 1702 /* Set bits in register to given value */
certvert 0:091e1a699d64 1703 time &= 0x07;//0b00000111;
certvert 0:091e1a699d64 1704 val &= 0xF8;//0b11111000;
certvert 0:091e1a699d64 1705 val |= time;
certvert 0:091e1a699d64 1706
certvert 0:091e1a699d64 1707 /* Write register value back into GCONF2 register */
certvert 0:091e1a699d64 1708 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GCONF2,val)){//!wireWriteDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1709 return false;
certvert 0:091e1a699d64 1710 }
certvert 0:091e1a699d64 1711 /*if( !wireWriteDataByte(APDS9960_GCONF2, val) ) {
certvert 0:091e1a699d64 1712 return false;
certvert 0:091e1a699d64 1713 }*/
certvert 0:091e1a699d64 1714 return true;
certvert 0:091e1a699d64 1715 }
certvert 0:091e1a699d64 1716
certvert 0:091e1a699d64 1717 /**
certvert 0:091e1a699d64 1718 * @brief Gets the low threshold for ambient light interrupts
certvert 0:091e1a699d64 1719 *
certvert 0:091e1a699d64 1720 * @param[out] threshold current low threshold stored on the APDS-9960
certvert 0:091e1a699d64 1721 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1722 */
certvert 0:091e1a699d64 1723 bool glibr::getLightIntLowThreshold(uint16_t &threshold)
certvert 0:091e1a699d64 1724 {
certvert 0:091e1a699d64 1725 uint8_t val_byte;
certvert 0:091e1a699d64 1726 threshold = 0;
certvert 0:091e1a699d64 1727
certvert 0:091e1a699d64 1728 /* Read value from ambient light low threshold, low byte register */
certvert 0:091e1a699d64 1729 val_byte = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_AILTL);
certvert 0:091e1a699d64 1730 if( val_byte == ERROR){//!wireReadDataByte(APDS9960_AILTL, val_byte) ) {
certvert 0:091e1a699d64 1731 return false;
certvert 0:091e1a699d64 1732 }
certvert 0:091e1a699d64 1733 threshold = val_byte;
certvert 0:091e1a699d64 1734
certvert 0:091e1a699d64 1735 /* Read value from ambient light low threshold, high byte register */
certvert 0:091e1a699d64 1736 val_byte = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_AILTH);
certvert 0:091e1a699d64 1737 if( val_byte == ERROR){//!wireReadDataByte(APDS9960_AILTH, val_byte) ) {
certvert 0:091e1a699d64 1738 return false;
certvert 0:091e1a699d64 1739 }
certvert 0:091e1a699d64 1740 threshold = threshold + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 1741
certvert 0:091e1a699d64 1742 return true;
certvert 0:091e1a699d64 1743 }
certvert 0:091e1a699d64 1744
certvert 0:091e1a699d64 1745 /**
certvert 0:091e1a699d64 1746 * @brief Sets the low threshold for ambient light interrupts
certvert 0:091e1a699d64 1747 *
certvert 0:091e1a699d64 1748 * @param[in] threshold low threshold value for interrupt to trigger
certvert 0:091e1a699d64 1749 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1750 */
certvert 0:091e1a699d64 1751 bool glibr::setLightIntLowThreshold(uint16_t threshold)
certvert 0:091e1a699d64 1752 {
certvert 0:091e1a699d64 1753 uint8_t val_low;
certvert 0:091e1a699d64 1754 uint8_t val_high;
certvert 0:091e1a699d64 1755
certvert 0:091e1a699d64 1756 /* Break 16-bit threshold into 2 8-bit values */
certvert 0:091e1a699d64 1757 val_low = threshold & 0x00FF;
certvert 0:091e1a699d64 1758 val_high = (threshold & 0xFF00) >> 8;
certvert 0:091e1a699d64 1759
certvert 0:091e1a699d64 1760 /* Write low byte */
certvert 0:091e1a699d64 1761 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_AILTL,val_low)){//!wireWriteDataByte(APDS9960_AILTL, val_low) ) {
certvert 0:091e1a699d64 1762 return false;
certvert 0:091e1a699d64 1763 }
certvert 0:091e1a699d64 1764
certvert 0:091e1a699d64 1765 /* Write high byte */
certvert 0:091e1a699d64 1766 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_AILTH,val_high)){//!wireWriteDataByte(APDS9960_AILTH, val_high) ) {
certvert 0:091e1a699d64 1767 return false;
certvert 0:091e1a699d64 1768 }
certvert 0:091e1a699d64 1769
certvert 0:091e1a699d64 1770 return true;
certvert 0:091e1a699d64 1771 }
certvert 0:091e1a699d64 1772
certvert 0:091e1a699d64 1773 /**
certvert 0:091e1a699d64 1774 * @brief Gets the high threshold for ambient light interrupts
certvert 0:091e1a699d64 1775 *
certvert 0:091e1a699d64 1776 * @param[out] threshold current low threshold stored on the APDS-9960
certvert 0:091e1a699d64 1777 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1778 */
certvert 0:091e1a699d64 1779 bool glibr::getLightIntHighThreshold(uint16_t &threshold)
certvert 0:091e1a699d64 1780 {
certvert 0:091e1a699d64 1781 uint8_t val_byte;
certvert 0:091e1a699d64 1782 threshold = 0;
certvert 0:091e1a699d64 1783
certvert 0:091e1a699d64 1784 /* Read value from ambient light high threshold, low byte register */
certvert 0:091e1a699d64 1785 val_byte = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_AIHTL);
certvert 0:091e1a699d64 1786 if( val_byte == ERROR){//!wireReadDataByte(APDS9960_AIHTL, val_byte) ) {
certvert 0:091e1a699d64 1787 return false;
certvert 0:091e1a699d64 1788 }
certvert 0:091e1a699d64 1789 threshold = val_byte;
certvert 0:091e1a699d64 1790
certvert 0:091e1a699d64 1791 /* Read value from ambient light high threshold, high byte register */
certvert 0:091e1a699d64 1792 val_byte = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_AIHTH);
certvert 0:091e1a699d64 1793 if( val_byte == ERROR){//!wireReadDataByte(APDS9960_AIHTH, val_byte) ) {
certvert 0:091e1a699d64 1794 return false;
certvert 0:091e1a699d64 1795 }
certvert 0:091e1a699d64 1796 threshold = threshold + ((uint16_t)val_byte << 8);
certvert 0:091e1a699d64 1797
certvert 0:091e1a699d64 1798 return true;
certvert 0:091e1a699d64 1799 }
certvert 0:091e1a699d64 1800
certvert 0:091e1a699d64 1801 /**
certvert 0:091e1a699d64 1802 * @brief Sets the high threshold for ambient light interrupts
certvert 0:091e1a699d64 1803 *
certvert 0:091e1a699d64 1804 * @param[in] threshold high threshold value for interrupt to trigger
certvert 0:091e1a699d64 1805 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1806 */
certvert 0:091e1a699d64 1807 bool glibr::setLightIntHighThreshold(uint16_t threshold)
certvert 0:091e1a699d64 1808 {
certvert 0:091e1a699d64 1809 uint8_t val_low;
certvert 0:091e1a699d64 1810 uint8_t val_high;
certvert 0:091e1a699d64 1811
certvert 0:091e1a699d64 1812 /* Break 16-bit threshold into 2 8-bit values */
certvert 0:091e1a699d64 1813 val_low = threshold & 0x00FF;
certvert 0:091e1a699d64 1814 val_high = (threshold & 0xFF00) >> 8;
certvert 0:091e1a699d64 1815
certvert 0:091e1a699d64 1816 /* Write low byte */
certvert 0:091e1a699d64 1817 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_AIHTL,val_low)){//!wireWriteDataByte(APDS9960_AIHTL, val_low) ) {
certvert 0:091e1a699d64 1818 return false;
certvert 0:091e1a699d64 1819 }
certvert 0:091e1a699d64 1820
certvert 0:091e1a699d64 1821 /* Write high byte */
certvert 0:091e1a699d64 1822 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_AIHTH,val_high)){//!wireWriteDataByte(APDS9960_AIHTH, val_high) ) {
certvert 0:091e1a699d64 1823 return false;
certvert 0:091e1a699d64 1824 }
certvert 0:091e1a699d64 1825
certvert 0:091e1a699d64 1826 return true;
certvert 0:091e1a699d64 1827 }
certvert 0:091e1a699d64 1828
certvert 0:091e1a699d64 1829 /**
certvert 0:091e1a699d64 1830 * @brief Gets the low threshold for proximity interrupts
certvert 0:091e1a699d64 1831 *
certvert 0:091e1a699d64 1832 * @param[out] threshold current low threshold stored on the APDS-9960
certvert 0:091e1a699d64 1833 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1834 */
certvert 0:091e1a699d64 1835 bool glibr::getProximityIntLowThreshold(uint8_t &threshold)
certvert 0:091e1a699d64 1836 {
certvert 0:091e1a699d64 1837 threshold = 0;
certvert 0:091e1a699d64 1838
certvert 0:091e1a699d64 1839 /* Read value from proximity low threshold register */
certvert 0:091e1a699d64 1840 threshold = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_PILT);
certvert 0:091e1a699d64 1841 if( threshold == ERROR){//!wireReadDataByte(APDS9960_PILT, threshold) ) {
certvert 0:091e1a699d64 1842 return false;
certvert 0:091e1a699d64 1843 }
certvert 0:091e1a699d64 1844
certvert 0:091e1a699d64 1845 return true;
certvert 0:091e1a699d64 1846 }
certvert 0:091e1a699d64 1847
certvert 0:091e1a699d64 1848 /**
certvert 0:091e1a699d64 1849 * @brief Sets the low threshold for proximity interrupts
certvert 0:091e1a699d64 1850 *
certvert 0:091e1a699d64 1851 * @param[in] threshold low threshold value for interrupt to trigger
certvert 0:091e1a699d64 1852 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1853 */
certvert 0:091e1a699d64 1854 bool glibr::setProximityIntLowThreshold(uint8_t threshold)
certvert 0:091e1a699d64 1855 {
certvert 0:091e1a699d64 1856
certvert 0:091e1a699d64 1857 /* Write threshold value to register */
certvert 0:091e1a699d64 1858 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PILT,threshold)){//!wireWriteDataByte(APDS9960_PILT, threshold) ) {
certvert 0:091e1a699d64 1859 return false;
certvert 0:091e1a699d64 1860 }
certvert 0:091e1a699d64 1861
certvert 0:091e1a699d64 1862 return true;
certvert 0:091e1a699d64 1863 }
certvert 0:091e1a699d64 1864
certvert 0:091e1a699d64 1865 /**
certvert 0:091e1a699d64 1866 * @brief Gets the high threshold for proximity interrupts
certvert 0:091e1a699d64 1867 *
certvert 0:091e1a699d64 1868 * @param[out] threshold current low threshold stored on the APDS-9960
certvert 0:091e1a699d64 1869 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1870 */
certvert 0:091e1a699d64 1871 bool glibr::getProximityIntHighThreshold(uint8_t &threshold)
certvert 0:091e1a699d64 1872 {
certvert 0:091e1a699d64 1873 threshold = 0;
certvert 0:091e1a699d64 1874
certvert 0:091e1a699d64 1875 /* Read value from proximity low threshold register */
certvert 0:091e1a699d64 1876 threshold = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_PIHT);
certvert 0:091e1a699d64 1877 if( threshold == ERROR){//!wireReadDataByte(APDS9960_PIHT, threshold) ) {
certvert 0:091e1a699d64 1878 return false;
certvert 0:091e1a699d64 1879 }
certvert 0:091e1a699d64 1880
certvert 0:091e1a699d64 1881 return true;
certvert 0:091e1a699d64 1882 }
certvert 0:091e1a699d64 1883
certvert 0:091e1a699d64 1884 /**
certvert 0:091e1a699d64 1885 * @brief Sets the high threshold for proximity interrupts
certvert 0:091e1a699d64 1886 *
certvert 0:091e1a699d64 1887 * @param[in] threshold high threshold value for interrupt to trigger
certvert 0:091e1a699d64 1888 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1889 */
certvert 0:091e1a699d64 1890 bool glibr::setProximityIntHighThreshold(uint8_t threshold)
certvert 0:091e1a699d64 1891 {
certvert 0:091e1a699d64 1892
certvert 0:091e1a699d64 1893 /* Write threshold value to register */
certvert 0:091e1a699d64 1894 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_PIHT,threshold)){//!wireWriteDataByte(APDS9960_PIHT, threshold) ) {
certvert 0:091e1a699d64 1895 return false;
certvert 0:091e1a699d64 1896 }
certvert 0:091e1a699d64 1897
certvert 0:091e1a699d64 1898 return true;
certvert 0:091e1a699d64 1899 }
certvert 0:091e1a699d64 1900
certvert 0:091e1a699d64 1901 /**
certvert 0:091e1a699d64 1902 * @brief Gets if ambient light interrupts are enabled or not
certvert 0:091e1a699d64 1903 *
certvert 0:091e1a699d64 1904 * @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
certvert 0:091e1a699d64 1905 */
certvert 0:091e1a699d64 1906 uint8_t glibr::getAmbientLightIntEnable()
certvert 0:091e1a699d64 1907 {
certvert 0:091e1a699d64 1908 uint8_t val;
certvert 0:091e1a699d64 1909
certvert 0:091e1a699d64 1910 /* Read value from ENABLE register */
certvert 0:091e1a699d64 1911 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ENABLE);
certvert 0:091e1a699d64 1912 if( val == ERROR){//!wireReadDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1913 return ERROR;
certvert 0:091e1a699d64 1914 }
certvert 0:091e1a699d64 1915
certvert 0:091e1a699d64 1916 /* Shift and mask out AIEN bit */
certvert 0:091e1a699d64 1917 val = (val >> 4) & 0x01;//0b00000001;
certvert 0:091e1a699d64 1918
certvert 0:091e1a699d64 1919 return val;
certvert 0:091e1a699d64 1920 }
certvert 0:091e1a699d64 1921
certvert 0:091e1a699d64 1922 /**
certvert 0:091e1a699d64 1923 * @brief Turns ambient light interrupts on or off
certvert 0:091e1a699d64 1924 *
certvert 0:091e1a699d64 1925 * @param[in] enable 1 to enable interrupts, 0 to turn them off
certvert 0:091e1a699d64 1926 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1927 */
certvert 0:091e1a699d64 1928 bool glibr::setAmbientLightIntEnable(uint8_t enable)
certvert 0:091e1a699d64 1929 {
certvert 0:091e1a699d64 1930 uint8_t val;
certvert 0:091e1a699d64 1931
certvert 0:091e1a699d64 1932 /* Read value from ENABLE register */
certvert 0:091e1a699d64 1933 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ENABLE);
certvert 0:091e1a699d64 1934 if( val == ERROR){//!wireReadDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1935 return false;
certvert 0:091e1a699d64 1936 }
certvert 0:091e1a699d64 1937
certvert 0:091e1a699d64 1938 /* Set bits in register to given value */
certvert 0:091e1a699d64 1939 enable &= 0x01;//0b00000001;
certvert 0:091e1a699d64 1940 enable = enable << 4;
certvert 0:091e1a699d64 1941 val &= 0xEF;//0b11101111;
certvert 0:091e1a699d64 1942 val |= enable;
certvert 0:091e1a699d64 1943
certvert 0:091e1a699d64 1944 /* Write register value back into ENABLE register */
certvert 0:091e1a699d64 1945 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_ENABLE,val)){//!wireWriteDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1946 return false;
certvert 0:091e1a699d64 1947 }
certvert 0:091e1a699d64 1948
certvert 0:091e1a699d64 1949 return true;
certvert 0:091e1a699d64 1950 }
certvert 0:091e1a699d64 1951
certvert 0:091e1a699d64 1952 /**
certvert 0:091e1a699d64 1953 * @brief Gets if proximity interrupts are enabled or not
certvert 0:091e1a699d64 1954 *
certvert 0:091e1a699d64 1955 * @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
certvert 0:091e1a699d64 1956 */
certvert 0:091e1a699d64 1957 uint8_t glibr::getProximityIntEnable()
certvert 0:091e1a699d64 1958 {
certvert 0:091e1a699d64 1959 uint8_t val;
certvert 0:091e1a699d64 1960
certvert 0:091e1a699d64 1961 /* Read value from ENABLE register */
certvert 0:091e1a699d64 1962 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ENABLE);
certvert 0:091e1a699d64 1963 if( val == ERROR){//!wireReadDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1964 return ERROR;
certvert 0:091e1a699d64 1965 }
certvert 0:091e1a699d64 1966
certvert 0:091e1a699d64 1967 /* Shift and mask out PIEN bit */
certvert 0:091e1a699d64 1968 val = (val >> 5) & 0x01;//0b00000001;
certvert 0:091e1a699d64 1969
certvert 0:091e1a699d64 1970 return val;
certvert 0:091e1a699d64 1971 }
certvert 0:091e1a699d64 1972
certvert 0:091e1a699d64 1973 /**
certvert 0:091e1a699d64 1974 * @brief Turns proximity interrupts on or off
certvert 0:091e1a699d64 1975 *
certvert 0:091e1a699d64 1976 * @param[in] enable 1 to enable interrupts, 0 to turn them off
certvert 0:091e1a699d64 1977 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 1978 */
certvert 0:091e1a699d64 1979 bool glibr::setProximityIntEnable(uint8_t enable)
certvert 0:091e1a699d64 1980 {
certvert 0:091e1a699d64 1981 uint8_t val;
certvert 0:091e1a699d64 1982
certvert 0:091e1a699d64 1983 /* Read value from ENABLE register */
certvert 0:091e1a699d64 1984 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_ENABLE);
certvert 0:091e1a699d64 1985 if( val == ERROR){//!wireReadDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1986 return false;
certvert 0:091e1a699d64 1987 }
certvert 0:091e1a699d64 1988
certvert 0:091e1a699d64 1989 /* Set bits in register to given value */
certvert 0:091e1a699d64 1990 enable &= 0x01;//0b00000001;
certvert 0:091e1a699d64 1991 enable = enable << 5;
certvert 0:091e1a699d64 1992 val &= 0xDF;//0b11011111;
certvert 0:091e1a699d64 1993 val |= enable;
certvert 0:091e1a699d64 1994
certvert 0:091e1a699d64 1995 /* Write register value back into ENABLE register */
certvert 0:091e1a699d64 1996 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_ENABLE,val)){//!wireWriteDataByte(APDS9960_ENABLE, val) ) {
certvert 0:091e1a699d64 1997 return false;
certvert 0:091e1a699d64 1998 }
certvert 0:091e1a699d64 1999
certvert 0:091e1a699d64 2000 return true;
certvert 0:091e1a699d64 2001 }
certvert 0:091e1a699d64 2002
certvert 0:091e1a699d64 2003 /**
certvert 0:091e1a699d64 2004 * @brief Gets if gesture interrupts are enabled or not
certvert 0:091e1a699d64 2005 *
certvert 0:091e1a699d64 2006 * @return 1 if interrupts are enabled, 0 if not. 0xFF on error.
certvert 0:091e1a699d64 2007 */
certvert 0:091e1a699d64 2008 uint8_t glibr::getGestureIntEnable()
certvert 0:091e1a699d64 2009 {
certvert 0:091e1a699d64 2010 uint8_t val;
certvert 0:091e1a699d64 2011
certvert 0:091e1a699d64 2012 /* Read value from GCONF4 register */
certvert 0:091e1a699d64 2013 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF4);
certvert 0:091e1a699d64 2014 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2015 return ERROR;
certvert 0:091e1a699d64 2016 }
certvert 0:091e1a699d64 2017
certvert 0:091e1a699d64 2018 /* Shift and mask out GIEN bit */
certvert 0:091e1a699d64 2019 val = (val >> 1) & 0x01;//0b00000001;
certvert 0:091e1a699d64 2020
certvert 0:091e1a699d64 2021 return val;
certvert 0:091e1a699d64 2022 }
certvert 0:091e1a699d64 2023
certvert 0:091e1a699d64 2024 /**
certvert 0:091e1a699d64 2025 * @brief Turns gesture-related interrupts on or off
certvert 0:091e1a699d64 2026 *
certvert 0:091e1a699d64 2027 * @param[in] enable 1 to enable interrupts, 0 to turn them off
certvert 0:091e1a699d64 2028 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 2029 */
certvert 0:091e1a699d64 2030 bool glibr::setGestureIntEnable(uint8_t enable)
certvert 0:091e1a699d64 2031 {
certvert 0:091e1a699d64 2032 uint8_t val;
certvert 0:091e1a699d64 2033
certvert 0:091e1a699d64 2034 /* Read value from GCONF4 register */
certvert 0:091e1a699d64 2035 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF4);
certvert 0:091e1a699d64 2036 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2037 return false;
certvert 0:091e1a699d64 2038 }
certvert 0:091e1a699d64 2039
certvert 0:091e1a699d64 2040 /* Set bits in register to given value */
certvert 0:091e1a699d64 2041 enable &= 0x01;//0b00000001;
certvert 0:091e1a699d64 2042 enable = enable << 1;
certvert 0:091e1a699d64 2043 val &= 0xFD;//0b11111101;
certvert 0:091e1a699d64 2044 val |= enable;
certvert 0:091e1a699d64 2045
certvert 0:091e1a699d64 2046 /* Write register value back into GCONF4 register */
certvert 0:091e1a699d64 2047 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GCONF4,val)){//!wireWriteDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2048 return false;
certvert 0:091e1a699d64 2049 }
certvert 0:091e1a699d64 2050
certvert 0:091e1a699d64 2051 return true;
certvert 0:091e1a699d64 2052 }
certvert 0:091e1a699d64 2053
certvert 0:091e1a699d64 2054 /**
certvert 0:091e1a699d64 2055 * @brief Clears the ambient light interrupt
certvert 0:091e1a699d64 2056 *
certvert 0:091e1a699d64 2057 * @return True if operation completed successfully. False otherwise.
certvert 0:091e1a699d64 2058 */
certvert 0:091e1a699d64 2059 bool glibr::clearAmbientLightInt()
certvert 0:091e1a699d64 2060 {
certvert 0:091e1a699d64 2061 uint8_t throwaway;
certvert 0:091e1a699d64 2062 throwaway = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_AICLEAR);
certvert 0:091e1a699d64 2063 if( throwaway == ERROR){//!wireReadDataByte(APDS9960_AICLEAR, throwaway) ) {
certvert 0:091e1a699d64 2064 return false;
certvert 0:091e1a699d64 2065 }
certvert 0:091e1a699d64 2066
certvert 0:091e1a699d64 2067 return true;
certvert 0:091e1a699d64 2068 }
certvert 0:091e1a699d64 2069
certvert 0:091e1a699d64 2070 /**
certvert 0:091e1a699d64 2071 * @brief Clears the proximity interrupt
certvert 0:091e1a699d64 2072 *
certvert 0:091e1a699d64 2073 * @return True if operation completed successfully. False otherwise.
certvert 0:091e1a699d64 2074 */
certvert 0:091e1a699d64 2075 bool glibr::clearProximityInt()
certvert 0:091e1a699d64 2076 {
certvert 0:091e1a699d64 2077 uint8_t throwaway;
certvert 0:091e1a699d64 2078 throwaway = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_PICLEAR);
certvert 0:091e1a699d64 2079 if( throwaway == ERROR){//!wireReadDataByte(APDS9960_PICLEAR, throwaway) ) {
certvert 0:091e1a699d64 2080 return false;
certvert 0:091e1a699d64 2081 }
certvert 0:091e1a699d64 2082
certvert 0:091e1a699d64 2083 return true;
certvert 0:091e1a699d64 2084 }
certvert 0:091e1a699d64 2085
certvert 0:091e1a699d64 2086 /**
certvert 0:091e1a699d64 2087 * @brief Tells if the gesture state machine is currently running
certvert 0:091e1a699d64 2088 *
certvert 0:091e1a699d64 2089 * @return 1 if gesture state machine is running, 0 if not. 0xFF on error.
certvert 0:091e1a699d64 2090 */
certvert 0:091e1a699d64 2091 uint8_t glibr::getGestureMode()
certvert 0:091e1a699d64 2092 {
certvert 0:091e1a699d64 2093 uint8_t val;
certvert 0:091e1a699d64 2094
certvert 0:091e1a699d64 2095 /* Read value from GCONF4 register */
certvert 0:091e1a699d64 2096 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF4);
certvert 0:091e1a699d64 2097 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2098 return ERROR;
certvert 0:091e1a699d64 2099 }
certvert 0:091e1a699d64 2100
certvert 0:091e1a699d64 2101 /* Mask out GMODE bit */
certvert 0:091e1a699d64 2102 val &= 0x01;//0b00000001;
certvert 0:091e1a699d64 2103
certvert 0:091e1a699d64 2104 return val;
certvert 0:091e1a699d64 2105 }
certvert 0:091e1a699d64 2106
certvert 0:091e1a699d64 2107 /**
certvert 0:091e1a699d64 2108 * @brief Tells the state machine to either enter or exit gesture state machine
certvert 0:091e1a699d64 2109 *
certvert 0:091e1a699d64 2110 * @param[in] mode 1 to enter gesture state machine, 0 to exit.
certvert 0:091e1a699d64 2111 * @return True if operation successful. False otherwise.
certvert 0:091e1a699d64 2112 */
certvert 0:091e1a699d64 2113 bool glibr::setGestureMode(uint8_t mode)
certvert 0:091e1a699d64 2114 {
certvert 0:091e1a699d64 2115 uint8_t val;
certvert 0:091e1a699d64 2116
certvert 0:091e1a699d64 2117 /* Read value from GCONF4 register */
certvert 0:091e1a699d64 2118 val = I2CreadByte(APDS9960_I2C_ADDR, APDS9960_GCONF4);
certvert 0:091e1a699d64 2119 if( val == ERROR){//!wireReadDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2120 return false;
certvert 0:091e1a699d64 2121 }
certvert 0:091e1a699d64 2122
certvert 0:091e1a699d64 2123 /* Set bits in register to given value */
certvert 0:091e1a699d64 2124 mode &= 0x01;//0b00000001;
certvert 0:091e1a699d64 2125 val &= 0xFE;//0b11111110;
certvert 0:091e1a699d64 2126 val |= mode;
certvert 0:091e1a699d64 2127
certvert 0:091e1a699d64 2128 /* Write register value back into GCONF4 register */
certvert 0:091e1a699d64 2129 if( I2CwriteByte(APDS9960_I2C_ADDR,APDS9960_GCONF4,val)){//!wireWriteDataByte(APDS9960_GCONF4, val) ) {
certvert 0:091e1a699d64 2130 return false;
certvert 0:091e1a699d64 2131 }
certvert 0:091e1a699d64 2132
certvert 0:091e1a699d64 2133 return true;
certvert 0:091e1a699d64 2134 }
certvert 0:091e1a699d64 2135
certvert 0:091e1a699d64 2136
certvert 0:091e1a699d64 2137
certvert 0:091e1a699d64 2138
certvert 0:091e1a699d64 2139
certvert 0:091e1a699d64 2140 int glibr::I2CwriteByte(char address, char subAddress, char data)
certvert 0:091e1a699d64 2141 {
certvert 0:091e1a699d64 2142 int ret;
certvert 0:091e1a699d64 2143 char cmd[2] = {subAddress, data};
certvert 0:091e1a699d64 2144 ret=i2c.write(address<<1, cmd, 2); //if ret is 1, then not acked.
certvert 0:091e1a699d64 2145
certvert 0:091e1a699d64 2146 if (ret != 1)
certvert 0:091e1a699d64 2147 pc.printf("Error occured!!.\r\n");
certvert 0:091e1a699d64 2148 return ret;
certvert 0:091e1a699d64 2149 }
certvert 0:091e1a699d64 2150
certvert 0:091e1a699d64 2151
certvert 0:091e1a699d64 2152
certvert 0:091e1a699d64 2153 uint8_t glibr::I2CreadByte(char address, char subAddress)
certvert 0:091e1a699d64 2154 {
certvert 0:091e1a699d64 2155 char data; // store the register data
certvert 0:091e1a699d64 2156
certvert 0:091e1a699d64 2157 if(i2c.write(address<<1, &subAddress, 1, true)){
certvert 0:091e1a699d64 2158 return ERROR; //7 bit //not acked
certvert 0:091e1a699d64 2159 }
certvert 0:091e1a699d64 2160
certvert 0:091e1a699d64 2161 if(i2c.read(address<<1, &data, 1)){
certvert 0:091e1a699d64 2162 return ERROR;
certvert 0:091e1a699d64 2163 }
certvert 0:091e1a699d64 2164 //i2c.read(address<<1, &data, 1);
certvert 0:091e1a699d64 2165 return data;
certvert 0:091e1a699d64 2166
certvert 0:091e1a699d64 2167 }
certvert 0:091e1a699d64 2168
certvert 0:091e1a699d64 2169
certvert 0:091e1a699d64 2170 // * @brief Reads a block (array) of bytes from the I2C device and register
certvert 0:091e1a699d64 2171 // *
certvert 0:091e1a699d64 2172 // * @param[in] reg the register to read from
certvert 0:091e1a699d64 2173 // * @param[out] val pointer to the beginning of the data
certvert 0:091e1a699d64 2174 // * @param[in] len number of bytes to read
certvert 0:091e1a699d64 2175 // * @return Number of bytes read. -1 on read error.
certvert 0:091e1a699d64 2176 // */
certvert 0:091e1a699d64 2177 int glibr::I2CReadDataBlock(char address, char subAddress, char *data, unsigned int len)
certvert 0:091e1a699d64 2178 {
certvert 0:091e1a699d64 2179 // unsigned char i = 0;
certvert 0:091e1a699d64 2180
certvert 0:091e1a699d64 2181 /* Indicate which register we want to read from */
certvert 0:091e1a699d64 2182
certvert 0:091e1a699d64 2183 if(i2c.write(address<<1, &subAddress, 1, true)){
certvert 0:091e1a699d64 2184 return -1; //7 bit //not acked
certvert 0:091e1a699d64 2185 }
certvert 0:091e1a699d64 2186
certvert 0:091e1a699d64 2187 /* Read block data */
certvert 0:091e1a699d64 2188
certvert 0:091e1a699d64 2189 if(i2c.read(address<<1, data, len)){
certvert 0:091e1a699d64 2190 return -1;
certvert 0:091e1a699d64 2191 }
certvert 0:091e1a699d64 2192
certvert 0:091e1a699d64 2193 return 1;
certvert 0:091e1a699d64 2194 //Wire.requestFrom(APDS9960_I2C_ADDR, len);
certvert 0:091e1a699d64 2195 /*while (Wire.available()) {
certvert 0:091e1a699d64 2196 if (i >= len) {
certvert 0:091e1a699d64 2197 return -1;
certvert 0:091e1a699d64 2198 }
certvert 0:091e1a699d64 2199 val[i] = Wire.read();
certvert 0:091e1a699d64 2200 i++;
certvert 0:091e1a699d64 2201 }*/
certvert 0:091e1a699d64 2202 }