Elliot Heisenberg / APDS_9960

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.

Dependents:   MoveYourTetris

Fork of APDS_9960 by Krishan Bhagat

glibr.cpp@4:8cfe25a48918, 2016-04-24 (annotated)

Committer:
Willheisen
Date:
Sun Apr 24 21:35:31 2016 +0000
Revision:
4:8cfe25a48918
zq

Who changed what in which revision?

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